fix

docker/test/performance-comparison/compare.sh

@@ -309,7 +309,7 @@ create view addresses_src as select *
     from file('$version-addresses.tsv', TSVWithNamesAndTypes,
         '$(cat "$version-addresses.tsv.columns")');
 
-create table addresses_join engine Join(any, left, address) as
+create table addresses_join_$version engine Join(any, left, address) as
     select addr address, name from addresses_src;
 
 create table unstable_query_runs engine File(TSVWithNamesAndTypes,
@@ -348,7 +348,7 @@ create table unstable_run_traces engine File(TSVWithNamesAndTypes,
         'unstable-run-traces.$version.rep') as
     select
         count() value,
-        joinGet(addresses_join, 'name', arrayJoin(trace)) metric,
+        joinGet(addresses_join_$version, 'name', arrayJoin(trace)) metric,
         unstable_query_runs.query_id,
         any(unstable_query_runs.query) query
     from unstable_query_runs
@@ -374,7 +374,7 @@ create table stacks engine File(TSV, 'stacks.$version.rep') as
     select
         query,
         arrayStringConcat(
-            arrayMap(x -> joinGet(addresses_join, 'name', x),
+            arrayMap(x -> joinGet(addresses_join_$version, 'name', x),
                 arrayReverse(trace)
             ),
             ';'

programs/copier/ClusterCopierApp.cpp

@@ -110,7 +110,7 @@ void ClusterCopierApp::mainImpl()
     registerDisks();
 
     static const std::string default_database = "_local";
-    DatabaseCatalog::instance().attachDatabase(default_database, std::make_shared<DatabaseMemory>(default_database));
+    DatabaseCatalog::instance().attachDatabase(default_database, std::make_shared<DatabaseMemory>(default_database, *context));
     context->setCurrentDatabase(default_database);
 
     /// Initialize query scope just in case.

programs/local/LocalServer.cpp

@@ -119,13 +119,13 @@ void LocalServer::tryInitPath()
 }
 
 
-static void attachSystemTables()
+static void attachSystemTables(const Context & context)
 {
     DatabasePtr system_database = DatabaseCatalog::instance().tryGetDatabase(DatabaseCatalog::SYSTEM_DATABASE);
     if (!system_database)
     {
         /// TODO: add attachTableDelayed into DatabaseMemory to speedup loading
-        system_database = std::make_shared<DatabaseMemory>(DatabaseCatalog::SYSTEM_DATABASE);
+        system_database = std::make_shared<DatabaseMemory>(DatabaseCatalog::SYSTEM_DATABASE, context);
         DatabaseCatalog::instance().attachDatabase(DatabaseCatalog::SYSTEM_DATABASE, system_database);
     }
 
@@ -202,7 +202,7 @@ try
       *  if such tables will not be dropped, clickhouse-server will not be able to load them due to security reasons.
       */
     std::string default_database = config().getString("default_database", "_local");
-    DatabaseCatalog::instance().attachDatabase(default_database, std::make_shared<DatabaseMemory>(default_database));
+    DatabaseCatalog::instance().attachDatabase(default_database, std::make_shared<DatabaseMemory>(default_database, *context));
     context->setCurrentDatabase(default_database);
     applyCmdOptions();
 
@@ -213,14 +213,14 @@ try
 
         LOG_DEBUG(log, "Loading metadata from " << context->getPath());
         loadMetadataSystem(*context);
-        attachSystemTables();
+        attachSystemTables(*context);
         loadMetadata(*context);
         DatabaseCatalog::instance().loadDatabases();
         LOG_DEBUG(log, "Loaded metadata.");
     }
     else
     {
-        attachSystemTables();
+        attachSystemTables(*context);
     }
 
     processQueries();

src/Databases/DatabaseAtomic.cpp

@@ -51,7 +51,6 @@ String DatabaseAtomic::getTableDataPath(const ASTCreateQuery & query) const
     auto tmp = data_path + DatabaseCatalog::getPathForUUID(query.uuid);
     assert(tmp != data_path && !tmp.empty());
     return tmp;
-
 }
 
 void DatabaseAtomic::drop(const Context &)
@@ -285,6 +284,13 @@ DatabaseTablesIteratorPtr DatabaseAtomic::getTablesWithDictionaryTablesIterator(
     return std::make_unique<AtomicDatabaseTablesSnapshotIterator>(std::move(typeid_cast<DatabaseTablesSnapshotIterator &>(*base_iter)));
 }
 
+UUID DatabaseAtomic::tryGetTableUUID(const String & table_name) const
+{
+    if (auto table = tryGetTable(global_context, table_name))
+        return table->getStorageID().uuid;
+    return UUIDHelpers::Nil;
+}
+
 void DatabaseAtomic::loadStoredObjects(Context & context, bool has_force_restore_data_flag)
 {
     /// Recreate symlinks to table data dirs in case of force restore, because some of them may be broken

src/Databases/DatabaseAtomic.h

@@ -40,6 +40,8 @@ public:
 
     void assertCanBeDetached(bool cleenup);
 
+    UUID tryGetTableUUID(const String & table_name) const override;
+
 private:
     void commitAlterTable(const StorageID & table_id, const String & table_metadata_tmp_path, const String & table_metadata_path) override;
     void commitCreateTable(const ASTCreateQuery & query, const StoragePtr & table,

src/Databases/DatabaseFactory.cpp

@@ -79,7 +79,7 @@ DatabasePtr DatabaseFactory::getImpl(
     else if (engine_name == "Atomic")
         return std::make_shared<DatabaseAtomic>(database_name, metadata_path, context);
     else if (engine_name == "Memory")
-        return std::make_shared<DatabaseMemory>(database_name);
+        return std::make_shared<DatabaseMemory>(database_name, context);
     else if (engine_name == "Dictionary")
         return std::make_shared<DatabaseDictionary>(database_name, context);
 

src/Databases/DatabaseMemory.cpp

 #include <common/logger_useful.h>
 #include <Databases/DatabaseMemory.h>
 #include <Databases/DatabasesCommon.h>
+#include <Interpreters/Context.h>
 #include <Parsers/ASTCreateQuery.h>
 #include <Storages/IStorage.h>
 #include <Poco/File.h>
@@ -14,8 +15,9 @@ namespace ErrorCodes
     extern const int UNKNOWN_TABLE;
 }
 
-DatabaseMemory::DatabaseMemory(const String & name_)
+DatabaseMemory::DatabaseMemory(const String & name_, const Context & global_context_)
     : DatabaseWithOwnTablesBase(name_, "DatabaseMemory(" + name_ + ")")
+    , global_context(global_context_.getGlobalContext())
     , data_path("data/" + escapeForFileName(database_name) + "/")
 {}
 
@@ -76,4 +78,11 @@ ASTPtr DatabaseMemory::getCreateTableQueryImpl(const Context &, const String & t
     return it->second;
 }
 
+UUID DatabaseMemory::tryGetTableUUID(const String & table_name) const
+{
+    if (auto table = tryGetTable(global_context, table_name))
+        return table->getStorageID().uuid;
+    return UUIDHelpers::Nil;
+}
+
 }

src/Databases/DatabaseMemory.h

@@ -19,7 +19,7 @@ namespace DB
 class DatabaseMemory final : public DatabaseWithOwnTablesBase
 {
 public:
-    DatabaseMemory(const String & name_);
+    DatabaseMemory(const String & name_, const Context & global_context_);
 
     String getEngineName() const override { return "Memory"; }
 
@@ -44,7 +44,10 @@ public:
     String getTableDataPath(const String & table_name) const override { return data_path + escapeForFileName(table_name) + "/"; }
     String getTableDataPath(const ASTCreateQuery & query) const override { return getTableDataPath(query.table); }
 
+    UUID tryGetTableUUID(const String & table_name) const override;
+
 private:
+    const Context & global_context;
     String data_path;
     using NameToASTCreate = std::unordered_map<String, ASTPtr>;
     NameToASTCreate create_queries;

src/Databases/IDatabase.h

@@ -141,6 +141,8 @@ public:
         const Context & context,
         const String & name) const = 0;
 
+    virtual UUID tryGetTableUUID(const String & /*table_name*/) const { return UUIDHelpers::Nil; }
+
     using FilterByNameFunction = std::function<bool(const String &)>;
 
     /// Get an iterator that allows you to pass through all the tables.

src/Interpreters/Context.cpp

@@ -2037,7 +2037,9 @@ StorageID Context::resolveStorageID(StorageID storage_id, StorageNamespace where
     }
     if (exc)
         throw Exception(*exc);
-    return DatabaseCatalog::instance().getTable(resolved)->getStorageID();
+    if (!resolved.hasUUID() && resolved.database_name != DatabaseCatalog::TEMPORARY_DATABASE)
+        resolved.uuid = DatabaseCatalog::instance().getDatabase(resolved.database_name)->tryGetTableUUID(resolved.table_name);
+    return resolved;
 }
 
 StorageID Context::tryResolveStorageID(StorageID storage_id, StorageNamespace where) const
@@ -2050,9 +2052,13 @@ StorageID Context::tryResolveStorageID(StorageID storage_id, StorageNamespace wh
         auto lock = getLock();
         resolved = resolveStorageIDImpl(std::move(storage_id), where, nullptr);
     }
-    if (auto table = DatabaseCatalog::instance().tryGetTable(resolved))
-        return table->getStorageID();
-    return StorageID::createEmpty();
+    if (resolved && !resolved.hasUUID() && resolved.database_name != DatabaseCatalog::TEMPORARY_DATABASE)
+    {
+        auto db = DatabaseCatalog::instance().tryGetDatabase(resolved.database_name);
+        if (db)
+            resolved.uuid = db->tryGetTableUUID(resolved.table_name);
+    }
+    return resolved;
 }
 
 StorageID Context::resolveStorageIDImpl(StorageID storage_id, StorageNamespace where, std::optional<Exception> * exception) const

src/Interpreters/DatabaseCatalog.cpp

@@ -108,7 +108,7 @@ void DatabaseCatalog::loadDatabases()
 {
     drop_delay_s = global_context->getConfigRef().getInt("database_atomic_delay_before_drop_table_s", 60);
 
-    auto db_for_temporary_and_external_tables = std::make_shared<DatabaseMemory>(TEMPORARY_DATABASE);
+    auto db_for_temporary_and_external_tables = std::make_shared<DatabaseMemory>(TEMPORARY_DATABASE, *global_context);
     attachDatabase(TEMPORARY_DATABASE, db_for_temporary_and_external_tables);
 
     loadMarkedAsDroppedTables();
@@ -483,6 +483,15 @@ StoragePtr DatabaseCatalog::tryGetTable(const StorageID & table_id) const
     return getTableImpl(table_id, *global_context, nullptr).second;
 }
 
+DatabaseAndTable DatabaseCatalog::getDatabaseAndTable(const StorageID & table_id) const
+{
+    std::optional<Exception> exc;
+    auto res = getTableImpl(table_id, *global_context, &exc);
+    if (!res.second)
+        throw Exception(*exc);
+    return res;
+}
+
 DatabaseAndTable DatabaseCatalog::tryGetDatabaseAndTable(const StorageID & table_id) const
 {
     return getTableImpl(table_id, *global_context, nullptr);

src/Interpreters/DatabaseCatalog.h

@@ -135,7 +135,7 @@ public:
 
     StoragePtr getTable(const StorageID & table_id) const;
     StoragePtr tryGetTable(const StorageID & table_id) const;
-    DatabaseAndTable getDatabaseAndTable(const StorageID & table_id) const { return getTableImpl(table_id, *global_context); }
+    DatabaseAndTable getDatabaseAndTable(const StorageID & table_id) const;
     DatabaseAndTable tryGetDatabaseAndTable(const StorageID & table_id) const;
     DatabaseAndTable getTableImpl(const StorageID & table_id, const Context & local_context, std::optional<Exception> * exception = nullptr) const;
 

src/Interpreters/InterpreterDropQuery.cpp

@@ -73,7 +73,6 @@ BlockIO InterpreterDropQuery::executeToTable(
                         ErrorCodes::UNKNOWN_TABLE);
     }
 
-    /// If table was already dropped by anyone, an exception will be thrown
     auto table_id = query.if_exists ? context.tryResolveStorageID(table_id_, Context::ResolveOrdinary)
                                     : context.resolveStorageID(table_id_, Context::ResolveOrdinary);
     if (!table_id)
@@ -81,7 +80,9 @@ BlockIO InterpreterDropQuery::executeToTable(
 
     auto ddl_guard = (!query.no_ddl_lock ? DatabaseCatalog::instance().getDDLGuard(table_id.database_name, table_id.table_name) : nullptr);
 
-    auto [database, table] = DatabaseCatalog::instance().getDatabaseAndTable(table_id);
+    /// If table was already dropped by anyone, an exception will be thrown
+    auto [database, table] = query.if_exists ? DatabaseCatalog::instance().tryGetDatabaseAndTable(table_id)
+                                             : DatabaseCatalog::instance().getDatabaseAndTable(table_id);
 
     if (database && table)
     {

src/Interpreters/tests/expression_analyzer.cpp

@@ -98,7 +98,7 @@ int main()
     Context context = Context::createGlobal();
     context.makeGlobalContext();
 
-    auto system_database = std::make_shared<DatabaseMemory>("system");
+    auto system_database = std::make_shared<DatabaseMemory>("system", context);
     DatabaseCatalog::instance().attachDatabase("system", system_database);
     //context.setCurrentDatabase("system");
     system_database->attachTable("one", StorageSystemOne::create("one"), {});

tests/queries/0_stateless/00693_max_block_size_system_tables_columns.sql

@@ -5,7 +5,9 @@ SELECT (SELECT count() FROM system.tables SETTINGS max_block_size = 100) = (SELE
 
 DROP TEMPORARY TABLE IF EXISTS t_00693;
 CREATE TEMPORARY TABLE t_00693 (x UInt8);
-SELECT * FROM system.tables WHERE is_temporary AND name='t_00693';
+SELECT database, name, engine, is_temporary, data_paths, metadata_path, metadata_modification_time, dependencies_database,
+       dependencies_table, create_table_query, engine_full, partition_key, sorting_key, primary_key, sampling_key, storage_policy,
+       total_rows, total_bytes FROM system.tables WHERE is_temporary AND name='t_00693';
 
 SELECT avg(blockSize()) <= 10000 FROM system.columns SETTINGS max_block_size = 10;
 SELECT avg(blockSize()) <= 10000 FROM system.columns LIMIT 10 SETTINGS max_block_size = 10;

tests/queries/0_stateless/01004_rename_deadlock.sh

@@ -55,6 +55,7 @@ timeout $TIMEOUT bash -c thread2 2> /dev/null &
 timeout $TIMEOUT bash -c thread3 2> /dev/null &
 
 wait
+sleep 1
 
 $CLICKHOUSE_CLIENT -q "DROP TABLE test1"
 $CLICKHOUSE_CLIENT -q "DROP TABLE test2"