vesoft-inc · critical27 · Jan 26, 2022 · Jan 25, 2022
diff --git a/src/clients/meta/MetaClient.cpp b/src/clients/meta/MetaClient.cpp
@@ -340,32 +340,20 @@ bool MetaClient::loadSchemas(GraphSpaceID spaceId,
   EdgeSchemas edgeSchemas;
   TagID lastTagId = -1;
 
-  auto addSchemaField = [&spaceInfoCache](NebulaSchemaProvider* schema,
-                                          const cpp2::ColumnDef& col) {
+  auto addSchemaField = [](NebulaSchemaProvider* schema, const cpp2::ColumnDef& col) {
     bool hasDef = col.default_value_ref().has_value();
     auto& colType = col.get_type();
     size_t len = colType.type_length_ref().has_value() ? *colType.get_type_length() : 0;
     cpp2::GeoShape geoShape =
         colType.geo_shape_ref().has_value() ? *colType.get_geo_shape() : cpp2::GeoShape::ANY;
     bool nullable = col.nullable_ref().has_value() ? *col.get_nullable() : false;
-    Expression* defaultValueExpr = nullptr;
+    std::string defaultValueExprStr = "";
     if (hasDef) {
-      auto encoded = *col.get_default_value();
-      defaultValueExpr = Expression::decode(&(spaceInfoCache->pool_),
-                                            folly::StringPiece(encoded.data(), encoded.size()));
-
-      if (defaultValueExpr == nullptr) {
-        LOG(ERROR) << "Wrong expr default value for column name: " << col.get_name();
-        hasDef = false;
-      }
+      defaultValueExprStr = *col.get_default_value();
     }
 
-    schema->addField(col.get_name(),
-                     colType.get_type(),
-                     len,
-                     nullable,
-                     hasDef ? defaultValueExpr : nullptr,
-                     geoShape);
+    schema->addField(
+        col.get_name(), colType.get_type(), len, nullable, defaultValueExprStr, geoShape);
   };
 
   for (auto& tagIt : tagItemVec) {

diff --git a/src/clients/meta/MetaClient.h b/src/clients/meta/MetaClient.h
@@ -79,8 +79,6 @@ struct SpaceInfoCache {
   Indexes tagIndexes_;
   Indexes edgeIndexes_;
   Listeners listeners_;
-  // objPool used to decode when adding field
-  ObjectPool pool_;
   std::unordered_map<PartitionID, TermID> termOfPartition_;
 };
 

diff --git a/src/codec/RowWriterV2.cpp b/src/codec/RowWriterV2.cpp
@@ -783,7 +783,9 @@ WriteResult RowWriterV2::checkUnsetFields() noexcept {
 
       WriteResult r = WriteResult::SUCCEEDED;
       if (field->hasDefault()) {
-        auto expr = field->defaultValue()->clone();
+        ObjectPool pool;
+        auto& exprStr = field->defaultValue();
+        auto expr = Expression::decode(&pool, folly::StringPiece(exprStr.data(), exprStr.size()));
         auto defVal = Expression::eval(expr, expCtx);
         switch (defVal.type()) {
           case Value::Type::NULLVALUE:
@@ -816,7 +818,7 @@ WriteResult RowWriterV2::checkUnsetFields() noexcept {
           default:
             LOG(FATAL) << "Unsupported default value type: " << defVal.typeName()
                        << ", default value: " << defVal
-                       << ", default value expr: " << field->defaultValue()->toString();
+                       << ", default value expr: " << field->defaultValue();
         }
       } else {
         // Set NULL

diff --git a/src/codec/test/ResultSchemaProvider.cpp b/src/codec/test/ResultSchemaProvider.cpp
@@ -22,7 +22,7 @@ ResultSchemaProvider::ResultSchemaField::ResultSchemaField(std::string name,
                                                            bool nullable,
                                                            int32_t offset,
                                                            size_t nullFlagPos,
-                                                           Expression* defaultValue,
+                                                           std::string defaultValue,
                                                            meta::cpp2::GeoShape geoShape)
     : name_(std::move(name)),
       type_(type),
@@ -37,13 +37,13 @@ const char* ResultSchemaProvider::ResultSchemaField::name() const { return name_
 
 PropertyType ResultSchemaProvider::ResultSchemaField::type() const { return type_; }
 
-bool ResultSchemaProvider::ResultSchemaField::hasDefault() const {
-  return defaultValue_ != nullptr;
-}
+bool ResultSchemaProvider::ResultSchemaField::hasDefault() const { return defaultValue_ != ""; }
 
 bool ResultSchemaProvider::ResultSchemaField::nullable() const { return nullable_; }
 
-Expression* ResultSchemaProvider::ResultSchemaField::defaultValue() const { return defaultValue_; }
+const std::string& ResultSchemaProvider::ResultSchemaField::defaultValue() const {
+  return defaultValue_;
+}
 
 size_t ResultSchemaProvider::ResultSchemaField::size() const { return size_; }
 

diff --git a/src/codec/test/ResultSchemaProvider.h b/src/codec/test/ResultSchemaProvider.h
@@ -21,14 +21,14 @@ class ResultSchemaProvider : public meta::SchemaProviderIf {
                                bool nullable,
                                int32_t offset,
                                size_t nullFlagPos,
-                               Expression* defaultValue = nullptr,
+                               std::string defaultValue = "",
                                meta::cpp2::GeoShape = meta::cpp2::GeoShape::ANY);
 
     const char* name() const override;
     meta::cpp2::PropertyType type() const override;
     bool nullable() const override;
     bool hasDefault() const override;
-    Expression* defaultValue() const override;
+    const std::string& defaultValue() const override;
     size_t size() const override;
     size_t offset() const override;
     size_t nullFlagPos() const override;
@@ -41,7 +41,7 @@ class ResultSchemaProvider : public meta::SchemaProviderIf {
     bool nullable_;
     int32_t offset_;
     size_t nullFlagPos_;
-    Expression* defaultValue_;
+    std::string defaultValue_;
     meta::cpp2::GeoShape geoShape_;
   };
 

diff --git a/src/codec/test/SchemaWriter.cpp b/src/codec/test/SchemaWriter.cpp
@@ -87,8 +87,14 @@ SchemaWriter& SchemaWriter::appendCol(folly::StringPiece name,
     nullFlagPos = numNullableFields_++;
   }
 
-  columns_.emplace_back(
-      name.toString(), type, size, nullable, offset, nullFlagPos, defaultValue, geoShape);
+  columns_.emplace_back(name.toString(),
+                        type,
+                        size,
+                        nullable,
+                        offset,
+                        nullFlagPos,
+                        defaultValue ? defaultValue->encode() : "",
+                        geoShape);
   nameIndex_.emplace(std::make_pair(hash, columns_.size() - 1));
 
   return *this;

diff --git a/src/common/meta/NebulaSchemaProvider.cpp b/src/common/meta/NebulaSchemaProvider.cpp
@@ -90,7 +90,7 @@ void NebulaSchemaProvider::addField(folly::StringPiece name,
                                     cpp2::PropertyType type,
                                     size_t fixedStrLen,
                                     bool nullable,
-                                    Expression* defaultValue,
+                                    std::string defaultValue,
                                     cpp2::GeoShape geoShape) {
   size_t size = fieldSize(type, fixedStrLen);
 
@@ -108,7 +108,7 @@ void NebulaSchemaProvider::addField(folly::StringPiece name,
   fields_.emplace_back(name.toString(),
                        type,
                        nullable,
-                       defaultValue != nullptr,
+                       defaultValue != "",
                        defaultValue,
                        size,
                        offset,

diff --git a/src/common/meta/NebulaSchemaProvider.h b/src/common/meta/NebulaSchemaProvider.h
@@ -25,7 +25,7 @@ class NebulaSchemaProvider : public SchemaProviderIf {
                 cpp2::PropertyType type,
                 bool nullable,
                 bool hasDefault,
-                Expression* defaultValue,
+                std::string defaultValue,
                 size_t size,
                 size_t offset,
                 size_t nullFlagPos,
@@ -48,7 +48,7 @@ class NebulaSchemaProvider : public SchemaProviderIf {
 
     bool hasDefault() const override { return hasDefault_; }
 
-    Expression* defaultValue() const override { return defaultValue_; }
+    const std::string& defaultValue() const override { return defaultValue_; }
 
     size_t size() const override { return size_; }
 
@@ -66,7 +66,7 @@ class NebulaSchemaProvider : public SchemaProviderIf {
     cpp2::PropertyType type_;
     bool nullable_;
     bool hasDefault_;
-    Expression* defaultValue_;
+    std::string defaultValue_;
     size_t size_;
     size_t offset_;
     size_t nullFlagPos_;
@@ -97,7 +97,7 @@ class NebulaSchemaProvider : public SchemaProviderIf {
                 cpp2::PropertyType type,
                 size_t fixedStrLen = 0,
                 bool nullable = false,
-                Expression* defaultValue = nullptr,
+                std::string defaultValue = "",
                 cpp2::GeoShape geoShape = cpp2::GeoShape::ANY);
 
   static std::size_t fieldSize(cpp2::PropertyType type, std::size_t fixedStrLimit);

diff --git a/src/common/meta/SchemaProviderIf.h b/src/common/meta/SchemaProviderIf.h
@@ -24,7 +24,7 @@ class SchemaProviderIf {
     virtual cpp2::PropertyType type() const = 0;
     virtual bool nullable() const = 0;
     virtual bool hasDefault() const = 0;
-    virtual Expression* defaultValue() const = 0;
+    virtual const std::string& defaultValue() const = 0;
     // This method returns the number of bytes the field will occupy
     // when the field is persisted on the storage medium
     // For the variant length string, the size will return 8

diff --git a/src/graph/util/SchemaUtil.cpp b/src/graph/util/SchemaUtil.cpp
@@ -54,19 +54,19 @@ Status SchemaUtil::validateProps(const std::vector<SchemaPropItem *> &schemaProp
 
 // static
 std::shared_ptr<const meta::NebulaSchemaProvider> SchemaUtil::generateSchemaProvider(
-    ObjectPool *pool, const SchemaVer ver, const meta::cpp2::Schema &schema) {
+    const SchemaVer ver, const meta::cpp2::Schema &schema) {
   auto schemaPtr = std::make_shared<meta::NebulaSchemaProvider>(ver);
   for (auto col : schema.get_columns()) {
     bool hasDef = col.default_value_ref().has_value();
-    Expression *defaultValueExpr = nullptr;
+    std::string exprStr;
     if (hasDef) {
-      defaultValueExpr = Expression::decode(pool, *col.default_value_ref());
+      exprStr = *col.get_default_value();
     }
     schemaPtr->addField(col.get_name(),
                         col.get_type().get_type(),
                         col.type.type_length_ref().value_or(0),
                         col.nullable_ref().value_or(false),
-                        hasDef ? defaultValueExpr : nullptr,
+                        exprStr,
                         col.type.geo_shape_ref().value_or(meta::cpp2::GeoShape::ANY));
   }
   return schemaPtr;

diff --git a/src/graph/util/SchemaUtil.h b/src/graph/util/SchemaUtil.h
@@ -30,7 +30,7 @@ class SchemaUtil final {
                               meta::cpp2::Schema& schema);
 
   static std::shared_ptr<const meta::NebulaSchemaProvider> generateSchemaProvider(
-      ObjectPool* pool, const SchemaVer ver, const meta::cpp2::Schema& schema);
+      const SchemaVer ver, const meta::cpp2::Schema& schema);
 
   static Status setTTLDuration(SchemaPropItem* schemaProp, meta::cpp2::Schema& schema);
 

diff --git a/src/graph/validator/MaintainValidator.cpp b/src/graph/validator/MaintainValidator.cpp
@@ -154,8 +154,7 @@ Status CreateTagValidator::validateImpl() {
   NG_RETURN_IF_ERROR(validateColumns(sentence->columnSpecs(), schema));
   NG_RETURN_IF_ERROR(SchemaUtil::validateProps(sentence->getSchemaProps(), schema));
   // Save the schema in validateContext
-  auto pool = qctx_->objPool();
-  auto schemaPro = SchemaUtil::generateSchemaProvider(pool, 0, schema);
+  auto schemaPro = SchemaUtil::generateSchemaProvider(0, schema);
   vctx_->addSchema(name, schemaPro);
   createCtx_->name = std::move(name);
   createCtx_->schema = std::move(schema);
@@ -177,8 +176,7 @@ Status CreateEdgeValidator::validateImpl() {
   NG_RETURN_IF_ERROR(validateColumns(sentence->columnSpecs(), schema));
   NG_RETURN_IF_ERROR(SchemaUtil::validateProps(sentence->getSchemaProps(), schema));
   // Save the schema in validateContext
-  auto pool = qctx_->objPool();
-  auto schemaPro = SchemaUtil::generateSchemaProvider(pool, 0, schema);
+  auto schemaPro = SchemaUtil::generateSchemaProvider(0, schema);
   vctx_->addSchema(name, schemaPro);
   createCtx_->name = std::move(name);
   createCtx_->schema = std::move(schema);

diff --git a/src/graph/validator/MutateValidator.cpp b/src/graph/validator/MutateValidator.cpp
@@ -242,9 +242,12 @@ Status InsertEdgesValidator::prepareEdges() {
       auto iter = std::find(propNames_.begin(), propNames_.end(), propName);
       if (iter == propNames_.end()) {
         if (field->hasDefault()) {
-          auto *defaultValue = field->defaultValue();
-          DCHECK(!!defaultValue);
-          auto v = defaultValue->eval(QueryExpressionContext()(nullptr));
+          auto &defaultValue = field->defaultValue();
+          DCHECK(!defaultValue.empty());
+          ObjectPool pool;
+          auto expr = Expression::decode(
+              &pool, folly::StringPiece(defaultValue.data(), defaultValue.size()));
+          auto v = expr->eval(QueryExpressionContext()(nullptr));
           entirePropValues.emplace_back(v);
         } else {
           if (!field->nullable()) {