Back to index

php5  5.3.10
Classes | Defines | Typedefs | Enumerations | Functions
php_pdo_driver.h File Reference
#include "php_pdo.h"
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  pdo_driver_t
struct  pdo_dbh_methods
struct  pdo_stmt_methods
struct  _pdo_dbh_t
struct  pdo_column_data
struct  pdo_bound_param_data
struct  _pdo_stmt_t
struct  pdo_data_src_parser
union  _pdo_stmt_t.fetch
struct  _pdo_stmt_t.fetch.cls
struct  _pdo_stmt_t.fetch.func

Defines

#define TRUE   1
#define FALSE   0
#define PDO_DRIVER_API   20080721
#define PDO_PARAM_INPUT_OUTPUT   0x80000000
#define PDO_PARAM_FLAGS   0xFFFF0000
#define PDO_PARAM_TYPE(x)   ((x) & ~PDO_PARAM_FLAGS)
#define PDO_FETCH_FLAGS   0xFFFF0000 /* fetchAll() modes or'd to PDO_FETCH_XYZ */
#define PDO_FETCH_GROUP   0x00010000 /* fetch into groups */
#define PDO_FETCH_UNIQUE   0x00030000 /* fetch into groups assuming first col is unique */
#define PDO_FETCH_CLASSTYPE   0x00040000 /* fetch class gets its class name from 1st column */
#define PDO_FETCH_SERIALIZE   0x00080000 /* fetch class instances by calling serialize */
#define PDO_FETCH_PROPS_LATE   0x00100000 /* fetch props after calling ctor */
#define PDO_ERR_NONE   "00000"
#define PDO_DRIVER_HEADER(name)

Typedefs

typedef struct _pdo_dbh_t
typedef struct _pdo_stmt_t
typedef long long int pdo_int64_t
typedef unsigned long long int pdo_uint64_t
typedef char pdo_error_type [6]
typedef int(* pdo_dbh_close_func )(pdo_dbh_t *dbh TSRMLS_DC)
typedef int(* pdo_dbh_prepare_func )(pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)
typedef long(* pdo_dbh_do_func )(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC)
typedef int(* pdo_dbh_quote_func )(pdo_dbh_t *dbh, const char *unquoted, int unquotedlen, char **quoted, int *quotedlen, enum pdo_param_type paramtype TSRMLS_DC)
typedef int(* pdo_dbh_txn_func )(pdo_dbh_t *dbh TSRMLS_DC)
typedef int(* pdo_dbh_set_attr_func )(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
typedef char *(* pdo_dbh_last_id_func )(pdo_dbh_t *dbh, const char *name, unsigned int *len TSRMLS_DC)
typedef int(* pdo_dbh_fetch_error_func )(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info TSRMLS_DC)
typedef int(* pdo_dbh_get_attr_func )(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)
typedef int(* pdo_dbh_check_liveness_func )(pdo_dbh_t *dbh TSRMLS_DC)
typedef void(* pdo_dbh_request_shutdown )(pdo_dbh_t *dbh TSRMLS_DC)
typedef const
zend_function_entry *(* 
pdo_dbh_get_driver_methods_func )(pdo_dbh_t *dbh, int kind TSRMLS_DC)
typedef int(* pdo_stmt_dtor_func )(pdo_stmt_t *stmt TSRMLS_DC)
typedef int(* pdo_stmt_execute_func )(pdo_stmt_t *stmt TSRMLS_DC)
typedef int(* pdo_stmt_fetch_func )(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, long offset TSRMLS_DC)
typedef int(* pdo_stmt_describe_col_func )(pdo_stmt_t *stmt, int colno TSRMLS_DC)
typedef int(* pdo_stmt_get_col_data_func )(pdo_stmt_t *stmt, int colno, char **ptr, unsigned long *len, int *caller_frees TSRMLS_DC)
typedef int(* pdo_stmt_param_hook_func )(pdo_stmt_t *stmt, struct pdo_bound_param_data *param, enum pdo_param_event event_type TSRMLS_DC)
typedef int(* pdo_stmt_set_attr_func )(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC)
typedef int(* pdo_stmt_get_attr_func )(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC)
typedef int(* pdo_stmt_get_column_meta_func )(pdo_stmt_t *stmt, long colno, zval *return_value TSRMLS_DC)
typedef int(* pdo_stmt_next_rowset_func )(pdo_stmt_t *stmt TSRMLS_DC)
typedef int(* pdo_stmt_cursor_closer_func )(pdo_stmt_t *stmt TSRMLS_DC)

Enumerations

enum  pdo_param_type {
  PDO_PARAM_NULL, PDO_PARAM_INT, PDO_PARAM_STR, PDO_PARAM_LOB,
  PDO_PARAM_STMT, PDO_PARAM_BOOL, PDO_PARAM_ZVAL
}
enum  pdo_fetch_type {
  PDO_FETCH_USE_DEFAULT, PDO_FETCH_LAZY, PDO_FETCH_ASSOC, PDO_FETCH_NUM,
  PDO_FETCH_BOTH, PDO_FETCH_OBJ, PDO_FETCH_BOUND, PDO_FETCH_COLUMN,
  PDO_FETCH_CLASS, PDO_FETCH_INTO, PDO_FETCH_FUNC, PDO_FETCH_NAMED,
  PDO_FETCH_KEY_PAIR, PDO_FETCH__MAX
}
enum  pdo_fetch_orientation {
  PDO_FETCH_ORI_NEXT, PDO_FETCH_ORI_PRIOR, PDO_FETCH_ORI_FIRST, PDO_FETCH_ORI_LAST,
  PDO_FETCH_ORI_ABS, PDO_FETCH_ORI_REL
}
enum  pdo_attribute_type {
  PDO_ATTR_AUTOCOMMIT, PDO_ATTR_PREFETCH, PDO_ATTR_TIMEOUT, PDO_ATTR_ERRMODE,
  PDO_ATTR_SERVER_VERSION, PDO_ATTR_CLIENT_VERSION, PDO_ATTR_SERVER_INFO, PDO_ATTR_CONNECTION_STATUS,
  PDO_ATTR_CASE, PDO_ATTR_CURSOR_NAME, PDO_ATTR_CURSOR, PDO_ATTR_ORACLE_NULLS,
  PDO_ATTR_PERSISTENT, PDO_ATTR_STATEMENT_CLASS, PDO_ATTR_FETCH_TABLE_NAMES, PDO_ATTR_FETCH_CATALOG_NAMES,
  PDO_ATTR_DRIVER_NAME, PDO_ATTR_STRINGIFY_FETCHES, PDO_ATTR_MAX_COLUMN_LEN, PDO_ATTR_DEFAULT_FETCH_MODE,
  PDO_ATTR_EMULATE_PREPARES, PDO_ATTR_DRIVER_SPECIFIC = 1000
}
enum  pdo_cursor_type { PDO_CURSOR_FWDONLY, PDO_CURSOR_SCROLL }
enum  pdo_error_mode { PDO_ERRMODE_SILENT, PDO_ERRMODE_WARNING, PDO_ERRMODE_EXCEPTION }
enum  pdo_case_conversion { PDO_CASE_NATURAL, PDO_CASE_UPPER, PDO_CASE_LOWER }
enum  pdo_null_handling { PDO_NULL_NATURAL = 0, PDO_NULL_EMPTY_STRING = 1, PDO_NULL_TO_STRING = 2 }
enum  { PDO_DBH_DRIVER_METHOD_KIND_DBH = 0, PDO_DBH_DRIVER_METHOD_KIND_STMT, PDO_DBH_DRIVER_METHOD_KIND__MAX }
enum  pdo_param_event {
  PDO_PARAM_EVT_ALLOC, PDO_PARAM_EVT_FREE, PDO_PARAM_EVT_EXEC_PRE, PDO_PARAM_EVT_EXEC_POST,
  PDO_PARAM_EVT_FETCH_PRE, PDO_PARAM_EVT_FETCH_POST, PDO_PARAM_EVT_NORMALIZE
}
enum  pdo_placeholder_support { PDO_PLACEHOLDER_NONE = 0, PDO_PLACEHOLDER_NAMED = 1, PDO_PLACEHOLDER_POSITIONAL = 2 }

Functions

PDO_API char * php_pdo_int64_to_str (pdo_int64_t i64 TSRMLS_DC)
static long pdo_attr_lval (zval *options, enum pdo_attribute_type option_name, long defval TSRMLS_DC)
static char * pdo_attr_strval (zval *options, enum pdo_attribute_type option_name, char *defval TSRMLS_DC)
PDO_API int php_pdo_register_driver (pdo_driver_t *driver)
PDO_API void php_pdo_unregister_driver (pdo_driver_t *driver)
PDO_API int php_pdo_parse_data_source (const char *data_source, unsigned long data_source_len, struct pdo_data_src_parser *parsed, int nparams)
PDO_API zend_class_entry * php_pdo_get_dbh_ce (void)
PDO_API zend_class_entry * php_pdo_get_exception (void)
PDO_API int pdo_parse_params (pdo_stmt_t *stmt, char *inquery, int inquery_len, char **outquery, int *outquery_len TSRMLS_DC)
PDO_API void pdo_raise_impl_error (pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *sqlstate, const char *supp TSRMLS_DC)
PDO_API void php_pdo_dbh_addref (pdo_dbh_t *dbh TSRMLS_DC)
PDO_API void php_pdo_dbh_delref (pdo_dbh_t *dbh TSRMLS_DC)
PDO_API void php_pdo_stmt_addref (pdo_stmt_t *stmt TSRMLS_DC)
PDO_API void php_pdo_stmt_delref (pdo_stmt_t *stmt TSRMLS_DC)

Class Documentation

struct pdo_dbh_methods

Definition at line 298 of file php_pdo_driver.h.

Collaboration diagram for pdo_dbh_methods:
Class Members
pdo_dbh_txn_func begin
pdo_dbh_check_liveness_func check_liveness
pdo_dbh_close_func closer
pdo_dbh_txn_func commit
pdo_dbh_do_func doer
pdo_dbh_fetch_error_func fetch_err
pdo_dbh_get_attr_func get_attribute
pdo_dbh_get_driver_methods_func get_driver_methods
pdo_dbh_last_id_func last_id
pdo_dbh_request_shutdown persistent_shutdown
pdo_dbh_prepare_func preparer
pdo_dbh_quote_func quoter
pdo_dbh_txn_func rollback
pdo_dbh_set_attr_func set_attribute
struct pdo_stmt_methods

Definition at line 404 of file php_pdo_driver.h.

Collaboration diagram for pdo_stmt_methods:
Class Members
pdo_stmt_cursor_closer_func cursor_closer
pdo_stmt_describe_col_func describer
pdo_stmt_dtor_func dtor
pdo_stmt_execute_func executer
pdo_stmt_fetch_func fetcher
pdo_stmt_get_attr_func get_attribute
pdo_stmt_get_col_data_func get_col
pdo_stmt_get_column_meta_func get_column_meta
pdo_stmt_next_rowset_func next_rowset
pdo_stmt_param_hook_func param_hook
pdo_stmt_set_attr_func set_attribute
struct _pdo_dbh_t

Definition at line 427 of file php_pdo_driver.h.

Collaboration diagram for _pdo_dbh_t:
Class Members
unsigned _reserved_flags:21
unsigned alloc_own_columns:1
unsigned auto_commit:1
zend_class_entry * ce
const char * data_source
unsigned long data_source_len
void * driver_data
pdo_error_type error_code
unsigned int in_get:1
unsigned int in_set:1
unsigned in_txn:1
unsigned is_closed:1
unsigned is_persistent:1
unsigned max_escaped_char_length:3
struct pdo_dbh_methods * methods
unsigned oracle_nulls:2
char * password
HashTable * properties
unsigned stringify:1
char * username
struct pdo_column_data

Definition at line 515 of file php_pdo_driver.h.

Class Members
unsigned long maxlen
char * name
int namelen
struct pdo_bound_param_data

Definition at line 527 of file php_pdo_driver.h.

Class Members
long max_value_len
char * name
int namelen
zval * parameter
long paramno
struct _pdo_stmt_t

Definition at line 545 of file php_pdo_driver.h.

Collaboration diagram for _pdo_stmt_t:
Class Members
unsigned _reserved:29
char * active_query_string
int active_query_stringlen
HashTable * bound_columns
HashTable * bound_param_map
HashTable * bound_params
zend_class_entry * ce
int column_count
struct pdo_column_data * columns
zval database_object_handle
pdo_dbh_t * dbh
void * driver_data
pdo_error_type error_code
unsigned executed:1
enum pdo_fetch_type union
_pdo_stmt_t
fetch
unsigned int in_get:1
unsigned int in_set:1
zval lazy_object_ref
struct pdo_stmt_methods * methods
const char * named_rewrite_template
HashTable * properties
char * query_string
int query_stringlen
unsigned long refcount
long row_count
unsigned supports_placeholders:2
struct pdo_data_src_parser

Definition at line 644 of file php_pdo_driver.h.

Class Members
int freeme
const char * optname
char * optval
union _pdo_stmt_t.fetch

Definition at line 611 of file php_pdo_driver.h.

Class Members
fetch cls
int column
fetch func
zval * into
struct _pdo_stmt_t.fetch.cls

Definition at line 613 of file php_pdo_driver.h.

Class Members
zend_class_entry * ce
zval * ctor_args
zend_fcall_info_cache fcc
zend_fcall_info fci
zval * retval_ptr
struct _pdo_stmt_t.fetch.func

Definition at line 620 of file php_pdo_driver.h.

Class Members
zend_fcall_info_cache fcc
zend_fcall_info fci
zval * fetch_args
zval * function
zval * object
zval ** values

Define Documentation

#define FALSE   0

Definition at line 44 of file php_pdo_driver.h.

#define PDO_DRIVER_API   20080721

Definition at line 47 of file php_pdo_driver.h.

#define PDO_DRIVER_HEADER (   name)
Value:
#name, sizeof(#name)-1, \
       PDO_DRIVER_API

Definition at line 224 of file php_pdo_driver.h.

#define PDO_ERR_NONE   "00000"

Definition at line 173 of file php_pdo_driver.h.

#define PDO_FETCH_CLASSTYPE   0x00040000 /* fetch class gets its class name from 1st column */

Definition at line 105 of file php_pdo_driver.h.

#define PDO_FETCH_FLAGS   0xFFFF0000 /* fetchAll() modes or'd to PDO_FETCH_XYZ */

Definition at line 102 of file php_pdo_driver.h.

#define PDO_FETCH_GROUP   0x00010000 /* fetch into groups */

Definition at line 103 of file php_pdo_driver.h.

#define PDO_FETCH_PROPS_LATE   0x00100000 /* fetch props after calling ctor */

Definition at line 107 of file php_pdo_driver.h.

#define PDO_FETCH_SERIALIZE   0x00080000 /* fetch class instances by calling serialize */

Definition at line 106 of file php_pdo_driver.h.

#define PDO_FETCH_UNIQUE   0x00030000 /* fetch into groups assuming first col is unique */

Definition at line 104 of file php_pdo_driver.h.

#define PDO_PARAM_FLAGS   0xFFFF0000

Definition at line 81 of file php_pdo_driver.h.

#define PDO_PARAM_INPUT_OUTPUT   0x80000000

Definition at line 79 of file php_pdo_driver.h.

#define PDO_PARAM_TYPE (   x)    ((x) & ~PDO_PARAM_FLAGS)

Definition at line 83 of file php_pdo_driver.h.

#define TRUE   1

Definition at line 41 of file php_pdo_driver.h.


Typedef Documentation

typedef struct _pdo_dbh_t

Definition at line 27 of file php_pdo_driver.h.

typedef struct _pdo_stmt_t

Definition at line 28 of file php_pdo_driver.h.

typedef int(* pdo_dbh_check_liveness_func)(pdo_dbh_t *dbh TSRMLS_DC)

Definition at line 277 of file php_pdo_driver.h.

typedef int(* pdo_dbh_close_func)(pdo_dbh_t *dbh TSRMLS_DC)

Definition at line 242 of file php_pdo_driver.h.

typedef long(* pdo_dbh_do_func)(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC)

Definition at line 248 of file php_pdo_driver.h.

typedef int(* pdo_dbh_fetch_error_func)(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info TSRMLS_DC)

Definition at line 269 of file php_pdo_driver.h.

typedef int(* pdo_dbh_get_attr_func)(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)

Definition at line 272 of file php_pdo_driver.h.

typedef const zend_function_entry*(* pdo_dbh_get_driver_methods_func)(pdo_dbh_t *dbh, int kind TSRMLS_DC)

Definition at line 296 of file php_pdo_driver.h.

typedef char*(* pdo_dbh_last_id_func)(pdo_dbh_t *dbh, const char *name, unsigned int *len TSRMLS_DC)

Definition at line 261 of file php_pdo_driver.h.

typedef int(* pdo_dbh_prepare_func)(pdo_dbh_t *dbh, const char *sql, long sql_len, pdo_stmt_t *stmt, zval *driver_options TSRMLS_DC)

Definition at line 245 of file php_pdo_driver.h.

typedef int(* pdo_dbh_quote_func)(pdo_dbh_t *dbh, const char *unquoted, int unquotedlen, char **quoted, int *quotedlen, enum pdo_param_type paramtype TSRMLS_DC)

Definition at line 251 of file php_pdo_driver.h.

typedef void(* pdo_dbh_request_shutdown)(pdo_dbh_t *dbh TSRMLS_DC)

Definition at line 282 of file php_pdo_driver.h.

typedef int(* pdo_dbh_set_attr_func)(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC)

Definition at line 257 of file php_pdo_driver.h.

typedef int(* pdo_dbh_txn_func)(pdo_dbh_t *dbh TSRMLS_DC)

Definition at line 254 of file php_pdo_driver.h.

typedef char pdo_error_type[6]

Definition at line 170 of file php_pdo_driver.h.

typedef long long int pdo_int64_t

Definition at line 29 of file php_pdo_driver.h.

typedef int(* pdo_stmt_cursor_closer_func)(pdo_stmt_t *stmt TSRMLS_DC)

Definition at line 402 of file php_pdo_driver.h.

typedef int(* pdo_stmt_describe_col_func)(pdo_stmt_t *stmt, int colno TSRMLS_DC)

Definition at line 333 of file php_pdo_driver.h.

typedef int(* pdo_stmt_dtor_func)(pdo_stmt_t *stmt TSRMLS_DC)

Definition at line 320 of file php_pdo_driver.h.

typedef int(* pdo_stmt_execute_func)(pdo_stmt_t *stmt TSRMLS_DC)

Definition at line 323 of file php_pdo_driver.h.

typedef int(* pdo_stmt_fetch_func)(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, long offset TSRMLS_DC)

Definition at line 328 of file php_pdo_driver.h.

typedef int(* pdo_stmt_get_attr_func)(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC)

Definition at line 360 of file php_pdo_driver.h.

typedef int(* pdo_stmt_get_col_data_func)(pdo_stmt_t *stmt, int colno, char **ptr, unsigned long *len, int *caller_frees TSRMLS_DC)

Definition at line 341 of file php_pdo_driver.h.

typedef int(* pdo_stmt_get_column_meta_func)(pdo_stmt_t *stmt, long colno, zval *return_value TSRMLS_DC)

Definition at line 390 of file php_pdo_driver.h.

typedef int(* pdo_stmt_next_rowset_func)(pdo_stmt_t *stmt TSRMLS_DC)

Definition at line 396 of file php_pdo_driver.h.

typedef int(* pdo_stmt_param_hook_func)(pdo_stmt_t *stmt, struct pdo_bound_param_data *param, enum pdo_param_event event_type TSRMLS_DC)

Definition at line 354 of file php_pdo_driver.h.

typedef int(* pdo_stmt_set_attr_func)(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC)

Definition at line 357 of file php_pdo_driver.h.

typedef unsigned long long int pdo_uint64_t

Definition at line 36 of file php_pdo_driver.h.


Enumeration Type Documentation

anonymous enum
Enumerator:
PDO_DBH_DRIVER_METHOD_KIND_DBH 
PDO_DBH_DRIVER_METHOD_KIND_STMT 
PDO_DBH_DRIVER_METHOD_KIND__MAX 

Definition at line 290 of file php_pdo_driver.h.

Enumerator:
PDO_ATTR_AUTOCOMMIT 
PDO_ATTR_PREFETCH 
PDO_ATTR_TIMEOUT 
PDO_ATTR_ERRMODE 
PDO_ATTR_SERVER_VERSION 
PDO_ATTR_CLIENT_VERSION 
PDO_ATTR_SERVER_INFO 
PDO_ATTR_CONNECTION_STATUS 
PDO_ATTR_CASE 
PDO_ATTR_CURSOR_NAME 
PDO_ATTR_CURSOR 
PDO_ATTR_ORACLE_NULLS 
PDO_ATTR_PERSISTENT 
PDO_ATTR_STATEMENT_CLASS 
PDO_ATTR_FETCH_TABLE_NAMES 
PDO_ATTR_FETCH_CATALOG_NAMES 
PDO_ATTR_DRIVER_NAME 
PDO_ATTR_STRINGIFY_FETCHES 
PDO_ATTR_MAX_COLUMN_LEN 
PDO_ATTR_DEFAULT_FETCH_MODE 
PDO_ATTR_EMULATE_PREPARES 
PDO_ATTR_DRIVER_SPECIFIC 

Definition at line 119 of file php_pdo_driver.h.

                        {
       PDO_ATTR_AUTOCOMMIT, /* use to turn on or off auto-commit mode */
       PDO_ATTR_PREFETCH,          /* configure the prefetch size for drivers that support it. Size is in KB */
       PDO_ATTR_TIMEOUT,           /* connection timeout in seconds */
       PDO_ATTR_ERRMODE,           /* control how errors are handled */
       PDO_ATTR_SERVER_VERSION,    /* database server version */
       PDO_ATTR_CLIENT_VERSION,    /* client library version */
       PDO_ATTR_SERVER_INFO,              /* server information */
       PDO_ATTR_CONNECTION_STATUS, /* connection status */
       PDO_ATTR_CASE,                            /* control case folding for portability */
       PDO_ATTR_CURSOR_NAME,              /* name a cursor for use in "WHERE CURRENT OF <name>" */
       PDO_ATTR_CURSOR,                   /* cursor type */
       PDO_ATTR_ORACLE_NULLS,             /* convert empty strings to NULL */
       PDO_ATTR_PERSISTENT,        /* pconnect style connection */
       PDO_ATTR_STATEMENT_CLASS,   /* array(classname, array(ctor_args)) to specify the class of the constructed statement */
       PDO_ATTR_FETCH_TABLE_NAMES, /* include table names in the column names, where available */
       PDO_ATTR_FETCH_CATALOG_NAMES, /* include the catalog/db name names in the column names, where available */
       PDO_ATTR_DRIVER_NAME,                /* name of the driver (as used in the constructor) */
       PDO_ATTR_STRINGIFY_FETCHES, /* converts integer/float types to strings during fetch */
       PDO_ATTR_MAX_COLUMN_LEN,    /* make database calculate maximum length of data found in a column */
       PDO_ATTR_DEFAULT_FETCH_MODE, /* Set the default fetch mode */
       PDO_ATTR_EMULATE_PREPARES,  /* use query emulation rather than native */

       /* this defines the start of the range for driver specific options.
        * Drivers should define their own attribute constants beginning with this
        * value. */
       PDO_ATTR_DRIVER_SPECIFIC = 1000
};
Enumerator:
PDO_CASE_NATURAL 
PDO_CASE_UPPER 
PDO_CASE_LOWER 

Definition at line 181 of file php_pdo_driver.h.

Enumerator:
PDO_CURSOR_FWDONLY 
PDO_CURSOR_SCROLL 

Definition at line 148 of file php_pdo_driver.h.

                     {
       PDO_CURSOR_FWDONLY,         /* forward only cursor (default) */
       PDO_CURSOR_SCROLL           /* scrollable cursor */
};
Enumerator:
PDO_ERRMODE_SILENT 
PDO_ERRMODE_WARNING 
PDO_ERRMODE_EXCEPTION 

Definition at line 175 of file php_pdo_driver.h.

                    {
       PDO_ERRMODE_SILENT,         /* just set error codes */
       PDO_ERRMODE_WARNING, /* raise E_WARNING */
       PDO_ERRMODE_EXCEPTION       /* throw exceptions */
};
Enumerator:
PDO_FETCH_ORI_NEXT 
PDO_FETCH_ORI_PRIOR 
PDO_FETCH_ORI_FIRST 
PDO_FETCH_ORI_LAST 
PDO_FETCH_ORI_ABS 
PDO_FETCH_ORI_REL 

Definition at line 110 of file php_pdo_driver.h.

                           {
       PDO_FETCH_ORI_NEXT,         /* default: fetch the next available row */
       PDO_FETCH_ORI_PRIOR, /* scroll back to prior row and fetch that */
       PDO_FETCH_ORI_FIRST, /* scroll to the first row and fetch that */
       PDO_FETCH_ORI_LAST,         /* scroll to the last row and fetch that */
       PDO_FETCH_ORI_ABS,          /* scroll to an absolute numbered row and fetch that */
       PDO_FETCH_ORI_REL           /* scroll relative to the current row, and fetch that */
};
Enumerator:
PDO_FETCH_USE_DEFAULT 
PDO_FETCH_LAZY 
PDO_FETCH_ASSOC 
PDO_FETCH_NUM 
PDO_FETCH_BOTH 
PDO_FETCH_OBJ 
PDO_FETCH_BOUND 
PDO_FETCH_COLUMN 
PDO_FETCH_CLASS 
PDO_FETCH_INTO 
PDO_FETCH_FUNC 
PDO_FETCH_NAMED 
PDO_FETCH_KEY_PAIR 
PDO_FETCH__MAX 

Definition at line 85 of file php_pdo_driver.h.

                    {
       PDO_FETCH_USE_DEFAULT,
       PDO_FETCH_LAZY,
       PDO_FETCH_ASSOC,
       PDO_FETCH_NUM,
       PDO_FETCH_BOTH,
       PDO_FETCH_OBJ,
       PDO_FETCH_BOUND, /* return true/false only; rely on bound columns */
       PDO_FETCH_COLUMN,    /* fetch a numbered column only */
       PDO_FETCH_CLASS,     /* create an instance of named class, call ctor and set properties */
       PDO_FETCH_INTO,             /* fetch row into an existing object */
       PDO_FETCH_FUNC,             /* fetch into function and return its result */
       PDO_FETCH_NAMED,    /* like PDO_FETCH_ASSOC, but can handle duplicate names */
       PDO_FETCH_KEY_PAIR,  /* fetch into an array where the 1st column is a key and all subsequent columns are values */
       PDO_FETCH__MAX /* must be last */
};
Enumerator:
PDO_NULL_NATURAL 
PDO_NULL_EMPTY_STRING 
PDO_NULL_TO_STRING 

Definition at line 188 of file php_pdo_driver.h.

Enumerator:
PDO_PARAM_EVT_ALLOC 
PDO_PARAM_EVT_FREE 
PDO_PARAM_EVT_EXEC_PRE 
PDO_PARAM_EVT_EXEC_POST 
PDO_PARAM_EVT_FETCH_PRE 
PDO_PARAM_EVT_FETCH_POST 
PDO_PARAM_EVT_NORMALIZE 

Definition at line 344 of file php_pdo_driver.h.

Enumerator:
PDO_PARAM_NULL 
PDO_PARAM_INT 
PDO_PARAM_STR 
PDO_PARAM_LOB 
PDO_PARAM_STMT 
PDO_PARAM_BOOL 
PDO_PARAM_ZVAL 

Definition at line 49 of file php_pdo_driver.h.

                    {
       PDO_PARAM_NULL,

       /* int as in long (the php native int type).
        * If you mark a column as an int, PDO expects get_col to return
        * a pointer to a long */
       PDO_PARAM_INT,

       /* get_col ptr should point to start of the string buffer */
       PDO_PARAM_STR,

       /* get_col: when len is 0 ptr should point to a php_stream *,
        * otherwise it should behave like a string. Indicate a NULL field
        * value by setting the ptr to NULL */
       PDO_PARAM_LOB,

       /* get_col: will expect the ptr to point to a new PDOStatement object handle,
        * but this isn't wired up yet */
       PDO_PARAM_STMT, /* hierarchical result set */

       /* get_col ptr should point to a zend_bool */
       PDO_PARAM_BOOL,

       /* get_col ptr should point to a zval*
          and the driver is responsible for adding correct type information to get_column_meta()
        */
       PDO_PARAM_ZVAL
};
Enumerator:
PDO_PLACEHOLDER_NONE 
PDO_PLACEHOLDER_NAMED 
PDO_PLACEHOLDER_POSITIONAL 

Definition at line 420 of file php_pdo_driver.h.


Function Documentation

static long pdo_attr_lval ( zval *  options,
enum pdo_attribute_type  option_name,
long defval  TSRMLS_DC 
) [inline, static]

Definition at line 195 of file php_pdo_driver.h.

{
       zval **v;

       if (options && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), option_name, (void**)&v)) {
              convert_to_long_ex(v);
              return Z_LVAL_PP(v);
       }
       return defval;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* pdo_attr_strval ( zval *  options,
enum pdo_attribute_type  option_name,
char *defval  TSRMLS_DC 
) [inline, static]

Definition at line 205 of file php_pdo_driver.h.

{
       zval **v;

       if (options && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), option_name, (void**)&v)) {
              convert_to_string_ex(v);
              return estrndup(Z_STRVAL_PP(v), Z_STRLEN_PP(v));
       }
       return defval ? estrdup(defval) : NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PDO_API int pdo_parse_params ( pdo_stmt_t *  stmt,
char *  inquery,
int  inquery_len,
char **  outquery,
int *outquery_len  TSRMLS_DC 
)

Definition at line 415 of file pdo_sql_parser.c.

{
       Scanner s;
       char *ptr, *newbuffer;
       int t;
       int bindno = 0;
       int ret = 0;
       int newbuffer_len;
       HashTable *params;
       struct pdo_bound_param_data *param;
       int query_type = PDO_PLACEHOLDER_NONE;
       struct placeholder *placeholders = NULL, *placetail = NULL, *plc = NULL;

       ptr = *outquery;
       s.cur = inquery;

       /* phase 1: look for args */
       while((t = scan(&s)) != PDO_PARSER_EOI) {
              if (t == PDO_PARSER_BIND || t == PDO_PARSER_BIND_POS) {
                     if (t == PDO_PARSER_BIND) {
                            int len = s.cur - s.tok;
                            if ((inquery < (s.cur - len)) && isalnum(*(s.cur - len - 1))) {
                                   continue;
                            }
                            query_type |= PDO_PLACEHOLDER_NAMED;
                     } else {
                            query_type |= PDO_PLACEHOLDER_POSITIONAL;
                     }

                     plc = emalloc(sizeof(*plc));
                     memset(plc, 0, sizeof(*plc));
                     plc->next = NULL;
                     plc->pos = s.tok;
                     plc->len = s.cur - s.tok;
                     plc->bindno = bindno++;

                     if (placetail) {
                            placetail->next = plc;
                     } else {
                            placeholders = plc;
                     }
                     placetail = plc;
              }
       }

       if (bindno == 0) {
              /* nothing to do; good! */
              return 0;
       }

       /* did the query make sense to me? */
       if (query_type == (PDO_PLACEHOLDER_NAMED|PDO_PLACEHOLDER_POSITIONAL)) {
              /* they mixed both types; punt */
              pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "mixed named and positional parameters" TSRMLS_CC);
              ret = -1;
              goto clean_up;
       }

       if (stmt->supports_placeholders == query_type && !stmt->named_rewrite_template) {
              /* query matches native syntax */
              ret = 0;
              goto clean_up;
       }

       if (stmt->named_rewrite_template) {
              /* magic/hack.
               * We we pretend that the query was positional even if
               * it was named so that we fall into the
               * named rewrite case below.  Not too pretty,
               * but it works. */
              query_type = PDO_PLACEHOLDER_POSITIONAL;
       }
       
       params = stmt->bound_params;
       
       /* Do we have placeholders but no bound params */
       if (bindno && !params && stmt->supports_placeholders == PDO_PLACEHOLDER_NONE) {
              pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "no parameters were bound" TSRMLS_CC);
              ret = -1;
              goto clean_up;
       }

       if (params && bindno != zend_hash_num_elements(params) && stmt->supports_placeholders == PDO_PLACEHOLDER_NONE) {
              /* extra bit of validation for instances when same params are bound more then once */
              if (query_type != PDO_PLACEHOLDER_POSITIONAL && bindno > zend_hash_num_elements(params)) {
                     int ok = 1;
                     for (plc = placeholders; plc; plc = plc->next) {
                            if (zend_hash_find(params, plc->pos, plc->len, (void**) &param) == FAILURE) {
                                   ok = 0;
                                   break;
                            }
                     }
                     if (ok) {
                            goto safe;
                     }
              }
              pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "number of bound variables does not match number of tokens" TSRMLS_CC);
              ret = -1;
              goto clean_up;
       }
safe:
       /* what are we going to do ? */
       if (stmt->supports_placeholders == PDO_PLACEHOLDER_NONE) {
              /* query generation */

              newbuffer_len = inquery_len;

              /* let's quote all the values */   
              for (plc = placeholders; plc; plc = plc->next) {
                     if (query_type == PDO_PLACEHOLDER_POSITIONAL) {
                            ret = zend_hash_index_find(params, plc->bindno, (void**) &param);
                     } else {
                            ret = zend_hash_find(params, plc->pos, plc->len, (void**) &param);
                     }
                     if (ret == FAILURE) {
                            /* parameter was not defined */
                            ret = -1;
                            pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined" TSRMLS_CC);
                            goto clean_up;
                     }
                     if (stmt->dbh->methods->quoter) {
                            if (param->param_type == PDO_PARAM_LOB && Z_TYPE_P(param->parameter) == IS_RESOURCE) {
                                   php_stream *stm;

                                   php_stream_from_zval_no_verify(stm, &param->parameter);
                                   if (stm) {
                                          size_t len;
                                          char *buf = NULL;
                                   
                                          len = php_stream_copy_to_mem(stm, &buf, PHP_STREAM_COPY_ALL, 0);
                                          if (!stmt->dbh->methods->quoter(stmt->dbh, buf, len, &plc->quoted, &plc->qlen,
                                                        param->param_type TSRMLS_CC)) {
                                                 /* bork */
                                                 ret = -1;
                                                 strcpy(stmt->error_code, stmt->dbh->error_code);
                                                 if (buf) {
                                                        efree(buf);
                                                 }
                                                 goto clean_up;
                                          }
                                          if (buf) {
                                                 efree(buf);
                                          }
                                   } else {
                                          pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource" TSRMLS_CC);
                                          ret = -1;
                                          goto clean_up;
                                   }
                                   plc->freeq = 1;
                            } else {
                                   switch (Z_TYPE_P(param->parameter)) {
                                          case IS_NULL:
                                                 plc->quoted = "NULL";
                                                 plc->qlen = sizeof("NULL")-1;
                                                 plc->freeq = 0;
                                                 break;

                                          case IS_LONG:
                                          case IS_DOUBLE:
                                                 convert_to_string(param->parameter);
                                                 plc->qlen = Z_STRLEN_P(param->parameter);
                                                 plc->quoted = Z_STRVAL_P(param->parameter);
                                                 plc->freeq = 0;
                                                 break;

                                          case IS_BOOL:
                                                 convert_to_long(param->parameter);
                                          default:
                                                 convert_to_string(param->parameter);
                                                 if (!stmt->dbh->methods->quoter(stmt->dbh, Z_STRVAL_P(param->parameter),
                                                               Z_STRLEN_P(param->parameter), &plc->quoted, &plc->qlen,
                                                               param->param_type TSRMLS_CC)) {
                                                        /* bork */
                                                        ret = -1;
                                                        strcpy(stmt->error_code, stmt->dbh->error_code);
                                                        goto clean_up;
                                                 }
                                                 plc->freeq = 1;
                                   }
                            }
                     } else {
                            plc->quoted = Z_STRVAL_P(param->parameter);
                            plc->qlen = Z_STRLEN_P(param->parameter);
                     }
                     newbuffer_len += plc->qlen;
              }

rewrite:
              /* allocate output buffer */
              newbuffer = emalloc(newbuffer_len + 1);
              *outquery = newbuffer;

              /* and build the query */
              plc = placeholders;
              ptr = inquery;

              do {
                     t = plc->pos - ptr;
                     if (t) {
                            memcpy(newbuffer, ptr, t);
                            newbuffer += t;
                     }
                     memcpy(newbuffer, plc->quoted, plc->qlen);
                     newbuffer += plc->qlen;
                     ptr = plc->pos + plc->len;

                     plc = plc->next;
              } while (plc);

              t = (inquery + inquery_len) - ptr;
              if (t) {
                     memcpy(newbuffer, ptr, t);
                     newbuffer += t;
              }
              *newbuffer = '\0';
              *outquery_len = newbuffer - *outquery;

              ret = 1;
              goto clean_up;

       } else if (query_type == PDO_PLACEHOLDER_POSITIONAL) {
              /* rewrite ? to :pdoX */
              char *name, *idxbuf;
              const char *tmpl = stmt->named_rewrite_template ? stmt->named_rewrite_template : ":pdo%d";
              int bind_no = 1;
              
              newbuffer_len = inquery_len;

              if (stmt->bound_param_map == NULL) {
                     ALLOC_HASHTABLE(stmt->bound_param_map);
                     zend_hash_init(stmt->bound_param_map, 13, NULL, NULL, 0);
              }

              for (plc = placeholders; plc; plc = plc->next) {
                     int skip_map = 0;
                     char *p;
                     name = estrndup(plc->pos, plc->len);

                     /* check if bound parameter is already available */
                     if (!strcmp(name, "?") || zend_hash_find(stmt->bound_param_map, name, plc->len + 1, (void**) &p) == FAILURE) {
                            spprintf(&idxbuf, 0, tmpl, bind_no++);
                     } else {
                            idxbuf = estrdup(p);
                            skip_map = 1;
                     }

                     plc->quoted = idxbuf;
                     plc->qlen = strlen(plc->quoted);
                     plc->freeq = 1;
                     newbuffer_len += plc->qlen;

                     if (!skip_map && stmt->named_rewrite_template) {
                            /* create a mapping */
                            zend_hash_update(stmt->bound_param_map, name, plc->len + 1, idxbuf, plc->qlen + 1, NULL);
                     }

                     /* map number to name */
                     zend_hash_index_update(stmt->bound_param_map, plc->bindno, idxbuf, plc->qlen + 1, NULL);
                     
                     efree(name);
              }
                            
              goto rewrite;

       } else {
              /* rewrite :name to ? */
              
              newbuffer_len = inquery_len;
       
              if (stmt->bound_param_map == NULL) {
                     ALLOC_HASHTABLE(stmt->bound_param_map);
                     zend_hash_init(stmt->bound_param_map, 13, NULL, NULL, 0);
              }
              
              for (plc = placeholders; plc; plc = plc->next) {
                     char *name;
                     
                     name = estrndup(plc->pos, plc->len);
                     zend_hash_index_update(stmt->bound_param_map, plc->bindno, name, plc->len + 1, NULL);
                     efree(name);
                     plc->quoted = "?";
                     plc->qlen = 1;
              }

              goto rewrite;
       }

clean_up:

       while (placeholders) {
              plc = placeholders;
              placeholders = plc->next;

              if (plc->freeq) {
                     efree(plc->quoted);
              }

              efree(plc);
       }

       return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PDO_API void pdo_raise_impl_error ( pdo_dbh_t *  dbh,
pdo_stmt_t *  stmt,
const char *  sqlstate,
const char *supp  TSRMLS_DC 
)

Definition at line 41 of file pdo_dbh.c.

{
       pdo_error_type *pdo_err = &dbh->error_code;
       char *message = NULL;
       const char *msg;

       if (dbh && dbh->error_mode == PDO_ERRMODE_SILENT) {
#if 0
              /* BUG: if user is running in silent mode and hits an error at the driver level
               * when they use the PDO methods to call up the error information, they may
               * get bogus information */
              return;
#endif
       }
       
       if (stmt) {
              pdo_err = &stmt->error_code;
       }

       strncpy(*pdo_err, sqlstate, 6);

       /* hash sqlstate to error messages */
       msg = pdo_sqlstate_state_to_description(*pdo_err);
       if (!msg) {
              msg = "<<Unknown error>>";
       }

       if (supp) {
              spprintf(&message, 0, "SQLSTATE[%s]: %s: %s", *pdo_err, msg, supp);
       } else {
              spprintf(&message, 0, "SQLSTATE[%s]: %s", *pdo_err, msg);
       }

       if (dbh && dbh->error_mode != PDO_ERRMODE_EXCEPTION) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message);
       } else {
              zval *ex, *info;
              zend_class_entry *def_ex = php_pdo_get_exception_base(1 TSRMLS_CC), *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);
              zend_update_property_string(def_ex, ex, "code", sizeof("code")-1, *pdo_err TSRMLS_CC);
              
              MAKE_STD_ZVAL(info);
              array_init(info);

              add_next_index_string(info, *pdo_err, 1);
              add_next_index_long(info, 0);

              zend_update_property(pdo_ex, ex, "errorInfo", sizeof("errorInfo")-1, info TSRMLS_CC);
              zval_ptr_dtor(&info);

              zend_throw_exception_object(ex TSRMLS_CC);
       }
       
       if (message) {
              efree(message);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PDO_API void php_pdo_dbh_addref ( pdo_dbh_t *dbh  TSRMLS_DC)

Definition at line 1542 of file pdo_dbh.c.

{
       dbh->refcount++;
}

Here is the caller graph for this function:

PDO_API void php_pdo_dbh_delref ( pdo_dbh_t *dbh  TSRMLS_DC)

Definition at line 1547 of file pdo_dbh.c.

{
       dbh_free(dbh TSRMLS_CC);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PDO_API zend_class_entry* php_pdo_get_dbh_ce ( void  )

Definition at line 57 of file pdo.c.

{
       return pdo_dbh_ce;
}
PDO_API zend_class_entry* php_pdo_get_exception ( void  )

Definition at line 62 of file pdo.c.

{
       return pdo_exception_ce;
}

Here is the caller graph for this function:

Definition at line 317 of file pdo.c.

{
       char buffer[65];
       char outbuf[65] = "";
       register char *p;
       long long_val;
       char *dst = outbuf;

       if (i64 < 0) {
              i64 = -i64;
              *dst++ = '-';
       }

       if (i64 == 0) {
              *dst++ = '0';
              *dst++ = '\0';
              return estrdup(outbuf);
       }

       p = &buffer[sizeof(buffer)-1];
       *p = '\0';

       while ((pdo_uint64_t)i64 > (pdo_uint64_t)LONG_MAX) {
              pdo_uint64_t quo = (pdo_uint64_t)i64 / (unsigned int)10;
              unsigned int rem = (unsigned int)(i64 - quo*10U);
              *--p = digit_vec[rem];
              i64 = (pdo_int64_t)quo;
       }
       long_val = (long)i64;
       while (long_val != 0) {
              long quo = long_val / 10;
              *--p = digit_vec[(unsigned int)(long_val - quo * 10)];
              long_val = quo;
       }
       while ((*dst++ = *p++) != 0)
              ;
       *dst = '\0';
       return estrdup(outbuf);
}

Here is the caller graph for this function:

PDO_API int php_pdo_parse_data_source ( const char *  data_source,
unsigned long  data_source_len,
struct pdo_data_src_parser parsed,
int  nparams 
)

Definition at line 215 of file pdo.c.

{
       int i, j;
       int valstart = -1;
       int semi = -1;
       int optstart = 0;
       int nlen;
       int n_matches = 0;
       int n_semicolumns = 0;

       i = 0;
       while (i < data_source_len) {
              /* looking for NAME= */

              if (data_source[i] == '\0') {
                     break;
              }

              if (data_source[i] != '=') {
                     ++i;
                     continue;
              }

              valstart = ++i;

              /* now we're looking for VALUE; or just VALUE<NUL> */
              semi = -1;
              n_semicolumns = 0;
              while (i < data_source_len) {
                     if (data_source[i] == '\0') {
                            semi = i++;
                            break;
                     }
                     if (data_source[i] == ';') {
                            if ((i + 1 >= data_source_len) || data_source[i+1] != ';') {
                                   semi = i++;
                                   break;
                            } else {
                                   n_semicolumns++; 
                                   i += 2;
                                   continue;
                            }
                     }
                     ++i;
              }

              if (semi == -1) {
                     semi = i;
              }

              /* find the entry in the array */
              nlen = valstart - optstart - 1;
              for (j = 0; j < nparams; j++) {
                     if (0 == strncmp(data_source + optstart, parsed[j].optname, nlen) && parsed[j].optname[nlen] == '\0') {
                            /* got a match */
                            if (parsed[j].freeme) {
                                   efree(parsed[j].optval);
                            }

                            if (n_semicolumns == 0) {
                                   parsed[j].optval = estrndup(data_source + valstart, semi - valstart - n_semicolumns);
                            } else {
                                   int vlen = semi - valstart;
                                   char *orig_val = data_source + valstart;
                                   char *new_val  = (char *) emalloc(vlen - n_semicolumns + 1);
                            
                                   parsed[j].optval = new_val;

                                   while (vlen && *orig_val) {
                                          *new_val = *orig_val;
                                          new_val++;

                                          if (*orig_val == ';') {
                                                 orig_val+=2; 
                                                 vlen-=2;
                                          } else {
                                                 orig_val++;
                                                 vlen--;
                                          }
                                   }
                                   *new_val = '\0';
                            }

                            parsed[j].freeme = 1;
                            ++n_matches;
                            break;
                     }
              }

              while (i < data_source_len && isspace(data_source[i])) {
                     i++;
              }

              optstart = i;
       }

       return n_matches;
}

Here is the caller graph for this function:

Definition at line 181 of file pdo.c.

{
       if (driver->api_version != PDO_DRIVER_API) {
              zend_error(E_ERROR, "PDO: driver %s requires PDO API version %ld; this is PDO version %d",
                     driver->driver_name, driver->api_version, PDO_DRIVER_API);
              return FAILURE;
       }
       if (!zend_hash_exists(&module_registry, "pdo", sizeof("pdo"))) {
              zend_error(E_ERROR, "You MUST load PDO before loading any PDO drivers");
              return FAILURE;      /* NOTREACHED */
       }

       return zend_hash_add(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len,
                     (void**)&driver, sizeof(pdo_driver_t *), NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PDO_API void php_pdo_stmt_addref ( pdo_stmt_t *stmt  TSRMLS_DC)

Definition at line 2440 of file pdo_stmt.c.

{
       stmt->refcount++;
}

Here is the caller graph for this function:

PDO_API void php_pdo_stmt_delref ( pdo_stmt_t *stmt  TSRMLS_DC)

Definition at line 2445 of file pdo_stmt.c.

{
       if (--stmt->refcount == 0) {
              free_statement(stmt TSRMLS_CC);
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 197 of file pdo.c.

{
       if (!zend_hash_exists(&module_registry, "pdo", sizeof("pdo"))) {
              return;
       }

       zend_hash_del(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len);
}

Here is the call graph for this function:

Here is the caller graph for this function: