ddl: Fix exchange partition impl

dbms/src/Databases/DatabaseTiFlash.cpp

@@ -32,6 +32,7 @@
 #include <Storages/IManageableStorage.h>
 #include <Storages/KVStore/TMTContext.h>
 #include <Storages/KVStore/TMTStorages.h>
+#include <TiDB/Schema/TiDB.h>
 #include <common/logger_useful.h>
 
 namespace DB
@@ -610,7 +611,7 @@ void DatabaseTiFlash::shutdown()
     tables.clear();
 }
 
-void DatabaseTiFlash::alterTombstone(const Context & context, Timestamp tombstone_)
+void DatabaseTiFlash::alterTombstone(const Context & context, Timestamp tombstone_, const TiDB::DBInfoPtr & new_db_info)
 {
     const auto database_metadata_path = getDatabaseMetadataPath(metadata_path);
     const auto database_metadata_tmp_path = database_metadata_path + ".tmp";
@@ -622,7 +623,18 @@ void DatabaseTiFlash::alterTombstone(const Context & context, Timestamp tombston
 
     {
         // Alter the attach statement in metadata.
-        auto dbinfo_literal = std::make_shared<ASTLiteral>(Field(db_info == nullptr ? "" : (db_info->serialize())));
+        std::shared_ptr<ASTLiteral> dbinfo_literal = [&]() {
+            String seri_info;
+            if (new_db_info != nullptr)
+            {
+                seri_info = new_db_info->serialize();
+            }
+            else if (db_info != nullptr)
+            {
+                seri_info = db_info->serialize();
+            }
+            return std::make_shared<ASTLiteral>(Field(seri_info));
+        }();
         Field format_version_field(static_cast<UInt64>(DatabaseTiFlash::CURRENT_VERSION));
         auto version_literal = std::make_shared<ASTLiteral>(format_version_field);
         auto tombstone_literal = std::make_shared<ASTLiteral>(Field(tombstone_));
@@ -651,6 +663,9 @@ void DatabaseTiFlash::alterTombstone(const Context & context, Timestamp tombston
         }
         else
         {
+            // update the seri dbinfo
+            args.children[0] = dbinfo_literal;
+            args.children[1] = version_literal;
             // udpate the tombstone mark
             args.children[2] = tombstone_literal;
         }

dbms/src/Databases/DatabaseTiFlash.h

@@ -89,7 +89,7 @@ class DatabaseTiFlash : public DatabaseWithOwnTablesBase
 
     bool isTombstone() const override { return tombstone != 0; }
     Timestamp getTombstone() const override { return tombstone; }
-    void alterTombstone(const Context & context, Timestamp tombstone_) override;
+    void alterTombstone(const Context & context, Timestamp tombstone_, const TiDB::DBInfoPtr & new_db_info) override;
 
     void drop(const Context & context) override;
 

dbms/src/Databases/IDatabase.h

@@ -24,6 +24,11 @@
 #include <functional>
 #include <memory>
 
+namespace TiDB
+{
+struct DBInfo;
+using DBInfoPtr = std::shared_ptr<DBInfo>;
+} // namespace TiDB
 
 namespace DB
 {
@@ -144,7 +149,11 @@ class IDatabase : public std::enable_shared_from_this<IDatabase>
 
     virtual bool isTombstone() const { return false; }
     virtual Timestamp getTombstone() const { return 0; }
-    virtual void alterTombstone(const Context & /*context*/, Timestamp /*tombstone_*/) {}
+    virtual void alterTombstone(
+        const Context & /*context*/,
+        Timestamp /*tombstone_*/,
+        const TiDB::DBInfoPtr & /*new_db_info*/)
+    {}
 
     /// Delete metadata, the deletion of which differs from the recursive deletion of the directory, if any.
     virtual void drop(const Context & context) = 0;

dbms/src/Databases/test/gtest_database.cpp

@@ -28,10 +28,12 @@
 #include <Storages/IStorage.h>
 #include <Storages/KVStore/TMTContext.h>
 #include <Storages/KVStore/TMTStorages.h>
+#include <Storages/KVStore/Types.h>
 #include <Storages/MutableSupport.h>
 #include <Storages/registerStorages.h>
 #include <TestUtils/TiFlashTestBasic.h>
 #include <TiDB/Schema/SchemaNameMapper.h>
+#include <TiDB/Schema/TiDB.h>
 #include <common/logger_useful.h>
 
 #include <optional>
@@ -968,7 +970,7 @@ try
         LOG_DEBUG(log, "After create [meta={}]", meta);
 
         DB::Timestamp tso = 1000;
-        db->alterTombstone(*ctx, tso);
+        db->alterTombstone(*ctx, tso, nullptr);
         EXPECT_TRUE(db->isTombstone());
         EXPECT_EQ(db->getTombstone(), tso);
 
@@ -977,8 +979,11 @@ try
         EXPECT_TRUE(db->isTombstone());
         EXPECT_EQ(db->getTombstone(), tso);
 
-        // Recover
-        db->alterTombstone(*ctx, 0);
+        // Recover, usually recover with a new database name
+        auto new_db_info = std::make_shared<TiDB::DBInfo>(
+            R"json({"charset":"utf8mb4","collate":"utf8mb4_bin","db_name":{"L":"test_new_db","O":"test_db"},"id":1010,"state":5})json",
+            NullspaceID);
+        db->alterTombstone(*ctx, 0, new_db_info);
         EXPECT_FALSE(db->isTombstone());
 
         // Try restore from disk

dbms/src/Debug/MockSchemaGetter.h

@@ -39,6 +39,11 @@ struct MockSchemaGetter
         return MockTiDB::instance().getTableInfoByID(table_id);
     }
 
+    static std::pair<TiDB::TableInfoPtr, bool> getTableInfoAndCheckMvcc(DatabaseID db_id, TableID table_id)
+    {
+        return {getTableInfo(db_id, table_id), false};
+    }
+
     static std::tuple<TiDB::DBInfoPtr, TiDB::TableInfoPtr> getDatabaseAndTableInfo(DatabaseID db_id, TableID table_id)
     {
         return std::make_tuple(getDatabase(db_id), getTableInfo(db_id, table_id));

dbms/src/Storages/DeltaMerge/StoragePool.cpp

@@ -799,7 +799,7 @@ PageStorageRunMode StoragePool::restore()
         logger,
         "Finished StoragePool restore. [current_run_mode={}] [ns_id={}]"
         " [max_log_page_id={}] [max_data_page_id={}] [max_meta_page_id={}]",
-        static_cast<UInt8>(run_mode),
+        magic_enum::enum_name(run_mode),
         ns_id,
         max_log_page_id,
         max_data_page_id,

dbms/src/Storages/tests/gtest_filter_parser.cpp

@@ -29,7 +29,6 @@
 #include <Storages/DeltaMerge/Index/RSResult.h>
 #include <Storages/KVStore/TMTContext.h>
 #include <TestUtils/TiFlashTestBasic.h>
-#include <TiDB/Schema/SchemaBuilder-internal.h>
 #include <TiDB/Schema/SchemaNameMapper.h>
 #include <common/logger_useful.h>
 

dbms/src/Storages/tests/gtests_parse_push_down_filter.cpp

@@ -25,7 +25,6 @@
 #include <Storages/StorageDeltaMerge.h>
 #include <TestUtils/FunctionTestUtils.h>
 #include <TestUtils/TiFlashTestBasic.h>
-#include <TiDB/Schema/SchemaBuilder-internal.h>
 #include <common/logger_useful.h>
 
 #include <regex>

dbms/src/TiDB/Schema/DatabaseInfoCache.h

@@ -0,0 +1,79 @@
+// Copyright 2023 PingCAP, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include <Storages/KVStore/Types.h>
+#include <TiDB/Schema/TiDB.h>
+
+#include <shared_mutex>
+#include <unordered_map>
+
+namespace DB
+{
+
+class DatabaseInfoCache
+{
+public:
+    TiDB::DBInfoPtr getDBInfoByName(const String & database_name) const
+    {
+        std::shared_lock lock(mtx_databases);
+
+        auto it = std::find_if(databases.begin(), databases.end(), [&](const auto & pair) {
+            return pair.second->name == database_name;
+        });
+        if (it == databases.end())
+            return nullptr;
+        return it->second;
+    }
+
+    void addDatabaseInfo(const TiDB::DBInfoPtr & db_info)
+    {
+        std::unique_lock lock(mtx_databases);
+        databases.emplace(db_info->id, db_info);
+    }
+
+    TiDB::DBInfoPtr getDBInfo(DatabaseID database_id) const
+    {
+        std::shared_lock shared_lock(mtx_databases);
+        if (auto it = databases.find(database_id); likely(it != databases.end()))
+        {
+            return it->second;
+        }
+        return nullptr;
+    }
+
+    bool exists(DatabaseID database_id) const
+    {
+        std::shared_lock shared_lock(mtx_databases);
+        return databases.contains(database_id);
+    }
+
+    void eraseDBInfo(DatabaseID database_id)
+    {
+        std::unique_lock shared_lock(mtx_databases);
+        databases.erase(database_id);
+    }
+
+    void clear()
+    {
+        std::unique_lock lock(mtx_databases);
+        databases.clear();
+    }
+
+private:
+    mutable std::shared_mutex mtx_databases;
+    std::unordered_map<DB::DatabaseID, TiDB::DBInfoPtr> databases;
+};
+} // namespace DB