www.aleph1.co.uk Git - yaffs-website/blob - web/core/tests/Drupal/KernelTests/Core/Database/InsertTest.php

   1 <?php
   2
   3 namespace Drupal\KernelTests\Core\Database;
   4
   5 /**
   6  * Tests the insert builder.
   7  *
   8  * @group Database
   9  */
  10 class InsertTest extends DatabaseTestBase {
  11
  12   /**
  13    * Tests very basic insert functionality.
  14    */
  15   public function testSimpleInsert() {
  16     $num_records_before = db_query('SELECT COUNT(*) FROM {test}')->fetchField();
  17
  18     $query = db_insert('test');
  19     $query->fields([
  20       'name' => 'Yoko',
  21       'age' => '29',
  22     ]);
  23
  24     // Check how many records are queued for insertion.
  25     $this->assertIdentical($query->count(), 1, 'One record is queued for insertion.');
  26     $query->execute();
  27
  28     $num_records_after = db_query('SELECT COUNT(*) FROM {test}')->fetchField();
  29     $this->assertIdentical($num_records_before + 1, (int) $num_records_after, 'Record inserts correctly.');
  30     $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', [':name' => 'Yoko'])->fetchField();
  31     $this->assertIdentical($saved_age, '29', 'Can retrieve after inserting.');
  32   }
  33
  34   /**
  35    * Tests that we can insert multiple records in one query object.
  36    */
  37   public function testMultiInsert() {
  38     $num_records_before = (int) db_query('SELECT COUNT(*) FROM {test}')->fetchField();
  39
  40     $query = db_insert('test');
  41     $query->fields([
  42       'name' => 'Larry',
  43       'age' => '30',
  44     ]);
  45
  46     // We should be able to specify values in any order if named.
  47     $query->values([
  48       'age' => '31',
  49       'name' => 'Curly',
  50     ]);
  51
  52     // Check how many records are queued for insertion.
  53     $this->assertIdentical($query->count(), 2, 'Two records are queued for insertion.');
  54
  55     // We should be able to say "use the field order".
  56     // This is not the recommended mechanism for most cases, but it should work.
  57     $query->values(['Moe', '32']);
  58
  59     // Check how many records are queued for insertion.
  60     $this->assertIdentical($query->count(), 3, 'Three records are queued for insertion.');
  61     $query->execute();
  62
  63     $num_records_after = (int) db_query('SELECT COUNT(*) FROM {test}')->fetchField();
  64     $this->assertIdentical($num_records_before + 3, $num_records_after, 'Record inserts correctly.');
  65     $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', [':name' => 'Larry'])->fetchField();
  66     $this->assertIdentical($saved_age, '30', 'Can retrieve after inserting.');
  67     $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', [':name' => 'Curly'])->fetchField();
  68     $this->assertIdentical($saved_age, '31', 'Can retrieve after inserting.');
  69     $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', [':name' => 'Moe'])->fetchField();
  70     $this->assertIdentical($saved_age, '32', 'Can retrieve after inserting.');
  71   }
  72
  73   /**
  74    * Tests that an insert object can be reused with new data after it executes.
  75    */
  76   public function testRepeatedInsert() {
  77     $num_records_before = db_query('SELECT COUNT(*) FROM {test}')->fetchField();
  78
  79     $query = db_insert('test');
  80
  81     $query->fields([
  82       'name' => 'Larry',
  83       'age' => '30',
  84     ]);
  85     // Check how many records are queued for insertion.
  86     $this->assertIdentical($query->count(), 1, 'One record is queued for insertion.');
  87     $query->execute();  // This should run the insert, but leave the fields intact.
  88
  89     // We should be able to specify values in any order if named.
  90     $query->values([
  91       'age' => '31',
  92       'name' => 'Curly',
  93     ]);
  94     // Check how many records are queued for insertion.
  95     $this->assertIdentical($query->count(), 1, 'One record is queued for insertion.');
  96     $query->execute();
  97
  98     // We should be able to say "use the field order".
  99     $query->values(['Moe', '32']);
 100
 101     // Check how many records are queued for insertion.
 102     $this->assertIdentical($query->count(), 1, 'One record is queued for insertion.');
 103     $query->execute();
 104
 105     $num_records_after = db_query('SELECT COUNT(*) FROM {test}')->fetchField();
 106     $this->assertIdentical((int) $num_records_before + 3, (int) $num_records_after, 'Record inserts correctly.');
 107     $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', [':name' => 'Larry'])->fetchField();
 108     $this->assertIdentical($saved_age, '30', 'Can retrieve after inserting.');
 109     $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', [':name' => 'Curly'])->fetchField();
 110     $this->assertIdentical($saved_age, '31', 'Can retrieve after inserting.');
 111     $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', [':name' => 'Moe'])->fetchField();
 112     $this->assertIdentical($saved_age, '32', 'Can retrieve after inserting.');
 113   }
 114
 115   /**
 116    * Tests that we can specify fields without values and specify values later.
 117    */
 118   public function testInsertFieldOnlyDefinition() {
 119     // This is useful for importers, when we want to create a query and define
 120     // its fields once, then loop over a multi-insert execution.
 121     db_insert('test')
 122       ->fields(['name', 'age'])
 123       ->values(['Larry', '30'])
 124       ->values(['Curly', '31'])
 125       ->values(['Moe', '32'])
 126       ->execute();
 127     $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', [':name' => 'Larry'])->fetchField();
 128     $this->assertIdentical($saved_age, '30', 'Can retrieve after inserting.');
 129     $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', [':name' => 'Curly'])->fetchField();
 130     $this->assertIdentical($saved_age, '31', 'Can retrieve after inserting.');
 131     $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', [':name' => 'Moe'])->fetchField();
 132     $this->assertIdentical($saved_age, '32', 'Can retrieve after inserting.');
 133   }
 134
 135   /**
 136    * Tests that inserts return the proper auto-increment ID.
 137    */
 138   public function testInsertLastInsertID() {
 139     $id = db_insert('test')
 140       ->fields([
 141         'name' => 'Larry',
 142         'age' => '30',
 143       ])
 144       ->execute();
 145
 146     $this->assertIdentical($id, '5', 'Auto-increment ID returned successfully.');
 147   }
 148
 149   /**
 150    * Tests that the INSERT INTO ... SELECT (fields) ... syntax works.
 151    */
 152   public function testInsertSelectFields() {
 153     $query = db_select('test_people', 'tp');
 154     // The query builder will always append expressions after fields.
 155     // Add the expression first to test that the insert fields are correctly
 156     // re-ordered.
 157     $query->addExpression('tp.age', 'age');
 158     $query
 159       ->fields('tp', ['name', 'job'])
 160       ->condition('tp.name', 'Meredith');
 161
 162     // The resulting query should be equivalent to:
 163     // INSERT INTO test (age, name, job)
 164     // SELECT tp.age AS age, tp.name AS name, tp.job AS job
 165     // FROM test_people tp
 166     // WHERE tp.name = 'Meredith'
 167     db_insert('test')
 168       ->from($query)
 169       ->execute();
 170
 171     $saved_age = db_query('SELECT age FROM {test} WHERE name = :name', [':name' => 'Meredith'])->fetchField();
 172     $this->assertIdentical($saved_age, '30', 'Can retrieve after inserting.');
 173   }
 174
 175   /**
 176    * Tests that the INSERT INTO ... SELECT * ... syntax works.
 177    */
 178   public function testInsertSelectAll() {
 179     $query = db_select('test_people', 'tp')
 180       ->fields('tp')
 181       ->condition('tp.name', 'Meredith');
 182
 183     // The resulting query should be equivalent to:
 184     // INSERT INTO test_people_copy
 185     // SELECT *
 186     // FROM test_people tp
 187     // WHERE tp.name = 'Meredith'
 188     db_insert('test_people_copy')
 189       ->from($query)
 190       ->execute();
 191
 192     $saved_age = db_query('SELECT age FROM {test_people_copy} WHERE name = :name', [':name' => 'Meredith'])->fetchField();
 193     $this->assertIdentical($saved_age, '30', 'Can retrieve after inserting.');
 194   }
 195
 196   /**
 197    * Tests that we can INSERT INTO a special named column.
 198    */
 199   public function testSpecialColumnInsert() {
 200     $id = db_insert('test_special_columns')
 201       ->fields([
 202         'id' => 2,
 203         'offset' => 'Offset value 2',
 204       ])
 205       ->execute();
 206     $saved_value = db_query('SELECT "offset" FROM {test_special_columns} WHERE id = :id', [':id' => 2])->fetchField();
 207     $this->assertIdentical($saved_value, 'Offset value 2', 'Can retrieve special column name value after inserting.');
 208   }
 209
 210 }