Annotation of embedaddon/php/ext/pdo/php_pdo_driver.h, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Author: Wez Furlong <wez@php.net> |
! 16: +----------------------------------------------------------------------+
! 17: */
! 18:
! 19: /* $Id: php_pdo_driver.h 321634 2012-01-01 13:15:04Z felipe $ */
! 20:
! 21: #ifndef PHP_PDO_DRIVER_H
! 22: #define PHP_PDO_DRIVER_H
! 23:
! 24: #include "php_pdo.h"
! 25:
! 26: /* forward declarations */
! 27: typedef struct _pdo_dbh_t pdo_dbh_t;
! 28: typedef struct _pdo_stmt_t pdo_stmt_t;
! 29: struct pdo_bound_param_data;
! 30:
! 31: #ifdef PHP_WIN32
! 32: typedef __int64 pdo_int64_t;
! 33: typedef unsigned __int64 pdo_uint64_t;
! 34: #else
! 35: typedef long long int pdo_int64_t;
! 36: typedef unsigned long long int pdo_uint64_t;
! 37: #endif
! 38: PDO_API char *php_pdo_int64_to_str(pdo_int64_t i64 TSRMLS_DC);
! 39:
! 40: #ifndef TRUE
! 41: # define TRUE 1
! 42: #endif
! 43: #ifndef FALSE
! 44: # define FALSE 0
! 45: #endif
! 46:
! 47: #define PDO_DRIVER_API 20080721
! 48:
! 49: enum pdo_param_type {
! 50: PDO_PARAM_NULL,
! 51:
! 52: /* int as in long (the php native int type).
! 53: * If you mark a column as an int, PDO expects get_col to return
! 54: * a pointer to a long */
! 55: PDO_PARAM_INT,
! 56:
! 57: /* get_col ptr should point to start of the string buffer */
! 58: PDO_PARAM_STR,
! 59:
! 60: /* get_col: when len is 0 ptr should point to a php_stream *,
! 61: * otherwise it should behave like a string. Indicate a NULL field
! 62: * value by setting the ptr to NULL */
! 63: PDO_PARAM_LOB,
! 64:
! 65: /* get_col: will expect the ptr to point to a new PDOStatement object handle,
! 66: * but this isn't wired up yet */
! 67: PDO_PARAM_STMT, /* hierarchical result set */
! 68:
! 69: /* get_col ptr should point to a zend_bool */
! 70: PDO_PARAM_BOOL,
! 71:
! 72: /* get_col ptr should point to a zval*
! 73: and the driver is responsible for adding correct type information to get_column_meta()
! 74: */
! 75: PDO_PARAM_ZVAL
! 76: };
! 77:
! 78: /* magic flag to denote a parameter as being input/output */
! 79: #define PDO_PARAM_INPUT_OUTPUT 0x80000000
! 80:
! 81: #define PDO_PARAM_FLAGS 0xFFFF0000
! 82:
! 83: #define PDO_PARAM_TYPE(x) ((x) & ~PDO_PARAM_FLAGS)
! 84:
! 85: enum pdo_fetch_type {
! 86: PDO_FETCH_USE_DEFAULT,
! 87: PDO_FETCH_LAZY,
! 88: PDO_FETCH_ASSOC,
! 89: PDO_FETCH_NUM,
! 90: PDO_FETCH_BOTH,
! 91: PDO_FETCH_OBJ,
! 92: PDO_FETCH_BOUND, /* return true/false only; rely on bound columns */
! 93: PDO_FETCH_COLUMN, /* fetch a numbered column only */
! 94: PDO_FETCH_CLASS, /* create an instance of named class, call ctor and set properties */
! 95: PDO_FETCH_INTO, /* fetch row into an existing object */
! 96: PDO_FETCH_FUNC, /* fetch into function and return its result */
! 97: PDO_FETCH_NAMED, /* like PDO_FETCH_ASSOC, but can handle duplicate names */
! 98: PDO_FETCH_KEY_PAIR, /* fetch into an array where the 1st column is a key and all subsequent columns are values */
! 99: PDO_FETCH__MAX /* must be last */
! 100: };
! 101:
! 102: #define PDO_FETCH_FLAGS 0xFFFF0000 /* fetchAll() modes or'd to PDO_FETCH_XYZ */
! 103: #define PDO_FETCH_GROUP 0x00010000 /* fetch into groups */
! 104: #define PDO_FETCH_UNIQUE 0x00030000 /* fetch into groups assuming first col is unique */
! 105: #define PDO_FETCH_CLASSTYPE 0x00040000 /* fetch class gets its class name from 1st column */
! 106: #define PDO_FETCH_SERIALIZE 0x00080000 /* fetch class instances by calling serialize */
! 107: #define PDO_FETCH_PROPS_LATE 0x00100000 /* fetch props after calling ctor */
! 108:
! 109: /* fetch orientation for scrollable cursors */
! 110: enum pdo_fetch_orientation {
! 111: PDO_FETCH_ORI_NEXT, /* default: fetch the next available row */
! 112: PDO_FETCH_ORI_PRIOR, /* scroll back to prior row and fetch that */
! 113: PDO_FETCH_ORI_FIRST, /* scroll to the first row and fetch that */
! 114: PDO_FETCH_ORI_LAST, /* scroll to the last row and fetch that */
! 115: PDO_FETCH_ORI_ABS, /* scroll to an absolute numbered row and fetch that */
! 116: PDO_FETCH_ORI_REL /* scroll relative to the current row, and fetch that */
! 117: };
! 118:
! 119: enum pdo_attribute_type {
! 120: PDO_ATTR_AUTOCOMMIT, /* use to turn on or off auto-commit mode */
! 121: PDO_ATTR_PREFETCH, /* configure the prefetch size for drivers that support it. Size is in KB */
! 122: PDO_ATTR_TIMEOUT, /* connection timeout in seconds */
! 123: PDO_ATTR_ERRMODE, /* control how errors are handled */
! 124: PDO_ATTR_SERVER_VERSION, /* database server version */
! 125: PDO_ATTR_CLIENT_VERSION, /* client library version */
! 126: PDO_ATTR_SERVER_INFO, /* server information */
! 127: PDO_ATTR_CONNECTION_STATUS, /* connection status */
! 128: PDO_ATTR_CASE, /* control case folding for portability */
! 129: PDO_ATTR_CURSOR_NAME, /* name a cursor for use in "WHERE CURRENT OF <name>" */
! 130: PDO_ATTR_CURSOR, /* cursor type */
! 131: PDO_ATTR_ORACLE_NULLS, /* convert empty strings to NULL */
! 132: PDO_ATTR_PERSISTENT, /* pconnect style connection */
! 133: PDO_ATTR_STATEMENT_CLASS, /* array(classname, array(ctor_args)) to specify the class of the constructed statement */
! 134: PDO_ATTR_FETCH_TABLE_NAMES, /* include table names in the column names, where available */
! 135: PDO_ATTR_FETCH_CATALOG_NAMES, /* include the catalog/db name names in the column names, where available */
! 136: PDO_ATTR_DRIVER_NAME, /* name of the driver (as used in the constructor) */
! 137: PDO_ATTR_STRINGIFY_FETCHES, /* converts integer/float types to strings during fetch */
! 138: PDO_ATTR_MAX_COLUMN_LEN, /* make database calculate maximum length of data found in a column */
! 139: PDO_ATTR_DEFAULT_FETCH_MODE, /* Set the default fetch mode */
! 140: PDO_ATTR_EMULATE_PREPARES, /* use query emulation rather than native */
! 141:
! 142: /* this defines the start of the range for driver specific options.
! 143: * Drivers should define their own attribute constants beginning with this
! 144: * value. */
! 145: PDO_ATTR_DRIVER_SPECIFIC = 1000
! 146: };
! 147:
! 148: enum pdo_cursor_type {
! 149: PDO_CURSOR_FWDONLY, /* forward only cursor (default) */
! 150: PDO_CURSOR_SCROLL /* scrollable cursor */
! 151: };
! 152:
! 153: /* SQL-92 SQLSTATE error codes.
! 154:
! 155: The character string value returned for an SQLSTATE consists of a two-character
! 156: class value followed by a three-character subclass value. A class value of 01
! 157: indicates a warning and is accompanied by a return code of
! 158: SQL_SUCCESS_WITH_INFO.
! 159:
! 160: Class values other than '01', except for the class 'IM',
! 161: indicate an error and are accompanied by a return code of SQL_ERROR. The class
! 162: 'IM' is specific to warnings and errors that derive from the implementation of
! 163: ODBC itself.
! 164:
! 165: The subclass value '000' in any class indicates that there is no
! 166: subclass for that SQLSTATE. The assignment of class and subclass values is
! 167: defined by SQL-92.
! 168: */
! 169:
! 170: typedef char pdo_error_type[6]; /* SQLSTATE */
! 171:
! 172:
! 173: #define PDO_ERR_NONE "00000"
! 174:
! 175: enum pdo_error_mode {
! 176: PDO_ERRMODE_SILENT, /* just set error codes */
! 177: PDO_ERRMODE_WARNING, /* raise E_WARNING */
! 178: PDO_ERRMODE_EXCEPTION /* throw exceptions */
! 179: };
! 180:
! 181: enum pdo_case_conversion {
! 182: PDO_CASE_NATURAL,
! 183: PDO_CASE_UPPER,
! 184: PDO_CASE_LOWER
! 185: };
! 186:
! 187: /* oracle interop settings */
! 188: enum pdo_null_handling {
! 189: PDO_NULL_NATURAL = 0,
! 190: PDO_NULL_EMPTY_STRING = 1,
! 191: PDO_NULL_TO_STRING = 2
! 192: };
! 193:
! 194: /* {{{ utils for reading attributes set as driver_options */
! 195: static inline long pdo_attr_lval(zval *options, enum pdo_attribute_type option_name, long defval TSRMLS_DC)
! 196: {
! 197: zval **v;
! 198:
! 199: if (options && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), option_name, (void**)&v)) {
! 200: convert_to_long_ex(v);
! 201: return Z_LVAL_PP(v);
! 202: }
! 203: return defval;
! 204: }
! 205: static inline char *pdo_attr_strval(zval *options, enum pdo_attribute_type option_name, char *defval TSRMLS_DC)
! 206: {
! 207: zval **v;
! 208:
! 209: if (options && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), option_name, (void**)&v)) {
! 210: convert_to_string_ex(v);
! 211: return estrndup(Z_STRVAL_PP(v), Z_STRLEN_PP(v));
! 212: }
! 213: return defval ? estrdup(defval) : NULL;
! 214: }
! 215: /* }}} */
! 216:
! 217: /* This structure is registered with PDO when a PDO driver extension is
! 218: * initialized */
! 219: typedef struct {
! 220: const char *driver_name;
! 221: unsigned long driver_name_len;
! 222: unsigned long api_version; /* needs to be compatible with PDO */
! 223:
! 224: #define PDO_DRIVER_HEADER(name) \
! 225: #name, sizeof(#name)-1, \
! 226: PDO_DRIVER_API
! 227:
! 228: /* create driver specific portion of the database handle and stash it into
! 229: * the dbh. dbh contains the data source string and flags for this
! 230: * instance. You MUST respect dbh->is_persistent and pass that flag to
! 231: * pemalloc() for all allocations that are stored in the dbh or your instance
! 232: * data in the db, otherwise you will crash PHP when persistent connections
! 233: * are used.
! 234: */
! 235: int (*db_handle_factory)(pdo_dbh_t *dbh, zval *driver_options TSRMLS_DC);
! 236:
! 237: } pdo_driver_t;
! 238:
! 239: /* {{{ methods for a database handle */
! 240:
! 241: /* close or otherwise disconnect the database */
! 242: typedef int (*pdo_dbh_close_func)(pdo_dbh_t *dbh TSRMLS_DC);
! 243:
! 244: /* prepare a statement and stash driver specific portion into stmt */
! 245: 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);
! 246:
! 247: /* execute a statement (that does not return a result set) */
! 248: typedef long (*pdo_dbh_do_func)(pdo_dbh_t *dbh, const char *sql, long sql_len TSRMLS_DC);
! 249:
! 250: /* quote a string */
! 251: 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);
! 252:
! 253: /* transaction related */
! 254: typedef int (*pdo_dbh_txn_func)(pdo_dbh_t *dbh TSRMLS_DC);
! 255:
! 256: /* setting of attributes */
! 257: typedef int (*pdo_dbh_set_attr_func)(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC);
! 258:
! 259: /* return last insert id. NULL indicates error condition, otherwise, the return value
! 260: * MUST be an emalloc'd NULL terminated string. */
! 261: typedef char *(*pdo_dbh_last_id_func)(pdo_dbh_t *dbh, const char *name, unsigned int *len TSRMLS_DC);
! 262:
! 263: /* fetch error information. if stmt is not null, fetch information pertaining
! 264: * to the statement, otherwise fetch global error information. The driver
! 265: * should add the following information to the array "info" in this order:
! 266: * - native error code
! 267: * - string representation of the error code ... any other optional driver
! 268: * specific data ... */
! 269: typedef int (*pdo_dbh_fetch_error_func)(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info TSRMLS_DC);
! 270:
! 271: /* fetching of attributes */
! 272: typedef int (*pdo_dbh_get_attr_func)(pdo_dbh_t *dbh, long attr, zval *val TSRMLS_DC);
! 273:
! 274: /* checking/pinging persistent connections; return SUCCESS if the connection
! 275: * is still alive and ready to be used, FAILURE otherwise.
! 276: * You may set this handler to NULL, which is equivalent to returning SUCCESS. */
! 277: typedef int (*pdo_dbh_check_liveness_func)(pdo_dbh_t *dbh TSRMLS_DC);
! 278:
! 279: /* called at request end for each persistent dbh; this gives the driver
! 280: * the opportunity to safely release resources that only have per-request
! 281: * scope */
! 282: typedef void (*pdo_dbh_request_shutdown)(pdo_dbh_t *dbh TSRMLS_DC);
! 283:
! 284: /* for adding methods to the dbh or stmt objects
! 285: pointer to a list of driver specific functions. The convention is
! 286: to prefix the function names using the PDO driver name; this will
! 287: reduce the chance of collisions with future functionality in the
! 288: PDO class or in user code (they can extend the PDO object).
! 289: */
! 290: enum {
! 291: PDO_DBH_DRIVER_METHOD_KIND_DBH = 0,
! 292: PDO_DBH_DRIVER_METHOD_KIND_STMT,
! 293: PDO_DBH_DRIVER_METHOD_KIND__MAX
! 294: };
! 295:
! 296: typedef const zend_function_entry *(*pdo_dbh_get_driver_methods_func)(pdo_dbh_t *dbh, int kind TSRMLS_DC);
! 297:
! 298: struct pdo_dbh_methods {
! 299: pdo_dbh_close_func closer;
! 300: pdo_dbh_prepare_func preparer;
! 301: pdo_dbh_do_func doer;
! 302: pdo_dbh_quote_func quoter;
! 303: pdo_dbh_txn_func begin;
! 304: pdo_dbh_txn_func commit;
! 305: pdo_dbh_txn_func rollback;
! 306: pdo_dbh_set_attr_func set_attribute;
! 307: pdo_dbh_last_id_func last_id;
! 308: pdo_dbh_fetch_error_func fetch_err;
! 309: pdo_dbh_get_attr_func get_attribute;
! 310: pdo_dbh_check_liveness_func check_liveness;
! 311: pdo_dbh_get_driver_methods_func get_driver_methods;
! 312: pdo_dbh_request_shutdown persistent_shutdown;
! 313: };
! 314:
! 315: /* }}} */
! 316:
! 317: /* {{{ methods for a statement handle */
! 318:
! 319: /* free the statement handle */
! 320: typedef int (*pdo_stmt_dtor_func)(pdo_stmt_t *stmt TSRMLS_DC);
! 321:
! 322: /* start the query */
! 323: typedef int (*pdo_stmt_execute_func)(pdo_stmt_t *stmt TSRMLS_DC);
! 324:
! 325: /* causes the next row in the set to be fetched; indicates if there are no
! 326: * more rows. The ori and offset params modify which row should be returned,
! 327: * if the stmt represents a scrollable cursor */
! 328: typedef int (*pdo_stmt_fetch_func)(pdo_stmt_t *stmt,
! 329: enum pdo_fetch_orientation ori, long offset TSRMLS_DC);
! 330:
! 331: /* queries information about the type of a column, by index (0 based).
! 332: * Driver should populate stmt->columns[colno] with appropriate info */
! 333: typedef int (*pdo_stmt_describe_col_func)(pdo_stmt_t *stmt, int colno TSRMLS_DC);
! 334:
! 335: /* retrieves pointer and size of the value for a column.
! 336: * Note that PDO expects the driver to manage the lifetime of this data;
! 337: * it will copy the value into a zval on behalf of the script.
! 338: * If the driver sets caller_frees, ptr should point to emalloc'd memory
! 339: * and PDO will free it as soon as it is done using it.
! 340: */
! 341: typedef int (*pdo_stmt_get_col_data_func)(pdo_stmt_t *stmt, int colno, char **ptr, unsigned long *len, int *caller_frees TSRMLS_DC);
! 342:
! 343: /* hook for bound params */
! 344: enum pdo_param_event {
! 345: PDO_PARAM_EVT_ALLOC,
! 346: PDO_PARAM_EVT_FREE,
! 347: PDO_PARAM_EVT_EXEC_PRE,
! 348: PDO_PARAM_EVT_EXEC_POST,
! 349: PDO_PARAM_EVT_FETCH_PRE,
! 350: PDO_PARAM_EVT_FETCH_POST,
! 351: PDO_PARAM_EVT_NORMALIZE
! 352: };
! 353:
! 354: 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);
! 355:
! 356: /* setting of attributes */
! 357: typedef int (*pdo_stmt_set_attr_func)(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC);
! 358:
! 359: /* fetching of attributes */
! 360: typedef int (*pdo_stmt_get_attr_func)(pdo_stmt_t *stmt, long attr, zval *val TSRMLS_DC);
! 361:
! 362: /* retrieves meta data for a numbered column.
! 363: * Returns SUCCESS/FAILURE.
! 364: * On SUCCESS, fill in return_value with an array with the following fields.
! 365: * If a particular field is not supported, then the driver simply does not add it to
! 366: * the array, so that scripts can use isset() to check for it.
! 367: *
! 368: * ### this is just a rough first cut, and subject to change ###
! 369: *
! 370: * these are added by PDO itself, based on data from the describe handler:
! 371: * name => the column name
! 372: * len => the length/size of the column
! 373: * precision => precision of the column
! 374: * pdo_type => an integer, one of the PDO_PARAM_XXX values
! 375: *
! 376: * scale => the floating point scale
! 377: * table => the table for that column
! 378: * type => a string representation of the type, mapped to the PHP equivalent type name
! 379: * native_type => a string representation of the type, native style, if different from
! 380: * the mapped name.
! 381: * flags => an array of flags including zero or more of the following:
! 382: * primary_key, not_null, unique_key, multiple_key, unsigned, auto_increment, blob
! 383: *
! 384: * Any driver specific data should be returned using a prefixed key or value.
! 385: * Eg: custom data for the mysql driver would use either
! 386: * 'mysql:foobar' => 'some data' // to add a new key to the array
! 387: * or
! 388: * 'flags' => array('not_null', 'mysql:some_flag'); // to add data to an existing key
! 389: */
! 390: typedef int (*pdo_stmt_get_column_meta_func)(pdo_stmt_t *stmt, long colno, zval *return_value TSRMLS_DC);
! 391:
! 392: /* advances the statement to the next rowset of the batch.
! 393: * If it returns 1, PDO will tear down its idea of columns
! 394: * and meta data. If it returns 0, PDO will indicate an error
! 395: * to the caller. */
! 396: typedef int (*pdo_stmt_next_rowset_func)(pdo_stmt_t *stmt TSRMLS_DC);
! 397:
! 398: /* closes the active cursor on a statement, leaving the prepared
! 399: * statement ready for re-execution. Useful to explicitly state
! 400: * that you are done with a given rowset, without having to explicitly
! 401: * fetch all the rows. */
! 402: typedef int (*pdo_stmt_cursor_closer_func)(pdo_stmt_t *stmt TSRMLS_DC);
! 403:
! 404: struct pdo_stmt_methods {
! 405: pdo_stmt_dtor_func dtor;
! 406: pdo_stmt_execute_func executer;
! 407: pdo_stmt_fetch_func fetcher;
! 408: pdo_stmt_describe_col_func describer;
! 409: pdo_stmt_get_col_data_func get_col;
! 410: pdo_stmt_param_hook_func param_hook;
! 411: pdo_stmt_set_attr_func set_attribute;
! 412: pdo_stmt_get_attr_func get_attribute;
! 413: pdo_stmt_get_column_meta_func get_column_meta;
! 414: pdo_stmt_next_rowset_func next_rowset;
! 415: pdo_stmt_cursor_closer_func cursor_closer;
! 416: };
! 417:
! 418: /* }}} */
! 419:
! 420: enum pdo_placeholder_support {
! 421: PDO_PLACEHOLDER_NONE=0,
! 422: PDO_PLACEHOLDER_NAMED=1,
! 423: PDO_PLACEHOLDER_POSITIONAL=2
! 424: };
! 425:
! 426: /* represents a connection to a database */
! 427: struct _pdo_dbh_t {
! 428: /* these items must appear in this order at the beginning of the
! 429: struct so that this can be cast as a zend_object. we need this
! 430: to allow the extending class to escape all the custom handlers
! 431: that PDO declares.
! 432: */
! 433: zend_class_entry *ce;
! 434: HashTable *properties;
! 435: unsigned int in_get:1;
! 436: unsigned int in_set:1;
! 437:
! 438: /* driver specific methods */
! 439: struct pdo_dbh_methods *methods;
! 440: /* driver specific data */
! 441: void *driver_data;
! 442:
! 443: /* credentials */
! 444: char *username, *password;
! 445:
! 446: /* if true, then data stored and pointed at by this handle must all be
! 447: * persistently allocated */
! 448: unsigned is_persistent:1;
! 449:
! 450: /* if true, driver should act as though a COMMIT were executed between
! 451: * each executed statement; otherwise, COMMIT must be carried out manually
! 452: * */
! 453: unsigned auto_commit:1;
! 454:
! 455: /* if true, the handle has been closed and will not function anymore */
! 456: unsigned is_closed:1;
! 457:
! 458: /* if true, the driver requires that memory be allocated explicitly for
! 459: * the columns that are returned */
! 460: unsigned alloc_own_columns:1;
! 461:
! 462: /* if true, commit or rollBack is allowed to be called */
! 463: unsigned in_txn:1;
! 464:
! 465: /* max length a single character can become after correct quoting */
! 466: unsigned max_escaped_char_length:3;
! 467:
! 468: /* oracle compat; see enum pdo_null_handling */
! 469: unsigned oracle_nulls:2;
! 470:
! 471: /* when set, convert int/floats to strings */
! 472: unsigned stringify:1;
! 473:
! 474: /* the sum of the number of bits here and the bit fields preceeding should
! 475: * equal 32 */
! 476: unsigned _reserved_flags:21;
! 477:
! 478: /* data source string used to open this handle */
! 479: const char *data_source;
! 480: unsigned long data_source_len;
! 481:
! 482: /* the global error code. */
! 483: pdo_error_type error_code;
! 484:
! 485: enum pdo_error_mode error_mode;
! 486:
! 487: enum pdo_case_conversion native_case, desired_case;
! 488:
! 489: /* persistent hash key associated with this handle */
! 490: const char *persistent_id;
! 491: int persistent_id_len;
! 492: unsigned int refcount;
! 493:
! 494: /* driver specific "class" methods for the dbh and stmt */
! 495: HashTable *cls_methods[PDO_DBH_DRIVER_METHOD_KIND__MAX];
! 496:
! 497: pdo_driver_t *driver;
! 498:
! 499: zend_class_entry *def_stmt_ce;
! 500:
! 501: zval *def_stmt_ctor_args;
! 502:
! 503: /* when calling PDO::query(), we need to keep the error
! 504: * context from the statement around until we next clear it.
! 505: * This will allow us to report the correct error message
! 506: * when PDO::query() fails */
! 507: pdo_stmt_t *query_stmt;
! 508: zval query_stmt_zval;
! 509:
! 510: /* defaults for fetches */
! 511: enum pdo_fetch_type default_fetch_type;
! 512: };
! 513:
! 514: /* describes a column */
! 515: struct pdo_column_data {
! 516: char *name;
! 517: int namelen;
! 518: unsigned long maxlen;
! 519: enum pdo_param_type param_type;
! 520: unsigned long precision;
! 521:
! 522: /* don't touch this unless your name is dbdo */
! 523: void *dbdo_data;
! 524: };
! 525:
! 526: /* describes a bound parameter */
! 527: struct pdo_bound_param_data {
! 528: long paramno; /* if -1, then it has a name, and we don't know the index *yet* */
! 529: char *name;
! 530: int namelen;
! 531:
! 532: long max_value_len; /* as a hint for pre-allocation */
! 533:
! 534: zval *parameter; /* the variable itself */
! 535: enum pdo_param_type param_type; /* desired or suggested type */
! 536:
! 537: zval *driver_params; /* optional parameter(s) for the driver */
! 538: void *driver_data;
! 539:
! 540: pdo_stmt_t *stmt; /* for convenience in dtor */
! 541: int is_param; /* parameter or column ? */
! 542: };
! 543:
! 544: /* represents a prepared statement */
! 545: struct _pdo_stmt_t {
! 546: /* these items must appear in this order at the beginning of the
! 547: struct so that this can be cast as a zend_object. we need this
! 548: to allow the extending class to escape all the custom handlers
! 549: that PDO declares.
! 550: */
! 551: zend_class_entry *ce;
! 552: HashTable *properties;
! 553: unsigned int in_get:1;
! 554: unsigned int in_set:1;
! 555:
! 556: /* driver specifics */
! 557: struct pdo_stmt_methods *methods;
! 558: void *driver_data;
! 559:
! 560: /* if true, we've already successfully executed this statement at least
! 561: * once */
! 562: unsigned executed:1;
! 563: /* if true, the statement supports placeholders and can implement
! 564: * bindParam() for its prepared statements, if false, PDO should
! 565: * emulate prepare and bind on its behalf */
! 566: unsigned supports_placeholders:2;
! 567:
! 568: unsigned _reserved:29;
! 569:
! 570: /* the number of columns in the result set; not valid until after
! 571: * the statement has been executed at least once. In some cases, might
! 572: * not be valid until fetch (at the driver level) has been called at least once.
! 573: * */
! 574: int column_count;
! 575: struct pdo_column_data *columns;
! 576:
! 577: /* we want to keep the dbh alive while we live, so we own a reference */
! 578: zval database_object_handle;
! 579: pdo_dbh_t *dbh;
! 580:
! 581: /* keep track of bound input parameters. Some drivers support
! 582: * input/output parameters, but you can't rely on that working */
! 583: HashTable *bound_params;
! 584: /* When rewriting from named to positional, this maps positions to names */
! 585: HashTable *bound_param_map;
! 586: /* keep track of PHP variables bound to named (or positional) columns
! 587: * in the result set */
! 588: HashTable *bound_columns;
! 589:
! 590: /* not always meaningful */
! 591: long row_count;
! 592:
! 593: /* used to hold the statement's current query */
! 594: char *query_string;
! 595: int query_stringlen;
! 596:
! 597: /* the copy of the query with expanded binds ONLY for emulated-prepare drivers */
! 598: char *active_query_string;
! 599: int active_query_stringlen;
! 600:
! 601: /* the cursor specific error code. */
! 602: pdo_error_type error_code;
! 603:
! 604: /* for lazy fetches, we always return the same lazy object handle.
! 605: * Let's keep it here. */
! 606: zval lazy_object_ref;
! 607: unsigned long refcount;
! 608:
! 609: /* defaults for fetches */
! 610: enum pdo_fetch_type default_fetch_type;
! 611: union {
! 612: int column;
! 613: struct {
! 614: zend_class_entry *ce;
! 615: zval *ctor_args; /* freed */
! 616: zval *retval_ptr;
! 617: zend_fcall_info fci;
! 618: zend_fcall_info_cache fcc;
! 619: } cls;
! 620: struct {
! 621: zval *function;
! 622: zval *fetch_args; /* freed */
! 623: zval *object;
! 624: zend_fcall_info fci;
! 625: zend_fcall_info_cache fcc;
! 626: zval **values; /* freed */
! 627: } func;
! 628: zval *into;
! 629: } fetch;
! 630:
! 631: /* used by the query parser for driver specific
! 632: * parameter naming (see pgsql driver for example) */
! 633: const char *named_rewrite_template;
! 634: };
! 635:
! 636: /* call this in MINIT to register your PDO driver */
! 637: PDO_API int php_pdo_register_driver(pdo_driver_t *driver);
! 638: /* call this in MSHUTDOWN to unregister your PDO driver */
! 639: PDO_API void php_pdo_unregister_driver(pdo_driver_t *driver);
! 640:
! 641: /* For the convenience of drivers, this function will parse a data source
! 642: * string, of the form "name=value; name2=value2" and populate variables
! 643: * according to the data you pass in and array of pdo_data_src_parser structures */
! 644: struct pdo_data_src_parser {
! 645: const char *optname;
! 646: char *optval;
! 647: int freeme;
! 648: };
! 649:
! 650: PDO_API int php_pdo_parse_data_source(const char *data_source,
! 651: unsigned long data_source_len, struct pdo_data_src_parser *parsed,
! 652: int nparams);
! 653:
! 654: PDO_API zend_class_entry *php_pdo_get_dbh_ce(void);
! 655: PDO_API zend_class_entry *php_pdo_get_exception(void);
! 656:
! 657: PDO_API int pdo_parse_params(pdo_stmt_t *stmt, char *inquery, int inquery_len,
! 658: char **outquery, int *outquery_len TSRMLS_DC);
! 659:
! 660: PDO_API void pdo_raise_impl_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt,
! 661: const char *sqlstate, const char *supp TSRMLS_DC);
! 662:
! 663: PDO_API void php_pdo_dbh_addref(pdo_dbh_t *dbh TSRMLS_DC);
! 664: PDO_API void php_pdo_dbh_delref(pdo_dbh_t *dbh TSRMLS_DC);
! 665:
! 666: PDO_API void php_pdo_stmt_addref(pdo_stmt_t *stmt TSRMLS_DC);
! 667: PDO_API void php_pdo_stmt_delref(pdo_stmt_t *stmt TSRMLS_DC);
! 668:
! 669:
! 670: #endif /* PHP_PDO_DRIVER_H */
! 671: /*
! 672: * Local variables:
! 673: * tab-width: 4
! 674: * c-basic-offset: 4
! 675: * End:
! 676: * vim600: noet sw=4 ts=4 fdm=marker
! 677: * vim<600: noet sw=4 ts=4
! 678: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to php_pdo_driver.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / pdo