mirrors/php-src
0
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-12-04 23:34:25 +08:00
Code Issues Packages Projects Releases Wiki Activity
20be664666
php-src/ext/pdo/pdo_dbh.c

1001 lines
26 KiB
C
Raw Normal View History

Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
/*
+----------------------------------------------------------------------+
| PHP Version 5 |
+----------------------------------------------------------------------+
API support for scrollable cursors
2005-01-12 12:49:12 +08:00
| Copyright (c) 1997-2005 The PHP Group |
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
+----------------------------------------------------------------------+
| This source file is subject to version 3.0 of the PHP license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.php.net/license/3_0.txt. |
| If you did not receive a copy of the PHP license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@php.net so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
| Author: Wez Furlong <wez@php.net> |
| Marcus Boerger <helly@php.net> |
| Sterling Hughes <sterling@php.net> |
+----------------------------------------------------------------------+
*/
/* $Id$ */
/* The PDO Database Handle Class */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "php_ini.h"
#include "ext/standard/info.h"
#include "php_pdo.h"
#include "php_pdo_driver.h"
#include "php_pdo_int.h"
#include "zend_exceptions.h"
allow pdo to be functionally inherited from.
2004-07-26 15:42:46 +08:00
#include "zend_object_handlers.h"
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
#include "zend_hash.h"
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
void pdo_handle_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt TSRMLS_DC)
{
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
pdo_error_type *pdo_err = &dbh->error_code;
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
const char *msg = "<<Unknown>>";
char *supp = NULL;
long native_code = 0;
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
char *message = NULL;
zval *info = NULL;
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
if (dbh->error_mode == PDO_ERRMODE_SILENT) {
return;
}
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
if (stmt) {
pdo_err = &stmt->error_code;
}
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
/* hash sqlstate to error messages */
msg = pdo_sqlstate_state_to_description(*pdo_err);
if (!msg) {
msg = "<<Unknown error>>";
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
}
if (dbh->methods->fetch_err) {
MAKE_STD_ZVAL(info);
array_init(info);
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
add_next_index_string(info, *pdo_err, 1);
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
if (dbh->methods->fetch_err(dbh, stmt, info TSRMLS_CC)) {
zval **item;
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(info), 1, (void**)&item)) {
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
native_code = Z_LVAL_PP(item);
}
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(info), 2, (void**)&item)) {
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
supp = estrndup(Z_STRVAL_PP(item), Z_STRLEN_PP(item));
}
}
}
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
if (supp) {
spprintf(&message, 0, "SQLSTATE[%s]: %s: %ld %s", *pdo_err, msg, native_code, supp);
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
} else {
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
spprintf(&message, 0, "SQLSTATE[%s]: %s", *pdo_err, msg);
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
}
if (dbh->error_mode == PDO_ERRMODE_WARNING) {
Fixed compiler warning.
2004-05-21 22:27:48 +08:00
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message);
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
if (info) {
Don't use alloca() where it can reached by the users.
2004-07-06 05:16:29 +08:00
zval_ptr_dtor(&info);
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
}
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
} else {
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
zval *ex;
zend_class_entry *def_ex = zend_exception_get_default(), *pdo_ex = php_pdo_get_exception();
MAKE_STD_ZVAL(ex);
object_init_ex(ex, pdo_ex);
zend_update_property_string(def_ex, ex, "message", sizeof("message")-1, message TSRMLS_CC);
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_update_property_string(def_ex, ex, "code", sizeof("code")-1, *pdo_err TSRMLS_CC);
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
if (info) {
zend_update_property(pdo_ex, ex, "errorInfo", sizeof("errorInfo")-1, info TSRMLS_CC);
}
zend_throw_exception_object(ex TSRMLS_CC);
}
if (message) {
efree(message);
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
}
if (supp) {
efree(supp);
}
}
un-bogusify uri: stuff...
2004-09-20 02:11:27 +08:00
static char *dsn_from_uri(char *uri, char *buf, size_t buflen TSRMLS_DC)
Add "no permission" error code. Add a uri: psuedo driver; it specifies the name of a resource that contains, as its first line, the actual data source to connect to. The resource can be a local file, or it can be any resource for which PHP has a wrapper. // loads connection data from the file "myapp" $d = new PDO('uri:myapp'); // lets say that public.db.com has a read-only db open for the public // their connection data is also published via the web: // (not so great to resolve this on each request though...) $d = new PDO('uri:http://public.db.com/pdo-connection-data');
2004-09-20 00:58:13 +08:00
{
php_stream *stream;
char *dsn = NULL;
stream = php_stream_open_wrapper(uri, "rb", ENFORCE_SAFE_MODE|REPORT_ERRORS, NULL);
if (stream) {
un-bogusify uri: stuff...
2004-09-20 02:11:27 +08:00
dsn = php_stream_get_line(stream, buf, buflen, NULL);
Add "no permission" error code. Add a uri: psuedo driver; it specifies the name of a resource that contains, as its first line, the actual data source to connect to. The resource can be a local file, or it can be any resource for which PHP has a wrapper. // loads connection data from the file "myapp" $d = new PDO('uri:myapp'); // lets say that public.db.com has a read-only db open for the public // their connection data is also published via the web: // (not so great to resolve this on each request though...) $d = new PDO('uri:http://public.db.com/pdo-connection-data');
2004-09-20 00:58:13 +08:00
php_stream_close(stream);
}
return dsn;
}
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
/* {{{ proto object PDO::__construct(string dsn, string username, string passwd [, array driver_opts])
*/
static PHP_FUNCTION(dbh_constructor)
{
zval *object = getThis();
pdo_dbh_t *dbh = NULL;
zend_bool is_persistent = FALSE;
char *data_source;
Fixed some int-long issues
2004-06-23 21:20:54 +08:00
int data_source_len;
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
char *colon;
Make username & password parameters optional.
2004-05-21 04:25:22 +08:00
char *username=NULL, *password=NULL;
Fixed some int-long issues
2004-06-23 21:20:54 +08:00
int usernamelen, passwordlen;
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
pdo_driver_t *driver = NULL;
zval *driver_options = NULL;
un-bogusify uri: stuff...
2004-09-20 02:11:27 +08:00
char alt_dsn[512];
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
Make username & password parameters optional.
2004-05-21 04:25:22 +08:00
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ssa!", &data_source, &data_source_len,
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
&username, &usernamelen, &password, &passwordlen, &driver_options)) {
ZVAL_NULL(object);
return;
}
/* parse the data source name */
colon = strchr(data_source, ':');
if (!colon) {
Add support for: $d = new PDO('foobar'); // name has no : character This will indirect via the entry "pdo.dsn.foobar" from the php.ini file, so if you have: pdo.dsn.foobar=sqlite::memory: the above is equivalent to this: $d = new PDO('sqlite::memory:'); which creates an in-memory sqlite db.
2004-09-20 03:28:02 +08:00
/* let's see if this string has a matching dsn in the php.ini */
char *ini_dsn = NULL;
snprintf(alt_dsn, sizeof(alt_dsn), "pdo.dsn.%s", data_source);
if (FAILURE == cfg_get_string(alt_dsn, &ini_dsn)) {
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source name");
Add support for: $d = new PDO('foobar'); // name has no : character This will indirect via the entry "pdo.dsn.foobar" from the php.ini file, so if you have: pdo.dsn.foobar=sqlite::memory: the above is equivalent to this: $d = new PDO('sqlite::memory:'); which creates an in-memory sqlite db.
2004-09-20 03:28:02 +08:00
ZVAL_NULL(object);
return;
}
data_source = ini_dsn;
colon = strchr(data_source, ':');
if (!colon) {
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source name (via INI: %s)", alt_dsn);
Add support for: $d = new PDO('foobar'); // name has no : character This will indirect via the entry "pdo.dsn.foobar" from the php.ini file, so if you have: pdo.dsn.foobar=sqlite::memory: the above is equivalent to this: $d = new PDO('sqlite::memory:'); which creates an in-memory sqlite db.
2004-09-20 03:28:02 +08:00
ZVAL_NULL(object);
return;
}
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
}
Add "no permission" error code. Add a uri: psuedo driver; it specifies the name of a resource that contains, as its first line, the actual data source to connect to. The resource can be a local file, or it can be any resource for which PHP has a wrapper. // loads connection data from the file "myapp" $d = new PDO('uri:myapp'); // lets say that public.db.com has a read-only db open for the public // their connection data is also published via the web: // (not so great to resolve this on each request though...) $d = new PDO('uri:http://public.db.com/pdo-connection-data');
2004-09-20 00:58:13 +08:00
if (!strncmp(data_source, "uri:", sizeof("uri:")-1)) {
/* the specified URI holds connection details */
un-bogusify uri: stuff...
2004-09-20 02:11:27 +08:00
data_source = dsn_from_uri(data_source, alt_dsn, sizeof(alt_dsn) TSRMLS_CC);
Add "no permission" error code. Add a uri: psuedo driver; it specifies the name of a resource that contains, as its first line, the actual data source to connect to. The resource can be a local file, or it can be any resource for which PHP has a wrapper. // loads connection data from the file "myapp" $d = new PDO('uri:myapp'); // lets say that public.db.com has a read-only db open for the public // their connection data is also published via the web: // (not so great to resolve this on each request though...) $d = new PDO('uri:http://public.db.com/pdo-connection-data');
2004-09-20 00:58:13 +08:00
if (!data_source) {
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source URI");
Add "no permission" error code. Add a uri: psuedo driver; it specifies the name of a resource that contains, as its first line, the actual data source to connect to. The resource can be a local file, or it can be any resource for which PHP has a wrapper. // loads connection data from the file "myapp" $d = new PDO('uri:myapp'); // lets say that public.db.com has a read-only db open for the public // their connection data is also published via the web: // (not so great to resolve this on each request though...) $d = new PDO('uri:http://public.db.com/pdo-connection-data');
2004-09-20 00:58:13 +08:00
ZVAL_NULL(object);
return;
un-bogusify uri: stuff...
2004-09-20 02:11:27 +08:00
}
colon = strchr(data_source, ':');
if (!colon) {
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source name (via URI)");
un-bogusify uri: stuff...
2004-09-20 02:11:27 +08:00
ZVAL_NULL(object);
return;
Add "no permission" error code. Add a uri: psuedo driver; it specifies the name of a resource that contains, as its first line, the actual data source to connect to. The resource can be a local file, or it can be any resource for which PHP has a wrapper. // loads connection data from the file "myapp" $d = new PDO('uri:myapp'); // lets say that public.db.com has a read-only db open for the public // their connection data is also published via the web: // (not so great to resolve this on each request though...) $d = new PDO('uri:http://public.db.com/pdo-connection-data');
2004-09-20 00:58:13 +08:00
}
}
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
driver = pdo_find_driver(data_source, colon - data_source);
if (!driver) {
/* NB: don't want to include the data_source in the error message as
* it might contain a password */
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "could not find driver");
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
ZVAL_NULL(object);
return;
}
fix for inheritability
2004-06-24 02:06:00 +08:00
dbh = (pdo_dbh_t *) zend_object_store_get_object(object TSRMLS_CC);
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
/* is this supposed to be a persistent connection ? */
if (driver_options) {
zval **v;
int plen;
char *hashkey = NULL;
list_entry *le;
pdo_dbh_t *pdbh = NULL;
if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(driver_options), PDO_ATTR_PERSISTENT, (void**)&v)) {
if (Z_TYPE_PP(v) == IS_STRING) {
/* user specified key */
plen = spprintf(&hashkey, 0, "PDO:DBH:DSN=%s:%s:%s:%s", data_source,
username ? username : "",
password ? password : "",
Z_STRVAL_PP(v));
is_persistent = 1;
} else {
convert_to_long_ex(v);
is_persistent = Z_LVAL_PP(v) ? 1 : 0;
plen = spprintf(&hashkey, 0, "PDO:DBH:DSN=%s:%s:%s", data_source,
username ? username : "",
password ? password : "");
}
}
/* let's see if we have one cached.... */
if (is_persistent && SUCCESS == zend_hash_find(&EG(persistent_list), hashkey, plen+1, (void*)&le)) {
if (Z_TYPE_P(le) == php_pdo_list_entry()) {
pdbh = (pdo_dbh_t*)le->ptr;
/* is the connection still alive ? */
if (pdbh->methods->check_liveness && FAILURE == (pdbh->methods->check_liveness)(pdbh TSRMLS_CC)) {
/* nope... need to kill it */
pdbh = NULL;
}
}
}
if (is_persistent && !pdbh) {
/* need a brand new pdbh */
pdbh = pecalloc(1, sizeof(*pdbh), 1);
if (!pdbh) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "out of memory while allocating PDO handle");
/* NOTREACHED */
}
pdbh->is_persistent = 1;
pdbh->persistent_id = pemalloc(plen + 1, 1);
memcpy((char *)pdbh->persistent_id, hashkey, plen+1);
pdbh->persistent_id_len = plen+1;
pdbh->refcount = 1;
}
if (pdbh) {
/* let's copy the emalloc bits over from the other handle */
pdbh->ce = dbh->ce;
pdbh->properties = dbh->properties;
/* kill the non-persistent thingamy */
efree(dbh);
/* switch over to the persistent one */
dbh = pdbh;
zend_object_store_set_object(object, dbh TSRMLS_CC);
dbh->refcount++;
}
if (hashkey) {
efree(hashkey);
}
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
}
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
dbh->data_source_len = strlen(colon + 1);
dbh->data_source = (const char*)pestrdup(colon + 1, is_persistent);
Make username & password parameters optional.
2004-05-21 04:25:22 +08:00
dbh->username = username ? pestrdup(username, is_persistent) : NULL;
dbh->password = password ? pestrdup(password, is_persistent) : NULL;
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
Some definitions for cursors. Define a mechanism for driver-specific attributes. Use a refcount for the stmt structure.
2004-05-26 01:43:24 +08:00
dbh->auto_commit = pdo_attr_lval(driver_options, PDO_ATTR_AUTOCOMMIT, 1 TSRMLS_CC);
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
Add rough cut at fetching meta data.
2004-09-27 04:45:44 +08:00
if (!dbh->data_source || (username && !dbh->username) || (password && !dbh->password)) {
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
php_error_docref(NULL TSRMLS_CC, E_ERROR, "out of memory");
}
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
if (driver->db_handle_factory(dbh, driver_options TSRMLS_CC)) {
/* all set */
if (is_persistent) {
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
list_entry le;
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
/* register in the persistent list etc. */
fix for inheritability
2004-06-24 02:06:00 +08:00
/* we should also need to replace the object store entry,
since it was created with emalloc */
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
le.type = php_pdo_list_entry();
le.ptr = dbh;
if (FAILURE == zend_hash_update(&EG(persistent_list),
(char*)dbh->persistent_id, dbh->persistent_id_len, (void*)&le,
sizeof(le), NULL)) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to register persistent entry");
}
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
}
return;
}
fix for inheritability
2004-06-24 02:06:00 +08:00
/* the connection failed; things will tidy up in free_storage */
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
/* XXX raise exception */
ZVAL_NULL(object);
}
/* }}} */
Expand the prepare() prototype to accept additional options.
2004-05-19 20:37:31 +08:00
/* {{{ proto object PDO::prepare(string statment [, int options [, array driver_options]])
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
Prepares a statement for execution and returns a statement object */
Expand the prepare() prototype to accept additional options.
2004-05-19 20:37:31 +08:00
/* TODO: options will be a PDO specific bitmask controlling such things as
* cursor type. */
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
static PHP_METHOD(PDO, prepare)
{
pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
pdo_stmt_t *stmt;
char *statement;
Fixed some int-long issues
2004-06-23 21:20:54 +08:00
int statement_len;
Expand the prepare() prototype to accept additional options.
2004-05-19 20:37:31 +08:00
zval *driver_options = NULL;
long options = 0;
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
Expand the prepare() prototype to accept additional options.
2004-05-19 20:37:31 +08:00
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|la", &statement,
&statement_len, &options, &driver_options)) {
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
RETURN_FALSE;
}
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
PDO_DBH_CLEAR_ERR();
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
stmt = ecalloc(1, sizeof(*stmt));
Expand the prepare() prototype to accept additional options.
2004-05-19 20:37:31 +08:00
/* unconditionally keep this for later reference */
handle binding/quoting of queries for drivers with emulated prepares
2004-05-18 23:19:31 +08:00
stmt->query_string = estrndup(statement, statement_len);
stmt->query_stringlen = statement_len;
Synopsis: PDOStatement::setFetchMode() reset default fetch() mode for a statement to PDO_FETCH_BOTH PDOStatement::setFetchMode(PDO_FETCH_NUM) PDOStatement::setFetchMode(PDO_FETCH_ASSOC) PDOStatement::setFetchMode(PDO_FETCH_BOTH) PDOStatement::setFetchMode(PDO_FETCH_OBJ) set default fetch() mode for a statement. PDOStatement::setFetchMode(PDO_FETCH_COLUMN, int colno) set default fetch() mode to retrieve colno-th column on each fetch() call. PDOStatement::setFetchMode(PDO_FETCH_CLASS, string classname [, array ctor args]) set default fetch() mode to create an instance of classname, calling it's ctor, passing the optional ctor args. The names of the columns in the result set will be used as property names on the object instance. PPP rules apply. [NOTE: calling ctor is not yet implemented] [TODO: this might crash PHP for persistent PDO handles] PDOStatement::setFetchMode(PDO_FETCH_INTO, object obj) Similar to PDO_FETCH_CLASS, except that each iteration will update the supplied object properties. [TODO: this might crash PHP for persistent PDO handles] The default fetch() mode is used when no parameters are passed to PDOStatement::fetch(). When using a statement in an iterator context, PDOStatement::fetch() is called implicitly on each iteration. object PDO::queryAndIterate(string sql, <PDOStatement::setFetchMode args>) This is semantically equivalent to: $stmt = $pdo->prepare($sql); $stmt->execute(); $stmt->setFetchMode($args); return $stmt; Example/Intended usage: /* fetch an array with numeric and string keys */ foreach ($pdo->queryAndIterate("select NAME, VALUE from test") as $row) { debug_zval_dump($row); } /* fetch the value of column 1 into $row on each iteration */ foreach ($pdo->queryAndIterate("select NAME, VALUE from test", PDO_FETCH_COLUMN, 1) as $row) { debug_zval_dump($row); // string(3) "foo" } /* create a new instance of class Foo on each iteration */ foreach ($pdo->queryAndIterate("select NAME, VALUE from test", PDO_FETCH_CLASS, 'Foo') as $row) { debug_zval_dump($row); /* Object(Foo)#4 (2) refcount(2){ ["NAME"]=> string(12) "foo220051429" refcount(2) ["VALUE"]=> string(12) "bar789825748" refcount(2) } */ } etc.
2004-10-27 18:26:27 +08:00
stmt->default_fetch_type = PDO_FETCH_BOTH;
Expand the prepare() prototype to accept additional options.
2004-05-19 20:37:31 +08:00
if (dbh->methods->preparer(dbh, statement, statement_len, stmt, options, driver_options TSRMLS_CC)) {
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
/* prepared; create a statement object for PHP land to access it */
Z_TYPE_P(return_value) = IS_OBJECT;
Z_OBJ_HANDLE_P(return_value) = zend_objects_store_put(stmt, NULL, pdo_dbstmt_free_storage, NULL TSRMLS_CC);
Z_OBJ_HT_P(return_value) = &pdo_dbstmt_object_handlers;
/* give it a reference to me */
stmt->database_object_handle = *getThis();
zend_objects_store_add_ref(getThis() TSRMLS_CC);
stmt->dbh = dbh;
Version 1 of PDO_FETCH_LAZY
2004-05-21 21:26:58 +08:00
/* we haven't created a lazy object yet */
ZVAL_NULL(&stmt->lazy_object_ref);
Some definitions for cursors. Define a mechanism for driver-specific attributes. Use a refcount for the stmt structure.
2004-05-26 01:43:24 +08:00
stmt->refcount = 1;
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
return;
}
efree(stmt);
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
PDO_HANDLE_DBH_ERR();
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
RETURN_FALSE;
}
fix for inheritability
2004-06-24 02:06:00 +08:00
/* }}} */
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
Add $dbh->exec() method. Rename $dbh->beginWork() to $dbh->beginTransaction().
2004-05-19 21:43:07 +08:00
/* {{{ proto bool PDO::beginTransaction()
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
Initiates a transaction */
Add $dbh->exec() method. Rename $dbh->beginWork() to $dbh->beginTransaction().
2004-05-19 21:43:07 +08:00
static PHP_METHOD(PDO, beginTransaction)
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
{
pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
if (dbh->in_txn) {
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "There is already an active transaction");
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
RETURN_FALSE;
}
if (!dbh->methods->begin) {
Expand the prepare() prototype to accept additional options.
2004-05-19 20:37:31 +08:00
/* TODO: this should be an exception; see the auto-commit mode
* comments below */
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "This driver doesn't support transactions");
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
RETURN_FALSE;
}
if (dbh->methods->begin(dbh TSRMLS_CC)) {
dbh->in_txn = 1;
RETURN_TRUE;
}
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
PDO_HANDLE_DBH_ERR();
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
RETURN_FALSE;
}
/* }}} */
/* {{{ proto bool PDO::commit()
Commit a transaction */
static PHP_METHOD(PDO, commit)
{
pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
if (!dbh->in_txn) {
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "There is no active transaction");
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
RETURN_FALSE;
}
if (dbh->methods->commit(dbh TSRMLS_CC)) {
dbh->in_txn = 0;
RETURN_TRUE;
}
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
PDO_HANDLE_DBH_ERR();
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
RETURN_FALSE;
}
/* }}} */
/* {{{ proto bool PDO::rollBack()
roll back a transaction */
static PHP_METHOD(PDO, rollBack)
{
pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
if (!dbh->in_txn) {
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "There is no active transaction");
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
RETURN_FALSE;
}
if (dbh->methods->rollback(dbh TSRMLS_CC)) {
dbh->in_txn = 0;
RETURN_TRUE;
}
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
PDO_HANDLE_DBH_ERR();
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
RETURN_FALSE;
}
/* }}} */
/* {{{ proto bool PDO::setAttribute(long attribute, mixed value)
Set an attribute */
static PHP_METHOD(PDO, setAttribute)
{
pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
long attr;
zval *value = NULL;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lz!", &attr, &value)) {
RETURN_FALSE;
}
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
switch (attr) {
case PDO_ATTR_ERRMODE:
convert_to_long(value);
switch (Z_LVAL_P(value)) {
case PDO_ERRMODE_SILENT:
case PDO_ERRMODE_WARNING:
case PDO_ERRMODE_EXCEPTION:
dbh->error_mode = Z_LVAL_P(value);
RETURN_TRUE;
default:
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "Error mode %d is invalid", Z_LVAL_P(value));
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
}
RETURN_FALSE;
Implement case folding of column names as a portability option.
2004-05-21 06:28:53 +08:00
case PDO_ATTR_CASE:
convert_to_long(value);
switch (Z_LVAL_P(value)) {
case PDO_CASE_NATURAL:
case PDO_CASE_UPPER:
case PDO_CASE_LOWER:
dbh->desired_case = Z_LVAL_P(value);
RETURN_TRUE;
default:
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "Case folding mode %d is invalid", Z_LVAL_P(value));
Implement case folding of column names as a portability option.
2004-05-21 06:28:53 +08:00
}
RETURN_FALSE;
Implement empty-string-to-null conversion option for oracle compat. This can be enabled using: $dbh->setAttribute(PDO_ATTR_ORACLE_NULLS, true);
2004-07-19 17:35:36 +08:00
case PDO_ATTR_ORACLE_NULLS:
convert_to_long(value);
dbh->oracle_nulls = Z_LVAL_P(value) ? 1 : 0;
RETURN_TRUE;
Enable setting the different error modes via PDO::setAttribute()
2004-05-21 03:16:49 +08:00
default:
;
}
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
if (!dbh->methods->set_attribute) {
goto fail;
}
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
PDO_DBH_CLEAR_ERR();
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
if (dbh->methods->set_attribute(dbh, attr, value TSRMLS_CC)) {
RETURN_TRUE;
}
fail:
if (attr == PDO_ATTR_AUTOCOMMIT) {
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "The auto-commit mode cannot be changed for this driver");
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
} else if (!dbh->methods->set_attribute) {
get/set attributes for statements
2004-05-26 02:32:48 +08:00
/* XXX: do something better here */
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
php_error_docref(NULL TSRMLS_CC, E_WARNING, "This driver doesn't support setting attributes");
get/set attributes for statements
2004-05-26 02:32:48 +08:00
} else {
PDO_HANDLE_DBH_ERR();
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
}
RETURN_FALSE;
}
/* }}} */
get/set attributes for statements
2004-05-26 02:32:48 +08:00
/* {{{ proto mixed PDO::getAttribute(long attribute)
Get an attribute */
Added getAttribute() method.
2004-05-21 03:09:35 +08:00
static PHP_METHOD(PDO, getAttribute)
{
pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
long attr;
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &attr)) {
RETURN_FALSE;
}
Fixed typo.
2004-05-21 03:14:44 +08:00
if (!dbh->methods->get_attribute) {
Added getAttribute() method.
2004-05-21 03:09:35 +08:00
php_error_docref(NULL TSRMLS_CC, E_WARNING, "This driver doesn't support fetching attributes");
RETURN_FALSE;
}
PDO_DBH_CLEAR_ERR();
switch (dbh->methods->get_attribute(dbh, attr, return_value TSRMLS_CC)) {
case -1:
PDO_HANDLE_DBH_ERR();
RETURN_FALSE;
case 0:
get/set attributes for statements
2004-05-26 02:32:48 +08:00
/* XXX: should do something better here */
Added getAttribute() method.
2004-05-21 03:09:35 +08:00
php_error_docref(NULL TSRMLS_CC, E_WARNING, "This driver doesn't support fetching %ld attribute", attr);
break;
default:
return;
}
}
/* }}} */
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
/* {{{ proto long PDO::exec(string query)
exec() now returns row count
2004-05-20 03:27:53 +08:00
Execute a query that does not return a row set, returning the number of affected rows */
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
static PHP_METHOD(PDO, exec)
Add $dbh->exec() method. Rename $dbh->beginWork() to $dbh->beginTransaction().
2004-05-19 21:43:07 +08:00
{
pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
char *statement;
Fixed some int-long issues
2004-06-23 21:20:54 +08:00
int statement_len;
exec() now returns row count
2004-05-20 03:27:53 +08:00
long ret;
Add $dbh->exec() method. Rename $dbh->beginWork() to $dbh->beginTransaction().
2004-05-19 21:43:07 +08:00
if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &statement, &statement_len)) {
RETURN_FALSE;
}
if (!statement_len) {
RETURN_FALSE;
}
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
PDO_DBH_CLEAR_ERR();
exec() now returns row count
2004-05-20 03:27:53 +08:00
ret = dbh->methods->doer(dbh, statement, statement_len TSRMLS_CC);
if(ret == -1) {
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
PDO_HANDLE_DBH_ERR();
Revise $dbh->exec(). The driver doer() method should populate dbh->affected_rows if it can determine its value.
2004-05-19 21:55:41 +08:00
RETURN_FALSE;
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
} else {
exec() now returns row count
2004-05-20 03:27:53 +08:00
RETURN_LONG(ret);
Added lastInsertId() method for retrieving last insert id. Made affectedRows() work for MySQL. Populate error value in MySQL on error.
2004-05-20 01:35:39 +08:00
}
Add $dbh->exec() method. Rename $dbh->beginWork() to $dbh->beginTransaction().
2004-05-19 21:43:07 +08:00
}
/* }}} */
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
exec() now returns row count
2004-05-20 03:27:53 +08:00
Added lastInsertId() method for retrieving last insert id. Made affectedRows() work for MySQL. Populate error value in MySQL on error.
2004-05-20 01:35:39 +08:00
/* {{{ proto int PDO::lastInsertId()
Returns the number id of rows that we affected by the last call to PDO::exec(). Not always meaningful. */
static PHP_METHOD(PDO, lastInsertId)
{
pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
if (ZEND_NUM_ARGS()) {
RETURN_FALSE;
}
First cut at a "unified" error handling API. The main thing that is missing currently is a switch in the dbh to indicate what to do with the errors.
2004-05-20 08:05:22 +08:00
PDO_DBH_CLEAR_ERR();
Added lastInsertId() method for retrieving last insert id. Made affectedRows() work for MySQL. Populate error value in MySQL on error.
2004-05-20 01:35:39 +08:00
if (!dbh->methods->last_id) {
Better error message.
2004-05-21 02:05:44 +08:00
php_error_docref(NULL TSRMLS_CC, E_WARNING, "This driver does not support last inserted id retrieval.");
Added lastInsertId() method for retrieving last insert id. Made affectedRows() work for MySQL. Populate error value in MySQL on error.
2004-05-20 01:35:39 +08:00
} else {
Set correct Win32 line endings and fix ZTS compilation
2004-05-20 02:04:47 +08:00
RETURN_LONG(dbh->methods->last_id(dbh TSRMLS_CC));
Added lastInsertId() method for retrieving last insert id. Made affectedRows() work for MySQL. Populate error value in MySQL on error.
2004-05-20 01:35:39 +08:00
}
}
/* }}} */
Revise $dbh->exec(). The driver doer() method should populate dbh->affected_rows if it can determine its value.
2004-05-19 21:55:41 +08:00
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
/* {{{ proto string PDO::errorCode()
Add methods for error handling
2004-05-21 01:22:13 +08:00
Fetch the error code associated with the last operation on the database handle */
static PHP_METHOD(PDO, errorCode)
{
pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
if (ZEND_NUM_ARGS()) {
RETURN_FALSE;
}
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
RETURN_STRING(dbh->error_code, 1);
Add methods for error handling
2004-05-21 01:22:13 +08:00
}
/* }}} */
/* {{{ proto int PDO::errorInfo()
Fetch extended error information associated with the last operation on the database handle */
static PHP_METHOD(PDO, errorInfo)
{
pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
if (ZEND_NUM_ARGS()) {
RETURN_FALSE;
}
array_init(return_value);
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
add_next_index_string(return_value, dbh->error_code, 1);
Add methods for error handling
2004-05-21 01:22:13 +08:00
if (dbh->methods->fetch_err) {
dbh->methods->fetch_err(dbh, NULL, return_value TSRMLS_CC);
}
}
/* }}} */
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
/* {{{ proto object PDO::query(string sql [, PDOStatement::setFetchMode() args])
Synopsis: PDOStatement::setFetchMode() reset default fetch() mode for a statement to PDO_FETCH_BOTH PDOStatement::setFetchMode(PDO_FETCH_NUM) PDOStatement::setFetchMode(PDO_FETCH_ASSOC) PDOStatement::setFetchMode(PDO_FETCH_BOTH) PDOStatement::setFetchMode(PDO_FETCH_OBJ) set default fetch() mode for a statement. PDOStatement::setFetchMode(PDO_FETCH_COLUMN, int colno) set default fetch() mode to retrieve colno-th column on each fetch() call. PDOStatement::setFetchMode(PDO_FETCH_CLASS, string classname [, array ctor args]) set default fetch() mode to create an instance of classname, calling it's ctor, passing the optional ctor args. The names of the columns in the result set will be used as property names on the object instance. PPP rules apply. [NOTE: calling ctor is not yet implemented] [TODO: this might crash PHP for persistent PDO handles] PDOStatement::setFetchMode(PDO_FETCH_INTO, object obj) Similar to PDO_FETCH_CLASS, except that each iteration will update the supplied object properties. [TODO: this might crash PHP for persistent PDO handles] The default fetch() mode is used when no parameters are passed to PDOStatement::fetch(). When using a statement in an iterator context, PDOStatement::fetch() is called implicitly on each iteration. object PDO::queryAndIterate(string sql, <PDOStatement::setFetchMode args>) This is semantically equivalent to: $stmt = $pdo->prepare($sql); $stmt->execute(); $stmt->setFetchMode($args); return $stmt; Example/Intended usage: /* fetch an array with numeric and string keys */ foreach ($pdo->queryAndIterate("select NAME, VALUE from test") as $row) { debug_zval_dump($row); } /* fetch the value of column 1 into $row on each iteration */ foreach ($pdo->queryAndIterate("select NAME, VALUE from test", PDO_FETCH_COLUMN, 1) as $row) { debug_zval_dump($row); // string(3) "foo" } /* create a new instance of class Foo on each iteration */ foreach ($pdo->queryAndIterate("select NAME, VALUE from test", PDO_FETCH_CLASS, 'Foo') as $row) { debug_zval_dump($row); /* Object(Foo)#4 (2) refcount(2){ ["NAME"]=> string(12) "foo220051429" refcount(2) ["VALUE"]=> string(12) "bar789825748" refcount(2) } */ } etc.
2004-10-27 18:26:27 +08:00
Prepare and execute $sql; returns the statement object for iteration */
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
static PHP_METHOD(PDO, query)
Synopsis: PDOStatement::setFetchMode() reset default fetch() mode for a statement to PDO_FETCH_BOTH PDOStatement::setFetchMode(PDO_FETCH_NUM) PDOStatement::setFetchMode(PDO_FETCH_ASSOC) PDOStatement::setFetchMode(PDO_FETCH_BOTH) PDOStatement::setFetchMode(PDO_FETCH_OBJ) set default fetch() mode for a statement. PDOStatement::setFetchMode(PDO_FETCH_COLUMN, int colno) set default fetch() mode to retrieve colno-th column on each fetch() call. PDOStatement::setFetchMode(PDO_FETCH_CLASS, string classname [, array ctor args]) set default fetch() mode to create an instance of classname, calling it's ctor, passing the optional ctor args. The names of the columns in the result set will be used as property names on the object instance. PPP rules apply. [NOTE: calling ctor is not yet implemented] [TODO: this might crash PHP for persistent PDO handles] PDOStatement::setFetchMode(PDO_FETCH_INTO, object obj) Similar to PDO_FETCH_CLASS, except that each iteration will update the supplied object properties. [TODO: this might crash PHP for persistent PDO handles] The default fetch() mode is used when no parameters are passed to PDOStatement::fetch(). When using a statement in an iterator context, PDOStatement::fetch() is called implicitly on each iteration. object PDO::queryAndIterate(string sql, <PDOStatement::setFetchMode args>) This is semantically equivalent to: $stmt = $pdo->prepare($sql); $stmt->execute(); $stmt->setFetchMode($args); return $stmt; Example/Intended usage: /* fetch an array with numeric and string keys */ foreach ($pdo->queryAndIterate("select NAME, VALUE from test") as $row) { debug_zval_dump($row); } /* fetch the value of column 1 into $row on each iteration */ foreach ($pdo->queryAndIterate("select NAME, VALUE from test", PDO_FETCH_COLUMN, 1) as $row) { debug_zval_dump($row); // string(3) "foo" } /* create a new instance of class Foo on each iteration */ foreach ($pdo->queryAndIterate("select NAME, VALUE from test", PDO_FETCH_CLASS, 'Foo') as $row) { debug_zval_dump($row); /* Object(Foo)#4 (2) refcount(2){ ["NAME"]=> string(12) "foo220051429" refcount(2) ["VALUE"]=> string(12) "bar789825748" refcount(2) } */ } etc.
2004-10-27 18:26:27 +08:00
{
pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
pdo_stmt_t *stmt;
char *statement;
int statement_len;
zval *driver_options = NULL;
long options = 0;
if (FAILURE == zend_parse_parameters(1 TSRMLS_CC, "s", &statement,
&statement_len)) {
RETURN_FALSE;
}
PDO_DBH_CLEAR_ERR();
stmt = ecalloc(1, sizeof(*stmt));
/* unconditionally keep this for later reference */
stmt->query_string = estrndup(statement, statement_len);
stmt->query_stringlen = statement_len;
stmt->default_fetch_type = PDO_FETCH_BOTH;
if (dbh->methods->preparer(dbh, statement, statement_len, stmt, options, driver_options TSRMLS_CC)) {
/* prepared; create a statement object for PHP land to access it */
Z_TYPE_P(return_value) = IS_OBJECT;
Z_OBJ_HANDLE_P(return_value) = zend_objects_store_put(stmt, NULL, pdo_dbstmt_free_storage, NULL TSRMLS_CC);
Z_OBJ_HT_P(return_value) = &pdo_dbstmt_object_handlers;
/* give it a reference to me */
stmt->database_object_handle = *getThis();
zend_objects_store_add_ref(getThis() TSRMLS_CC);
stmt->dbh = dbh;
/* we haven't created a lazy object yet */
ZVAL_NULL(&stmt->lazy_object_ref);
stmt->refcount = 1;
if (ZEND_NUM_ARGS() == 1 ||
SUCCESS == pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAM_PASSTHRU,
stmt, 1)) {
PDO_STMT_CLEAR_ERR();
/* now execute the statement */
PDO_STMT_CLEAR_ERR();
if (stmt->methods->executer(stmt TSRMLS_CC)) {
int ret = 1;
if (!stmt->executed) {
if (stmt->dbh->alloc_own_columns) {
ret = pdo_stmt_describe_columns(stmt TSRMLS_CC);
}
stmt->executed = 1;
}
if (ret) {
return;
}
}
}
/* something broke */
PDO_HANDLE_STMT_ERR();
/* TODO: kill the object handle for the stmt here */
} else {
efree(stmt);
PDO_HANDLE_DBH_ERR();
}
RETURN_FALSE;
}
/* }}} */
Add methods for error handling
2004-05-21 01:22:13 +08:00
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
function_entry pdo_dbh_functions[] = {
fix for inheritability
2004-06-24 02:06:00 +08:00
PHP_ME_MAPPING(__construct, dbh_constructor, NULL)
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
PHP_ME(PDO, prepare, NULL, ZEND_ACC_PUBLIC)
Add $dbh->exec() method. Rename $dbh->beginWork() to $dbh->beginTransaction().
2004-05-19 21:43:07 +08:00
PHP_ME(PDO, beginTransaction,NULL, ZEND_ACC_PUBLIC)
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
PHP_ME(PDO, commit, NULL, ZEND_ACC_PUBLIC)
PHP_ME(PDO, rollBack, NULL, ZEND_ACC_PUBLIC)
PHP_ME(PDO, setAttribute, NULL, ZEND_ACC_PUBLIC)
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
PHP_ME(PDO, exec, NULL, ZEND_ACC_PUBLIC)
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
PHP_ME(PDO, query, NULL, ZEND_ACC_PUBLIC)
Added lastInsertId() method for retrieving last insert id. Made affectedRows() work for MySQL. Populate error value in MySQL on error.
2004-05-20 01:35:39 +08:00
PHP_ME(PDO, lastInsertId, NULL, ZEND_ACC_PUBLIC)
Add methods for error handling
2004-05-21 01:22:13 +08:00
PHP_ME(PDO, errorCode, NULL, ZEND_ACC_PUBLIC)
PHP_ME(PDO, errorInfo, NULL, ZEND_ACC_PUBLIC)
Added getAttribute() method.
2004-05-21 03:09:35 +08:00
PHP_ME(PDO, getAttribute, NULL, ZEND_ACC_PUBLIC)
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
{NULL, NULL, NULL}
};
/* {{{ overloaded object handlers for PDO class */
static zval *dbh_prop_read(zval *object, zval *member, int type TSRMLS_DC)
{
zval *return_value;
MAKE_STD_ZVAL(return_value);
ZVAL_NULL(return_value);
return return_value;
}
static void dbh_prop_write(zval *object, zval *member, zval *value TSRMLS_DC)
{
return;
}
static zval *dbh_read_dim(zval *object, zval *offset, int type TSRMLS_DC)
{
zval *return_value;
MAKE_STD_ZVAL(return_value);
ZVAL_NULL(return_value);
return return_value;
}
static void dbh_write_dim(zval *object, zval *offset, zval *value TSRMLS_DC)
{
return;
}
static int dbh_prop_exists(zval *object, zval *member, int check_empty TSRMLS_DC)
{
return 0;
}
static int dbh_dim_exists(zval *object, zval *member, int check_empty TSRMLS_DC)
{
return 0;
}
static void dbh_prop_delete(zval *object, zval *offset TSRMLS_DC)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot delete properties from a PDO DBH");
}
static void dbh_dim_delete(zval *object, zval *offset TSRMLS_DC)
{
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot delete dimensions from a PDO DBH");
}
static HashTable *dbh_get_properties(zval *object TSRMLS_DC)
{
return NULL;
}
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
{
function_entry *funcs;
zend_function func;
zend_internal_function *ifunc = (zend_internal_function*)&func;
int namelen;
char *lc_name;
if (!dbh->methods->get_driver_methods) {
return 0;
}
funcs = dbh->methods->get_driver_methods(dbh,
- Fix warning - Fix tsrm usage
2005-01-08 20:35:50 +08:00
PDO_DBH_DRIVER_METHOD_KIND_DBH TSRMLS_CC);
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
if (!funcs) {
return 0;
}
dbh->cls_methods[kind] = pemalloc(sizeof(HashTable), dbh->is_persistent);
zend_hash_init_ex(dbh->cls_methods[kind], 8, NULL, NULL, dbh->is_persistent, 0);
while (funcs->fname) {
ifunc->handler = funcs->handler;
ifunc->function_name = funcs->fname;
ifunc->scope = dbh->ce;
ifunc->prototype = NULL;
if (funcs->arg_info) {
ifunc->arg_info = funcs->arg_info + 1;
ifunc->num_args = funcs->num_args;
if (funcs->arg_info[0].required_num_args == -1) {
ifunc->required_num_args = funcs->num_args;
} else {
ifunc->required_num_args = funcs->arg_info[0].required_num_args;
}
ifunc->pass_rest_by_reference = funcs->arg_info[0].pass_by_reference;
ifunc->return_reference = funcs->arg_info[0].return_reference;
} else {
ifunc->arg_info = NULL;
ifunc->num_args = 0;
ifunc->required_num_args = 0;
ifunc->pass_rest_by_reference = 0;
ifunc->return_reference = 0;
}
if (funcs->flags) {
ifunc->fn_flags = funcs->flags;
} else {
ifunc->fn_flags = ZEND_ACC_PUBLIC;
}
namelen = strlen(funcs->fname);
lc_name = emalloc(namelen+1);
zend_str_tolower_copy(lc_name, funcs->fname, namelen);
zend_hash_add(dbh->cls_methods[kind], lc_name, namelen+1, &func, sizeof(func), NULL);
efree(lc_name);
funcs++;
}
return 1;
}
don't blow up under HEAD
2004-12-26 12:50:09 +08:00
static union _zend_function *dbh_method_get(
#if PHP_API_VERSION >= 20041225
zval **object_pp,
#else
zval *object,
#endif
char *method_name, int method_len TSRMLS_DC)
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
{
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
zend_function *fbc = NULL;
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
char *lc_method_name;
don't blow up under HEAD
2004-12-26 12:50:09 +08:00
#if PHP_API_VERSION >= 20041225
zval *object = *object_pp;
#endif
allow pdo to be functionally inherited from.
2004-07-26 15:42:46 +08:00
pdo_dbh_t *dbh = zend_object_store_get_object(object TSRMLS_CC);
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
Don't use alloca() where it can reached by the users.
2004-07-06 05:16:29 +08:00
lc_method_name = emalloc(method_len + 1);
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
zend_str_tolower_copy(lc_method_name, method_name, method_len);
allow pdo to be functionally inherited from.
2004-07-26 15:42:46 +08:00
if (zend_hash_find(&dbh->ce->function_table, lc_method_name, method_len+1, (void**)&fbc) == FAILURE) {
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
/* not a pre-defined method, nor a user-defined method; check
* the driver specific methods */
if (!dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH]) {
Tidy up driver specific method handling
2005-01-18 07:59:16 +08:00
if (!pdo_hash_methods(dbh,
PDO_DBH_DRIVER_METHOD_KIND_DBH TSRMLS_CC)
|| !dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH]) {
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
goto out;
}
}
if (zend_hash_find(dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH],
lc_method_name, method_len+1, (void**)&fbc) == FAILURE) {
fbc = NULL;
goto out;
}
/* got it */
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
}
implement SQLSTATE style error codes. Allow drivers to add methods to dbh and stmt objects (note that we can't use a class, because the use only sees the PDO class). Clarify the api slightly: PDO::exec() is used for one-shot queries that don't return rows PDO::query() is a convenience function for returning a rowset without having to go through the steps of preparing and executing.
2005-01-07 13:23:10 +08:00
out:
Don't use alloca() where it can reached by the users.
2004-07-06 05:16:29 +08:00
efree(lc_method_name);
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
return fbc;
}
static int dbh_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS)
{
return FAILURE;
}
fix for inheritability
2004-06-24 02:06:00 +08:00
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
static union _zend_function *dbh_get_ctor(zval *object TSRMLS_DC)
{
allow pdo to be functionally inherited from.
2004-07-26 15:42:46 +08:00
static zend_internal_function ctor = {0};
ctor.type = ZEND_INTERNAL_FUNCTION;
ctor.function_name = "__construct";
ctor.scope = pdo_dbh_ce;
ctor.handler = ZEND_FN(dbh_constructor);
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
allow pdo to be functionally inherited from.
2004-07-26 15:42:46 +08:00
return (union _zend_function*)&ctor;
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
}
static zend_class_entry *dbh_get_ce(zval *object TSRMLS_DC)
{
allow pdo to be functionally inherited from.
2004-07-26 15:42:46 +08:00
pdo_dbh_t *dbh = zend_object_store_get_object(object TSRMLS_CC);
return dbh->ce;
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
}
static int dbh_get_classname(zval *object, char **class_name, zend_uint *class_name_len, int parent TSRMLS_DC)
{
*class_name = estrndup("PDO", sizeof("PDO")-1);
*class_name_len = sizeof("PDO")-1;
return 0;
}
static int dbh_compare(zval *object1, zval *object2 TSRMLS_DC)
{
return -1;
}
static zend_object_handlers pdo_dbh_object_handlers = {
ZEND_OBJECTS_STORE_HANDLERS,
dbh_prop_read,
dbh_prop_write,
dbh_read_dim,
dbh_write_dim,
NULL,
NULL,
NULL,
dbh_prop_exists,
dbh_prop_delete,
dbh_dim_exists,
dbh_dim_delete,
dbh_get_properties,
dbh_method_get,
dbh_call_method,
dbh_get_ctor,
dbh_get_ce,
dbh_get_classname,
dbh_compare,
NULL, /* cast */
NULL
};
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
static void dbh_free(pdo_dbh_t *dbh TSRMLS_DC)
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
{
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
if (--dbh->refcount)
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
return;
- Fix SEGV in case ctor failed
2004-07-28 08:01:12 +08:00
if (dbh->methods) {
dbh->methods->closer(dbh TSRMLS_CC);
}
Fixed memory leak.
2004-05-25 22:12:15 +08:00
if (dbh->data_source) {
More leak fixes.
2004-05-25 22:30:07 +08:00
pefree((char *)dbh->data_source, dbh->is_persistent);
Fixed memory leak.
2004-05-25 22:12:15 +08:00
}
if (dbh->username) {
More leak fixes.
2004-05-25 22:30:07 +08:00
pefree(dbh->username, dbh->is_persistent);
Fixed memory leak.
2004-05-25 22:12:15 +08:00
}
if (dbh->password) {
More leak fixes.
2004-05-25 22:30:07 +08:00
pefree(dbh->password, dbh->is_persistent);
Fixed memory leak.
2004-05-25 22:12:15 +08:00
}
More leak fixes.
2004-05-25 22:30:07 +08:00
pefree(dbh, dbh->is_persistent);
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
}
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
static void pdo_dbh_free_storage(zend_object *object TSRMLS_DC)
{
pdo_dbh_t *dbh = (pdo_dbh_t*)object;
if (!dbh) {
return;
}
if (dbh->properties) {
zend_hash_destroy(dbh->properties);
efree(dbh->properties);
dbh->properties = NULL;
}
if (!dbh->is_persistent) {
dbh_free(dbh TSRMLS_CC);
}
}
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
zend_object_value pdo_dbh_new(zend_class_entry *ce TSRMLS_DC)
{
zend_object_value retval;
fix for inheritability
2004-06-24 02:06:00 +08:00
pdo_dbh_t *dbh;
dbh = emalloc(sizeof(*dbh));
memset(dbh, 0, sizeof(*dbh));
dbh->ce = ce;
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
dbh->refcount = 1;
allow pdo to be functionally inherited from.
2004-07-26 15:42:46 +08:00
ALLOC_HASHTABLE(dbh->properties);
zend_hash_init(dbh->properties, 0, NULL, ZVAL_PTR_DTOR, 0);
fix for inheritability
2004-06-24 02:06:00 +08:00
retval.handle = zend_objects_store_put(dbh, NULL, pdo_dbh_free_storage, NULL TSRMLS_CC);
allow pdo to be functionally inherited from.
2004-07-26 15:42:46 +08:00
if(ce == pdo_dbh_ce) {
retval.handlers = &pdo_dbh_object_handlers;
}
else {
retval.handlers = &std_object_handlers;
}
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
return retval;
}
/* }}} */
Implement persistent connections $dbh->exec --> $dbh->query
2004-09-24 04:07:02 +08:00
ZEND_RSRC_DTOR_FUNC(php_pdo_pdbh_dtor)
{
if (rsrc->ptr) {
pdo_dbh_t *dbh = (pdo_dbh_t*)rsrc->ptr;
dbh_free(dbh TSRMLS_CC);
rsrc->ptr = NULL;
}
}
Hello PDO. Still more to come. Give it a couple of days before starting to write drivers for the other databases; a few things might change, so I'd like to coordinate that, but in a couple of days.
2004-05-17 23:41:51 +08:00
/*
* Local variables:
* tab-width: 4
* c-basic-offset: 4
* End:
* vim600: noet sw=4 ts=4 fdm=marker
* vim<600: noet sw=4 ts=4
*/
Reference in New Issue Copy Permalink