diff --git a/core/lib/Drupal/Core/Database/Connection.php b/core/lib/Drupal/Core/Database/Connection.php index 142e452ceb..d897025fd4 100644 --- a/core/lib/Drupal/Core/Database/Connection.php +++ b/core/lib/Drupal/Core/Database/Connection.php @@ -381,8 +381,16 @@ public function getPrefix(): string { protected function setPrefix($prefix) { assert(is_string($prefix), 'The \'$prefix\' argument to ' . __METHOD__ . '() must be a string'); $this->prefix = $prefix; + + // Add the schema name of it is not set to public, else it will use the + // default schema name. + $quoted_schema = ''; + if (isset($this->connectionOptions['schema']) && ($this->connectionOptions['schema'] != 'public')) { + $quoted_schema = $this->identifierQuotes[0] . $this->connectionOptions['schema'] . $this->identifierQuotes[1] . '.'; + } + $this->tablePlaceholderReplacements = [ - $this->identifierQuotes[0] . str_replace('.', $this->identifierQuotes[1] . '.' . $this->identifierQuotes[0], $prefix), + $quoted_schema . $this->identifierQuotes[0] . str_replace('.', $this->identifierQuotes[1] . '.' . $this->identifierQuotes[0], $prefix), $this->identifierQuotes[1], ]; } diff --git a/core/modules/pgsql/src/Driver/Database/pgsql/Connection.php b/core/modules/pgsql/src/Driver/Database/pgsql/Connection.php index 58d500e361..4aab6ea03b 100644 --- a/core/modules/pgsql/src/Driver/Database/pgsql/Connection.php +++ b/core/modules/pgsql/src/Driver/Database/pgsql/Connection.php @@ -73,6 +73,10 @@ class Connection extends DatabaseConnection implements SupportsTemporaryTablesIn * Constructs a connection object. */ public function __construct(\PDO $connection, array $connection_options) { + // We need to set the connectionOptions before the parent, because setPrefix + // needs this. + $this->connectionOptions = $connection_options; + parent::__construct($connection, $connection_options); // Force PostgreSQL to use the UTF-8 character set by default. @@ -309,12 +313,11 @@ public function nextId($existing = 0) { */ public function getFullQualifiedTableName($table) { $options = $this->getConnectionOptions(); - $prefix = $this->getPrefix(); + $schema = $options['schema'] ?? 'public'; // The fully qualified table name in PostgreSQL is in the form of - // .., so we have to include the 'public' schema in - // the return value. - return $options['database'] . '.public.' . $prefix . $table; + // ..
. + return $options['database'] . '.' . $schema . '.' . $this->getPrefix() . $table; } /** diff --git a/core/modules/pgsql/src/Driver/Database/pgsql/Schema.php b/core/modules/pgsql/src/Driver/Database/pgsql/Schema.php index 2336d103fa..d17c03d0e7 100644 --- a/core/modules/pgsql/src/Driver/Database/pgsql/Schema.php +++ b/core/modules/pgsql/src/Driver/Database/pgsql/Schema.php @@ -50,6 +50,17 @@ class Schema extends DatabaseSchema { */ protected $tempNamespaceName; + /** + * {@inheritdoc} + */ + public function __construct($connection) { + parent::__construct($connection); + + // If the schema is not set in the connection options than schema defaults + // to public. + $this->defaultSchema = $connection->getConnectionOptions()['schema'] ?? 'public'; + } + /** * Make sure to limit identifiers according to PostgreSQL compiled in length. * @@ -121,10 +132,7 @@ public function queryTableInformation($table) { // Take into account that temporary tables are stored in a different schema. // \Drupal\Core\Database\Connection::generateTemporaryTableName() sets the // 'db_temporary_' prefix to all temporary tables. - if (strpos($key, '.') === FALSE && strpos($table, 'db_temporary_') === FALSE) { - $key = 'public.' . $key; - } - else { + if (strpos($table, 'db_temporary_') !== FALSE) { $key = $this->getTempNamespaceName() . '.' . $key; } @@ -206,10 +214,7 @@ protected function getTempNamespaceName() { * The non-prefixed name of the table. */ protected function resetTableInformation($table) { - $key = $this->connection->prefixTables('{' . $table . '}'); - if (strpos($key, '.') === FALSE) { - $key = 'public.' . $key; - } + $key = $this->defaultSchema . '.' . $this->connection->getPrefix() . $table; unset($this->tableInformation[$key]); } @@ -549,33 +554,41 @@ public function renameTable($table, $new_name) { } // Get the schema and tablename for the old table. - $old_full_name = str_replace('"', '', $this->connection->prefixTables('{' . $table . '}')); - [$old_schema, $old_table_name] = strpos($old_full_name, '.') ? explode('.', $old_full_name) : ['public', $old_full_name]; - + $table_name = $this->connection->getPrefix() . $table; // Index names and constraint names are global in PostgreSQL, so we need to // rename them when renaming the table. - $indexes = $this->connection->query('SELECT indexname FROM pg_indexes WHERE schemaname = :schema AND tablename = :table', [':schema' => $old_schema, ':table' => $old_table_name]); + $indexes = $this->connection->query('SELECT indexname FROM pg_indexes WHERE schemaname = :schema AND tablename = :table', [':schema' => $this->defaultSchema, ':table' => $table_name]); foreach ($indexes as $index) { - // Get the index type by suffix, e.g. idx/key/pkey - $index_type = substr($index->indexname, strrpos($index->indexname, '_') + 1); + // Append the schema to the index name. + $index_short_name = $index->indexname; + if ($this->defaultSchema != 'public') { + $index_full_name = $this->defaultSchema . '.' . $index_short_name; + $index_full_name = $this->connection->escapeTable($index_full_name); + } + else { + $index_full_name = '"' . $index_short_name . '"'; + } + + // Get the index type by suffix, e.g. idx/key/pkey. + $index_type = substr($index_short_name, strrpos($index_short_name, '_') + 1); // If the index is already rewritten by ensureIdentifiersLength() to not // exceed the 63 chars limit of PostgreSQL, we need to take care of that. // cSpell:disable-next-line // Example (drupal_Gk7Su_T1jcBHVuvSPeP22_I3Ni4GrVEgTYlIYnBJkro_idx). - if (strpos($index->indexname, 'drupal_') !== FALSE) { - preg_match('/^drupal_(.*)_' . preg_quote($index_type) . '/', $index->indexname, $matches); + if (strpos($index_short_name, 'drupal_') !== FALSE) { + preg_match('/^drupal_(.*)_' . preg_quote($index_type) . '/', $index_short_name, $matches); $index_name = $matches[1]; } else { // Make sure to remove the suffix from index names, because // $this->ensureIdentifiersLength() will add the suffix again and thus // would result in a wrong index name. - preg_match('/^' . preg_quote($old_full_name) . '__(.*)__' . preg_quote($index_type) . '/', $index->indexname, $matches); + preg_match('/^' . preg_quote($table_name) . '__(.*)__' . preg_quote($index_type) . '/', $index_short_name, $matches); $index_name = $matches[1]; } - $this->connection->query('ALTER INDEX "' . $index->indexname . '" RENAME TO ' . $this->ensureIdentifiersLength($new_name, $index_name, $index_type) . ''); + $this->connection->query('ALTER INDEX "' . $this->defaultSchema . '"."' . $index->indexname . '" RENAME TO ' . $this->ensureIdentifiersLength($new_name, $index_name, $index_type) . ''); } // Ensure the new table name does not include schema syntax. @@ -588,7 +601,7 @@ public function renameTable($table, $new_name) { // The initial name of the sequence is generated automatically by // PostgreSQL when the table is created, so we need to use // pg_get_serial_sequence() to retrieve it. - $old_sequence = $this->connection->query("SELECT pg_get_serial_sequence('" . $old_full_name . "', '" . $field . "')")->fetchField(); + $old_sequence = $this->connection->query("SELECT pg_get_serial_sequence('" . $this->defaultSchema . '.' . $table_name . "', '" . $field . "')")->fetchField(); // If the new sequence name exceeds the maximum identifier length limit, // it will not match the pattern that is automatically applied by @@ -711,7 +724,14 @@ public function indexExists($table, $name) { // Remove leading and trailing quotes because the index name is in a WHERE // clause and not used as an identifier. $index_name = str_replace('"', '', $index_name); - return (bool) $this->connection->query("SELECT 1 FROM pg_indexes WHERE indexname = '$index_name'")->fetchField(); + + // Get the schema and tablename for the old table. + $sql_params = [ + ':schema' => $this->defaultSchema, + ':table' => $this->connection->getPrefix() . $table, + ':index' => $index_name, + ]; + return (bool) $this->connection->query("SELECT 1 FROM pg_indexes WHERE schemaname = :schema AND tablename = :table AND indexname = :index", $sql_params)->fetchField(); } /** @@ -835,7 +855,7 @@ public function dropIndex($table, $name) { return FALSE; } - $this->connection->query('DROP INDEX ' . $this->ensureIdentifiersLength($table, $name, 'idx')); + $this->connection->query('DROP INDEX ' . $this->defaultSchema . '.' . $this->ensureIdentifiersLength($table, $name, 'idx')); $this->resetTableInformation($table); return TRUE; } diff --git a/core/modules/pgsql/tests/src/Kernel/pgsql/NonPublicSchemaTest.php b/core/modules/pgsql/tests/src/Kernel/pgsql/NonPublicSchemaTest.php new file mode 100644 index 0000000000..731a3053f2 --- /dev/null +++ b/core/modules/pgsql/tests/src/Kernel/pgsql/NonPublicSchemaTest.php @@ -0,0 +1,361 @@ +testingFakeConnection = Database::getConnection('testing_fake', 'default'); + + $table_specification = [ + 'description' => 'Schema table description may contain "quotes" and could be long—very long indeed.', + 'fields' => [ + 'id' => [ + 'type' => 'serial', + 'not null' => TRUE, + ], + 'test_field' => [ + 'type' => 'int', + 'not null' => TRUE, + ], + ], + 'primary key' => ['id'], + ]; + + $this->testingFakeConnection->schema()->createTable('faking_table', $table_specification); + + $this->testingFakeConnection->insert('faking_table') + ->fields( + [ + 'id' => '1', + 'test_field' => '123', + ] + )->execute(); + + $this->testingFakeConnection->insert('faking_table') + ->fields( + [ + 'id' => '2', + 'test_field' => '456', + ] + )->execute(); + + $this->testingFakeConnection->insert('faking_table') + ->fields( + [ + 'id' => '3', + 'test_field' => '789', + ] + )->execute(); + } + + /** + * {@inheritdoc} + */ + protected function tearDown(): void { + // We overwrite this function because the regular teardown will not drop the + // tables from a specified schema. + $tables = $this->testingFakeConnection->schema()->findTables('%'); + foreach ($tables as $table) { + if ($this->testingFakeConnection->schema()->dropTable($table)) { + unset($tables[$table]); + } + } + + $this->assertEmpty($this->testingFakeConnection->schema()->findTables('%')); + + Database::removeConnection('testing_fake'); + + parent::tearDown(); + } + + /** + * @covers ::extensionExists + * @covers ::tableExists + */ + public function testExtensionExists(): void { + // Check if PG_trgm extension is present. + $this->assertTrue($this->testingFakeConnection->schema()->extensionExists('pg_trgm')); + // Asserting that the Schema testing_fake exist in the database. + $this->assertCount(1, \Drupal::database()->query("SELECT * FROM pg_catalog.pg_namespace WHERE nspname = 'testing_fake'")->fetchAll()); + $this->assertTrue($this->testingFakeConnection->schema()->tableExists('faking_table')); + + // Hardcoded assertion that we created the table in the non-public schema. + $this->assertCount(1, $this->testingFakeConnection->query("SELECT * FROM pg_tables WHERE schemaname = 'testing_fake' AND tablename = :prefixedTable", [':prefixedTable' => $this->testingFakeConnection->getPrefix() . "faking_table"])->fetchAll()); + } + + /** + * @covers ::addField + * @covers ::fieldExists + * @covers ::dropField + * @covers ::changeField + */ + public function testField(): void { + $this->testingFakeConnection->schema()->addField('faking_table', 'added_field', ['type' => 'int', 'not null' => FALSE]); + $this->assertTrue($this->testingFakeConnection->schema()->fieldExists('faking_table', 'added_field')); + + $this->testingFakeConnection->schema()->changeField('faking_table', 'added_field', 'changed_field', ['type' => 'int', 'not null' => FALSE]); + $this->assertFalse($this->testingFakeConnection->schema()->fieldExists('faking_table', 'added_field')); + $this->assertTrue($this->testingFakeConnection->schema()->fieldExists('faking_table', 'changed_field')); + + $this->testingFakeConnection->schema()->dropField('faking_table', 'changed_field'); + $this->assertFalse($this->testingFakeConnection->schema()->fieldExists('faking_table', 'changed_field')); + } + + /** + * @covers ::insert + * @covers ::select + */ + public function testInsert(): void { + $num_records_before = $this->testingFakeConnection->query('SELECT COUNT(*) FROM {faking_table}')->fetchField(); + + $this->testingFakeConnection->insert('faking_table') + ->fields([ + 'id' => '123', + 'test_field' => '55', + ])->execute(); + + // Testing that the insert is correct. + $results = $this->testingFakeConnection->select('faking_table')->fields('faking_table')->condition('id', '123')->execute()->fetchAll(); + $this->assertIsArray($results); + + $num_records_after = $this->testingFakeConnection->query('SELECT COUNT(*) FROM {faking_table}')->fetchField(); + $this->assertEquals($num_records_before + 1, $num_records_after, 'Merge inserted properly.'); + + $this->assertSame('123', $results[0]->id); + $this->assertSame('55', $results[0]->test_field); + } + + /** + * @covers ::update + */ + public function testUpdate(): void { + $updated_record = $this->testingFakeConnection->update('faking_table') + ->fields(['test_field' => 321]) + ->condition('id', 1) + ->execute(); + + $this->assertSame(1, $updated_record, 'Updated 1 record.'); + + $updated_results = $this->testingFakeConnection->select('faking_table')->fields('faking_table')->condition('id', '1')->execute()->fetchAll(); + + $this->assertSame('321', $updated_results[0]->test_field); + } + + /** + * @covers ::upsert + */ + public function testUpsert(): void { + $num_records_before = $this->testingFakeConnection->query('SELECT COUNT(*) FROM {faking_table}')->fetchField(); + + $upsert = $this->testingFakeConnection->upsert('faking_table') + ->key('id') + ->fields(['id', 'test_field']); + + // Upserting a new row. + $upsert->values([ + 'id' => '456', + 'test_field' => '444', + ]); + + // Upserting an existing row. + $upsert->values([ + 'id' => '1', + 'test_field' => '898', + ]); + + $result = $upsert->execute(); + $this->assertSame(2, $result, 'The result of the upsert operation should report that at exactly two rows were affected.'); + + $num_records_after = $this->testingFakeConnection->query('SELECT COUNT(*) FROM {faking_table}')->fetchField(); + $this->assertEquals($num_records_before + 1, $num_records_after, 'Merge inserted properly.'); + + // Check if new row has been added with upsert. + $result = $this->testingFakeConnection->query('SELECT * FROM {faking_table} WHERE [id] = :id', [':id' => '456'])->fetch(); + $this->assertEquals('456', $result->id, 'ID set correctly.'); + $this->assertEquals('444', $result->test_field, 'test_field set correctly.'); + + // Check if new row has been edited with upsert. + $result = $this->testingFakeConnection->query('SELECT * FROM {faking_table} WHERE [id] = :id', [':id' => '1'])->fetch(); + $this->assertEquals('1', $result->id, 'ID set correctly.'); + $this->assertEquals('898', $result->test_field, 'test_field set correctly.'); + } + + /** + * @covers ::merge + */ + public function testMerge(): void { + $num_records_before = $this->testingFakeConnection->query('SELECT COUNT(*) FROM {faking_table}')->fetchField(); + + $this->testingFakeConnection->merge('faking_table') + ->key('id', '789') + ->fields([ + 'test_field' => 343, + ]) + ->execute(); + + $num_records_after = $this->testingFakeConnection->query('SELECT COUNT(*) FROM {faking_table}')->fetchField(); + $this->assertEquals($num_records_before + 1, $num_records_after, 'Merge inserted properly.'); + + $merge_results = $this->testingFakeConnection->select('faking_table')->fields('faking_table')->condition('id', '789')->execute()->fetchAll(); + $this->assertSame('789', $merge_results[0]->id); + $this->assertSame('343', $merge_results[0]->test_field); + } + + /** + * @covers ::delete + * @covers ::truncate + */ + public function testDelete(): void { + $num_records_before = $this->testingFakeConnection->query('SELECT COUNT(*) FROM {faking_table}')->fetchField(); + + $num_deleted = $this->testingFakeConnection->delete('faking_table') + ->condition('id', 3) + ->execute(); + $this->assertSame(1, $num_deleted, 'Deleted 1 record.'); + + $num_records_after = $this->testingFakeConnection->query('SELECT COUNT(*) FROM {faking_table}')->fetchField(); + $this->assertEquals($num_records_before, $num_records_after + $num_deleted, 'Deletion adds up.'); + + $num_records_before = $this->testingFakeConnection->query("SELECT COUNT(*) FROM {faking_table}")->fetchField(); + $this->assertNotEmpty($num_records_before); + + $this->testingFakeConnection->truncate('faking_table')->execute(); + + $num_records_after = $this->testingFakeConnection->query("SELECT COUNT(*) FROM {faking_table}")->fetchField(); + $this->assertEquals(0, $num_records_after, 'Truncate really deletes everything.'); + } + + /** + * @covers ::addIndex + * @covers ::indexExists + * @covers ::dropIndex + */ + public function testIndex(): void { + $this->testingFakeConnection->schema()->addIndex('faking_table', 'test_field', ['test_field'], []); + + $this->assertTrue($this->testingFakeConnection->schema()->indexExists('faking_table', 'test_field')); + + $results = $this->testingFakeConnection->query("SELECT * FROM pg_indexes WHERE indexname = :indexname", [':indexname' => $this->testingFakeConnection->getPrefix() . 'faking_table__test_field__idx'])->fetchAll(); + + $this->assertCount(1, $results); + $this->assertSame('testing_fake', $results[0]->schemaname); + $this->assertSame($this->testingFakeConnection->getPrefix() . 'faking_table', $results[0]->tablename); + $this->assertStringContainsString('USING btree (test_field)', $results[0]->indexdef); + + $this->testingFakeConnection->schema()->dropIndex('faking_table', 'test_field'); + + $this->assertFalse($this->testingFakeConnection->schema()->indexExists('faking_table', 'test_field')); + } + + /** + * @covers ::addUniqueKey + * @covers ::indexExists + * @covers ::dropUniqueKey + */ + public function testUniqueKey(): void { + $this->testingFakeConnection->schema()->addUniqueKey('faking_table', 'test_field', ['test_field']); + + // This should work, but currently indexExist() only searches for keys that end with idx. + // @todo remove comments when: https://www.drupal.org/project/drupal/issues/3325358 is committed. + // $this->assertTrue($this->testingFakeConnection->schema()->indexExists('faking_table', 'test_field')); + + $results = $this->testingFakeConnection->query("SELECT * FROM pg_indexes WHERE indexname = :indexname", [':indexname' => $this->testingFakeConnection->getPrefix() . 'faking_table__test_field__key'])->fetchAll(); + + // Check the unique key columns. + $this->assertCount(1, $results); + $this->assertSame('testing_fake', $results[0]->schemaname); + $this->assertSame($this->testingFakeConnection->getPrefix() . 'faking_table', $results[0]->tablename); + $this->assertStringContainsString('USING btree (test_field)', $results[0]->indexdef); + + $this->testingFakeConnection->schema()->dropUniqueKey('faking_table', 'test_field'); + + // This function will not work due to a the fact that indexExist() does not search for keys without idx tag. + // @todo remove comments when: https://www.drupal.org/project/drupal/issues/3325358 is committed. + // $this->assertFalse($this->testingFakeConnection->schema()->indexExists('faking_table', 'test_field')); + } + + /** + * @covers ::addPrimaryKey + * @covers ::dropPrimaryKey + */ + public function testPrimaryKey(): void { + $this->testingFakeConnection->schema()->dropPrimaryKey('faking_table'); + $results = $this->testingFakeConnection->query("SELECT * FROM pg_indexes WHERE schemaname = 'testing_fake'")->fetchAll(); + + $this->assertCount(0, $results); + + $this->testingFakeConnection->schema()->addPrimaryKey('faking_table', ['id']); + $results = $this->testingFakeConnection->query("SELECT * FROM pg_indexes WHERE schemaname = 'testing_fake'")->fetchAll(); + + $this->assertCount(1, $results); + $this->assertSame('testing_fake', $results[0]->schemaname); + $this->assertSame($this->testingFakeConnection->getPrefix() . 'faking_table', $results[0]->tablename); + $this->assertStringContainsString('USING btree (id)', $results[0]->indexdef); + + $find_primary_keys_columns = new \ReflectionMethod(get_class($this->testingFakeConnection->schema()), 'findPrimaryKeyColumns'); + $results = $find_primary_keys_columns->invoke($this->testingFakeConnection->schema(), 'faking_table'); + + $this->assertCount(1, $results); + $this->assertSame('id', $results[0]); + } + + /** + * @covers ::renameTable + * @covers ::tableExists + * @covers ::findTables + * @covers ::dropTable + */ + public function testTable(): void { + $this->testingFakeConnection->schema()->renameTable('faking_table', 'new_faking_table'); + + $tables = $this->testingFakeConnection->schema()->findTables('%'); + $result = $this->testingFakeConnection->query("SELECT * FROM information_schema.tables WHERE table_schema = 'testing_fake'")->fetchAll(); + $this->assertFalse($this->testingFakeConnection->schema()->tableExists('faking_table')); + $this->assertTrue($this->testingFakeConnection->schema()->tableExists('new_faking_table')); + $this->assertEquals($this->testingFakeConnection->getPrefix() . 'new_faking_table', $result[0]->table_name); + $this->assertEquals('testing_fake', $result[0]->table_schema); + sort($tables); + $this->assertEquals(['new_faking_table'], $tables); + + $this->testingFakeConnection->schema()->dropTable('new_faking_table'); + $this->assertFalse($this->testingFakeConnection->schema()->tableExists('new_faking_table')); + $this->assertCount(0, $this->testingFakeConnection->query("SELECT * FROM information_schema.tables WHERE table_schema = 'testing_fake'")->fetchAll()); + } + +}