Storage: Fix DataTypePtr is not shared as expected (#9939) (#10305)

close #9947

Storage: Fix DataTypePtr is not shared as expected
* Introduce a class `DataTypePtrCache` and manage the shared cache of `DataTypePtr` instances.
* Introduce `DataTypeFactory::getOrSet(const ASTPtr & ast)` and try to find the cache with data type name as "ast->range.first, ast->range.second"
logging: Turn the logging level of "updateTableColumnInfo" into debug because that could cause lots of logging when restarting tiflash

Signed-off-by: ti-chi-bot <[email protected]>
Signed-off-by: JaySon-Huang <[email protected]>

Co-authored-by: JaySon <[email protected]>
Co-authored-by: JaySon-Huang <[email protected]>

Author: ti-chi-bot

dbms/src/DataTypes/DataTypeFactory.cpp

@@ -34,46 +34,63 @@ extern const int DATA_TYPE_CANNOT_HAVE_ARGUMENTS;
 } // namespace ErrorCodes
 
 
-DataTypePtr DataTypeFactory::get(const String & full_name) const
+DataTypePtr DataTypePtrCache::get(const String & full_name) const
 {
-    ParserIdentifierWithOptionalParameters parser;
-    ASTPtr ast = parseQuery(parser, full_name.data(), full_name.data() + full_name.size(), "data type", 0);
-    return get(ast);
+    std::shared_lock lock(rw_lock);
+    if (auto it = cached_types.find(full_name); //
+        it != cached_types.end())
+        return it->second;
+    return nullptr;
 }
-// DataTypeFactory is a Singleton, so need to be protected by lock.
-DataTypePtr DataTypeFactory::getOrSet(const String & full_name)
+
+void DataTypePtrCache::tryCache(const String & full_name, const DataTypePtr & datatype_ptr)
 {
-    {
-        std::shared_lock lock(rw_lock);
-        auto it = fullname_types.find(full_name);
-        if (it != fullname_types.end())
-        {
-            return it->second;
-        }
-    }
-    ParserIdentifierWithOptionalParameters parser;
-    ASTPtr ast = parseQuery(parser, full_name.data(), full_name.data() + full_name.size(), "data type", 0);
-    DataTypePtr datatype_ptr = get(ast);
-    // avoid big hashmap in rare cases.
+    // It can not handle the situation that DataTypePtr sharing between
+    // "Enum16('N' = 1, 'Y' = 2)" and "Enum16('Y' = 2, 'N' = 1)", but should
+    // be good enough.
+    // Avoid big hashmap in rare cases.
     std::unique_lock lock(rw_lock);
-    if (fullname_types.size() < MAX_FULLNAME_TYPES)
+    if (cached_types.size() < MAX_FULLNAME_TYPES)
     {
         // DataTypeEnum may generate too many full_name, so just skip inserting DataTypeEnum into fullname_types when
         // the capacity limit is almost reached, which ensures that most datatypes can be cached.
-        if (fullname_types.size() > FULLNAME_TYPES_HIGH_WATER_MARK
+        if (cached_types.size() > FULLNAME_TYPES_HIGH_WATER_MARK
             && (datatype_ptr->getTypeId() == TypeIndex::Enum8 || datatype_ptr->getTypeId() == TypeIndex::Enum16))
         {
-            return datatype_ptr;
+            return;
         }
-        fullname_types.emplace(full_name, datatype_ptr);
+        cached_types.emplace(full_name, datatype_ptr);
     }
+}
+
+DataTypePtr DataTypeFactory::get(const String & full_name) const
+{
+    ParserIdentifierWithOptionalParameters parser;
+    ASTPtr ast = parseQuery(parser, full_name.data(), full_name.data() + full_name.size(), "data type", 0);
+    return get(ast);
+}
+
+DataTypePtr DataTypeFactory::getOrSet(const ASTPtr & ast)
+{
+    String owned_str_full_name(ast->range.first, ast->range.second);
+    if (auto cached_ptr = fullname_types.get(owned_str_full_name); cached_ptr != nullptr)
+        return cached_ptr;
+
+    auto datatype_ptr = get(ast);
+    fullname_types.tryCache(owned_str_full_name, datatype_ptr);
     return datatype_ptr;
 }
 
-size_t DataTypeFactory::getFullNameCacheSize() const
+DataTypePtr DataTypeFactory::getOrSet(const String & full_name)
 {
-    std::shared_lock lock(rw_lock);
-    return fullname_types.size();
+    if (auto cached_ptr = fullname_types.get(full_name); cached_ptr != nullptr)
+        return cached_ptr;
+
+    ParserIdentifierWithOptionalParameters parser;
+    ASTPtr ast = parseQuery(parser, full_name.data(), full_name.data() + full_name.size(), "data type", 0);
+    auto datatype_ptr = get(ast);
+    fullname_types.tryCache(full_name, datatype_ptr);
+    return datatype_ptr;
 }
 
 DataTypePtr DataTypeFactory::get(const ASTPtr & ast) const
@@ -116,7 +133,7 @@ DataTypePtr DataTypeFactory::get(const String & family_name, const ASTPtr & para
             return it->second(parameters);
     }
 
-    throw Exception("Unknown data type family: " + family_name, ErrorCodes::UNKNOWN_TYPE);
+    throw Exception(ErrorCodes::UNKNOWN_TYPE, "Unknown data type family: {}", family_name);
 }
 
 
@@ -127,21 +144,23 @@ void DataTypeFactory::registerDataType(
 {
     if (creator == nullptr)
         throw Exception(
-            "DataTypeFactory: the data type family " + family_name + " has been provided a null constructor",
-            ErrorCodes::LOGICAL_ERROR);
+            ErrorCodes::LOGICAL_ERROR,
+            "DataTypeFactory: the data type family {} has been provided a null constructor",
+            family_name);
 
     if (!data_types.emplace(family_name, creator).second)
         throw Exception(
-            "DataTypeFactory: the data type family name '" + family_name + "' is not unique",
-            ErrorCodes::LOGICAL_ERROR);
+            ErrorCodes::LOGICAL_ERROR,
+            "DataTypeFactory: the data type family name '{}' is not unique",
+            family_name);
 
     String family_name_lowercase = Poco::toLower(family_name);
-
     if (case_sensitiveness == CaseInsensitive
         && !case_insensitive_data_types.emplace(family_name_lowercase, creator).second)
         throw Exception(
-            "DataTypeFactory: the case insensitive data type family name '" + family_name + "' is not unique",
-            ErrorCodes::LOGICAL_ERROR);
+            ErrorCodes::LOGICAL_ERROR,
+            "DataTypeFactory: the case insensitive data type family name '{}' is not unique",
+            family_name);
 }
 
 
@@ -152,16 +171,18 @@ void DataTypeFactory::registerSimpleDataType(
 {
     if (creator == nullptr)
         throw Exception(
-            "DataTypeFactory: the data type " + name + " has been provided a null constructor",
-            ErrorCodes::LOGICAL_ERROR);
+            ErrorCodes::LOGICAL_ERROR,
+            "DataTypeFactory: the data type {} has been provided a null constructor",
+            name);
 
     registerDataType(
         name,
         [name, creator](const ASTPtr & ast) {
             if (ast)
                 throw Exception(
-                    "Data type " + name + " cannot have arguments",
-                    ErrorCodes::DATA_TYPE_CANNOT_HAVE_ARGUMENTS);
+                    ErrorCodes::DATA_TYPE_CANNOT_HAVE_ARGUMENTS,
+                    "Data type {} cannot have arguments",
+                    name);
             return creator();
         },
         case_sensitiveness);

dbms/src/DataTypes/DataTypeFactory.h

@@ -30,6 +30,29 @@ using DataTypePtr = std::shared_ptr<const IDataType>;
 class IAST;
 using ASTPtr = std::shared_ptr<IAST>;
 
+// When there are lots of tables created, the DataTypePtr could consume lots of
+// memory (tiflash#9947), or lots of CPU time to parse the string into IAST and
+// create the datatype (tiflash#6395). So we make a cache of FullName to
+// DataTypePtr in order to reuse the same DataTypePtr.
+class DataTypePtrCache
+{
+public:
+    DataTypePtr get(const String & full_name) const;
+    void tryCache(const String & full_name, const DataTypePtr & datatype_ptr);
+    size_t getFullNameCacheSize() const
+    {
+        std::shared_lock lock(rw_lock);
+        return cached_types.size();
+    }
+
+private:
+    // full_name -> DataTypePtr
+    using FullnameTypes = std::unordered_map<String, DataTypePtr>;
+    static constexpr int MAX_FULLNAME_TYPES = 50000;
+    static constexpr int FULLNAME_TYPES_HIGH_WATER_MARK = 49000;
+    mutable std::shared_mutex rw_lock;
+    FullnameTypes cached_types;
+};
 
 /** Creates a data type by name of data type family and parameters.
   */
@@ -40,16 +63,15 @@ class DataTypeFactory final : public ext::Singleton<DataTypeFactory>
     using SimpleCreator = std::function<DataTypePtr()>;
     // family_name -> Creator
     using DataTypesDictionary = std::unordered_map<String, Creator>;
-    // full_name -> DataTypePtr
-    using FullnameTypes = std::unordered_map<String, DataTypePtr>;
 
 public:
     DataTypePtr get(const String & full_name) const;
     // In order to optimize the speed of generating data type instances, this will cache the full_name -> DataTypePtr.
     DataTypePtr getOrSet(const String & full_name);
+    DataTypePtr getOrSet(const ASTPtr & ast);
     DataTypePtr get(const String & family_name, const ASTPtr & parameters) const;
     DataTypePtr get(const ASTPtr & ast) const;
-    size_t getFullNameCacheSize() const;
+    size_t getFullNameCacheSize() const { return fullname_types.getFullNameCacheSize(); }
 
     /// For compatibility with SQL, it's possible to specify that certain data type name is case insensitive.
     enum CaseSensitiveness
@@ -76,10 +98,8 @@ class DataTypeFactory final : public ext::Singleton<DataTypeFactory>
     /// Case insensitive data types will be additionally added here with lowercased name.
     DataTypesDictionary case_insensitive_data_types;
 
-    static constexpr int MAX_FULLNAME_TYPES = 50000;
-    static constexpr int FULLNAME_TYPES_HIGH_WATER_MARK = 49000;
-    mutable std::shared_mutex rw_lock;
-    FullnameTypes fullname_types;
+    DataTypePtrCache fullname_types;
+
     DataTypeFactory();
     friend class ext::Singleton<DataTypeFactory>;
 };

dbms/src/DataTypes/tests/gtest_data_type_get_common_type.cpp

@@ -16,7 +16,13 @@
 #include <DataTypes/getLeastSupertype.h>
 #include <DataTypes/getMostSubtype.h>
 #include <DataTypes/isSupportedDataTypeCast.h>
+#include <Interpreters/InterpreterCreateQuery.h>
+#include <Parsers/ASTCreateQuery.h>
+#include <Parsers/ParserCreateQuery.h>
+#include <Parsers/parseQuery.h>
+#include <Storages/ColumnsDescription.h>
 #include <TestUtils/TiFlashTestBasic.h>
+#include <TestUtils/TiFlashTestEnv.h>
 
 #include <sstream>
 
@@ -333,5 +339,78 @@ try
 }
 CATCH
 
+TEST(DataTypeTest, ParseColumns)
+{
+    std::string table_def = R"(ATTACH TABLE ks_133501_t_10
+(
+    s_0 String, 
+    s_1 String, 
+    s_2 String, 
+    e_0 Enum16('N' = 1, 'Y' = 2), 
+    e_1 Enum16('N' = 1, 'Y' = 2), 
+    e_2 Enum16('N' = 1, 'Y' = 2), 
+    e_3 Enum16('N' = 1, 'Y' = 2), 
+    e_4 Enum16('N' = 1, 'Y' = 2), 
+    e_5 Enum16('N' = 1, 'Y' = 2), 
+    e_6 Enum16('N' = 1, 'Y' = 2), 
+    e_7 Enum16('N' = 1, 'Y' = 2), 
+    e_8 Enum16('N' = 1, 'Y' = 2), 
+    e_9 Enum16('N' = 1, 'Y' = 2), 
+    e_10 Enum16('N' = 1, 'Y' = 2), 
+    e_11 Enum16('N' = 1, 'Y' = 2), 
+    e_12 Enum16('N' = 1, 'Y' = 2), 
+    e_13 Enum16('N' = 1, 'Y' = 2), 
+    e_14 Enum16('N' = 1, 'Y' = 2), 
+    e_15 Enum16('N' = 1, 'Y' = 2), 
+    e_16 Enum16('N' = 1, 'Y' = 2), 
+    e_17 Enum16('N' = 1, 'Y' = 2), 
+    e_18 Enum16('N' = 1, 'Y' = 2), 
+    _tidb_rowid Int64
+)
+ENGINE = DeltaMerge(_tidb_rowid, '{"cols":[{"id":1,"name":{"L":"s_0","O":"s_0"},"offset":0,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Flag":4099,"Flen":255,"Tp":254}},{"id":2,"name":{"L":"s_1","O":"s_1"},"offset":1,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Flag":4099,"Flen":64,"Tp":254}},{"id":3,"name":{"L":"s_2","O":"s_2"},"offset":2,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Flag":4099,"Flen":32,"Tp":254}},{"default":"N","default_bit":null,"id":4,"name":{"L":"e_0","O":"e_0"},"offset":3,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":5,"name":{"L":"e_1","O":"e_1"},"offset":4,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":6,"name":{"L":"e_2","O":"e_2"},"offset":5,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":7,"name":{"L":"e_3","O":"e_3"},"offset":6,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":8,"name":{"L":"e_4","O":"e_4"},"offset":7,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":9,"name":{"L":"e_5","O":"e_5"},"offset":8,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":10,"name":{"L":"e_6","O":"e_6"},"offset":9,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":11,"name":{"L":"e_7","O":"e_7"},"offset":10,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":12,"name":{"L":"e_8","O":"e_8"},"offset":11,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":13,"name":{"L":"e_9","O":"e_9"},"offset":12,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":14,"name":{"L":"e_10","O":"e_10"},"offset":13,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":15,"name":{"L":"e_11","O":"e_11"},"offset":14,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":16,"name":{"L":"e_12","O":"e_12"},"offset":15,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":17,"name":{"L":"e_13","O":"e_13"},"offset":16,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":18,"name":{"L":"e_14","O":"e_14"},"offset":17,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":19,"name":{"L":"e_15","O":"e_15"},"offset":18,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":20,"name":{"L":"e_16","O":"e_16"},"offset":19,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":21,"name":{"L":"e_17","O":"e_17"},"offset":20,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}},{"default":"N","default_bit":null,"id":22,"name":{"L":"e_18","O":"e_18"},"offset":21,"state":5,"type":{"Charset":"utf8mb4","Collate":"utf8mb4_bin","Decimal":0,"Elems":["N","Y"],"Flag":1,"Flen":1,"Tp":247}}],"id":10,"index_info":[{"id":1,"idx_cols":[{"length":-1,"name":{"L":"s_0","O":"s_0"},"offset":0},{"length":-1,"name":{"L":"s_1","O":"s_1"},"offset":1},{"length":-1,"name":{"L":"s_2","O":"s_2"},"offset":2}],"idx_name":{"L":"primary","O":"primary"},"index_type":1,"is_global":false,"is_invisible":false,"is_primary":true,"is_unique":true,"state":5}],"is_common_handle":false,"keyspace_id":133501,"name":{"L":"s_1","O":"s_1"},"partition":null,"pk_is_handle":false,"schema_version":-1,"state":5,"tiflash_replica":{"Count":0},"update_timestamp":456193504796999692}', 0))";
+
+    auto & global_context = TiFlashTestEnv::getGlobalContext();
+
+    std::vector<ColumnsDescription> parsed_columns;
+    for (size_t i = 0; i < 1000; ++i)
+    {
+        ParserCreateQuery parser;
+        ASTPtr ast = parseQuery(parser, table_def.data(), table_def.data() + table_def.size(), "", 0);
+        ASTCreateQuery & ast_create_query = typeid_cast<ASTCreateQuery &>(*ast);
+        ColumnsDescription columns
+            = InterpreterCreateQuery::getColumnsDescription(*ast_create_query.columns, global_context);
+        parsed_columns.emplace_back(columns);
+    }
+    ASSERT_EQ(parsed_columns.size(), 1000);
+
+    auto str_type_ptr = parsed_columns[0].getAll().filter(Names{"s_0"}).begin()->type;
+    auto enum_type_ptr = parsed_columns[0].getAll().filter(Names{"e_0"}).begin()->type;
+    for (size_t i = 1; i < parsed_columns.size(); ++i)
+    {
+        auto enum_cols = parsed_columns[i].getAll().filter(Names{
+            "e_0",  "e_1",  "e_2",  "e_3",  "e_4",  "e_5",  "e_6",  "e_7",  "e_8",  "e_9",
+            "e_10", "e_11", "e_12", "e_13", "e_14", "e_15", "e_16", "e_17", "e_18",
+        });
+        ASSERT_EQ(enum_cols.size(), 19);
+        for (const auto & col : enum_cols)
+        {
+            ASSERT_TRUE(col.type->equals(*enum_type_ptr));
+            // they must share the same ptr, otherwise the memory consumption is too high when there are
+            // many columns with the same type
+            ASSERT_EQ(col.type.get(), enum_type_ptr.get());
+        }
+
+        auto str_cols = parsed_columns[i].getAll().filter(Names{"s_0", "s_1", "s_2"});
+        ASSERT_EQ(str_cols.size(), 3);
+        for (const auto & col : str_cols)
+        {
+            ASSERT_TRUE(col.type->equals(*str_type_ptr));
+            // they must share the same ptr, otherwise the memory consumption is too high when there are
+            // many columns with the same type
+            ASSERT_EQ(col.type.get(), str_type_ptr.get());
+        }
+    }
+}
+
 } // namespace tests
 } // namespace DB

dbms/src/Interpreters/InterpreterCreateQuery.cpp

@@ -219,7 +219,7 @@ static ColumnsAndDefaults parseColumns(const ASTExpressionList & column_list_ast
 
         if (col_decl.type)
         {
-            columns.emplace_back(col_decl.name, DataTypeFactory::instance().get(col_decl.type));
+            columns.emplace_back(col_decl.name, DataTypeFactory::instance().getOrSet(col_decl.type));
         }
         else
             /// we're creating dummy DataTypeUInt8 in order to prevent the NullPointerException in ExpressionActions
@@ -295,7 +295,8 @@ static ColumnsAndDefaults parseColumns(const ASTExpressionList & column_list_ast
                 column_name,
                 ColumnDefault{
                     columnDefaultKindFromString(col_decl_ptr->default_specifier),
-                    col_decl_ptr->default_expression});
+                    col_decl_ptr->default_expression,
+                });
         }
     }
 

dbms/src/Parsers/StringRange.h

@@ -17,7 +17,6 @@
 #include <Core/Types.h>
 #include <Parsers/TokenIterator.h>
 
-#include <map>
 #include <memory>
 
 
@@ -29,7 +28,7 @@ struct StringRange
     const char * first = nullptr;
     const char * second = nullptr;
 
-    StringRange() {}
+    StringRange() = default;
     StringRange(const char * begin, const char * end)
         : first(begin)
         , second(end)

dbms/src/Storages/DeltaMerge/tests/gtest_key_range.cpp

@@ -173,11 +173,11 @@ TEST(RowKey, ToNextKeyIntHandle)
         EXPECT_EQ(0, compare(next.toRowKeyValueRef(), range.getEnd()));
         EXPECT_EQ(range.getEnd().toDebugString(), "21");
     }
-    // any suffix will be regarded as Key=21 in RowKeyRange::fromRegionRange.
+    // any non-empty suffix will be regarded as Key=21 in RowKeyRange::fromRegionRange.
     {
         auto key_end = RecordKVFormat::genRawKey(table_id, 20);
         std::mt19937_64 rand_gen(std::random_device{}());
-        size_t rand_length = rand_gen() % 255;
+        size_t rand_length = std::min(1, rand_gen() % 255); // ensure rand_length is at least 1
         auto rand_suffix = DB::random::randomString(rand_length);
         key_end.insert(key_end.end(), rand_suffix.begin(), rand_suffix.end());
         LOG_INFO(

dbms/src/Storages/StorageDeltaMerge.cpp

@@ -126,7 +126,7 @@ void StorageDeltaMerge::updateTableColumnInfo()
 {
     const ColumnsDescription & columns = getColumns();
 
-    LOG_INFO(
+    LOG_DEBUG(
         log,
         "updateTableColumnInfo, table_name={} ordinary=\"{}\" materialized=\"{}\"",
         table_column_info->table_name,
@@ -231,6 +231,7 @@ void StorageDeltaMerge::updateTableColumnInfo()
         }
         table_column_defines.push_back(col_def);
     }
+    table_column_defines.shrink_to_fit();
 
     if (!new_columns.materialized.contains(VERSION_COLUMN_NAME))
     {