diff --git a/src/Databases/DatabaseLazy.cpp b/src/Databases/DatabaseLazy.cpp
index 81414902a33..0119f17f843 100644
--- a/src/Databases/DatabaseLazy.cpp
+++ b/src/Databases/DatabaseLazy.cpp
@@ -329,10 +329,4 @@ const StoragePtr & DatabaseLazyIterator::table() const
     return current_storage;
 }
 
-void DatabaseLazyIterator::reset()
-{
-    if (current_storage)
-        current_storage.reset();
-}
-
 }
diff --git a/src/Databases/DatabaseLazy.h b/src/Databases/DatabaseLazy.h
index 58e5e465eef..13c14863efb 100644
--- a/src/Databases/DatabaseLazy.h
+++ b/src/Databases/DatabaseLazy.h
@@ -122,7 +122,6 @@ public:
     bool isValid() const override;
     const String & name() const override;
     const StoragePtr & table() const override;
-    void reset() override;
 
 private:
     const DatabaseLazy & database;
diff --git a/src/Databases/IDatabase.h b/src/Databases/IDatabase.h
index 9b744259406..b28bd5fd599 100644
--- a/src/Databases/IDatabase.h
+++ b/src/Databases/IDatabase.h
@@ -44,8 +44,6 @@ public:
     /// (a database with support for lazy tables loading
     /// - it maintains a list of tables but tables are loaded lazily).
     virtual const StoragePtr & table() const = 0;
-    /// Reset reference counter to the StoragePtr.
-    virtual void reset() = 0;
 
     virtual ~IDatabaseTablesIterator() = default;
 
@@ -95,8 +93,6 @@ public:
     const String & name() const override { return it->first; }
 
     const StoragePtr & table() const override { return it->second; }
-
-    void reset() override { it->second.reset(); }
 };
 
 /// Copies list of dictionaries and iterates through such snapshot.
diff --git a/src/Databases/MySQL/DatabaseMaterializeTablesIterator.h b/src/Databases/MySQL/DatabaseMaterializeTablesIterator.h
index 5a0ec242c2f..86a5cbf8206 100644
--- a/src/Databases/MySQL/DatabaseMaterializeTablesIterator.h
+++ b/src/Databases/MySQL/DatabaseMaterializeTablesIterator.h
@@ -28,11 +28,6 @@ public:
         return tables.emplace_back(storage);
     }
 
-    void reset() override
-    {
-        tables.clear();
-    }
-
     UUID uuid() const override { return nested_iterator->uuid(); }
 
     DatabaseMaterializeTablesIterator(DatabaseTablesIteratorPtr nested_iterator_, DatabaseMaterializeMySQL * database_)
diff --git a/src/Interpreters/InterpreterDropQuery.cpp b/src/Interpreters/InterpreterDropQuery.cpp
index c4ebe596649..8bf8675b15d 100644
--- a/src/Interpreters/InterpreterDropQuery.cpp
+++ b/src/Interpreters/InterpreterDropQuery.cpp
@@ -52,13 +52,37 @@ BlockIO InterpreterDropQuery::execute()
             return executeToDictionary(drop.database, drop.table, drop.kind, drop.if_exists, drop.temporary, drop.no_ddl_lock);
     }
     else if (!drop.database.empty())
-        return executeToDatabase(drop.database, drop.kind, drop.if_exists, drop.no_delay);
+        return executeToDatabase(drop);
     else
         throw Exception("Nothing to drop, both names are empty", ErrorCodes::LOGICAL_ERROR);
 }
 
 
+void InterpreterDropQuery::waitForTableToBeActuallyDroppedOrDetached(const ASTDropQuery & query, const DatabasePtr & db, const UUID & uuid_to_wait)
+{
+    if (uuid_to_wait == UUIDHelpers::Nil)
+        return;
+
+    if (query.kind == ASTDropQuery::Kind::Drop)
+        DatabaseCatalog::instance().waitTableFinallyDropped(uuid_to_wait);
+    else if (query.kind == ASTDropQuery::Kind::Detach)
+    {
+        if (auto * atomic = typeid_cast<DatabaseAtomic *>(db.get()))
+            atomic->waitDetachedTableNotInUse(uuid_to_wait);
+    }
+}
+
 BlockIO InterpreterDropQuery::executeToTable(const ASTDropQuery & query)
+{
+    DatabasePtr database;
+    UUID table_to_wait_on = UUIDHelpers::Nil;
+    auto res = executeToTableImpl(query, database, table_to_wait_on);
+    if (query.no_delay)
+        waitForTableToBeActuallyDroppedOrDetached(query, database, table_to_wait_on);
+    return res;
+}
+
+BlockIO InterpreterDropQuery::executeToTableImpl(const ASTDropQuery & query, DatabasePtr & db, UUID & uuid_to_wait)
 {
     /// NOTE: it does not contain UUID, we will resolve it with locked DDLGuard
     auto table_id = StorageID(query);
@@ -125,19 +149,9 @@ BlockIO InterpreterDropQuery::executeToTable(const ASTDropQuery & query)
 
             database->dropTable(context, table_id.table_name, query.no_delay);
         }
-    }
 
-    table.reset();
-    ddl_guard = {};
-    if (query.no_delay)
-    {
-        if (query.kind == ASTDropQuery::Kind::Drop)
-            DatabaseCatalog::instance().waitTableFinallyDropped(table_id.uuid);
-        else if (query.kind == ASTDropQuery::Kind::Detach)
-        {
-            if (auto * atomic = typeid_cast<DatabaseAtomic *>(database.get()))
-                atomic->waitDetachedTableNotInUse(table_id.uuid);
-        }
+        db = database;
+        uuid_to_wait = table_id.uuid;
     }
 
     return {};
@@ -223,19 +237,48 @@ BlockIO InterpreterDropQuery::executeToTemporaryTable(const String & table_name,
 }
 
 
-BlockIO InterpreterDropQuery::executeToDatabase(const String & database_name, ASTDropQuery::Kind kind, bool if_exists, bool no_delay)
+BlockIO InterpreterDropQuery::executeToDatabase(const ASTDropQuery & query)
 {
+    DatabasePtr database;
+    std::vector<UUID> tables_to_wait;
+    BlockIO res;
+    try
+    {
+        res = executeToDatabaseImpl(query, database, tables_to_wait);
+    }
+    catch (...)
+    {
+        if (query.no_delay)
+        {
+            for (const auto table_uuid : tables_to_wait)
+                waitForTableToBeActuallyDroppedOrDetached(query, database, table_uuid);
+        }
+        throw;
+    }
+
+    if (query.no_delay)
+    {
+        for (const auto table_uuid : tables_to_wait)
+            waitForTableToBeActuallyDroppedOrDetached(query, database, table_uuid);
+    }
+    return res;
+}
+
+BlockIO InterpreterDropQuery::executeToDatabaseImpl(const ASTDropQuery & query, DatabasePtr & database, std::vector<UUID> & uuids_to_wait)
+{
+    const auto & database_name = query.database;
     auto ddl_guard = DatabaseCatalog::instance().getDDLGuard(database_name, "");
 
-    if (auto database = tryGetDatabase(database_name, if_exists))
+    database = tryGetDatabase(database_name, query.if_exists);
+    if (database)
     {
-        if (kind == ASTDropQuery::Kind::Truncate)
+        if (query.kind == ASTDropQuery::Kind::Truncate)
         {
             throw Exception("Unable to truncate database", ErrorCodes::SYNTAX_ERROR);
         }
-        else if (kind == ASTDropQuery::Kind::Detach || kind == ASTDropQuery::Kind::Drop)
+        else if (query.kind == ASTDropQuery::Kind::Detach || query.kind == ASTDropQuery::Kind::Drop)
         {
-            bool drop = kind == ASTDropQuery::Kind::Drop;
+            bool drop = query.kind == ASTDropQuery::Kind::Drop;
             context.checkAccess(AccessType::DROP_DATABASE, database_name);
 
             if (database->shouldBeEmptyOnDetach())
@@ -246,21 +289,22 @@ BlockIO InterpreterDropQuery::executeToDatabase(const String & database_name, AS
                 for (auto iterator = database->getDictionariesIterator(); iterator->isValid(); iterator->next())
                 {
                     String current_dictionary = iterator->name();
-                    executeToDictionary(database_name, current_dictionary, kind, false, false, false);
+                    executeToDictionary(database_name, current_dictionary, query.kind, false, false, false);
                 }
 
-                ASTDropQuery query;
-                query.kind = kind;
-                query.if_exists = true;
-                query.database = database_name;
-                query.no_delay = no_delay;
+                ASTDropQuery query_for_table;
+                query_for_table.kind = query.kind;
+                query_for_table.if_exists = true;
+                query_for_table.database = database_name;
+                query_for_table.no_delay = query.no_delay;
 
                 for (auto iterator = database->getTablesIterator(context); iterator->isValid(); iterator->next())
                 {
-                    /// Reset reference counter of the StoragePtr to allow synchronous drop.
-                    iterator->reset();
-                    query.table = iterator->name();
-                    executeToTable(query);
+                    DatabasePtr db;
+                    UUID table_to_wait = UUIDHelpers::Nil;
+                    query_for_table.table = iterator->name();
+                    executeToTableImpl(query_for_table, db, table_to_wait);
+                    uuids_to_wait.push_back(table_to_wait);
                 }
             }
 
diff --git a/src/Interpreters/InterpreterDropQuery.h b/src/Interpreters/InterpreterDropQuery.h
index 0e1fd47b079..fe5362985de 100644
--- a/src/Interpreters/InterpreterDropQuery.h
+++ b/src/Interpreters/InterpreterDropQuery.h
@@ -29,9 +29,13 @@ private:
     ASTPtr query_ptr;
     Context & context;
 
-    BlockIO executeToDatabase(const String & database_name, ASTDropQuery::Kind kind, bool if_exists, bool no_delay);
+    BlockIO executeToDatabase(const ASTDropQuery & query);
+    BlockIO executeToDatabaseImpl(const ASTDropQuery & query, DatabasePtr & database, std::vector<UUID> & uuids_to_wait);
 
     BlockIO executeToTable(const ASTDropQuery & query);
+    BlockIO executeToTableImpl(const ASTDropQuery & query, DatabasePtr & db, UUID & uuid_to_wait);
+
+    static void waitForTableToBeActuallyDroppedOrDetached(const ASTDropQuery & query, const DatabasePtr & db, const UUID & uuid_to_wait);
 
     BlockIO executeToDictionary(const String & database_name, const String & dictionary_name, ASTDropQuery::Kind kind, bool if_exists, bool is_temporary, bool no_ddl_lock);
 
diff --git a/tests/queries/0_stateless/01193_metadata_loading.sh b/tests/queries/0_stateless/01193_metadata_loading.sh
index 0ee583a7265..319b537e84b 100755
--- a/tests/queries/0_stateless/01193_metadata_loading.sh
+++ b/tests/queries/0_stateless/01193_metadata_loading.sh
@@ -49,4 +49,4 @@ $CLICKHOUSE_CLIENT -q "SELECT if(quantile(0.5)(query_duration_ms) < $max_time_ms
 
 $CLICKHOUSE_CLIENT -q "SELECT count() * $count_multiplier, i, d, s, n.i, n.f FROM $db.table_merge GROUP BY i, d, s, n.i, n.f ORDER BY i"
 
-$CLICKHOUSE_CLIENT -q "DROP DATABASE $db"
+$CLICKHOUSE_CLIENT -q "DROP DATABASE $db" --database_atomic_wait_for_drop_and_detach_synchronously=0