yiisoft /
yii2
Complex classes like Query often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use Query, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 51 | class Query extends Component implements QueryInterface, ExpressionInterface |
||
| 52 | { |
||
| 53 | use QueryTrait; |
||
| 54 | |||
| 55 | /** |
||
| 56 | * @var array the columns being selected. For example, `['id', 'name']`. |
||
| 57 | * This is used to construct the SELECT clause in a SQL statement. If not set, it means selecting all columns. |
||
| 58 | * @see select() |
||
| 59 | */ |
||
| 60 | public $select; |
||
| 61 | /** |
||
| 62 | * @var string additional option that should be appended to the 'SELECT' keyword. For example, |
||
| 63 | * in MySQL, the option 'SQL_CALC_FOUND_ROWS' can be used. |
||
| 64 | */ |
||
| 65 | public $selectOption; |
||
| 66 | /** |
||
| 67 | * @var bool whether to select distinct rows of data only. If this is set true, |
||
| 68 | * the SELECT clause would be changed to SELECT DISTINCT. |
||
| 69 | */ |
||
| 70 | public $distinct; |
||
| 71 | /** |
||
| 72 | * @var array the table(s) to be selected from. For example, `['user', 'post']`. |
||
| 73 | * This is used to construct the FROM clause in a SQL statement. |
||
| 74 | * @see from() |
||
| 75 | */ |
||
| 76 | public $from; |
||
| 77 | /** |
||
| 78 | * @var array how to group the query results. For example, `['company', 'department']`. |
||
| 79 | * This is used to construct the GROUP BY clause in a SQL statement. |
||
| 80 | */ |
||
| 81 | public $groupBy; |
||
| 82 | /** |
||
| 83 | * @var array how to join with other tables. Each array element represents the specification |
||
| 84 | * of one join which has the following structure: |
||
| 85 | * |
||
| 86 | * ```php |
||
| 87 | * [$joinType, $tableName, $joinCondition] |
||
| 88 | * ``` |
||
| 89 | * |
||
| 90 | * For example, |
||
| 91 | * |
||
| 92 | * ```php |
||
| 93 | * [ |
||
| 94 | * ['INNER JOIN', 'user', 'user.id = author_id'], |
||
| 95 | * ['LEFT JOIN', 'team', 'team.id = team_id'], |
||
| 96 | * ] |
||
| 97 | * ``` |
||
| 98 | */ |
||
| 99 | public $join; |
||
| 100 | /** |
||
| 101 | * @var string|array|ExpressionInterface the condition to be applied in the GROUP BY clause. |
||
| 102 | * It can be either a string or an array. Please refer to [[where()]] on how to specify the condition. |
||
| 103 | */ |
||
| 104 | public $having; |
||
| 105 | /** |
||
| 106 | * @var array this is used to construct the UNION clause(s) in a SQL statement. |
||
| 107 | * Each array element is an array of the following structure: |
||
| 108 | * |
||
| 109 | * - `query`: either a string or a [[Query]] object representing a query |
||
| 110 | * - `all`: boolean, whether it should be `UNION ALL` or `UNION` |
||
| 111 | */ |
||
| 112 | public $union; |
||
| 113 | /** |
||
| 114 | * @var array list of query parameter values indexed by parameter placeholders. |
||
| 115 | * For example, `[':name' => 'Dan', ':age' => 31]`. |
||
| 116 | */ |
||
| 117 | public $params = []; |
||
| 118 | /** |
||
| 119 | * @var int|true the default number of seconds that query results can remain valid in cache. |
||
| 120 | * Use 0 to indicate that the cached data will never expire. |
||
| 121 | * Use a negative number to indicate that query cache should not be used. |
||
| 122 | * Use boolean `true` to indicate that [[Connection::queryCacheDuration]] should be used. |
||
| 123 | * @see cache() |
||
| 124 | * @since 2.0.14 |
||
| 125 | */ |
||
| 126 | public $queryCacheDuration; |
||
| 127 | /** |
||
| 128 | * @var \yii\caching\Dependency the dependency to be associated with the cached query result for this query |
||
| 129 | * @see cache() |
||
| 130 | * @since 2.0.14 |
||
| 131 | */ |
||
| 132 | public $queryCacheDependency; |
||
| 133 | |||
| 134 | |||
| 135 | /** |
||
| 136 | * Creates a DB command that can be used to execute this query. |
||
| 137 | * @param Connection $db the database connection used to generate the SQL statement. |
||
| 138 | * If this parameter is not given, the `db` application component will be used. |
||
| 139 | * @return Command the created DB command instance. |
||
| 140 | */ |
||
| 141 | 363 | public function createCommand($db = null) |
|
| 142 | { |
||
| 143 | 363 | if ($db === null) { |
|
| 144 | 37 | $db = Yii::$app->getDb(); |
|
| 145 | } |
||
| 146 | 363 | [$sql, $params] = $db->getQueryBuilder()->build($this); |
|
| 147 | |||
| 148 | 363 | $command = $db->createCommand($sql, $params); |
|
| 149 | 363 | $this->setCommandCache($command); |
|
| 150 | |||
| 151 | 363 | return $command; |
|
| 152 | } |
||
| 153 | |||
| 154 | /** |
||
| 155 | * Prepares for building SQL. |
||
| 156 | * This method is called by [[QueryBuilder]] when it starts to build SQL from a query object. |
||
| 157 | * You may override this method to do some final preparation work when converting a query into a SQL statement. |
||
| 158 | * @param QueryBuilder $builder |
||
| 159 | * @return $this a prepared query instance which will be used by [[QueryBuilder]] to build the SQL |
||
| 160 | */ |
||
| 161 | 775 | public function prepare($builder) |
|
| 162 | { |
||
| 163 | 775 | return $this; |
|
| 164 | } |
||
| 165 | |||
| 166 | /** |
||
| 167 | * Starts a batch query. |
||
| 168 | * |
||
| 169 | * A batch query supports fetching data in batches, which can keep the memory usage under a limit. |
||
| 170 | * This method will return a [[BatchQueryResult]] object which implements the [[\Iterator]] interface |
||
| 171 | * and can be traversed to retrieve the data in batches. |
||
| 172 | * |
||
| 173 | * For example, |
||
| 174 | * |
||
| 175 | * ```php |
||
| 176 | * $query = (new Query)->from('user'); |
||
| 177 | * foreach ($query->batch() as $rows) { |
||
| 178 | * // $rows is an array of 100 or fewer rows from user table |
||
| 179 | * } |
||
| 180 | * ``` |
||
| 181 | * |
||
| 182 | * @param int $batchSize the number of records to be fetched in each batch. |
||
| 183 | * @param Connection $db the database connection. If not set, the "db" application component will be used. |
||
| 184 | * @return BatchQueryResult the batch query result. It implements the [[\Iterator]] interface |
||
| 185 | * and can be traversed to retrieve the data in batches. |
||
| 186 | */ |
||
| 187 | 6 | public function batch($batchSize = 100, $db = null) |
|
| 188 | { |
||
| 189 | 6 | return Yii::createObject([ |
|
| 190 | 6 | 'class' => BatchQueryResult::class, |
|
| 191 | 6 | 'query' => $this, |
|
| 192 | 6 | 'batchSize' => $batchSize, |
|
| 193 | 6 | 'db' => $db, |
|
| 194 | 'each' => false, |
||
| 195 | ]); |
||
| 196 | } |
||
| 197 | |||
| 198 | /** |
||
| 199 | * Starts a batch query and retrieves data row by row. |
||
| 200 | * |
||
| 201 | * This method is similar to [[batch()]] except that in each iteration of the result, |
||
| 202 | * only one row of data is returned. For example, |
||
| 203 | * |
||
| 204 | * ```php |
||
| 205 | * $query = (new Query)->from('user'); |
||
| 206 | * foreach ($query->each() as $row) { |
||
| 207 | * } |
||
| 208 | * ``` |
||
| 209 | * |
||
| 210 | * @param int $batchSize the number of records to be fetched in each batch. |
||
| 211 | * @param Connection $db the database connection. If not set, the "db" application component will be used. |
||
| 212 | * @return BatchQueryResult the batch query result. It implements the [[\Iterator]] interface |
||
| 213 | * and can be traversed to retrieve the data in batches. |
||
| 214 | */ |
||
| 215 | 3 | public function each($batchSize = 100, $db = null) |
|
| 216 | { |
||
| 217 | 3 | return Yii::createObject([ |
|
| 218 | 3 | 'class' => BatchQueryResult::class, |
|
| 219 | 3 | 'query' => $this, |
|
| 220 | 3 | 'batchSize' => $batchSize, |
|
| 221 | 3 | 'db' => $db, |
|
| 222 | 'each' => true, |
||
| 223 | ]); |
||
| 224 | } |
||
| 225 | |||
| 226 | /** |
||
| 227 | * Executes the query and returns all results as an array. |
||
| 228 | * @param Connection $db the database connection used to generate the SQL statement. |
||
| 229 | * If this parameter is not given, the `db` application component will be used. |
||
| 230 | * @return array the query results. If the query results in nothing, an empty array will be returned. |
||
| 231 | */ |
||
| 232 | 424 | public function all($db = null) |
|
| 233 | { |
||
| 234 | 424 | if ($this->emulateExecution) { |
|
| 235 | 9 | return []; |
|
| 236 | } |
||
| 237 | 418 | $rows = $this->createCommand($db)->queryAll(); |
|
| 238 | 418 | return $this->populate($rows); |
|
| 239 | } |
||
| 240 | |||
| 241 | /** |
||
| 242 | * Converts the raw query results into the format as specified by this query. |
||
| 243 | * This method is internally used to convert the data fetched from database |
||
| 244 | * into the format as required by this query. |
||
| 245 | * @param array $rows the raw query result from database |
||
| 246 | * @return array the converted query result |
||
| 247 | */ |
||
| 248 | 548 | public function populate($rows) |
|
| 249 | { |
||
| 250 | 548 | if ($this->indexBy === null) { |
|
| 251 | 542 | return $rows; |
|
| 252 | } |
||
| 253 | 21 | $result = []; |
|
| 254 | 21 | foreach ($rows as $row) { |
|
| 255 | 21 | $result[ArrayHelper::getValue($row, $this->indexBy)] = $row; |
|
| 256 | } |
||
| 257 | |||
| 258 | 21 | return $result; |
|
| 259 | } |
||
| 260 | |||
| 261 | /** |
||
| 262 | * Executes the query and returns a single row of result. |
||
| 263 | * @param Connection $db the database connection used to generate the SQL statement. |
||
| 264 | * If this parameter is not given, the `db` application component will be used. |
||
| 265 | * @return array|bool the first row (in terms of an array) of the query result. False is returned if the query |
||
| 266 | * results in nothing. |
||
| 267 | */ |
||
| 268 | 451 | public function one($db = null) |
|
| 269 | { |
||
| 270 | 451 | if ($this->emulateExecution) { |
|
| 271 | 6 | return false; |
|
| 272 | } |
||
| 273 | |||
| 274 | 445 | return $this->createCommand($db)->queryOne(); |
|
| 275 | } |
||
| 276 | |||
| 277 | /** |
||
| 278 | * Returns the query result as a scalar value. |
||
| 279 | * The value returned will be the first column in the first row of the query results. |
||
| 280 | * @param Connection $db the database connection used to generate the SQL statement. |
||
| 281 | * If this parameter is not given, the `db` application component will be used. |
||
| 282 | * @return string|null|false the value of the first column in the first row of the query result. |
||
| 283 | * False is returned if the query result is empty. |
||
| 284 | */ |
||
| 285 | 30 | public function scalar($db = null) |
|
| 286 | { |
||
| 287 | 30 | if ($this->emulateExecution) { |
|
| 288 | 6 | return null; |
|
| 289 | } |
||
| 290 | |||
| 291 | 24 | return $this->createCommand($db)->queryScalar(); |
|
| 292 | } |
||
| 293 | |||
| 294 | /** |
||
| 295 | * Executes the query and returns the first column of the result. |
||
| 296 | * @param Connection $db the database connection used to generate the SQL statement. |
||
| 297 | * If this parameter is not given, the `db` application component will be used. |
||
| 298 | * @return array the first column of the query result. An empty array is returned if the query results in nothing. |
||
| 299 | */ |
||
| 300 | 73 | public function column($db = null) |
|
| 301 | { |
||
| 302 | 73 | if ($this->emulateExecution) { |
|
| 303 | 6 | return []; |
|
| 304 | } |
||
| 305 | |||
| 306 | 67 | if ($this->indexBy === null) { |
|
| 307 | 61 | return $this->createCommand($db)->queryColumn(); |
|
| 308 | } |
||
| 309 | |||
| 310 | 9 | if (is_string($this->indexBy) && is_array($this->select) && count($this->select) === 1) { |
|
| 311 | 9 | if (strpos($this->indexBy, '.') === false && count($tables = $this->getTablesUsedInFrom()) > 0) { |
|
| 312 | 9 | $this->select[] = key($tables) . '.' . $this->indexBy; |
|
| 313 | } else { |
||
| 314 | $this->select[] = $this->indexBy; |
||
| 315 | } |
||
| 316 | } |
||
| 317 | 9 | $rows = $this->createCommand($db)->queryAll(); |
|
| 318 | 9 | $results = []; |
|
| 319 | 9 | foreach ($rows as $row) { |
|
| 320 | 9 | $value = reset($row); |
|
| 321 | |||
| 322 | 9 | if ($this->indexBy instanceof \Closure) { |
|
| 323 | 3 | $results[call_user_func($this->indexBy, $row)] = $value; |
|
| 324 | } else { |
||
| 325 | 9 | $results[$row[$this->indexBy]] = $value; |
|
| 326 | } |
||
| 327 | } |
||
| 328 | |||
| 329 | 9 | return $results; |
|
| 330 | } |
||
| 331 | |||
| 332 | /** |
||
| 333 | * Returns the number of records. |
||
| 334 | * @param string $q the COUNT expression. Defaults to '*'. |
||
| 335 | * Make sure you properly [quote](guide:db-dao#quoting-table-and-column-names) column names in the expression. |
||
| 336 | * @param Connection $db the database connection used to generate the SQL statement. |
||
| 337 | * If this parameter is not given (or null), the `db` application component will be used. |
||
| 338 | * @return int|string number of records. The result may be a string depending on the |
||
| 339 | * underlying database engine and to support integer values higher than a 32bit PHP integer can handle. |
||
| 340 | */ |
||
| 341 | 90 | public function count($q = '*', $db = null) |
|
| 342 | { |
||
| 343 | 90 | if ($this->emulateExecution) { |
|
| 344 | 6 | return 0; |
|
| 345 | } |
||
| 346 | |||
| 347 | 90 | return $this->queryScalar("COUNT($q)", $db); |
|
| 348 | } |
||
| 349 | |||
| 350 | /** |
||
| 351 | * Returns the sum of the specified column values. |
||
| 352 | * @param string $q the column name or expression. |
||
| 353 | * Make sure you properly [quote](guide:db-dao#quoting-table-and-column-names) column names in the expression. |
||
| 354 | * @param Connection $db the database connection used to generate the SQL statement. |
||
| 355 | * If this parameter is not given, the `db` application component will be used. |
||
| 356 | * @return mixed the sum of the specified column values. |
||
| 357 | */ |
||
| 358 | 9 | public function sum($q, $db = null) |
|
| 359 | { |
||
| 360 | 9 | if ($this->emulateExecution) { |
|
| 361 | 6 | return 0; |
|
| 362 | } |
||
| 363 | |||
| 364 | 3 | return $this->queryScalar("SUM($q)", $db); |
|
| 365 | } |
||
| 366 | |||
| 367 | /** |
||
| 368 | * Returns the average of the specified column values. |
||
| 369 | * @param string $q the column name or expression. |
||
| 370 | * Make sure you properly [quote](guide:db-dao#quoting-table-and-column-names) column names in the expression. |
||
| 371 | * @param Connection $db the database connection used to generate the SQL statement. |
||
| 372 | * If this parameter is not given, the `db` application component will be used. |
||
| 373 | * @return mixed the average of the specified column values. |
||
| 374 | */ |
||
| 375 | 9 | public function average($q, $db = null) |
|
| 376 | { |
||
| 377 | 9 | if ($this->emulateExecution) { |
|
| 378 | 6 | return 0; |
|
| 379 | } |
||
| 380 | |||
| 381 | 3 | return $this->queryScalar("AVG($q)", $db); |
|
| 382 | } |
||
| 383 | |||
| 384 | /** |
||
| 385 | * Returns the minimum of the specified column values. |
||
| 386 | * @param string $q the column name or expression. |
||
| 387 | * Make sure you properly [quote](guide:db-dao#quoting-table-and-column-names) column names in the expression. |
||
| 388 | * @param Connection $db the database connection used to generate the SQL statement. |
||
| 389 | * If this parameter is not given, the `db` application component will be used. |
||
| 390 | * @return mixed the minimum of the specified column values. |
||
| 391 | */ |
||
| 392 | 9 | public function min($q, $db = null) |
|
| 393 | { |
||
| 394 | 9 | return $this->queryScalar("MIN($q)", $db); |
|
| 395 | } |
||
| 396 | |||
| 397 | /** |
||
| 398 | * Returns the maximum of the specified column values. |
||
| 399 | * @param string $q the column name or expression. |
||
| 400 | * Make sure you properly [quote](guide:db-dao#quoting-table-and-column-names) column names in the expression. |
||
| 401 | * @param Connection $db the database connection used to generate the SQL statement. |
||
| 402 | * If this parameter is not given, the `db` application component will be used. |
||
| 403 | * @return mixed the maximum of the specified column values. |
||
| 404 | */ |
||
| 405 | 9 | public function max($q, $db = null) |
|
| 406 | { |
||
| 407 | 9 | return $this->queryScalar("MAX($q)", $db); |
|
| 408 | } |
||
| 409 | |||
| 410 | /** |
||
| 411 | * Returns a value indicating whether the query result contains any row of data. |
||
| 412 | * @param Connection $db the database connection used to generate the SQL statement. |
||
| 413 | * If this parameter is not given, the `db` application component will be used. |
||
| 414 | * @return bool whether the query result contains any row of data. |
||
| 415 | */ |
||
| 416 | 73 | public function exists($db = null) |
|
| 417 | { |
||
| 418 | 73 | if ($this->emulateExecution) { |
|
| 419 | 6 | return false; |
|
| 420 | } |
||
| 421 | 67 | $command = $this->createCommand($db); |
|
| 422 | 67 | $params = $command->params; |
|
| 423 | 67 | $command->setSql($command->db->getQueryBuilder()->selectExists($command->getSql())); |
|
| 424 | 67 | $command->bindValues($params); |
|
| 425 | 67 | return (bool) $command->queryScalar(); |
|
| 426 | } |
||
| 427 | |||
| 428 | /** |
||
| 429 | * Queries a scalar value by setting [[select]] first. |
||
| 430 | * Restores the value of select to make this query reusable. |
||
| 431 | * @param string|ExpressionInterface $selectExpression |
||
| 432 | * @param Connection|null $db |
||
| 433 | * @return bool|string |
||
| 434 | */ |
||
| 435 | 90 | protected function queryScalar($selectExpression, $db) |
|
| 436 | { |
||
| 437 | 90 | if ($this->emulateExecution) { |
|
| 438 | 6 | return null; |
|
| 439 | } |
||
| 440 | |||
| 441 | if ( |
||
| 442 | 90 | !$this->distinct |
|
| 443 | 90 | && empty($this->groupBy) |
|
| 444 | 90 | && empty($this->having) |
|
| 445 | 90 | && empty($this->union) |
|
| 446 | ) { |
||
| 447 | 89 | $select = $this->select; |
|
| 448 | 89 | $order = $this->orderBy; |
|
| 449 | 89 | $limit = $this->limit; |
|
| 450 | 89 | $offset = $this->offset; |
|
| 451 | |||
| 452 | 89 | $this->select = [$selectExpression]; |
|
| 453 | 89 | $this->orderBy = null; |
|
| 454 | 89 | $this->limit = null; |
|
| 455 | 89 | $this->offset = null; |
|
| 456 | 89 | $command = $this->createCommand($db); |
|
| 457 | |||
| 458 | 89 | $this->select = $select; |
|
| 459 | 89 | $this->orderBy = $order; |
|
| 460 | 89 | $this->limit = $limit; |
|
| 461 | 89 | $this->offset = $offset; |
|
| 462 | |||
| 463 | 89 | return $command->queryScalar(); |
|
| 464 | } |
||
| 465 | |||
| 466 | 7 | $command = (new self()) |
|
| 467 | 7 | ->select([$selectExpression]) |
|
| 468 | 7 | ->from(['c' => $this]) |
|
| 469 | 7 | ->createCommand($db); |
|
| 470 | 7 | $this->setCommandCache($command); |
|
| 471 | |||
| 472 | 7 | return $command->queryScalar(); |
|
| 473 | } |
||
| 474 | |||
| 475 | /** |
||
| 476 | * Returns table names used in [[from]] indexed by aliases. |
||
| 477 | * Both aliases and names are enclosed into {{ and }}. |
||
| 478 | * @return string[] table names indexed by aliases |
||
| 479 | * @throws \yii\base\InvalidConfigException |
||
| 480 | * @since 2.0.12 |
||
| 481 | */ |
||
| 482 | 69 | public function getTablesUsedInFrom() |
|
| 483 | { |
||
| 484 | 69 | if (empty($this->from)) { |
|
| 485 | return []; |
||
| 486 | } |
||
| 487 | |||
| 488 | 69 | if (is_array($this->from)) { |
|
| 489 | 33 | $tableNames = $this->from; |
|
| 490 | 36 | } elseif (is_string($this->from)) { |
|
| 491 | 24 | $tableNames = preg_split('/\s*,\s*/', trim($this->from), -1, PREG_SPLIT_NO_EMPTY); |
|
| 492 | 12 | } elseif ($this->from instanceof Expression) { |
|
| 493 | 6 | $tableNames = [$this->from]; |
|
| 494 | } else { |
||
| 495 | 6 | throw new InvalidConfigException(gettype($this->from) . ' in $from is not supported.'); |
|
| 496 | } |
||
| 497 | |||
| 498 | 63 | return $this->cleanUpTableNames($tableNames); |
|
| 499 | } |
||
| 500 | |||
| 501 | /** |
||
| 502 | * Clean up table names and aliases |
||
| 503 | * Both aliases and names are enclosed into {{ and }}. |
||
| 504 | * @param array $tableNames non-empty array |
||
| 505 | * @return string[] table names indexed by aliases |
||
| 506 | * @since 2.0.14 |
||
| 507 | */ |
||
| 508 | 165 | protected function cleanUpTableNames($tableNames) |
|
| 509 | { |
||
| 510 | 165 | $cleanedUpTableNames = []; |
|
| 511 | 165 | foreach ($tableNames as $alias => $tableName) { |
|
| 512 | 165 | if (is_string($tableName) && !is_string($alias)) { |
|
| 513 | $pattern = <<<PATTERN |
||
| 514 | 144 | ~ |
|
| 515 | ^ |
||
| 516 | \s* |
||
| 517 | ( |
||
| 518 | (?:['"`\[]|{{) |
||
| 519 | .*? |
||
| 520 | (?:['"`\]]|}}) |
||
| 521 | | |
||
| 522 | \(.*?\) |
||
| 523 | | |
||
| 524 | .*? |
||
| 525 | ) |
||
| 526 | (?: |
||
| 527 | (?: |
||
| 528 | \s+ |
||
| 529 | (?:as)? |
||
| 530 | \s* |
||
| 531 | ) |
||
| 532 | ( |
||
| 533 | (?:['"`\[]|{{) |
||
| 534 | .*? |
||
| 535 | (?:['"`\]]|}}) |
||
| 536 | | |
||
| 537 | .*? |
||
| 538 | ) |
||
| 539 | )? |
||
| 540 | \s* |
||
| 541 | $ |
||
| 542 | ~iux |
||
| 543 | PATTERN; |
||
| 544 | 144 | if (preg_match($pattern, $tableName, $matches)) { |
|
| 545 | 144 | if (isset($matches[2])) { |
|
| 546 | 18 | [, $tableName, $alias] = $matches; |
|
| 547 | } else { |
||
| 548 | 138 | $tableName = $alias = $matches[1]; |
|
| 549 | } |
||
| 550 | } |
||
| 551 | } |
||
| 552 | |||
| 553 | |||
| 554 | 165 | if ($tableName instanceof Expression) { |
|
| 555 | 12 | if (!is_string($alias)) { |
|
| 556 | 6 | throw new InvalidArgumentException('To use Expression in from() method, pass it in array format with alias.'); |
|
| 557 | } |
||
| 558 | 6 | $cleanedUpTableNames[$this->ensureNameQuoted($alias)] = $tableName; |
|
| 559 | 153 | } elseif ($tableName instanceof self) { |
|
| 560 | 6 | $cleanedUpTableNames[$this->ensureNameQuoted($alias)] = $tableName; |
|
| 561 | } else { |
||
| 562 | 159 | $cleanedUpTableNames[$this->ensureNameQuoted($alias)] = $this->ensureNameQuoted($tableName); |
|
| 563 | } |
||
| 564 | } |
||
| 565 | |||
| 566 | 159 | return $cleanedUpTableNames; |
|
| 567 | } |
||
| 568 | |||
| 569 | /** |
||
| 570 | * Ensures name is wrapped with {{ and }} |
||
| 571 | * @param string $name |
||
| 572 | * @return string |
||
| 573 | */ |
||
| 574 | 159 | private function ensureNameQuoted($name) |
|
| 575 | { |
||
| 576 | 159 | $name = str_replace(["'", '"', '`', '[', ']'], '', $name); |
|
| 577 | 159 | if ($name && !preg_match('/^{{.*}}$/', $name)) { |
|
| 578 | 147 | return '{{' . $name . '}}'; |
|
| 579 | } |
||
| 580 | |||
| 581 | 30 | return $name; |
|
| 582 | } |
||
| 583 | |||
| 584 | /** |
||
| 585 | * Sets the SELECT part of the query. |
||
| 586 | * @param string|array|ExpressionInterface $columns the columns to be selected. |
||
| 587 | * Columns can be specified in either a string (e.g. "id, name") or an array (e.g. ['id', 'name']). |
||
| 588 | * Columns can be prefixed with table names (e.g. "user.id") and/or contain column aliases (e.g. "user.id AS user_id"). |
||
| 589 | * The method will automatically quote the column names unless a column contains some parenthesis |
||
| 590 | * (which means the column contains a DB expression). A DB expression may also be passed in form of |
||
| 591 | * an [[ExpressionInterface]] object. |
||
| 592 | * |
||
| 593 | * Note that if you are selecting an expression like `CONCAT(first_name, ' ', last_name)`, you should |
||
| 594 | * use an array to specify the columns. Otherwise, the expression may be incorrectly split into several parts. |
||
| 595 | * |
||
| 596 | * When the columns are specified as an array, you may also use array keys as the column aliases (if a column |
||
| 597 | * does not need alias, do not use a string key). |
||
| 598 | * |
||
| 599 | * Starting from version 2.0.1, you may also select sub-queries as columns by specifying each such column |
||
| 600 | * as a `Query` instance representing the sub-query. |
||
| 601 | * |
||
| 602 | * @param string $option additional option that should be appended to the 'SELECT' keyword. For example, |
||
| 603 | * in MySQL, the option 'SQL_CALC_FOUND_ROWS' can be used. |
||
| 604 | * @return $this the query object itself |
||
| 605 | */ |
||
| 606 | 402 | public function select($columns, $option = null) |
|
| 607 | { |
||
| 608 | 402 | if ($columns instanceof ExpressionInterface) { |
|
| 609 | 3 | $columns = [$columns]; |
|
| 610 | 399 | } elseif (!is_array($columns)) { |
|
| 611 | 107 | $columns = preg_split('/\s*,\s*/', trim($columns), -1, PREG_SPLIT_NO_EMPTY); |
|
| 612 | } |
||
| 613 | 402 | $this->select = []; |
|
| 614 | 402 | $this->select = $this->getUniqueColumns($columns); |
|
| 615 | 402 | $this->selectOption = $option; |
|
| 616 | 402 | return $this; |
|
| 617 | } |
||
| 618 | |||
| 619 | /** |
||
| 620 | * Add more columns to the SELECT part of the query. |
||
| 621 | * |
||
| 622 | * Note, that if [[select]] has not been specified before, you should include `*` explicitly |
||
| 623 | * if you want to select all remaining columns too: |
||
| 624 | * |
||
| 625 | * ```php |
||
| 626 | * $query->addSelect(["*", "CONCAT(first_name, ' ', last_name) AS full_name"])->one(); |
||
| 627 | * ``` |
||
| 628 | * |
||
| 629 | * @param string|array|ExpressionInterface $columns the columns to add to the select. See [[select()]] for more |
||
| 630 | * details about the format of this parameter. |
||
| 631 | * @return $this the query object itself |
||
| 632 | * @see select() |
||
| 633 | */ |
||
| 634 | 9 | public function addSelect($columns) |
|
| 650 | |||
| 651 | /** |
||
| 652 | * Returns unique column names excluding duplicates. |
||
| 653 | * Columns to be removed: |
||
| 654 | * - if column definition already present in SELECT part with same alias |
||
| 655 | * - if column definition without alias already present in SELECT part without alias too |
||
| 656 | * @param array $columns the columns to be merged to the select. |
||
| 657 | * @since 2.0.14 |
||
| 658 | */ |
||
| 659 | 402 | protected function getUniqueColumns($columns) |
|
| 678 | |||
| 679 | /** |
||
| 680 | * @return array List of columns without aliases from SELECT statement. |
||
| 681 | * @since 2.0.14 |
||
| 682 | */ |
||
| 683 | 402 | protected function getUnaliasedColumnsFromSelect() |
|
| 695 | |||
| 696 | /** |
||
| 697 | * Sets the value indicating whether to SELECT DISTINCT or not. |
||
| 698 | * @param bool $value whether to SELECT DISTINCT or not. |
||
| 699 | * @return $this the query object itself |
||
| 700 | */ |
||
| 701 | 6 | public function distinct($value = true) |
|
| 706 | |||
| 707 | /** |
||
| 708 | * Sets the FROM part of the query. |
||
| 709 | * @param string|array|ExpressionInterface $tables the table(s) to be selected from. This can be either a string (e.g. `'user'`) |
||
| 710 | * or an array (e.g. `['user', 'profile']`) specifying one or several table names. |
||
| 711 | * Table names can contain schema prefixes (e.g. `'public.user'`) and/or table aliases (e.g. `'user u'`). |
||
| 712 | * The method will automatically quote the table names unless it contains some parenthesis |
||
| 713 | * (which means the table is given as a sub-query or DB expression). |
||
| 714 | * |
||
| 715 | * When the tables are specified as an array, you may also use the array keys as the table aliases |
||
| 716 | * (if a table does not need alias, do not use a string key). |
||
| 717 | * |
||
| 718 | * Use a Query object to represent a sub-query. In this case, the corresponding array key will be used |
||
| 719 | * as the alias for the sub-query. |
||
| 720 | * |
||
| 721 | * To specify the `FROM` part in plain SQL, you may pass an instance of [[ExpressionInterface]]. |
||
| 722 | * |
||
| 723 | * Here are some examples: |
||
| 724 | * |
||
| 725 | * ```php |
||
| 726 | * // SELECT * FROM `user` `u`, `profile`; |
||
| 727 | * $query = (new \yii\db\Query)->from(['u' => 'user', 'profile']); |
||
| 728 | * |
||
| 729 | * // SELECT * FROM (SELECT * FROM `user` WHERE `active` = 1) `activeusers`; |
||
| 730 | * $subquery = (new \yii\db\Query)->from('user')->where(['active' => true]) |
||
| 731 | * $query = (new \yii\db\Query)->from(['activeusers' => $subquery]); |
||
| 732 | * |
||
| 733 | * // subquery can also be a string with plain SQL wrapped in parenthesis |
||
| 734 | * // SELECT * FROM (SELECT * FROM `user` WHERE `active` = 1) `activeusers`; |
||
| 735 | * $subquery = "(SELECT * FROM `user` WHERE `active` = 1)"; |
||
| 736 | * $query = (new \yii\db\Query)->from(['activeusers' => $subquery]); |
||
| 737 | * ``` |
||
| 738 | * |
||
| 739 | * @return $this the query object itself |
||
| 740 | */ |
||
| 741 | 441 | public function from($tables) |
|
| 752 | |||
| 753 | /** |
||
| 754 | * Sets the WHERE part of the query. |
||
| 755 | * |
||
| 756 | * The method requires a `$condition` parameter, and optionally a `$params` parameter |
||
| 757 | * specifying the values to be bound to the query. |
||
| 758 | * |
||
| 759 | * The `$condition` parameter should be either a string (e.g. `'id=1'`) or an array. |
||
| 760 | * |
||
| 761 | * {@inheritdoc} |
||
| 762 | * |
||
| 763 | * @param string|array|ExpressionInterface $condition the conditions that should be put in the WHERE part. |
||
| 764 | * @param array $params the parameters (name => value) to be bound to the query. |
||
| 765 | * @return $this the query object itself |
||
| 766 | * @see andWhere() |
||
| 767 | * @see orWhere() |
||
| 768 | * @see QueryInterface::where() |
||
| 769 | */ |
||
| 770 | 747 | public function where($condition, $params = []) |
|
| 776 | |||
| 777 | /** |
||
| 778 | * Adds an additional WHERE condition to the existing one. |
||
| 779 | * The new condition and the existing one will be joined using the `AND` operator. |
||
| 780 | * @param string|array|ExpressionInterface $condition the new WHERE condition. Please refer to [[where()]] |
||
| 781 | * on how to specify this parameter. |
||
| 782 | * @param array $params the parameters (name => value) to be bound to the query. |
||
| 783 | * @return $this the query object itself |
||
| 784 | * @see where() |
||
| 785 | * @see orWhere() |
||
| 786 | */ |
||
| 787 | 343 | public function andWhere($condition, $params = []) |
|
| 799 | |||
| 800 | /** |
||
| 801 | * Adds an additional WHERE condition to the existing one. |
||
| 802 | * The new condition and the existing one will be joined using the `OR` operator. |
||
| 803 | * @param string|array|ExpressionInterface $condition the new WHERE condition. Please refer to [[where()]] |
||
| 804 | * on how to specify this parameter. |
||
| 805 | * @param array $params the parameters (name => value) to be bound to the query. |
||
| 806 | * @return $this the query object itself |
||
| 807 | * @see where() |
||
| 808 | * @see andWhere() |
||
| 809 | */ |
||
| 810 | 7 | public function orWhere($condition, $params = []) |
|
| 820 | |||
| 821 | /** |
||
| 822 | * Adds a filtering condition for a specific column and allow the user to choose a filter operator. |
||
| 823 | * |
||
| 824 | * It adds an additional WHERE condition for the given field and determines the comparison operator |
||
| 825 | * based on the first few characters of the given value. |
||
| 826 | * The condition is added in the same way as in [[andFilterWhere]] so [[isEmpty()|empty values]] are ignored. |
||
| 827 | * The new condition and the existing one will be joined using the `AND` operator. |
||
| 828 | * |
||
| 829 | * The comparison operator is intelligently determined based on the first few characters in the given value. |
||
| 830 | * In particular, it recognizes the following operators if they appear as the leading characters in the given value: |
||
| 831 | * |
||
| 832 | * - `<`: the column must be less than the given value. |
||
| 833 | * - `>`: the column must be greater than the given value. |
||
| 834 | * - `<=`: the column must be less than or equal to the given value. |
||
| 835 | * - `>=`: the column must be greater than or equal to the given value. |
||
| 836 | * - `<>`: the column must not be the same as the given value. |
||
| 837 | * - `=`: the column must be equal to the given value. |
||
| 838 | * - If none of the above operators is detected, the `$defaultOperator` will be used. |
||
| 839 | * |
||
| 840 | * @param string $name the column name. |
||
| 841 | * @param string $value the column value optionally prepended with the comparison operator. |
||
| 842 | * @param string $defaultOperator The operator to use, when no operator is given in `$value`. |
||
| 843 | * Defaults to `=`, performing an exact match. |
||
| 844 | * @return $this The query object itself |
||
| 845 | * @since 2.0.8 |
||
| 846 | */ |
||
| 847 | 3 | public function andFilterCompare($name, $value, $defaultOperator = '=') |
|
| 858 | |||
| 859 | /** |
||
| 860 | * Appends a JOIN part to the query. |
||
| 861 | * The first parameter specifies what type of join it is. |
||
| 862 | * @param string $type the type of join, such as INNER JOIN, LEFT JOIN. |
||
| 863 | * @param string|array $table the table to be joined. |
||
| 864 | * |
||
| 865 | * Use a string to represent the name of the table to be joined. |
||
| 866 | * The table name can contain a schema prefix (e.g. 'public.user') and/or table alias (e.g. 'user u'). |
||
| 867 | * The method will automatically quote the table name unless it contains some parenthesis |
||
| 868 | * (which means the table is given as a sub-query or DB expression). |
||
| 869 | * |
||
| 870 | * Use an array to represent joining with a sub-query. The array must contain only one element. |
||
| 871 | * The value must be a [[Query]] object representing the sub-query while the corresponding key |
||
| 872 | * represents the alias for the sub-query. |
||
| 873 | * |
||
| 874 | * @param string|array $on the join condition that should appear in the ON part. |
||
| 875 | * Please refer to [[where()]] on how to specify this parameter. |
||
| 876 | * |
||
| 877 | * Note that the array format of [[where()]] is designed to match columns to values instead of columns to columns, so |
||
| 878 | * the following would **not** work as expected: `['post.author_id' => 'user.id']`, it would |
||
| 879 | * match the `post.author_id` column value against the string `'user.id'`. |
||
| 880 | * It is recommended to use the string syntax here which is more suited for a join: |
||
| 881 | * |
||
| 882 | * ```php |
||
| 883 | * 'post.author_id = user.id' |
||
| 884 | * ``` |
||
| 885 | * |
||
| 886 | * @param array $params the parameters (name => value) to be bound to the query. |
||
| 887 | * @return $this the query object itself |
||
| 888 | */ |
||
| 889 | 48 | public function join($type, $table, $on = '', $params = []) |
|
| 894 | |||
| 895 | /** |
||
| 896 | * Appends an INNER JOIN part to the query. |
||
| 897 | * @param string|array $table the table to be joined. |
||
| 898 | * |
||
| 899 | * Use a string to represent the name of the table to be joined. |
||
| 900 | * The table name can contain a schema prefix (e.g. 'public.user') and/or table alias (e.g. 'user u'). |
||
| 901 | * The method will automatically quote the table name unless it contains some parenthesis |
||
| 902 | * (which means the table is given as a sub-query or DB expression). |
||
| 903 | * |
||
| 904 | * Use an array to represent joining with a sub-query. The array must contain only one element. |
||
| 905 | * The value must be a [[Query]] object representing the sub-query while the corresponding key |
||
| 906 | * represents the alias for the sub-query. |
||
| 907 | * |
||
| 908 | * @param string|array $on the join condition that should appear in the ON part. |
||
| 909 | * Please refer to [[join()]] on how to specify this parameter. |
||
| 910 | * @param array $params the parameters (name => value) to be bound to the query. |
||
| 911 | * @return $this the query object itself |
||
| 912 | */ |
||
| 913 | 3 | public function innerJoin($table, $on = '', $params = []) |
|
| 918 | |||
| 919 | /** |
||
| 920 | * Appends a LEFT OUTER JOIN part to the query. |
||
| 921 | * @param string|array $table the table to be joined. |
||
| 922 | * |
||
| 923 | * Use a string to represent the name of the table to be joined. |
||
| 924 | * The table name can contain a schema prefix (e.g. 'public.user') and/or table alias (e.g. 'user u'). |
||
| 925 | * The method will automatically quote the table name unless it contains some parenthesis |
||
| 926 | * (which means the table is given as a sub-query or DB expression). |
||
| 927 | * |
||
| 928 | * Use an array to represent joining with a sub-query. The array must contain only one element. |
||
| 929 | * The value must be a [[Query]] object representing the sub-query while the corresponding key |
||
| 930 | * represents the alias for the sub-query. |
||
| 931 | * |
||
| 932 | * @param string|array $on the join condition that should appear in the ON part. |
||
| 933 | * Please refer to [[join()]] on how to specify this parameter. |
||
| 934 | * @param array $params the parameters (name => value) to be bound to the query |
||
| 935 | * @return $this the query object itself |
||
| 936 | */ |
||
| 937 | 3 | public function leftJoin($table, $on = '', $params = []) |
|
| 942 | |||
| 943 | /** |
||
| 944 | * Appends a RIGHT OUTER JOIN part to the query. |
||
| 945 | * @param string|array $table the table to be joined. |
||
| 946 | * |
||
| 947 | * Use a string to represent the name of the table to be joined. |
||
| 948 | * The table name can contain a schema prefix (e.g. 'public.user') and/or table alias (e.g. 'user u'). |
||
| 949 | * The method will automatically quote the table name unless it contains some parenthesis |
||
| 950 | * (which means the table is given as a sub-query or DB expression). |
||
| 951 | * |
||
| 952 | * Use an array to represent joining with a sub-query. The array must contain only one element. |
||
| 953 | * The value must be a [[Query]] object representing the sub-query while the corresponding key |
||
| 954 | * represents the alias for the sub-query. |
||
| 955 | * |
||
| 956 | * @param string|array $on the join condition that should appear in the ON part. |
||
| 957 | * Please refer to [[join()]] on how to specify this parameter. |
||
| 958 | * @param array $params the parameters (name => value) to be bound to the query |
||
| 959 | * @return $this the query object itself |
||
| 960 | */ |
||
| 961 | public function rightJoin($table, $on = '', $params = []) |
||
| 966 | |||
| 967 | /** |
||
| 968 | * Sets the GROUP BY part of the query. |
||
| 969 | * @param string|array|ExpressionInterface $columns the columns to be grouped by. |
||
| 970 | * Columns can be specified in either a string (e.g. "id, name") or an array (e.g. ['id', 'name']). |
||
| 971 | * The method will automatically quote the column names unless a column contains some parenthesis |
||
| 972 | * (which means the column contains a DB expression). |
||
| 973 | * |
||
| 974 | * Note that if your group-by is an expression containing commas, you should always use an array |
||
| 975 | * to represent the group-by information. Otherwise, the method will not be able to correctly determine |
||
| 976 | * the group-by columns. |
||
| 977 | * |
||
| 978 | * Since version 2.0.7, an [[ExpressionInterface]] object can be passed to specify the GROUP BY part explicitly in plain SQL. |
||
| 979 | * Since version 2.0.14, an [[ExpressionInterface]] object can be passed as well. |
||
| 980 | * @return $this the query object itself |
||
| 981 | * @see addGroupBy() |
||
| 982 | */ |
||
| 983 | 24 | public function groupBy($columns) |
|
| 993 | |||
| 994 | /** |
||
| 995 | * Adds additional group-by columns to the existing ones. |
||
| 996 | * @param string|array $columns additional columns to be grouped by. |
||
| 997 | * Columns can be specified in either a string (e.g. "id, name") or an array (e.g. ['id', 'name']). |
||
| 998 | * The method will automatically quote the column names unless a column contains some parenthesis |
||
| 999 | * (which means the column contains a DB expression). |
||
| 1000 | * |
||
| 1001 | * Note that if your group-by is an expression containing commas, you should always use an array |
||
| 1002 | * to represent the group-by information. Otherwise, the method will not be able to correctly determine |
||
| 1003 | * the group-by columns. |
||
| 1004 | * |
||
| 1005 | * Since version 2.0.7, an [[Expression]] object can be passed to specify the GROUP BY part explicitly in plain SQL. |
||
| 1006 | * Since version 2.0.14, an [[ExpressionInterface]] object can be passed as well. |
||
| 1007 | * @return $this the query object itself |
||
| 1008 | * @see groupBy() |
||
| 1009 | */ |
||
| 1010 | 3 | public function addGroupBy($columns) |
|
| 1025 | |||
| 1026 | /** |
||
| 1027 | * Sets the HAVING part of the query. |
||
| 1028 | * @param string|array|ExpressionInterface $condition the conditions to be put after HAVING. |
||
| 1029 | * Please refer to [[where()]] on how to specify this parameter. |
||
| 1030 | * @param array $params the parameters (name => value) to be bound to the query. |
||
| 1031 | * @return $this the query object itself |
||
| 1032 | * @see andHaving() |
||
| 1033 | * @see orHaving() |
||
| 1034 | */ |
||
| 1035 | 10 | public function having($condition, $params = []) |
|
| 1041 | |||
| 1042 | /** |
||
| 1043 | * Adds an additional HAVING condition to the existing one. |
||
| 1044 | * The new condition and the existing one will be joined using the `AND` operator. |
||
| 1045 | * @param string|array|ExpressionInterface $condition the new HAVING condition. Please refer to [[where()]] |
||
| 1046 | * on how to specify this parameter. |
||
| 1047 | * @param array $params the parameters (name => value) to be bound to the query. |
||
| 1048 | * @return $this the query object itself |
||
| 1049 | * @see having() |
||
| 1050 | * @see orHaving() |
||
| 1051 | */ |
||
| 1052 | 3 | public function andHaving($condition, $params = []) |
|
| 1062 | |||
| 1063 | /** |
||
| 1064 | * Adds an additional HAVING condition to the existing one. |
||
| 1065 | * The new condition and the existing one will be joined using the `OR` operator. |
||
| 1066 | * @param string|array|ExpressionInterface $condition the new HAVING condition. Please refer to [[where()]] |
||
| 1067 | * on how to specify this parameter. |
||
| 1068 | * @param array $params the parameters (name => value) to be bound to the query. |
||
| 1069 | * @return $this the query object itself |
||
| 1070 | * @see having() |
||
| 1071 | * @see andHaving() |
||
| 1072 | */ |
||
| 1073 | 3 | public function orHaving($condition, $params = []) |
|
| 1083 | |||
| 1084 | /** |
||
| 1085 | * Sets the HAVING part of the query but ignores [[isEmpty()|empty operands]]. |
||
| 1086 | * |
||
| 1087 | * This method is similar to [[having()]]. The main difference is that this method will |
||
| 1088 | * remove [[isEmpty()|empty query operands]]. As a result, this method is best suited |
||
| 1089 | * for building query conditions based on filter values entered by users. |
||
| 1090 | * |
||
| 1091 | * The following code shows the difference between this method and [[having()]]: |
||
| 1092 | * |
||
| 1093 | * ```php |
||
| 1094 | * // HAVING `age`=:age |
||
| 1095 | * $query->filterHaving(['name' => null, 'age' => 20]); |
||
| 1096 | * // HAVING `age`=:age |
||
| 1097 | * $query->having(['age' => 20]); |
||
| 1098 | * // HAVING `name` IS NULL AND `age`=:age |
||
| 1099 | * $query->having(['name' => null, 'age' => 20]); |
||
| 1100 | * ``` |
||
| 1101 | * |
||
| 1102 | * Note that unlike [[having()]], you cannot pass binding parameters to this method. |
||
| 1103 | * |
||
| 1104 | * @param array $condition the conditions that should be put in the HAVING part. |
||
| 1105 | * See [[having()]] on how to specify this parameter. |
||
| 1106 | * @return $this the query object itself |
||
| 1107 | * @see having() |
||
| 1108 | * @see andFilterHaving() |
||
| 1109 | * @see orFilterHaving() |
||
| 1110 | * @since 2.0.11 |
||
| 1111 | */ |
||
| 1112 | 6 | public function filterHaving(array $condition) |
|
| 1121 | |||
| 1122 | /** |
||
| 1123 | * Adds an additional HAVING condition to the existing one but ignores [[isEmpty()|empty operands]]. |
||
| 1124 | * The new condition and the existing one will be joined using the `AND` operator. |
||
| 1125 | * |
||
| 1126 | * This method is similar to [[andHaving()]]. The main difference is that this method will |
||
| 1127 | * remove [[isEmpty()|empty query operands]]. As a result, this method is best suited |
||
| 1128 | * for building query conditions based on filter values entered by users. |
||
| 1129 | * |
||
| 1130 | * @param array $condition the new HAVING condition. Please refer to [[having()]] |
||
| 1131 | * on how to specify this parameter. |
||
| 1132 | * @return $this the query object itself |
||
| 1133 | * @see filterHaving() |
||
| 1134 | * @see orFilterHaving() |
||
| 1135 | * @since 2.0.11 |
||
| 1136 | */ |
||
| 1137 | 6 | public function andFilterHaving(array $condition) |
|
| 1146 | |||
| 1147 | /** |
||
| 1148 | * Adds an additional HAVING condition to the existing one but ignores [[isEmpty()|empty operands]]. |
||
| 1149 | * The new condition and the existing one will be joined using the `OR` operator. |
||
| 1150 | * |
||
| 1151 | * This method is similar to [[orHaving()]]. The main difference is that this method will |
||
| 1152 | * remove [[isEmpty()|empty query operands]]. As a result, this method is best suited |
||
| 1153 | * for building query conditions based on filter values entered by users. |
||
| 1154 | * |
||
| 1155 | * @param array $condition the new HAVING condition. Please refer to [[having()]] |
||
| 1156 | * on how to specify this parameter. |
||
| 1157 | * @return $this the query object itself |
||
| 1158 | * @see filterHaving() |
||
| 1159 | * @see andFilterHaving() |
||
| 1160 | * @since 2.0.11 |
||
| 1161 | */ |
||
| 1162 | 6 | public function orFilterHaving(array $condition) |
|
| 1171 | |||
| 1172 | /** |
||
| 1173 | * Appends a SQL statement using UNION operator. |
||
| 1174 | * @param string|Query $sql the SQL statement to be appended using UNION |
||
| 1175 | * @param bool $all TRUE if using UNION ALL and FALSE if using UNION |
||
| 1176 | * @return $this the query object itself |
||
| 1177 | */ |
||
| 1178 | 10 | public function union($sql, $all = false) |
|
| 1183 | |||
| 1184 | /** |
||
| 1185 | * Sets the parameters to be bound to the query. |
||
| 1186 | * @param array $params list of query parameter values indexed by parameter placeholders. |
||
| 1187 | * For example, `[':name' => 'Dan', ':age' => 31]`. |
||
| 1188 | * @return $this the query object itself |
||
| 1189 | * @see addParams() |
||
| 1190 | */ |
||
| 1191 | 6 | public function params($params) |
|
| 1196 | |||
| 1197 | /** |
||
| 1198 | * Adds additional parameters to be bound to the query. |
||
| 1199 | * @param array $params list of query parameter values indexed by parameter placeholders. |
||
| 1200 | * For example, `[':name' => 'Dan', ':age' => 31]`. |
||
| 1201 | * @return $this the query object itself |
||
| 1202 | * @see params() |
||
| 1203 | */ |
||
| 1204 | 1001 | public function addParams($params) |
|
| 1222 | |||
| 1223 | /** |
||
| 1224 | * Enables query cache for this Query. |
||
| 1225 | * @param int|true $duration the number of seconds that query results can remain valid in cache. |
||
| 1226 | * Use 0 to indicate that the cached data will never expire. |
||
| 1227 | * Use a negative number to indicate that query cache should not be used. |
||
| 1228 | * Use boolean `true` to indicate that [[Connection::queryCacheDuration]] should be used. |
||
| 1229 | * Defaults to `true`. |
||
| 1230 | * @param \yii\caching\Dependency $dependency the cache dependency associated with the cached result. |
||
| 1231 | * @return $this the Query object itself |
||
| 1232 | * @since 2.0.14 |
||
| 1233 | */ |
||
| 1234 | 3 | public function cache($duration = true, $dependency = null) |
|
| 1235 | { |
||
| 1236 | 3 | $this->queryCacheDuration = $duration; |
|
| 1237 | 3 | $this->queryCacheDependency = $dependency; |
|
| 1238 | 3 | return $this; |
|
| 1239 | } |
||
| 1240 | |||
| 1241 | /** |
||
| 1242 | * Disables query cache for this Query. |
||
| 1243 | * @return $this the Query object itself |
||
| 1244 | * @since 2.0.14 |
||
| 1245 | */ |
||
| 1246 | 3 | public function noCache() |
|
| 1251 | |||
| 1252 | /** |
||
| 1253 | * Sets $command cache, if this query has enabled caching. |
||
| 1254 | * |
||
| 1255 | * @param Command $command |
||
| 1256 | * @return Command |
||
| 1257 | * @since 2.0.14 |
||
| 1258 | */ |
||
| 1259 | 744 | protected function setCommandCache($command) |
|
| 1268 | |||
| 1269 | /** |
||
| 1270 | * Creates a new Query object and copies its property values from an existing one. |
||
| 1271 | * The properties being copies are the ones to be used by query builders. |
||
| 1272 | * @param Query $from the source query object |
||
| 1273 | * @return Query the new Query object |
||
| 1274 | */ |
||
| 1275 | 384 | public static function create($from) |
|
| 1294 | |||
| 1295 | /** |
||
| 1296 | * Returns the SQL representation of Query |
||
| 1297 | * @return string |
||
| 1298 | */ |
||
| 1299 | public function __toString() |
||
| 1303 | } |
||
| 1304 |
Loading history...
This check marks access to variables or properties that have not been declared yet. While PHP has no explicit notion of declaring a variable, accessing it before a value is assigned to it is most likely a bug.