PageRenderTime 61ms CodeModel.GetById 21ms app.highlight 17ms RepoModel.GetById 13ms app.codeStats 0ms

/stubs/PDO.php

http://github.com/nnmatveev/php-stubs
PHP | 1277 lines | 146 code | 124 blank | 1007 comment | 0 complexity | d0f662f174c0b7c72fef65411e9f6632 MD5 | raw file
   1<?php
   2
   3// Start of PDO v.1.0.4dev
   4
   5/**
   6 * Represents an error raised by PDO. You should not throw a
   7 * PDOException from your own code.
   8 * See Exceptions for more
   9 * information about Exceptions in PHP.
  10 * @link http://php.net/manual/en/class.pdoexception.php
  11 */
  12class PDOException extends RuntimeException  {
  13	protected $message;
  14	protected $code;
  15	protected $file;
  16	protected $line;
  17	public $errorInfo;
  18
  19
  20	/**
  21	 * (PHP 5 &gt;= 5.1.0)<br/>
  22	 * Clone the exception
  23	 * @link http://php.net/manual/en/exception.clone.php
  24	 * @return void 
  25	 */
  26	final private function __clone () {}
  27
  28	/**
  29	 * (PHP 5 &gt;= 5.1.0)<br/>
  30	 * Construct the exception
  31	 * @link http://php.net/manual/en/exception.construct.php
  32	 * @param $message [optional]
  33	 * @param $code [optional]
  34	 * @param $previous [optional]
  35	 */
  36	public function __construct ($message, $code, $previous) {}
  37
  38	/**
  39	 * (PHP 5 &gt;= 5.1.0)<br/>
  40	 * Gets the Exception message
  41	 * @link http://php.net/manual/en/exception.getmessage.php
  42	 * @return string the Exception message as a string.
  43	 */
  44	final public function getMessage () {}
  45
  46	/**
  47	 * (PHP 5 &gt;= 5.1.0)<br/>
  48	 * Gets the Exception code
  49	 * @link http://php.net/manual/en/exception.getcode.php
  50	 * @return int the Exception code as a integer.
  51	 */
  52	final public function getCode () {}
  53
  54	/**
  55	 * (PHP 5 &gt;= 5.1.0)<br/>
  56	 * Gets the file in which the exception occurred
  57	 * @link http://php.net/manual/en/exception.getfile.php
  58	 * @return string the filename in which the exception was thrown.
  59	 */
  60	final public function getFile () {}
  61
  62	/**
  63	 * (PHP 5 &gt;= 5.1.0)<br/>
  64	 * Gets the line in which the exception occurred
  65	 * @link http://php.net/manual/en/exception.getline.php
  66	 * @return int the line number where the exception was thrown.
  67	 */
  68	final public function getLine () {}
  69
  70	/**
  71	 * (PHP 5 &gt;= 5.1.0)<br/>
  72	 * Gets the stack trace
  73	 * @link http://php.net/manual/en/exception.gettrace.php
  74	 * @return array the Exception stack trace as an array.
  75	 */
  76	final public function getTrace () {}
  77
  78	/**
  79	 * (PHP 5 &gt;= 5.3.0)<br/>
  80	 * Returns previous Exception
  81	 * @link http://php.net/manual/en/exception.getprevious.php
  82	 * @return Exception the previous Exception if available 
  83	 * or &null; otherwise.
  84	 */
  85	final public function getPrevious () {}
  86
  87	/**
  88	 * (PHP 5 &gt;= 5.1.0)<br/>
  89	 * Gets the stack trace as a string
  90	 * @link http://php.net/manual/en/exception.gettraceasstring.php
  91	 * @return string the Exception stack trace as a string.
  92	 */
  93	final public function getTraceAsString () {}
  94
  95	/**
  96	 * (PHP 5 &gt;= 5.1.0)<br/>
  97	 * String representation of the exception
  98	 * @link http://php.net/manual/en/exception.tostring.php
  99	 * @return string the string representation of the exception.
 100	 */
 101	public function __toString () {}
 102
 103}
 104
 105/**
 106 * Represents a connection between PHP and a database server.
 107 * @link http://php.net/manual/en/class.pdo.php
 108 */
 109class PDO  {
 110
 111	/**
 112	 * Represents a boolean data type.
 113	 * @link http://php.net/manual/en/pdo.constants.php
 114	 */
 115	const PARAM_BOOL = 5;
 116
 117	/**
 118	 * Represents the SQL NULL data type.
 119	 * @link http://php.net/manual/en/pdo.constants.php
 120	 */
 121	const PARAM_NULL = 0;
 122
 123	/**
 124	 * Represents the SQL INTEGER data type.
 125	 * @link http://php.net/manual/en/pdo.constants.php
 126	 */
 127	const PARAM_INT = 1;
 128
 129	/**
 130	 * Represents the SQL CHAR, VARCHAR, or other string data type.
 131	 * @link http://php.net/manual/en/pdo.constants.php
 132	 */
 133	const PARAM_STR = 2;
 134
 135	/**
 136	 * Represents the SQL large object data type.
 137	 * @link http://php.net/manual/en/pdo.constants.php
 138	 */
 139	const PARAM_LOB = 3;
 140
 141	/**
 142	 * Represents a recordset type. Not currently supported by any drivers.
 143	 * @link http://php.net/manual/en/pdo.constants.php
 144	 */
 145	const PARAM_STMT = 4;
 146
 147	/**
 148	 * Specifies that the parameter is an INOUT parameter for a stored
 149	 * procedure. You must bitwise-OR this value with an explicit
 150	 * PDO::PARAM_* data type.
 151	 * @link http://php.net/manual/en/pdo.constants.php
 152	 */
 153	const PARAM_INPUT_OUTPUT = 2147483648;
 154
 155	/**
 156	 * Allocation event
 157	 * @link http://php.net/manual/en/pdo.constants.php
 158	 */
 159	const PARAM_EVT_ALLOC = 0;
 160
 161	/**
 162	 * Deallocation event
 163	 * @link http://php.net/manual/en/pdo.constants.php
 164	 */
 165	const PARAM_EVT_FREE = 1;
 166
 167	/**
 168	 * Event triggered prior to execution of a prepared statement.
 169	 * @link http://php.net/manual/en/pdo.constants.php
 170	 */
 171	const PARAM_EVT_EXEC_PRE = 2;
 172
 173	/**
 174	 * Event triggered subsequent to execution of a prepared statement.
 175	 * @link http://php.net/manual/en/pdo.constants.php
 176	 */
 177	const PARAM_EVT_EXEC_POST = 3;
 178
 179	/**
 180	 * Event triggered prior to fetching a result from a resultset.
 181	 * @link http://php.net/manual/en/pdo.constants.php
 182	 */
 183	const PARAM_EVT_FETCH_PRE = 4;
 184
 185	/**
 186	 * Event triggered subsequent to fetching a result from a resultset.
 187	 * @link http://php.net/manual/en/pdo.constants.php
 188	 */
 189	const PARAM_EVT_FETCH_POST = 5;
 190
 191	/**
 192	 * Event triggered during bound parameter registration
 193	 * allowing the driver to normalize the parameter name.
 194	 * @link http://php.net/manual/en/pdo.constants.php
 195	 */
 196	const PARAM_EVT_NORMALIZE = 6;
 197
 198	/**
 199	 * Specifies that the fetch method shall return each row as an object with
 200	 * variable names that correspond to the column names returned in the result
 201	 * set. PDO::FETCH_LAZY creates the object variable names as they are accessed.
 202	 * @link http://php.net/manual/en/pdo.constants.php
 203	 */
 204	const FETCH_LAZY = 1;
 205
 206	/**
 207	 * Specifies that the fetch method shall return each row as an array indexed
 208	 * by column name as returned in the corresponding result set. If the result
 209	 * set contains multiple columns with the same name,
 210	 * PDO::FETCH_ASSOC returns
 211	 * only a single value per column name.
 212	 * @link http://php.net/manual/en/pdo.constants.php
 213	 */
 214	const FETCH_ASSOC = 2;
 215
 216	/**
 217	 * Specifies that the fetch method shall return each row as an array indexed
 218	 * by column number as returned in the corresponding result set, starting at
 219	 * column 0.
 220	 * @link http://php.net/manual/en/pdo.constants.php
 221	 */
 222	const FETCH_NUM = 3;
 223
 224	/**
 225	 * Specifies that the fetch method shall return each row as an array indexed
 226	 * by both column name and number as returned in the corresponding result set,
 227	 * starting at column 0.
 228	 * @link http://php.net/manual/en/pdo.constants.php
 229	 */
 230	const FETCH_BOTH = 4;
 231
 232	/**
 233	 * Specifies that the fetch method shall return each row as an object with
 234	 * property names that correspond to the column names returned in the result
 235	 * set.
 236	 * @link http://php.net/manual/en/pdo.constants.php
 237	 */
 238	const FETCH_OBJ = 5;
 239
 240	/**
 241	 * Specifies that the fetch method shall return TRUE and assign the values of
 242	 * the columns in the result set to the PHP variables to which they were
 243	 * bound with the PDOStatement::bindParam or
 244	 * PDOStatement::bindColumn methods.
 245	 * @link http://php.net/manual/en/pdo.constants.php
 246	 */
 247	const FETCH_BOUND = 6;
 248
 249	/**
 250	 * Specifies that the fetch method shall return only a single requested
 251	 * column from the next row in the result set.
 252	 * @link http://php.net/manual/en/pdo.constants.php
 253	 */
 254	const FETCH_COLUMN = 7;
 255
 256	/**
 257	 * Specifies that the fetch method shall return a new instance of the
 258	 * requested class, mapping the columns to named properties in the class.
 259	 * The magic
 260	 * __set
 261	 * method is called if the property doesn't exist in the requested class
 262	 * @link http://php.net/manual/en/pdo.constants.php
 263	 */
 264	const FETCH_CLASS = 8;
 265
 266	/**
 267	 * Specifies that the fetch method shall update an existing instance of the
 268	 * requested class, mapping the columns to named properties in the class.
 269	 * @link http://php.net/manual/en/pdo.constants.php
 270	 */
 271	const FETCH_INTO = 9;
 272	const FETCH_FUNC = 10;
 273	const FETCH_GROUP = 65536;
 274	const FETCH_UNIQUE = 196608;
 275
 276	/**
 277	 * Fetch into an array where the 1st column is a key and all subsequent
 278	 * columns are values. Available since PHP 5.2.3.
 279	 * @link http://php.net/manual/en/pdo.constants.php
 280	 */
 281	const FETCH_KEY_PAIR = 12;
 282
 283	/**
 284	 * Determine the class name from the value of first column.
 285	 * @link http://php.net/manual/en/pdo.constants.php
 286	 */
 287	const FETCH_CLASSTYPE = 262144;
 288
 289	/**
 290	 * As PDO::FETCH_INTO but object is provided as a serialized string.
 291	 * Available since PHP 5.1.0.
 292	 * @link http://php.net/manual/en/pdo.constants.php
 293	 */
 294	const FETCH_SERIALIZE = 524288;
 295
 296	/**
 297	 * Available since PHP 5.2.0
 298	 * @link http://php.net/manual/en/pdo.constants.php
 299	 */
 300	const FETCH_PROPS_LATE = 1048576;
 301
 302	/**
 303	 * Specifies that the fetch method shall return each row as an array indexed
 304	 * by column name as returned in the corresponding result set. If the result
 305	 * set contains multiple columns with the same name,
 306	 * PDO::FETCH_NAMED returns
 307	 * an array of values per column name.
 308	 * @link http://php.net/manual/en/pdo.constants.php
 309	 */
 310	const FETCH_NAMED = 11;
 311
 312	/**
 313	 * If this value is false, PDO attempts to disable autocommit so that the
 314	 * connection begins a transaction.
 315	 * @link http://php.net/manual/en/pdo.constants.php
 316	 */
 317	const ATTR_AUTOCOMMIT = 0;
 318
 319	/**
 320	 * Setting the prefetch size allows you to balance speed against memory
 321	 * usage for your application. Not all database/driver combinations support
 322	 * setting of the prefetch size. A larger prefetch size results in
 323	 * increased performance at the cost of higher memory usage.
 324	 * @link http://php.net/manual/en/pdo.constants.php
 325	 */
 326	const ATTR_PREFETCH = 1;
 327
 328	/**
 329	 * Sets the timeout value in seconds for communications with the database.
 330	 * @link http://php.net/manual/en/pdo.constants.php
 331	 */
 332	const ATTR_TIMEOUT = 2;
 333
 334	/**
 335	 * See the Errors and error
 336	 * handling section for more information about this attribute.
 337	 * @link http://php.net/manual/en/pdo.constants.php
 338	 */
 339	const ATTR_ERRMODE = 3;
 340
 341	/**
 342	 * This is a read only attribute; it will return information about the
 343	 * version of the database server to which PDO is connected.
 344	 * @link http://php.net/manual/en/pdo.constants.php
 345	 */
 346	const ATTR_SERVER_VERSION = 4;
 347
 348	/**
 349	 * This is a read only attribute; it will return information about the
 350	 * version of the client libraries that the PDO driver is using.
 351	 * @link http://php.net/manual/en/pdo.constants.php
 352	 */
 353	const ATTR_CLIENT_VERSION = 5;
 354
 355	/**
 356	 * This is a read only attribute; it will return some meta information about the
 357	 * database server to which PDO is connected.
 358	 * @link http://php.net/manual/en/pdo.constants.php
 359	 */
 360	const ATTR_SERVER_INFO = 6;
 361	const ATTR_CONNECTION_STATUS = 7;
 362
 363	/**
 364	 * Force column names to a specific case specified by the PDO::CASE_*
 365	 * constants.
 366	 * @link http://php.net/manual/en/pdo.constants.php
 367	 */
 368	const ATTR_CASE = 8;
 369
 370	/**
 371	 * Get or set the name to use for a cursor. Most useful when using
 372	 * scrollable cursors and positioned updates.
 373	 * @link http://php.net/manual/en/pdo.constants.php
 374	 */
 375	const ATTR_CURSOR_NAME = 9;
 376
 377	/**
 378	 * Selects the cursor type. PDO currently supports either
 379	 * PDO::CURSOR_FWDONLY and 
 380	 * PDO::CURSOR_SCROLL. Stick with
 381	 * PDO::CURSOR_FWDONLY unless you know that you need a
 382	 * scrollable cursor.
 383	 * @link http://php.net/manual/en/pdo.constants.php
 384	 */
 385	const ATTR_CURSOR = 10;
 386
 387	/**
 388	 * Convert empty strings to SQL NULL values on data fetches.
 389	 * @link http://php.net/manual/en/pdo.constants.php
 390	 */
 391	const ATTR_ORACLE_NULLS = 11;
 392
 393	/**
 394	 * Request a persistent connection, rather than creating a new connection.
 395	 * See Connections and Connection
 396	 * management for more information on this attribute.
 397	 * @link http://php.net/manual/en/pdo.constants.php
 398	 */
 399	const ATTR_PERSISTENT = 12;
 400	const ATTR_STATEMENT_CLASS = 13;
 401
 402	/**
 403	 * Prepend the containing table name to each column name returned in the
 404	 * result set. The table name and column name are separated by a decimal (.)
 405	 * character. Support of this attribute is at the driver level; it may not
 406	 * be supported by your driver.
 407	 * @link http://php.net/manual/en/pdo.constants.php
 408	 */
 409	const ATTR_FETCH_TABLE_NAMES = 14;
 410
 411	/**
 412	 * Prepend the containing catalog name to each column name returned in the
 413	 * result set. The catalog name and column name are separated by a decimal
 414	 * (.) character. Support of this attribute is at the driver level; it may
 415	 * not be supported by your driver.
 416	 * @link http://php.net/manual/en/pdo.constants.php
 417	 */
 418	const ATTR_FETCH_CATALOG_NAMES = 15;
 419
 420	/**
 421	 * Returns the name of the driver.
 422	 * <p>
 423	 * using PDO::ATTR_DRIVER_NAME
 424	 * getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
 425	 * echo "Running on mysql; doing something mysql specific here\n";
 426	 * }
 427	 * ?>
 428	 * ]]>
 429	 * </p>
 430	 * @link http://php.net/manual/en/pdo.constants.php
 431	 */
 432	const ATTR_DRIVER_NAME = 16;
 433	const ATTR_STRINGIFY_FETCHES = 17;
 434	const ATTR_MAX_COLUMN_LEN = 18;
 435
 436	/**
 437	 * Available since PHP 5.1.3.
 438	 * @link http://php.net/manual/en/pdo.constants.php
 439	 */
 440	const ATTR_EMULATE_PREPARES = 20;
 441
 442	/**
 443	 * Available since PHP 5.2.0
 444	 * @link http://php.net/manual/en/pdo.constants.php
 445	 */
 446	const ATTR_DEFAULT_FETCH_MODE = 19;
 447
 448	/**
 449	 * Do not raise an error or exception if an error occurs. The developer is
 450	 * expected to explicitly check for errors. This is the default mode.
 451	 * See Errors and error handling
 452	 * for more information about this attribute.
 453	 * @link http://php.net/manual/en/pdo.constants.php
 454	 */
 455	const ERRMODE_SILENT = 0;
 456
 457	/**
 458	 * Issue a PHP E_WARNING message if an error occurs.
 459	 * See Errors and error handling
 460	 * for more information about this attribute.
 461	 * @link http://php.net/manual/en/pdo.constants.php
 462	 */
 463	const ERRMODE_WARNING = 1;
 464
 465	/**
 466	 * Throw a PDOException if an error occurs.
 467	 * See Errors and error handling
 468	 * for more information about this attribute.
 469	 * @link http://php.net/manual/en/pdo.constants.php
 470	 */
 471	const ERRMODE_EXCEPTION = 2;
 472
 473	/**
 474	 * Leave column names as returned by the database driver.
 475	 * @link http://php.net/manual/en/pdo.constants.php
 476	 */
 477	const CASE_NATURAL = 0;
 478
 479	/**
 480	 * Force column names to lower case.
 481	 * @link http://php.net/manual/en/pdo.constants.php
 482	 */
 483	const CASE_LOWER = 2;
 484
 485	/**
 486	 * Force column names to upper case.
 487	 * @link http://php.net/manual/en/pdo.constants.php
 488	 */
 489	const CASE_UPPER = 1;
 490	const NULL_NATURAL = 0;
 491	const NULL_EMPTY_STRING = 1;
 492	const NULL_TO_STRING = 2;
 493
 494	/**
 495	 * Corresponds to SQLSTATE '00000', meaning that the SQL statement was
 496	 * successfully issued with no errors or warnings. This constant is for
 497	 * your convenience when checking PDO::errorCode or
 498	 * PDOStatement::errorCode to determine if an error
 499	 * occurred. You will usually know if this is the case by examining the
 500	 * return code from the method that raised the error condition anyway.
 501	 * @link http://php.net/manual/en/pdo.constants.php
 502	 */
 503	const ERR_NONE = 00000;
 504
 505	/**
 506	 * Fetch the next row in the result set. Valid only for scrollable cursors.
 507	 * @link http://php.net/manual/en/pdo.constants.php
 508	 */
 509	const FETCH_ORI_NEXT = 0;
 510
 511	/**
 512	 * Fetch the previous row in the result set. Valid only for scrollable
 513	 * cursors.
 514	 * @link http://php.net/manual/en/pdo.constants.php
 515	 */
 516	const FETCH_ORI_PRIOR = 1;
 517
 518	/**
 519	 * Fetch the first row in the result set. Valid only for scrollable cursors.
 520	 * @link http://php.net/manual/en/pdo.constants.php
 521	 */
 522	const FETCH_ORI_FIRST = 2;
 523
 524	/**
 525	 * Fetch the last row in the result set. Valid only for scrollable cursors.
 526	 * @link http://php.net/manual/en/pdo.constants.php
 527	 */
 528	const FETCH_ORI_LAST = 3;
 529
 530	/**
 531	 * Fetch the requested row by row number from the result set. Valid only
 532	 * for scrollable cursors.
 533	 * @link http://php.net/manual/en/pdo.constants.php
 534	 */
 535	const FETCH_ORI_ABS = 4;
 536
 537	/**
 538	 * Fetch the requested row by relative position from the current position
 539	 * of the cursor in the result set. Valid only for scrollable cursors.
 540	 * @link http://php.net/manual/en/pdo.constants.php
 541	 */
 542	const FETCH_ORI_REL = 5;
 543
 544	/**
 545	 * Create a PDOStatement object with a forward-only cursor. This is the
 546	 * default cursor choice, as it is the fastest and most common data access
 547	 * pattern in PHP.
 548	 * @link http://php.net/manual/en/pdo.constants.php
 549	 */
 550	const CURSOR_FWDONLY = 0;
 551
 552	/**
 553	 * Create a PDOStatement object with a scrollable cursor. Pass the
 554	 * PDO::FETCH_ORI_* constants to control the rows fetched from the result set.
 555	 * @link http://php.net/manual/en/pdo.constants.php
 556	 */
 557	const CURSOR_SCROLL = 1;
 558
 559	/**
 560	 * If this attribute is set to true on a
 561	 * PDOStatement, the MySQL driver will use the
 562	 * buffered versions of the MySQL API. If you're writing portable code, you
 563	 * should use PDOStatement::fetchAll instead.
 564	 * <p>
 565	 * Forcing queries to be buffered in mysql
 566	 * getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
 567	 * $stmt = $db->prepare('select * from foo',
 568	 * array(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true));
 569	 * } else {
 570	 * die("my application only works with mysql; I should use \$stmt->fetchAll() instead");
 571	 * }
 572	 * ?>
 573	 * ]]>
 574	 * </p>
 575	 * @link http://php.net/manual/en/pdo-mysql.constants.php
 576	 */
 577	const MYSQL_ATTR_USE_BUFFERED_QUERY = 1000;
 578
 579	/**
 580	 * <p>
 581	 * Enable LOAD LOCAL INFILE.
 582	 * </p>
 583	 * @link http://php.net/manual/en/pdo-mysql.constants.php
 584	 */
 585	const MYSQL_ATTR_LOCAL_INFILE = 1001;
 586
 587	/**
 588	 * <p>
 589	 * Command to execute when connecting to the MySQL server. Will
 590	 * automatically be re-executed when reconnecting.
 591	 * </p>
 592	 * @link http://php.net/manual/en/pdo-mysql.constants.php
 593	 */
 594	const MYSQL_ATTR_INIT_COMMAND = 1002;
 595
 596	/**
 597	 * <p>
 598	 * Perform direct queries, don't use prepared statements.
 599	 * </p>
 600	 * @link http://php.net/manual/en/pdo-mysql.constants.php
 601	 */
 602	const MYSQL_ATTR_DIRECT_QUERY = 1003;
 603	const MYSQL_ATTR_FOUND_ROWS = 1004;
 604	const MYSQL_ATTR_IGNORE_SPACE = 1005;
 605	const ODBC_ATTR_USE_CURSOR_LIBRARY = 1000;
 606	const ODBC_ATTR_ASSUME_UTF8 = 1001;
 607	const ODBC_SQL_USE_IF_NEEDED = 0;
 608	const ODBC_SQL_USE_DRIVER = 2;
 609	const ODBC_SQL_USE_ODBC = 1;
 610	const PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT = 1000;
 611
 612
 613	/**
 614	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 615	 * Creates a PDO instance representing a connection to a database
 616	 * @link http://php.net/manual/en/pdo.construct.php
 617	 * @param $dsn
 618	 * @param $username [optional]
 619	 * @param $passwd [optional]
 620	 * @param $options [optional]
 621	 */
 622	public function __construct ($dsn, $username, $passwd, $options) {}
 623
 624	/**
 625	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 626	 * Prepares a statement for execution and returns a statement object
 627	 * @link http://php.net/manual/en/pdo.prepare.php
 628	 * @param string $statement <p>
 629	 * This must be a valid SQL statement for the target database server.
 630	 * </p>
 631	 * @param array $driver_options [optional] <p>
 632	 * This array holds one or more key=&gt;value pairs to set
 633	 * attribute values for the PDOStatement object that this method
 634	 * returns. You would most commonly use this to set the
 635	 * PDO::ATTR_CURSOR value to
 636	 * PDO::CURSOR_SCROLL to request a scrollable cursor.
 637	 * Some drivers have driver specific options that may be set at
 638	 * prepare-time.
 639	 * </p>
 640	 * @return PDOStatement If the database server successfully prepares the statement,
 641	 * PDO::prepare returns a
 642	 * PDOStatement object.
 643	 * If the database server cannot successfully prepare the statement,
 644	 * PDO::prepare returns false or emits
 645	 * PDOException (depending on error handling).
 646	 * </p>
 647	 * <p>
 648	 * Emulated prepared statements does not communicate with the database server
 649	 * so PDO::prepare does not check the statement.
 650	 */
 651	public function prepare ($statement, array $driver_options = null) {}
 652
 653	/**
 654	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 655	 * Initiates a transaction
 656	 * @link http://php.net/manual/en/pdo.begintransaction.php
 657	 * @return bool Returns true on success or false on failure.
 658	 */
 659	public function beginTransaction () {}
 660
 661	/**
 662	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 663	 * Commits a transaction
 664	 * @link http://php.net/manual/en/pdo.commit.php
 665	 * @return bool Returns true on success or false on failure.
 666	 */
 667	public function commit () {}
 668
 669	/**
 670	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 671	 * Rolls back a transaction
 672	 * @link http://php.net/manual/en/pdo.rollback.php
 673	 * @return bool Returns true on success or false on failure.
 674	 */
 675	public function rollBack () {}
 676
 677	/**
 678	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 679	 * Set an attribute
 680	 * @link http://php.net/manual/en/pdo.setattribute.php
 681	 * @param int $attribute 
 682	 * @param mixed $value 
 683	 * @return bool Returns true on success or false on failure.
 684	 */
 685	public function setAttribute ($attribute, $value) {}
 686
 687	/**
 688	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 689	 * Execute an SQL statement and return the number of affected rows
 690	 * @link http://php.net/manual/en/pdo.exec.php
 691	 * @param string $statement <p>
 692	 * The SQL statement to prepare and execute.
 693	 * </p>
 694	 * <p>
 695	 * Data inside the query should be properly escaped.
 696	 * </p>
 697	 * @return int PDO::exec returns the number of rows that were modified
 698	 * or deleted by the SQL statement you issued. If no rows were affected, 
 699	 * PDO::exec returns 0. 
 700	 * </p>
 701	 * &return.falseproblem;
 702	 * <p>
 703	 * The following example incorrectly relies on the return value of
 704	 * PDO::exec, wherein a statement that affected 0 rows
 705	 * results in a call to die:
 706	 * exec() or die(print_r($db->errorInfo(), true));
 707	 * ?>
 708	 * ]]>
 709	 */
 710	public function exec ($statement) {}
 711
 712	/**
 713	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.2.0)<br/>
 714	 * Executes an SQL statement, returning a result set as a PDOStatement object
 715	 * @link http://php.net/manual/en/pdo.query.php
 716	 * @param string $statement <p>
 717	 * The SQL statement to prepare and execute.
 718	 * </p>
 719	 * <p>
 720	 * Data inside the query should be properly escaped.
 721	 * </p>
 722	 * @return PDOStatement PDO::query returns a PDOStatement object, or false
 723	 * on failure.
 724	 */
 725	public function query ($statement) {}
 726
 727	/**
 728	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 729	 * Returns the ID of the last inserted row or sequence value
 730	 * @link http://php.net/manual/en/pdo.lastinsertid.php
 731	 * @param string $name [optional] <p>
 732	 * Name of the sequence object from which the ID should be returned.
 733	 * </p>
 734	 * @return string If a sequence name was not specified for the name
 735	 * parameter, PDO::lastInsertId returns a
 736	 * string representing the row ID of the last row that was inserted into
 737	 * the database.
 738	 * </p>
 739	 * <p>
 740	 * If a sequence name was specified for the name
 741	 * parameter, PDO::lastInsertId returns a
 742	 * string representing the last value retrieved from the specified sequence
 743	 * object.
 744	 * </p>
 745	 * <p>
 746	 * If the PDO driver does not support this capability,
 747	 * PDO::lastInsertId triggers an
 748	 * IM001 SQLSTATE.
 749	 */
 750	public function lastInsertId ($name = null) {}
 751
 752	/**
 753	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 754	 * Fetch the SQLSTATE associated with the last operation on the database handle
 755	 * @link http://php.net/manual/en/pdo.errorcode.php
 756	 * @return mixed a SQLSTATE, a five characters alphanumeric identifier defined in
 757	 * the ANSI SQL-92 standard. Briefly, an SQLSTATE consists of a
 758	 * two characters class value followed by a three characters subclass value. A
 759	 * class value of 01 indicates a warning and is accompanied by a return code
 760	 * of SQL_SUCCESS_WITH_INFO. Class values other than '01', except for the
 761	 * class 'IM', indicate an error. The class 'IM' is specific to warnings
 762	 * and errors that derive from the implementation of PDO (or perhaps ODBC,
 763	 * if you're using the ODBC driver) itself. The subclass value '000' in any
 764	 * class indicates that there is no subclass for that SQLSTATE.
 765	 * </p>
 766	 * <p>
 767	 * PDO::errorCode only retrieves error codes for operations
 768	 * performed directly on the database handle. If you create a PDOStatement
 769	 * object through PDO::prepare or
 770	 * PDO::query and invoke an error on the statement
 771	 * handle, PDO::errorCode will not reflect that error.
 772	 * You must call PDOStatement::errorCode to return the error
 773	 * code for an operation performed on a particular statement handle.
 774	 * </p>
 775	 * <p>
 776	 * Returns &null; if no operation has been run on the database handle.
 777	 */
 778	public function errorCode () {}
 779
 780	/**
 781	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 782	 * Fetch extended error information associated with the last operation on the database handle
 783	 * @link http://php.net/manual/en/pdo.errorinfo.php
 784	 * @return array PDO::errorInfo returns an array of error information
 785	 * about the last operation performed by this database handle. The array
 786	 * consists of the following fields:
 787	 * <tr valign="top">
 788	 * <td>Element</td>
 789	 * <td>Information</td>
 790	 * </tr>
 791	 * <tr valign="top">
 792	 * <td>0</td>
 793	 * <td>SQLSTATE error code (a five characters alphanumeric identifier defined
 794	 * in the ANSI SQL standard).</td>
 795	 * </tr>
 796	 * <tr valign="top">
 797	 * <td>1</td>
 798	 * <td>Driver-specific error code.</td>
 799	 * </tr>
 800	 * <tr valign="top">
 801	 * <td>2</td>
 802	 * <td>Driver-specific error message.</td>
 803	 * </tr>
 804	 * </p>
 805	 * <p>
 806	 * If the SQLSTATE error code is not set or there is no driver-specific
 807	 * error, the elements following element 0 will be set to &null;.
 808	 * </p>
 809	 * <p>
 810	 * PDO::errorInfo only retrieves error information for
 811	 * operations performed directly on the database handle. If you create a
 812	 * PDOStatement object through PDO::prepare or
 813	 * PDO::query and invoke an error on the statement
 814	 * handle, PDO::errorInfo will not reflect the error
 815	 * from the statement handle. You must call
 816	 * PDOStatement::errorInfo to return the error
 817	 * information for an operation performed on a particular statement handle.
 818	 */
 819	public function errorInfo () {}
 820
 821	/**
 822	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.2.0)<br/>
 823	 * Retrieve a database connection attribute
 824	 * @link http://php.net/manual/en/pdo.getattribute.php
 825	 * @param int $attribute <p>
 826	 * One of the PDO::ATTR_* constants. The constants that
 827	 * apply to database connections are as follows:
 828	 * PDO::ATTR_AUTOCOMMIT
 829	 * PDO::ATTR_CASE
 830	 * PDO::ATTR_CLIENT_VERSION
 831	 * PDO::ATTR_CONNECTION_STATUS
 832	 * PDO::ATTR_DRIVER_NAME
 833	 * PDO::ATTR_ERRMODE
 834	 * PDO::ATTR_ORACLE_NULLS
 835	 * PDO::ATTR_PERSISTENT
 836	 * PDO::ATTR_PREFETCH
 837	 * PDO::ATTR_SERVER_INFO
 838	 * PDO::ATTR_SERVER_VERSION
 839	 * PDO::ATTR_TIMEOUT
 840	 * </p>
 841	 * @return mixed A successful call returns the value of the requested PDO attribute.
 842	 * An unsuccessful call returns null.
 843	 */
 844	public function getAttribute ($attribute) {}
 845
 846	/**
 847	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.2.1)<br/>
 848	 * Quotes a string for use in a query.
 849	 * @link http://php.net/manual/en/pdo.quote.php
 850	 * @param string $string <p>
 851	 * The string to be quoted.
 852	 * </p>
 853	 * @param int $parameter_type [optional] <p>
 854	 * Provides a data type hint for drivers that have alternate quoting styles.
 855	 * </p>
 856	 * @return string a quoted string that is theoretically safe to pass into an
 857	 * SQL statement. Returns false if the driver does not support quoting in
 858	 * this way.
 859	 */
 860	public function quote ($string, $parameter_type = null) {}
 861
 862	final public function __wakeup () {}
 863
 864	final public function __sleep () {}
 865
 866	/**
 867	 * (PHP 5 &gt;= 5.1.3, PECL pdo &gt;= 1.0.3)<br/>
 868	 * Return an array of available PDO drivers
 869	 * @link http://php.net/manual/en/pdo.getavailabledrivers.php
 870	 * @return array PDO::getAvailableDrivers returns an array of PDO driver names. If
 871	 * no drivers are available, it returns an empty array.
 872	 */
 873	public static function getAvailableDrivers () {}
 874
 875}
 876
 877/**
 878 * Represents a prepared statement and, after the statement is executed, an 
 879 * associated result set.
 880 * @link http://php.net/manual/en/class.pdostatement.php
 881 */
 882class PDOStatement implements Traversable {
 883	/**
 884	 * @var string
 885	 */
 886	public $queryString;
 887
 888
 889	/**
 890	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 891	 * Executes a prepared statement
 892	 * @link http://php.net/manual/en/pdostatement.execute.php
 893	 * @param array $input_parameters [optional] <p>
 894	 * An array of values with as many elements as there are bound
 895	 * parameters in the SQL statement being executed.
 896	 * All values are treated as PDO::PARAM_STR.
 897	 * </p>
 898	 * <p>
 899	 * You cannot bind multiple values to a single parameter; for example,
 900	 * you cannot bind two values to a single named parameter in an IN()
 901	 * clause.
 902	 * </p>
 903	 * @return bool Returns true on success or false on failure.
 904	 */
 905	public function execute (array $input_parameters = null) {}
 906
 907	/**
 908	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 909	 * Fetches the next row from a result set
 910	 * @link http://php.net/manual/en/pdostatement.fetch.php
 911	 * @param int $fetch_style [optional] <p>
 912	 * Controls how the next row will be returned to the caller. This value
 913	 * must be one of the PDO::FETCH_* constants,
 914	 * defaulting to PDO::FETCH_BOTH.
 915	 * <p>
 916	 * PDO::FETCH_ASSOC: returns an array indexed by column
 917	 * name as returned in your result set
 918	 * </p>
 919	 * @param int $cursor_orientation [optional] <p>
 920	 * For a PDOStatement object representing a scrollable cursor, this
 921	 * value determines which row will be returned to the caller. This value
 922	 * must be one of the PDO::FETCH_ORI_* constants,
 923	 * defaulting to PDO::FETCH_ORI_NEXT. To request a
 924	 * scrollable cursor for your PDOStatement object, you must set the
 925	 * PDO::ATTR_CURSOR attribute to
 926	 * PDO::CURSOR_SCROLL when you prepare the SQL
 927	 * statement with PDO::prepare.
 928	 * </p>
 929	 * @param int $cursor_offset [optional] 
 930	 * @return mixed The return value of this function on success depends on the fetch type. In
 931	 * all cases, false is returned on failure.
 932	 */
 933	public function fetch ($fetch_style = null, $cursor_orientation = null, $cursor_offset = null) {}
 934
 935	/**
 936	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 937	 * Binds a parameter to the specified variable name
 938	 * @link http://php.net/manual/en/pdostatement.bindparam.php
 939	 * @param mixed $parameter <p>
 940	 * Parameter identifier. For a prepared statement using named
 941	 * placeholders, this will be a parameter name of the form
 942	 * :name. For a prepared statement using
 943	 * question mark placeholders, this will be the 1-indexed position of
 944	 * the parameter. 
 945	 * </p>
 946	 * @param mixed $variable <p>
 947	 * Name of the PHP variable to bind to the SQL statement parameter.
 948	 * </p>
 949	 * @param int $data_type [optional] <p>
 950	 * Explicit data type for the parameter using the PDO::PARAM_*
 951	 * constants.
 952	 * To return an INOUT parameter from a stored procedure, 
 953	 * use the bitwise OR operator to set the PDO::PARAM_INPUT_OUTPUT bits
 954	 * for the data_type parameter.
 955	 * </p>
 956	 * @param int $length [optional] <p>
 957	 * Length of the data type. To indicate that a parameter is an OUT
 958	 * parameter from a stored procedure, you must explicitly set the
 959	 * length.
 960	 * </p>
 961	 * @param mixed $driver_options [optional] <p>
 962	 * </p>
 963	 * @return bool Returns true on success or false on failure.
 964	 */
 965	public function bindParam ($parameter, &$variable, $data_type = null, $length = null, $driver_options = null) {}
 966
 967	/**
 968	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
 969	 * Bind a column to a PHP variable
 970	 * @link http://php.net/manual/en/pdostatement.bindcolumn.php
 971	 * @param mixed $column <p>
 972	 * Number of the column (1-indexed) or name of the column in the result set.
 973	 * If using the column name, be aware that the name should match the
 974	 * case of the column, as returned by the driver.
 975	 * </p>
 976	 * @param mixed $param <p>
 977	 * Name of the PHP variable to which the column will be bound.
 978	 * </p>
 979	 * @param int $type [optional] <p>
 980	 * Data type of the parameter, specified by the PDO::PARAM_* constants.
 981	 * </p>
 982	 * @param int $maxlen [optional] <p>
 983	 * A hint for pre-allocation.
 984	 * </p>
 985	 * @param mixed $driverdata [optional] <p>
 986	 * Optional parameter(s) for the driver.
 987	 * </p>
 988	 * @return bool Returns true on success or false on failure.
 989	 */
 990	public function bindColumn ($column, &$param, $type = null, $maxlen = null, $driverdata = null) {}
 991
 992	/**
 993	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 1.0.0)<br/>
 994	 * Binds a value to a parameter
 995	 * @link http://php.net/manual/en/pdostatement.bindvalue.php
 996	 * @param mixed $parameter <p>
 997	 * Parameter identifier. For a prepared statement using named
 998	 * placeholders, this will be a parameter name of the form
 999	 * :name. For a prepared statement using
1000	 * question mark placeholders, this will be the 1-indexed position of
1001	 * the parameter. 
1002	 * </p>
1003	 * @param mixed $value <p>
1004	 * The value to bind to the parameter.
1005	 * </p>
1006	 * @param int $data_type [optional] <p>
1007	 * Explicit data type for the parameter using the PDO::PARAM_*
1008	 * constants.
1009	 * </p>
1010	 * @return bool Returns true on success or false on failure.
1011	 */
1012	public function bindValue ($parameter, $value, $data_type = null) {}
1013
1014	/**
1015	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
1016	 * Returns the number of rows affected by the last SQL statement
1017	 * @link http://php.net/manual/en/pdostatement.rowcount.php
1018	 * @return int the number of rows.
1019	 */
1020	public function rowCount () {}
1021
1022	/**
1023	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.9.0)<br/>
1024	 * Returns a single column from the next row of a result set
1025	 * @link http://php.net/manual/en/pdostatement.fetchcolumn.php
1026	 * @param int $column_number [optional] <p>
1027	 * 0-indexed number of the column you wish to retrieve from the row. If
1028	 * no value is supplied, PDOStatement::fetchColumn
1029	 * fetches the first column.
1030	 * </p>
1031	 * @return string PDOStatement::fetchColumn returns a single column
1032	 * in the next row of a result set.
1033	 * </p>
1034	 * <p>
1035	 * There is no way to return another column from the same row if you
1036	 * use PDOStatement::fetchColumn to retrieve data.
1037	 */
1038	public function fetchColumn ($column_number = null) {}
1039
1040	/**
1041	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
1042	 * Returns an array containing all of the result set rows
1043	 * @link http://php.net/manual/en/pdostatement.fetchall.php
1044	 * @param int $fetch_style [optional] <p>
1045	 * Controls the contents of the returned array as documented in
1046	 * PDOStatement::fetch.
1047	 * </p>
1048	 * <p>
1049	 * To return an array consisting of all values of a single column from
1050	 * the result set, specify PDO::FETCH_COLUMN. You
1051	 * can specify which column you want with the
1052	 * column-index parameter.
1053	 * </p>
1054	 * <p>
1055	 * To fetch only the unique values of a single column from the result set,
1056	 * bitwise-OR PDO::FETCH_COLUMN with
1057	 * PDO::FETCH_UNIQUE.
1058	 * </p>
1059	 * <p>
1060	 * To return an associative array grouped by the values of a specified
1061	 * column, bitwise-OR PDO::FETCH_COLUMN with
1062	 * PDO::FETCH_GROUP.
1063	 * </p>
1064	 * @param int $column_index [optional] <p>
1065	 * Returns the indicated 0-indexed column when the value of
1066	 * fetch_style is
1067	 * PDO::FETCH_COLUMN.
1068	 * </p>
1069	 * @param array $ctor_args [optional] <p>
1070	 * Arguments of custom class constructor.
1071	 * </p>
1072	 * @return array PDOStatement::fetchAll returns an array containing
1073	 * all of the remaining rows in the result set. The array represents each
1074	 * row as either an array of column values or an object with properties
1075	 * corresponding to each column name.
1076	 * </p>
1077	 * <p>
1078	 * Using this method to fetch large result sets will result in a heavy
1079	 * demand on system and possibly network resources. Rather than retrieving
1080	 * all of the data and manipulating it in PHP, consider using the database
1081	 * server to manipulate the result sets. For example, use the WHERE and
1082	 * SORT BY clauses in SQL to restrict results before retrieving and
1083	 * processing them with PHP.
1084	 */
1085	public function fetchAll ($fetch_style = null, $column_index = null, array $ctor_args = null) {}
1086
1087	/**
1088	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.2.4)<br/>
1089	 * Fetches the next row and returns it as an object.
1090	 * @link http://php.net/manual/en/pdostatement.fetchobject.php
1091	 * @param string $class_name [optional] <p>
1092	 * Name of the created class.
1093	 * </p>
1094	 * @param array $ctor_args [optional] <p>
1095	 * Elements of this array are passed to the constructor.
1096	 * </p>
1097	 * @return mixed an instance of the required class with property names that
1098	 * correspond to the column names &return.falseforfailure;.
1099	 */
1100	public function fetchObject ($class_name = null, array $ctor_args = null) {}
1101
1102	/**
1103	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
1104	 * Fetch the SQLSTATE associated with the last operation on the statement handle
1105	 * @link http://php.net/manual/en/pdostatement.errorcode.php
1106	 * @return string Identical to PDO::errorCode, except that 
1107	 * PDOStatement::errorCode only retrieves error codes
1108	 * for operations performed with PDOStatement objects.
1109	 */
1110	public function errorCode () {}
1111
1112	/**
1113	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.1.0)<br/>
1114	 * Fetch extended error information associated with the last operation on the statement handle
1115	 * @link http://php.net/manual/en/pdostatement.errorinfo.php
1116	 * @return array PDOStatement::errorInfo returns an array of
1117	 * error information about the last operation performed by this
1118	 * statement handle. The array consists of the following fields:
1119	 * <tr valign="top">
1120	 * <td>Element</td>
1121	 * <td>Information</td>
1122	 * </tr>
1123	 * <tr valign="top">
1124	 * <td>0</td>
1125	 * <td>SQLSTATE error code (a five characters alphanumeric identifier defined
1126	 * in the ANSI SQL standard).</td>
1127	 * </tr>
1128	 * <tr valign="top">
1129	 * <td>1</td>
1130	 * <td>Driver specific error code.</td>
1131	 * </tr>
1132	 * <tr valign="top">
1133	 * <td>2</td>
1134	 * <td>Driver specific error message.</td>
1135	 * </tr>
1136	 */
1137	public function errorInfo () {}
1138
1139	/**
1140	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.2.0)<br/>
1141	 * Set a statement attribute
1142	 * @link http://php.net/manual/en/pdostatement.setattribute.php
1143	 * @param int $attribute 
1144	 * @param mixed $value 
1145	 * @return bool Returns true on success or false on failure.
1146	 */
1147	public function setAttribute ($attribute, $value) {}
1148
1149	/**
1150	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.2.0)<br/>
1151	 * Retrieve a statement attribute
1152	 * @link http://php.net/manual/en/pdostatement.getattribute.php
1153	 * @param int $attribute 
1154	 * @return mixed the attribute value.
1155	 */
1156	public function getAttribute ($attribute) {}
1157
1158	/**
1159	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.2.0)<br/>
1160	 * Returns the number of columns in the result set
1161	 * @link http://php.net/manual/en/pdostatement.columncount.php
1162	 * @return int the number of columns in the result set represented by the
1163	 * PDOStatement object. If there is no result set,
1164	 * PDOStatement::columnCount returns 0.
1165	 */
1166	public function columnCount () {}
1167
1168	/**
1169	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.2.0)<br/>
1170	 * Returns metadata for a column in a result set
1171	 * @link http://php.net/manual/en/pdostatement.getcolumnmeta.php
1172	 * @param int $column <p>
1173	 * The 0-indexed column in the result set.
1174	 * </p>
1175	 * @return array an associative array containing the following values representing
1176	 * the metadata for a single column:
1177	 * </p>
1178	 * <table>
1179	 * Column metadata
1180	 * <tr valign="top">
1181	 * <td>Name</td>
1182	 * <td>Value</td>
1183	 * </tr>
1184	 * <tr valign="top">
1185	 * <td>native_type</td>
1186	 * <td>The PHP native type used to represent the column value.</td>
1187	 * </tr>
1188	 * <tr valign="top">
1189	 * <td>driver:decl_type</td>
1190	 * <td>The SQL type used to represent the column value in the database.
1191	 * If the column in the result set is the result of a function, this value
1192	 * is not returned by PDOStatement::getColumnMeta.
1193	 * </td>
1194	 * </tr>
1195	 * <tr valign="top">
1196	 * <td>flags</td>
1197	 * <td>Any flags set for this column.</td>
1198	 * </tr>
1199	 * <tr valign="top">
1200	 * <td>name</td>
1201	 * <td>The name of this column as returned by the database.</td>
1202	 * </tr>
1203	 * <tr valign="top">
1204	 * <td>table</td>
1205	 * <td>The name of this column's table as returned by the database.</td>
1206	 * </tr>
1207	 * <tr valign="top">
1208	 * <td>len</td>
1209	 * <td>The length of this column. Normally -1 for
1210	 * types other than floating point decimals.</td>
1211	 * </tr>
1212	 * <tr valign="top">
1213	 * <td>precision</td>
1214	 * <td>The numeric precision of this column. Normally
1215	 * 0 for types other than floating point
1216	 * decimals.</td>
1217	 * </tr>
1218	 * <tr valign="top">
1219	 * <td>pdo_type</td>
1220	 * <td>The type of this column as represented by the
1221	 * PDO::PARAM_* constants.</td>
1222	 * </tr>
1223	 * </table>
1224	 * <p>
1225	 * Returns false if the requested column does not exist in the result set,
1226	 * or if no result set exists.
1227	 */
1228	public function getColumnMeta ($column) {}
1229
1230	/**
1231	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.2.0)<br/>
1232	 * Set the default fetch mode for this statement
1233	 * @link http://php.net/manual/en/pdostatement.setfetchmode.php
1234	 * @param int $mode <p>
1235	 * The fetch mode must be one of the PDO::FETCH_* constants.
1236	 * </p>
1237	 * @return bool 1 on success&return.falseforfailure;.
1238	 */
1239	public function setFetchMode ($mode) {}
1240
1241	/**
1242	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.2.0)<br/>
1243	 * Advances to the next rowset in a multi-rowset statement handle
1244	 * @link http://php.net/manual/en/pdostatement.nextrowset.php
1245	 * @return bool Returns true on success or false on failure.
1246	 */
1247	public function nextRowset () {}
1248
1249	/**
1250	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.9.0)<br/>
1251	 * Closes the cursor, enabling the statement to be executed again.
1252	 * @link http://php.net/manual/en/pdostatement.closecursor.php
1253	 * @return bool Returns true on success or false on failure.
1254	 */
1255	public function closeCursor () {}
1256
1257	/**
1258	 * (PHP 5 &gt;= 5.1.0, PECL pdo &gt;= 0.9.0)<br/>
1259	 * Dump a SQL prepared command
1260	 * @link http://php.net/manual/en/pdostatement.debugdumpparams.php
1261	 * @return bool 
1262	 */
1263	public function debugDumpParams () {}
1264
1265	final public function __wakeup () {}
1266
1267	final public function __sleep () {}
1268
1269}
1270
1271final class PDORow  {
1272}
1273
1274function pdo_drivers () {}
1275
1276// End of PDO v.1.0.4dev
1277?>