SelectComplexTest.php 14.9 KB
Newer Older
1 2
<?php

3
namespace Drupal\KernelTests\Core\Database;
4

5
use Drupal\Core\Database\Database;
6
use Drupal\Core\Database\Query\Condition;
7
use Drupal\Core\Database\RowCountException;
8
use Drupal\user\Entity\User;
9

10
/**
11 12 13
 * Tests the Select query builder with more complex queries.
 *
 * @group Database
14 15 16
 */
class SelectComplexTest extends DatabaseTestBase {

17 18 19 20 21
  /**
   * Modules to enable.
   *
   * @var array
   */
22
  public static $modules = array('system', 'user', 'node_access_test', 'field');
23

24
  /**
25
   * Tests simple JOIN statements.
26 27 28 29 30
   */
  function testDefaultJoin() {
    $query = db_select('test_task', 't');
    $people_alias = $query->join('test', 'p', 't.pid = p.id');
    $name_field = $query->addField($people_alias, 'name', 'name');
31
    $query->addField('t', 'task', 'task');
32 33 34 35 36 37 38 39 40
    $priority_field = $query->addField('t', 'priority', 'priority');

    $query->orderBy($priority_field);
    $result = $query->execute();

    $num_records = 0;
    $last_priority = 0;
    foreach ($result as $record) {
      $num_records++;
41 42
      $this->assertTrue($record->$priority_field >= $last_priority, 'Results returned in correct order.');
      $this->assertNotEqual($record->$name_field, 'Ringo', 'Taskless person not selected.');
43 44 45
      $last_priority = $record->$priority_field;
    }

46
    $this->assertEqual($num_records, 7, 'Returned the correct number of rows.');
47 48 49
  }

  /**
50
   * Tests LEFT OUTER joins.
51 52 53 54 55
   */
  function testLeftOuterJoin() {
    $query = db_select('test', 'p');
    $people_alias = $query->leftJoin('test_task', 't', 't.pid = p.id');
    $name_field = $query->addField('p', 'name', 'name');
56 57
    $query->addField($people_alias, 'task', 'task');
    $query->addField($people_alias, 'priority', 'priority');
58 59 60 61 62 63 64 65 66

    $query->orderBy($name_field);
    $result = $query->execute();

    $num_records = 0;
    $last_name = 0;

    foreach ($result as $record) {
      $num_records++;
67
      $this->assertTrue(strcmp($record->$name_field, $last_name) >= 0, 'Results returned in correct order.');
68 69
    }

70
    $this->assertEqual($num_records, 8, 'Returned the correct number of rows.');
71 72 73
  }

  /**
74
   * Tests GROUP BY clauses.
75 76 77 78 79 80 81 82 83 84 85 86 87 88
   */
  function testGroupBy() {
    $query = db_select('test_task', 't');
    $count_field = $query->addExpression('COUNT(task)', 'num');
    $task_field = $query->addField('t', 'task');
    $query->orderBy($count_field);
    $query->groupBy($task_field);
    $result = $query->execute();

    $num_records = 0;
    $last_count = 0;
    $records = array();
    foreach ($result as $record) {
      $num_records++;
89
      $this->assertTrue($record->$count_field >= $last_count, 'Results returned in correct order.');
90 91 92 93 94 95 96 97 98 99 100 101 102
      $last_count = $record->$count_field;
      $records[$record->$task_field] = $record->$count_field;
    }

    $correct_results = array(
      'eat' => 1,
      'sleep' => 2,
      'code' => 1,
      'found new band' => 1,
      'perform at superbowl' => 1,
    );

    foreach ($correct_results as $task => $count) {
103
      $this->assertEqual($records[$task], $count, format_string("Correct number of '@task' records found.", array('@task' => $task)));
104 105
    }

106
    $this->assertEqual($num_records, 6, 'Returned the correct number of total rows.');
107 108 109
  }

  /**
110
   * Tests GROUP BY and HAVING clauses together.
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
   */
  function testGroupByAndHaving() {
    $query = db_select('test_task', 't');
    $count_field = $query->addExpression('COUNT(task)', 'num');
    $task_field = $query->addField('t', 'task');
    $query->orderBy($count_field);
    $query->groupBy($task_field);
    $query->having('COUNT(task) >= 2');
    $result = $query->execute();

    $num_records = 0;
    $last_count = 0;
    $records = array();
    foreach ($result as $record) {
      $num_records++;
126 127
      $this->assertTrue($record->$count_field >= 2, 'Record has the minimum count.');
      $this->assertTrue($record->$count_field >= $last_count, 'Results returned in correct order.');
128 129 130 131 132 133 134 135 136
      $last_count = $record->$count_field;
      $records[$record->$task_field] = $record->$count_field;
    }

    $correct_results = array(
      'sleep' => 2,
    );

    foreach ($correct_results as $task => $count) {
137
      $this->assertEqual($records[$task], $count, format_string("Correct number of '@task' records found.", array('@task' => $task)));
138 139
    }

140
    $this->assertEqual($num_records, 1, 'Returned the correct number of total rows.');
141 142 143
  }

  /**
144 145 146
   * Tests range queries.
   *
   * The SQL clause varies with the database.
147 148 149
   */
  function testRange() {
    $query = db_select('test');
150 151
    $query->addField('test', 'name');
    $query->addField('test', 'age', 'age');
152
    $query->range(0, 2);
153
    $query_result = $query->countQuery()->execute()->fetchField();
154

155
    $this->assertEqual($query_result, 2, 'Returned the correct number of rows.');
156 157
  }

158 159 160 161 162 163 164 165 166 167 168 169 170 171
  /**
   * Test whether the range property of a select clause can be undone.
   */
  function testRangeUndo() {
    $query = db_select('test');
    $name_field = $query->addField('test', 'name');
    $age_field = $query->addField('test', 'age', 'age');
    $query->range(0, 2);
    $query->range(NULL, NULL);
    $query_result = $query->countQuery()->execute()->fetchField();

    $this->assertEqual($query_result, 4, 'Returned the correct number of rows.');
  }

172
  /**
173
   * Tests distinct queries.
174 175 176
   */
  function testDistinct() {
    $query = db_select('test_task');
177
    $query->addField('test_task', 'task');
178
    $query->distinct();
179
    $query_result = $query->countQuery()->execute()->fetchField();
180

181
    $this->assertEqual($query_result, 6, 'Returned the correct number of rows.');
182 183 184
  }

  /**
185
   * Tests that we can generate a count query from a built query.
186 187 188 189 190 191 192 193 194
   */
  function testCountQuery() {
    $query = db_select('test');
    $name_field = $query->addField('test', 'name');
    $age_field = $query->addField('test', 'age', 'age');
    $query->orderBy('name');

    $count = $query->countQuery()->execute()->fetchField();

195
    $this->assertEqual($count, 4, 'Counted the correct number of records.');
196 197 198 199

    // Now make sure we didn't break the original query!  We should still have
    // all of the fields we asked for.
    $record = $query->execute()->fetch();
200 201
    $this->assertEqual($record->$name_field, 'George', 'Correct data retrieved.');
    $this->assertEqual($record->$age_field, 27, 'Correct data retrieved.');
202 203
  }

204 205 206
  /**
   * Tests having queries.
   */
207 208 209 210 211 212 213 214
  function testHavingCountQuery() {
    $query = db_select('test')
      ->extend('Drupal\Core\Database\Query\PagerSelectExtender')
      ->groupBy('age')
      ->having('age + 1 > 0');
    $query->addField('test', 'age');
    $query->addExpression('age + 1');
    $count = count($query->execute()->fetchCol());
215
    $this->assertEqual($count, 4, 'Counted the correct number of records.');
216 217 218
  }

  /**
219
   * Tests that countQuery removes 'all_fields' statements and ordering clauses.
220 221 222 223 224 225 226 227 228
   */
  function testCountQueryRemovals() {
    $query = db_select('test');
    $query->fields('test');
    $query->orderBy('name');
    $count = $query->countQuery();

    // Check that the 'all_fields' statement is handled properly.
    $tables = $query->getTables();
229
    $this->assertEqual($tables['test']['all_fields'], 1, 'Query correctly sets \'all_fields\' statement.');
230
    $tables = $count->getTables();
231
    $this->assertFalse(isset($tables['test']['all_fields']), 'Count query correctly unsets \'all_fields\' statement.');
232 233 234

    // Check that the ordering clause is handled properly.
    $orderby = $query->getOrderBy();
235 236 237 238
    // The orderby string is different for PostgreSQL.
    // @see Drupal\Core\Database\Driver\pgsql\Select::orderBy()
    $db_type = Database::getConnection()->databaseType();
    $this->assertEqual($orderby['name'], ($db_type == 'pgsql' ? 'ASC NULLS FIRST' : 'ASC'), 'Query correctly sets ordering clause.');
239
    $orderby = $count->getOrderBy();
240
    $this->assertFalse(isset($orderby['name']), 'Count query correctly unsets ordering clause.');
241 242 243 244

    // Make sure that the count query works.
    $count = $count->execute()->fetchField();

245
    $this->assertEqual($count, 4, 'Counted the correct number of records.');
246 247 248 249
  }


  /**
250
   * Tests that countQuery properly removes fields and expressions.
251 252 253 254 255 256 257 258 259
   */
  function testCountQueryFieldRemovals() {
    // countQuery should remove all fields and expressions, so this can be
    // tested by adding a non-existent field and expression: if it ends
    // up in the query, an error will be thrown. If not, it will return the
    // number of records, which in this case happens to be 4 (there are four
    // records in the {test} table).
    $query = db_select('test');
    $query->fields('test', array('fail'));
260
    $this->assertEqual(4, $query->countQuery()->execute()->fetchField(), 'Count Query removed fields');
261 262 263

    $query = db_select('test');
    $query->addExpression('fail');
264
    $this->assertEqual(4, $query->countQuery()->execute()->fetchField(), 'Count Query removed expressions');
265 266 267
  }

  /**
268
   * Tests that we can generate a count query from a query with distinct.
269 270 271
   */
  function testCountQueryDistinct() {
    $query = db_select('test_task');
272
    $query->addField('test_task', 'task');
273 274 275 276
    $query->distinct();

    $count = $query->countQuery()->execute()->fetchField();

277
    $this->assertEqual($count, 6, 'Counted the correct number of records.');
278 279 280
  }

  /**
281
   * Tests that we can generate a count query from a query with GROUP BY.
282 283 284
   */
  function testCountQueryGroupBy() {
    $query = db_select('test_task');
285
    $query->addField('test_task', 'pid');
286 287 288 289
    $query->groupBy('pid');

    $count = $query->countQuery()->execute()->fetchField();

290
    $this->assertEqual($count, 3, 'Counted the correct number of records.');
291 292 293 294

    // Use a column alias as, without one, the query can succeed for the wrong
    // reason.
    $query = db_select('test_task');
295
    $query->addField('test_task', 'pid', 'pid_alias');
296 297 298 299 300 301
    $query->addExpression('COUNT(test_task.task)', 'count');
    $query->groupBy('pid_alias');
    $query->orderBy('pid_alias', 'asc');

    $count = $query->countQuery()->execute()->fetchField();

302
    $this->assertEqual($count, 3, 'Counted the correct number of records.');
303 304 305
  }

  /**
306
   * Confirms that we can properly nest conditional clauses.
307 308 309 310 311 312 313 314 315
   */
  function testNestedConditions() {
    // This query should translate to:
    // "SELECT job FROM {test} WHERE name = 'Paul' AND (age = 26 OR age = 27)"
    // That should find only one record. Yes it's a non-optimal way of writing
    // that query but that's not the point!
    $query = db_select('test');
    $query->addField('test', 'job');
    $query->condition('name', 'Paul');
316
    $query->condition((new Condition('OR'))->condition('age', 26)->condition('age', 27));
317 318

    $job = $query->execute()->fetchField();
319
    $this->assertEqual($job, 'Songwriter', 'Correct data retrieved.');
320 321 322
  }

  /**
323
   * Confirms we can join on a single table twice with a dynamic alias.
324 325 326 327 328 329 330 331
   */
  function testJoinTwice() {
    $query = db_select('test')->fields('test');
    $alias = $query->join('test', 'test', 'test.job = %alias.job');
    $query->addField($alias, 'name', 'othername');
    $query->addField($alias, 'job', 'otherjob');
    $query->where("$alias.name <> test.name");
    $crowded_job = $query->execute()->fetch();
332 333
    $this->assertEqual($crowded_job->job, $crowded_job->otherjob, 'Correctly joined same table twice.');
    $this->assertNotEqual($crowded_job->name, $crowded_job->othername, 'Correctly joined same table twice.');
334 335 336
  }

  /**
337
   * Tests that we can join on a query.
338 339
   */
  function testJoinSubquery() {
340 341
    $this->installSchema('system', 'sequences');

342
    $account = User::create([
343 344
      'name' => $this->randomMachineName(),
      'mail' => $this->randomMachineName() . '@example.com',
345
    ]);
346

347
    $query = db_select('test_task', 'tt', array('target' => 'replica'));
348 349 350 351 352 353 354 355
    $query->addExpression('tt.pid + 1', 'abc');
    $query->condition('priority', 1, '>');
    $query->condition('priority', 100, '<');

    $subquery = db_select('test', 'tp');
    $subquery->join('test_one_blob', 'tpb', 'tp.id = tpb.id');
    $subquery->join('node', 'n', 'tp.id = n.nid');
    $subquery->addTag('node_access');
356
    $subquery->addMetaData('account', $account);
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
    $subquery->addField('tp', 'id');
    $subquery->condition('age', 5, '>');
    $subquery->condition('age', 500, '<');

    $query->leftJoin($subquery, 'sq', 'tt.pid = sq.id');
    $query->join('test_one_blob', 'tb3', 'tt.pid = tb3.id');

    // Construct the query string.
    // This is the same sequence that SelectQuery::execute() goes through.
    $query->preExecute();
    $query->getArguments();
    $str = (string) $query;

    // Verify that the string only has one copy of condition placeholder 0.
    $pos = strpos($str, 'db_condition_placeholder_0', 0);
    $pos2 = strpos($str, 'db_condition_placeholder_0', $pos + 1);
373
    $this->assertFalse($pos2, 'Condition placeholder is not repeated.');
374
  }
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392

  /**
   * Tests that rowCount() throws exception on SELECT query.
   */
  function testSelectWithRowCount() {
    $query = db_select('test');
    $query->addField('test', 'name');
    $result = $query->execute();
    try {
      $result->rowCount();
      $exception = FALSE;
    }
    catch (RowCountException $e) {
      $exception = TRUE;
    }
    $this->assertTrue($exception, 'Exception was thrown');
  }

393 394 395 396 397 398
  /**
   * Test that join conditions can use Condition objects.
   */
  public function testJoinConditionObject() {
    // Same test as testDefaultJoin, but with a Condition object.
    $query = db_select('test_task', 't');
399
    $join_cond = (new Condition('AND'))->where('t.pid = p.id');
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
    $people_alias = $query->join('test', 'p', $join_cond);
    $name_field = $query->addField($people_alias, 'name', 'name');
    $query->addField('t', 'task', 'task');
    $priority_field = $query->addField('t', 'priority', 'priority');

    $query->orderBy($priority_field);
    $result = $query->execute();

    $num_records = 0;
    $last_priority = 0;
    foreach ($result as $record) {
      $num_records++;
      $this->assertTrue($record->$priority_field >= $last_priority, 'Results returned in correct order.');
      $this->assertNotEqual($record->$name_field, 'Ringo', 'Taskless person not selected.');
      $last_priority = $record->$priority_field;
    }

    $this->assertEqual($num_records, 7, 'Returned the correct number of rows.');

    // Test a condition object that creates placeholders.
    $t1_name = 'John';
    $t2_name = 'George';
422
    $join_cond = (new Condition('AND'))
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
      ->condition('t1.name', $t1_name)
      ->condition('t2.name', $t2_name);
    $query = db_select('test', 't1');
    $query->innerJoin('test', 't2', $join_cond);
    $query->addField('t1', 'name', 't1_name');
    $query->addField('t2', 'name', 't2_name');

    $num_records = $query->countQuery()->execute()->fetchField();
    $this->assertEqual($num_records, 1, 'Query expected to return 1 row. Actual: ' . $num_records);
    if ($num_records == 1) {
      $record = $query->execute()->fetchObject();
      $this->assertEqual($record->t1_name, $t1_name, 'Query expected to retrieve name ' . $t1_name . ' from table t1. Actual: ' . $record->t1_name);
      $this->assertEqual($record->t2_name, $t2_name, 'Query expected to retrieve name ' . $t2_name . ' from table t2. Actual: ' . $record->t2_name);
    }
  }

439
}