From 1132282fee959cf3ac4216a0bf3e2c7c3fcd89ab Mon Sep 17 00:00:00 2001 From: zYne Date: Thu, 1 Feb 2007 22:46:59 +0000 Subject: [PATCH] Doctrine_Db_Statement no longer depends on PDOStatement --- lib/Doctrine.php | 9 +- lib/Doctrine/Adapter/Statement/Interface.php | 109 +++++- lib/Doctrine/Db.php | 78 ++++- lib/Doctrine/Db/Event.php | 4 +- lib/Doctrine/Db/EventListener/Interface.php | 10 +- lib/Doctrine/Db/Statement.php | 329 ++++++++++++++++++- lib/Doctrine/Hydrate.php | 11 +- lib/Doctrine/Locking/Manager/Pessimistic.php | 2 +- lib/Doctrine/Manager.php | 8 +- tests/Cache/ApcTestCase.php | 2 +- tests/Cache/MemcacheTestCase.php | 13 +- tests/Cache/SqliteTestCase.php | 7 +- tests/CacheTestCase.php | 35 +- tests/run.php | 6 +- 14 files changed, 567 insertions(+), 56 deletions(-) diff --git a/lib/Doctrine.php b/lib/Doctrine.php index 6794908c9..34534894e 100644 --- a/lib/Doctrine.php +++ b/lib/Doctrine.php @@ -150,7 +150,14 @@ final class Doctrine const ATTR_FIELD_CASE = 102; const ATTR_IDXNAME_FORMAT = 103; const ATTR_SEQNAME_FORMAT = 104; + const ATTR_CMPNAME_FORMAT = 118; + const ATTR_DBNAME_FORMAT = 117; + const ATTR_TBLCLASS_FORMAT = 119; + const ATTR_SEQCOL_NAME = 105; + + + const ATTR_PORTABILITY = 106; const ATTR_VLD = 107; const ATTR_COLL_KEY = 108; @@ -162,7 +169,7 @@ final class Doctrine const ATTR_DEF_VARCHAR_LENGTH = 114; const ATTR_DEF_TABLESPACE = 115; const ATTR_EMULATE_DATABASE = 116; - const ATTR_DB_NAME_FORMAT = 117; + /** TODO: REMOVE THE FOLLOWING CONSTANTS AND UPDATE THE DOCS ! */ diff --git a/lib/Doctrine/Adapter/Statement/Interface.php b/lib/Doctrine/Adapter/Statement/Interface.php index 465857389..d028b7cce 100644 --- a/lib/Doctrine/Adapter/Statement/Interface.php +++ b/lib/Doctrine/Adapter/Statement/Interface.php @@ -85,7 +85,7 @@ interface Doctrine_Adapter_Statement_Interface * @param mixed $driverOptions * @return boolean Returns TRUE on success or FALSE on failure. */ - public function bindParam($column, $variable, $type = null, $length = null, $driverOptions); + public function bindParam($column, $variable, $type = null, $length = null, $driverOptions = array()); /** * closeCursor * Closes the cursor, enabling the statement to be executed again. @@ -133,7 +133,7 @@ interface Doctrine_Adapter_Statement_Interface * bound parameters in the SQL statement being executed. * @return boolean Returns TRUE on success or FALSE on failure. */ - public function execute($params); + public function execute(array $params = array()); /** * fetch * @@ -161,26 +161,115 @@ interface Doctrine_Adapter_Statement_Interface * * @return mixed */ - public function fetch($fetchStyle = Doctrine::FETCH_BOTH, + public function fetch($fetchStyle = Doctrine::FETCH_BOTH, $cursorOrientation = Doctrine::FETCH_ORI_NEXT, $cursorOffset = null); /** * fetchAll * Returns an array containing all of the result set rows * - * + * @param integer $fetchStyle Controls how the next row will be returned to the caller. + * This value must be one of the Doctrine::FETCH_* constants, + * defaulting to Doctrine::FETCH_BOTH * * @param integer $columnIndex Returns the indicated 0-indexed column when the value of $fetchStyle is * Doctrine::FETCH_COLUMN. Defaults to 0. * * @return array */ - public function fetchAll($fetchStyle = Doctrine::FETCH_BOTH, - $columnIndex = 0); + public function fetchAll($fetchStyle = Doctrine::FETCH_BOTH); + /** + * fetchColumn + * Returns a single column from the next row of a + * result set or FALSE if there are no more rows. + * + * @param integer $columnIndex 0-indexed number of the column you wish to retrieve from the row. If no + * value is supplied, Doctrine_Adapter_Statement_Interface->fetchColumn() + * fetches the first column. + * + * @return string returns a single column in the next row of a result set. + */ + public function fetchColumn($columnIndex = 0); + /** + * fetchObject + * Fetches the next row and returns it as an object. + * + * Fetches the next row and returns it as an object. This function is an alternative to + * Doctrine_Adapter_Statement_Interface->fetch() with Doctrine::FETCH_CLASS or Doctrine::FETCH_OBJ style. + * + * @param string $className Name of the created class, defaults to stdClass. + * @param array $args 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 in case of an error. + */ + public function fetchObject($className = 'stdClass', $args = array()); + /** + * getAttribute + * Retrieve a statement attribute + * + * @param integer $attribute + * @see Doctrine::ATTR_* constants + * @return mixed the attribute value + */ + public function getAttribute($attribute); + /** + * getColumnMeta + * Returns metadata for a column in a result set + * + * @param integer $column The 0-indexed column in the result set. + * + * @return array Associative meta data array with the following structure: + * + * 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. + * 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. + */ + public function getColumnMeta($column); + /** + * nextRowset + * Advances to the next rowset in a multi-rowset statement handle + * + * Some database servers support stored procedures that return more than one rowset + * (also known as a result set). The nextRowset() method enables you to access the second + * and subsequent rowsets associated with a PDOStatement object. Each rowset can have a + * different set of columns from the preceding rowset. + * + * @return boolean Returns TRUE on success or FALSE on failure. + */ public function nextRowset(); - - + /** + * rowCount + * rowCount() returns the number of rows affected by the last DELETE, INSERT, or UPDATE statement + * executed by the corresponding object. + * + * If the last SQL statement executed by the associated Statement object was a SELECT statement, + * some databases may return the number of rows returned by that statement. However, + * this behaviour is not guaranteed for all databases and should not be + * relied on for portable applications. + * + * @return integer Returns the number of rows. + */ public function rowCount(); - public function setFetchMode($mode); - + /** + * setAttribute + * Set a statement attribute + * + * @param integer $attribute + * @param mixed $value the value of given attribute + * @return boolean Returns TRUE on success or FALSE on failure. + */ + public function setAttribute($attribute, $value); + /** + * setFetchMode + * Set the default fetch mode for this statement + * + * @param integer $mode The fetch mode must be one of the Doctrine::FETCH_* constants. + * @return boolean Returns 1 on success or FALSE on failure. + */ + public function setFetchMode($mode, $arg1 = null, $arg2 = null); } diff --git a/lib/Doctrine/Db.php b/lib/Doctrine/Db.php index 389633d19..ee7e88225 100644 --- a/lib/Doctrine/Db.php +++ b/lib/Doctrine/Db.php @@ -34,12 +34,6 @@ * to database. Connecting to database is only invoked when actually needed * (for example when query() is being called) * - * 3. Portable error codes - * Doctrine_Db_Exception drivers provide portable error code handling. - * - * 4. Easy-to-use fetching methods - * For convience Doctrine_Db provides methods such as fetchOne(), fetchAssoc() etc. - * * @author Konsta Vesterinen * @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @package Doctrine @@ -84,6 +78,12 @@ class Doctrine_Db implements Countable, IteratorAggregate, Doctrine_Adapter_Inte * @var integer $querySequence */ protected $querySequence = 0; + /** + * @var string $name name of this connection + * @see Doctrine_Manager::openConnection() + */ + protected $name; + private static $driverMap = array('oracle' => 'oci8', 'postgres' => 'pgsql', @@ -112,7 +112,7 @@ class Doctrine_Db implements Countable, IteratorAggregate, Doctrine_Adapter_Inte $e[0] = 'odbc'; } - $this->pendingAttributes[PDO::ATTR_DRIVER_NAME] = $e[0]; + $this->pendingAttributes[Doctrine::ATTR_DRIVER_NAME] = $e[0]; } $this->options['dsn'] = $dsn; @@ -133,12 +133,43 @@ class Doctrine_Db implements Countable, IteratorAggregate, Doctrine_Adapter_Inte return $this->querySequence; } /** - * getDBH + * getDbh */ - public function getDBH() + public function getDbh() { return $this->dbh; } + /** + * setAdapter + * + * @param Doctrine_Adapter_Interface|PDO $adapter + * @return void + */ + public function setAdapter($adapter) + { + $this->dbh = $adapter; + } + /** + * setName + * this method should only be used by doctrine internally and + * also for testing purposes + * + * @param string $name connection name + * @return void + */ + public function setName($name) + { + $this->name = $name; + } + /** + * getName + * + * @return string the name of the associated connection + */ + public function getName() + { + return $this->name; + } public function getOption($name) { if ( ! array_key_exists($name, $this->options)) { @@ -203,13 +234,32 @@ class Doctrine_Db implements Countable, IteratorAggregate, Doctrine_Adapter_Inte $this->listener->onPreConnect($event); - $this->dbh = new PDO($this->options['dsn'], $this->options['username'], $this->options['password']); - $this->dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); - $this->dbh->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('Doctrine_Db_Statement', array($this))); + $e = explode(':', $this->options['dsn']); + $found = false; + + if (extension_loaded('pdo')) { + if (in_array($e[0], PDO::getAvailableDrivers())) { + $this->dbh = new PDO($this->options['dsn'], $this->options['username'], $this->options['password']); + $this->dbh->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); + //$this->dbh->setAttribute(PDO::ATTR_STATEMENT_CLASS, array('Doctrine_Db_Statement', array($this))); + $found = true; + } + } + + if ( ! $found) { + $class = 'Doctrine_Adapter_' . ucwords($e[0]); + + if (class_exists($class)) { + $this->dbh = new $class($this->options['dsn'], $this->options['username'], $this->options['password']); + } else { + throw new Doctrine_Db_Exception("Couldn't locate driver named " . $e[0]); + } + } + foreach($this->pendingAttributes as $attr => $value) { // some drivers don't support setting this so we just skip it - if($attr == PDO::ATTR_DRIVER_NAME) { + if($attr == Doctrine::ATTR_DRIVER_NAME) { continue; } $this->dbh->setAttribute($attr, $value); @@ -362,7 +412,7 @@ class Doctrine_Db implements Countable, IteratorAggregate, Doctrine_Adapter_Inte $this->querySequence++; - return $stmt; + return new Doctrine_Db_Statement($this, $stmt); } /** * query diff --git a/lib/Doctrine/Db/Event.php b/lib/Doctrine/Db/Event.php index 175658a53..4241b5185 100644 --- a/lib/Doctrine/Db/Event.php +++ b/lib/Doctrine/Db/Event.php @@ -42,6 +42,8 @@ class Doctrine_Db_Event const COMMIT = 6; const ROLLBACK = 7; const CONNECT = 8; + const FETCH = 9; + const FETCHALL = 10; /** * @var Doctrine_Db $invoker the handler which invoked this event */ @@ -78,7 +80,7 @@ class Doctrine_Db_Event { $this->invoker = $invoker; $this->code = $code; - $this->query = $query; + $this->query = $query; $this->params = $params; } /** diff --git a/lib/Doctrine/Db/EventListener/Interface.php b/lib/Doctrine/Db/EventListener/Interface.php index a10bd3457..5ea2651ea 100644 --- a/lib/Doctrine/Db/EventListener/Interface.php +++ b/lib/Doctrine/Db/EventListener/Interface.php @@ -21,9 +21,13 @@ /** * Doctrine_Db_EventListener * - * @author Konsta Vesterinen - * @license LGPL + * @author Konsta Vesterinen + * @license http://www.opensource.org/licenses/lgpl-license.php LGPL * @package Doctrine + * @category Object Relational Mapping + * @link www.phpdoctrine.com + * @since 1.0 + * @version $Revision$ */ interface Doctrine_Db_EventListener_Interface { public function onPreConnect(Doctrine_Db_Event $event); @@ -40,7 +44,7 @@ interface Doctrine_Db_EventListener_Interface { public function onPreFetch(Doctrine_Db_Event $event); public function onFetch(Doctrine_Db_Event $event); - + public function onPreFetchAll(Doctrine_Db_Event $event); public function onFetchAll(Doctrine_Db_Event $event); diff --git a/lib/Doctrine/Db/Statement.php b/lib/Doctrine/Db/Statement.php index d5794b04d..e6dbc2834 100644 --- a/lib/Doctrine/Db/Statement.php +++ b/lib/Doctrine/Db/Statement.php @@ -31,28 +31,339 @@ */ class Doctrine_Db_Statement implements Doctrine_Adapter_Statement_Interface { - protected $dbh; + protected $adapter; + + protected $stmt; protected $executed = false; - protected function __construct($dbh) + public function __construct($adapter, $stmt) { - $this->dbh = $dbh; + $this->adapter = $adapter; + $this->stmt = $stmt; } + public function getQuery() { - return $this->queryString; + return $this->stmt->queryString; } - public function execute(array $params = null) + /** + * bindColumn + * Bind a column to a PHP variable + * + * @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 string $param Name of the PHP variable to which the column will be bound. + * @param integer $type Data type of the parameter, specified by the Doctrine::PARAM_* constants. + * @return boolean Returns TRUE on success or FALSE on failure + */ + public function bindColumn($column, $param, $type = null) { - $event = new Doctrine_Db_Event($this, Doctrine_Db_Event::EXECUTE, $this->queryString, $params); + if($type === null) { + return $this->stmt->bindValue($column, $param); + } else { + return $this->stmt->bindValue($column, $param, $type); + } + } + /** + * bindValue + * Binds a value to a corresponding named or question mark + * placeholder in the SQL statement that was use to prepare the statement. + * + * @param mixed $param 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 integer $type Explicit data type for the parameter using the Doctrine::PARAM_* constants. + * + * @return boolean Returns TRUE on success or FALSE on failure. + */ + public function bindValue($param, $value, $type = null) + { + if($type === null) { + return $this->stmt->bindValue($param, $value); + } else { + return $this->stmt->bindValue($param, $value, $type); + } + } + /** + * bindParam + * Binds a PHP variable to a corresponding named or question mark placeholder in the + * SQL statement that was use to prepare the statement. Unlike Doctrine_Adapter_Statement_Interface->bindValue(), + * the variable is bound as a reference and will only be evaluated at the time + * that Doctrine_Adapter_Statement_Interface->execute() is called. + * + * Most parameters are input parameters, that is, parameters that are + * used in a read-only fashion to build up the query. Some drivers support the invocation + * of stored procedures that return data as output parameters, and some also as input/output + * parameters that both send in data and are updated to receive it. + * + * @param mixed $param 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 integer $type Explicit data type for the parameter using the Doctrine::PARAM_* constants. To return + * an INOUT parameter from a stored procedure, use the bitwise OR operator to set the + * Doctrine::PARAM_INPUT_OUTPUT bits for the data_type parameter. + * + * @param integer $length 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 $driverOptions + * @return boolean Returns TRUE on success or FALSE on failure. + */ + public function bindParam($column, $variable, $type = null, $length = null, $driverOptions = array()) + { + if($type === null) { + return $this->stmt->bindParam($column, $variable); + } else { + return $this->stmt->bindParam($column, $variable, $type, $length, $driverOptions); + } + } + /** + * closeCursor + * Closes the cursor, enabling the statement to be executed again. + * + * @return boolean Returns TRUE on success or FALSE on failure. + */ + public function closeCursor() + { + return $this->stmt->closeCursor(); + } + /** + * columnCount + * Returns the number of columns in the result set + * + * @return integer Returns the number of columns in the result set represented + * by the Doctrine_Adapter_Statement_Interface object. If there is no result set, + * this method should return 0. + */ + public function columnCount() + { + return $this->stmt->columnCount(); + } + /** + * errorCode + * Fetch the SQLSTATE associated with the last operation on the statement handle + * + * @see Doctrine_Adapter_Interface::errorCode() + * @return string error code string + */ + public function errorCode() + { + return $this->stmt->errorCode(); + } + /** + * errorInfo + * Fetch extended error information associated with the last operation on the statement handle + * + * @see Doctrine_Adapter_Interface::errorInfo() + * @return array error info array + */ + public function errorInfo() + { + return $this->stmt->errorInfo(); + } + /** + * execute + * Executes a prepared statement + * + * If the prepared statement included parameter markers, you must either: + * call PDOStatement->bindParam() to bind PHP variables to the parameter markers: + * bound variables pass their value as input and receive the output value, + * if any, of their associated parameter markers or pass an array of input-only + * parameter values + * + * + * @param array $params An array of values with as many elements as there are + * bound parameters in the SQL statement being executed. + * @return boolean Returns TRUE on success or FALSE on failure. + */ + public function execute(array $params = array()) + { + $event = new Doctrine_Db_Event($this, Doctrine_Db_Event::EXECUTE, $this->stmt->queryString, $params); - $this->dbh->getListener()->onPreExecute($event); + $this->adapter->getListener()->onPreExecute($event); - $ret = parent::execute($params); + $this->stmt->execute($params); - $this->dbh->getListener()->onExecute($event); + $this->adapter->getListener()->onExecute($event); return $this; } + /** + * fetch + * + * @see Doctrine::FETCH_* constants + * @param integer $fetchStyle Controls how the next row will be returned to the caller. + * This value must be one of the Doctrine::FETCH_* constants, + * defaulting to Doctrine::FETCH_BOTH + * + * @param integer $cursorOrientation 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 Doctrine::FETCH_ORI_* constants, defaulting to + * Doctrine::FETCH_ORI_NEXT. To request a scrollable cursor for your + * Doctrine_Adapter_Statement_Interface object, + * you must set the Doctrine::ATTR_CURSOR attribute to Doctrine::CURSOR_SCROLL when you + * prepare the SQL statement with Doctrine_Adapter_Interface->prepare(). + * + * @param integer $cursorOffset For a Doctrine_Adapter_Statement_Interface object representing a scrollable cursor for which the + * $cursorOrientation parameter is set to Doctrine::FETCH_ORI_ABS, this value specifies + * the absolute number of the row in the result set that shall be fetched. + * + * For a Doctrine_Adapter_Statement_Interface object representing a scrollable cursor for + * which the $cursorOrientation parameter is set to Doctrine::FETCH_ORI_REL, this value + * specifies the row to fetch relative to the cursor position before + * Doctrine_Adapter_Statement_Interface->fetch() was called. + * + * @return mixed + */ + public function fetch($fetchStyle = Doctrine::FETCH_BOTH, + $cursorOrientation = Doctrine::FETCH_ORI_NEXT, + $cursorOffset = null) + { + return $this->stmt->fetch($fetchStyle, $cursorOrientation, $cursorOffset); + } + /** + * fetchAll + * Returns an array containing all of the result set rows + * + * + * + * @param integer $columnIndex Returns the indicated 0-indexed column when the value of $fetchStyle is + * Doctrine::FETCH_COLUMN. Defaults to 0. + * + * @return array + */ + public function fetchAll($fetchStyle = Doctrine::FETCH_BOTH, + $columnIndex = null) + { + if($columnIndex !== null) { + return $this->stmt->fetchAll($fetchStyle, $columnIndex); + } else { + return $this->stmt->fetchAll($fetchStyle); + } + } + /** + * fetchColumn + * Returns a single column from the next row of a + * result set or FALSE if there are no more rows. + * + * @param integer $columnIndex 0-indexed number of the column you wish to retrieve from the row. If no + * value is supplied, Doctrine_Adapter_Statement_Interface->fetchColumn() + * fetches the first column. + * + * @return string returns a single column in the next row of a result set. + */ + public function fetchColumn($columnIndex = 0) + { + return $this->stmt->fetchColumn($columnIndex); + } + /** + * fetchObject + * Fetches the next row and returns it as an object. + * + * Fetches the next row and returns it as an object. This function is an alternative to + * Doctrine_Adapter_Statement_Interface->fetch() with Doctrine::FETCH_CLASS or Doctrine::FETCH_OBJ style. + * + * @param string $className Name of the created class, defaults to stdClass. + * @param array $args 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 in case of an error. + */ + public function fetchObject($className = 'stdClass', $args = array()) + { + return $this->stmt->fetchObject($className, $args); + } + /** + * getAttribute + * Retrieve a statement attribute + * + * @param integer $attribute + * @see Doctrine::ATTR_* constants + * @return mixed the attribute value + */ + public function getAttribute($attribute) + { + return $this->stmt->getAttribute($attribute); + } + /** + * getColumnMeta + * Returns metadata for a column in a result set + * + * @param integer $column The 0-indexed column in the result set. + * + * @return array Associative meta data array with the following structure: + * + * 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. + * 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. + */ + public function getColumnMeta($column) + { + return $this->stmt->getColumnMeta($column); + } + /** + * nextRowset + * Advances to the next rowset in a multi-rowset statement handle + * + * Some database servers support stored procedures that return more than one rowset + * (also known as a result set). The nextRowset() method enables you to access the second + * and subsequent rowsets associated with a PDOStatement object. Each rowset can have a + * different set of columns from the preceding rowset. + * + * @return boolean Returns TRUE on success or FALSE on failure. + */ + public function nextRowset() + { + return $this->stmt->nextRowset(); + } + /** + * rowCount + * rowCount() returns the number of rows affected by the last DELETE, INSERT, or UPDATE statement + * executed by the corresponding object. + * + * If the last SQL statement executed by the associated Statement object was a SELECT statement, + * some databases may return the number of rows returned by that statement. However, + * this behaviour is not guaranteed for all databases and should not be + * relied on for portable applications. + * + * @return integer Returns the number of rows. + */ + public function rowCount() + { + return $this->stmt->rowCount(); + } + /** + * setAttribute + * Set a statement attribute + * + * @param integer $attribute + * @param mixed $value the value of given attribute + * @return boolean Returns TRUE on success or FALSE on failure. + */ + public function setAttribute($attribute, $value) + { + return $this->stmt->setAttribute($attribute, $value); + } + /** + * setFetchMode + * Set the default fetch mode for this statement + * + * @param integer $mode The fetch mode must be one of the Doctrine::FETCH_* constants. + * @return boolean Returns 1 on success or FALSE on failure. + */ + public function setFetchMode($mode, $arg1 = null, $arg2 = null) + { + return $this->stmt->setFetchMode($mode, $arg1, $arg2); + } } diff --git a/lib/Doctrine/Hydrate.php b/lib/Doctrine/Hydrate.php index f635f882e..858459252 100644 --- a/lib/Doctrine/Hydrate.php +++ b/lib/Doctrine/Hydrate.php @@ -395,8 +395,9 @@ abstract class Doctrine_Hydrate extends Doctrine_Access } $stmt = $this->conn->execute($query, $params); - if ($this->aggregate) - return $stmt->fetchAll(PDO::FETCH_ASSOC); + if ($this->aggregate) { + return $stmt->fetchAll(Doctrine::FETCH_ASSOC); + } if (count($this->tables) == 0) { throw new Doctrine_Query_Exception("No components selected"); @@ -669,12 +670,12 @@ abstract class Doctrine_Hydrate extends Doctrine_Access } /** * parseData - * parses the data returned by PDOStatement + * parses the data returned by statement object * - * @param PDOStatement $stmt + * @param mixed $stmt * @return array */ - public function parseData(PDOStatement $stmt) + public function parseData($stmt) { $array = array(); diff --git a/lib/Doctrine/Locking/Manager/Pessimistic.php b/lib/Doctrine/Locking/Manager/Pessimistic.php index d38fb2b04..9f33bb9c9 100644 --- a/lib/Doctrine/Locking/Manager/Pessimistic.php +++ b/lib/Doctrine/Locking/Manager/Pessimistic.php @@ -109,7 +109,7 @@ class Doctrine_Locking_Manager_Pessimistic } try { - $dbh = $this->conn->getDBH(); + $dbh = $this->conn->getDbh(); $dbh->beginTransaction(); $stmt = $dbh->prepare("INSERT INTO $this->_lockTable diff --git a/lib/Doctrine/Manager.php b/lib/Doctrine/Manager.php index 7643e7c32..79fd27c1b 100644 --- a/lib/Doctrine/Manager.php +++ b/lib/Doctrine/Manager.php @@ -187,6 +187,10 @@ class Doctrine_Manager extends Doctrine_Configurable implements Countable, Itera throw new Doctrine_Manager_Exception("First argument should be an instance of PDO or implement Doctrine_Adapter_Interface"); } + if ($adapter instanceof Doctrine_Db) { + $adapter->setName($name); + } + // initialize the default attributes $this->setDefaultAttributes(); @@ -229,9 +233,9 @@ class Doctrine_Manager extends Doctrine_Configurable implements Countable, Itera default: throw new Doctrine_Manager_Exception('Unknown connection driver '. $adapter->getAttribute(PDO::ATTR_DRIVER_NAME)); }; - + if ($setCurrent) { - $this->currIndex = $name; + $this->currIndex = $name; } return $this->connections[$name]; } diff --git a/tests/Cache/ApcTestCase.php b/tests/Cache/ApcTestCase.php index bc17e67f9..bec05c170 100644 --- a/tests/Cache/ApcTestCase.php +++ b/tests/Cache/ApcTestCase.php @@ -31,7 +31,7 @@ * @since 1.0 * @version $Revision$ */ -class Doctrine_Cache_Apc_TestCase +class Doctrine_Cache_Apc_TestCase extends Doctrine_UnitTestCase { } diff --git a/tests/Cache/MemcacheTestCase.php b/tests/Cache/MemcacheTestCase.php index 6f3d3fd94..dbc7b80fc 100644 --- a/tests/Cache/MemcacheTestCase.php +++ b/tests/Cache/MemcacheTestCase.php @@ -31,10 +31,17 @@ * @since 1.0 * @version $Revision$ */ -class Doctrine_Cache_Memcache_TestCase +class Doctrine_Cache_Memcache_TestCase extends Doctrine_UnitTestCase { - + public function prepareTables() + { } + public function prepareData() + { } } class Doctrine_Cache_Memcache_Mock extends Doctrine_Cache_Memcache -{ +{ +} +class Memcache +{ + } diff --git a/tests/Cache/SqliteTestCase.php b/tests/Cache/SqliteTestCase.php index f8bb63e50..46364f63a 100644 --- a/tests/Cache/SqliteTestCase.php +++ b/tests/Cache/SqliteTestCase.php @@ -31,7 +31,10 @@ * @since 1.0 * @version $Revision$ */ -class Doctrine_Cache_Sqlite_TestCase +class Doctrine_Cache_Sqlite_TestCase extends Doctrine_UnitTestCase { - + public function prepareTables() + { } + public function prepareData() + { } } diff --git a/tests/CacheTestCase.php b/tests/CacheTestCase.php index 5c53055fa..5996995a5 100644 --- a/tests/CacheTestCase.php +++ b/tests/CacheTestCase.php @@ -31,7 +31,40 @@ * @since 1.0 * @version $Revision$ */ -class Doctrine_Cache_TestCase +class Doctrine_Cache_TestCase extends Doctrine_UnitTestCase { + protected $cache; + public function prepareTables() + { } + public function prepareData() + { } + + public function testAdapterQueryAddsQueriesToCacheStack() + { + $this->dbh->query('SELECT * FROM user'); + + $this->assertEqual($this->cache->getAll(), array('main' => array('SELECT * FROM user'))); + } + public function testAdapterStatementExecuteAddsQueriesToCacheStack() + { + $stmt = $this->dbh->prepare('SELECT * FROM user'); + + $stmt->execute(); + + $this->assertEqual($this->cache->getAll(), array('main' => array('SELECT * FROM user'))); + } + public function setUp() + { + parent::setUp(); + + if ( ! isset($this->cache)) { + $this->cache = new Doctrine_Cache('Array'); + + $this->dbh->setAdapter(new Doctrine_Adapter_Mock()); + $this->dbh->addListener($this->cache); + } + + $this->cache->reset(); + } } diff --git a/tests/run.php b/tests/run.php index 469db5ab3..9c30a1625 100644 --- a/tests/run.php +++ b/tests/run.php @@ -62,7 +62,7 @@ $test = new GroupTest('Doctrine Framework Unit Tests'); // DATABASE ABSTRACTION tests -/** + // Connection drivers (not yet fully tested) $test->addTestCase(new Doctrine_Connection_Pgsql_TestCase()); $test->addTestCase(new Doctrine_Connection_Oracle_TestCase()); @@ -214,12 +214,12 @@ $test->addTestCase(new Doctrine_Query_JoinCondition_TestCase()); $test->addTestCase(new Doctrine_ColumnAlias_TestCase()); $test->addTestCase(new Doctrine_Query_Subquery_TestCase()); $test->addTestCase(new Doctrine_Query_Orderby_TestCase()); -*/ +/** $test->addTestCase(new Doctrine_Cache_TestCase()); $test->addTestCase(new Doctrine_Cache_Apc_TestCase()); $test->addTestCase(new Doctrine_Cache_Memcache_TestCase()); $test->addTestCase(new Doctrine_Cache_Sqlite_TestCase()); - +*/ // Cache tests //$test->addTestCase(new Doctrine_Cache_Query_SqliteTestCase()); //$test->addTestCase(new Doctrine_Cache_FileTestCase());