mirror of
https://github.com/php/pecl-database-pdo_user.git
synced 2026-03-23 22:42:10 +01:00
295 lines
7.4 KiB
Plaintext
295 lines
7.4 KiB
Plaintext
PDO Userspace Driver
|
|
--------------------
|
|
|
|
This extension exports three class definitions (two interfaces plus one static class):
|
|
|
|
interface PDO_User_Driver {
|
|
function __construct($dsn, $user, $pass, $options) {
|
|
/* new PDO('user:driver=classname;...') */
|
|
}
|
|
|
|
function pdo_prepare($sql, $options) {
|
|
/* PDO::prepare() or PDO::query() */
|
|
|
|
if (SUCCESS) {
|
|
return new Object_Implementing_PDO_User_Statement($optional, $parameters);
|
|
} else {
|
|
/* If your class will be unable to perform the query, return false here to indicate failure */
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_do($sql) {
|
|
/* PDO::exec() */
|
|
if (SUCCESS) {
|
|
return $rowsAffected;
|
|
} else {
|
|
return FALSE; /* NULL or a negative number may also be used to indicate failure */
|
|
}
|
|
}
|
|
|
|
function pdo_quote($string) {
|
|
/* PDO::quote() */
|
|
|
|
/* There is no "failure" mode for this method, you must return something */
|
|
return $modifiedString;
|
|
}
|
|
|
|
function pdo_begin() {
|
|
/* PDO::beginTransaction() */
|
|
if (SUCCESS) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_commit() {
|
|
/* PDO::commit() */
|
|
if (SUCCESS) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_rollback() {
|
|
/* PDO::rollBack() */
|
|
if (SUCCESS) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_lastInsertID($seq) {
|
|
/* PDO::lastInsertID() */
|
|
|
|
/* There is no "failure" mode for this method, you must return something */
|
|
return $lastIDString;
|
|
}
|
|
|
|
function pdo_checkLiveness() {
|
|
/* Called by PDO internally */
|
|
return $driverIsAliveBool;
|
|
}
|
|
|
|
function pdo_setAttribute($attr, $val) {
|
|
/* PDO::setAttribute($attr, $val) */
|
|
|
|
/* $attr == PDO::ATTR_* */
|
|
if (SUCCESS) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_getAttribute($attr) {
|
|
/* PDO::getAttribute($attr) */
|
|
|
|
/* $attr == PDO::ATTR_* */
|
|
if (SUCCESS) {
|
|
return $attributeValue;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_close() {
|
|
/* Called when shutting down a database handle - e.g. unset($pdoHandle); */
|
|
|
|
/* Return value ignored */
|
|
}
|
|
|
|
function pdo_fetchError() {
|
|
/* PDO::errorInfo */
|
|
|
|
return array(0 => 12345, 1 => 'Error 12345 has occured...blah...blah...blah');
|
|
}
|
|
}
|
|
|
|
interface PDO_User_Statement {
|
|
function pdo_execute() {
|
|
/* PDO_Statement::execute() */
|
|
|
|
/* The result of emulated bound parameters may be retreived via: */
|
|
$resultQuery = PDO_User::statementParam($this, PDO_User::STATEMENT_PARAM_ACTIVE_QUERY);
|
|
|
|
if (SUCCESS) {
|
|
return array('rows' => $numberOfRowsInSet, 'cols' => $numberOfColsInSet);
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_fetch($orientation, $offset) {
|
|
/* PDO_Statement::fetch() and family */
|
|
|
|
/* This method should only adjust the current cursor's position,
|
|
* getcol() will be used to actually retreive the data */
|
|
|
|
/* $orientation is one of PDO::FETCH_ORI_*
|
|
* $offset is a relative position to the location tagged by $orientation */
|
|
if (SUCCESS) {
|
|
return true;
|
|
} else {
|
|
/* e.g. - No more rows */
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_nextRowset() {
|
|
/* PDO_Statement::nextRowset() */
|
|
|
|
if (SUCCESS) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_describe($columnNumber) {
|
|
/* Called after PDO_Statement::execute() to determine column names,
|
|
* also used by PDO_Statement::getColumnMeta() */
|
|
return array('name' => $nameOfColumn, 'maxlen' => $maximumLengthOfDataInColumn);
|
|
}
|
|
|
|
function pdo_colmeta($columnNumber) {
|
|
/* PDO_Statement::getColumnMeta() */
|
|
/* Return as many of the supported fields as possible,
|
|
* custom fields may also be returned by prefixing with user: */
|
|
return array('scale' => $floatingPointScale,
|
|
'table' => $sourceTable,
|
|
'type' => $phpTypeName, /* e.g. 'string', 'integer', 'bool' */
|
|
'native_type' => $dbTypeName, /* e.g. 'char', 'blog', 'double' */
|
|
'flags' => array( 'primary_key',
|
|
'not_null',
|
|
'unique_key',
|
|
'multiple_key',
|
|
'unsigned',
|
|
'auto_increment',
|
|
'blob',
|
|
'user:foo', /* custom flag(s) */
|
|
),
|
|
'user:bar' => 'baz' /* custom metadata(s) */
|
|
);
|
|
}
|
|
|
|
function pdo_getcol($columnNumber) {
|
|
/* Called by PDO_Statement::fetch() family of functions */
|
|
|
|
return $contentsOfColumnForCurrentRow;
|
|
}
|
|
|
|
function pdo_paramhook($event, $columnNumber, $columnName, $isParam, &$parameter) {
|
|
/* Called before and after EXEC and FETCH events */
|
|
/* $event is one of PDO::PARAM_EVT_EXEC_* or PDO_PARAM_EVT_FETCH_*
|
|
* $columnNumber / $columnName are the identifiers of the column, either or both may be available
|
|
* $isParam is TRUE for placeholder parameters (e.g. WHERE foo = ?), it is FALSE for result parameters (e.g. SELECT col1)
|
|
* $parameter is the actual bound variable and is always passed by reference */
|
|
|
|
/* Return value is ignored */
|
|
}
|
|
|
|
function pdo_setAttribute($attr, $val) {
|
|
/* PDO_Statement::setAttribute($attr, $val) */
|
|
|
|
/* $attr == PDO::ATTR_* */
|
|
if (SUCCESS) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_getAttribute($attr) {
|
|
/* PDO_Statement::getAttribute($attr) */
|
|
|
|
/* $attr == PDO::ATTR_* */
|
|
if (SUCCESS) {
|
|
return $attributeValue;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_closeCursor() {
|
|
/* PDO_Statement::closeCursor() */
|
|
|
|
if (SUCCESS) {
|
|
return true;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function pdo_close() {
|
|
/* Called with shutting down a statement */
|
|
|
|
/* Return value ignored */
|
|
}
|
|
}
|
|
|
|
class PDO_User {
|
|
function parseDSN($dsn, $params) {
|
|
/* Parses a DSN string in the format: var1=val1;var2=val2;var3=val3;...
|
|
* For the variables named in $params, For example:
|
|
|
|
$result = PDO_User::parseDSN('host=localhost;port=3306', array('host','port'));
|
|
print_r($result);
|
|
|
|
* Results in:
|
|
|
|
Array(2) {
|
|
[host] => localhost
|
|
[port] => 3306
|
|
}
|
|
|
|
*/
|
|
}
|
|
|
|
function driverParam($attribute[, $value]) {
|
|
/* $attribute is one of:
|
|
PDO_User::DRIVER_PARAM_MAX_ESCAPSED_CHAR_LENGTH (used by emulated prepared statement routines internally)
|
|
PDO_User::DRIVER_PARAM_DATA_SOURCE (refers to the $dsn passed to the driver class' constructor)
|
|
PDO_User::DRIVER_PARAM_SQLSTATE (Driver's current SQLSTATE value)
|
|
|
|
PDO_User::STATEMENT_PARAM_ACTIVE_QUERY (Post-transformation emulated prepared statement result)
|
|
PDO_User::STATEMENT_PARAM_SQLSTATE (Statement's current SQLSTATE value)
|
|
|
|
* When $value is passed, the parameter will be set to this new value
|
|
* Whether or not $value is passed, the current value will be returned */
|
|
}
|
|
|
|
function tokenizeSQL($sql[, $ignore_whitespace = true]) {
|
|
/* Split a standard SQL statement into token pieces interpolating some escape sequences in ``, '', and "" pairs
|
|
\\ Literal backslash
|
|
\000 Interpolated to character with identified octal value
|
|
\x00 Interpolated to character with identified hex value
|
|
\r Carriage Return (0x0D)
|
|
\n Line Feed (0x0A)
|
|
\t Tab (0x09)
|
|
\' Single Quote (Only interpolated within '' strings)
|
|
\" Double Quote (Only interpolated within "" strings)
|
|
\` Backtick (Only interpolated witin `` strings)
|
|
|
|
Any other escape sequence will be interpolated as it's literal value, e.g.:
|
|
\a Literal backslash followed by the letter a
|
|
|
|
Returns a 2D array of arrays containing the token id and the source text it came from. */
|
|
}
|
|
|
|
function tokenName($tokenid) {
|
|
/* Returns the textual name of the token ID returned by tokenizeSQL(), e.g.:
|
|
PU_SELECT
|
|
PU_STRING
|
|
PU_WHITESPACE
|
|
etc... */
|
|
}
|
|
|
|
function parseSQL($sql) {
|
|
/* Parse a standard SQL string into a query expression tree */
|
|
}
|
|
}
|