Debian Codegraph @

codelitephp/resources/cc/PDO.php

raw
1 <?php
2
3 // Start of PDO v.1.0.4dev
4
5 class PDOException extends RuntimeException {
6 protected $message;
7 protected $code;
8 protected $file;
9 protected $line;
10 public $errorInfo;
11
12
13 final private function __clone () {}
14
15 /**
16 * @param message[optional]
17 * @param code[optional]
18 * @param previous[optional]
19 */
20 public function __construct ($message, $code, $previous) {}
21
22 final public function getMessage () {}
23
24 final public function getCode () {}
25
26 final public function getFile () {}
27
28 final public function getLine () {}
29
30 final public function getTrace () {}
31
32 final public function getPrevious () {}
33
34 final public function getTraceAsString () {}
35
36 public function __toString () {}
37
38 }
39
40 class PDO {
41 const PARAM_BOOL = 5;
42 const PARAM_NULL = 0;
43 const PARAM_INT = 1;
44 const PARAM_STR = 2;
45 const PARAM_LOB = 3;
46 const PARAM_STMT = 4;
47 const PARAM_INPUT_OUTPUT = 2147483648;
48 const PARAM_EVT_ALLOC = 0;
49 const PARAM_EVT_FREE = 1;
50 const PARAM_EVT_EXEC_PRE = 2;
51 const PARAM_EVT_EXEC_POST = 3;
52 const PARAM_EVT_FETCH_PRE = 4;
53 const PARAM_EVT_FETCH_POST = 5;
54 const PARAM_EVT_NORMALIZE = 6;
55 const FETCH_LAZY = 1;
56 const FETCH_ASSOC = 2;
57 const FETCH_NUM = 3;
58 const FETCH_BOTH = 4;
59 const FETCH_OBJ = 5;
60 const FETCH_BOUND = 6;
61 const FETCH_COLUMN = 7;
62 const FETCH_CLASS = 8;
63 const FETCH_INTO = 9;
64 const FETCH_FUNC = 10;
65 const FETCH_GROUP = 65536;
66 const FETCH_UNIQUE = 196608;
67 const FETCH_KEY_PAIR = 12;
68 const FETCH_CLASSTYPE = 262144;
69 const FETCH_SERIALIZE = 524288;
70 const FETCH_PROPS_LATE = 1048576;
71 const FETCH_NAMED = 11;
72 const ATTR_AUTOCOMMIT = 0;
73 const ATTR_PREFETCH = 1;
74 const ATTR_TIMEOUT = 2;
75 const ATTR_ERRMODE = 3;
76 const ATTR_SERVER_VERSION = 4;
77 const ATTR_CLIENT_VERSION = 5;
78 const ATTR_SERVER_INFO = 6;
79 const ATTR_CONNECTION_STATUS = 7;
80 const ATTR_CASE = 8;
81 const ATTR_CURSOR_NAME = 9;
82 const ATTR_CURSOR = 10;
83 const ATTR_ORACLE_NULLS = 11;
84 const ATTR_PERSISTENT = 12;
85 const ATTR_STATEMENT_CLASS = 13;
86 const ATTR_FETCH_TABLE_NAMES = 14;
87 const ATTR_FETCH_CATALOG_NAMES = 15;
88 const ATTR_DRIVER_NAME = 16;
89 const ATTR_STRINGIFY_FETCHES = 17;
90 const ATTR_MAX_COLUMN_LEN = 18;
91 const ATTR_EMULATE_PREPARES = 20;
92 const ATTR_DEFAULT_FETCH_MODE = 19;
93 const ERRMODE_SILENT = 0;
94 const ERRMODE_WARNING = 1;
95 const ERRMODE_EXCEPTION = 2;
96 const CASE_NATURAL = 0;
97 const CASE_LOWER = 2;
98 const CASE_UPPER = 1;
99 const NULL_NATURAL = 0;
100 const NULL_EMPTY_STRING = 1;
101 const NULL_TO_STRING = 2;
102 const ERR_NONE = 00000;
103 const FETCH_ORI_NEXT = 0;
104 const FETCH_ORI_PRIOR = 1;
105 const FETCH_ORI_FIRST = 2;
106 const FETCH_ORI_LAST = 3;
107 const FETCH_ORI_ABS = 4;
108 const FETCH_ORI_REL = 5;
109 const CURSOR_FWDONLY = 0;
110 const CURSOR_SCROLL = 1;
111 const MYSQL_ATTR_USE_BUFFERED_QUERY = 1000;
112 const MYSQL_ATTR_LOCAL_INFILE = 1001;
113 const MYSQL_ATTR_INIT_COMMAND = 1002;
114 const MYSQL_ATTR_COMPRESS = 1003;
115 const MYSQL_ATTR_DIRECT_QUERY = 1004;
116 const MYSQL_ATTR_FOUND_ROWS = 1005;
117 const MYSQL_ATTR_IGNORE_SPACE = 1006;
118 const MYSQL_ATTR_SSL_KEY = 1007;
119 const MYSQL_ATTR_SSL_CERT = 1008;
120 const MYSQL_ATTR_SSL_CA = 1009;
121 const MYSQL_ATTR_SSL_CAPATH = 1010;
122 const MYSQL_ATTR_SSL_CIPHER = 1011;
123 const MYSQL_ATTR_SERVER_PUBLIC_KEY = 1012;
124 const PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT = 1000;
125 const PGSQL_ATTR_DISABLE_PREPARES = 1001;
126 const PGSQL_TRANSACTION_IDLE = 0;
127 const PGSQL_TRANSACTION_ACTIVE = 1;
128 const PGSQL_TRANSACTION_INTRANS = 2;
129 const PGSQL_TRANSACTION_INERROR = 3;
130 const PGSQL_TRANSACTION_UNKNOWN = 4;
131
132
133 /**
134 * Creates a PDO instance representing a connection to a database
135 * @link http://www.php.net/manual/en/pdo.construct.php
136 * @param dsn
137 * @param username[optional]
138 * @param passwd[optional]
139 * @param options[optional]
140 */
141 public function __construct ($dsn, $username, $passwd, $options) {}
142
143 /**
144 * Prepares a statement for execution and returns a statement object
145 * @link http://www.php.net/manual/en/pdo.prepare.php
146 * @param statement string <p>
147 * This must be a valid SQL statement for the target database server.
148 * </p>
149 * @param driver_options array[optional] <p>
150 * This array holds one or more key=>value pairs to set
151 * attribute values for the PDOStatement object that this method
152 * returns. You would most commonly use this to set the
153 * PDO::ATTR_CURSOR value to
154 * PDO::CURSOR_SCROLL to request a scrollable cursor.
155 * Some drivers have driver specific options that may be set at
156 * prepare-time.
157 * </p>
158 * @return PDOStatement If the database server successfully prepares the statement,
159 * PDO::prepare returns a
160 * PDOStatement object.
161 * If the database server cannot successfully prepare the statement,
162 * PDO::prepare returns false or emits
163 * PDOException (depending on error handling).
164 * </p>
165 *
166 * <p>
167 * Emulated prepared statements does not communicate with the database server
168 * so PDO::prepare does not check the statement.
169 */
170 public function prepare ($statement, array $driver_options = null) {}
171
172 /**
173 * Initiates a transaction
174 * @link http://www.php.net/manual/en/pdo.begintransaction.php
175 * @return bool Returns true on success, false on failure.
176 */
177 public function beginTransaction () {}
178
179 /**
180 * Commits a transaction
181 * @link http://www.php.net/manual/en/pdo.commit.php
182 * @return bool Returns true on success, false on failure.
183 */
184 public function commit () {}
185
186 /**
187 * Rolls back a transaction
188 * @link http://www.php.net/manual/en/pdo.rollback.php
189 * @return bool Returns true on success, false on failure.
190 */
191 public function rollBack () {}
192
193 /**
194 * Checks if inside a transaction
195 * @link http://www.php.net/manual/en/pdo.intransaction.php
196 * @return bool true if a transaction is currently active, and false if not.
197 */
198 public function inTransaction () {}
199
200 /**
201 * Set an attribute
202 * @link http://www.php.net/manual/en/pdo.setattribute.php
203 * @param attribute int
204 * @param value mixed
205 * @return bool Returns true on success, false on failure.
206 */
207 public function setAttribute ($attribute, $value) {}
208
209 /**
210 * Execute an SQL statement and return the number of affected rows
211 * @link http://www.php.net/manual/en/pdo.exec.php
212 * @param statement string <p>
213 * The SQL statement to prepare and execute.
214 * </p>
215 * <p>
216 * Data inside the query should be properly escaped.
217 * </p>
218 * @return int PDO::exec returns the number of rows that were modified
219 * or deleted by the SQL statement you issued. If no rows were affected,
220 * PDO::exec returns 0.
221 * </p>
222 * &return.falseproblem;
223 * <p>
224 * The following example incorrectly relies on the return value of
225 * PDO::exec, wherein a statement that affected 0 rows
226 * results in a call to die:
227 *
228 * exec() or die(print_r($db->errorInfo(), true));
229 * ?>
230 * ]]>
231 */
232 public function exec ($statement) {}
233
234 /**
235 * Executes an SQL statement, returning a result set as a PDOStatement object
236 * @link http://www.php.net/manual/en/pdo.query.php
237 * @param statement string <p>
238 * The SQL statement to prepare and execute.
239 * </p>
240 * <p>
241 * Data inside the query should be properly escaped.
242 * </p>
243 * @return PDOStatement PDO::query returns a PDOStatement object, or false
244 * on failure.
245 */
246 public function query ($statement) {}
247
248 /**
249 * Returns the ID of the last inserted row or sequence value
250 * @link http://www.php.net/manual/en/pdo.lastinsertid.php
251 * @param name string[optional] <p>
252 * Name of the sequence object from which the ID should be returned.
253 * </p>
254 * @return string If a sequence name was not specified for the name
255 * parameter, PDO::lastInsertId returns a
256 * string representing the row ID of the last row that was inserted into
257 * the database.
258 * </p>
259 * <p>
260 * If a sequence name was specified for the name
261 * parameter, PDO::lastInsertId returns a
262 * string representing the last value retrieved from the specified sequence
263 * object.
264 * </p>
265 * <p>
266 * If the PDO driver does not support this capability,
267 * PDO::lastInsertId triggers an
268 * IM001 SQLSTATE.
269 */
270 public function lastInsertId ($name = null) {}
271
272 /**
273 * Fetch the SQLSTATE associated with the last operation on the database handle
274 * @link http://www.php.net/manual/en/pdo.errorcode.php
275 * @return mixed an SQLSTATE, a five characters alphanumeric identifier defined in
276 * the ANSI SQL-92 standard. Briefly, an SQLSTATE consists of a
277 * two characters class value followed by a three characters subclass value. A
278 * class value of 01 indicates a warning and is accompanied by a return code
279 * of SQL_SUCCESS_WITH_INFO. Class values other than '01', except for the
280 * class 'IM', indicate an error. The class 'IM' is specific to warnings
281 * and errors that derive from the implementation of PDO (or perhaps ODBC,
282 * if you're using the ODBC driver) itself. The subclass value '000' in any
283 * class indicates that there is no subclass for that SQLSTATE.
284 * </p>
285 * <p>
286 * PDO::errorCode only retrieves error codes for operations
287 * performed directly on the database handle. If you create a PDOStatement
288 * object through PDO::prepare or
289 * PDO::query and invoke an error on the statement
290 * handle, PDO::errorCode will not reflect that error.
291 * You must call PDOStatement::errorCode to return the error
292 * code for an operation performed on a particular statement handle.
293 * </p>
294 * <p>
295 * Returns &null; if no operation has been run on the database handle.
296 */
297 public function errorCode () {}
298
299 /**
300 * Fetch extended error information associated with the last operation on the database handle
301 * @link http://www.php.net/manual/en/pdo.errorinfo.php
302 * @return array PDO::errorInfo returns an array of error information
303 * about the last operation performed by this database handle. The array
304 * consists of the following fields:
305 *
306 *
307 *
308 * <tr valign="top">
309 * <td>Element</td>
310 * <td>Information</td>
311 * </tr>
312 *
313 *
314 * <tr valign="top">
315 * <td>0</td>
316 * <td>SQLSTATE error code (a five characters alphanumeric identifier defined
317 * in the ANSI SQL standard).</td>
318 * </tr>
319 * <tr valign="top">
320 * <td>1</td>
321 * <td>Driver-specific error code.</td>
322 * </tr>
323 * <tr valign="top">
324 * <td>2</td>
325 * <td>Driver-specific error message.</td>
326 * </tr>
327 *
328 *
329 *
330 * </p>
331 *
332 * <p>
333 * If the SQLSTATE error code is not set or there is no driver-specific
334 * error, the elements following element 0 will be set to &null;.
335 * </p>
336 *
337 * <p>
338 * PDO::errorInfo only retrieves error information for
339 * operations performed directly on the database handle. If you create a
340 * PDOStatement object through PDO::prepare or
341 * PDO::query and invoke an error on the statement
342 * handle, PDO::errorInfo will not reflect the error
343 * from the statement handle. You must call
344 * PDOStatement::errorInfo to return the error
345 * information for an operation performed on a particular statement handle.
346 */
347 public function errorInfo () {}
348
349 /**
350 * Retrieve a database connection attribute
351 * @link http://www.php.net/manual/en/pdo.getattribute.php
352 * @param attribute int <p>
353 * One of the PDO::ATTR_* constants. The constants that
354 * apply to database connections are as follows:
355 *
356 * PDO::ATTR_AUTOCOMMIT
357 * PDO::ATTR_CASE
358 * PDO::ATTR_CLIENT_VERSION
359 * PDO::ATTR_CONNECTION_STATUS
360 * PDO::ATTR_DRIVER_NAME
361 * PDO::ATTR_ERRMODE
362 * PDO::ATTR_ORACLE_NULLS
363 * PDO::ATTR_PERSISTENT
364 * PDO::ATTR_PREFETCH
365 * PDO::ATTR_SERVER_INFO
366 * PDO::ATTR_SERVER_VERSION
367 * PDO::ATTR_TIMEOUT
368 *
369 * </p>
370 * @return mixed A successful call returns the value of the requested PDO attribute.
371 * An unsuccessful call returns null.
372 */
373 public function getAttribute ($attribute) {}
374
375 /**
376 * Quotes a string for use in a query.
377 * @link http://www.php.net/manual/en/pdo.quote.php
378 * @param string string <p>
379 * The string to be quoted.
380 * </p>
381 * @param parameter_type int[optional] <p>
382 * Provides a data type hint for drivers that have alternate quoting styles.
383 * </p>
384 * @return string a quoted string that is theoretically safe to pass into an
385 * SQL statement. Returns false if the driver does not support quoting in
386 * this way.
387 */
388 public function quote ($string, $parameter_type = null) {}
389
390 final public function __wakeup () {}
391
392 final public function __sleep () {}
393
394 /**
395 * Return an array of available PDO drivers
396 * @link http://www.php.net/manual/en/pdo.getavailabledrivers.php
397 * @return array PDO::getAvailableDrivers returns an array of PDO driver names. If
398 * no drivers are available, it returns an empty array.
399 */
400 public static function getAvailableDrivers () {}
401
402 }
403
404 class PDOStatement implements Traversable {
405 public $queryString;
406
407
408 /**
409 * Executes a prepared statement
410 * @link http://www.php.net/manual/en/pdostatement.execute.php
411 * @param input_parameters array[optional] <p>
412 * An array of values with as many elements as there are bound
413 * parameters in the SQL statement being executed.
414 * All values are treated as PDO::PARAM_STR.
415 * </p>
416 * <p>
417 * You cannot bind multiple values to a single parameter; for example,
418 * you cannot bind two values to a single named parameter in an IN()
419 * clause.
420 * </p>
421 * <p>
422 * You cannot bind more values than specified; if more keys exist in
423 * input_parameters than in the SQL specified
424 * in the PDO::prepare, then the statement will
425 * fail and an error is emitted.
426 * </p>
427 * @return bool Returns true on success, false on failure.
428 */
429 public function execute (array $input_parameters = null) {}
430
431 /**
432 * Fetches the next row from a result set
433 * @link http://www.php.net/manual/en/pdostatement.fetch.php
434 * @param fetch_style int[optional] <p>
435 * Controls how the next row will be returned to the caller. This value
436 * must be one of the PDO::FETCH_* constants,
437 * defaulting to value of PDO::ATTR_DEFAULT_FETCH_MODE
438 * (which defaults to PDO::FETCH_BOTH).
439 *
440 * <p>
441 * PDO::FETCH_ASSOC: returns an array indexed by column
442 * name as returned in your result set
443 * </p>
444 * @param cursor_orientation int[optional] <p>
445 * For a PDOStatement object representing a scrollable cursor, this
446 * value determines which row will be returned to the caller. This value
447 * must be one of the PDO::FETCH_ORI_* constants,
448 * defaulting to PDO::FETCH_ORI_NEXT. To request a
449 * scrollable cursor for your PDOStatement object, you must set the
450 * PDO::ATTR_CURSOR attribute to
451 * PDO::CURSOR_SCROLL when you prepare the SQL
452 * statement with PDO::prepare.
453 * </p>
454 * @param cursor_offset int[optional]
455 * @return mixed The return value of this function on success depends on the fetch type. In
456 * all cases, false is returned on failure.
457 */
458 public function fetch ($fetch_style = null, $cursor_orientation = null, $cursor_offset = null) {}
459
460 /**
461 * Binds a parameter to the specified variable name
462 * @link http://www.php.net/manual/en/pdostatement.bindparam.php
463 * @param parameter mixed <p>
464 * Parameter identifier. For a prepared statement using named
465 * placeholders, this will be a parameter name of the form
466 * :name. For a prepared statement using
467 * question mark placeholders, this will be the 1-indexed position of
468 * the parameter.
469 * </p>
470 * @param variable mixed <p>
471 * Name of the PHP variable to bind to the SQL statement parameter.
472 * </p>
473 * @param data_type int[optional] <p>
474 * Explicit data type for the parameter using the PDO::PARAM_*
475 * constants.
476 * To return an INOUT parameter from a stored procedure,
477 * use the bitwise OR operator to set the PDO::PARAM_INPUT_OUTPUT bits
478 * for the data_type parameter.
479 * </p>
480 * @param length int[optional] <p>
481 * Length of the data type. To indicate that a parameter is an OUT
482 * parameter from a stored procedure, you must explicitly set the
483 * length.
484 * </p>
485 * @param driver_options mixed[optional] <p>
486 *
487 * </p>
488 * @return bool Returns true on success, false on failure.
489 */
490 public function bindParam ($parameter, &$variable, $data_type = null, $length = null, $driver_options = null) {}
491
492 /**
493 * Bind a column to a PHP variable
494 * @link http://www.php.net/manual/en/pdostatement.bindcolumn.php
495 * @param column mixed <p>
496 * Number of the column (1-indexed) or name of the column in the result set.
497 * If using the column name, be aware that the name should match the
498 * case of the column, as returned by the driver.
499 * </p>
500 * @param param mixed <p>
501 * Name of the PHP variable to which the column will be bound.
502 * </p>
503 * @param type int[optional] <p>
504 * Data type of the parameter, specified by the PDO::PARAM_*
505 * constants.
506 * </p>
507 * @param maxlen int[optional] <p>
508 * A hint for pre-allocation.
509 * </p>
510 * @param driverdata mixed[optional] <p>
511 * Optional parameter(s) for the driver.
512 * </p>
513 * @return bool Returns true on success, false on failure.
514 */
515 public function bindColumn ($column, &$param, $type = null, $maxlen = null, $driverdata = null) {}
516
517 /**
518 * Binds a value to a parameter
519 * @link http://www.php.net/manual/en/pdostatement.bindvalue.php
520 * @param parameter mixed <p>
521 * Parameter identifier. For a prepared statement using named
522 * placeholders, this will be a parameter name of the form
523 * :name. For a prepared statement using
524 * question mark placeholders, this will be the 1-indexed position of
525 * the parameter.
526 * </p>
527 * @param value mixed <p>
528 * The value to bind to the parameter.
529 * </p>
530 * @param data_type int[optional] <p>
531 * Explicit data type for the parameter using the PDO::PARAM_*
532 * constants.
533 * </p>
534 * @return bool Returns true on success, false on failure.
535 */
536 public function bindValue ($parameter, $value, $data_type = null) {}
537
538 /**
539 * Returns the number of rows affected by the last SQL statement
540 * @link http://www.php.net/manual/en/pdostatement.rowcount.php
541 * @return int the number of rows.
542 */
543 public function rowCount () {}
544
545 /**
546 * Returns a single column from the next row of a result set
547 * @link http://www.php.net/manual/en/pdostatement.fetchcolumn.php
548 * @param column_number int[optional] <p>
549 * 0-indexed number of the column you wish to retrieve from the row. If
550 * no value is supplied, PDOStatement::fetchColumn
551 * fetches the first column.
552 * </p>
553 * @return string PDOStatement::fetchColumn returns a single column
554 * in the next row of a result set.
555 * </p>
556 *
557 * <p>
558 * There is no way to return another column from the same row if you
559 * use PDOStatement::fetchColumn to retrieve data.
560 */
561 public function fetchColumn ($column_number = null) {}
562
563 /**
564 * Returns an array containing all of the result set rows
565 * @link http://www.php.net/manual/en/pdostatement.fetchall.php
566 * @param fetch_style int[optional] <p>
567 * Controls the contents of the returned array as documented in
568 * PDOStatement::fetch.
569 * Defaults to value of PDO::ATTR_DEFAULT_FETCH_MODE
570 * (which defaults to PDO::FETCH_BOTH)
571 * </p>
572 * <p>
573 * To return an array consisting of all values of a single column from
574 * the result set, specify PDO::FETCH_COLUMN. You
575 * can specify which column you want with the
576 * column-index parameter.
577 * </p>
578 * <p>
579 * To fetch only the unique values of a single column from the result set,
580 * bitwise-OR PDO::FETCH_COLUMN with
581 * PDO::FETCH_UNIQUE.
582 * </p>
583 * <p>
584 * To return an associative array grouped by the values of a specified
585 * column, bitwise-OR PDO::FETCH_COLUMN with
586 * PDO::FETCH_GROUP.
587 * </p>
588 * @param fetch_argument mixed[optional] <p>
589 * This argument have a different meaning depending on the value of
590 * the fetch_style parameter:
591 *
592 *
593 * <p>
594 * PDO::FETCH_COLUMN: Returns the indicated 0-indexed
595 * column.
596 * </p>
597 * @param ctor_args array[optional] <p>
598 * Arguments of custom class constructor when the fetch_style
599 * parameter is PDO::FETCH_CLASS.
600 * </p>
601 * @return array PDOStatement::fetchAll returns an array containing
602 * all of the remaining rows in the result set. The array represents each
603 * row as either an array of column values or an object with properties
604 * corresponding to each column name. An empty array is returned if there
605 * are zero results to fetch, or false on failure.
606 * </p>
607 * <p>
608 * Using this method to fetch large result sets will result in a heavy
609 * demand on system and possibly network resources. Rather than retrieving
610 * all of the data and manipulating it in PHP, consider using the database
611 * server to manipulate the result sets. For example, use the WHERE and
612 * ORDER BY clauses in SQL to restrict results before retrieving and
613 * processing them with PHP.
614 */
615 public function fetchAll ($fetch_style = null, $fetch_argument = null, array $ctor_args = null) {}
616
617 /**
618 * Fetches the next row and returns it as an object.
619 * @link http://www.php.net/manual/en/pdostatement.fetchobject.php
620 * @param class_name string[optional] <p>
621 * Name of the created class.
622 * </p>
623 * @param ctor_args array[optional] <p>
624 * Elements of this array are passed to the constructor.
625 * </p>
626 * @return mixed an instance of the required class with property names that
627 * correspond to the column names &return.falseforfailure;.
628 */
629 public function fetchObject ($class_name = null, array $ctor_args = null) {}
630
631 /**
632 * Fetch the SQLSTATE associated with the last operation on the statement handle
633 * @link http://www.php.net/manual/en/pdostatement.errorcode.php
634 * @return string Identical to PDO::errorCode, except that
635 * PDOStatement::errorCode only retrieves error codes
636 * for operations performed with PDOStatement objects.
637 */
638 public function errorCode () {}
639
640 /**
641 * Fetch extended error information associated with the last operation on the statement handle
642 * @link http://www.php.net/manual/en/pdostatement.errorinfo.php
643 * @return array PDOStatement::errorInfo returns an array of
644 * error information about the last operation performed by this
645 * statement handle. The array consists of the following fields:
646 *
647 *
648 *
649 * <tr valign="top">
650 * <td>Element</td>
651 * <td>Information</td>
652 * </tr>
653 *
654 *
655 * <tr valign="top">
656 * <td>0</td>
657 * <td>SQLSTATE error code (a five characters alphanumeric identifier defined
658 * in the ANSI SQL standard).</td>
659 * </tr>
660 * <tr valign="top">
661 * <td>1</td>
662 * <td>Driver specific error code.</td>
663 * </tr>
664 * <tr valign="top">
665 * <td>2</td>
666 * <td>Driver specific error message.</td>
667 * </tr>
668 */
669 public function errorInfo () {}
670
671 /**
672 * Set a statement attribute
673 * @link http://www.php.net/manual/en/pdostatement.setattribute.php
674 * @param attribute int
675 * @param value mixed
676 * @return bool Returns true on success, false on failure.
677 */
678 public function setAttribute ($attribute, $value) {}
679
680 /**
681 * Retrieve a statement attribute
682 * @link http://www.php.net/manual/en/pdostatement.getattribute.php
683 * @param attribute int
684 * @return mixed the attribute value.
685 */
686 public function getAttribute ($attribute) {}
687
688 /**
689 * Returns the number of columns in the result set
690 * @link http://www.php.net/manual/en/pdostatement.columncount.php
691 * @return int the number of columns in the result set represented by the
692 * PDOStatement object. If there is no result set,
693 * PDOStatement::columnCount returns 0.
694 */
695 public function columnCount () {}
696
697 /**
698 * Returns metadata for a column in a result set
699 * @link http://www.php.net/manual/en/pdostatement.getcolumnmeta.php
700 * @param column int <p>
701 * The 0-indexed column in the result set.
702 * </p>
703 * @return array an associative array containing the following values representing
704 * the metadata for a single column:
705 * </p>
706 * <table>
707 * Column metadata
708 *
709 *
710 *
711 *
712 * <tr valign="top">
713 * <td>Name</td>
714 * <td>Value</td>
715 * </tr>
716 *
717 *
718 * <tr valign="top">
719 * <td>native_type</td>
720 * <td>The PHP native type used to represent the column value.</td>
721 * </tr>
722 * <tr valign="top">
723 * <td>driver:decl_type</td>
724 * <td>The SQL type used to represent the column value in the database.
725 * If the column in the result set is the result of a function, this value
726 * is not returned by PDOStatement::getColumnMeta.
727 * </td>
728 * </tr>
729 * <tr valign="top">
730 * <td>flags</td>
731 * <td>Any flags set for this column.</td>
732 * </tr>
733 * <tr valign="top">
734 * <td>name</td>
735 * <td>The name of this column as returned by the database.</td>
736 * </tr>
737 * <tr valign="top">
738 * <td>table</td>
739 * <td>The name of this column's table as returned by the database.</td>
740 * </tr>
741 * <tr valign="top">
742 * <td>len</td>
743 * <td>The length of this column. Normally -1 for
744 * types other than floating point decimals.</td>
745 * </tr>
746 * <tr valign="top">
747 * <td>precision</td>
748 * <td>The numeric precision of this column. Normally
749 * 0 for types other than floating point
750 * decimals.</td>
751 * </tr>
752 * <tr valign="top">
753 * <td>pdo_type</td>
754 * <td>The type of this column as represented by the
755 * PDO::PARAM_*
756 * constants.</td>
757 * </tr>
758 *
759 *
760 * </table>
761 * <p>
762 * Returns false if the requested column does not exist in the result set,
763 * or if no result set exists.
764 */
765 public function getColumnMeta ($column) {}
766
767 /**
768 * Set the default fetch mode for this statement
769 * @link http://www.php.net/manual/en/pdostatement.setfetchmode.php
770 * @param mode int <p>
771 * The fetch mode must be one of the PDO::FETCH_* constants.
772 * </p>
773 * @return bool Returns true on success, false on failure.
774 */
775 public function setFetchMode ($mode) {}
776
777 /**
778 * Advances to the next rowset in a multi-rowset statement handle
779 * @link http://www.php.net/manual/en/pdostatement.nextrowset.php
780 * @return bool Returns true on success, false on failure.
781 */
782 public function nextRowset () {}
783
784 /**
785 * Closes the cursor, enabling the statement to be executed again.
786 * @link http://www.php.net/manual/en/pdostatement.closecursor.php
787 * @return bool Returns true on success, false on failure.
788 */
789 public function closeCursor () {}
790
791 /**
792 * Dump an SQL prepared command
793 * @link http://www.php.net/manual/en/pdostatement.debugdumpparams.php
794 * @return void
795 */
796 public function debugDumpParams () {}
797
798 final public function __wakeup () {}
799
800 final public function __sleep () {}
801
802 }
803
804 final class PDORow {
805 }
806
807 function pdo_drivers () {}
808
809 // End of PDO v.1.0.4dev
810 ?>