View source
<?php
namespace Drupal\KernelTests\Core\Database;
use Drupal\Component\Render\FormattableMarkup;
use Drupal\Core\Database\Database;
use Drupal\Core\Database\SchemaException;
use Drupal\Core\Database\SchemaObjectDoesNotExistException;
use Drupal\Core\Database\SchemaObjectExistsException;
use Drupal\KernelTests\KernelTestBase;
use Drupal\Component\Utility\Unicode;
use Drupal\Tests\Core\Database\SchemaIntrospectionTestTrait;
class SchemaTest extends KernelTestBase {
use SchemaIntrospectionTestTrait;
protected $counter;
protected $connection;
protected $schema;
protected function setUp() {
parent::setUp();
$this->connection = Database::getConnection();
$this->schema = $this->connection
->schema();
}
public function testSchema() {
$table_specification = [
'description' => 'Schema table description may contain "quotes" and could be long—very long indeed.',
'fields' => [
'id' => [
'type' => 'int',
'default' => NULL,
],
'test_field' => [
'type' => 'int',
'not null' => TRUE,
'description' => 'Schema table description may contain "quotes" and could be long—very long indeed. There could be "multiple quoted regions".',
],
'test_field_string' => [
'type' => 'varchar',
'length' => 20,
'not null' => TRUE,
'default' => "'\"funky default'\"",
'description' => 'Schema column description for string.',
],
'test_field_string_ascii' => [
'type' => 'varchar_ascii',
'length' => 255,
'description' => 'Schema column description for ASCII string.',
],
],
];
$this->schema
->createTable('test_table', $table_specification);
$this
->assertTrue($this->schema
->tableExists('test_table'), 'The table exists.');
$this
->checkSchemaComment($table_specification['description'], 'test_table');
$this
->checkSchemaComment($table_specification['fields']['test_field']['description'], 'test_table', 'test_field');
if ($this->connection
->databaseType() === 'mysql') {
$columns = $this->connection
->query('SHOW FULL COLUMNS FROM {test_table}');
foreach ($columns as $column) {
if ($column->Field == 'test_field_string') {
$string_check = $column->Collation == 'utf8mb4_general_ci' || $column->Collation == 'utf8mb4_0900_ai_ci';
}
if ($column->Field == 'test_field_string_ascii') {
$string_ascii_check = $column->Collation == 'ascii_general_ci';
}
}
$this
->assertTrue(!empty($string_check), 'string field has the right collation.');
$this
->assertTrue(!empty($string_ascii_check), 'ASCII string field has the right collation.');
}
$this
->assertFalse($this
->tryInsert(), 'Insert without a default failed.');
$this->schema
->changeField('test_table', 'test_field', 'test_field', [
'type' => 'int',
'not null' => TRUE,
'default' => 0,
]);
$this
->assertTrue($this
->tryInsert(), 'Insert with a default succeeded.');
$this->schema
->changeField('test_table', 'test_field', 'test_field', [
'type' => 'int',
'not null' => TRUE,
]);
$this
->assertFalse($this
->tryInsert(), 'Insert without a default failed.');
$index_exists = $this->schema
->indexExists('test_table', 'test_field');
$this
->assertIdentical($index_exists, FALSE, 'Fake index does not exist');
$this->schema
->addIndex('test_table', 'test_field', [
'test_field',
], $table_specification);
$index_exists = $this->schema
->indexExists('test_table', 'test_field');
$this
->assertIdentical($index_exists, TRUE, 'Index created.');
$this
->assertNull($this->schema
->renameTable('test_table', 'test_table2'));
$index_exists = $this->schema
->indexExists('test_table2', 'test_field');
$this
->assertTrue($index_exists, 'Index was renamed.');
$this->schema
->changeField('test_table2', 'test_field', 'test_field', [
'type' => 'int',
'not null' => TRUE,
'default' => 0,
]);
$this
->assertFalse($this
->tryInsert(), 'Insert into the old table failed.');
$this
->assertTrue($this
->tryInsert('test_table2'), 'Insert into the new table succeeded.');
$count = $this->connection
->query('SELECT COUNT(*) FROM {test_table2}')
->fetchField();
$this
->assertEqual($count, 2, 'Two fields were successfully inserted.');
$this->schema
->dropTable('test_table2');
$this
->assertFalse($this->schema
->tableExists('test_table2'), 'The dropped table does not exist.');
$this->schema
->createTable('test_table', $table_specification);
$this->schema
->changeField('test_table', 'test_field', 'test_field', [
'type' => 'int',
'not null' => TRUE,
'default' => 0,
]);
$this->schema
->addField('test_table', 'test_serial', [
'type' => 'int',
'not null' => TRUE,
'default' => 0,
'description' => 'Added column description.',
]);
$this
->checkSchemaComment('Added column description.', 'test_table', 'test_serial');
$this->schema
->changeField('test_table', 'test_serial', 'test_serial', [
'type' => 'serial',
'not null' => TRUE,
'description' => 'Changed column description.',
], [
'primary key' => [
'test_serial',
],
]);
$this
->checkSchemaComment('Changed column description.', 'test_table', 'test_serial');
$this
->assertTrue($this
->tryInsert(), 'Insert with a serial succeeded.');
$max1 = $this->connection
->query('SELECT MAX(test_serial) FROM {test_table}')
->fetchField();
$this
->assertTrue($this
->tryInsert(), 'Insert with a serial succeeded.');
$max2 = $this->connection
->query('SELECT MAX(test_serial) FROM {test_table}')
->fetchField();
$this
->assertTrue($max2 > $max1, 'The serial is monotone.');
$count = $this->connection
->query('SELECT COUNT(*) FROM {test_table}')
->fetchField();
$this
->assertEqual($count, 2, 'There were two rows.');
$this->schema
->dropTable('test_table');
$this->schema
->createTable('test_table', $table_specification);
$this->schema
->changeField('test_table', 'test_field', 'test_field', [
'type' => 'int',
'not null' => TRUE,
'default' => 0,
]);
$this->schema
->addField('test_table', 'test_serial', [
'type' => 'serial',
'not null' => TRUE,
], [
'primary key' => [
'test_serial',
],
]);
$method = new \ReflectionMethod(get_class($this->schema), 'findPrimaryKeyColumns');
$method
->setAccessible(TRUE);
$this
->assertSame([
'test_serial',
], $method
->invoke($this->schema, 'test_table'));
$this
->assertTrue($this
->tryInsert(), 'Insert with a serial succeeded.');
$max1 = $this->connection
->query('SELECT MAX(test_serial) FROM {test_table}')
->fetchField();
$this
->assertTrue($this
->tryInsert(), 'Insert with a serial succeeded.');
$max2 = $this->connection
->query('SELECT MAX(test_serial) FROM {test_table}')
->fetchField();
$this
->assertTrue($max2 > $max1, 'The serial is monotone.');
$count = $this->connection
->query('SELECT COUNT(*) FROM {test_table}')
->fetchField();
$this
->assertEqual($count, 2, 'There were two rows.');
$this->schema
->addField('test_table', 'test_composite_primary_key', [
'type' => 'int',
'not null' => TRUE,
'default' => 0,
], [
'primary key' => [
'test_serial',
'test_composite_primary_key',
],
]);
$this
->assertSame([
'test_serial',
'test_composite_primary_key',
], $method
->invoke($this->schema, 'test_table'));
$this->schema
->dropTable('test_table');
$table_specification = [
'fields' => [
'id' => [
'type' => 'serial',
'not null' => TRUE,
],
'test_field' => [
'type' => 'int',
'default' => 0,
],
],
'primary key' => [
'id',
],
'unique keys' => [
'test_field' => [
'test_field',
],
],
];
$table_name = strtolower($this
->getRandomGenerator()
->name(63 - strlen($this
->getDatabasePrefix())));
$this->schema
->createTable($table_name, $table_specification);
$this
->assertIndexOnColumns($table_name, [
'id',
], 'primary');
$this
->assertIndexOnColumns($table_name, [
'test_field',
], 'unique');
$new_table_name = strtolower($this
->getRandomGenerator()
->name(63 - strlen($this
->getDatabasePrefix())));
$this
->assertNull($this->schema
->renameTable($table_name, $new_table_name));
$this
->assertIndexOnColumns($new_table_name, [
'id',
], 'primary');
$this
->assertIndexOnColumns($new_table_name, [
'test_field',
], 'unique');
if ($this->connection
->databaseType() == 'pgsql') {
$sequence_exists = (bool) $this->connection
->query("SELECT pg_get_serial_sequence('{" . $new_table_name . "}', 'id')")
->fetchField();
$this
->assertTrue($sequence_exists, 'Sequence was renamed.');
$another_table_name = strtolower($this
->getRandomGenerator()
->name(63 - strlen($this
->getDatabasePrefix())));
$this->schema
->renameTable($new_table_name, $another_table_name);
$sequence_exists = (bool) $this->connection
->query("SELECT pg_get_serial_sequence('{" . $another_table_name . "}', 'id')")
->fetchField();
$this
->assertTrue($sequence_exists, 'Sequence was renamed.');
}
$table_specification = [
'description' => 'Schema table description.',
'fields' => [
'timestamp' => [
'mysql_type' => 'timestamp',
'pgsql_type' => 'timestamp',
'sqlite_type' => 'datetime',
'not null' => FALSE,
'default' => NULL,
],
],
];
try {
$this->schema
->createTable('test_timestamp', $table_specification);
} catch (\Exception $e) {
}
$this
->assertTrue($this->schema
->tableExists('test_timestamp'), 'Table with database specific datatype was created.');
}
public function testIntrospectIndexSchema() {
$table_specification = [
'fields' => [
'id' => [
'type' => 'int',
'not null' => TRUE,
'default' => 0,
],
'test_field_1' => [
'type' => 'int',
'not null' => TRUE,
'default' => 0,
],
'test_field_2' => [
'type' => 'int',
'default' => 0,
],
'test_field_3' => [
'type' => 'int',
'default' => 0,
],
'test_field_4' => [
'type' => 'int',
'default' => 0,
],
'test_field_5' => [
'type' => 'int',
'default' => 0,
],
],
'primary key' => [
'id',
'test_field_1',
],
'unique keys' => [
'test_field_2' => [
'test_field_2',
],
'test_field_3_test_field_4' => [
'test_field_3',
'test_field_4',
],
],
'indexes' => [
'test_field_4' => [
'test_field_4',
],
'test_field_4_test_field_5' => [
'test_field_4',
'test_field_5',
],
],
];
$table_name = strtolower($this
->getRandomGenerator()
->name());
$this->schema
->createTable($table_name, $table_specification);
unset($table_specification['fields']);
$introspect_index_schema = new \ReflectionMethod(get_class($this->schema), 'introspectIndexSchema');
$introspect_index_schema
->setAccessible(TRUE);
$index_schema = $introspect_index_schema
->invoke($this->schema, $table_name);
if ($this->connection
->databaseType() === 'pgsql') {
$ensure_identifier_length = new \ReflectionMethod(get_class($this->schema), 'ensureIdentifiersLength');
$ensure_identifier_length
->setAccessible(TRUE);
foreach ($table_specification['unique keys'] as $original_index_name => $columns) {
unset($table_specification['unique keys'][$original_index_name]);
$new_index_name = $ensure_identifier_length
->invoke($this->schema, $table_name, $original_index_name, 'key');
$table_specification['unique keys'][$new_index_name] = $columns;
}
foreach ($table_specification['indexes'] as $original_index_name => $columns) {
unset($table_specification['indexes'][$original_index_name]);
$new_index_name = $ensure_identifier_length
->invoke($this->schema, $table_name, $original_index_name, 'idx');
$table_specification['indexes'][$new_index_name] = $columns;
}
}
$this
->assertEquals($table_specification, $index_schema);
}
public function testIndexLength() {
if ($this->connection
->databaseType() !== 'mysql') {
$this
->markTestSkipped("The '{$this->connection->databaseType()}' database type does not support setting column length for indexes.");
}
$table_specification = [
'fields' => [
'id' => [
'type' => 'int',
'default' => NULL,
],
'test_field_text' => [
'type' => 'text',
'not null' => TRUE,
],
'test_field_string_long' => [
'type' => 'varchar',
'length' => 255,
'not null' => TRUE,
],
'test_field_string_ascii_long' => [
'type' => 'varchar_ascii',
'length' => 255,
],
'test_field_string_short' => [
'type' => 'varchar',
'length' => 128,
'not null' => TRUE,
],
],
'indexes' => [
'test_regular' => [
'test_field_text',
'test_field_string_long',
'test_field_string_ascii_long',
'test_field_string_short',
],
'test_length' => [
[
'test_field_text',
128,
],
[
'test_field_string_long',
128,
],
[
'test_field_string_ascii_long',
128,
],
[
'test_field_string_short',
128,
],
],
'test_mixed' => [
[
'test_field_text',
200,
],
'test_field_string_long',
[
'test_field_string_ascii_long',
200,
],
'test_field_string_short',
],
],
];
$this->schema
->createTable('test_table_index_length', $table_specification);
$expected_exception_message = "MySQL needs the 'test_field_text' field specification in order to normalize the 'test_regular' index";
$missing_field_spec = $table_specification;
unset($missing_field_spec['fields']['test_field_text']);
try {
$this->schema
->addIndex('test_table_index_length', 'test_separate', [
[
'test_field_text',
200,
],
], $missing_field_spec);
$this
->fail('SchemaException not thrown when adding index with missing information.');
} catch (SchemaException $e) {
$this
->assertEqual($expected_exception_message, $e
->getMessage());
}
$this->schema
->addIndex('test_table_index_length', 'test_separate', [
[
'test_field_text',
200,
],
], $table_specification);
$table_specification_with_new_index = $table_specification;
$table_specification_with_new_index['indexes']['test_separate'] = [
[
'test_field_text',
200,
],
];
try {
$this->schema
->addIndex('test_table_index_length', 'test_separate', [
[
'test_field_text',
200,
],
], $table_specification);
$this
->fail('\\Drupal\\Core\\Database\\SchemaObjectExistsException exception missed.');
} catch (SchemaObjectExistsException $e) {
}
try {
$this->schema
->addIndex('test_table_non_existing', 'test_separate', [
[
'test_field_text',
200,
],
], $table_specification);
$this
->fail('\\Drupal\\Core\\Database\\SchemaObjectDoesNotExistException exception missed.');
} catch (SchemaObjectDoesNotExistException $e) {
}
$results = $this->connection
->query('SHOW INDEX FROM {test_table_index_length}');
$expected_lengths = [
'test_regular' => [
'test_field_text' => 191,
'test_field_string_long' => 191,
'test_field_string_ascii_long' => NULL,
'test_field_string_short' => NULL,
],
'test_length' => [
'test_field_text' => 128,
'test_field_string_long' => 128,
'test_field_string_ascii_long' => 128,
'test_field_string_short' => NULL,
],
'test_mixed' => [
'test_field_text' => 191,
'test_field_string_long' => 191,
'test_field_string_ascii_long' => 200,
'test_field_string_short' => NULL,
],
'test_separate' => [
'test_field_text' => 191,
],
];
$column_count = 0;
foreach ($table_specification_with_new_index['indexes'] as $index) {
foreach ($index as $field) {
$column_count++;
}
}
$test_count = 0;
foreach ($results as $result) {
$this
->assertEqual($result->Sub_part, $expected_lengths[$result->Key_name][$result->Column_name], 'Index length matches expected value.');
$test_count++;
}
$this
->assertEqual($test_count, $column_count, 'Number of tests matches expected value.');
}
public function tryInsert($table = 'test_table') {
try {
$this->connection
->insert($table)
->fields([
'id' => mt_rand(10, 20),
])
->execute();
return TRUE;
} catch (\Exception $e) {
return FALSE;
}
}
public function checkSchemaComment($description, $table, $column = NULL) {
if (method_exists($this->schema, 'getComment')) {
$comment = $this->schema
->getComment($table, $column);
if ($this->connection
->databaseType() === 'mysql') {
$max_length = $column ? 255 : 60;
$description = Unicode::truncate($description, $max_length, TRUE, TRUE);
}
$this
->assertEqual($comment, $description, 'The comment matches the schema description.');
}
}
public function testUnsignedColumns() {
$table_name = 'unsigned_table';
$table_spec = [
'fields' => [
'serial_column' => [
'type' => 'serial',
'unsigned' => TRUE,
'not null' => TRUE,
],
],
'primary key' => [
'serial_column',
],
];
$this->schema
->createTable($table_name, $table_spec);
$types = [
'int',
'float',
'numeric',
];
foreach ($types as $type) {
$column_spec = [
'type' => $type,
'unsigned' => TRUE,
];
if ($type == 'numeric') {
$column_spec += [
'precision' => 10,
'scale' => 0,
];
}
$column_name = $type . '_column';
$table_spec['fields'][$column_name] = $column_spec;
$this->schema
->addField($table_name, $column_name, $column_spec);
}
foreach ($table_spec['fields'] as $column_name => $column_spec) {
$this
->assertTrue($this->schema
->fieldExists($table_name, $column_name), new FormattableMarkup('Unsigned @type column was created.', [
'@type' => $column_spec['type'],
]));
$this
->assertFalse($this
->tryUnsignedInsert($table_name, $column_name), new FormattableMarkup('Unsigned @type column rejected a negative value.', [
'@type' => $column_spec['type'],
]));
}
}
public function tryUnsignedInsert($table_name, $column_name) {
try {
$this->connection
->insert($table_name)
->fields([
$column_name => -1,
])
->execute();
return TRUE;
} catch (\Exception $e) {
return FALSE;
}
}
public function testSchemaAddFieldDefaultInitial() {
foreach ([
1,
32,
128,
256,
512,
] as $length) {
$base_field_spec = [
'type' => 'varchar',
'length' => $length,
];
$variations = [
[
'not null' => FALSE,
],
[
'not null' => FALSE,
'default' => '7',
],
[
'not null' => FALSE,
'default' => substr('"thing"', 0, $length),
],
[
'not null' => FALSE,
'default' => substr("\"'hing", 0, $length),
],
[
'not null' => TRUE,
'initial' => 'd',
],
[
'not null' => FALSE,
'default' => NULL,
],
[
'not null' => TRUE,
'initial' => 'd',
'default' => '7',
],
];
foreach ($variations as $variation) {
$field_spec = $variation + $base_field_spec;
$this
->assertFieldAdditionRemoval($field_spec);
}
}
foreach ([
'int',
'float',
] as $type) {
foreach ([
'tiny',
'small',
'medium',
'normal',
'big',
] as $size) {
$base_field_spec = [
'type' => $type,
'size' => $size,
];
$variations = [
[
'not null' => FALSE,
],
[
'not null' => FALSE,
'default' => 7,
],
[
'not null' => TRUE,
'initial' => 1,
],
[
'not null' => TRUE,
'initial' => 1,
'default' => 7,
],
[
'not null' => TRUE,
'initial_from_field' => 'serial_column',
],
[
'not null' => TRUE,
'initial_from_field' => 'test_nullable_field',
'initial' => 100,
],
];
foreach ($variations as $variation) {
$field_spec = $variation + $base_field_spec;
$this
->assertFieldAdditionRemoval($field_spec);
}
}
}
foreach ([
1,
5,
10,
40,
65,
] as $precision) {
foreach ([
0,
2,
10,
30,
] as $scale) {
if ($precision <= $scale) {
continue;
}
$base_field_spec = [
'type' => 'numeric',
'scale' => $scale,
'precision' => $precision,
];
$variations = [
[
'not null' => FALSE,
],
[
'not null' => FALSE,
'default' => 7,
],
[
'not null' => TRUE,
'initial' => 1,
],
[
'not null' => TRUE,
'initial' => 1,
'default' => 7,
],
[
'not null' => TRUE,
'initial_from_field' => 'serial_column',
],
];
foreach ($variations as $variation) {
$field_spec = $variation + $base_field_spec;
$this
->assertFieldAdditionRemoval($field_spec);
}
}
}
}
protected function assertFieldAdditionRemoval($field_spec) {
$table_name = 'test_table_' . $this->counter++;
$table_spec = [
'fields' => [
'serial_column' => [
'type' => 'serial',
'unsigned' => TRUE,
'not null' => TRUE,
],
'test_nullable_field' => [
'type' => 'int',
'not null' => FALSE,
],
'test_field' => $field_spec,
],
'primary key' => [
'serial_column',
],
];
$this->schema
->createTable($table_name, $table_spec);
$this
->assertFieldCharacteristics($table_name, 'test_field', $field_spec);
$this->schema
->dropTable($table_name);
$table_name = 'test_table_' . $this->counter++;
$table_spec = [
'fields' => [
'serial_column' => [
'type' => 'serial',
'unsigned' => TRUE,
'not null' => TRUE,
],
'test_nullable_field' => [
'type' => 'int',
'not null' => FALSE,
],
],
'primary key' => [
'serial_column',
],
];
$this->schema
->createTable($table_name, $table_spec);
for ($i = 0; $i < 3; $i++) {
$this->connection
->insert($table_name)
->useDefaults([
'serial_column',
])
->fields([
'test_nullable_field' => 100,
])
->execute();
}
$this->connection
->insert($table_name)
->useDefaults([
'serial_column',
])
->execute();
$this->schema
->addField($table_name, 'test_field', $field_spec);
$this
->assertFieldCharacteristics($table_name, 'test_field', $field_spec);
$this->schema
->dropField($table_name, 'test_field');
$this->schema
->addField($table_name, 'test_field', $field_spec);
$this->schema
->dropField($table_name, 'serial_column');
$this->schema
->dropTable($table_name);
}
protected function assertFieldCharacteristics($table_name, $field_name, $field_spec) {
if (isset($field_spec['initial'])) {
$count = $this->connection
->select($table_name)
->fields($table_name, [
'serial_column',
])
->condition($field_name, $field_spec['initial'], '<>')
->countQuery()
->execute()
->fetchField();
$this
->assertEqual($count, 0, 'Initial values filled out.');
}
if (isset($field_spec['initial_from_field']) && !isset($field_spec['initial'])) {
$count = $this->connection
->select($table_name)
->fields($table_name, [
'serial_column',
])
->where($table_name . '.' . $field_spec['initial_from_field'] . ' <> ' . $table_name . '.' . $field_name)
->countQuery()
->execute()
->fetchField();
$this
->assertEqual($count, 0, 'Initial values from another field filled out.');
}
elseif (isset($field_spec['initial_from_field']) && isset($field_spec['initial'])) {
$count = $this->connection
->select($table_name)
->fields($table_name, [
'serial_column',
])
->condition($field_name, 100, '<>')
->countQuery()
->execute()
->fetchField();
$this
->assertEqual($count, 0, 'Initial values from another field or a default value filled out.');
}
if (isset($field_spec['default'])) {
$id = $this->connection
->insert($table_name)
->useDefaults([
'serial_column',
])
->execute();
$field_value = $this->connection
->select($table_name)
->fields($table_name, [
$field_name,
])
->condition('serial_column', $id)
->execute()
->fetchField();
$this
->assertEqual($field_value, $field_spec['default'], 'Default value registered.');
}
}
public function testSchemaChangePrimaryKey(array $initial_primary_key, array $renamed_primary_key) {
$find_primary_key_columns = new \ReflectionMethod(get_class($this->schema), 'findPrimaryKeyColumns');
$find_primary_key_columns
->setAccessible(TRUE);
$table_name = 'test_table';
$table_spec = [
'fields' => [
'test_field' => [
'type' => 'int',
'not null' => TRUE,
],
'other_test_field' => [
'type' => 'int',
'not null' => TRUE,
],
],
'primary key' => $initial_primary_key,
];
$this->schema
->createTable($table_name, $table_spec);
$this
->assertTrue($this->schema
->fieldExists($table_name, 'test_field'));
$this
->assertEquals($initial_primary_key, $find_primary_key_columns
->invoke($this->schema, $table_name));
$this->schema
->changeField($table_name, 'test_field', 'test_field', [
'type' => 'varchar',
'length' => 32,
'not null' => TRUE,
]);
$this
->assertTrue($this->schema
->fieldExists($table_name, 'test_field'));
$this
->assertEquals($initial_primary_key, $find_primary_key_columns
->invoke($this->schema, $table_name));
$this->connection
->insert($table_name)
->fields([
'test_field' => 1,
'other_test_field' => 2,
])
->execute();
$this->schema
->changeField($table_name, 'test_field', 'test_field', [
'type' => 'int',
'not null' => TRUE,
]);
$this
->assertTrue($this->schema
->fieldExists($table_name, 'test_field'));
$this
->assertEquals($initial_primary_key, $find_primary_key_columns
->invoke($this->schema, $table_name));
$this->schema
->dropPrimaryKey($table_name);
$this
->assertEquals([], $find_primary_key_columns
->invoke($this->schema, $table_name));
$this->schema
->changeField($table_name, 'test_field', 'test_field', [
'type' => 'int',
'not null' => TRUE,
], [
'primary key' => $initial_primary_key,
]);
$this
->assertTrue($this->schema
->fieldExists($table_name, 'test_field'));
$this
->assertEquals($initial_primary_key, $find_primary_key_columns
->invoke($this->schema, $table_name));
$this->schema
->changeField($table_name, 'test_field', 'test_field_renamed', [
'type' => 'int',
'not null' => TRUE,
]);
$this
->assertTrue($this->schema
->fieldExists($table_name, 'test_field_renamed'));
$this
->assertEquals($renamed_primary_key, $find_primary_key_columns
->invoke($this->schema, $table_name));
$this->schema
->dropField($table_name, 'test_field_renamed');
$this
->assertFalse($this->schema
->fieldExists($table_name, 'test_field_renamed'));
$this
->assertEquals([], $find_primary_key_columns
->invoke($this->schema, $table_name));
$this->schema
->addField($table_name, 'test_field', [
'type' => 'int',
'default' => 0,
'not null' => TRUE,
], [
'primary key' => $initial_primary_key,
]);
$this
->assertTrue($this->schema
->fieldExists($table_name, 'test_field'));
$this
->assertEquals($initial_primary_key, $find_primary_key_columns
->invoke($this->schema, $table_name));
$this->schema
->dropField($table_name, 'test_field');
$this->schema
->addPrimaryKey($table_name, [
'other_test_field',
]);
$this
->assertFalse($this->schema
->fieldExists($table_name, 'test_field'));
$this
->assertEquals([
'other_test_field',
], $find_primary_key_columns
->invoke($this->schema, $table_name));
$this->schema
->addField($table_name, 'test_field', [
'type' => 'int',
'default' => 0,
'not null' => TRUE,
], [
'primary key' => $initial_primary_key,
]);
$this
->assertTrue($this->schema
->fieldExists($table_name, 'test_field'));
$this
->assertEquals($initial_primary_key, $find_primary_key_columns
->invoke($this->schema, $table_name));
}
public function providerTestSchemaCreateTablePrimaryKey() {
$tests = [];
$tests['simple_primary_key'] = [
'initial_primary_key' => [
'test_field',
],
'renamed_primary_key' => [
'test_field_renamed',
],
];
$tests['composite_primary_key'] = [
'initial_primary_key' => [
'test_field',
'other_test_field',
],
'renamed_primary_key' => [
'test_field_renamed',
'other_test_field',
],
];
$tests['composite_primary_key_different_order'] = [
'initial_primary_key' => [
'other_test_field',
'test_field',
],
'renamed_primary_key' => [
'other_test_field',
'test_field_renamed',
],
];
return $tests;
}
public function testInvalidPrimaryKeyOnTableCreation() {
$table_name = 'test_table';
$table_spec = [
'fields' => [
'test_field' => [
'type' => 'int',
],
],
'primary key' => [
'test_field',
],
];
$this
->expectException(SchemaException::class);
$this
->expectExceptionMessage("The 'test_field' field specification does not define 'not null' as TRUE.");
$this->schema
->createTable($table_name, $table_spec);
}
public function testInvalidPrimaryKeyAddition() {
$table_name = 'test_table';
$table_spec = [
'fields' => [
'test_field' => [
'type' => 'int',
'not null' => TRUE,
],
],
'primary key' => [
'test_field',
],
];
$this->schema
->createTable($table_name, $table_spec);
$this
->expectException(SchemaException::class);
$this
->expectExceptionMessage("The 'new_test_field' field specification does not define 'not null' as TRUE.");
$this->schema
->addField($table_name, 'new_test_field', [
'type' => 'int',
], [
'primary key' => [
'test_field',
'new_test_field',
],
]);
}
public function testInvalidPrimaryKeyChange() {
$table_name = 'test_table';
$table_spec = [
'fields' => [
'test_field' => [
'type' => 'int',
'not null' => TRUE,
],
],
'primary key' => [
'test_field',
],
];
$this->schema
->createTable($table_name, $table_spec);
$this
->expectException(SchemaException::class);
$this
->expectExceptionMessage("The 'changed_test_field' field specification does not define 'not null' as TRUE.");
$this->schema
->dropPrimaryKey($table_name);
$this->schema
->changeField($table_name, 'test_field', 'changed_test_field', [
'type' => 'int',
], [
'primary key' => [
'changed_test_field',
],
]);
}
public function testSchemaChangeFieldDefaultInitial() {
$field_specs = [
[
'type' => 'int',
'size' => 'normal',
'not null' => FALSE,
],
[
'type' => 'int',
'size' => 'normal',
'not null' => TRUE,
'initial' => 1,
'default' => 17,
],
[
'type' => 'float',
'size' => 'normal',
'not null' => FALSE,
],
[
'type' => 'float',
'size' => 'normal',
'not null' => TRUE,
'initial' => 1,
'default' => 7.3,
],
[
'type' => 'numeric',
'scale' => 2,
'precision' => 10,
'not null' => FALSE,
],
[
'type' => 'numeric',
'scale' => 2,
'precision' => 10,
'not null' => TRUE,
'initial' => 1,
'default' => 7,
],
];
foreach ($field_specs as $i => $old_spec) {
foreach ($field_specs as $j => $new_spec) {
if ($i === $j) {
continue;
}
$this
->assertFieldChange($old_spec, $new_spec);
}
}
$field_specs = [
[
'type' => 'varchar_ascii',
'length' => '255',
],
[
'type' => 'varchar',
'length' => '255',
],
[
'type' => 'text',
],
[
'type' => 'blob',
'size' => 'big',
],
];
foreach ($field_specs as $i => $old_spec) {
foreach ($field_specs as $j => $new_spec) {
if ($i === $j) {
continue;
}
$this
->assertFieldChange($old_spec, $new_spec, serialize([
'string' => "This \n has \\\\ some backslash \"*string action.\\n",
]));
}
}
}
protected function assertFieldChange($old_spec, $new_spec, $test_data = NULL) {
$table_name = 'test_table_' . $this->counter++;
$table_spec = [
'fields' => [
'serial_column' => [
'type' => 'serial',
'unsigned' => TRUE,
'not null' => TRUE,
],
'test_field' => $old_spec,
],
'primary key' => [
'serial_column',
],
];
$this->schema
->createTable($table_name, $table_spec);
$this
->assertFieldCharacteristics($table_name, 'test_field', $old_spec);
$this->connection
->truncate($table_name)
->execute();
if ($test_data) {
$id = $this->connection
->insert($table_name)
->fields([
'test_field',
], [
$test_data,
])
->execute();
}
$this->schema
->changeField($table_name, 'test_field', 'test_field', $new_spec);
if ($test_data) {
$field_value = $this->connection
->select($table_name)
->fields($table_name, [
'test_field',
])
->condition('serial_column', $id)
->execute()
->fetchField();
$this
->assertIdentical($field_value, $test_data);
}
$this
->assertFieldCharacteristics($table_name, 'test_field', $new_spec);
$this->schema
->dropTable($table_name);
}
public function testFindPrimaryKeyColumns() {
$method = new \ReflectionMethod(get_class($this->schema), 'findPrimaryKeyColumns');
$method
->setAccessible(TRUE);
$this->schema
->createTable('table_with_pk_0', [
'description' => 'Table with primary key.',
'fields' => [
'id' => [
'type' => 'int',
'not null' => TRUE,
],
'test_field' => [
'type' => 'int',
'not null' => TRUE,
],
],
'primary key' => [
'id',
],
]);
$this
->assertSame([
'id',
], $method
->invoke($this->schema, 'table_with_pk_0'));
$this->schema
->createTable('table_with_pk_1', [
'description' => 'Table with primary key with multiple columns.',
'fields' => [
'id0' => [
'type' => 'int',
'not null' => TRUE,
],
'id1' => [
'type' => 'int',
'not null' => TRUE,
],
'test_field' => [
'type' => 'int',
'not null' => TRUE,
],
],
'primary key' => [
'id0',
'id1',
],
]);
$this
->assertSame([
'id0',
'id1',
], $method
->invoke($this->schema, 'table_with_pk_1'));
$this->schema
->createTable('table_with_pk_2', [
'description' => 'Table with primary key with multiple columns at the end and in reverted sequence.',
'fields' => [
'test_field_1' => [
'type' => 'int',
'not null' => TRUE,
],
'test_field_2' => [
'type' => 'int',
'not null' => TRUE,
],
'id3' => [
'type' => 'int',
'not null' => TRUE,
],
'id4' => [
'type' => 'int',
'not null' => TRUE,
],
],
'primary key' => [
'id4',
'id3',
],
]);
$this
->assertSame([
'id4',
'id3',
], $method
->invoke($this->schema, 'table_with_pk_2'));
$this->schema
->createTable('table_with_pk_3', [
'description' => 'Table with primary key with multiple columns at the end and in reverted sequence.',
'fields' => [
'test_field_1' => [
'type' => 'int',
'not null' => TRUE,
],
'test_field_2' => [
'type' => 'int',
'not null' => TRUE,
],
'id3' => [
'type' => 'int',
'not null' => TRUE,
],
'id4' => [
'type' => 'int',
'not null' => TRUE,
],
],
'primary key' => [
'id3',
'test_field_2',
'id4',
],
]);
$this
->assertSame([
'id3',
'test_field_2',
'id4',
], $method
->invoke($this->schema, 'table_with_pk_3'));
$this->schema
->createTable('table_without_pk_1', [
'description' => 'Table without primary key.',
'fields' => [
'id' => [
'type' => 'int',
'not null' => TRUE,
],
'test_field' => [
'type' => 'int',
'not null' => TRUE,
],
],
]);
$this
->assertSame([], $method
->invoke($this->schema, 'table_without_pk_1'));
$this->schema
->createTable('table_without_pk_2', [
'description' => 'Table without primary key.',
'fields' => [
'id' => [
'type' => 'int',
'not null' => TRUE,
],
'test_field' => [
'type' => 'int',
'not null' => TRUE,
],
],
'primary key' => [],
]);
$this
->assertSame([], $method
->invoke($this->schema, 'table_without_pk_2'));
$this
->assertFalse($method
->invoke($this->schema, 'non_existing_table'));
}
public function testFindTables() {
$connection_info = Database::getConnectionInfo();
$new_connection_info = $connection_info['default'];
$new_connection_info['prefix']['test_2_table'] = $new_connection_info['prefix']['default'] . '_shared_';
Database::addConnectionInfo('test', 'default', $new_connection_info);
Database::setActiveConnection('test');
$test_schema = Database::getConnection()
->schema();
$table_specification = [
'description' => 'Test table.',
'fields' => [
'id' => [
'type' => 'int',
'default' => NULL,
],
],
];
$test_schema
->createTable('test_1_table', $table_specification);
$test_schema
->createTable('test_2_table', $table_specification);
$test_schema
->createTable('the_third_table', $table_specification);
$tables = $test_schema
->findTables('%');
sort($tables);
$expected = [
'config',
'test_1_table',
'test_2_table',
'the_third_table',
];
$this
->assertEqual($tables, $expected, 'All tables were found.');
$tables = $test_schema
->findTables('test_%');
sort($tables);
$expected = [
'test_1_table',
'test_2_table',
];
$this
->assertEqual($tables, $expected, 'Two tables were found.');
Database::setActiveConnection('default');
}
}