Command.php 26.8 KB
Newer Older
w  
Qiang Xue committed
1 2 3
<?php
/**
 * @link http://www.yiiframework.com/
Qiang Xue committed
4
 * @copyright Copyright (c) 2008 Yii Software LLC
w  
Qiang Xue committed
5 6 7
 * @license http://www.yiiframework.com/license/
 */

Qiang Xue committed
8
namespace yii\db;
w  
Qiang Xue committed
9

Qiang Xue committed
10 11
use yii\base\NotSupportedException;

w  
Qiang Xue committed
12
/**
w  
Qiang Xue committed
13
 * Command represents a SQL statement to be executed against a database.
w  
Qiang Xue committed
14
 *
Qiang Xue committed
15
 * A command object is usually created by calling [[Connection::createCommand()]].
Qiang Xue committed
16
 * The SQL statement it represents can be set via the [[sql]] property.
w  
Qiang Xue committed
17
 *
Qiang Xue committed
18
 * To execute a non-query SQL (such as INSERT, DELETE, UPDATE), call [[execute()]].
Qiang Xue committed
19
 * To execute a SQL statement that returns result data set (such as SELECT),
Qiang Xue committed
20
 * use [[queryAll()]], [[queryRow()]], [[queryColumn()]], [[queryScalar()]], or [[query()]].
Qiang Xue committed
21 22 23
 * For example,
 *
 * ~~~
Qiang Xue committed
24
 * $users = $connection->createCommand('SELECT * FROM tbl_user')->queryAll();
Qiang Xue committed
25
 * ~~~
w  
Qiang Xue committed
26
 *
Qiang Xue committed
27
 * Command supports SQL statement preparation and parameter binding.
Qiang Xue committed
28 29
 * Call [[bindValue()]] to bind a value to a SQL parameter;
 * Call [[bindParam()]] to bind a PHP variable to a SQL parameter.
w  
Qiang Xue committed
30
 * When binding a parameter, the SQL statement is automatically prepared.
Qiang Xue committed
31
 * You may also call [[prepare()]] explicitly to prepare a SQL statement.
w  
Qiang Xue committed
32
 *
Qiang Xue committed
33 34 35 36 37 38 39 40 41 42 43 44
 * Command also supports building SQL statements by providing methods such as [[insert()]],
 * [[update()]], etc. For example,
 *
 * ~~~
 * $connection->createCommand()->insert('tbl_user', array(
 *     'name' => 'Sam',
 *     'age' => 30,
 * ))->execute();
 * ~~~
 *
 * To build SELECT SQL statements, please use [[QueryBuilder]] instead.
 *
Qiang Xue committed
45 46
 * @property string $sql the SQL statement to be executed
 *
w  
Qiang Xue committed
47
 * @author Qiang Xue <qiang.xue@gmail.com>
w  
Qiang Xue committed
48
 * @since 2.0
w  
Qiang Xue committed
49
 */
w  
Qiang Xue committed
50
class Command extends \yii\base\Component
w  
Qiang Xue committed
51
{
Qiang Xue committed
52 53 54
	/**
	 * @var Connection the DB connection that this command is associated with
	 */
Qiang Xue committed
55
	public $db;
Qiang Xue committed
56
	/**
Qiang Xue committed
57
	 * @var \PDOStatement the PDOStatement object that this command is associated with
Qiang Xue committed
58
	 */
w  
Qiang Xue committed
59 60
	public $pdoStatement;
	/**
Qiang Xue committed
61
	 * @var mixed the default fetch mode for this command.
w  
Qiang Xue committed
62 63 64
	 * @see http://www.php.net/manual/en/function.PDOStatement-setFetchMode.php
	 */
	public $fetchMode = \PDO::FETCH_ASSOC;
Qiang Xue committed
65 66 67 68 69
	/**
	 * @var string the SQL statement that this command represents
	 */
	private $_sql;
	/**
Qiang Xue committed
70
	 * @var array the parameter log information (name=>value)
Qiang Xue committed
71
	 */
Qiang Xue committed
72
	private $_params = array();
Qiang Xue committed
73

w  
Qiang Xue committed
74
	/**
Qiang Xue committed
75
	 * Returns the SQL statement for this command.
w  
Qiang Xue committed
76 77
	 * @return string the SQL statement to be executed
	 */
Qiang Xue committed
78
	public function getSql()
w  
Qiang Xue committed
79
	{
w  
Qiang Xue committed
80
		return $this->_sql;
w  
Qiang Xue committed
81 82 83 84
	}

	/**
	 * Specifies the SQL statement to be executed.
Qiang Xue committed
85
	 * Any previous execution will be terminated or cancelled.
86
	 * @param string $sql the SQL statement to be set.
w  
Qiang Xue committed
87
	 * @return Command this command instance
w  
Qiang Xue committed
88
	 */
89
	public function setSql($sql)
w  
Qiang Xue committed
90
	{
91
		if ($sql !== $this->_sql) {
Qiang Xue committed
92
			if ($this->db->enableAutoQuoting && $sql != '') {
Qiang Xue committed
93
				$sql = $this->expandSql($sql);
94
			}
Qiang Xue committed
95
			$this->cancel();
96 97 98
			$this->_sql = $sql;
			$this->_params = array();
		}
w  
Qiang Xue committed
99 100 101
		return $this;
	}

Qiang Xue committed
102 103 104 105 106 107 108
	/**
	 * Expands a SQL statement by quoting table and column names and replacing table prefixes.
	 * @param string $sql the SQL to be expanded
	 * @return string the expanded SQL
	 */
	protected function expandSql($sql)
	{
Qiang Xue committed
109 110
		$db = $this->db;
		return preg_replace_callback('/(\\{\\{(.*?)\\}\\}|\\[\\[(.*?)\\]\\])/', function($matches) use($db) {
Qiang Xue committed
111
			if (isset($matches[3])) {
Qiang Xue committed
112
				return $db->quoteColumnName($matches[3]);
Qiang Xue committed
113
			} else {
Qiang Xue committed
114 115
				$name = str_replace('%', $db->tablePrefix, $matches[2]);
				return $db->quoteTableName($name);
Qiang Xue committed
116 117 118 119
			}
		}, $sql);
	}

w  
Qiang Xue committed
120 121 122 123 124 125
	/**
	 * Prepares the SQL statement to be executed.
	 * For complex SQL statement that is to be executed multiple times,
	 * this may improve performance.
	 * For SQL statement with binding parameters, this method is invoked
	 * automatically.
Qiang Xue committed
126
	 * @throws Exception if there is any DB error
w  
Qiang Xue committed
127 128 129
	 */
	public function prepare()
	{
w  
Qiang Xue committed
130
		if ($this->pdoStatement == null) {
131
			$sql = $this->getSql();
w  
Qiang Xue committed
132
			try {
Qiang Xue committed
133
				$this->pdoStatement = $this->db->pdo->prepare($sql);
Qiang Xue committed
134
			} catch (\Exception $e) {
Qiang Xue committed
135
				\Yii::error($e->getMessage() . "\nFailed to prepare SQL: $sql", __CLASS__);
Qiang Xue committed
136
				$errorInfo = $e instanceof \PDOException ? $e->errorInfo : null;
Qiang Xue committed
137
				throw new Exception($e->getMessage(), (int)$e->getCode(), $errorInfo);
w  
Qiang Xue committed
138 139 140 141 142 143
			}
		}
	}

	/**
	 * Cancels the execution of the SQL statement.
Qiang Xue committed
144
	 * This method mainly sets [[pdoStatement]] to be null.
w  
Qiang Xue committed
145 146 147
	 */
	public function cancel()
	{
w  
Qiang Xue committed
148
		$this->pdoStatement = null;
w  
Qiang Xue committed
149 150 151 152
	}

	/**
	 * Binds a parameter to the SQL statement to be executed.
Qiang Xue committed
153
	 * @param string|integer $name parameter identifier. For a prepared statement
w  
Qiang Xue committed
154
	 * using named placeholders, this will be a parameter name of
Qiang Xue committed
155
	 * the form `:name`. For a prepared statement using question mark
w  
Qiang Xue committed
156 157 158 159
	 * placeholders, this will be the 1-indexed position of the parameter.
	 * @param mixed $value Name of the PHP variable to bind to the SQL statement parameter
	 * @param integer $dataType SQL data type of the parameter. If null, the type is determined by the PHP type of the value.
	 * @param integer $length length of the data type
Qiang Xue committed
160 161
	 * @param mixed $driverOptions the driver-specific options
	 * @return Command the current command being executed
w  
Qiang Xue committed
162 163 164 165 166
	 * @see http://www.php.net/manual/en/function.PDOStatement-bindParam.php
	 */
	public function bindParam($name, &$value, $dataType = null, $length = null, $driverOptions = null)
	{
		$this->prepare();
Qiang Xue committed
167
		if ($dataType === null) {
Qiang Xue committed
168
			$this->pdoStatement->bindParam($name, $value, $this->getPdoType($value));
Qiang Xue committed
169
		} elseif ($length === null) {
w  
Qiang Xue committed
170
			$this->pdoStatement->bindParam($name, $value, $dataType);
Qiang Xue committed
171
		} elseif ($driverOptions === null) {
w  
Qiang Xue committed
172
			$this->pdoStatement->bindParam($name, $value, $dataType, $length);
Qiang Xue committed
173
		} else {
w  
Qiang Xue committed
174
			$this->pdoStatement->bindParam($name, $value, $dataType, $length, $driverOptions);
Qiang Xue committed
175
		}
Qiang Xue committed
176
		$this->_params[$name] =& $value;
w  
Qiang Xue committed
177 178 179 180 181
		return $this;
	}

	/**
	 * Binds a value to a parameter.
Qiang Xue committed
182
	 * @param string|integer $name Parameter identifier. For a prepared statement
w  
Qiang Xue committed
183
	 * using named placeholders, this will be a parameter name of
Qiang Xue committed
184
	 * the form `:name`. For a prepared statement using question mark
w  
Qiang Xue committed
185 186 187
	 * placeholders, this will be the 1-indexed position of the parameter.
	 * @param mixed $value The value to bind to the parameter
	 * @param integer $dataType SQL data type of the parameter. If null, the type is determined by the PHP type of the value.
Qiang Xue committed
188
	 * @return Command the current command being executed
w  
Qiang Xue committed
189 190 191 192 193
	 * @see http://www.php.net/manual/en/function.PDOStatement-bindValue.php
	 */
	public function bindValue($name, $value, $dataType = null)
	{
		$this->prepare();
Qiang Xue committed
194
		if ($dataType === null) {
Qiang Xue committed
195
			$this->pdoStatement->bindValue($name, $value, $this->getPdoType($value));
Qiang Xue committed
196
		} else {
w  
Qiang Xue committed
197
			$this->pdoStatement->bindValue($name, $value, $dataType);
Qiang Xue committed
198
		}
Qiang Xue committed
199
		$this->_params[$name] = $value;
w  
Qiang Xue committed
200 201 202 203 204
		return $this;
	}

	/**
	 * Binds a list of values to the corresponding parameters.
Qiang Xue committed
205
	 * This is similar to [[bindValue()]] except that it binds multiple values at a time.
w  
Qiang Xue committed
206 207
	 * Note that the SQL data type of each value is determined by its PHP type.
	 * @param array $values the values to be bound. This must be given in terms of an associative
Qiang Xue committed
208
	 * array with array keys being the parameter names, and array values the corresponding parameter values,
209 210 211
	 * e.g. `array(':name'=>'John', ':age'=>25)`. By default, the PDO type of each value is determined
	 * by its PHP type. You may explicitly specify the PDO type by using an array: `array(value, type)`,
	 * e.g. `array(':name'=>'John', ':profile'=>array($profile, \PDO::PARAM_LOB))`.
w  
Qiang Xue committed
212
	 * @return Command the current command being executed
w  
Qiang Xue committed
213 214 215
	 */
	public function bindValues($values)
	{
Qiang Xue committed
216
		if (!empty($values)) {
Qiang Xue committed
217 218
			$this->prepare();
			foreach ($values as $name => $value) {
219 220 221 222
				if (is_array($value)) {
					$type = $value[1];
					$value = $value[0];
				} else {
Qiang Xue committed
223
					$type = $this->getPdoType($value);
224 225
				}
				$this->pdoStatement->bindValue($name, $value, $type);
Qiang Xue committed
226 227 228
				$this->_params[$name] = $value;
			}
		}
w  
Qiang Xue committed
229 230 231
		return $this;
	}

232
	/**
Qiang Xue committed
233 234 235
	 * Determines the PDO type for the give PHP data value.
	 * @param mixed $data the data whose PDO type is to be determined
	 * @return integer the PDO type
236 237
	 * @see http://www.php.net/manual/en/pdo.constants.php
	 */
Qiang Xue committed
238
	private function getPdoType($data)
239 240 241 242 243 244 245
	{
		static $typeMap = array(
			'boolean' => \PDO::PARAM_BOOL,
			'integer' => \PDO::PARAM_INT,
			'string' => \PDO::PARAM_STR,
			'NULL' => \PDO::PARAM_NULL,
		);
Qiang Xue committed
246
		$type = gettype($data);
247 248 249
		return isset($typeMap[$type]) ? $typeMap[$type] : \PDO::PARAM_STR;
	}

w  
Qiang Xue committed
250 251
	/**
	 * Executes the SQL statement.
Qiang Xue committed
252
	 * This method should only be used for executing non-query SQL statement, such as `INSERT`, `DELETE`, `UPDATE` SQLs.
w  
Qiang Xue committed
253 254
	 * No result set will be returned.
	 * @return integer number of rows affected by the execution.
Qiang Xue committed
255
	 * @throws Exception execution failed
w  
Qiang Xue committed
256
	 */
257
	public function execute()
w  
Qiang Xue committed
258
	{
259
		$sql = $this->getSql();
Qiang Xue committed
260

Qiang Xue committed
261 262
		if ($this->_params === array()) {
			$paramLog = '';
Qiang Xue committed
263
		} else {
Qiang Xue committed
264
			$paramLog = "\nParameters: " . var_export($this->_params, true);
w  
Qiang Xue committed
265
		}
Qiang Xue committed
266 267

		\Yii::trace("Executing SQL: {$sql}{$paramLog}", __CLASS__);
Qiang Xue committed
268

Qiang Xue committed
269 270 271 272
		if ($sql == '') {
			return 0;
		}

Qiang Xue committed
273
		try {
Qiang Xue committed
274
			if ($this->db->enableProfiling) {
Qiang Xue committed
275 276
				\Yii::beginProfile(__METHOD__ . "($sql)", __CLASS__);
			}
w  
Qiang Xue committed
277 278

			$this->prepare();
279
			$this->pdoStatement->execute();
w  
Qiang Xue committed
280
			$n = $this->pdoStatement->rowCount();
w  
Qiang Xue committed
281

Qiang Xue committed
282
			if ($this->db->enableProfiling) {
Qiang Xue committed
283 284
				\Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
			}
w  
Qiang Xue committed
285
			return $n;
Qiang Xue committed
286
		} catch (\Exception $e) {
Qiang Xue committed
287
			if ($this->db->enableProfiling) {
Qiang Xue committed
288 289 290
				\Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
			}
			$message = $e->getMessage();
Qiang Xue committed
291

Qiang Xue committed
292
			\Yii::error("$message\nFailed to execute SQL: {$sql}{$paramLog}", __CLASS__);
Qiang Xue committed
293

Qiang Xue committed
294 295
			$errorInfo = $e instanceof \PDOException ? $e->errorInfo : null;
			throw new Exception($message, (int)$e->getCode(), $errorInfo);
w  
Qiang Xue committed
296 297 298 299 300
		}
	}

	/**
	 * Executes the SQL statement and returns query result.
Qiang Xue committed
301 302 303
	 * This method is for executing a SQL query that returns result set, such as `SELECT`.
	 * @return DataReader the reader object for fetching the query result
	 * @throws Exception execution failed
w  
Qiang Xue committed
304
	 */
305
	public function query()
w  
Qiang Xue committed
306
	{
307
		return $this->queryInternal('');
w  
Qiang Xue committed
308 309 310
	}

	/**
Qiang Xue committed
311 312 313 314
	 * Executes the SQL statement and returns ALL rows at once.
	 * @param mixed $fetchMode the result fetch mode. Please refer to [PHP manual](http://www.php.net/manual/en/function.PDOStatement-setFetchMode.php)
	 * for valid fetch modes. If this parameter is null, the value set in [[fetchMode]] will be used.
	 * @return array all rows of the query result. Each array element is an array representing a row of data.
w  
Qiang Xue committed
315
	 * An empty array is returned if the query results in nothing.
Qiang Xue committed
316
	 * @throws Exception execution failed
w  
Qiang Xue committed
317
	 */
318
	public function queryAll($fetchMode = null)
w  
Qiang Xue committed
319
	{
320
		return $this->queryInternal('fetchAll', $fetchMode);
w  
Qiang Xue committed
321 322 323 324
	}

	/**
	 * Executes the SQL statement and returns the first row of the result.
Qiang Xue committed
325 326 327 328 329
	 * This method is best used when only the first row of result is needed for a query.
	 * @param mixed $fetchMode the result fetch mode. Please refer to [PHP manual](http://www.php.net/manual/en/function.PDOStatement-setFetchMode.php)
	 * for valid fetch modes. If this parameter is null, the value set in [[fetchMode]] will be used.
	 * @return array|boolean the first row (in terms of an array) of the query result. False is returned if the query
	 * results in nothing.
Qiang Xue committed
330
	 * @throws Exception execution failed
w  
Qiang Xue committed
331
	 */
332
	public function queryRow($fetchMode = null)
w  
Qiang Xue committed
333
	{
334
		return $this->queryInternal('fetch', $fetchMode);
w  
Qiang Xue committed
335 336 337 338
	}

	/**
	 * Executes the SQL statement and returns the value of the first column in the first row of data.
Qiang Xue committed
339
	 * This method is best used when only a single value is needed for a query.
Qiang Xue committed
340
	 * @return string|boolean the value of the first column in the first row of the query result.
Qiang Xue committed
341
	 * False is returned if there is no value.
Qiang Xue committed
342
	 * @throws Exception execution failed
w  
Qiang Xue committed
343
	 */
344
	public function queryScalar()
w  
Qiang Xue committed
345
	{
346
		$result = $this->queryInternal('fetchColumn', 0);
w  
Qiang Xue committed
347
		if (is_resource($result) && get_resource_type($result) === 'stream') {
w  
Qiang Xue committed
348
			return stream_get_contents($result);
Qiang Xue committed
349
		} else {
w  
Qiang Xue committed
350
			return $result;
w  
Qiang Xue committed
351
		}
w  
Qiang Xue committed
352 353 354 355
	}

	/**
	 * Executes the SQL statement and returns the first column of the result.
Qiang Xue committed
356 357 358
	 * This method is best used when only the first column of result (i.e. the first element in each row)
	 * is needed for a query.
	 * @return array the first column of the query result. Empty array is returned if the query results in nothing.
Qiang Xue committed
359
	 * @throws Exception execution failed
w  
Qiang Xue committed
360
	 */
361
	public function queryColumn()
w  
Qiang Xue committed
362
	{
363
		return $this->queryInternal('fetchAll', \PDO::FETCH_COLUMN);
w  
Qiang Xue committed
364 365 366
	}

	/**
Qiang Xue committed
367
	 * Performs the actual DB query of a SQL statement.
w  
Qiang Xue committed
368
	 * @param string $method method of PDOStatement to be called
Qiang Xue committed
369 370
	 * @param mixed $fetchMode the result fetch mode. Please refer to [PHP manual](http://www.php.net/manual/en/function.PDOStatement-setFetchMode.php)
	 * for valid fetch modes. If this parameter is null, the value set in [[fetchMode]] will be used.
w  
Qiang Xue committed
371
	 * @return mixed the method execution result
Qiang Xue committed
372
	 * @throws Exception if the query causes any problem
w  
Qiang Xue committed
373
	 */
374
	private function queryInternal($method, $fetchMode = null)
w  
Qiang Xue committed
375
	{
Qiang Xue committed
376
		$db = $this->db;
377
		$sql = $this->getSql();
Qiang Xue committed
378 379
		if ($this->_params === array()) {
			$paramLog = '';
Qiang Xue committed
380
		} else {
Qiang Xue committed
381
			$paramLog = "\nParameters: " . var_export($this->_params, true);
w  
Qiang Xue committed
382
		}
Qiang Xue committed
383 384

		\Yii::trace("Querying SQL: {$sql}{$paramLog}", __CLASS__);
385

Qiang Xue committed
386
		/** @var $cache \yii\caching\Cache */
387
		if ($db->enableQueryCache && $method !== '') {
Qiang Xue committed
388
			$cache = \Yii::$app->getComponent($db->queryCacheID);
Qiang Xue committed
389 390 391
		}

		if (isset($cache)) {
Qiang Xue committed
392
			$cacheKey = $cache->buildKey(__CLASS__, $db->dsn, $db->username, $sql, $paramLog);
Qiang Xue committed
393
			if (($result = $cache->get($cacheKey)) !== false) {
Qiang Xue committed
394
				\Yii::trace('Query result found in cache', __CLASS__);
w  
Qiang Xue committed
395 396 397 398
				return $result;
			}
		}

Qiang Xue committed
399 400 401 402
		try {
			if ($db->enableProfiling) {
				\Yii::beginProfile(__METHOD__ . "($sql)", __CLASS__);
			}
w  
Qiang Xue committed
403 404

			$this->prepare();
405
			$this->pdoStatement->execute();
w  
Qiang Xue committed
406

Qiang Xue committed
407
			if ($method === '') {
w  
Qiang Xue committed
408
				$result = new DataReader($this);
Qiang Xue committed
409
			} else {
Qiang Xue committed
410 411 412
				if ($fetchMode === null) {
					$fetchMode = $this->fetchMode;
				}
w  
Qiang Xue committed
413 414
				$result = call_user_func_array(array($this->pdoStatement, $method), (array)$fetchMode);
				$this->pdoStatement->closeCursor();
w  
Qiang Xue committed
415 416
			}

Qiang Xue committed
417 418 419
			if ($db->enableProfiling) {
				\Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
			}
w  
Qiang Xue committed
420

Qiang Xue committed
421
			if (isset($cache, $cacheKey)) {
422
				$cache->set($cacheKey, $result, $db->queryCacheDuration, $db->queryCacheDependency);
Qiang Xue committed
423
				\Yii::trace('Saved query result in cache', __CLASS__);
Qiang Xue committed
424
			}
w  
Qiang Xue committed
425 426

			return $result;
Qiang Xue committed
427
		} catch (\Exception $e) {
Qiang Xue committed
428 429 430 431
			if ($db->enableProfiling) {
				\Yii::endProfile(__METHOD__ . "($sql)", __CLASS__);
			}
			$message = $e->getMessage();
Qiang Xue committed
432 433 434
			\Yii::error("$message\nCommand::$method() failed: {$sql}{$paramLog}", __CLASS__);
			$errorInfo = $e instanceof \PDOException ? $e->errorInfo : null;
			throw new Exception($message, (int)$e->getCode(), $errorInfo);
w  
Qiang Xue committed
435 436
		}
	}
Qiang Xue committed
437 438 439 440 441 442

	/**
	 * Creates an INSERT command.
	 * For example,
	 *
	 * ~~~
Qiang Xue committed
443 444 445
	 * $connection->createCommand()->insert('tbl_user', array(
	 *     'name' => 'Sam',
	 *     'age' => 30,
Qiang Xue committed
446 447 448 449 450 451 452 453 454 455 456
	 * ))->execute();
	 * ~~~
	 *
	 * The method will properly escape the column names, and bind the values to be inserted.
	 *
	 * Note that the created command is not executed until [[execute()]] is called.
	 *
	 * @param string $table the table that new rows will be inserted into.
	 * @param array $columns the column data (name=>value) to be inserted into the table.
	 * @return Command the command object itself
	 */
Qiang Xue committed
457
	public function insert($table, $columns)
Qiang Xue committed
458
	{
Qiang Xue committed
459
		$params = array();
Qiang Xue committed
460
		$sql = $this->db->getQueryBuilder()->insert($table, $columns, $params);
Qiang Xue committed
461 462 463
		return $this->setSql($sql)->bindValues($params);
	}

Qiang Xue committed
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
	/**
	 * Creates a batch INSERT command.
	 * For example,
	 *
	 * ~~~
	 * $connection->createCommand()->batchInsert('tbl_user', array('name', 'age'), array(
	 *     array('Tom', 30),
	 *     array('Jane', 20),
	 *     array('Linda', 25),
	 * ))->execute();
	 * ~~~
	 *
	 * Not that the values in each row must match the corresponding column names.
	 *
	 * @param string $table the table that new rows will be inserted into.
	 * @param array $columns the column names
	 * @param array $rows the rows to be batch inserted into the table
	 * @return Command the command object itself
	 */
	public function batchInsert($table, $columns, $rows)
	{
		$sql = $this->db->getQueryBuilder()->batchInsert($table, $columns, $rows);
		return $this->setSql($sql);
	}

Qiang Xue committed
489 490 491 492 493
	/**
	 * Creates an UPDATE command.
	 * For example,
	 *
	 * ~~~
Qiang Xue committed
494 495
	 * $connection->createCommand()->update('tbl_user', array(
	 *     'status' => 1,
Qiang Xue committed
496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
	 * ), 'age > 30')->execute();
	 * ~~~
	 *
	 * The method will properly escape the column names and bind the values to be updated.
	 *
	 * Note that the created command is not executed until [[execute()]] is called.
	 *
	 * @param string $table the table to be updated.
	 * @param array $columns the column data (name=>value) to be updated.
	 * @param mixed $condition the condition that will be put in the WHERE part. Please
	 * refer to [[Query::where()]] on how to specify condition.
	 * @param array $params the parameters to be bound to the command
	 * @return Command the command object itself
	 */
	public function update($table, $columns, $condition = '', $params = array())
	{
Qiang Xue committed
512
		$sql = $this->db->getQueryBuilder()->update($table, $columns, $condition, $params);
Qiang Xue committed
513 514 515 516 517 518 519 520
		return $this->setSql($sql)->bindValues($params);
	}

	/**
	 * Creates a DELETE command.
	 * For example,
	 *
	 * ~~~
Qiang Xue committed
521
	 * $connection->createCommand()->delete('tbl_user', 'status = 0')->execute();
Qiang Xue committed
522 523 524 525 526 527 528 529 530 531 532 533 534 535
	 * ~~~
	 *
	 * The method will properly escape the table and column names.
	 *
	 * Note that the created command is not executed until [[execute()]] is called.
	 *
	 * @param string $table the table where the data will be deleted from.
	 * @param mixed $condition the condition that will be put in the WHERE part. Please
	 * refer to [[Query::where()]] on how to specify condition.
	 * @param array $params the parameters to be bound to the command
	 * @return Command the command object itself
	 */
	public function delete($table, $condition = '', $params = array())
	{
Qiang Xue committed
536
		$sql = $this->db->getQueryBuilder()->delete($table, $condition);
Qiang Xue committed
537 538 539 540 541 542 543 544 545 546
		return $this->setSql($sql)->bindValues($params);
	}


	/**
	 * Creates a SQL command for creating a new DB table.
	 *
	 * The columns in the new table should be specified as name-definition pairs (e.g. 'name'=>'string'),
	 * where name stands for a column name which will be properly quoted by the method, and definition
	 * stands for the column type which can contain an abstract DB type.
Qiang Xue committed
547
	 * The method [[QueryBuilder::getColumnType()]] will be called
Qiang Xue committed
548 549 550 551 552 553 554 555 556 557 558 559 560
	 * to convert the abstract column types to physical ones. For example, `string` will be converted
	 * as `varchar(255)`, and `string not null` becomes `varchar(255) not null`.
	 *
	 * If a column is specified with definition only (e.g. 'PRIMARY KEY (name, type)'), it will be directly
	 * inserted into the generated SQL.
	 *
	 * @param string $table the name of the table to be created. The name will be properly quoted by the method.
	 * @param array $columns the columns (name=>definition) in the new table.
	 * @param string $options additional SQL fragment that will be appended to the generated SQL.
	 * @return Command the command object itself
	 */
	public function createTable($table, $columns, $options = null)
	{
Qiang Xue committed
561
		$sql = $this->db->getQueryBuilder()->createTable($table, $columns, $options);
Qiang Xue committed
562 563 564 565 566 567 568 569 570 571 572
		return $this->setSql($sql);
	}

	/**
	 * Creates a SQL command for renaming a DB table.
	 * @param string $table the table to be renamed. The name will be properly quoted by the method.
	 * @param string $newName the new table name. The name will be properly quoted by the method.
	 * @return Command the command object itself
	 */
	public function renameTable($table, $newName)
	{
Qiang Xue committed
573
		$sql = $this->db->getQueryBuilder()->renameTable($table, $newName);
Qiang Xue committed
574 575 576 577 578 579 580 581 582 583
		return $this->setSql($sql);
	}

	/**
	 * Creates a SQL command for dropping a DB table.
	 * @param string $table the table to be dropped. The name will be properly quoted by the method.
	 * @return Command the command object itself
	 */
	public function dropTable($table)
	{
Qiang Xue committed
584
		$sql = $this->db->getQueryBuilder()->dropTable($table);
Qiang Xue committed
585 586 587 588 589 590 591 592 593 594
		return $this->setSql($sql);
	}

	/**
	 * Creates a SQL command for truncating a DB table.
	 * @param string $table the table to be truncated. The name will be properly quoted by the method.
	 * @return Command the command object itself
	 */
	public function truncateTable($table)
	{
Qiang Xue committed
595
		$sql = $this->db->getQueryBuilder()->truncateTable($table);
Qiang Xue committed
596 597 598 599 600 601 602 603 604 605 606 607 608 609
		return $this->setSql($sql);
	}

	/**
	 * Creates a SQL command for adding a new DB column.
	 * @param string $table the table that the new column will be added to. The table name will be properly quoted by the method.
	 * @param string $column the name of the new column. The name will be properly quoted by the method.
	 * @param string $type the column type. [[\yii\db\QueryBuilder::getColumnType()]] will be called
	 * to convert the give column type to the physical one. For example, `string` will be converted
	 * as `varchar(255)`, and `string not null` becomes `varchar(255) not null`.
	 * @return Command the command object itself
	 */
	public function addColumn($table, $column, $type)
	{
Qiang Xue committed
610
		$sql = $this->db->getQueryBuilder()->addColumn($table, $column, $type);
Qiang Xue committed
611 612 613 614 615 616 617 618 619 620 621
		return $this->setSql($sql);
	}

	/**
	 * Creates a SQL command for dropping a DB column.
	 * @param string $table the table whose column is to be dropped. The name will be properly quoted by the method.
	 * @param string $column the name of the column to be dropped. The name will be properly quoted by the method.
	 * @return Command the command object itself
	 */
	public function dropColumn($table, $column)
	{
Qiang Xue committed
622
		$sql = $this->db->getQueryBuilder()->dropColumn($table, $column);
Qiang Xue committed
623 624 625 626 627 628 629 630 631 632 633 634
		return $this->setSql($sql);
	}

	/**
	 * Creates a SQL command for renaming a column.
	 * @param string $table the table whose column is to be renamed. The name will be properly quoted by the method.
	 * @param string $oldName the old name of the column. The name will be properly quoted by the method.
	 * @param string $newName the new name of the column. The name will be properly quoted by the method.
	 * @return Command the command object itself
	 */
	public function renameColumn($table, $oldName, $newName)
	{
Qiang Xue committed
635
		$sql = $this->db->getQueryBuilder()->renameColumn($table, $oldName, $newName);
Qiang Xue committed
636 637 638 639 640 641 642 643 644 645 646 647 648 649
		return $this->setSql($sql);
	}

	/**
	 * Creates a SQL command for changing the definition of a column.
	 * @param string $table the table whose column is to be changed. The table name will be properly quoted by the method.
	 * @param string $column the name of the column to be changed. The name will be properly quoted by the method.
	 * @param string $type the column type. [[\yii\db\QueryBuilder::getColumnType()]] will be called
	 * to convert the give column type to the physical one. For example, `string` will be converted
	 * as `varchar(255)`, and `string not null` becomes `varchar(255) not null`.
	 * @return Command the command object itself
	 */
	public function alterColumn($table, $column, $type)
	{
Qiang Xue committed
650
		$sql = $this->db->getQueryBuilder()->alterColumn($table, $column, $type);
Qiang Xue committed
651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
		return $this->setSql($sql);
	}

	/**
	 * Creates a SQL command for adding a foreign key constraint to an existing table.
	 * The method will properly quote the table and column names.
	 * @param string $name the name of the foreign key constraint.
	 * @param string $table the table that the foreign key constraint will be added to.
	 * @param string $columns the name of the column to that the constraint will be added on. If there are multiple columns, separate them with commas.
	 * @param string $refTable the table that the foreign key references to.
	 * @param string $refColumns the name of the column that the foreign key references to. If there are multiple columns, separate them with commas.
	 * @param string $delete the ON DELETE option. Most DBMS support these options: RESTRICT, CASCADE, NO ACTION, SET DEFAULT, SET NULL
	 * @param string $update the ON UPDATE option. Most DBMS support these options: RESTRICT, CASCADE, NO ACTION, SET DEFAULT, SET NULL
	 * @return Command the command object itself
	 */
	public function addForeignKey($name, $table, $columns, $refTable, $refColumns, $delete = null, $update = null)
	{
Qiang Xue committed
668
		$sql = $this->db->getQueryBuilder()->addForeignKey($name, $table, $columns, $refTable, $refColumns, $delete, $update);
Qiang Xue committed
669 670 671 672 673 674 675 676 677 678 679
		return $this->setSql($sql);
	}

	/**
	 * Creates a SQL command for dropping a foreign key constraint.
	 * @param string $name the name of the foreign key constraint to be dropped. The name will be properly quoted by the method.
	 * @param string $table the table whose foreign is to be dropped. The name will be properly quoted by the method.
	 * @return Command the command object itself
	 */
	public function dropForeignKey($name, $table)
	{
Qiang Xue committed
680
		$sql = $this->db->getQueryBuilder()->dropForeignKey($name, $table);
Qiang Xue committed
681 682 683 684 685 686 687 688 689 690 691 692 693 694
		return $this->setSql($sql);
	}

	/**
	 * Creates a SQL command for creating a new index.
	 * @param string $name the name of the index. The name will be properly quoted by the method.
	 * @param string $table the table that the new index will be created for. The table name will be properly quoted by the method.
	 * @param string $columns the column(s) that should be included in the index. If there are multiple columns, please separate them
	 * by commas. The column names will be properly quoted by the method.
	 * @param boolean $unique whether to add UNIQUE constraint on the created index.
	 * @return Command the command object itself
	 */
	public function createIndex($name, $table, $columns, $unique = false)
	{
Qiang Xue committed
695
		$sql = $this->db->getQueryBuilder()->createIndex($name, $table, $columns, $unique);
Qiang Xue committed
696 697 698 699 700 701 702 703 704 705 706
		return $this->setSql($sql);
	}

	/**
	 * Creates a SQL command for dropping an index.
	 * @param string $name the name of the index to be dropped. The name will be properly quoted by the method.
	 * @param string $table the table whose index is to be dropped. The name will be properly quoted by the method.
	 * @return Command the command object itself
	 */
	public function dropIndex($name, $table)
	{
Qiang Xue committed
707
		$sql = $this->db->getQueryBuilder()->dropIndex($name, $table);
Qiang Xue committed
708 709
		return $this->setSql($sql);
	}
Qiang Xue committed
710 711 712 713 714 715 716 717 718 719 720 721 722

	/**
	 * Creates a SQL command for resetting the sequence value of a table's primary key.
	 * The sequence will be reset such that the primary key of the next new row inserted
	 * will have the specified value or 1.
	 * @param string $table the name of the table whose primary key sequence will be reset
	 * @param mixed $value the value for the primary key of the next new row inserted. If this is not set,
	 * the next new row's primary key will have a value 1.
	 * @return Command the command object itself
	 * @throws NotSupportedException if this is not supported by the underlying DBMS
	 */
	public function resetSequence($table, $value = null)
	{
Qiang Xue committed
723
		$sql = $this->db->getQueryBuilder()->resetSequence($table, $value);
Qiang Xue committed
724 725 726 727 728 729 730 731 732 733 734 735 736
		return $this->setSql($sql);
	}

	/**
	 * Builds a SQL command for enabling or disabling integrity check.
	 * @param boolean $check whether to turn on or off the integrity check.
	 * @param string $schema the schema name of the tables. Defaults to empty string, meaning the current
	 * or default schema.
	 * @return Command the command object itself
	 * @throws NotSupportedException if this is not supported by the underlying DBMS
	 */
	public function checkIntegrity($check = true, $schema = '')
	{
Qiang Xue committed
737
		$sql = $this->db->getQueryBuilder()->checkIntegrity($check, $schema);
Qiang Xue committed
738 739
		return $this->setSql($sql);
	}
w  
Qiang Xue committed
740
}