PK CVҟ+ + phpunit.xml.distnu W+A
./tests/Doctrine/Tests/DBAL
PK CV7o% % lib/Doctrine/DBAL/Statement.phpnu W+A .
*/
namespace Doctrine\DBAL;
use PDO,
Doctrine\DBAL\Types\Type,
Doctrine\DBAL\Driver\Statement as DriverStatement;
/**
* A thin wrapper around a Doctrine\DBAL\Driver\Statement that adds support
* for logging, DBAL mapping types, etc.
*
* @author Roman Borschel
* @since 2.0
*/
class Statement implements \IteratorAggregate, DriverStatement
{
/**
* @var string The SQL statement.
*/
protected $sql;
/**
* @var array The bound parameters.
*/
protected $params = array();
/**
* @var array The parameter types
*/
protected $types = array();
/**
* @var \Doctrine\DBAL\Driver\Statement The underlying driver statement.
*/
protected $stmt;
/**
* @var \Doctrine\DBAL\Platforms\AbstractPlatform The underlying database platform.
*/
protected $platform;
/**
* @var \Doctrine\DBAL\Connection The connection this statement is bound to and executed on.
*/
protected $conn;
/**
* Creates a new Statement for the given SQL and Connection.
*
* @param string $sql The SQL of the statement.
* @param \Doctrine\DBAL\Connection The connection on which the statement should be executed.
*/
public function __construct($sql, Connection $conn)
{
$this->sql = $sql;
$this->stmt = $conn->getWrappedConnection()->prepare($sql);
$this->conn = $conn;
$this->platform = $conn->getDatabasePlatform();
}
/**
* Binds a parameter value to the statement.
*
* The value can optionally be bound with a PDO binding type or a DBAL mapping type.
* If bound with a DBAL mapping type, the binding type is derived from the mapping
* type and the value undergoes the conversion routines of the mapping type before
* being bound.
*
* @param string $name The name or position of the parameter.
* @param mixed $value The value of the parameter.
* @param mixed $type Either a PDO binding type or a DBAL mapping type name or instance.
* @return boolean TRUE on success, FALSE on failure.
*/
public function bindValue($name, $value, $type = null)
{
$this->params[$name] = $value;
$this->types[$name] = $type;
if ($type !== null) {
if (is_string($type)) {
$type = Type::getType($type);
}
if ($type instanceof Type) {
$value = $type->convertToDatabaseValue($value, $this->platform);
$bindingType = $type->getBindingType();
} else {
$bindingType = $type; // PDO::PARAM_* constants
}
return $this->stmt->bindValue($name, $value, $bindingType);
} else {
return $this->stmt->bindValue($name, $value);
}
}
/**
* Binds a parameter to a value by reference.
*
* Binding a parameter by reference does not support DBAL mapping types.
*
* @param string $name The name or position of the parameter.
* @param mixed $var The reference to the variable to bind
* @param integer $type The PDO binding type.
* @return boolean TRUE on success, FALSE on failure.
*/
public function bindParam($name, &$var, $type = PDO::PARAM_STR, $length = null)
{
return $this->stmt->bindParam($name, $var, $type, $length );
}
/**
* Executes the statement with the currently bound parameters.
*
* @param array $params
* @return boolean TRUE on success, FALSE on failure.
*/
public function execute($params = null)
{
$logger = $this->conn->getConfiguration()->getSQLLogger();
if ($logger) {
$logger->startQuery($this->sql, $this->params, $this->types);
}
try {
$stmt = $this->stmt->execute($params);
} catch (\Exception $ex) {
throw DBALException::driverExceptionDuringQuery($ex, $this->sql, $this->conn->resolveParams($this->params, $this->types));
}
if ($logger) {
$logger->stopQuery();
}
$this->params = array();
$this->types = array();
return $stmt;
}
/**
* Closes the cursor, freeing the database resources used by this statement.
*
* @return boolean TRUE on success, FALSE on failure.
*/
public function closeCursor()
{
return $this->stmt->closeCursor();
}
/**
* Returns the number of columns in the result set.
*
* @return integer
*/
public function columnCount()
{
return $this->stmt->columnCount();
}
/**
* Fetches the SQLSTATE associated with the last operation on the statement.
*
* @return string
*/
public function errorCode()
{
return $this->stmt->errorCode();
}
/**
* Fetches extended error information associated with the last operation on the statement.
*
* @return array
*/
public function errorInfo()
{
return $this->stmt->errorInfo();
}
public function setFetchMode($fetchMode, $arg2 = null, $arg3 = null)
{
return $this->stmt->setFetchMode($fetchMode, $arg2, $arg3);
}
public function getIterator()
{
return $this->stmt;
}
/**
* Fetches the next row from a result set.
*
* @param integer $fetchMode
* @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($fetchMode = null)
{
return $this->stmt->fetch($fetchMode);
}
/**
* Returns an array containing all of the result set rows.
*
* @param integer $fetchMode
* @param mixed $fetchArgument
* @return array An array containing all of the remaining rows in the result set.
*/
public function fetchAll($fetchMode = null, $fetchArgument = 0)
{
if ($fetchArgument !== 0) {
return $this->stmt->fetchAll($fetchMode, $fetchArgument);
}
return $this->stmt->fetchAll($fetchMode);
}
/**
* Returns a single column from the next row of a result set.
*
* @param integer $columnIndex
* @return mixed A single column from the next row of a result set or FALSE if there are no more rows.
*/
public function fetchColumn($columnIndex = 0)
{
return $this->stmt->fetchColumn($columnIndex);
}
/**
* Returns the number of rows affected by the last execution of this statement.
*
* @return integer The number of affected rows.
*/
public function rowCount()
{
return $this->stmt->rowCount();
}
/**
* Gets the wrapped driver statement.
*
* @return \Doctrine\DBAL\Driver\Statement
*/
public function getWrappedStatement()
{
return $this->stmt;
}
}
PK CV Y
Y
lib/Doctrine/DBAL/Driver.phpnu W+A .
*/
namespace Doctrine\DBAL;
/**
* Driver interface.
* Interface that all DBAL drivers must implement.
*
* @since 2.0
*/
interface Driver
{
/**
* Attempts to create a connection with the database.
*
* @param array $params All connection parameters passed by the user.
* @param string $username The username to use when connecting.
* @param string $password The password to use when connecting.
* @param array $driverOptions The driver options to use when connecting.
* @return \Doctrine\DBAL\Driver\Connection The database connection.
*/
public function connect(array $params, $username = null, $password = null, array $driverOptions = array());
/**
* Gets the DatabasePlatform instance that provides all the metadata about
* the platform this driver connects to.
*
* @return \Doctrine\DBAL\Platforms\AbstractPlatform The database platform.
*/
public function getDatabasePlatform();
/**
* Gets the SchemaManager that can be used to inspect and change the underlying
* database schema of the platform this driver connects to.
*
* @param \Doctrine\DBAL\Connection $conn
* @return \Doctrine\DBAL\Schema\AbstractSchemaManager
*/
public function getSchemaManager(Connection $conn);
/**
* Gets the name of the driver.
*
* @return string The name of the driver.
*/
public function getName();
/**
* Get the name of the database connected to for this driver.
*
* @param \Doctrine\DBAL\Connection $conn
* @return string $database
*/
public function getDatabase(Connection $conn);
}
PK CV7ϴ
; lib/Doctrine/DBAL/Event/SchemaColumnDefinitionEventArgs.phpnu W+A .
*/
namespace Doctrine\DBAL\Event;
use Doctrine\DBAL\Connection,
Doctrine\DBAL\Schema\Column;
/**
* Event Arguments used when the portable column definition is generated inside Doctrine\DBAL\Schema\AbstractSchemaManager.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.com
* @since 2.2
* @author Jan Sorgalla
*/
class SchemaColumnDefinitionEventArgs extends SchemaEventArgs
{
/**
* @var \Doctrine\DBAL\Schema\Column
*/
private $_column = null;
/**
* Raw column data as fetched from the database
*
* @var array
*/
private $_tableColumn = null;
/**
* @var string
*/
private $_table = null;
/**
* @var string
*/
private $_database = null;
/**
* @var \Doctrine\DBAL\Connection
*/
private $_connection = null;
/**
* @param array $tableColumn
* @param string $table
* @param string $database
* @param \Doctrine\DBAL\Connection $conn
*/
public function __construct(array $tableColumn, $table, $database, Connection $connection)
{
$this->_tableColumn = $tableColumn;
$this->_table = $table;
$this->_database = $database;
$this->_connection = $connection;
}
/**
* Allows to clear the column which means the column will be excluded from
* tables column list.
*
* @param null|\Doctrine\DBAL\Schema\Column $column
* @return SchemaColumnDefinitionEventArgs
*/
public function setColumn(Column $column = null)
{
$this->_column = $column;
return $this;
}
/**
* @return \Doctrine\DBAL\Schema\Column
*/
public function getColumn()
{
return $this->_column;
}
/**
* @return array
*/
public function getTableColumn()
{
return $this->_tableColumn;
}
/**
* @return string
*/
public function getTable()
{
return $this->_table;
}
/**
* @return string
*/
public function getDatabase()
{
return $this->_database;
}
/**
* @return \Doctrine\DBAL\Connection
*/
public function getConnection()
{
return $this->_connection;
}
/**
* @return \Doctrine\DBAL\Platforms\AbstractPlatform
*/
public function getDatabasePlatform()
{
return $this->_connection->getDatabasePlatform();
}
}
PK CV'! 6 lib/Doctrine/DBAL/Event/SchemaCreateTableEventArgs.phpnu W+A .
*/
namespace Doctrine\DBAL\Event;
use Doctrine\DBAL\Platforms\AbstractPlatform,
Doctrine\DBAL\Schema\Table;
/**
* Event Arguments used when SQL queries for creating tables are generated inside Doctrine\DBAL\Platform\AbstractPlatform.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.com
* @since 2.2
* @author Jan Sorgalla
*/
class SchemaCreateTableEventArgs extends SchemaEventArgs
{
/**
* @var \Doctrine\DBAL\Schema\Table
*/
private $_table = null;
/**
* @var array
*/
private $_columns = null;
/**
* @var array
*/
private $_options = null;
/**
* @var \Doctrine\DBAL\Platforms\AbstractPlatform
*/
private $_platform = null;
/**
* @var array
*/
private $_sql = array();
/**
* @param \Doctrine\DBAL\Schema\Table $table
* @param array $columns
* @param array $options
* @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
*/
public function __construct(Table $table, array $columns, array $options, AbstractPlatform $platform)
{
$this->_table = $table;
$this->_columns = $columns;
$this->_options = $options;
$this->_platform = $platform;
}
/**
* @return \Doctrine\DBAL\Schema\Table
*/
public function getTable()
{
return $this->_table;
}
/**
* @return array
*/
public function getColumns()
{
return $this->_columns;
}
/**
* @return array
*/
public function getOptions()
{
return $this->_options;
}
/**
* @return \Doctrine\DBAL\Platforms\AbstractPlatform
*/
public function getPlatform()
{
return $this->_platform;
}
/**
* @param string|array $sql
* @return \Doctrine\DBAL\Event\SchemaCreateTableEventArgs
*/
public function addSql($sql)
{
if (is_array($sql)) {
$this->_sql = array_merge($this->_sql, $sql);
} else {
$this->_sql[] = $sql;
}
return $this;
}
/**
* @return array
*/
public function getSql()
{
return $this->_sql;
}
}
PK CV_ A lib/Doctrine/DBAL/Event/SchemaAlterTableChangeColumnEventArgs.phpnu W+A .
*/
namespace Doctrine\DBAL\Event;
use Doctrine\DBAL\Platforms\AbstractPlatform,
Doctrine\DBAL\Schema\ColumnDiff,
Doctrine\DBAL\Schema\TableDiff;
/**
* Event Arguments used when SQL queries for changing table columns are generated inside Doctrine\DBAL\Platform\*Platform.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.com
* @since 2.2
* @author Jan Sorgalla
*/
class SchemaAlterTableChangeColumnEventArgs extends SchemaEventArgs
{
/**
* @var \Doctrine\DBAL\Schema\ColumnDiff
*/
private $_columnDiff = null;
/**
* @var \Doctrine\DBAL\Schema\TableDiff
*/
private $_tableDiff = null;
/**
* @var \Doctrine\DBAL\Platforms\AbstractPlatform
*/
private $_platform = null;
/**
* @var array
*/
private $_sql = array();
/**
* @param \Doctrine\DBAL\Schema\ColumnDiff $columnDiff
* @param \Doctrine\DBAL\Schema\TableDiff $tableDiff
* @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
*/
public function __construct(ColumnDiff $columnDiff, TableDiff $tableDiff, AbstractPlatform $platform)
{
$this->_columnDiff = $columnDiff;
$this->_tableDiff = $tableDiff;
$this->_platform = $platform;
}
/**
* @return \Doctrine\DBAL\Schema\ColumnDiff
*/
public function getColumnDiff()
{
return $this->_columnDiff;
}
/**
* @return \Doctrine\DBAL\Schema\TableDiff
*/
public function getTableDiff()
{
return $this->_tableDiff;
}
/**
* @return \Doctrine\DBAL\Platforms\AbstractPlatform
*/
public function getPlatform()
{
return $this->_platform;
}
/**
* @param string|array $sql
* @return \Doctrine\DBAL\Event\SchemaAlterTableChangeColumnEventArgs
*/
public function addSql($sql)
{
if (is_array($sql)) {
$this->_sql = array_merge($this->_sql, $sql);
} else {
$this->_sql[] = $sql;
}
return $this;
}
/**
* @return array
*/
public function getSql()
{
return $this->_sql;
}
}
PK CV0 5 lib/Doctrine/DBAL/Event/SchemaAlterTableEventArgs.phpnu W+A .
*/
namespace Doctrine\DBAL\Event;
use Doctrine\DBAL\Platforms\AbstractPlatform,
Doctrine\DBAL\Schema\Column,
Doctrine\DBAL\Schema\TableDiff;
/**
* Event Arguments used when SQL queries for creating tables are generated inside Doctrine\DBAL\Platform\*Platform.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.com
* @since 2.2
* @author Jan Sorgalla
*/
class SchemaAlterTableEventArgs extends SchemaEventArgs
{
/**
* @var \Doctrine\DBAL\Schema\TableDiff
*/
private $_tableDiff = null;
/**
* @var \Doctrine\DBAL\Platforms\AbstractPlatform
*/
private $_platform = null;
/**
* @var array
*/
private $_sql = array();
/**
* @param \Doctrine\DBAL\Schema\TableDiff $tableDiff
* @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
*/
public function __construct(TableDiff $tableDiff, AbstractPlatform $platform)
{
$this->_tableDiff = $tableDiff;
$this->_platform = $platform;
}
/**
* @return \Doctrine\DBAL\Schema\TableDiff
*/
public function getTableDiff()
{
return $this->_tableDiff;
}
/**
* @return \Doctrine\DBAL\Platforms\AbstractPlatform
*/
public function getPlatform()
{
return $this->_platform;
}
/**
* @param string|array $sql
* @return \Doctrine\DBAL\Event\SchemaAlterTableEventArgs
*/
public function addSql($sql)
{
if (is_array($sql)) {
$this->_sql = array_merge($this->_sql, $sql);
} else {
$this->_sql[] = $sql;
}
return $this;
}
/**
* @return array
*/
public function getSql()
{
return $this->_sql;
}
}
PK CV)( ( 4 lib/Doctrine/DBAL/Event/SchemaDropTableEventArgs.phpnu W+A .
*/
namespace Doctrine\DBAL\Event;
use Doctrine\DBAL\Platforms\AbstractPlatform,
Doctrine\DBAL\Schema\Table;
/**
* Event Arguments used when the SQL query for dropping tables are generated inside Doctrine\DBAL\Platform\AbstractPlatform.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.com
* @since 2.2
* @author Jan Sorgalla
*/
class SchemaDropTableEventArgs extends SchemaEventArgs
{
/**
* @var string|\Doctrine\DBAL\Schema\Table
*/
private $_table = null;
/**
* @var \Doctrine\DBAL\Platforms\AbstractPlatform
*/
private $_platform = null;
/**
* @var string
*/
private $_sql = null;
/**
* @param string|\Doctrine\DBAL\Schema\Table $table
* @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
*/
public function __construct($table, AbstractPlatform $platform)
{
if ( ! $table instanceof Table && !is_string($table)) {
throw new \InvalidArgumentException('SchemaCreateTableEventArgs expects $table parameter to be string or \Doctrine\DBAL\Schema\Table.');
}
$this->_table = $table;
$this->_platform = $platform;
}
/**
* @return string|\Doctrine\DBAL\Schema\Table
*/
public function getTable()
{
return $this->_table;
}
/**
* @return \Doctrine\DBAL\Platforms\AbstractPlatform
*/
public function getPlatform()
{
return $this->_platform;
}
/**
* @param string $sql
* @return \Doctrine\DBAL\Event\SchemaDropTableEventArgs
*/
public function setSql($sql)
{
$this->_sql = $sql;
return $this;
}
/**
* @return string
*/
public function getSql()
{
return $this->_sql;
}
}
PK CViX;
A lib/Doctrine/DBAL/Event/SchemaAlterTableRenameColumnEventArgs.phpnu W+A .
*/
namespace Doctrine\DBAL\Event;
use Doctrine\DBAL\Platforms\AbstractPlatform,
Doctrine\DBAL\Schema\Column,
Doctrine\DBAL\Schema\TableDiff;
/**
* Event Arguments used when SQL queries for renaming table columns are generated inside Doctrine\DBAL\Platform\*Platform.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.com
* @since 2.2
* @author Jan Sorgalla
*/
class SchemaAlterTableRenameColumnEventArgs extends SchemaEventArgs
{
/**
* @var string
*/
private $_oldColumnName = null;
/**
* @var \Doctrine\DBAL\Schema\Column
*/
private $_column = null;
/**
* @var \Doctrine\DBAL\Schema\TableDiff
*/
private $_tableDiff = null;
/**
* @var \Doctrine\DBAL\Platforms\AbstractPlatform
*/
private $_platform = null;
/**
* @var array
*/
private $_sql = array();
/**
* @param string $oldColumnName
* @param \Doctrine\DBAL\Schema\Column $column
* @param \Doctrine\DBAL\Schema\TableDiff $tableDiff
* @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
*/
public function __construct($oldColumnName, Column $column, TableDiff $tableDiff, AbstractPlatform $platform)
{
$this->_oldColumnName = $oldColumnName;
$this->_column = $column;
$this->_tableDiff = $tableDiff;
$this->_platform = $platform;
}
/**
* @return string
*/
public function getOldColumnName()
{
return $this->_oldColumnName;
}
/**
* @return \Doctrine\DBAL\Schema\Column
*/
public function getColumn()
{
return $this->_column;
}
/**
* @return \Doctrine\DBAL\Schema\TableDiff
*/
public function getTableDiff()
{
return $this->_tableDiff;
}
/**
* @return \Doctrine\DBAL\Platforms\AbstractPlatform
*/
public function getPlatform()
{
return $this->_platform;
}
/**
* @param string|array $sql
* @return \Doctrine\DBAL\Event\SchemaAlterTableRenameColumnEventArgs
*/
public function addSql($sql)
{
if (is_array($sql)) {
$this->_sql = array_merge($this->_sql, $sql);
} else {
$this->_sql[] = $sql;
}
return $this;
}
/**
* @return array
*/
public function getSql()
{
return $this->_sql;
}
}
PK CV̋ : lib/Doctrine/DBAL/Event/SchemaIndexDefinitionEventArgs.phpnu W+A .
*/
namespace Doctrine\DBAL\Event;
use Doctrine\DBAL\Connection,
Doctrine\DBAL\Schema\Index;
/**
* Event Arguments used when the portable index definition is generated inside Doctrine\DBAL\Schema\AbstractSchemaManager.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.com
* @since 2.2
* @author Jan Sorgalla
*/
class SchemaIndexDefinitionEventArgs extends SchemaEventArgs
{
/**
* @var \Doctrine\DBAL\Schema\Index
*/
private $_index = null;
/**
* Raw index data as fetched from the database
*
* @var array
*/
private $_tableIndex = null;
/**
* @var string
*/
private $_table = null;
/**
* @var \Doctrine\DBAL\Connection
*/
private $_connection = null;
/**
* @param array $tableIndex
* @param string $table
* @param \Doctrine\DBAL\Connection $conn
*/
public function __construct(array $tableIndex, $table, Connection $connection)
{
$this->_tableIndex = $tableIndex;
$this->_table = $table;
$this->_connection = $connection;
}
/**
* Allows to clear the index which means the index will be excluded from
* tables index list.
*
* @param null|\Doctrine\DBAL\Schema\Index $index
* @return SchemaIndexDefinitionEventArgs
*/
public function setIndex(Index $index = null)
{
$this->_index = $index;
return $this;
}
/**
* @return \Doctrine\DBAL\Schema\Index
*/
public function getIndex()
{
return $this->_index;
}
/**
* @return array
*/
public function getTableIndex()
{
return $this->_tableIndex;
}
/**
* @return string
*/
public function getTable()
{
return $this->_table;
}
/**
* @return \Doctrine\DBAL\Connection
*/
public function getConnection()
{
return $this->_connection;
}
/**
* @return \Doctrine\DBAL\Platforms\AbstractPlatform
*/
public function getDatabasePlatform()
{
return $this->_connection->getDatabasePlatform();
}
}
PK CVڵ_ _ > lib/Doctrine/DBAL/Event/SchemaAlterTableAddColumnEventArgs.phpnu W+A .
*/
namespace Doctrine\DBAL\Event;
use Doctrine\DBAL\Platforms\AbstractPlatform,
Doctrine\DBAL\Schema\Column,
Doctrine\DBAL\Schema\TableDiff;
/**
* Event Arguments used when SQL queries for adding table columns are generated inside Doctrine\DBAL\Platform\*Platform.
*
* @license http://www.opensource.org/licenses/lgpl-license.php LGPL
* @link www.doctrine-project.com
* @since 2.2
* @author Jan Sorgalla
*/
class SchemaAlterTableAddColumnEventArgs extends SchemaEventArgs
{
/**
* @var \Doctrine\DBAL\Schema\Column
*/
private $_column = null;
/**
* @var \Doctrine\DBAL\Schema\TableDiff
*/
private $_tableDiff = null;
/**
* @var \Doctrine\DBAL\Platforms\AbstractPlatform
*/
private $_platform = null;
/**
* @var array
*/
private $_sql = array();
/**
* @param \Doctrine\DBAL\Schema\Column $column
* @param \Doctrine\DBAL\Schema\TableDiff $tableDiff
* @param \Doctrine\DBAL\Platforms\AbstractPlatform $platform
*/
public function __construct(Column $column, TableDiff $tableDiff, AbstractPlatform $platform)
{
$this->_column = $column;
$this->_tableDiff = $tableDiff;
$this->_platform = $platform;
}
/**
* @return \Doctrine\DBAL\Schema\Column
*/
public function getColumn()
{
return $this->_column;
}
/**
* @return \Doctrine\DBAL\Schema\TableDiff
*/
public function getTableDiff()
{
return $this->_tableDiff;
}
/**
* @return \Doctrine\DBAL\Platforms\AbstractPlatform
*/
public function getPlatform()
{
return $this->_platform;
}
/**
* @param string|array $sql
* @return \Doctrine\DBAL\Event\SchemaAlterTableAddColumnEventArgs
*/
public function addSql($sql)
{
if (is_array($sql)) {
$this->_sql = array_merge($this->_sql, $sql);
} else {
$this->_sql[] = $sql;
}
return $this;
}
/**
* @return array
*/
public function getSql()
{
return $this->_sql;
}
}
PK CV?~5 5 <