|
|
|
@ -11,74 +11,72 @@
|
|
|
|
|
namespace yii\db\dao; |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Connection represents a connection to a database. |
|
|
|
|
* Connection represents a connection to a database via [PDO](http://www.php.net/manual/en/ref.pdo.php). |
|
|
|
|
* |
|
|
|
|
* Connection works together with {@link CDbCommand}, {@link CDbDataReader} |
|
|
|
|
* and {@link CDbTransaction} to provide data access to various DBMS |
|
|
|
|
* in a common set of APIs. They are a thin wrapper of the {@link http://www.php.net/manual/en/ref.pdo.php PDO} |
|
|
|
|
* PHP extension. |
|
|
|
|
* Connection works together with [[Command]], [[DataReader]] and [[Transaction]] |
|
|
|
|
* to provide data access to various DBMS in a common set of APIs. They are a thin wrapper |
|
|
|
|
* of the [[PDO PHP extension]](http://www.php.net/manual/en/ref.pdo.php). |
|
|
|
|
* |
|
|
|
|
* To establish a connection, set {@link setActive active} to true after |
|
|
|
|
* specifying {@link connectionString}, {@link username} and {@link password}. |
|
|
|
|
* To establish a DB connection, set [[dsn]], [[username]] and [[password]], and then |
|
|
|
|
* call [[open]] or set [[active]] to be true. |
|
|
|
|
* |
|
|
|
|
* The following example shows how to create a Connection instance and establish |
|
|
|
|
* the actual connection: |
|
|
|
|
* <pre> |
|
|
|
|
* $connection=new Connection($dsn,$username,$password); |
|
|
|
|
* $connection->active=true; |
|
|
|
|
* </pre> |
|
|
|
|
* the DB connection: |
|
|
|
|
* |
|
|
|
|
* After the DB connection is established, one can execute an SQL statement like the following: |
|
|
|
|
* <pre> |
|
|
|
|
* $command=$connection->createCommand($sqlStatement); |
|
|
|
|
* ~~~ |
|
|
|
|
* $connection = \yii\db\dao\Connection::create($dsn, $username, $password); |
|
|
|
|
* $connection->open(); // same as: $connection->active = true; |
|
|
|
|
* ~~~ |
|
|
|
|
* |
|
|
|
|
* After the DB connection is established, one can execute a SQL statement like the following: |
|
|
|
|
* |
|
|
|
|
* ~~~ |
|
|
|
|
* $command = $connection->createCommand('SELECT * FROM tbl_post'); |
|
|
|
|
* $command->execute(); // a non-query SQL statement execution |
|
|
|
|
* // or execute an SQL query and fetch the result set |
|
|
|
|
* $reader=$command->query(); |
|
|
|
|
* // or execute an SQL query and return the results as an array |
|
|
|
|
* $rows = $command->queryAll(); |
|
|
|
|
* ~~~ |
|
|
|
|
* |
|
|
|
|
* One can also do prepared SQL execution and bind parameters to the prepared SQL: |
|
|
|
|
* |
|
|
|
|
* // each $row is an array representing a row of data |
|
|
|
|
* foreach($reader as $row) ... |
|
|
|
|
* </pre> |
|
|
|
|
* ~~~ |
|
|
|
|
* $command = $connection->createCommand('SELECT * FROM tbl_post WHERE id=:id'); |
|
|
|
|
* $command->bindValue(':id', $_GET['id']); |
|
|
|
|
* $post = $command->query(); |
|
|
|
|
* ~~~ |
|
|
|
|
* |
|
|
|
|
* One can do prepared SQL execution and bind parameters to the prepared SQL: |
|
|
|
|
* <pre> |
|
|
|
|
* $command=$connection->createCommand($sqlStatement); |
|
|
|
|
* $command->bindParam($name1,$value1); |
|
|
|
|
* $command->bindParam($name2,$value2); |
|
|
|
|
* $command->execute(); |
|
|
|
|
* </pre> |
|
|
|
|
* DB transaction may also be used for DBMS that supports it. For example, |
|
|
|
|
* |
|
|
|
|
* To use transaction, do like the following: |
|
|
|
|
* <pre> |
|
|
|
|
* ~~~ |
|
|
|
|
* $transaction = $connection->beginTransaction(); |
|
|
|
|
* try |
|
|
|
|
* { |
|
|
|
|
* try { |
|
|
|
|
* $connection->createCommand($sql1)->execute(); |
|
|
|
|
* $connection->createCommand($sql2)->execute(); |
|
|
|
|
* //.... other SQL executions |
|
|
|
|
* // ... executing other SQL statements ... |
|
|
|
|
* $transaction->commit(); |
|
|
|
|
* } |
|
|
|
|
* catch(Exception $e) |
|
|
|
|
* { |
|
|
|
|
* catch(Exception $e) { |
|
|
|
|
* $transaction->rollBack(); |
|
|
|
|
* } |
|
|
|
|
* </pre> |
|
|
|
|
* ~~~ |
|
|
|
|
* |
|
|
|
|
* Connection also provides a set of methods to support setting and querying |
|
|
|
|
* of certain DBMS attributes, such as {@link getNullConversion nullConversion}. |
|
|
|
|
* |
|
|
|
|
* Since Connection implements the interface IApplicationComponent, it can |
|
|
|
|
* Since Connection extends from [[\yii\base\ApplicationComponent]], it can |
|
|
|
|
* be used as an application component and be configured in application configuration, |
|
|
|
|
* like the following, |
|
|
|
|
* <pre> |
|
|
|
|
* |
|
|
|
|
* ~~~ |
|
|
|
|
* array( |
|
|
|
|
* 'components' => array( |
|
|
|
|
* 'db' => array( |
|
|
|
|
* 'class'=>'Connection', |
|
|
|
|
* 'connectionString'=>'sqlite:path/to/dbfile', |
|
|
|
|
* 'class' => '\yii\db\dao\Connection', |
|
|
|
|
* 'dsn' => 'mysql:host=127.0.0.1;dbname=demo', |
|
|
|
|
* 'username' => 'root', |
|
|
|
|
* 'password' => '', |
|
|
|
|
* 'charset' => 'utf8', |
|
|
|
|
* ), |
|
|
|
|
* ), |
|
|
|
|
* ) |
|
|
|
|
* </pre> |
|
|
|
|
* ~~~ |
|
|
|
|
* |
|
|
|
|
* @author Qiang Xue <qiang.xue@gmail.com> |
|
|
|
|
* @since 2.0 |
|
|
|
@ -86,8 +84,9 @@ namespace yii\db\dao;
|
|
|
|
|
class Connection extends \yii\base\ApplicationComponent |
|
|
|
|
{ |
|
|
|
|
/** |
|
|
|
|
* @var string The Data Source Name, or DSN, contains the information required to connect to the database. |
|
|
|
|
* @see http://www.php.net/manual/en/function.PDO-construct.php |
|
|
|
|
* @var string the Data Source Name, or DSN, contains the information required to connect to the database. |
|
|
|
|
* Please refer to the [PHP manual](http://www.php.net/manual/en/function.PDO-construct.php) on |
|
|
|
|
* the format of the DSN string. |
|
|
|
|
* |
|
|
|
|
* Note that if your database is using GBK or BIG5 charset, we highly recommend you |
|
|
|
|
* to upgrade to PHP 5.3.6+ and specify charset via DSN like the following to prevent |
|
|
|
@ -103,12 +102,30 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
*/ |
|
|
|
|
public $password = ''; |
|
|
|
|
/** |
|
|
|
|
* @var array PDO attributes (name=>value) that should be set when calling [[open]] |
|
|
|
|
* to establish a DB connection. Please refer to the |
|
|
|
|
* [PHP manual](http://www.php.net/manual/en/function.PDO-setAttribute.php) for |
|
|
|
|
* details about available attributes. |
|
|
|
|
*/ |
|
|
|
|
public $attributes; |
|
|
|
|
/** |
|
|
|
|
* @var \PDO the PHP PDO instance associated with this DB connection. |
|
|
|
|
* This property is mainly managed by [[open]] and [[close]] methods. |
|
|
|
|
* When a DB connection is active, this property will represent a PDO instance; |
|
|
|
|
* otherwise, it will be null. |
|
|
|
|
*/ |
|
|
|
|
public $pdo; |
|
|
|
|
/** |
|
|
|
|
* @var integer number of seconds that table metadata can remain valid in cache. |
|
|
|
|
* Use 0 or negative value to indicate not caching schema. |
|
|
|
|
* If greater than 0 and the primary cache is enabled, the table metadata will be cached. |
|
|
|
|
* Defaults to -1, meaning schema caching is disabled. |
|
|
|
|
* Use 0 to indicate that the cached data will never expire. |
|
|
|
|
* |
|
|
|
|
* Note that in order to enable schema caching, a valid cache component as specified |
|
|
|
|
* by [[schemaCacheID]] must be enabled. |
|
|
|
|
* @see schemaCachingExclude |
|
|
|
|
* @see schemaCacheID |
|
|
|
|
*/ |
|
|
|
|
public $schemaCachingDuration = 0; |
|
|
|
|
public $schemaCachingDuration = -1; |
|
|
|
|
/** |
|
|
|
|
* @var array list of tables whose metadata should NOT be cached. Defaults to empty array. |
|
|
|
|
* @see schemaCachingDuration |
|
|
|
@ -116,55 +133,47 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
public $schemaCachingExclude = array(); |
|
|
|
|
/** |
|
|
|
|
* @var string the ID of the cache application component that is used to cache the table metadata. |
|
|
|
|
* Defaults to 'cache' which refers to the primary cache application component. |
|
|
|
|
* Set this property to false if you want to disable caching table metadata. |
|
|
|
|
* @since 1.0.10 |
|
|
|
|
* Defaults to 'cache'. |
|
|
|
|
* @see schemaCachingDuration |
|
|
|
|
*/ |
|
|
|
|
public $schemaCacheID = 'cache'; |
|
|
|
|
/** |
|
|
|
|
* @var integer number of seconds that query results can remain valid in cache. |
|
|
|
|
* Use 0 or negative value to indicate not caching query results (the default behavior). |
|
|
|
|
* Defaults to -1, meaning query caching is disabled. |
|
|
|
|
* Use 0 to indicate that the cached data will never expire. |
|
|
|
|
* |
|
|
|
|
* In order to enable query caching, this property must be a positive |
|
|
|
|
* integer and {@link queryCacheID} must point to a valid cache component ID. |
|
|
|
|
* Note that in order to enable query caching, a valid cache component as specified |
|
|
|
|
* by [[queryCacheID]] must be enabled. |
|
|
|
|
* |
|
|
|
|
* The method {@link cache()} is provided as a convenient way of setting this property |
|
|
|
|
* and {@link queryCachingDependency} on the fly. |
|
|
|
|
* The method [[cache()]] is provided as a convenient way of setting this property |
|
|
|
|
* and [[queryCachingDependency]] on the fly. |
|
|
|
|
* |
|
|
|
|
* @see cache |
|
|
|
|
* @see queryCachingDependency |
|
|
|
|
* @see queryCacheID |
|
|
|
|
* @since 1.1.7 |
|
|
|
|
*/ |
|
|
|
|
public $queryCachingDuration = 0; |
|
|
|
|
public $queryCachingDuration = -1; |
|
|
|
|
/** |
|
|
|
|
* @var CCacheDependency the dependency that will be used when saving query results into cache. |
|
|
|
|
* Defaults to null, meaning no dependency. |
|
|
|
|
* @see queryCachingDuration |
|
|
|
|
* @since 1.1.7 |
|
|
|
|
*/ |
|
|
|
|
public $queryCachingDependency; |
|
|
|
|
/** |
|
|
|
|
* @var integer the number of SQL statements that need to be cached next. |
|
|
|
|
* If this is 0, then even if query caching is enabled, no query will be cached. |
|
|
|
|
* @var integer the number of SQL statements that need to be cached when they are executed next. |
|
|
|
|
* Defaults to 0, meaning the query result of the next SQL statement will NOT be cached. |
|
|
|
|
* Note that each time after executing a SQL statement (whether executed on DB server or fetched from |
|
|
|
|
* query cache), this property will be reduced by 1 until 0. |
|
|
|
|
* @since 1.1.7 |
|
|
|
|
* @see queryCachingDuration |
|
|
|
|
*/ |
|
|
|
|
public $queryCachingCount = 0; |
|
|
|
|
/** |
|
|
|
|
* @var string the ID of the cache application component that is used for query caching. |
|
|
|
|
* Defaults to 'cache' which refers to the primary cache application component. |
|
|
|
|
* Set this property to false if you want to disable query caching. |
|
|
|
|
* @since 1.1.7 |
|
|
|
|
* Defaults to 'cache'. |
|
|
|
|
* @see queryCachingDuration |
|
|
|
|
*/ |
|
|
|
|
public $queryCacheID = 'cache'; |
|
|
|
|
/** |
|
|
|
|
* @var boolean whether the database connection should be automatically established |
|
|
|
|
* the component is being initialized. Defaults to true. Note, this property is only |
|
|
|
|
* effective when the Connection object is used as an application component. |
|
|
|
|
*/ |
|
|
|
|
public $autoConnect = true; |
|
|
|
|
/** |
|
|
|
|
* @var string the charset used for database connection. The property is only used |
|
|
|
|
* for MySQL and PostgreSQL databases. Defaults to null, meaning using default charset |
|
|
|
|
* as specified by the database. |
|
|
|
@ -188,77 +197,69 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
* so that parameter values bound to SQL statements are logged for debugging purpose. |
|
|
|
|
* You should be aware that logging parameter values could be expensive and have significant |
|
|
|
|
* impact on the performance of your application. |
|
|
|
|
* @since 1.0.5 |
|
|
|
|
*/ |
|
|
|
|
public $enableParamLogging = false; |
|
|
|
|
/** |
|
|
|
|
* @var boolean whether to enable profiling the SQL statements being executed. |
|
|
|
|
* @var boolean whether to enable profiling for the SQL statements being executed. |
|
|
|
|
* Defaults to false. This should be mainly enabled and used during development |
|
|
|
|
* to find out the bottleneck of SQL executions. |
|
|
|
|
* @since 1.0.6 |
|
|
|
|
* @see getStats |
|
|
|
|
*/ |
|
|
|
|
public $enableProfiling = false; |
|
|
|
|
/** |
|
|
|
|
* @var string the default prefix for table names. Defaults to null, meaning no table prefix. |
|
|
|
|
* By setting this property, any token like '{{tableName}}' in {@link CDbCommand::text} will |
|
|
|
|
* be replaced by 'prefixTableName', where 'prefix' refers to this property value. |
|
|
|
|
* @since 1.1.0 |
|
|
|
|
* By setting this property, any token like '{{tableName}}' in [[Command::text]] will |
|
|
|
|
* be replaced with 'prefixTableName', where 'prefix' refers to this property value. |
|
|
|
|
* For example, '{{post}}' becomes 'tbl_post', if 'tbl_' is set as the table prefix. |
|
|
|
|
*/ |
|
|
|
|
public $tablePrefix; |
|
|
|
|
/** |
|
|
|
|
* @var array list of SQL statements that should be executed right after the DB connection is established. |
|
|
|
|
* @since 1.1.1 |
|
|
|
|
*/ |
|
|
|
|
public $initSQLs; |
|
|
|
|
/** |
|
|
|
|
* @var array mapping between PDO driver and schema class name. |
|
|
|
|
* A schema class can be specified using path alias. |
|
|
|
|
* @since 1.1.6 |
|
|
|
|
*/ |
|
|
|
|
public $driverMap = array( |
|
|
|
|
'pgsql' => 'CPgsqlSchema', // PostgreSQL |
|
|
|
|
'mysqli' => 'CMysqlSchema', // MySQL |
|
|
|
|
'mysql' => 'CMysqlSchema', // MySQL |
|
|
|
|
'sqlite' => 'CSqliteSchema', // sqlite 3 |
|
|
|
|
'sqlite2' => 'CSqliteSchema', // sqlite 2 |
|
|
|
|
'mssql' => 'CMssqlSchema', // Mssql driver on windows hosts |
|
|
|
|
'dblib' => 'CMssqlSchema', // dblib drivers on linux (and maybe others os) hosts |
|
|
|
|
'sqlsrv' => 'CMssqlSchema', // Mssql |
|
|
|
|
'oci' => 'COciSchema', // Oracle driver |
|
|
|
|
* @var array mapping between PDO drivers and schema classes. |
|
|
|
|
* The keys of the array are PDO driver names while the values the corresponding |
|
|
|
|
* schema class name or configuration. Please refer to [[\Yii::createComponent]] for |
|
|
|
|
* details on how to specify a configuration. |
|
|
|
|
* |
|
|
|
|
* This property is mainly used by [[getSchema]] when fetching the database schema information. |
|
|
|
|
*/ |
|
|
|
|
public $schemaMap = array( |
|
|
|
|
'pgsql' => '\yii\db\dao\pgsql\Schema', // PostgreSQL |
|
|
|
|
'mysqli' => '\yii\db\dao\mysql\Schema', // MySQL |
|
|
|
|
'mysql' => '\yii\db\dao\mysql\Schema', // MySQL |
|
|
|
|
'sqlite' => '\yii\db\dao\sqlite\Schema', // sqlite 3 |
|
|
|
|
'sqlite2' => '\yii\db\dao\\sqlite\Schema', // sqlite 2 |
|
|
|
|
'mssql' => '\yii\db\dao\mssql\Schema', // Mssql driver on windows hosts |
|
|
|
|
'dblib' => '\yii\db\dao\mssql\Schema', // dblib drivers on linux (and maybe others os) hosts |
|
|
|
|
'sqlsrv' => '\yii\db\dao\mssql\Schema', // Mssql |
|
|
|
|
'oci' => '\yii\db\dao\oci\Schema', // Oracle driver |
|
|
|
|
); |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* @var string Custom PDO wrapper class. |
|
|
|
|
* @since 1.1.8 |
|
|
|
|
*/ |
|
|
|
|
public $pdoClass = 'PDO'; |
|
|
|
|
|
|
|
|
|
private $_attributes = array(); |
|
|
|
|
private $_active = false; |
|
|
|
|
private $_pdo; |
|
|
|
|
private $_transaction; |
|
|
|
|
private $_schema; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Constructor. |
|
|
|
|
* Note, the DB connection is not established when this connection |
|
|
|
|
* instance is created. Set {@link setActive active} property to true |
|
|
|
|
* instance is created. You may set [[active]] to be true or call [[open]] |
|
|
|
|
* to establish the connection. |
|
|
|
|
* @param string $dsn The Data Source Name, or DSN, contains the information required to connect to the database. |
|
|
|
|
* @param string $username The user name for the DSN string. |
|
|
|
|
* @param string $password The password for the DSN string. |
|
|
|
|
* @param string $dsn the Data Source Name, or DSN, contains the information |
|
|
|
|
* required to connect to the database. |
|
|
|
|
* @param string $username the user name for the DSN string. |
|
|
|
|
* @param string $password the password for the DSN string. |
|
|
|
|
* @see http://www.php.net/manual/en/function.PDO-construct.php |
|
|
|
|
*/ |
|
|
|
|
public function __construct($dsn = '', $username = '', $password = '') |
|
|
|
|
{ |
|
|
|
|
$this->connectionString = $dsn; |
|
|
|
|
$this->dsn = $dsn; |
|
|
|
|
$this->username = $username; |
|
|
|
|
$this->password = $password; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Close the connection when serializing. |
|
|
|
|
* Closes the connection when this component is being serialized. |
|
|
|
|
* @return array |
|
|
|
|
*/ |
|
|
|
|
public function __sleep() |
|
|
|
@ -278,61 +279,38 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Initializes the component. |
|
|
|
|
* This method is required by {@link IApplicationComponent} and is invoked by application |
|
|
|
|
* when the Connection is used as an application component. |
|
|
|
|
* If you override this method, make sure to call the parent implementation |
|
|
|
|
* so that the component can be marked as initialized. |
|
|
|
|
*/ |
|
|
|
|
public function init() |
|
|
|
|
{ |
|
|
|
|
parent::init(); |
|
|
|
|
if ($this->autoConnect) |
|
|
|
|
$this->setActive(true); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns whether the DB connection is established. |
|
|
|
|
* Returns a value indicating whether the DB connection is established. |
|
|
|
|
* @return boolean whether the DB connection is established |
|
|
|
|
*/ |
|
|
|
|
public function getActive() |
|
|
|
|
{ |
|
|
|
|
return $this->_active; |
|
|
|
|
return $this->pdo !== null; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Open or close the DB connection. |
|
|
|
|
* @param boolean $value whether to open or close DB connection |
|
|
|
|
* @throws CException if connection fails |
|
|
|
|
* Opens or closes the DB connection. |
|
|
|
|
* @param boolean $value whether to open or close the DB connection |
|
|
|
|
* @throws Exception if there is any error when establishing the connection |
|
|
|
|
*/ |
|
|
|
|
public function setActive($value) |
|
|
|
|
{ |
|
|
|
|
if ($value != $this->_active) |
|
|
|
|
{ |
|
|
|
|
if ($value) |
|
|
|
|
$this->open(); |
|
|
|
|
else |
|
|
|
|
$this->close(); |
|
|
|
|
} |
|
|
|
|
$value ? $this->open() : $this->close(); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Sets the parameters about query caching. |
|
|
|
|
* This method can be used to enable or disable query caching. |
|
|
|
|
* By setting the $duration parameter to be 0, the query caching will be disabled. |
|
|
|
|
* Otherwise, query results of the new SQL statements executed next will be saved in cache |
|
|
|
|
* and remain valid for the specified duration. |
|
|
|
|
* If the same query is executed again, the result may be fetched from cache directly |
|
|
|
|
* without actually executing the SQL statement. |
|
|
|
|
* This method is provided as a shortcut to setting three properties that are related |
|
|
|
|
* with query caching: [[queryCachingDuration]], [[queryCachingDependency]] and |
|
|
|
|
* [[queryCachingCount]]. |
|
|
|
|
* @param integer $duration the number of seconds that query results may remain valid in cache. |
|
|
|
|
* If this is 0, the caching will be disabled. |
|
|
|
|
* @param CCacheDependency $dependency the dependency that will be used when saving the query results into cache. |
|
|
|
|
* @param integer $queryCount number of SQL queries that need to be cached after calling this method. Defaults to 1, |
|
|
|
|
* meaning that the next SQL query will be cached. |
|
|
|
|
* See [[queryCachingDuration]] for more details. |
|
|
|
|
* @param CCacheDependency $dependency the dependency for the cached query result. |
|
|
|
|
* See [[queryCachingDependency]] for more details. |
|
|
|
|
* @param integer $queryCount number of SQL queries that need to be cached after calling this method. |
|
|
|
|
* See [[queryCachingCount]] for more details. |
|
|
|
|
* @return Connection the connection instance itself. |
|
|
|
|
* @since 1.1.7 |
|
|
|
|
*/ |
|
|
|
|
public function cache($duration, $dependency = null, $queryCount = 1) |
|
|
|
|
public function cache($duration = 300, $dependency = null, $queryCount = 1) |
|
|
|
|
{ |
|
|
|
|
$this->queryCachingDuration = $duration; |
|
|
|
|
$this->queryCachingDependency = $dependency; |
|
|
|
@ -341,33 +319,28 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Opens DB connection if it is currently not |
|
|
|
|
* @throws CException if connection fails |
|
|
|
|
* Establishes a DB connection. |
|
|
|
|
* It does nothing if a DB connection has already been established. |
|
|
|
|
* @throws Exception if connection fails |
|
|
|
|
*/ |
|
|
|
|
protected function open() |
|
|
|
|
{ |
|
|
|
|
if ($this->_pdo === null) |
|
|
|
|
{ |
|
|
|
|
if (empty($this->connectionString)) |
|
|
|
|
throw new CDbException(Yii::t('yii', 'Connection.connectionString cannot be empty.')); |
|
|
|
|
try |
|
|
|
|
public function open() |
|
|
|
|
{ |
|
|
|
|
Yii::trace('Opening DB connection', 'system.db.Connection'); |
|
|
|
|
$this->_pdo = $this->createPdoInstance(); |
|
|
|
|
$this->initConnection($this->_pdo); |
|
|
|
|
$this->_active = true; |
|
|
|
|
if ($this->pdo === null) { |
|
|
|
|
if (empty($this->dsn)) { |
|
|
|
|
throw new Exception('Connection.dsn cannot be empty.'); |
|
|
|
|
} |
|
|
|
|
catch(PDOException $e) |
|
|
|
|
{ |
|
|
|
|
if (YII_DEBUG) |
|
|
|
|
{ |
|
|
|
|
throw new CDbException(Yii::t('yii', 'Connection failed to open the DB connection: {error}', |
|
|
|
|
array('{error}' => $e->getMessage())), (int)$e->getCode(), $e->errorInfo); |
|
|
|
|
try { |
|
|
|
|
\Yii::trace('Opening DB connection', __CLASS__); |
|
|
|
|
$this->pdo = $this->createPdoInstance(); |
|
|
|
|
$this->initConnection($this->pdo); |
|
|
|
|
} |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
Yii::log($e->getMessage(), CLogger::LEVEL_ERROR, 'exception.CDbException'); |
|
|
|
|
throw new CDbException(Yii::t('yii', 'Connection failed to open the DB connection.'), (int)$e->getCode(), $e->errorInfo); |
|
|
|
|
catch (\PDOException $e) { |
|
|
|
|
if (YII_DEBUG) { |
|
|
|
|
throw new Exception('Failed to open DB connection: ' . $e->getMessage(), (int)$e->getCode(), $e->errorInfo); |
|
|
|
|
} |
|
|
|
|
else { |
|
|
|
|
\Yii::error($e->getMessage(), __CLASS__); |
|
|
|
|
throw new Exception('Failed to open DB connection.', (int)$e->getCode(), $e->errorInfo); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
@ -377,93 +350,82 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
* Closes the currently active DB connection. |
|
|
|
|
* It does nothing if the connection is already closed. |
|
|
|
|
*/ |
|
|
|
|
protected function close() |
|
|
|
|
public function close() |
|
|
|
|
{ |
|
|
|
|
Yii::trace('Closing DB connection', 'system.db.Connection'); |
|
|
|
|
$this->_pdo = null; |
|
|
|
|
$this->_active = false; |
|
|
|
|
if ($this->pdo !== null) { |
|
|
|
|
\Yii::trace('Closing DB connection', __CLASS__); |
|
|
|
|
$this->pdo = null; |
|
|
|
|
$this->_schema = null; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Creates the PDO instance. |
|
|
|
|
* When some functionalities are missing in the pdo driver, we may use |
|
|
|
|
* an adapter class to provides them. |
|
|
|
|
* @return PDO the pdo instance |
|
|
|
|
* @since 1.0.4 |
|
|
|
|
* This method is called by [[open]] to establish a DB connection. |
|
|
|
|
* The default implementation will create a PHP `PDO` instance. |
|
|
|
|
* You may override this method if the default `PDO` needs to be adapted for certain DBMS. |
|
|
|
|
* @return \PDO the pdo instance |
|
|
|
|
*/ |
|
|
|
|
protected function createPdoInstance() |
|
|
|
|
{ |
|
|
|
|
$pdoClass = $this->pdoClass; |
|
|
|
|
if (($pos = strpos($this->connectionString, ':')) !== false) |
|
|
|
|
{ |
|
|
|
|
$driver = strtolower(substr($this->connectionString, 0, $pos)); |
|
|
|
|
if ($driver === 'mssql' || $driver === 'dblib' || $driver === 'sqlsrv') |
|
|
|
|
$pdoClass = 'CMssqlPdoAdapter'; |
|
|
|
|
$pdoClass = '\PDO'; |
|
|
|
|
if (($pos = strpos($this->dsn, ':')) !== false) { |
|
|
|
|
$driver = strtolower(substr($this->dsn, 0, $pos)); |
|
|
|
|
if ($driver === 'mssql' || $driver === 'dblib' || $driver === 'sqlsrv') { |
|
|
|
|
$pdoClass = '\yii\db\dao\mssql\PDO'; |
|
|
|
|
} |
|
|
|
|
return new $pdoClass($this->connectionString, $this->username, |
|
|
|
|
$this->password, $this->_attributes); |
|
|
|
|
} |
|
|
|
|
return new $pdoClass($this->dsn, $this->username, $this->password, $this->attributes); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Initializes the open db connection. |
|
|
|
|
* This method is invoked right after the db connection is established. |
|
|
|
|
* The default implementation is to set the charset for MySQL and PostgreSQL database connections. |
|
|
|
|
* @param PDO $pdo the PDO instance |
|
|
|
|
* Initializes the DB connection. |
|
|
|
|
* This method is invoked right after the DB connection is established. |
|
|
|
|
* The default implementation sets the [[charset]] and executes SQLs specified |
|
|
|
|
* in [[initSQLs]]. |
|
|
|
|
*/ |
|
|
|
|
protected function initConnection($pdo) |
|
|
|
|
{ |
|
|
|
|
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION); |
|
|
|
|
if ($this->emulatePrepare !== null && constant('PDO::ATTR_EMULATE_PREPARES')) |
|
|
|
|
$pdo->setAttribute(PDO::ATTR_EMULATE_PREPARES, $this->emulatePrepare); |
|
|
|
|
if ($this->charset !== null) |
|
|
|
|
protected function initConnection() |
|
|
|
|
{ |
|
|
|
|
$driver = strtolower($pdo->getAttribute(PDO::ATTR_DRIVER_NAME)); |
|
|
|
|
if (in_array($driver, array('pgsql', 'mysql', 'mysqli'))) |
|
|
|
|
$pdo->exec('SET NAMES ' . $pdo->quote($this->charset)); |
|
|
|
|
$this->pdo->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION); |
|
|
|
|
if ($this->emulatePrepare !== null && constant('\PDO::ATTR_EMULATE_PREPARES')) { |
|
|
|
|
$this->pdo->setAttribute(\PDO::ATTR_EMULATE_PREPARES, $this->emulatePrepare); |
|
|
|
|
} |
|
|
|
|
if ($this->initSQLs !== null) |
|
|
|
|
{ |
|
|
|
|
foreach ($this->initSQLs as $sql) |
|
|
|
|
$pdo->exec($sql); |
|
|
|
|
if ($this->charset !== null) { |
|
|
|
|
$driver = strtolower($this->pdo->getAttribute(\PDO::ATTR_DRIVER_NAME)); |
|
|
|
|
if (in_array($driver, array('pgsql', 'mysql', 'mysqli'))) { |
|
|
|
|
$this->pdo->exec('SET NAMES ' . $this->pdo->quote($this->charset)); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
if (!empty($this->initSQLs)) { |
|
|
|
|
foreach ($this->initSQLs as $sql) { |
|
|
|
|
$this->pdo->exec($sql); |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the PDO instance. |
|
|
|
|
* @return PDO the PDO instance, null if the connection is not established yet |
|
|
|
|
*/ |
|
|
|
|
public function getPdoInstance() |
|
|
|
|
{ |
|
|
|
|
return $this->_pdo; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Creates a command for execution. |
|
|
|
|
* @param mixed $query the DB query to be executed. This can be either a string representing a SQL statement, |
|
|
|
|
* or an array representing different fragments of a SQL statement. Please refer to {@link CDbCommand::__construct} |
|
|
|
|
* or an array representing different fragments of a SQL statement. Please refer to [[Command::__construct]] |
|
|
|
|
* for more details about how to pass an array as the query. If this parameter is not given, |
|
|
|
|
* you will have to call query builder methods of {@link CDbCommand} to build the DB query. |
|
|
|
|
* @return CDbCommand the DB command |
|
|
|
|
* you will have to call query builder methods in [[Command]] to build the DB query. |
|
|
|
|
* @return Command the DB command |
|
|
|
|
*/ |
|
|
|
|
public function createCommand($query = null) |
|
|
|
|
{ |
|
|
|
|
$this->setActive(true); |
|
|
|
|
return new CDbCommand($this, $query); |
|
|
|
|
$this->open(); |
|
|
|
|
return new Command($this, $query); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the currently active transaction. |
|
|
|
|
* @return CDbTransaction the currently active transaction. Null if no active transaction. |
|
|
|
|
* @return Transaction the currently active transaction. Null if no active transaction. |
|
|
|
|
*/ |
|
|
|
|
public function getCurrentTransaction() |
|
|
|
|
{ |
|
|
|
|
if ($this->_transaction !== null) |
|
|
|
|
{ |
|
|
|
|
if ($this->_transaction->getActive()) |
|
|
|
|
if ($this->_transaction !== null && $this->_transaction->getActive()) { |
|
|
|
|
return $this->_transaction; |
|
|
|
|
} |
|
|
|
|
return null; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
@ -472,10 +434,10 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
*/ |
|
|
|
|
public function beginTransaction() |
|
|
|
|
{ |
|
|
|
|
Yii::trace('Starting transaction', 'system.db.Connection'); |
|
|
|
|
$this->setActive(true); |
|
|
|
|
$this->_pdo->beginTransaction(); |
|
|
|
|
return $this->_transaction = new CDbTransaction($this); |
|
|
|
|
\Yii::trace('Starting transaction', __CLASS__); |
|
|
|
|
$this->open(); |
|
|
|
|
$this->pdo->beginTransaction(); |
|
|
|
|
return $this->_transaction = new Transaction($this); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
@ -484,13 +446,13 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
*/ |
|
|
|
|
public function getSchema() |
|
|
|
|
{ |
|
|
|
|
if ($this->_schema !== null) |
|
|
|
|
if ($this->_schema !== null) { |
|
|
|
|
return $this->_schema; |
|
|
|
|
else |
|
|
|
|
{ |
|
|
|
|
} |
|
|
|
|
else { |
|
|
|
|
$driver = $this->getDriverName(); |
|
|
|
|
if (isset($this->driverMap[$driver])) |
|
|
|
|
return $this->_schema = Yii::createComponent($this->driverMap[$driver], $this); |
|
|
|
|
if (isset($this->schemaMap[$driver])) |
|
|
|
|
return $this->_schema = Yii::createComponent($this->schemaMap[$driver], $this); |
|
|
|
|
else |
|
|
|
|
throw new CDbException(Yii::t('yii', 'Connection does not support reading schema for {driver} database.', |
|
|
|
|
array('{driver}' => $driver))); |
|
|
|
@ -498,16 +460,6 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the SQL command builder for the current DB connection. |
|
|
|
|
* @return CDbCommandBuilder the command builder |
|
|
|
|
* @since 1.0.4 |
|
|
|
|
*/ |
|
|
|
|
public function getCommandBuilder() |
|
|
|
|
{ |
|
|
|
|
return $this->getSchema()->getCommandBuilder(); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the ID of the last inserted row or sequence value. |
|
|
|
|
* @param string $sequenceName name of the sequence object (required by some DBMS) |
|
|
|
|
* @return string the row ID of the last row inserted, or the last value retrieved from the sequence object |
|
|
|
@ -515,8 +467,8 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
*/ |
|
|
|
|
public function getLastInsertID($sequenceName = '') |
|
|
|
|
{ |
|
|
|
|
$this->setActive(true); |
|
|
|
|
return $this->_pdo->lastInsertId($sequenceName); |
|
|
|
|
$this->open(); |
|
|
|
|
return $this->pdo->lastInsertId($sequenceName); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
@ -527,15 +479,18 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
*/ |
|
|
|
|
public function quoteValue($str) |
|
|
|
|
{ |
|
|
|
|
if (is_int($str) || is_float($str)) |
|
|
|
|
if (is_int($str) || is_float($str) || is_bool($str)) { |
|
|
|
|
return $str; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
$this->setActive(true); |
|
|
|
|
if (($value = $this->_pdo->quote($str)) !== false) |
|
|
|
|
$this->open(); |
|
|
|
|
if (($value = $this->pdo->quote($str)) !== false) { |
|
|
|
|
return $value; |
|
|
|
|
else // the driver doesn't support quote (e.g. oci) |
|
|
|
|
} |
|
|
|
|
else { // the driver doesn't support quote (e.g. oci) |
|
|
|
|
return "'" . addcslashes(str_replace("'", "''", $str), "\000\n\r\\\032") . "'"; |
|
|
|
|
} |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Quotes a table name for use in a query. |
|
|
|
@ -560,166 +515,34 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Determines the PDO type for the specified PHP type. |
|
|
|
|
* @param string $type The PHP type (obtained by gettype() call). |
|
|
|
|
* Determines the PDO type for the give PHP data type. |
|
|
|
|
* @param string $type The PHP type (obtained by `gettype()` call). |
|
|
|
|
* @return integer the corresponding PDO type |
|
|
|
|
* @see http://www.php.net/manual/en/pdo.constants.php |
|
|
|
|
*/ |
|
|
|
|
public function getPdoType($type) |
|
|
|
|
{ |
|
|
|
|
static $map = array |
|
|
|
|
( |
|
|
|
|
'boolean' => PDO::PARAM_BOOL, |
|
|
|
|
'integer' => PDO::PARAM_INT, |
|
|
|
|
'string' => PDO::PARAM_STR, |
|
|
|
|
'NULL' => PDO::PARAM_NULL, |
|
|
|
|
static $map = array( |
|
|
|
|
'boolean' => \PDO::PARAM_BOOL, |
|
|
|
|
'integer' => \PDO::PARAM_INT, |
|
|
|
|
'string' => \PDO::PARAM_STR, |
|
|
|
|
'NULL' => \PDO::PARAM_NULL, |
|
|
|
|
); |
|
|
|
|
return isset($map[$type]) ? $map[$type] : PDO::PARAM_STR; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the case of the column names |
|
|
|
|
* @return mixed the case of the column names |
|
|
|
|
* @see http://www.php.net/manual/en/pdo.setattribute.php |
|
|
|
|
*/ |
|
|
|
|
public function getColumnCase() |
|
|
|
|
{ |
|
|
|
|
return $this->getAttribute(PDO::ATTR_CASE); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Sets the case of the column names. |
|
|
|
|
* @param mixed $value the case of the column names |
|
|
|
|
* @see http://www.php.net/manual/en/pdo.setattribute.php |
|
|
|
|
*/ |
|
|
|
|
public function setColumnCase($value) |
|
|
|
|
{ |
|
|
|
|
$this->setAttribute(PDO::ATTR_CASE, $value); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns how the null and empty strings are converted. |
|
|
|
|
* @return mixed how the null and empty strings are converted |
|
|
|
|
* @see http://www.php.net/manual/en/pdo.setattribute.php |
|
|
|
|
*/ |
|
|
|
|
public function getNullConversion() |
|
|
|
|
{ |
|
|
|
|
return $this->getAttribute(PDO::ATTR_ORACLE_NULLS); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Sets how the null and empty strings are converted. |
|
|
|
|
* @param mixed $value how the null and empty strings are converted |
|
|
|
|
* @see http://www.php.net/manual/en/pdo.setattribute.php |
|
|
|
|
*/ |
|
|
|
|
public function setNullConversion($value) |
|
|
|
|
{ |
|
|
|
|
$this->setAttribute(PDO::ATTR_ORACLE_NULLS, $value); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns whether creating or updating a DB record will be automatically committed. |
|
|
|
|
* Some DBMS (such as sqlite) may not support this feature. |
|
|
|
|
* @return boolean whether creating or updating a DB record will be automatically committed. |
|
|
|
|
*/ |
|
|
|
|
public function getAutoCommit() |
|
|
|
|
{ |
|
|
|
|
return $this->getAttribute(PDO::ATTR_AUTOCOMMIT); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Sets whether creating or updating a DB record will be automatically committed. |
|
|
|
|
* Some DBMS (such as sqlite) may not support this feature. |
|
|
|
|
* @param boolean $value whether creating or updating a DB record will be automatically committed. |
|
|
|
|
*/ |
|
|
|
|
public function setAutoCommit($value) |
|
|
|
|
{ |
|
|
|
|
$this->setAttribute(PDO::ATTR_AUTOCOMMIT, $value); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns whether the connection is persistent or not. |
|
|
|
|
* Some DBMS (such as sqlite) may not support this feature. |
|
|
|
|
* @return boolean whether the connection is persistent or not |
|
|
|
|
*/ |
|
|
|
|
public function getPersistent() |
|
|
|
|
{ |
|
|
|
|
return $this->getAttribute(PDO::ATTR_PERSISTENT); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Sets whether the connection is persistent or not. |
|
|
|
|
* Some DBMS (such as sqlite) may not support this feature. |
|
|
|
|
* @param boolean $value whether the connection is persistent or not |
|
|
|
|
*/ |
|
|
|
|
public function setPersistent($value) |
|
|
|
|
{ |
|
|
|
|
return $this->setAttribute(PDO::ATTR_PERSISTENT, $value); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the name of the DB driver |
|
|
|
|
* Returns the name of the DB driver for the current [[dsn]]. |
|
|
|
|
* @return string name of the DB driver |
|
|
|
|
*/ |
|
|
|
|
public function getDriverName() |
|
|
|
|
{ |
|
|
|
|
if (($pos = strpos($this->connectionString, ':')) !== false) |
|
|
|
|
return strtolower(substr($this->connectionString, 0, $pos)); |
|
|
|
|
// return $this->getAttribute(PDO::ATTR_DRIVER_NAME); |
|
|
|
|
if (($pos = strpos($this->dsn, ':')) !== false) { |
|
|
|
|
return strtolower(substr($this->dsn, 0, $pos)); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the version information of the DB driver. |
|
|
|
|
* @return string the version information of the DB driver |
|
|
|
|
*/ |
|
|
|
|
public function getClientVersion() |
|
|
|
|
{ |
|
|
|
|
return $this->getAttribute(PDO::ATTR_CLIENT_VERSION); |
|
|
|
|
else { |
|
|
|
|
return $this->getAttribute(\PDO::ATTR_DRIVER_NAME); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the status of the connection. |
|
|
|
|
* Some DBMS (such as sqlite) may not support this feature. |
|
|
|
|
* @return string the status of the connection |
|
|
|
|
*/ |
|
|
|
|
public function getConnectionStatus() |
|
|
|
|
{ |
|
|
|
|
return $this->getAttribute(PDO::ATTR_CONNECTION_STATUS); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns whether the connection performs data prefetching. |
|
|
|
|
* @return boolean whether the connection performs data prefetching |
|
|
|
|
*/ |
|
|
|
|
public function getPrefetch() |
|
|
|
|
{ |
|
|
|
|
return $this->getAttribute(PDO::ATTR_PREFETCH); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the information of DBMS server. |
|
|
|
|
* @return string the information of DBMS server |
|
|
|
|
*/ |
|
|
|
|
public function getServerInfo() |
|
|
|
|
{ |
|
|
|
|
return $this->getAttribute(PDO::ATTR_SERVER_INFO); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the version information of DBMS server. |
|
|
|
|
* @return string the version information of DBMS server |
|
|
|
|
*/ |
|
|
|
|
public function getServerVersion() |
|
|
|
|
{ |
|
|
|
|
return $this->getAttribute(PDO::ATTR_SERVER_VERSION); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the timeout settings for the connection. |
|
|
|
|
* @return integer timeout settings for the connection |
|
|
|
|
*/ |
|
|
|
|
public function getTimeout() |
|
|
|
|
{ |
|
|
|
|
return $this->getAttribute(PDO::ATTR_TIMEOUT); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
@ -730,8 +553,8 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
*/ |
|
|
|
|
public function getAttribute($name) |
|
|
|
|
{ |
|
|
|
|
$this->setActive(true); |
|
|
|
|
return $this->_pdo->getAttribute($name); |
|
|
|
|
$this->open(); |
|
|
|
|
return $this->pdo->getAttribute($name); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
@ -742,51 +565,25 @@ class Connection extends \yii\base\ApplicationComponent
|
|
|
|
|
*/ |
|
|
|
|
public function setAttribute($name, $value) |
|
|
|
|
{ |
|
|
|
|
if ($this->_pdo instanceof PDO) |
|
|
|
|
$this->_pdo->setAttribute($name, $value); |
|
|
|
|
else |
|
|
|
|
$this->_attributes[$name] = $value; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the attributes that are previously explicitly set for the DB connection. |
|
|
|
|
* @return array attributes (name=>value) that are previously explicitly set for the DB connection. |
|
|
|
|
* @see setAttributes |
|
|
|
|
* @since 1.1.7 |
|
|
|
|
*/ |
|
|
|
|
public function getAttributes() |
|
|
|
|
{ |
|
|
|
|
return $this->_attributes; |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Sets a set of attributes on the database connection. |
|
|
|
|
* @param array $values attributes (name=>value) to be set. |
|
|
|
|
* @see setAttribute |
|
|
|
|
* @since 1.1.7 |
|
|
|
|
*/ |
|
|
|
|
public function setAttributes($values) |
|
|
|
|
{ |
|
|
|
|
foreach ($values as $name => $value) |
|
|
|
|
$this->_attributes[$name] = $value; |
|
|
|
|
$this->open(); |
|
|
|
|
$this->pdo->setAttribute($name, $value); |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/** |
|
|
|
|
* Returns the statistical results of SQL executions. |
|
|
|
|
* The results returned include the number of SQL statements executed and |
|
|
|
|
* the total time spent. |
|
|
|
|
* In order to use this method, {@link enableProfiling} has to be set true. |
|
|
|
|
* In order to use this method, [[enableProfiling]] has to be set true. |
|
|
|
|
* @return array the first element indicates the number of SQL statements executed, |
|
|
|
|
* and the second element the total time spent in SQL execution. |
|
|
|
|
* @since 1.0.6 |
|
|
|
|
*/ |
|
|
|
|
public function getStats() |
|
|
|
|
{ |
|
|
|
|
$logger = Yii::getLogger(); |
|
|
|
|
$timings = $logger->getProfilingResults(null, 'system.db.CDbCommand.query'); |
|
|
|
|
$logger = \Yii::getLogger(); |
|
|
|
|
$timings = $logger->getProfilingResults(null, 'yii\db\dao\Command::query'); |
|
|
|
|
$count = count($timings); |
|
|
|
|
$time = array_sum($timings); |
|
|
|
|
$timings = $logger->getProfilingResults(null, 'system.db.CDbCommand.execute'); |
|
|
|
|
$timings = $logger->getProfilingResults(null, 'yii\db\dao\Command::execute'); |
|
|
|
|
$count += count($timings); |
|
|
|
|
$time += array_sum($timings); |
|
|
|
|
return array($count, $time); |
|
|
|
|