PDOException from your own code.
* See Exceptions for more
* information about Exceptions in PHP.
* @link http://php.net/manual/en/class.pdoexception.php
*/
class PDOException extends RuntimeException {
protected $message;
protected $code;
protected $file;
protected $line;
public $errorInfo;
/**
* (PHP 5 >= 5.1.0)
* Clone the exception
* @link http://php.net/manual/en/exception.clone.php
* @return void No value is returned.
*/
final private function __clone () {}
/**
* (PHP 5 >= 5.1.0)
* Construct the exception
* @link http://php.net/manual/en/exception.construct.php
* @param $message [optional]
* @param $code [optional]
* @param $previous [optional]
*/
public function __construct ($message, $code, $previous) {}
/**
* (PHP 5 >= 5.1.0)
* Gets the Exception message
* @link http://php.net/manual/en/exception.getmessage.php
* @return string the Exception message as a string.
*/
final public function getMessage () {}
/**
* (PHP 5 >= 5.1.0)
* Gets the Exception code
* @link http://php.net/manual/en/exception.getcode.php
* @return mixed the exception code as integer in
* Exception but possibly as other type in
* Exception descendants (for example as
* string in PDOException).
*/
final public function getCode () {}
/**
* (PHP 5 >= 5.1.0)
* Gets the file in which the exception occurred
* @link http://php.net/manual/en/exception.getfile.php
* @return string the filename in which the exception was created.
*/
final public function getFile () {}
/**
* (PHP 5 >= 5.1.0)
* Gets the line in which the exception occurred
* @link http://php.net/manual/en/exception.getline.php
* @return int the line number where the exception was created.
*/
final public function getLine () {}
/**
* (PHP 5 >= 5.1.0)
* Gets the stack trace
* @link http://php.net/manual/en/exception.gettrace.php
* @return array the Exception stack trace as an array.
*/
final public function getTrace () {}
/**
* (PHP 5 >= 5.3.0)
* Returns previous Exception
* @link http://php.net/manual/en/exception.getprevious.php
* @return Exception the previous Exception if available
* or NULL otherwise.
*/
final public function getPrevious () {}
/**
* (PHP 5 >= 5.1.0)
* Gets the stack trace as a string
* @link http://php.net/manual/en/exception.gettraceasstring.php
* @return string the Exception stack trace as a string.
*/
final public function getTraceAsString () {}
/**
* (PHP 5 >= 5.1.0)
* String representation of the exception
* @link http://php.net/manual/en/exception.tostring.php
* @return string the string representation of the exception.
*/
public function __toString () {}
}
/**
* Represents a connection between PHP and a database server.
* @link http://php.net/manual/en/class.pdo.php
*/
class PDO {
/**
* Represents a boolean data type.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_BOOL = 5;
/**
* Represents the SQL NULL data type.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_NULL = 0;
/**
* Represents the SQL INTEGER data type.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_INT = 1;
/**
* Represents the SQL CHAR, VARCHAR, or other string data type.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_STR = 2;
/**
* Represents the SQL large object data type.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_LOB = 3;
/**
* Represents a recordset type. Not currently supported by any drivers.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_STMT = 4;
/**
* Specifies that the parameter is an INOUT parameter for a stored
* procedure. You must bitwise-OR this value with an explicit
* PDO::PARAM_* data type.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_INPUT_OUTPUT = 2147483648;
/**
* Allocation event
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_EVT_ALLOC = 0;
/**
* Deallocation event
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_EVT_FREE = 1;
/**
* Event triggered prior to execution of a prepared statement.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_EVT_EXEC_PRE = 2;
/**
* Event triggered subsequent to execution of a prepared statement.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_EVT_EXEC_POST = 3;
/**
* Event triggered prior to fetching a result from a resultset.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_EVT_FETCH_PRE = 4;
/**
* Event triggered subsequent to fetching a result from a resultset.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_EVT_FETCH_POST = 5;
/**
* Event triggered during bound parameter registration
* allowing the driver to normalize the parameter name.
* @link http://php.net/manual/en/pdo.constants.php
*/
const PARAM_EVT_NORMALIZE = 6;
/**
* Specifies that the fetch method shall return each row as an object with
* variable names that correspond to the column names returned in the result
* set. PDO::FETCH_LAZY creates the object variable names as they are accessed.
* Not valid inside PDOStatement::fetchAll.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_LAZY = 1;
/**
* Specifies that the fetch method shall return each row as an array indexed
* by column name as returned in the corresponding result set. If the result
* set contains multiple columns with the same name,
* PDO::FETCH_ASSOC returns
* only a single value per column name.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_ASSOC = 2;
/**
* Specifies that the fetch method shall return each row as an array indexed
* by column number as returned in the corresponding result set, starting at
* column 0.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_NUM = 3;
/**
* Specifies that the fetch method shall return each row as an array indexed
* by both column name and number as returned in the corresponding result set,
* starting at column 0.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_BOTH = 4;
/**
* Specifies that the fetch method shall return each row as an object with
* property names that correspond to the column names returned in the result
* set.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_OBJ = 5;
/**
* Specifies that the fetch method shall return TRUE and assign the values of
* the columns in the result set to the PHP variables to which they were
* bound with the PDOStatement::bindParam or
* PDOStatement::bindColumn methods.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_BOUND = 6;
/**
* Specifies that the fetch method shall return only a single requested
* column from the next row in the result set.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_COLUMN = 7;
/**
* Specifies that the fetch method shall return a new instance of the
* requested class, mapping the columns to named properties in the class.
* The magic
* __set
* method is called if the property doesn't exist in the requested class
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_CLASS = 8;
/**
* Specifies that the fetch method shall update an existing instance of the
* requested class, mapping the columns to named properties in the class.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_INTO = 9;
/**
* Allows completely customize the way data is treated on the fly (only
* valid inside PDOStatement::fetchAll).
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_FUNC = 10;
/**
* Group return by values. Usually combined with
* PDO::FETCH_COLUMN or
* PDO::FETCH_KEY_PAIR.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_GROUP = 65536;
/**
* Fetch only the unique values.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_UNIQUE = 196608;
/**
* Fetch a two-column result into an array where the first column is a key and the second column
* is the value. Available since PHP 5.2.3.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_KEY_PAIR = 12;
/**
* Determine the class name from the value of first column.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_CLASSTYPE = 262144;
/**
* As PDO::FETCH_INTO but object is provided as a serialized string.
* Available since PHP 5.1.0.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_SERIALIZE = 524288;
/**
* Available since PHP 5.2.0
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_PROPS_LATE = 1048576;
/**
* Specifies that the fetch method shall return each row as an array indexed
* by column name as returned in the corresponding result set. If the result
* set contains multiple columns with the same name,
* PDO::FETCH_NAMED returns
* an array of values per column name.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_NAMED = 11;
/**
* If this value is FALSE, PDO attempts to disable autocommit so that the
* connection begins a transaction.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_AUTOCOMMIT = 0;
/**
* Setting the prefetch size allows you to balance speed against memory
* usage for your application. Not all database/driver combinations support
* setting of the prefetch size. A larger prefetch size results in
* increased performance at the cost of higher memory usage.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_PREFETCH = 1;
/**
* Sets the timeout value in seconds for communications with the database.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_TIMEOUT = 2;
/**
* See the Errors and error
* handling section for more information about this attribute.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_ERRMODE = 3;
/**
* This is a read only attribute; it will return information about the
* version of the database server to which PDO is connected.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_SERVER_VERSION = 4;
/**
* This is a read only attribute; it will return information about the
* version of the client libraries that the PDO driver is using.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_CLIENT_VERSION = 5;
/**
* This is a read only attribute; it will return some meta information about the
* database server to which PDO is connected.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_SERVER_INFO = 6;
const ATTR_CONNECTION_STATUS = 7;
/**
* Force column names to a specific case specified by the PDO::CASE_*
* constants.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_CASE = 8;
/**
* Get or set the name to use for a cursor. Most useful when using
* scrollable cursors and positioned updates.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_CURSOR_NAME = 9;
/**
* Selects the cursor type. PDO currently supports either
* PDO::CURSOR_FWDONLY and
* PDO::CURSOR_SCROLL. Stick with
* PDO::CURSOR_FWDONLY unless you know that you need a
* scrollable cursor.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_CURSOR = 10;
/**
* Convert empty strings to SQL NULL values on data fetches.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_ORACLE_NULLS = 11;
/**
* Request a persistent connection, rather than creating a new connection.
* See Connections and Connection
* management for more information on this attribute.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_PERSISTENT = 12;
const ATTR_STATEMENT_CLASS = 13;
/**
* Prepend the containing table name to each column name returned in the
* result set. The table name and column name are separated by a decimal (.)
* character. Support of this attribute is at the driver level; it may not
* be supported by your driver.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_FETCH_TABLE_NAMES = 14;
/**
* Prepend the containing catalog name to each column name returned in the
* result set. The catalog name and column name are separated by a decimal
* (.) character. Support of this attribute is at the driver level; it may
* not be supported by your driver.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_FETCH_CATALOG_NAMES = 15;
/**
* Returns the name of the driver.
*
* using PDO::ATTR_DRIVER_NAME
*
* if ($db->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
* echo "Running on mysql; doing something mysql specific here\n";
* }
*
*
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_DRIVER_NAME = 16;
const ATTR_STRINGIFY_FETCHES = 17;
const ATTR_MAX_COLUMN_LEN = 18;
/**
* Available since PHP 5.1.3.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_EMULATE_PREPARES = 20;
/**
* Available since PHP 5.2.0
* @link http://php.net/manual/en/pdo.constants.php
*/
const ATTR_DEFAULT_FETCH_MODE = 19;
/**
* Do not raise an error or exception if an error occurs. The developer is
* expected to explicitly check for errors. This is the default mode.
* See Errors and error handling
* for more information about this attribute.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ERRMODE_SILENT = 0;
/**
* Issue a PHP E_WARNING message if an error occurs.
* See Errors and error handling
* for more information about this attribute.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ERRMODE_WARNING = 1;
/**
* Throw a PDOException if an error occurs.
* See Errors and error handling
* for more information about this attribute.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ERRMODE_EXCEPTION = 2;
/**
* Leave column names as returned by the database driver.
* @link http://php.net/manual/en/pdo.constants.php
*/
const CASE_NATURAL = 0;
/**
* Force column names to lower case.
* @link http://php.net/manual/en/pdo.constants.php
*/
const CASE_LOWER = 2;
/**
* Force column names to upper case.
* @link http://php.net/manual/en/pdo.constants.php
*/
const CASE_UPPER = 1;
const NULL_NATURAL = 0;
const NULL_EMPTY_STRING = 1;
const NULL_TO_STRING = 2;
/**
* Corresponds to SQLSTATE '00000', meaning that the SQL statement was
* successfully issued with no errors or warnings. This constant is for
* your convenience when checking PDO::errorCode or
* PDOStatement::errorCode to determine if an error
* occurred. You will usually know if this is the case by examining the
* return code from the method that raised the error condition anyway.
* @link http://php.net/manual/en/pdo.constants.php
*/
const ERR_NONE = 00000;
/**
* Fetch the next row in the result set. Valid only for scrollable cursors.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_ORI_NEXT = 0;
/**
* Fetch the previous row in the result set. Valid only for scrollable
* cursors.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_ORI_PRIOR = 1;
/**
* Fetch the first row in the result set. Valid only for scrollable cursors.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_ORI_FIRST = 2;
/**
* Fetch the last row in the result set. Valid only for scrollable cursors.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_ORI_LAST = 3;
/**
* Fetch the requested row by row number from the result set. Valid only
* for scrollable cursors.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_ORI_ABS = 4;
/**
* Fetch the requested row by relative position from the current position
* of the cursor in the result set. Valid only for scrollable cursors.
* @link http://php.net/manual/en/pdo.constants.php
*/
const FETCH_ORI_REL = 5;
/**
* Create a PDOStatement object with a forward-only cursor. This is the
* default cursor choice, as it is the fastest and most common data access
* pattern in PHP.
* @link http://php.net/manual/en/pdo.constants.php
*/
const CURSOR_FWDONLY = 0;
/**
* Create a PDOStatement object with a scrollable cursor. Pass the
* PDO::FETCH_ORI_* constants to control the rows fetched from the result set.
* @link http://php.net/manual/en/pdo.constants.php
*/
const CURSOR_SCROLL = 1;
/**
* If this attribute is set to TRUE on a
* PDOStatement, the MySQL driver will use the
* buffered versions of the MySQL API. If you're writing portable code, you
* should use PDOStatement::fetchAll instead.
*
* Forcing queries to be buffered in mysql
*
* if ($db->getAttribute(PDO::ATTR_DRIVER_NAME) == 'mysql') {
* $stmt = $db->prepare('select * from foo',
* array(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY => true));
* } else {
* die("my application only works with mysql; I should use \$stmt->fetchAll() instead");
* }
*
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_USE_BUFFERED_QUERY = 1000;
/**
*
* Enable LOAD LOCAL INFILE.
*
*
* Note, this constant can only be used in the driver_options
* array when constructing a new database handle.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_LOCAL_INFILE = 1001;
/**
*
* Command to execute when connecting to the MySQL server. Will
* automatically be re-executed when reconnecting.
*
*
* Note, this constant can only be used in the driver_options
* array when constructing a new database handle.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_INIT_COMMAND = 1002;
/**
*
* Maximum buffer size. Defaults to 1 MiB. This constant is not supported when
* compiled against mysqlnd.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_MAX_BUFFER_SIZE = 1005;
/**
*
* Read options from the named option file instead of from
* my.cnf. This option is not available if
* mysqlnd is used, because mysqlnd does not read the mysql
* configuration files.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_READ_DEFAULT_FILE = 1003;
/**
*
* Read options from the named group from my.cnf or the
* file specified with MYSQL_READ_DEFAULT_FILE. This option
* is not available if mysqlnd is used, because mysqlnd does not read the mysql
* configuration files.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_READ_DEFAULT_GROUP = 1004;
/**
*
* Enable network communication compression. This is not supported when
* compiled against mysqlnd.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_COMPRESS = 1006;
/**
*
* Perform direct queries, don't use prepared statements.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_DIRECT_QUERY = 1007;
/**
*
* Return the number of found (matched) rows, not the
* number of changed rows.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_FOUND_ROWS = 1008;
/**
*
* Permit spaces after function names. Makes all functions
* names reserved words.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_IGNORE_SPACE = 1009;
const MYSQL_ATTR_SSL_KEY = 1010;
/**
*
* The file path to the SSL certificate.
*
*
* This exists as of PHP 5.3.7.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_SSL_CERT = 1011;
/**
*
* The file path to the SSL certificate authority.
*
*
* This exists as of PHP 5.3.7.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_SSL_CA = 1012;
/**
*
* The file path to the directory that contains the trusted SSL
* CA certificates, which are stored in PEM format.
*
*
* This exists as of PHP 5.3.7.
*
* @link http://php.net/manual/en/pdo-mysql.constants.php
*/
const MYSQL_ATTR_SSL_CAPATH = 1013;
const MYSQL_ATTR_SSL_CIPHER = 1014;
const PGSQL_ATTR_DISABLE_NATIVE_PREPARED_STATEMENT = 1000;
const PGSQL_TRANSACTION_IDLE = 0;
const PGSQL_TRANSACTION_ACTIVE = 1;
const PGSQL_TRANSACTION_INTRANS = 2;
const PGSQL_TRANSACTION_INERROR = 3;
const PGSQL_TRANSACTION_UNKNOWN = 4;
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Creates a PDO instance representing a connection to a database
* @link http://php.net/manual/en/pdo.construct.php
* @param $dsn
* @param $username
* @param $passwd
* @param $options [optional]
*/
public function __construct ($dsn, $username, $passwd, $options) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Prepares a statement for execution and returns a statement object
* @link http://php.net/manual/en/pdo.prepare.php
* @param string $statement
* This must be a valid SQL statement for the target database server.
*
* @param array $driver_options [optional]
* This array holds one or more key=>value pairs to set
* attribute values for the PDOStatement object that this method
* returns. You would most commonly use this to set the
* PDO::ATTR_CURSOR value to
* PDO::CURSOR_SCROLL to request a scrollable cursor.
* Some drivers have driver specific options that may be set at
* prepare-time.
*
* @return PDOStatement If the database server successfully prepares the statement,
* PDO::prepare returns a
* PDOStatement object.
* If the database server cannot successfully prepare the statement,
* PDO::prepare returns FALSE or emits
* PDOException (depending on error handling).
*
*
* Emulated prepared statements does not communicate with the database server
* so PDO::prepare does not check the statement.
*/
public function prepare ($statement, array $driver_options = 'array()') {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Initiates a transaction
* @link http://php.net/manual/en/pdo.begintransaction.php
* @return bool TRUE on success or FALSE on failure.
*/
public function beginTransaction () {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Commits a transaction
* @link http://php.net/manual/en/pdo.commit.php
* @return bool TRUE on success or FALSE on failure.
*/
public function commit () {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Rolls back a transaction
* @link http://php.net/manual/en/pdo.rollback.php
* @return bool TRUE on success or FALSE on failure.
*/
public function rollBack () {}
/**
* (PHP 5 >= 5.3.3, Bundled pdo_pgsql)
* Checks if inside a transaction
* @link http://php.net/manual/en/pdo.intransaction.php
* @return bool TRUE if a transaction is currently active, and FALSE if not.
*/
public function inTransaction () {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Set an attribute
* @link http://php.net/manual/en/pdo.setattribute.php
* @param int $attribute
* @param mixed $value
* @return bool TRUE on success or FALSE on failure.
*/
public function setAttribute ($attribute, $value) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Execute an SQL statement and return the number of affected rows
* @link http://php.net/manual/en/pdo.exec.php
* @param string $statement
* The SQL statement to prepare and execute.
*
*
* Data inside the query should be properly escaped.
*
* @return int PDO::exec returns the number of rows that were modified
* or deleted by the SQL statement you issued. If no rows were affected,
* PDO::exec returns 0.
*
* This function may
* return Boolean FALSE, but may also return a non-Boolean value which
* evaluates to FALSE. Please read the section on Booleans for more
* information. Use the ===
* operator for testing the return value of this
* function.
*
* The following example incorrectly relies on the return value of
* PDO::exec, wherein a statement that affected 0 rows
* results in a call to die:
*
* $db->exec() or die(print_r($db->errorInfo(), true));
*
*/
public function exec ($statement) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.2.0)
* Executes an SQL statement, returning a result set as a PDOStatement object
* @link http://php.net/manual/en/pdo.query.php
* @param string $statement
* The SQL statement to prepare and execute.
*
*
* Data inside the query should be properly escaped.
*
* @return PDOStatement PDO::query returns a PDOStatement object, or FALSE
* on failure.
*/
public function query ($statement) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Returns the ID of the last inserted row or sequence value
* @link http://php.net/manual/en/pdo.lastinsertid.php
* @param string $name [optional]
* Name of the sequence object from which the ID should be returned.
*
* @return string If a sequence name was not specified for the name
* parameter, PDO::lastInsertId returns a
* string representing the row ID of the last row that was inserted into
* the database.
*
*
* If a sequence name was specified for the name
* parameter, PDO::lastInsertId returns a
* string representing the last value retrieved from the specified sequence
* object.
*
*
* If the PDO driver does not support this capability,
* PDO::lastInsertId triggers an
* IM001 SQLSTATE.
*/
public function lastInsertId ($name = null) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Fetch the SQLSTATE associated with the last operation on the database handle
* @link http://php.net/manual/en/pdo.errorcode.php
* @return mixed an SQLSTATE, a five characters alphanumeric identifier defined in
* the ANSI SQL-92 standard. Briefly, an SQLSTATE consists of a
* two characters class value followed by a three characters subclass value. A
* class value of 01 indicates a warning and is accompanied by a return code
* of SQL_SUCCESS_WITH_INFO. Class values other than '01', except for the
* class 'IM', indicate an error. The class 'IM' is specific to warnings
* and errors that derive from the implementation of PDO (or perhaps ODBC,
* if you're using the ODBC driver) itself. The subclass value '000' in any
* class indicates that there is no subclass for that SQLSTATE.
*
*
* PDO::errorCode only retrieves error codes for operations
* performed directly on the database handle. If you create a PDOStatement
* object through PDO::prepare or
* PDO::query and invoke an error on the statement
* handle, PDO::errorCode will not reflect that error.
* You must call PDOStatement::errorCode to return the error
* code for an operation performed on a particular statement handle.
*
*
* Returns NULL if no operation has been run on the database handle.
*/
public function errorCode () {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Fetch extended error information associated with the last operation on the database handle
* @link http://php.net/manual/en/pdo.errorinfo.php
* @return array PDO::errorInfo returns an array of error information
* about the last operation performed by this database handle. The array
* consists of the following fields:
*
* | Element |
* Information |
*
*
* | 0 |
* SQLSTATE error code (a five characters alphanumeric identifier defined
* in the ANSI SQL standard). |
*
*
* | 1 |
* Driver-specific error code. |
*
*
* | 2 |
* Driver-specific error message. |
*
*
*
* If the SQLSTATE error code is not set or there is no driver-specific
* error, the elements following element 0 will be set to NULL.
*
*
* PDO::errorInfo only retrieves error information for
* operations performed directly on the database handle. If you create a
* PDOStatement object through PDO::prepare or
* PDO::query and invoke an error on the statement
* handle, PDO::errorInfo will not reflect the error
* from the statement handle. You must call
* PDOStatement::errorInfo to return the error
* information for an operation performed on a particular statement handle.
*/
public function errorInfo () {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.2.0)
* Retrieve a database connection attribute
* @link http://php.net/manual/en/pdo.getattribute.php
* @param int $attribute
* One of the PDO::ATTR_* constants. The constants that
* apply to database connections are as follows:
* PDO::ATTR_AUTOCOMMIT
* PDO::ATTR_CASE
* PDO::ATTR_CLIENT_VERSION
* PDO::ATTR_CONNECTION_STATUS
* PDO::ATTR_DRIVER_NAME
* PDO::ATTR_ERRMODE
* PDO::ATTR_ORACLE_NULLS
* PDO::ATTR_PERSISTENT
* PDO::ATTR_PREFETCH
* PDO::ATTR_SERVER_INFO
* PDO::ATTR_SERVER_VERSION
* PDO::ATTR_TIMEOUT
*
* @return mixed A successful call returns the value of the requested PDO attribute.
* An unsuccessful call returns null.
*/
public function getAttribute ($attribute) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.2.1)
* Quotes a string for use in a query.
* @link http://php.net/manual/en/pdo.quote.php
* @param string $string
* The string to be quoted.
*
* @param int $parameter_type [optional]
* Provides a data type hint for drivers that have alternate quoting styles.
*
* @return string a quoted string that is theoretically safe to pass into an
* SQL statement. Returns FALSE if the driver does not support quoting in
* this way.
*/
public function quote ($string, $parameter_type = 'PDO::PARAM_STR') {}
final public function __wakeup () {}
final public function __sleep () {}
/**
* (PHP 5 >= 5.1.3, PECL pdo >= 1.0.3)
* Return an array of available PDO drivers
* @link http://php.net/manual/en/pdo.getavailabledrivers.php
* @return array PDO::getAvailableDrivers returns an array of PDO driver names. If
* no drivers are available, it returns an empty array.
*/
public static function getAvailableDrivers () {}
}
/**
* Represents a prepared statement and, after the statement is executed, an
* associated result set.
* @link http://php.net/manual/en/class.pdostatement.php
*/
class PDOStatement implements Traversable {
/**
* @var string
*/
public $queryString;
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Executes a prepared statement
* @link http://php.net/manual/en/pdostatement.execute.php
* @param array $input_parameters [optional]
* An array of values with as many elements as there are bound
* parameters in the SQL statement being executed.
* All values are treated as PDO::PARAM_STR.
*
*
* You cannot bind multiple values to a single parameter; for example,
* you cannot bind two values to a single named parameter in an IN()
* clause.
*
*
* You cannot bind more values than specified; if more keys exist in
* input_parameters than in the SQL specified
* in the PDO::prepare, then the statement will
* fail and an error is emitted.
*
* @return bool TRUE on success or FALSE on failure.
*/
public function execute (array $input_parameters = null) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Fetches the next row from a result set
* @link http://php.net/manual/en/pdostatement.fetch.php
* @param int $fetch_style [optional]
* Controls how the next row will be returned to the caller. This value
* must be one of the PDO::FETCH_* constants,
* defaulting to value of PDO::ATTR_DEFAULT_FETCH_MODE
* (which defaults to PDO::FETCH_BOTH).
*
* PDO::FETCH_ASSOC: returns an array indexed by column
* name as returned in your result set
*
* @param int $cursor_orientation [optional]
* For a PDOStatement object representing a scrollable cursor, this
* value determines which row will be returned to the caller. This value
* must be one of the PDO::FETCH_ORI_* constants,
* defaulting to PDO::FETCH_ORI_NEXT. To request a
* scrollable cursor for your PDOStatement object, you must set the
* PDO::ATTR_CURSOR attribute to
* PDO::CURSOR_SCROLL when you prepare the SQL
* statement with PDO::prepare.
*
* @param int $cursor_offset [optional]
* @return mixed The return value of this function on success depends on the fetch type. In
* all cases, FALSE is returned on failure.
*/
public function fetch ($fetch_style = null, $cursor_orientation = 'PDO::FETCH_ORI_NEXT', $cursor_offset = 0) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Binds a parameter to the specified variable name
* @link http://php.net/manual/en/pdostatement.bindparam.php
* @param mixed $parameter
* Parameter identifier. For a prepared statement using named
* placeholders, this will be a parameter name of the form
* :name. For a prepared statement using
* question mark placeholders, this will be the 1-indexed position of
* the parameter.
*
* @param mixed $variable
* Name of the PHP variable to bind to the SQL statement parameter.
*
* @param int $data_type [optional]
* Explicit data type for the parameter using the PDO::PARAM_*
* constants.
* To return an INOUT parameter from a stored procedure,
* use the bitwise OR operator to set the PDO::PARAM_INPUT_OUTPUT bits
* for the data_type parameter.
*
* @param int $length [optional]
* Length of the data type. To indicate that a parameter is an OUT
* parameter from a stored procedure, you must explicitly set the
* length.
*
* @param mixed $driver_options [optional]
*
* @return bool TRUE on success or FALSE on failure.
*/
public function bindParam ($parameter, &$variable, $data_type = 'PDO::PARAM_STR', $length = null, $driver_options = null) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Bind a column to a PHP variable
* @link http://php.net/manual/en/pdostatement.bindcolumn.php
* @param mixed $column
* Number of the column (1-indexed) or name of the column in the result set.
* If using the column name, be aware that the name should match the
* case of the column, as returned by the driver.
*
* @param mixed $param
* Name of the PHP variable to which the column will be bound.
*
* @param int $type [optional]
* Data type of the parameter, specified by the PDO::PARAM_* constants.
*
* @param int $maxlen [optional]
* A hint for pre-allocation.
*
* @param mixed $driverdata [optional]
* Optional parameter(s) for the driver.
*
* @return bool TRUE on success or FALSE on failure.
*/
public function bindColumn ($column, &$param, $type = null, $maxlen = null, $driverdata = null) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 1.0.0)
* Binds a value to a parameter
* @link http://php.net/manual/en/pdostatement.bindvalue.php
* @param mixed $parameter
* Parameter identifier. For a prepared statement using named
* placeholders, this will be a parameter name of the form
* :name. For a prepared statement using
* question mark placeholders, this will be the 1-indexed position of
* the parameter.
*
* @param mixed $value
* The value to bind to the parameter.
*
* @param int $data_type [optional]
* Explicit data type for the parameter using the PDO::PARAM_*
* constants.
*
* @return bool TRUE on success or FALSE on failure.
*/
public function bindValue ($parameter, $value, $data_type = 'PDO::PARAM_STR') {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Returns the number of rows affected by the last SQL statement
* @link http://php.net/manual/en/pdostatement.rowcount.php
* @return int the number of rows.
*/
public function rowCount () {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.9.0)
* Returns a single column from the next row of a result set
* @link http://php.net/manual/en/pdostatement.fetchcolumn.php
* @param int $column_number [optional]
* 0-indexed number of the column you wish to retrieve from the row. If
* no value is supplied, PDOStatement::fetchColumn
* fetches the first column.
*
* @return string PDOStatement::fetchColumn returns a single column
* in the next row of a result set.
*
*
* There is no way to return another column from the same row if you
* use PDOStatement::fetchColumn to retrieve data.
*/
public function fetchColumn ($column_number = 0) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Returns an array containing all of the result set rows
* @link http://php.net/manual/en/pdostatement.fetchall.php
* @param int $fetch_style [optional]
* Controls the contents of the returned array as documented in
* PDOStatement::fetch.
* Defaults to value of PDO::ATTR_DEFAULT_FETCH_MODE
* (which defaults to PDO::FETCH_BOTH)
*
*
* To return an array consisting of all values of a single column from
* the result set, specify PDO::FETCH_COLUMN. You
* can specify which column you want with the
* column-index parameter.
*
*
* To fetch only the unique values of a single column from the result set,
* bitwise-OR PDO::FETCH_COLUMN with
* PDO::FETCH_UNIQUE.
*
*
* To return an associative array grouped by the values of a specified
* column, bitwise-OR PDO::FETCH_COLUMN with
* PDO::FETCH_GROUP.
*
* @param mixed $fetch_argument [optional]
* This argument have a different meaning depending on the value of
* the fetch_style parameter:
*
* PDO::FETCH_COLUMN: Returns the indicated 0-indexed
* column.
*
* @param array $ctor_args [optional]
* Arguments of custom class constructor when the fetch_style
* parameter is PDO::FETCH_CLASS.
*
* @return array PDOStatement::fetchAll returns an array containing
* all of the remaining rows in the result set. The array represents each
* row as either an array of column values or an object with properties
* corresponding to each column name.
*
*
* Using this method to fetch large result sets will result in a heavy
* demand on system and possibly network resources. Rather than retrieving
* all of the data and manipulating it in PHP, consider using the database
* server to manipulate the result sets. For example, use the WHERE and
* ORDER BY clauses in SQL to restrict results before retrieving and
* processing them with PHP.
*/
public function fetchAll ($fetch_style = null, $fetch_argument = null, array $ctor_args = 'array()') {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.2.4)
* Fetches the next row and returns it as an object.
* @link http://php.net/manual/en/pdostatement.fetchobject.php
* @param string $class_name [optional]
* Name of the created class.
*
* @param array $ctor_args [optional]
* Elements of this array are passed to the constructor.
*
* @return mixed an instance of the required class with property names that
* correspond to the column names or FALSE on failure.
*/
public function fetchObject ($class_name = "stdClass", array $ctor_args = null) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Fetch the SQLSTATE associated with the last operation on the statement handle
* @link http://php.net/manual/en/pdostatement.errorcode.php
* @return string Identical to PDO::errorCode, except that
* PDOStatement::errorCode only retrieves error codes
* for operations performed with PDOStatement objects.
*/
public function errorCode () {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.1.0)
* Fetch extended error information associated with the last operation on the statement handle
* @link http://php.net/manual/en/pdostatement.errorinfo.php
* @return array PDOStatement::errorInfo returns an array of
* error information about the last operation performed by this
* statement handle. The array consists of the following fields:
*
* | Element |
* Information |
*
*
* | 0 |
* SQLSTATE error code (a five characters alphanumeric identifier defined
* in the ANSI SQL standard). |
*
*
* | 1 |
* Driver specific error code. |
*
*
* | 2 |
* Driver specific error message. |
*
*/
public function errorInfo () {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.2.0)
* Set a statement attribute
* @link http://php.net/manual/en/pdostatement.setattribute.php
* @param int $attribute
* @param mixed $value
* @return bool TRUE on success or FALSE on failure.
*/
public function setAttribute ($attribute, $value) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.2.0)
* Retrieve a statement attribute
* @link http://php.net/manual/en/pdostatement.getattribute.php
* @param int $attribute
* @return mixed the attribute value.
*/
public function getAttribute ($attribute) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.2.0)
* Returns the number of columns in the result set
* @link http://php.net/manual/en/pdostatement.columncount.php
* @return int the number of columns in the result set represented by the
* PDOStatement object. If there is no result set,
* PDOStatement::columnCount returns 0.
*/
public function columnCount () {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.2.0)
* Returns metadata for a column in a result set
* @link http://php.net/manual/en/pdostatement.getcolumnmeta.php
* @param int $column
* The 0-indexed column in the result set.
*
* @return array an associative array containing the following values representing
* the metadata for a single column:
*
*
* Column metadata
*
* | Name |
* Value |
*
*
* | native_type |
* The PHP native type used to represent the column value. |
*
*
* | driver:decl_type |
* The SQL type used to represent the column value in the database.
* If the column in the result set is the result of a function, this value
* is not returned by PDOStatement::getColumnMeta.
* |
*
*
* | flags |
* Any flags set for this column. |
*
*
* | name |
* The name of this column as returned by the database. |
*
*
* | table |
* The name of this column's table as returned by the database. |
*
*
* | len |
* The length of this column. Normally -1 for
* types other than floating point decimals. |
*
*
* | precision |
* The numeric precision of this column. Normally
* 0 for types other than floating point
* decimals. |
*
*
* | pdo_type |
* The type of this column as represented by the
* PDO::PARAM_* constants. |
*
*
*
* Returns FALSE if the requested column does not exist in the result set,
* or if no result set exists.
*/
public function getColumnMeta ($column) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.2.0)
* Set the default fetch mode for this statement
* @link http://php.net/manual/en/pdostatement.setfetchmode.php
* @param int $mode
* The fetch mode must be one of the PDO::FETCH_* constants.
*
* @return bool 1 on success or FALSE on failure.
*/
public function setFetchMode ($mode) {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.2.0)
* Advances to the next rowset in a multi-rowset statement handle
* @link http://php.net/manual/en/pdostatement.nextrowset.php
* @return bool TRUE on success or FALSE on failure.
*/
public function nextRowset () {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.9.0)
* Closes the cursor, enabling the statement to be executed again.
* @link http://php.net/manual/en/pdostatement.closecursor.php
* @return bool TRUE on success or FALSE on failure.
*/
public function closeCursor () {}
/**
* (PHP 5 >= 5.1.0, PECL pdo >= 0.9.0)
* Dump an SQL prepared command
* @link http://php.net/manual/en/pdostatement.debugdumpparams.php
* @return bool No value is returned.
*/
public function debugDumpParams () {}
final public function __wakeup () {}
final public function __sleep () {}
}
final class PDORow {
}
function pdo_drivers () {}
// End of PDO v.1.0.4dev
?>