diff --git a/src/common/base/Arena.cpp b/src/common/base/Arena.cpp
new file mode 100644
index 00000000000..0b816386a2a
--- /dev/null
+++ b/src/common/base/Arena.cpp
@@ -0,0 +1,46 @@
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#include "common/base/Arena.h"
+
+#include <cstdint>
+
+namespace nebula {
+
+void* Arena::allocateAligned(const std::size_t alloc) {
+  DCHECK_NE(alloc, 0);  // don't allow zero sized allocation
+  // replace the modulo operation by bit and
+  static_assert(kAlignment && !(kAlignment & (kAlignment - 1)), "Align must be power of 2.");
+  const std::size_t pad =
+      kAlignment - (reinterpret_cast<uintptr_t>(currentPtr_) & (kAlignment - 1));
+  const std::size_t consumption = alloc + pad;
+  if (UNLIKELY(consumption > kMaxChunkSize)) {
+    DLOG(FATAL) << "Arena can't allocate so large memory.";
+    return nullptr;
+  }
+  if (LIKELY(consumption <= availableSize_)) {
+    void* ptr = currentPtr_ + pad;
+    currentPtr_ += consumption;
+#ifndef NDEBUG
+    allocatedSize_ += consumption;
+#endif
+    availableSize_ -= consumption;
+    return ptr;
+  } else {
+    newChunk(std::max(alloc, kMinChunkSize));
+    // The new operator will allocate the aligned memory
+    DCHECK_EQ(reinterpret_cast<uintptr_t>(currentPtr_) & (kAlignment - 1), 0);
+    void* ptr = currentPtr_;
+    currentPtr_ += alloc;
+#ifndef NDEBUG
+    allocatedSize_ += alloc;
+#endif
+    availableSize_ -= alloc;
+    return ptr;
+  }
+}
+
+}  // namespace nebula
diff --git a/src/common/base/Arena.h b/src/common/base/Arena.h
new file mode 100644
index 00000000000..e0de5876985
--- /dev/null
+++ b/src/common/base/Arena.h
@@ -0,0 +1,92 @@
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#pragma once
+
+#include <folly/Likely.h>
+
+#include <boost/core/noncopyable.hpp>
+#include <cstddef>
+#include <limits>
+#include <type_traits>
+
+#include "common/base/Logging.h"
+#include "common/cpp/helpers.h"
+
+namespace nebula {
+
+// MT-unsafe arena allocator
+// It's optimized for many small objects construct/destruct
+class Arena : public boost::noncopyable, cpp::NonMovable {
+ public:
+  ~Arena() {
+    while (LIKELY(currentChunk_ != nullptr)) {
+      auto *prev = currentChunk_->prev;
+      delete[] currentChunk_;
+      currentChunk_ = prev;
+    }
+#ifndef NDEBUG
+    allocatedSize_ = 0;
+#endif
+    availableSize_ = 0;
+    currentPtr_ = nullptr;
+  }
+
+  // The CPU access memory with the alignment,
+  // So construct object from alignment address will reduce the CPU access count then
+  // speed up read/write
+  void *allocateAligned(const std::size_t alloc);
+
+#ifndef NDEBUG
+  std::size_t allocatedSize() const {
+    return allocatedSize_;
+  }
+#endif
+
+  std::size_t availableSize() const {
+    return availableSize_;
+  }
+
+ private:
+  static constexpr std::size_t kMinChunkSize = 4096;
+  static constexpr std::size_t kMaxChunkSize = std::numeric_limits<uint16_t>::max();
+  static constexpr std::size_t kAlignment = std::alignment_of<std::max_align_t>::value;
+
+  struct Chunk {
+    explicit Chunk(Chunk *p) : prev{p} {}
+
+    union {
+      Chunk *prev{nullptr};
+      std::byte aligned[kAlignment];
+    };
+  };
+
+  // allocate new chunk
+  // The current pointer will keep alignment
+  void newChunk(std::size_t size) {
+    DCHECK_NE(size, 0);
+    std::byte *ptr = new std::byte[size + sizeof(Chunk)];
+    currentChunk_ = new (ptr) Chunk(currentChunk_);
+    availableSize_ = size;
+    currentPtr_ = (ptr + sizeof(Chunk));
+  }
+
+  Chunk *currentChunk_{nullptr};
+// These are debug info
+// Remove to speed up in Release build
+#ifndef NDEBUG
+  // total size allocated
+  std::size_t allocatedSize_{0};
+#endif
+  // total size which available to allocate
+  std::size_t availableSize_{0};
+  // The total chunks size
+  // = allocatedSize_ + availableSize_ + Memory Deprecated (Size can't fit allocation)
+  // Current pointer to available memory address
+  std::byte *currentPtr_{nullptr};
+};
+
+}  // namespace nebula
diff --git a/src/common/base/CMakeLists.txt b/src/common/base/CMakeLists.txt
index d32bebf795c..95539f0266e 100644
--- a/src/common/base/CMakeLists.txt
+++ b/src/common/base/CMakeLists.txt
@@ -13,6 +13,7 @@ nebula_add_library(
     Status.cpp
     SanitizerOptions.cpp
     SignalHandler.cpp
+    Arena.cpp
     ${gdb_debug_script}
 )
 
diff --git a/src/common/base/ObjectPool.h b/src/common/base/ObjectPool.h
index 04235f4bc88..acfe3a51b2f 100644
--- a/src/common/base/ObjectPool.h
+++ b/src/common/base/ObjectPool.h
@@ -13,6 +13,7 @@
 #include <list>
 #include <type_traits>
 
+#include "common/base/Arena.h"
 #include "common/base/Logging.h"
 #include "common/cpp/helpers.h"
 
@@ -26,26 +27,19 @@ class ObjectPool final : private boost::noncopyable, private cpp::NonMovable {
  public:
   ObjectPool() {}
 
-  ~ObjectPool() = default;
+  ~ObjectPool() {
+    clear();
+  }
 
   void clear() {
     SLGuard g(lock_);
     objects_.clear();
   }
 
-  template <typename T>
-  T *add(T *obj) {
-    if constexpr (std::is_base_of<Expression, T>::value) {
-      VLOG(3) << "New expression added into pool: " << obj->toString();
-    }
-    SLGuard g(lock_);
-    objects_.emplace_back(obj);
-    return obj;
-  }
-
   template <typename T, typename... Args>
   T *makeAndAdd(Args &&... args) {
-    return add(new T(std::forward<Args>(args)...));
+    void *ptr = arena_.allocateAligned(sizeof(T));
+    return add(new (ptr) T(std::forward<Args>(args)...));
   }
 
   bool empty() const {
@@ -58,7 +52,7 @@ class ObjectPool final : private boost::noncopyable, private cpp::NonMovable {
    public:
     template <typename T>
     explicit OwnershipHolder(T *obj)
-        : obj_(obj), deleteFn_([](void *p) { delete reinterpret_cast<T *>(p); }) {}
+        : obj_(obj), deleteFn_([](void *p) { reinterpret_cast<T *>(p)->~T(); }) {}
 
     ~OwnershipHolder() {
       deleteFn_(obj_);
@@ -69,7 +63,18 @@ class ObjectPool final : private boost::noncopyable, private cpp::NonMovable {
     std::function<void(void *)> deleteFn_;
   };
 
+  template <typename T>
+  T *add(T *obj) {
+    if constexpr (std::is_base_of<Expression, T>::value) {
+      VLOG(3) << "New expression added into pool: " << obj->toString();
+    }
+    SLGuard g(lock_);
+    objects_.emplace_back(obj);
+    return obj;
+  }
+
   std::list<OwnershipHolder> objects_;
+  Arena arena_;
 
   folly::SpinLock lock_;
 };
diff --git a/src/common/base/test/ArenaBenchmark.cpp b/src/common/base/test/ArenaBenchmark.cpp
new file mode 100644
index 00000000000..debbb57d802
--- /dev/null
+++ b/src/common/base/test/ArenaBenchmark.cpp
@@ -0,0 +1,90 @@
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#include <folly/Benchmark.h>
+#include <folly/init/Init.h>
+#include <folly/memory/Arena.h>
+
+#include <string>
+#include <type_traits>
+
+#include "common/base/Arena.h"
+#include "common/expression/LabelExpression.h"
+
+namespace nebula {
+
+class TestExpr : public LabelExpression {
+ public:
+  explicit TestExpr(const std::string &name = "")
+      : LabelExpression(reinterpret_cast<ObjectPool *>(1), name) {}
+};
+
+BENCHMARK(DefaultAllocator, iters) {
+  std::size_t round = iters * 1000;
+  for (std::size_t _ = 0; _ < round; ++_) {
+    auto *expr = new TestExpr("Label");
+    delete expr;
+  }
+}
+
+BENCHMARK_RELATIVE(ArenaAllocator, iters) {
+  std::size_t round = iters * 1000;
+  Arena a;
+  for (std::size_t _ = 0; _ < round; ++_) {
+    auto *ptr = a.allocateAligned(sizeof(TestExpr));
+    auto *expr = new (ptr) TestExpr("Label");
+    expr->~TestExpr();
+  }
+}
+
+BENCHMARK_RELATIVE(FollyArenaAllocator, iters) {
+  std::size_t round = iters * 1000;
+  folly::SysArena a;
+  for (std::size_t _ = 0; _ < round; ++_) {
+    auto *ptr = a.allocate(sizeof(TestExpr));
+    auto *expr = new (ptr) TestExpr("Label");
+    expr->~TestExpr();
+  }
+}
+
+BENCHMARK_DRAW_LINE();
+
+}  // namespace nebula
+
+int main(int argc, char **argv) {
+  folly::init(&argc, &argv, true);
+
+  folly::runBenchmarks();
+  return 0;
+}
+
+// CPU info
+// Brand Raw: Intel(R) Xeon(R) CPU E5-2690 v2 @ 3.00GHz
+// Hz Advertised Friendly: 3.0000 GHz
+// Hz Actual Friendly: 3.2942 GHz
+// Hz Advertised: (3000000000, 0)
+// Hz Actual: (3294220000, 0)
+// Arch: X86_64
+// Bits: 64
+// Count: 40
+// Arch String Raw: x86_64
+// L1 Data Cache Size: 32768
+// L1 Instruction Cache Size: 32768
+// L2 Cache Size: 262144
+// L2 Cache Line Size: 256
+// L2 Cache Associativity: 6
+// L3 Cache Size: 26214400
+//
+// Build in Release mode
+//
+// ============================================================================
+// /home/shylock.huang/nebula/src/common/base/test/ArenaBenchmark.cpprelative  time/iter  iters/s
+// ============================================================================
+// DefaultAllocator                                            36.59us   27.33K
+// ArenaAllocator                                   145.89%    25.08us   39.87K
+// FollyArenaAllocator                              138.96%    26.33us   37.98K
+// ----------------------------------------------------------------------------
+// ============================================================================
diff --git a/src/common/base/test/ArenaTest.cpp b/src/common/base/test/ArenaTest.cpp
new file mode 100644
index 00000000000..d2f9f40d44d
--- /dev/null
+++ b/src/common/base/test/ArenaTest.cpp
@@ -0,0 +1,46 @@
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License,
+ * attached with Common Clause Condition 1.0, found in the LICENSES directory.
+ */
+
+#include <gtest/gtest.h>
+
+#include <type_traits>
+
+#include "common/base/Arena.h"
+
+namespace nebula {
+
+TEST(ArenaTest, Basic) {
+  Arena a;
+
+  for (int i = 1; i < 4096; i += 8) {
+    void *ptr = a.allocateAligned(i);
+    EXPECT_EQ(reinterpret_cast<uintptr_t>(ptr) % std::alignment_of<std::max_align_t>::value, 0);
+  }
+}
+
+TEST(ArenaTest, Construct) {
+  Arena a;
+  {
+    void *ptr = a.allocateAligned(sizeof(std::string));
+    auto *obj = new (ptr) std::string("Hello World!");
+    EXPECT_EQ(*obj, "Hello World!");
+    obj->~basic_string();
+  }
+  {
+    void *ptr = a.allocateAligned(sizeof(int));
+    auto *obj = new (ptr) int(3);  // NOLINT
+    EXPECT_EQ(*obj, 3);
+  }
+  {
+    for (std::size_t i = 0; i < 1024; ++i) {
+      void *ptr = a.allocateAligned(sizeof(int));
+      auto *obj = new (ptr) int(i);  // NOLINT
+      EXPECT_EQ(*obj, i);
+    }
+  }
+}
+
+}  // namespace nebula
diff --git a/src/common/base/test/CMakeLists.txt b/src/common/base/test/CMakeLists.txt
index bfe1e4d5dd0..4963639cdf3 100644
--- a/src/common/base/test/CMakeLists.txt
+++ b/src/common/base/test/CMakeLists.txt
@@ -97,5 +97,35 @@ target_compile_options(range_vs_transform_bm PRIVATE -O3)
 nebula_add_test(
     NAME object_pool_test
     SOURCES ObjectPoolTest.cpp
+    OBJECTS $<TARGET_OBJECTS:base_obj>
     LIBRARIES gtest gtest_main
 )
+
+nebula_add_executable(
+    NAME arena_bm
+    SOURCES ArenaBenchmark.cpp
+    OBJECTS
+        $<TARGET_OBJECTS:base_obj>
+        $<TARGET_OBJECTS:datatypes_obj>
+        $<TARGET_OBJECTS:expression_obj>
+        $<TARGET_OBJECTS:function_manager_obj>
+        $<TARGET_OBJECTS:agg_function_manager_obj>
+        $<TARGET_OBJECTS:time_obj>
+        $<TARGET_OBJECTS:time_utils_obj>
+        $<TARGET_OBJECTS:ast_match_path_obj>
+        $<TARGET_OBJECTS:wkt_wkb_io_obj>
+        $<TARGET_OBJECTS:datetime_parser_obj>
+    LIBRARIES
+        follybenchmark
+        ${THRIFT_LIBRARIES}
+)
+
+nebula_add_test(
+    NAME arena_test
+    SOURCES ArenaTest.cpp
+    OBJECTS
+        $<TARGET_OBJECTS:base_obj>
+    LIBRARIES
+        gtest
+        gtest_main
+)
diff --git a/src/common/base/test/ObjectPoolTest.cpp b/src/common/base/test/ObjectPoolTest.cpp
index a98a6064cc6..1bc9fd6c7a6 100644
--- a/src/common/base/test/ObjectPoolTest.cpp
+++ b/src/common/base/test/ObjectPoolTest.cpp
@@ -25,8 +25,8 @@ TEST(ObjectPoolTest, TestPooling) {
   ASSERT_EQ(instances, 0);
 
   ObjectPool pool;
-  ASSERT_NE(pool.add(new MyClass), nullptr);
-  ASSERT_NE(pool.add(new MyClass), nullptr);
+  ASSERT_NE(pool.makeAndAdd<MyClass>(), nullptr);
+  ASSERT_NE(pool.makeAndAdd<MyClass>(), nullptr);
   ASSERT_EQ(instances, 2);
 
   pool.clear();
diff --git a/src/common/expression/AggregateExpression.h b/src/common/expression/AggregateExpression.h
index b38a6278f72..fd7fb68a5c4 100644
--- a/src/common/expression/AggregateExpression.h
+++ b/src/common/expression/AggregateExpression.h
@@ -24,7 +24,7 @@ class AggregateExpression final : public Expression {
                                    const std::string& name = "",
                                    Expression* arg = nullptr,
                                    bool distinct = false) {
-    return pool->add(new AggregateExpression(pool, name, arg, distinct));
+    return pool->makeAndAdd<AggregateExpression>(pool, name, arg, distinct);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -79,6 +79,7 @@ class AggregateExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   AggregateExpression(ObjectPool* pool,
                       const std::string& name = "",
                       Expression* arg = nullptr,
diff --git a/src/common/expression/ArithmeticExpression.h b/src/common/expression/ArithmeticExpression.h
index a1b536d8bfa..fd535167bbb 100644
--- a/src/common/expression/ArithmeticExpression.h
+++ b/src/common/expression/ArithmeticExpression.h
@@ -18,34 +18,34 @@ class ArithmeticExpression final : public BinaryExpression {
   static ArithmeticExpression* makeAdd(ObjectPool* pool,
                                        Expression* lhs = nullptr,
                                        Expression* rhs = nullptr) {
-    return pool->add(new ArithmeticExpression(pool, Expression::Kind::kAdd, lhs, rhs));
+    return pool->makeAndAdd<ArithmeticExpression>(pool, Expression::Kind::kAdd, lhs, rhs);
   }
   static ArithmeticExpression* makeMinus(ObjectPool* pool,
                                          Expression* lhs = nullptr,
                                          Expression* rhs = nullptr) {
-    return pool->add(new ArithmeticExpression(pool, Expression::Kind::kMinus, lhs, rhs));
+    return pool->makeAndAdd<ArithmeticExpression>(pool, Expression::Kind::kMinus, lhs, rhs);
   }
   static ArithmeticExpression* makeMultiply(ObjectPool* pool,
                                             Expression* lhs = nullptr,
                                             Expression* rhs = nullptr) {
-    return pool->add(new ArithmeticExpression(pool, Expression::Kind::kMultiply, lhs, rhs));
+    return pool->makeAndAdd<ArithmeticExpression>(pool, Expression::Kind::kMultiply, lhs, rhs);
   }
   static ArithmeticExpression* makeDivision(ObjectPool* pool,
                                             Expression* lhs = nullptr,
                                             Expression* rhs = nullptr) {
-    return pool->add(new ArithmeticExpression(pool, Expression::Kind::kDivision, lhs, rhs));
+    return pool->makeAndAdd<ArithmeticExpression>(pool, Expression::Kind::kDivision, lhs, rhs);
   }
   static ArithmeticExpression* makeMod(ObjectPool* pool,
                                        Expression* lhs = nullptr,
                                        Expression* rhs = nullptr) {
-    return pool->add(new ArithmeticExpression(pool, Expression::Kind::kMod, lhs, rhs));
+    return pool->makeAndAdd<ArithmeticExpression>(pool, Expression::Kind::kMod, lhs, rhs);
   }
   // Construct arithmetic expression with given kind
   static ArithmeticExpression* makeKind(ObjectPool* pool,
                                         Kind kind,
                                         Expression* lhs = nullptr,
                                         Expression* rhs = nullptr) {
-    return pool->add(new ArithmeticExpression(pool, kind, lhs, rhs));
+    return pool->makeAndAdd<ArithmeticExpression>(pool, kind, lhs, rhs);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -55,7 +55,8 @@ class ArithmeticExpression final : public BinaryExpression {
   std::string toString() const override;
 
   Expression* clone() const override {
-    return pool_->add(new ArithmeticExpression(pool_, kind(), left()->clone(), right()->clone()));
+    return pool_->makeAndAdd<ArithmeticExpression>(
+        pool_, kind(), left()->clone(), right()->clone());
   }
 
   bool isArithmeticExpr() const override {
@@ -63,6 +64,7 @@ class ArithmeticExpression final : public BinaryExpression {
   }
 
  private:
+  friend ObjectPool;
   ArithmeticExpression(ObjectPool* pool, Kind kind, Expression* lhs, Expression* rhs)
       : BinaryExpression(pool, kind, lhs, rhs) {}
 
diff --git a/src/common/expression/AttributeExpression.h b/src/common/expression/AttributeExpression.h
index 36f028e3da1..616ceb64466 100644
--- a/src/common/expression/AttributeExpression.h
+++ b/src/common/expression/AttributeExpression.h
@@ -19,7 +19,7 @@ class AttributeExpression final : public BinaryExpression {
   static AttributeExpression *make(ObjectPool *pool,
                                    Expression *lhs = nullptr,
                                    Expression *rhs = nullptr) {
-    return pool->add(new AttributeExpression(pool, lhs, rhs));
+    return pool->makeAndAdd<AttributeExpression>(pool, lhs, rhs);
   }
 
   const Value &eval(ExpressionContext &ctx) override;
@@ -33,6 +33,7 @@ class AttributeExpression final : public BinaryExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit AttributeExpression(ObjectPool *pool,
                                Expression *lhs = nullptr,
                                Expression *rhs = nullptr)
diff --git a/src/common/expression/CaseExpression.h b/src/common/expression/CaseExpression.h
index 94c9d455eba..49ba7af08ae 100644
--- a/src/common/expression/CaseExpression.h
+++ b/src/common/expression/CaseExpression.h
@@ -13,7 +13,7 @@ namespace nebula {
 class CaseList final {
  public:
   static CaseList* make(ObjectPool* pool, size_t sz = 0) {
-    return pool->add(new CaseList(sz));
+    return pool->makeAndAdd<CaseList>(sz);
   }
 
   void add(Expression* when, Expression* then) {
@@ -31,6 +31,7 @@ class CaseList final {
   };
 
  private:
+  friend ObjectPool;
   CaseList() = default;
   explicit CaseList(size_t sz) {
     items_.reserve(sz);
@@ -48,8 +49,8 @@ class CaseExpression final : public Expression {
   CaseExpression& operator=(CaseExpression&&) = delete;
 
   static CaseExpression* make(ObjectPool* pool, CaseList* cases = nullptr, bool isGeneric = true) {
-    return !cases ? pool->add(new CaseExpression(pool))
-                  : pool->add(new CaseExpression(pool, cases, isGeneric));
+    return !cases ? pool->makeAndAdd<CaseExpression>(pool)
+                  : pool->makeAndAdd<CaseExpression>(pool, cases, isGeneric);
   }
 
   bool operator==(const Expression& rhs) const override;
@@ -128,6 +129,7 @@ class CaseExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit CaseExpression(ObjectPool* pool) : Expression(pool, Kind::kCase), isGeneric_(true) {}
 
   CaseExpression(ObjectPool* pool, CaseList* cases, bool isGeneric)
diff --git a/src/common/expression/ColumnExpression.h b/src/common/expression/ColumnExpression.h
index 43e2d9b47d9..1ca147c294e 100644
--- a/src/common/expression/ColumnExpression.h
+++ b/src/common/expression/ColumnExpression.h
@@ -20,7 +20,7 @@ class ColumnExpression final : public Expression {
   ColumnExpression& operator=(ColumnExpression&&) = delete;
 
   static ColumnExpression* make(ObjectPool* pool, int32_t index = 0) {
-    return pool->add(new ColumnExpression(pool, index));
+    return pool->makeAndAdd<ColumnExpression>(pool, index);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -36,6 +36,7 @@ class ColumnExpression final : public Expression {
   bool operator==(const Expression& expr) const override;
 
  private:
+  friend ObjectPool;
   explicit ColumnExpression(ObjectPool* pool, int32_t index = 0)
       : Expression(pool, Kind::kColumn), index_(index) {}
 
diff --git a/src/common/expression/ConstantExpression.h b/src/common/expression/ConstantExpression.h
index c189564cb75..8c86bacdcd7 100644
--- a/src/common/expression/ConstantExpression.h
+++ b/src/common/expression/ConstantExpression.h
@@ -19,7 +19,7 @@ class ConstantExpression : public Expression {
   ConstantExpression& operator=(ConstantExpression&&) = delete;
 
   static ConstantExpression* make(ObjectPool* pool, Value v = Value(NullType::__NULL__)) {
-    return pool->add(new ConstantExpression(pool, v));
+    return pool->makeAndAdd<ConstantExpression>(pool, v);
   }
 
   bool operator==(const Expression& rhs) const override;
@@ -46,6 +46,7 @@ class ConstantExpression : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit ConstantExpression(ObjectPool* pool, Value v = Value(NullType::__NULL__))
       : Expression(pool, Kind::kConstant), val_(std::move(v)) {}
 
diff --git a/src/common/expression/ContainerExpression.h b/src/common/expression/ContainerExpression.h
index 1bf2f7240c5..56cb375f113 100644
--- a/src/common/expression/ContainerExpression.h
+++ b/src/common/expression/ContainerExpression.h
@@ -13,7 +13,7 @@ namespace nebula {
 class ExpressionList final {
  public:
   static ExpressionList *make(ObjectPool *pool, size_t sz = 0) {
-    return pool->add(new ExpressionList(sz));
+    return pool->makeAndAdd<ExpressionList>(sz);
   }
 
   ExpressionList &add(Expression *expr) {
@@ -26,6 +26,7 @@ class ExpressionList final {
   }
 
  private:
+  friend ObjectPool;
   ExpressionList() = default;
   explicit ExpressionList(size_t sz) {
     items_.reserve(sz);
@@ -38,7 +39,7 @@ class ExpressionList final {
 class MapItemList final {
  public:
   static MapItemList *make(ObjectPool *pool, size_t sz = 0) {
-    return pool->add(new MapItemList(sz));
+    return pool->makeAndAdd<MapItemList>(sz);
   }
 
   MapItemList &add(const std::string &key, Expression *value) {
@@ -51,6 +52,7 @@ class MapItemList final {
   }
 
  private:
+  friend ObjectPool;
   MapItemList() = default;
   explicit MapItemList(size_t sz) {
     items_.reserve(sz);
@@ -67,8 +69,8 @@ class ListExpression final : public Expression {
   ListExpression &operator=(ListExpression &&) = delete;
 
   static ListExpression *make(ObjectPool *pool, ExpressionList *items = nullptr) {
-    return items == nullptr ? pool->add(new ListExpression(pool))
-                            : pool->add(new ListExpression(pool, items));
+    return items == nullptr ? pool->makeAndAdd<ListExpression>(pool)
+                            : pool->makeAndAdd<ListExpression>(pool, items);
   }
 
   const Value &eval(ExpressionContext &ctx) override;
@@ -113,6 +115,7 @@ class ListExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit ListExpression(ObjectPool *pool) : Expression(pool, Kind::kList) {}
 
   ListExpression(ObjectPool *pool, ExpressionList *items) : Expression(pool, Kind::kList) {
@@ -134,8 +137,8 @@ class SetExpression final : public Expression {
   SetExpression &operator=(SetExpression &&) = delete;
 
   static SetExpression *make(ObjectPool *pool, ExpressionList *items = nullptr) {
-    return items == nullptr ? pool->add(new SetExpression(pool))
-                            : pool->add(new SetExpression(pool, items));
+    return items == nullptr ? pool->makeAndAdd<SetExpression>(pool)
+                            : pool->makeAndAdd<SetExpression>(pool, items);
   }
 
   const Value &eval(ExpressionContext &ctx) override;
@@ -180,6 +183,7 @@ class SetExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit SetExpression(ObjectPool *pool) : Expression(pool, Kind::kSet) {}
 
   SetExpression(ObjectPool *pool, ExpressionList *items) : Expression(pool, Kind::kSet) {
@@ -201,8 +205,8 @@ class MapExpression final : public Expression {
   MapExpression &operator=(MapExpression &&) = delete;
 
   static MapExpression *make(ObjectPool *pool, MapItemList *items = nullptr) {
-    return items == nullptr ? pool->add(new MapExpression(pool))
-                            : pool->add(new MapExpression(pool, items));
+    return items == nullptr ? pool->makeAndAdd<MapExpression>(pool)
+                            : pool->makeAndAdd<MapExpression>(pool, items);
   }
 
   using Item = std::pair<std::string, Expression *>;
@@ -249,6 +253,7 @@ class MapExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit MapExpression(ObjectPool *pool) : Expression(pool, Kind::kMap) {}
 
   MapExpression(ObjectPool *pool, MapItemList *items) : Expression(pool, Kind::kMap) {
diff --git a/src/common/expression/EdgeExpression.h b/src/common/expression/EdgeExpression.h
index 1e7fffd5019..ed2ffcbb869 100644
--- a/src/common/expression/EdgeExpression.h
+++ b/src/common/expression/EdgeExpression.h
@@ -22,7 +22,7 @@ class EdgeExpression final : public Expression {
   EdgeExpression& operator=(EdgeExpression&&) = delete;
 
   static EdgeExpression* make(ObjectPool* pool) {
-    return pool->add(new EdgeExpression(pool));
+    return pool->makeAndAdd<EdgeExpression>(pool);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -42,6 +42,7 @@ class EdgeExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit EdgeExpression(ObjectPool* pool) : Expression(pool, Kind::kEdge) {}
 
   void writeTo(Encoder& encoder) const override {
diff --git a/src/common/expression/FunctionCallExpression.h b/src/common/expression/FunctionCallExpression.h
index c752b54d910..77132aa5f06 100644
--- a/src/common/expression/FunctionCallExpression.h
+++ b/src/common/expression/FunctionCallExpression.h
@@ -16,7 +16,7 @@ namespace nebula {
 class ArgumentList final {
  public:
   static ArgumentList* make(ObjectPool* pool, size_t sz = 0) {
-    return pool->add(new ArgumentList(sz));
+    return pool->makeAndAdd<ArgumentList>(sz);
   }
 
   void addArgument(Expression* arg) {
@@ -48,6 +48,7 @@ class ArgumentList final {
   bool operator==(const ArgumentList& rhs) const;
 
  private:
+  friend ObjectPool;
   ArgumentList() = default;
   explicit ArgumentList(size_t sz) {
     args_.reserve(sz);
@@ -68,8 +69,8 @@ class FunctionCallExpression final : public Expression {
                                       const std::string& name = "",
                                       ArgumentList* args = nullptr) {
     return args == nullptr
-               ? pool->add(new FunctionCallExpression(pool, name, ArgumentList::make(pool)))
-               : pool->add(new FunctionCallExpression(pool, name, args));
+               ? pool->makeAndAdd<FunctionCallExpression>(pool, name, ArgumentList::make(pool))
+               : pool->makeAndAdd<FunctionCallExpression>(pool, name, args);
   }
 
   static FunctionCallExpression* make(ObjectPool* pool,
@@ -79,7 +80,7 @@ class FunctionCallExpression final : public Expression {
     for (auto* arg : args) {
       argList->addArgument(arg);
     }
-    return pool->add(new FunctionCallExpression(pool, name, argList));
+    return FunctionCallExpression::make(pool, name, argList);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -115,6 +116,7 @@ class FunctionCallExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   FunctionCallExpression(ObjectPool* pool, const std::string& name, ArgumentList* args)
       : Expression(pool, Kind::kFunctionCall), name_(name), args_(args) {
     if (!name_.empty()) {
diff --git a/src/common/expression/LabelAttributeExpression.h b/src/common/expression/LabelAttributeExpression.h
index 315031fefab..3ed02581f01 100644
--- a/src/common/expression/LabelAttributeExpression.h
+++ b/src/common/expression/LabelAttributeExpression.h
@@ -22,7 +22,7 @@ class LabelAttributeExpression final : public Expression {
   static LabelAttributeExpression* make(ObjectPool* pool,
                                         LabelExpression* lhs = nullptr,
                                         ConstantExpression* rhs = nullptr) {
-    return pool->add(new LabelAttributeExpression(pool, lhs, rhs));
+    return pool->makeAndAdd<LabelAttributeExpression>(pool, lhs, rhs);
   }
 
   bool operator==(const Expression& rhs) const override {
@@ -65,6 +65,7 @@ class LabelAttributeExpression final : public Expression {
   std::string toString() const override;
 
  private:
+  friend ObjectPool;
   explicit LabelAttributeExpression(ObjectPool* pool,
                                     LabelExpression* lhs = nullptr,
                                     ConstantExpression* rhs = nullptr)
diff --git a/src/common/expression/LabelExpression.h b/src/common/expression/LabelExpression.h
index b91609165f0..fae8bf00a5b 100644
--- a/src/common/expression/LabelExpression.h
+++ b/src/common/expression/LabelExpression.h
@@ -18,7 +18,7 @@ class LabelExpression : public Expression {
   LabelExpression& operator=(LabelExpression&&) = delete;
 
   static LabelExpression* make(ObjectPool* pool, const std::string& name = "") {
-    return pool->add(new LabelExpression(pool, name));
+    return pool->makeAndAdd<LabelExpression>(pool, name);
   }
 
   bool operator==(const Expression& rhs) const override;
@@ -38,6 +38,7 @@ class LabelExpression : public Expression {
   }
 
  protected:
+  friend ObjectPool;
   explicit LabelExpression(ObjectPool* pool, const std::string& name = "")
       : Expression(pool, Kind::kLabel), name_(name) {}
 
diff --git a/src/common/expression/ListComprehensionExpression.h b/src/common/expression/ListComprehensionExpression.h
index 26723d1f0ff..dd6c738de92 100644
--- a/src/common/expression/ListComprehensionExpression.h
+++ b/src/common/expression/ListComprehensionExpression.h
@@ -22,7 +22,8 @@ class ListComprehensionExpression final : public Expression {
                                            Expression* collection = nullptr,
                                            Expression* filter = nullptr,
                                            Expression* mapping = nullptr) {
-    return pool->add(new ListComprehensionExpression(pool, innerVar, collection, filter, mapping));
+    return pool->makeAndAdd<ListComprehensionExpression>(
+        pool, innerVar, collection, filter, mapping);
   }
 
   bool operator==(const Expression& rhs) const override;
@@ -100,6 +101,7 @@ class ListComprehensionExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit ListComprehensionExpression(ObjectPool* pool,
                                        const std::string& innerVar = "",
                                        Expression* collection = nullptr,
diff --git a/src/common/expression/LogicalExpression.h b/src/common/expression/LogicalExpression.h
index f64de79a402..91685c5bce1 100644
--- a/src/common/expression/LogicalExpression.h
+++ b/src/common/expression/LogicalExpression.h
@@ -17,30 +17,30 @@ class LogicalExpression final : public Expression {
   static LogicalExpression* makeAnd(ObjectPool* pool,
                                     Expression* lhs = nullptr,
                                     Expression* rhs = nullptr) {
-    return (lhs && rhs) ? pool->add(new LogicalExpression(pool, Kind::kLogicalAnd, lhs, rhs))
-                        : pool->add(new LogicalExpression(pool, Kind::kLogicalAnd));
+    return (lhs && rhs) ? pool->makeAndAdd<LogicalExpression>(pool, Kind::kLogicalAnd, lhs, rhs)
+                        : pool->makeAndAdd<LogicalExpression>(pool, Kind::kLogicalAnd);
   }
 
   static LogicalExpression* makeOr(ObjectPool* pool,
                                    Expression* lhs = nullptr,
                                    Expression* rhs = nullptr) {
-    return (lhs && rhs) ? pool->add(new LogicalExpression(pool, Kind::kLogicalOr, lhs, rhs))
-                        : pool->add(new LogicalExpression(pool, Kind::kLogicalOr));
+    return (lhs && rhs) ? pool->makeAndAdd<LogicalExpression>(pool, Kind::kLogicalOr, lhs, rhs)
+                        : pool->makeAndAdd<LogicalExpression>(pool, Kind::kLogicalOr);
   }
 
   static LogicalExpression* makeXor(ObjectPool* pool,
                                     Expression* lhs = nullptr,
                                     Expression* rhs = nullptr) {
-    return (lhs && rhs) ? pool->add(new LogicalExpression(pool, Kind::kLogicalXor, lhs, rhs))
-                        : pool->add(new LogicalExpression(pool, Kind::kLogicalXor));
+    return (lhs && rhs) ? pool->makeAndAdd<LogicalExpression>(pool, Kind::kLogicalXor, lhs, rhs)
+                        : pool->makeAndAdd<LogicalExpression>(pool, Kind::kLogicalXor);
   }
 
   static LogicalExpression* makeKind(ObjectPool* pool,
                                      Kind kind,
                                      Expression* lhs = nullptr,
                                      Expression* rhs = nullptr) {
-    return (lhs && rhs) ? pool->add(new LogicalExpression(pool, kind, lhs, rhs))
-                        : pool->add(new LogicalExpression(pool, kind));
+    return (lhs && rhs) ? pool->makeAndAdd<LogicalExpression>(pool, kind, lhs, rhs)
+                        : pool->makeAndAdd<LogicalExpression>(pool, kind);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -50,12 +50,12 @@ class LogicalExpression final : public Expression {
   void accept(ExprVisitor* visitor) override;
 
   Expression* clone() const override {
-    auto copy = new LogicalExpression(pool_, kind());
+    auto copy = LogicalExpression::makeKind(pool_, kind());
     copy->operands_.resize(operands_.size());
     for (auto i = 0u; i < operands_.size(); i++) {
       copy->operands_[i] = operands_[i]->clone();
     }
-    return pool_->add(copy);
+    return copy;
   }
 
   bool operator==(const Expression& rhs) const override;
@@ -104,6 +104,7 @@ class LogicalExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   LogicalExpression(ObjectPool* pool, Kind kind) : Expression(pool, kind) {}
 
   LogicalExpression(ObjectPool* pool, Kind kind, Expression* lhs, Expression* rhs)
diff --git a/src/common/expression/MatchPathPatternExpression.h b/src/common/expression/MatchPathPatternExpression.h
index 8e09be30dda..a80afe6345e 100644
--- a/src/common/expression/MatchPathPatternExpression.h
+++ b/src/common/expression/MatchPathPatternExpression.h
@@ -20,7 +20,7 @@ class MatchPathPatternExpression final : public Expression {
 
   static MatchPathPatternExpression* make(ObjectPool* pool,
                                           std::unique_ptr<MatchPath>&& matchPath) {
-    return pool->add(new MatchPathPatternExpression(pool, std::move(matchPath)));
+    return pool->makeAndAdd<MatchPathPatternExpression>(pool, std::move(matchPath));
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -55,6 +55,7 @@ class MatchPathPatternExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit MatchPathPatternExpression(ObjectPool* pool, std::unique_ptr<MatchPath>&& matchPath)
       : Expression(pool, Kind::kMatchPathPattern), matchPath_(std::move(matchPath)) {}
 
diff --git a/src/common/expression/PathBuildExpression.h b/src/common/expression/PathBuildExpression.h
index 4736ad7e30c..ea75275cf3e 100644
--- a/src/common/expression/PathBuildExpression.h
+++ b/src/common/expression/PathBuildExpression.h
@@ -18,7 +18,7 @@ class PathBuildExpression final : public Expression {
   PathBuildExpression& operator=(PathBuildExpression&&) = delete;
 
   static PathBuildExpression* make(ObjectPool* pool) {
-    return pool->add(new PathBuildExpression(pool));
+    return pool->makeAndAdd<PathBuildExpression>(pool);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -54,6 +54,7 @@ class PathBuildExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit PathBuildExpression(ObjectPool* pool) : Expression(pool, Kind::kPathBuild) {}
 
   void writeTo(Encoder& encoder) const override;
diff --git a/src/common/expression/PredicateExpression.h b/src/common/expression/PredicateExpression.h
index 9792e8f425d..db59ef64d7c 100644
--- a/src/common/expression/PredicateExpression.h
+++ b/src/common/expression/PredicateExpression.h
@@ -30,7 +30,7 @@ class PredicateExpression final : public Expression {
                                    const std::string& innerVar = "",
                                    Expression* collection = nullptr,
                                    Expression* filter = nullptr) {
-    return pool->add(new PredicateExpression(pool, name, innerVar, collection, filter));
+    return pool->makeAndAdd<PredicateExpression>(pool, name, innerVar, collection, filter);
   }
 
   bool operator==(const Expression& rhs) const override;
@@ -100,6 +100,7 @@ class PredicateExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit PredicateExpression(ObjectPool* pool,
                                const std::string& name = "",
                                const std::string& innerVar = "",
diff --git a/src/common/expression/PropertyExpression.h b/src/common/expression/PropertyExpression.h
index 3b7bd5e26cf..4054baab5af 100644
--- a/src/common/expression/PropertyExpression.h
+++ b/src/common/expression/PropertyExpression.h
@@ -71,7 +71,7 @@ class EdgePropertyExpression final : public PropertyExpression {
   static EdgePropertyExpression* make(ObjectPool* pool,
                                       const std::string& edge = "",
                                       const std::string& prop = "") {
-    return pool->add(new EdgePropertyExpression(pool, edge, prop));
+    return pool->makeAndAdd<EdgePropertyExpression>(pool, edge, prop);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -83,6 +83,7 @@ class EdgePropertyExpression final : public PropertyExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit EdgePropertyExpression(ObjectPool* pool,
                                   const std::string& edge = "",
                                   const std::string& prop = "")
@@ -101,7 +102,7 @@ class TagPropertyExpression final : public PropertyExpression {
   static TagPropertyExpression* make(ObjectPool* pool,
                                      const std::string& tag = "",
                                      const std::string& prop = "") {
-    return pool->add(new TagPropertyExpression(pool, tag, prop));
+    return pool->makeAndAdd<TagPropertyExpression>(pool, tag, prop);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -113,6 +114,7 @@ class TagPropertyExpression final : public PropertyExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit TagPropertyExpression(ObjectPool* pool,
                                  const std::string& tag = "",
                                  const std::string& prop = "")
@@ -132,7 +134,7 @@ class LabelTagPropertyExpression final : public PropertyExpression {
                                           Expression* label = nullptr,
                                           const std::string& tag = "",
                                           const std::string& prop = "") {
-    return pool->add(new LabelTagPropertyExpression(pool, label, tag, prop));
+    return pool->makeAndAdd<LabelTagPropertyExpression>(pool, label, tag, prop);
   }
 
   std::string toString() const override;
@@ -160,6 +162,7 @@ class LabelTagPropertyExpression final : public PropertyExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit LabelTagPropertyExpression(ObjectPool* pool,
                                       Expression* label = nullptr,
                                       const std::string& tag = "",
@@ -180,7 +183,7 @@ class InputPropertyExpression final : public PropertyExpression {
   InputPropertyExpression& operator=(InputPropertyExpression&&) = delete;
 
   static InputPropertyExpression* make(ObjectPool* pool, const std::string& prop = "") {
-    return pool->add(new InputPropertyExpression(pool, prop));
+    return pool->makeAndAdd<InputPropertyExpression>(pool, prop);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -192,6 +195,7 @@ class InputPropertyExpression final : public PropertyExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit InputPropertyExpression(ObjectPool* pool, const std::string& prop = "")
       : PropertyExpression(pool, Kind::kInputProperty, kInputRef, "", prop) {}
 };
@@ -205,7 +209,7 @@ class VariablePropertyExpression final : public PropertyExpression {
   static VariablePropertyExpression* make(ObjectPool* pool,
                                           const std::string& var = "",
                                           const std::string& prop = "") {
-    return pool->add(new VariablePropertyExpression(pool, var, prop));
+    return pool->makeAndAdd<VariablePropertyExpression>(pool, var, prop);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -219,6 +223,7 @@ class VariablePropertyExpression final : public PropertyExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit VariablePropertyExpression(ObjectPool* pool,
                                       const std::string& var = "",
                                       const std::string& prop = "")
@@ -234,7 +239,7 @@ class SourcePropertyExpression final : public PropertyExpression {
   static SourcePropertyExpression* make(ObjectPool* pool,
                                         const std::string& tag = "",
                                         const std::string& prop = "") {
-    return pool->add(new SourcePropertyExpression(pool, tag, prop));
+    return pool->makeAndAdd<SourcePropertyExpression>(pool, tag, prop);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -246,6 +251,7 @@ class SourcePropertyExpression final : public PropertyExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit SourcePropertyExpression(ObjectPool* pool,
                                     const std::string& tag = "",
                                     const std::string& prop = "")
@@ -264,7 +270,7 @@ class DestPropertyExpression final : public PropertyExpression {
   static DestPropertyExpression* make(ObjectPool* pool,
                                       const std::string& tag = "",
                                       const std::string& prop = "") {
-    return pool->add(new DestPropertyExpression(pool, tag, prop));
+    return pool->makeAndAdd<DestPropertyExpression>(pool, tag, prop);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -276,6 +282,7 @@ class DestPropertyExpression final : public PropertyExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit DestPropertyExpression(ObjectPool* pool,
                                   const std::string& tag = "",
                                   const std::string& prop = "")
@@ -289,7 +296,7 @@ class EdgeSrcIdExpression final : public PropertyExpression {
   EdgeSrcIdExpression& operator=(EdgeSrcIdExpression&&) = delete;
 
   static EdgeSrcIdExpression* make(ObjectPool* pool, const std::string& edge = "") {
-    return pool->add(new EdgeSrcIdExpression(pool, edge));
+    return pool->makeAndAdd<EdgeSrcIdExpression>(pool, edge);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -301,6 +308,7 @@ class EdgeSrcIdExpression final : public PropertyExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit EdgeSrcIdExpression(ObjectPool* pool, const std::string& edge = "")
       : PropertyExpression(pool, Kind::kEdgeSrc, "", edge, kSrc) {}
 
@@ -315,7 +323,7 @@ class EdgeTypeExpression final : public PropertyExpression {
   EdgeTypeExpression& operator=(EdgeTypeExpression&&) = delete;
 
   static EdgeTypeExpression* make(ObjectPool* pool, const std::string& edge = "") {
-    return pool->add(new EdgeTypeExpression(pool, edge));
+    return pool->makeAndAdd<EdgeTypeExpression>(pool, edge);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -327,6 +335,7 @@ class EdgeTypeExpression final : public PropertyExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit EdgeTypeExpression(ObjectPool* pool, const std::string& edge = "")
       : PropertyExpression(pool, Kind::kEdgeType, "", edge, kType) {}
 
@@ -341,7 +350,7 @@ class EdgeRankExpression final : public PropertyExpression {
   EdgeRankExpression& operator=(EdgeRankExpression&&) = delete;
 
   static EdgeRankExpression* make(ObjectPool* pool, const std::string& edge = "") {
-    return pool->add(new EdgeRankExpression(pool, edge));
+    return pool->makeAndAdd<EdgeRankExpression>(pool, edge);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -353,6 +362,7 @@ class EdgeRankExpression final : public PropertyExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit EdgeRankExpression(ObjectPool* pool, const std::string& edge = "")
       : PropertyExpression(pool, Kind::kEdgeRank, "", edge, kRank) {}
 
@@ -367,7 +377,7 @@ class EdgeDstIdExpression final : public PropertyExpression {
   EdgeDstIdExpression& operator=(EdgeDstIdExpression&&) = delete;
 
   static EdgeDstIdExpression* make(ObjectPool* pool, const std::string& edge = "") {
-    return pool->add(new EdgeDstIdExpression(pool, edge));
+    return pool->makeAndAdd<EdgeDstIdExpression>(pool, edge);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -379,6 +389,7 @@ class EdgeDstIdExpression final : public PropertyExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit EdgeDstIdExpression(ObjectPool* pool, const std::string& edge = "")
       : PropertyExpression(pool, Kind::kEdgeDst, "", edge, kDst) {}
 
diff --git a/src/common/expression/ReduceExpression.h b/src/common/expression/ReduceExpression.h
index 130be05672f..096e92d02ab 100644
--- a/src/common/expression/ReduceExpression.h
+++ b/src/common/expression/ReduceExpression.h
@@ -20,8 +20,8 @@ class ReduceExpression final : public Expression {
                                 const std::string& innerVar = "",
                                 Expression* collection = nullptr,
                                 Expression* mapping = nullptr) {
-    return pool->add(
-        new ReduceExpression(pool, accumulator, initial, innerVar, collection, mapping));
+    return pool->makeAndAdd<ReduceExpression>(
+        pool, accumulator, initial, innerVar, collection, mapping);
   }
 
   bool operator==(const Expression& rhs) const override;
@@ -99,6 +99,7 @@ class ReduceExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit ReduceExpression(ObjectPool* pool,
                             const std::string& accumulator = "",
                             Expression* initial = nullptr,
diff --git a/src/common/expression/RelationalExpression.h b/src/common/expression/RelationalExpression.h
index 7191fed9277..b7294fb9546 100644
--- a/src/common/expression/RelationalExpression.h
+++ b/src/common/expression/RelationalExpression.h
@@ -14,91 +14,91 @@ class RelationalExpression final : public BinaryExpression {
   static RelationalExpression* makeEQ(ObjectPool* pool,
                                       Expression* lhs = nullptr,
                                       Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kRelEQ, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kRelEQ, lhs, rhs);
   }
 
   static RelationalExpression* makeNE(ObjectPool* pool,
                                       Expression* lhs = nullptr,
                                       Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kRelNE, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kRelNE, lhs, rhs);
   }
 
   static RelationalExpression* makeLT(ObjectPool* pool,
                                       Expression* lhs = nullptr,
                                       Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kRelLT, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kRelLT, lhs, rhs);
   }
 
   static RelationalExpression* makeLE(ObjectPool* pool,
                                       Expression* lhs = nullptr,
                                       Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kRelLE, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kRelLE, lhs, rhs);
   }
 
   static RelationalExpression* makeGT(ObjectPool* pool,
                                       Expression* lhs = nullptr,
                                       Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kRelGT, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kRelGT, lhs, rhs);
   }
 
   static RelationalExpression* makeGE(ObjectPool* pool,
                                       Expression* lhs = nullptr,
                                       Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kRelGE, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kRelGE, lhs, rhs);
   }
 
   static RelationalExpression* makeREG(ObjectPool* pool,
                                        Expression* lhs = nullptr,
                                        Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kRelREG, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kRelREG, lhs, rhs);
   }
 
   static RelationalExpression* makeIn(ObjectPool* pool,
                                       Expression* lhs = nullptr,
                                       Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kRelIn, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kRelIn, lhs, rhs);
   }
 
   static RelationalExpression* makeNotIn(ObjectPool* pool,
                                          Expression* lhs = nullptr,
                                          Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kRelNotIn, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kRelNotIn, lhs, rhs);
   }
 
   static RelationalExpression* makeContains(ObjectPool* pool,
                                             Expression* lhs = nullptr,
                                             Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kContains, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kContains, lhs, rhs);
   }
 
   static RelationalExpression* makeNotContains(ObjectPool* pool,
                                                Expression* lhs = nullptr,
                                                Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kNotContains, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kNotContains, lhs, rhs);
   }
 
   static RelationalExpression* makeStartsWith(ObjectPool* pool,
                                               Expression* lhs = nullptr,
                                               Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kStartsWith, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kStartsWith, lhs, rhs);
   }
 
   static RelationalExpression* makeNotStartsWith(ObjectPool* pool,
                                                  Expression* lhs = nullptr,
                                                  Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kNotStartsWith, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kNotStartsWith, lhs, rhs);
   }
 
   static RelationalExpression* makeEndsWith(ObjectPool* pool,
                                             Expression* lhs = nullptr,
                                             Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kEndsWith, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kEndsWith, lhs, rhs);
   }
 
   static RelationalExpression* makeNotEndsWith(ObjectPool* pool,
                                                Expression* lhs = nullptr,
                                                Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, Kind::kNotEndsWith, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, Kind::kNotEndsWith, lhs, rhs);
   }
 
   // Construct a kind-specified relational expression
@@ -106,7 +106,7 @@ class RelationalExpression final : public BinaryExpression {
                                         Kind kind,
                                         Expression* lhs = nullptr,
                                         Expression* rhs = nullptr) {
-    return pool->add(new RelationalExpression(pool, kind, lhs, rhs));
+    return pool->makeAndAdd<RelationalExpression>(pool, kind, lhs, rhs);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -116,7 +116,7 @@ class RelationalExpression final : public BinaryExpression {
   void accept(ExprVisitor* visitor) override;
 
   Expression* clone() const override {
-    return pool_->add(new RelationalExpression(pool_, kind(), left()->clone(), right()->clone()));
+    return RelationalExpression::makeKind(pool_, kind(), left()->clone(), right()->clone());
   }
 
   bool isRelExpr() const override {
@@ -124,6 +124,7 @@ class RelationalExpression final : public BinaryExpression {
   }
 
  private:
+  friend ObjectPool;
   RelationalExpression(ObjectPool* pool, Kind kind, Expression* lhs, Expression* rhs)
       : BinaryExpression(pool, kind, lhs, rhs) {}
 
diff --git a/src/common/expression/SubscriptExpression.h b/src/common/expression/SubscriptExpression.h
index d959a7f7cc5..62b301a4a2f 100644
--- a/src/common/expression/SubscriptExpression.h
+++ b/src/common/expression/SubscriptExpression.h
@@ -17,7 +17,7 @@ class SubscriptExpression final : public BinaryExpression {
   static SubscriptExpression* make(ObjectPool* pool,
                                    Expression* lhs = nullptr,
                                    Expression* rhs = nullptr) {
-    return pool->add(new SubscriptExpression(pool, lhs, rhs));
+    return pool->makeAndAdd<SubscriptExpression>(pool, lhs, rhs);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -31,6 +31,7 @@ class SubscriptExpression final : public BinaryExpression {
   }
 
  private:
+  friend ObjectPool;
   explicit SubscriptExpression(ObjectPool* pool,
                                Expression* lhs = nullptr,
                                Expression* rhs = nullptr)
@@ -46,8 +47,8 @@ class SubscriptRangeExpression final : public Expression {
                                         Expression* list = nullptr,
                                         Expression* lo = nullptr,
                                         Expression* hi = nullptr) {
-    return !list && !lo && !hi ? pool->add(new SubscriptRangeExpression(pool))
-                               : pool->add(new SubscriptRangeExpression(pool, list, lo, hi));
+    return !list && !lo && !hi ? pool->makeAndAdd<SubscriptRangeExpression>(pool)
+                               : pool->makeAndAdd<SubscriptRangeExpression>(pool, list, lo, hi);
   }
 
   const Value& eval(ExpressionContext& ctx) override;
@@ -102,6 +103,7 @@ class SubscriptRangeExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   // for decode ctor
   explicit SubscriptRangeExpression(ObjectPool* pool)
       : Expression(pool, Kind::kSubscriptRange), list_(nullptr), lo_(nullptr), hi_(nullptr) {}
diff --git a/src/common/expression/TextSearchExpression.h b/src/common/expression/TextSearchExpression.h
index 373d7c8f77d..9c77f8667c9 100644
--- a/src/common/expression/TextSearchExpression.h
+++ b/src/common/expression/TextSearchExpression.h
@@ -17,7 +17,7 @@ class TextSearchArgument final {
                                   const std::string& from,
                                   const std::string& prop,
                                   const std::string& val) {
-    return pool->add(new TextSearchArgument(from, prop, val));
+    return pool->makeAndAdd<TextSearchArgument>(from, prop, val);
   }
 
   ~TextSearchArgument() = default;
@@ -75,6 +75,7 @@ class TextSearchArgument final {
   std::string toString() const;
 
  private:
+  friend ObjectPool;
   TextSearchArgument(const std::string& from, const std::string& prop, const std::string& val)
       : from_(from), prop_(prop), val_(val) {}
 
@@ -91,19 +92,23 @@ class TextSearchArgument final {
 class TextSearchExpression : public Expression {
  public:
   static TextSearchExpression* makePrefix(ObjectPool* pool, TextSearchArgument* arg) {
-    return pool->add(new TextSearchExpression(pool, Kind::kTSPrefix, arg));
+    return pool->makeAndAdd<TextSearchExpression>(pool, Kind::kTSPrefix, arg);
   }
 
   static TextSearchExpression* makeWildcard(ObjectPool* pool, TextSearchArgument* arg) {
-    return pool->add(new TextSearchExpression(pool, Kind::kTSWildcard, arg));
+    return pool->makeAndAdd<TextSearchExpression>(pool, Kind::kTSWildcard, arg);
   }
 
   static TextSearchExpression* makeRegexp(ObjectPool* pool, TextSearchArgument* arg) {
-    return pool->add(new TextSearchExpression(pool, Kind::kTSRegexp, arg));
+    return pool->makeAndAdd<TextSearchExpression>(pool, Kind::kTSRegexp, arg);
   }
 
   static TextSearchExpression* makeFuzzy(ObjectPool* pool, TextSearchArgument* arg) {
-    return pool->add(new TextSearchExpression(pool, Kind::kTSFuzzy, arg));
+    return pool->makeAndAdd<TextSearchExpression>(pool, Kind::kTSFuzzy, arg);
+  }
+
+  static TextSearchExpression* make(ObjectPool* pool, Kind kind, TextSearchArgument* arg) {
+    return pool->makeAndAdd<TextSearchExpression>(pool, kind, arg);
   }
 
   bool operator==(const Expression& rhs) const override;
@@ -121,7 +126,7 @@ class TextSearchExpression : public Expression {
 
   Expression* clone() const override {
     auto arg = TextSearchArgument::make(pool_, arg_->from(), arg_->prop(), arg_->val());
-    return pool_->add(new TextSearchExpression(pool_, kind_, arg));
+    return TextSearchExpression::make(pool_, kind_, arg);
   }
 
   const TextSearchArgument* arg() const {
@@ -137,6 +142,7 @@ class TextSearchExpression : public Expression {
   }
 
  private:
+  friend ObjectPool;
   TextSearchExpression(ObjectPool* pool, Kind kind, TextSearchArgument* arg)
       : Expression(pool, kind) {
     arg_ = arg;
diff --git a/src/common/expression/TypeCastingExpression.h b/src/common/expression/TypeCastingExpression.h
index 092b529fb4f..6009dfb7821 100644
--- a/src/common/expression/TypeCastingExpression.h
+++ b/src/common/expression/TypeCastingExpression.h
@@ -17,7 +17,7 @@ class TypeCastingExpression final : public Expression {
   static TypeCastingExpression* make(ObjectPool* pool,
                                      Value::Type vType = Value::Type::__EMPTY__,
                                      Expression* operand = nullptr) {
-    return pool->add(new TypeCastingExpression(pool, vType, operand));
+    return pool->makeAndAdd<TypeCastingExpression>(pool, vType, operand);
   }
 
   bool operator==(const Expression& rhs) const override;
@@ -51,6 +51,7 @@ class TypeCastingExpression final : public Expression {
   static bool validateTypeCast(Value::Type operandType, Value::Type type);
 
  private:
+  friend ObjectPool;
   explicit TypeCastingExpression(ObjectPool* pool,
                                  Value::Type vType = Value::Type::__EMPTY__,
                                  Expression* operand = nullptr)
diff --git a/src/common/expression/UUIDExpression.h b/src/common/expression/UUIDExpression.h
index febcfc32d6a..1a9c13e8fd2 100644
--- a/src/common/expression/UUIDExpression.h
+++ b/src/common/expression/UUIDExpression.h
@@ -15,7 +15,7 @@ class UUIDExpression final : public Expression {
 
  public:
   static UUIDExpression* make(ObjectPool* pool) {
-    return pool->add(new UUIDExpression(pool));
+    return pool->makeAndAdd<UUIDExpression>(pool);
   }
 
   bool operator==(const Expression& rhs) const override;
@@ -31,6 +31,7 @@ class UUIDExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit UUIDExpression(ObjectPool* pool) : Expression(pool, Kind::kUUID) {}
 
   void writeTo(Encoder& encoder) const override;
diff --git a/src/common/expression/UnaryExpression.h b/src/common/expression/UnaryExpression.h
index 26cd28d766a..1883aa0f118 100644
--- a/src/common/expression/UnaryExpression.h
+++ b/src/common/expression/UnaryExpression.h
@@ -15,39 +15,43 @@ class UnaryExpression final : public Expression {
 
  public:
   static UnaryExpression* makePlus(ObjectPool* pool, Expression* operand = nullptr) {
-    return pool->add(new UnaryExpression(pool, Kind::kUnaryPlus, operand));
+    return pool->makeAndAdd<UnaryExpression>(pool, Kind::kUnaryPlus, operand);
   }
 
   static UnaryExpression* makeNegate(ObjectPool* pool, Expression* operand = nullptr) {
-    return pool->add(new UnaryExpression(pool, Kind::kUnaryNegate, operand));
+    return pool->makeAndAdd<UnaryExpression>(pool, Kind::kUnaryNegate, operand);
   }
 
   static UnaryExpression* makeNot(ObjectPool* pool, Expression* operand = nullptr) {
-    return pool->add(new UnaryExpression(pool, Kind::kUnaryNot, operand));
+    return pool->makeAndAdd<UnaryExpression>(pool, Kind::kUnaryNot, operand);
   }
 
   static UnaryExpression* makeIncr(ObjectPool* pool, Expression* operand = nullptr) {
-    return pool->add(new UnaryExpression(pool, Kind::kUnaryIncr, operand));
+    return pool->makeAndAdd<UnaryExpression>(pool, Kind::kUnaryIncr, operand);
   }
 
   static UnaryExpression* makeDecr(ObjectPool* pool, Expression* operand = nullptr) {
-    return pool->add(new UnaryExpression(pool, Kind::kUnaryDecr, operand));
+    return pool->makeAndAdd<UnaryExpression>(pool, Kind::kUnaryDecr, operand);
   }
 
   static UnaryExpression* makeIsNull(ObjectPool* pool, Expression* operand = nullptr) {
-    return pool->add(new UnaryExpression(pool, Kind::kIsNull, operand));
+    return pool->makeAndAdd<UnaryExpression>(pool, Kind::kIsNull, operand);
   }
 
   static UnaryExpression* makeIsNotNull(ObjectPool* pool, Expression* operand = nullptr) {
-    return pool->add(new UnaryExpression(pool, Kind::kIsNotNull, operand));
+    return pool->makeAndAdd<UnaryExpression>(pool, Kind::kIsNotNull, operand);
   }
 
   static UnaryExpression* makeIsEmpty(ObjectPool* pool, Expression* operand = nullptr) {
-    return pool->add(new UnaryExpression(pool, Kind::kIsEmpty, operand));
+    return pool->makeAndAdd<UnaryExpression>(pool, Kind::kIsEmpty, operand);
   }
 
   static UnaryExpression* makeIsNotEmpty(ObjectPool* pool, Expression* operand = nullptr) {
-    return pool->add(new UnaryExpression(pool, Kind::kIsNotEmpty, operand));
+    return pool->makeAndAdd<UnaryExpression>(pool, Kind::kIsNotEmpty, operand);
+  }
+
+  static UnaryExpression* make(ObjectPool* pool, Kind kind, Expression* operand = nullptr) {
+    return pool->makeAndAdd<UnaryExpression>(pool, kind, operand);
   }
 
   bool operator==(const Expression& rhs) const override;
@@ -59,7 +63,7 @@ class UnaryExpression final : public Expression {
   void accept(ExprVisitor* visitor) override;
 
   Expression* clone() const override {
-    return pool_->add(new UnaryExpression(pool_, kind(), operand_->clone()));
+    return UnaryExpression::make(pool_, kind(), operand_->clone());
   }
 
   const Expression* operand() const {
@@ -75,6 +79,7 @@ class UnaryExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   UnaryExpression(ObjectPool* pool, Kind kind, Expression* operand = nullptr)
       : Expression(pool, kind), operand_(operand) {}
 
diff --git a/src/common/expression/VariableExpression.h b/src/common/expression/VariableExpression.h
index e2b4e03d83d..6df528bd7ba 100644
--- a/src/common/expression/VariableExpression.h
+++ b/src/common/expression/VariableExpression.h
@@ -14,7 +14,7 @@ class VariableExpression final : public Expression {
   static VariableExpression* make(ObjectPool* pool,
                                   const std::string& var = "",
                                   bool isInner = false) {
-    return pool->add(new VariableExpression(pool, var, isInner));
+    return pool->makeAndAdd<VariableExpression>(pool, var, isInner);
   }
 
   const std::string& var() const {
@@ -43,6 +43,7 @@ class VariableExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit VariableExpression(ObjectPool* pool, const std::string& var = "", bool isInner = false)
       : Expression(pool, Kind::kVar), isInner_(isInner), var_(var) {}
 
@@ -63,7 +64,7 @@ class VersionedVariableExpression final : public Expression {
   static VersionedVariableExpression* make(ObjectPool* pool,
                                            const std::string& var = "",
                                            Expression* version = nullptr) {
-    return pool->add(new VersionedVariableExpression(pool, var, version));
+    return pool->makeAndAdd<VersionedVariableExpression>(pool, var, version);
   }
 
   const std::string& var() const {
@@ -94,6 +95,7 @@ class VersionedVariableExpression final : public Expression {
   }
 
  private:
+  friend ObjectPool;
   explicit VersionedVariableExpression(ObjectPool* pool,
                                        const std::string& var = "",
                                        Expression* version = nullptr)
diff --git a/src/common/expression/VertexExpression.h b/src/common/expression/VertexExpression.h
index 29dd45806a3..e3d8e5b22da 100644
--- a/src/common/expression/VertexExpression.h
+++ b/src/common/expression/VertexExpression.h
@@ -21,7 +21,7 @@ class VertexExpression final : public Expression {
   // default name : VERTEX, $^ : startNode of EDGE, $$ : endNode of EDGE
   // $$ & $^ only used in go sentence
   static VertexExpression *make(ObjectPool *pool, const std::string &name = "VERTEX") {
-    return pool->add(new VertexExpression(pool, name));
+    return pool->makeAndAdd<VertexExpression>(pool, name);
   }
 
   const Value &eval(ExpressionContext &ctx) override;
@@ -43,6 +43,7 @@ class VertexExpression final : public Expression {
   bool operator==(const Expression &expr) const override;
 
  private:
+  friend ObjectPool;
   VertexExpression(ObjectPool *pool, const std::string &name)
       : Expression(pool, Kind::kVertex), name_(name) {}
 
diff --git a/src/graph/executor/Executor.cpp b/src/graph/executor/Executor.cpp
index 6e1a5ae6ddf..292fd0842f2 100644
--- a/src/graph/executor/Executor.cpp
+++ b/src/graph/executor/Executor.cpp
@@ -154,7 +154,7 @@ Executor *Executor::makeExecutor(QueryContext *qctx, const PlanNode *node) {
   auto &spaceName = qctx->rctx() ? qctx->rctx()->session()->spaceName() : "";
   switch (node->kind()) {
     case PlanNode::Kind::kPassThrough: {
-      return pool->add(new PassThroughExecutor(node, qctx));
+      return pool->makeAndAdd<PassThroughExecutor>(node, qctx);
     }
     case PlanNode::Kind::kAggregate: {
       stats::StatsManager::addValue(kNumAggregateExecutors);
@@ -162,7 +162,7 @@ Executor *Executor::makeExecutor(QueryContext *qctx, const PlanNode *node) {
         stats::StatsManager::addValue(
             stats::StatsManager::counterWithLabels(kNumAggregateExecutors, {{"space", spaceName}}));
       }
-      return pool->add(new AggregateExecutor(node, qctx));
+      return pool->makeAndAdd<AggregateExecutor>(node, qctx);
     }
     case PlanNode::Kind::kSort: {
       stats::StatsManager::addValue(kNumSortExecutors);
@@ -170,40 +170,40 @@ Executor *Executor::makeExecutor(QueryContext *qctx, const PlanNode *node) {
         stats::StatsManager::addValue(
             stats::StatsManager::counterWithLabels(kNumSortExecutors, {{"space", spaceName}}));
       }
-      return pool->add(new SortExecutor(node, qctx));
+      return pool->makeAndAdd<SortExecutor>(node, qctx);
     }
     case PlanNode::Kind::kTopN: {
-      return pool->add(new TopNExecutor(node, qctx));
+      return pool->makeAndAdd<TopNExecutor>(node, qctx);
     }
     case PlanNode::Kind::kFilter: {
-      return pool->add(new FilterExecutor(node, qctx));
+      return pool->makeAndAdd<FilterExecutor>(node, qctx);
     }
     case PlanNode::Kind::kGetEdges: {
-      return pool->add(new GetEdgesExecutor(node, qctx));
+      return pool->makeAndAdd<GetEdgesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kGetVertices: {
-      return pool->add(new GetVerticesExecutor(node, qctx));
+      return pool->makeAndAdd<GetVerticesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kScanEdges: {
-      return pool->add(new ScanEdgesExecutor(node, qctx));
+      return pool->makeAndAdd<ScanEdgesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kScanVertices: {
-      return pool->add(new ScanVerticesExecutor(node, qctx));
+      return pool->makeAndAdd<ScanVerticesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kGetNeighbors: {
-      return pool->add(new GetNeighborsExecutor(node, qctx));
+      return pool->makeAndAdd<GetNeighborsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kLimit: {
-      return pool->add(new LimitExecutor(node, qctx));
+      return pool->makeAndAdd<LimitExecutor>(node, qctx);
     }
     case PlanNode::Kind::kSample: {
-      return pool->add(new SampleExecutor(node, qctx));
+      return pool->makeAndAdd<SampleExecutor>(node, qctx);
     }
     case PlanNode::Kind::kProject: {
-      return pool->add(new ProjectExecutor(node, qctx));
+      return pool->makeAndAdd<ProjectExecutor>(node, qctx);
     }
     case PlanNode::Kind::kUnwind: {
-      return pool->add(new UnwindExecutor(node, qctx));
+      return pool->makeAndAdd<UnwindExecutor>(node, qctx);
     }
     case PlanNode::Kind::kIndexScan:
     case PlanNode::Kind::kEdgeIndexFullScan:
@@ -217,337 +217,337 @@ Executor *Executor::makeExecutor(QueryContext *qctx, const PlanNode *node) {
         stats::StatsManager::addValue(
             stats::StatsManager::counterWithLabels(kNumIndexScanExecutors, {{"space", spaceName}}));
       }
-      return pool->add(new IndexScanExecutor(node, qctx));
+      return pool->makeAndAdd<IndexScanExecutor>(node, qctx);
     }
     case PlanNode::Kind::kStart: {
-      return pool->add(new StartExecutor(node, qctx));
+      return pool->makeAndAdd<StartExecutor>(node, qctx);
     }
     case PlanNode::Kind::kUnion: {
-      return pool->add(new UnionExecutor(node, qctx));
+      return pool->makeAndAdd<UnionExecutor>(node, qctx);
     }
     case PlanNode::Kind::kUnionAllVersionVar: {
-      return pool->add(new UnionAllVersionVarExecutor(node, qctx));
+      return pool->makeAndAdd<UnionAllVersionVarExecutor>(node, qctx);
     }
     case PlanNode::Kind::kIntersect: {
-      return pool->add(new IntersectExecutor(node, qctx));
+      return pool->makeAndAdd<IntersectExecutor>(node, qctx);
     }
     case PlanNode::Kind::kMinus: {
-      return pool->add(new MinusExecutor(node, qctx));
+      return pool->makeAndAdd<MinusExecutor>(node, qctx);
     }
     case PlanNode::Kind::kLoop: {
-      return pool->add(new LoopExecutor(node, qctx));
+      return pool->makeAndAdd<LoopExecutor>(node, qctx);
     }
     case PlanNode::Kind::kSelect: {
-      return pool->add(new SelectExecutor(node, qctx));
+      return pool->makeAndAdd<SelectExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDedup: {
-      return pool->add(new DedupExecutor(node, qctx));
+      return pool->makeAndAdd<DedupExecutor>(node, qctx);
     }
     case PlanNode::Kind::kAssign: {
-      return pool->add(new AssignExecutor(node, qctx));
+      return pool->makeAndAdd<AssignExecutor>(node, qctx);
     }
     case PlanNode::Kind::kSwitchSpace: {
-      return pool->add(new SwitchSpaceExecutor(node, qctx));
+      return pool->makeAndAdd<SwitchSpaceExecutor>(node, qctx);
     }
     case PlanNode::Kind::kCreateSpace: {
-      return pool->add(new CreateSpaceExecutor(node, qctx));
+      return pool->makeAndAdd<CreateSpaceExecutor>(node, qctx);
     }
     case PlanNode::Kind::kCreateSpaceAs: {
-      return pool->add(new CreateSpaceAsExecutor(node, qctx));
+      return pool->makeAndAdd<CreateSpaceAsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDescSpace: {
-      return pool->add(new DescSpaceExecutor(node, qctx));
+      return pool->makeAndAdd<DescSpaceExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowSpaces: {
-      return pool->add(new ShowSpacesExecutor(node, qctx));
+      return pool->makeAndAdd<ShowSpacesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDropSpace: {
-      return pool->add(new DropSpaceExecutor(node, qctx));
+      return pool->makeAndAdd<DropSpaceExecutor>(node, qctx);
     }
     case PlanNode::Kind::kClearSpace: {
-      return pool->add(new ClearSpaceExecutor(node, qctx));
+      return pool->makeAndAdd<ClearSpaceExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowCreateSpace: {
-      return pool->add(new ShowCreateSpaceExecutor(node, qctx));
+      return pool->makeAndAdd<ShowCreateSpaceExecutor>(node, qctx);
     }
     case PlanNode::Kind::kCreateTag: {
-      return pool->add(new CreateTagExecutor(node, qctx));
+      return pool->makeAndAdd<CreateTagExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDescTag: {
-      return pool->add(new DescTagExecutor(node, qctx));
+      return pool->makeAndAdd<DescTagExecutor>(node, qctx);
     }
     case PlanNode::Kind::kAlterTag: {
-      return pool->add(new AlterTagExecutor(node, qctx));
+      return pool->makeAndAdd<AlterTagExecutor>(node, qctx);
     }
     case PlanNode::Kind::kCreateEdge: {
-      return pool->add(new CreateEdgeExecutor(node, qctx));
+      return pool->makeAndAdd<CreateEdgeExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDescEdge: {
-      return pool->add(new DescEdgeExecutor(node, qctx));
+      return pool->makeAndAdd<DescEdgeExecutor>(node, qctx);
     }
     case PlanNode::Kind::kAlterEdge: {
-      return pool->add(new AlterEdgeExecutor(node, qctx));
+      return pool->makeAndAdd<AlterEdgeExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowTags: {
-      return pool->add(new ShowTagsExecutor(node, qctx));
+      return pool->makeAndAdd<ShowTagsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowEdges: {
-      return pool->add(new ShowEdgesExecutor(node, qctx));
+      return pool->makeAndAdd<ShowEdgesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDropTag: {
-      return pool->add(new DropTagExecutor(node, qctx));
+      return pool->makeAndAdd<DropTagExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDropEdge: {
-      return pool->add(new DropEdgeExecutor(node, qctx));
+      return pool->makeAndAdd<DropEdgeExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowCreateTag: {
-      return pool->add(new ShowCreateTagExecutor(node, qctx));
+      return pool->makeAndAdd<ShowCreateTagExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowCreateEdge: {
-      return pool->add(new ShowCreateEdgeExecutor(node, qctx));
+      return pool->makeAndAdd<ShowCreateEdgeExecutor>(node, qctx);
     }
     case PlanNode::Kind::kCreateTagIndex: {
-      return pool->add(new CreateTagIndexExecutor(node, qctx));
+      return pool->makeAndAdd<CreateTagIndexExecutor>(node, qctx);
     }
     case PlanNode::Kind::kCreateEdgeIndex: {
-      return pool->add(new CreateEdgeIndexExecutor(node, qctx));
+      return pool->makeAndAdd<CreateEdgeIndexExecutor>(node, qctx);
     }
     case PlanNode::Kind::kCreateFTIndex: {
-      return pool->add(new CreateFTIndexExecutor(node, qctx));
+      return pool->makeAndAdd<CreateFTIndexExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDropTagIndex: {
-      return pool->add(new DropTagIndexExecutor(node, qctx));
+      return pool->makeAndAdd<DropTagIndexExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDropEdgeIndex: {
-      return pool->add(new DropEdgeIndexExecutor(node, qctx));
+      return pool->makeAndAdd<DropEdgeIndexExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDropFTIndex: {
-      return pool->add(new DropFTIndexExecutor(node, qctx));
+      return pool->makeAndAdd<DropFTIndexExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDescTagIndex: {
-      return pool->add(new DescTagIndexExecutor(node, qctx));
+      return pool->makeAndAdd<DescTagIndexExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDescEdgeIndex: {
-      return pool->add(new DescEdgeIndexExecutor(node, qctx));
+      return pool->makeAndAdd<DescEdgeIndexExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowCreateTagIndex: {
-      return pool->add(new ShowCreateTagIndexExecutor(node, qctx));
+      return pool->makeAndAdd<ShowCreateTagIndexExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowCreateEdgeIndex: {
-      return pool->add(new ShowCreateEdgeIndexExecutor(node, qctx));
+      return pool->makeAndAdd<ShowCreateEdgeIndexExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowTagIndexes: {
-      return pool->add(new ShowTagIndexesExecutor(node, qctx));
+      return pool->makeAndAdd<ShowTagIndexesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowEdgeIndexes: {
-      return pool->add(new ShowEdgeIndexesExecutor(node, qctx));
+      return pool->makeAndAdd<ShowEdgeIndexesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowTagIndexStatus: {
-      return pool->add(new ShowTagIndexStatusExecutor(node, qctx));
+      return pool->makeAndAdd<ShowTagIndexStatusExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowEdgeIndexStatus: {
-      return pool->add(new ShowEdgeIndexStatusExecutor(node, qctx));
+      return pool->makeAndAdd<ShowEdgeIndexStatusExecutor>(node, qctx);
     }
     case PlanNode::Kind::kInsertVertices: {
-      return pool->add(new InsertVerticesExecutor(node, qctx));
+      return pool->makeAndAdd<InsertVerticesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kInsertEdges: {
-      return pool->add(new InsertEdgesExecutor(node, qctx));
+      return pool->makeAndAdd<InsertEdgesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDataCollect: {
-      return pool->add(new DataCollectExecutor(node, qctx));
+      return pool->makeAndAdd<DataCollectExecutor>(node, qctx);
     }
     case PlanNode::Kind::kCreateSnapshot: {
-      return pool->add(new CreateSnapshotExecutor(node, qctx));
+      return pool->makeAndAdd<CreateSnapshotExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDropSnapshot: {
-      return pool->add(new DropSnapshotExecutor(node, qctx));
+      return pool->makeAndAdd<DropSnapshotExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowSnapshots: {
-      return pool->add(new ShowSnapshotsExecutor(node, qctx));
+      return pool->makeAndAdd<ShowSnapshotsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kLeftJoin: {
-      return pool->add(new LeftJoinExecutor(node, qctx));
+      return pool->makeAndAdd<LeftJoinExecutor>(node, qctx);
     }
     case PlanNode::Kind::kInnerJoin: {
-      return pool->add(new InnerJoinExecutor(node, qctx));
+      return pool->makeAndAdd<InnerJoinExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDeleteVertices: {
-      return pool->add(new DeleteVerticesExecutor(node, qctx));
+      return pool->makeAndAdd<DeleteVerticesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDeleteTags: {
-      return pool->add(new DeleteTagsExecutor(node, qctx));
+      return pool->makeAndAdd<DeleteTagsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDeleteEdges: {
-      return pool->add(new DeleteEdgesExecutor(node, qctx));
+      return pool->makeAndAdd<DeleteEdgesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kUpdateVertex: {
-      return pool->add(new UpdateVertexExecutor(node, qctx));
+      return pool->makeAndAdd<UpdateVertexExecutor>(node, qctx);
     }
     case PlanNode::Kind::kUpdateEdge: {
-      return pool->add(new UpdateEdgeExecutor(node, qctx));
+      return pool->makeAndAdd<UpdateEdgeExecutor>(node, qctx);
     }
     case PlanNode::Kind::kCreateUser: {
-      return pool->add(new CreateUserExecutor(node, qctx));
+      return pool->makeAndAdd<CreateUserExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDropUser: {
-      return pool->add(new DropUserExecutor(node, qctx));
+      return pool->makeAndAdd<DropUserExecutor>(node, qctx);
     }
     case PlanNode::Kind::kUpdateUser: {
-      return pool->add(new UpdateUserExecutor(node, qctx));
+      return pool->makeAndAdd<UpdateUserExecutor>(node, qctx);
     }
     case PlanNode::Kind::kGrantRole: {
-      return pool->add(new GrantRoleExecutor(node, qctx));
+      return pool->makeAndAdd<GrantRoleExecutor>(node, qctx);
     }
     case PlanNode::Kind::kRevokeRole: {
-      return pool->add(new RevokeRoleExecutor(node, qctx));
+      return pool->makeAndAdd<RevokeRoleExecutor>(node, qctx);
     }
     case PlanNode::Kind::kChangePassword: {
-      return pool->add(new ChangePasswordExecutor(node, qctx));
+      return pool->makeAndAdd<ChangePasswordExecutor>(node, qctx);
     }
     case PlanNode::Kind::kListUserRoles: {
-      return pool->add(new ListUserRolesExecutor(node, qctx));
+      return pool->makeAndAdd<ListUserRolesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kListUsers: {
-      return pool->add(new ListUsersExecutor(node, qctx));
+      return pool->makeAndAdd<ListUsersExecutor>(node, qctx);
     }
     case PlanNode::Kind::kListRoles: {
-      return pool->add(new ListRolesExecutor(node, qctx));
+      return pool->makeAndAdd<ListRolesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDescribeUser: {
-      return pool->add(new DescribeUserExecutor(node, qctx));
+      return pool->makeAndAdd<DescribeUserExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowConfigs: {
-      return pool->add(new ShowConfigsExecutor(node, qctx));
+      return pool->makeAndAdd<ShowConfigsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kSetConfig: {
-      return pool->add(new SetConfigExecutor(node, qctx));
+      return pool->makeAndAdd<SetConfigExecutor>(node, qctx);
     }
     case PlanNode::Kind::kGetConfig: {
-      return pool->add(new GetConfigExecutor(node, qctx));
+      return pool->makeAndAdd<GetConfigExecutor>(node, qctx);
     }
     case PlanNode::Kind::kSubmitJob: {
-      return pool->add(new SubmitJobExecutor(node, qctx));
+      return pool->makeAndAdd<SubmitJobExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowHosts: {
-      return pool->add(new ShowHostsExecutor(node, qctx));
+      return pool->makeAndAdd<ShowHostsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowMetaLeader: {
-      return pool->add(new ShowMetaLeaderExecutor(node, qctx));
+      return pool->makeAndAdd<ShowMetaLeaderExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowParts: {
-      return pool->add(new ShowPartsExecutor(node, qctx));
+      return pool->makeAndAdd<ShowPartsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowCharset: {
-      return pool->add(new ShowCharsetExecutor(node, qctx));
+      return pool->makeAndAdd<ShowCharsetExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowCollation: {
-      return pool->add(new ShowCollationExecutor(node, qctx));
+      return pool->makeAndAdd<ShowCollationExecutor>(node, qctx);
     }
     case PlanNode::Kind::kBFSShortest: {
-      return pool->add(new BFSShortestPathExecutor(node, qctx));
+      return pool->makeAndAdd<BFSShortestPathExecutor>(node, qctx);
     }
     case PlanNode::Kind::kMultiShortestPath: {
-      return pool->add(new MultiShortestPathExecutor(node, qctx));
+      return pool->makeAndAdd<MultiShortestPathExecutor>(node, qctx);
     }
     case PlanNode::Kind::kProduceAllPaths: {
-      return pool->add(new ProduceAllPathsExecutor(node, qctx));
+      return pool->makeAndAdd<ProduceAllPathsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kCartesianProduct: {
-      return pool->add(new CartesianProductExecutor(node, qctx));
+      return pool->makeAndAdd<CartesianProductExecutor>(node, qctx);
     }
     case PlanNode::Kind::kSubgraph: {
-      return pool->add(new SubgraphExecutor(node, qctx));
+      return pool->makeAndAdd<SubgraphExecutor>(node, qctx);
     }
     case PlanNode::Kind::kAddHosts: {
-      return pool->add(new AddHostsExecutor(node, qctx));
+      return pool->makeAndAdd<AddHostsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDropHosts: {
-      return pool->add(new DropHostsExecutor(node, qctx));
+      return pool->makeAndAdd<DropHostsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kMergeZone: {
-      return pool->add(new MergeZoneExecutor(node, qctx));
+      return pool->makeAndAdd<MergeZoneExecutor>(node, qctx);
     }
     case PlanNode::Kind::kRenameZone: {
-      return pool->add(new RenameZoneExecutor(node, qctx));
+      return pool->makeAndAdd<RenameZoneExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDropZone: {
-      return pool->add(new DropZoneExecutor(node, qctx));
+      return pool->makeAndAdd<DropZoneExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDivideZone: {
-      return pool->add(new DivideZoneExecutor(node, qctx));
+      return pool->makeAndAdd<DivideZoneExecutor>(node, qctx);
     }
     case PlanNode::Kind::kDescribeZone: {
-      return pool->add(new DescribeZoneExecutor(node, qctx));
+      return pool->makeAndAdd<DescribeZoneExecutor>(node, qctx);
     }
     case PlanNode::Kind::kAddHostsIntoZone: {
-      return pool->add(new AddHostsIntoZoneExecutor(node, qctx));
+      return pool->makeAndAdd<AddHostsIntoZoneExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowZones: {
-      return pool->add(new ListZonesExecutor(node, qctx));
+      return pool->makeAndAdd<ListZonesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kAddListener: {
-      return pool->add(new AddListenerExecutor(node, qctx));
+      return pool->makeAndAdd<AddListenerExecutor>(node, qctx);
     }
     case PlanNode::Kind::kRemoveListener: {
-      return pool->add(new RemoveListenerExecutor(node, qctx));
+      return pool->makeAndAdd<RemoveListenerExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowListener: {
-      return pool->add(new ShowListenerExecutor(node, qctx));
+      return pool->makeAndAdd<ShowListenerExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowStats: {
-      return pool->add(new ShowStatsExecutor(node, qctx));
+      return pool->makeAndAdd<ShowStatsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowServiceClients: {
-      return pool->add(new ShowServiceClientsExecutor(node, qctx));
+      return pool->makeAndAdd<ShowServiceClientsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowFTIndexes: {
-      return pool->add(new ShowFTIndexesExecutor(node, qctx));
+      return pool->makeAndAdd<ShowFTIndexesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kSignInService: {
-      return pool->add(new SignInServiceExecutor(node, qctx));
+      return pool->makeAndAdd<SignInServiceExecutor>(node, qctx);
     }
     case PlanNode::Kind::kSignOutService: {
-      return pool->add(new SignOutServiceExecutor(node, qctx));
+      return pool->makeAndAdd<SignOutServiceExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowSessions: {
-      return pool->add(new ShowSessionsExecutor(node, qctx));
+      return pool->makeAndAdd<ShowSessionsExecutor>(node, qctx);
     }
     case PlanNode::Kind::kUpdateSession: {
-      return pool->add(new UpdateSessionExecutor(node, qctx));
+      return pool->makeAndAdd<UpdateSessionExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShowQueries: {
-      return pool->add(new ShowQueriesExecutor(node, qctx));
+      return pool->makeAndAdd<ShowQueriesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kKillQuery: {
-      return pool->add(new KillQueryExecutor(node, qctx));
+      return pool->makeAndAdd<KillQueryExecutor>(node, qctx);
     }
     case PlanNode::Kind::kTraverse: {
-      return pool->add(new TraverseExecutor(node, qctx));
+      return pool->makeAndAdd<TraverseExecutor>(node, qctx);
     }
     case PlanNode::Kind::kAppendVertices: {
-      return pool->add(new AppendVerticesExecutor(node, qctx));
+      return pool->makeAndAdd<AppendVerticesExecutor>(node, qctx);
     }
     case PlanNode::Kind::kBiLeftJoin: {
-      return pool->add(new BiLeftJoinExecutor(node, qctx));
+      return pool->makeAndAdd<BiLeftJoinExecutor>(node, qctx);
     }
     case PlanNode::Kind::kBiInnerJoin: {
-      return pool->add(new BiInnerJoinExecutor(node, qctx));
+      return pool->makeAndAdd<BiInnerJoinExecutor>(node, qctx);
     }
     case PlanNode::Kind::kBiCartesianProduct: {
-      return pool->add(new BiCartesianProductExecutor(node, qctx));
+      return pool->makeAndAdd<BiCartesianProductExecutor>(node, qctx);
     }
     case PlanNode::Kind::kRollUpApply: {
-      return pool->add(new RollUpApplyExecutor(node, qctx));
+      return pool->makeAndAdd<RollUpApplyExecutor>(node, qctx);
     }
     case PlanNode::Kind::kArgument: {
-      return pool->add(new ArgumentExecutor(node, qctx));
+      return pool->makeAndAdd<ArgumentExecutor>(node, qctx);
     }
     case PlanNode::Kind::kAlterSpace: {
-      return pool->add(new AlterSpaceExecutor(node, qctx));
+      return pool->makeAndAdd<AlterSpaceExecutor>(node, qctx);
     }
     case PlanNode::Kind::kShortestPath: {
-      return pool->add(new ShortestPathExecutor(node, qctx));
+      return pool->makeAndAdd<ShortestPathExecutor>(node, qctx);
     }
     case PlanNode::Kind::kUnknown: {
       LOG(FATAL) << "Unknown plan node kind " << static_cast<int32_t>(node->kind());
diff --git a/src/graph/optimizer/OptGroup.cpp b/src/graph/optimizer/OptGroup.cpp
index 40ebea88a53..955b7031e0c 100644
--- a/src/graph/optimizer/OptGroup.cpp
+++ b/src/graph/optimizer/OptGroup.cpp
@@ -24,7 +24,7 @@ namespace nebula {
 namespace opt {
 
 OptGroup *OptGroup::create(OptContext *ctx) {
-  return ctx->objPool()->add(new OptGroup(ctx));
+  return ctx->objPool()->makeAndAdd<OptGroup>(ctx);
 }
 
 void OptGroup::setUnexplored(const OptRule *rule) {
@@ -161,7 +161,7 @@ const PlanNode *OptGroup::getPlan() const {
 }
 
 OptGroupNode *OptGroupNode::create(OptContext *ctx, PlanNode *node, const OptGroup *group) {
-  auto optGNode = ctx->objPool()->add(new OptGroupNode(node, group));
+  auto optGNode = ctx->objPool()->makeAndAdd<OptGroupNode>(node, group);
   ctx->addPlanNodeAndOptGroupNode(node->id(), optGNode);
   return optGNode;
 }
diff --git a/src/graph/optimizer/OptGroup.h b/src/graph/optimizer/OptGroup.h
index 04ec946a4aa..276bcc75bb8 100644
--- a/src/graph/optimizer/OptGroup.h
+++ b/src/graph/optimizer/OptGroup.h
@@ -6,6 +6,7 @@
 #ifndef GRAPH_OPTIMIZER_OPTGROUP_H_
 #define GRAPH_OPTIMIZER_OPTGROUP_H_
 
+#include "common/base/ObjectPool.h"
 #include "common/base/Status.h"
 
 namespace nebula {
@@ -48,6 +49,7 @@ class OptGroup final {
   }
 
  private:
+  friend ObjectPool;
   explicit OptGroup(OptContext *ctx) noexcept;
 
   static constexpr int16_t kMaxExplorationRound = 128;
@@ -108,6 +110,7 @@ class OptGroupNode final {
   const graph::PlanNode *getPlan() const;
 
  private:
+  friend ObjectPool;
   OptGroupNode(graph::PlanNode *node, const OptGroup *group) noexcept;
 
   graph::PlanNode *node_{nullptr};
diff --git a/src/graph/planner/match/MatchSolver.cpp b/src/graph/planner/match/MatchSolver.cpp
index 16d33439df5..b1c5b95c6f1 100644
--- a/src/graph/planner/match/MatchSolver.cpp
+++ b/src/graph/planner/match/MatchSolver.cpp
@@ -218,7 +218,7 @@ void MatchSolver::extractAndDedupVidColumn(QueryContext* qctx,
                                            PlanNode* dep,
                                            const std::string& inputVar,
                                            SubPlan& plan) {
-  auto columns = qctx->objPool()->add(new YieldColumns);
+  auto columns = qctx->objPool()->makeAndAdd<YieldColumns>();
   auto* var = qctx->symTable()->getVar(inputVar);
   Expression* vidExpr = initialExprOrEdgeDstExpr(qctx, initialExpr, var->colNames.back());
   if (initialExpr) {
@@ -312,7 +312,7 @@ Status MatchSolver::appendFetchVertexPlan(const Expression* nodeFilter,
   }
 
   // Normalize all columns to one
-  auto columns = pool->add(new YieldColumns);
+  auto columns = pool->makeAndAdd<YieldColumns>();
   auto pathExpr = PathBuildExpression::make(pool);
   pathExpr->add(VertexExpression::make(pool));
   columns->addColumn(new YieldColumn(pathExpr));
diff --git a/src/graph/planner/match/YieldClausePlanner.cpp b/src/graph/planner/match/YieldClausePlanner.cpp
index bc500125b61..1c3f1df33c6 100644
--- a/src/graph/planner/match/YieldClausePlanner.cpp
+++ b/src/graph/planner/match/YieldClausePlanner.cpp
@@ -45,7 +45,7 @@ void YieldClausePlanner::rewriteGroupExprs(const YieldClauseContext* yctx,
 Status YieldClausePlanner::buildYield(YieldClauseContext* yctx, SubPlan& subplan) {
   auto* currentRoot = subplan.root;
   DCHECK(!currentRoot);
-  auto* newProjCols = yctx->qctx->objPool()->add(new YieldColumns());
+  auto* newProjCols = yctx->qctx->objPool()->makeAndAdd<YieldColumns>();
   rewriteYieldColumns(yctx, yctx->projCols_, newProjCols);
   if (!yctx->hasAgg_) {
     auto* project = Project::make(yctx->qctx, currentRoot, newProjCols);
diff --git a/src/graph/planner/ngql/GoPlanner.cpp b/src/graph/planner/ngql/GoPlanner.cpp
index 8f7215b7bb0..afc95df18a7 100644
--- a/src/graph/planner/ngql/GoPlanner.cpp
+++ b/src/graph/planner/ngql/GoPlanner.cpp
@@ -118,7 +118,7 @@ PlanNode* GoPlanner::extractSrcEdgePropsFromGN(PlanNode* dep, const std::string&
 PlanNode* GoPlanner::extractSrcDstFromGN(PlanNode* dep, const std::string& input) {
   auto qctx = goCtx_->qctx;
   auto* pool = qctx->objPool();
-  auto* columns = pool->add(new YieldColumns());
+  auto* columns = pool->makeAndAdd<YieldColumns>();
 
   goCtx_->srcVidColName = qctx->vctx()->anonColGen()->getCol();
   auto* vidExpr = new YieldColumn(ColumnExpression::make(pool, VID_INDEX), goCtx_->srcVidColName);
@@ -141,7 +141,7 @@ PlanNode* GoPlanner::extractVidFromRuntimeInput(PlanNode* dep) {
   auto qctx = goCtx_->qctx;
   const auto& from = goCtx_->from;
 
-  auto* columns = qctx->objPool()->add(new YieldColumns());
+  auto* columns = qctx->objPool()->makeAndAdd<YieldColumns>();
   auto* vidExpr = new YieldColumn(from.originalSrc->clone(), from.runtimeVidName);
   columns->addColumn(vidExpr);
 
@@ -181,7 +181,7 @@ PlanNode* GoPlanner::trackStartVid(PlanNode* left, PlanNode* right) {
   join->setColNames(std::move(colNames));
 
   // extract runtimeVid  & dst from join result
-  auto* columns = pool->add(new YieldColumns());
+  auto* columns = pool->makeAndAdd<YieldColumns>();
   auto& vidName = goCtx_->from.runtimeVidName;
   auto* vidExpr = new YieldColumn(InputPropertyExpression::make(pool, vidName), vidName);
   columns->addColumn(vidExpr);
diff --git a/src/graph/planner/ngql/PathPlanner.cpp b/src/graph/planner/ngql/PathPlanner.cpp
index 9228640d768..8b20c266f3b 100644
--- a/src/graph/planner/ngql/PathPlanner.cpp
+++ b/src/graph/planner/ngql/PathPlanner.cpp
@@ -182,7 +182,7 @@ SubPlan PathPlanner::loopDepPlan() {
   auto* pool = qctx->objPool();
   SubPlan subPlan = buildRuntimeVidPlan();
   {
-    auto* columns = pool->add(new YieldColumns());
+    auto* columns = pool->makeAndAdd<YieldColumns>();
     auto* column = new YieldColumn(ColumnExpression::make(pool, 0), kVid);
     columns->addColumn(column);
     auto* project = Project::make(qctx, subPlan.root, columns);
@@ -193,7 +193,7 @@ SubPlan PathPlanner::loopDepPlan() {
   }
   subPlan.tail = subPlan.tail == nullptr ? subPlan.root : subPlan.tail;
   {
-    auto* columns = pool->add(new YieldColumns());
+    auto* columns = pool->makeAndAdd<YieldColumns>();
     auto* column = new YieldColumn(ColumnExpression::make(pool, 0), kVid);
     columns->addColumn(column);
     auto* project = Project::make(qctx, subPlan.root, columns);
@@ -312,7 +312,7 @@ PlanNode* PathPlanner::buildVertexPlan(PlanNode* dep, const std::string& input)
   auto funNodes = FunctionCallExpression::make(pool, "nodes", args);
 
   auto* column = new YieldColumn(funNodes, "nodes");
-  auto* columns = pool->add(new YieldColumns());
+  auto* columns = pool->makeAndAdd<YieldColumns>();
   columns->addColumn(column);
 
   auto* project = Project::make(qctx, dep, columns);
@@ -345,7 +345,7 @@ PlanNode* PathPlanner::buildEdgePlan(PlanNode* dep, const std::string& input) {
   auto funEdges = FunctionCallExpression::make(pool, "relationships", args);
 
   auto* column = new YieldColumn(funEdges, "edges");
-  auto* columns = pool->add(new YieldColumns());
+  auto* columns = pool->makeAndAdd<YieldColumns>();
   columns->addColumn(column);
 
   auto* project = Project::make(qctx, dep, columns);
diff --git a/src/graph/planner/plan/Admin.h b/src/graph/planner/plan/Admin.h
index 3b390a47f16..bf3490d86a1 100644
--- a/src/graph/planner/plan/Admin.h
+++ b/src/graph/planner/plan/Admin.h
@@ -54,7 +54,7 @@ class DropNode : public SingleDependencyNode {
 class AddHosts final : public SingleDependencyNode {
  public:
   static AddHosts* make(QueryContext* qctx, PlanNode* dep, std::vector<HostAddr> hosts) {
-    return qctx->objPool()->add(new AddHosts(qctx, dep, hosts));
+    return qctx->objPool()->makeAndAdd<AddHosts>(qctx, dep, hosts);
   }
 
   std::vector<HostAddr> getHosts() const {
@@ -64,6 +64,7 @@ class AddHosts final : public SingleDependencyNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   AddHosts(QueryContext* qctx, PlanNode* dep, std::vector<HostAddr> hosts)
       : SingleDependencyNode(qctx, Kind::kAddHosts, dep), hosts_(hosts) {}
 
@@ -73,7 +74,7 @@ class AddHosts final : public SingleDependencyNode {
 class DropHosts final : public SingleDependencyNode {
  public:
   static DropHosts* make(QueryContext* qctx, PlanNode* dep, std::vector<HostAddr> hosts) {
-    return qctx->objPool()->add(new DropHosts(qctx, dep, hosts));
+    return qctx->objPool()->makeAndAdd<DropHosts>(qctx, dep, hosts);
   }
 
   std::vector<HostAddr> getHosts() const {
@@ -83,6 +84,7 @@ class DropHosts final : public SingleDependencyNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   DropHosts(QueryContext* qctx, PlanNode* dep, std::vector<HostAddr> hosts)
       : SingleDependencyNode(qctx, Kind::kDropHosts, dep), hosts_(hosts) {}
 
@@ -93,7 +95,7 @@ class ShowHosts final : public SingleDependencyNode {
   // TODO(shylock) meta/storage/graph/agent enumerate
  public:
   static ShowHosts* make(QueryContext* qctx, PlanNode* dep, meta::cpp2::ListHostType type) {
-    return qctx->objPool()->add(new ShowHosts(qctx, dep, type));
+    return qctx->objPool()->makeAndAdd<ShowHosts>(qctx, dep, type);
   }
 
   meta::cpp2::ListHostType getType() const {
@@ -101,6 +103,7 @@ class ShowHosts final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   ShowHosts(QueryContext* qctx, PlanNode* dep, meta::cpp2::ListHostType type)
       : SingleDependencyNode(qctx, Kind::kShowHosts, dep), type_(type) {}
   meta::cpp2::ListHostType type_;
@@ -109,10 +112,11 @@ class ShowHosts final : public SingleDependencyNode {
 class ShowMetaLeaderNode final : public SingleDependencyNode {
  public:
   static ShowMetaLeaderNode* make(QueryContext* qctx, PlanNode* dep) {
-    return qctx->objPool()->add(new ShowMetaLeaderNode(qctx, dep));
+    return qctx->objPool()->makeAndAdd<ShowMetaLeaderNode>(qctx, dep);
   }
 
  private:
+  friend ObjectPool;
   ShowMetaLeaderNode(QueryContext* qctx, PlanNode* dep)
       : SingleDependencyNode(qctx, Kind::kShowMetaLeader, dep) {}
 };
@@ -123,7 +127,7 @@ class CreateSpace final : public SingleDependencyNode {
                            PlanNode* input,
                            meta::cpp2::SpaceDesc spaceDesc,
                            bool ifNotExists) {
-    return qctx->objPool()->add(new CreateSpace(qctx, input, std::move(spaceDesc), ifNotExists));
+    return qctx->objPool()->makeAndAdd<CreateSpace>(qctx, input, std::move(spaceDesc), ifNotExists);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -138,6 +142,7 @@ class CreateSpace final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   CreateSpace(QueryContext* qctx,
               PlanNode* input,
               meta::cpp2::SpaceDesc spaceDesc,
@@ -158,7 +163,7 @@ class CreateSpaceAsNode final : public SingleDependencyNode {
                                  PlanNode* input,
                                  const std::string& oldSpaceName,
                                  const std::string& newSpaceName) {
-    return qctx->objPool()->add(new CreateSpaceAsNode(qctx, input, oldSpaceName, newSpaceName));
+    return qctx->objPool()->makeAndAdd<CreateSpaceAsNode>(qctx, input, oldSpaceName, newSpaceName);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -173,6 +178,7 @@ class CreateSpaceAsNode final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   CreateSpaceAsNode(QueryContext* qctx, PlanNode* input, std::string oldName, std::string newName)
       : SingleDependencyNode(qctx, Kind::kCreateSpaceAs, input),
         oldSpaceName_(std::move(oldName)),
@@ -189,7 +195,7 @@ class DropSpace final : public SingleDependencyNode {
                          PlanNode* input,
                          std::string spaceName,
                          bool ifExists) {
-    return qctx->objPool()->add(new DropSpace(qctx, input, std::move(spaceName), ifExists));
+    return qctx->objPool()->makeAndAdd<DropSpace>(qctx, input, std::move(spaceName), ifExists);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -203,6 +209,7 @@ class DropSpace final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   DropSpace(QueryContext* qctx, PlanNode* input, std::string spaceName, bool ifExists)
       : SingleDependencyNode(qctx, Kind::kDropSpace, input) {
     spaceName_ = std::move(spaceName);
@@ -220,7 +227,7 @@ class ClearSpace final : public SingleDependencyNode {
                           PlanNode* input,
                           std::string spaceName,
                           bool ifExists) {
-    return qctx->objPool()->add(new ClearSpace(qctx, input, std::move(spaceName), ifExists));
+    return qctx->objPool()->makeAndAdd<ClearSpace>(qctx, input, std::move(spaceName), ifExists);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -234,6 +241,7 @@ class ClearSpace final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   ClearSpace(QueryContext* qctx, PlanNode* input, std::string spaceName, bool ifExists)
       : SingleDependencyNode(qctx, Kind::kClearSpace, input) {
     spaceName_ = std::move(spaceName);
@@ -252,7 +260,7 @@ class AlterSpace final : public SingleDependencyNode {
                           const std::string& spaceName,
                           meta::cpp2::AlterSpaceOp op,
                           const std::vector<std::string>& paras) {
-    return qctx->objPool()->add(new AlterSpace(qctx, input, spaceName, op, paras));
+    return qctx->objPool()->makeAndAdd<AlterSpace>(qctx, input, spaceName, op, paras);
   }
   const std::string& getSpaceName() const {
     return spaceName_;
@@ -267,6 +275,7 @@ class AlterSpace final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   AlterSpace(QueryContext* qctx,
              PlanNode* input,
              const std::string& spaceName,
@@ -286,7 +295,7 @@ class AlterSpace final : public SingleDependencyNode {
 class DescSpace final : public SingleDependencyNode {
  public:
   static DescSpace* make(QueryContext* qctx, PlanNode* input, std::string spaceName) {
-    return qctx->objPool()->add(new DescSpace(qctx, input, std::move(spaceName)));
+    return qctx->objPool()->makeAndAdd<DescSpace>(qctx, input, std::move(spaceName));
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -296,6 +305,7 @@ class DescSpace final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   DescSpace(QueryContext* qctx, PlanNode* input, std::string spaceName)
       : SingleDependencyNode(qctx, Kind::kDescSpace, input) {
     spaceName_ = std::move(spaceName);
@@ -308,10 +318,11 @@ class DescSpace final : public SingleDependencyNode {
 class ShowSpaces final : public SingleDependencyNode {
  public:
   static ShowSpaces* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowSpaces(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowSpaces>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowSpaces(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowSpaces, input) {}
 };
@@ -319,7 +330,7 @@ class ShowSpaces final : public SingleDependencyNode {
 class ShowConfigs final : public SingleDependencyNode {
  public:
   static ShowConfigs* make(QueryContext* qctx, PlanNode* input, meta::cpp2::ConfigModule module) {
-    return qctx->objPool()->add(new ShowConfigs(qctx, input, module));
+    return qctx->objPool()->makeAndAdd<ShowConfigs>(qctx, input, module);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -329,6 +340,7 @@ class ShowConfigs final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   ShowConfigs(QueryContext* qctx, PlanNode* input, meta::cpp2::ConfigModule module)
       : SingleDependencyNode(qctx, Kind::kShowConfigs, input), module_(module) {}
 
@@ -343,8 +355,8 @@ class SetConfig final : public SingleDependencyNode {
                          meta::cpp2::ConfigModule module,
                          std::string name,
                          Value value) {
-    return qctx->objPool()->add(
-        new SetConfig(qctx, input, module, std::move(name), std::move(value)));
+    return qctx->objPool()->makeAndAdd<SetConfig>(
+        qctx, input, module, std::move(name), std::move(value));
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -362,6 +374,7 @@ class SetConfig final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   SetConfig(QueryContext* qctx,
             PlanNode* input,
             meta::cpp2::ConfigModule module,
@@ -384,7 +397,7 @@ class GetConfig final : public SingleDependencyNode {
                          PlanNode* input,
                          meta::cpp2::ConfigModule module,
                          std::string name) {
-    return qctx->objPool()->add(new GetConfig(qctx, input, module, std::move(name)));
+    return qctx->objPool()->makeAndAdd<GetConfig>(qctx, input, module, std::move(name));
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -398,6 +411,7 @@ class GetConfig final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   GetConfig(QueryContext* qctx, PlanNode* input, meta::cpp2::ConfigModule module, std::string name)
       : SingleDependencyNode(qctx, Kind::kGetConfig, input),
         module_(module),
@@ -411,7 +425,7 @@ class GetConfig final : public SingleDependencyNode {
 class ShowCreateSpace final : public SingleDependencyNode {
  public:
   static ShowCreateSpace* make(QueryContext* qctx, PlanNode* input, std::string spaceName) {
-    return qctx->objPool()->add(new ShowCreateSpace(qctx, input, std::move(spaceName)));
+    return qctx->objPool()->makeAndAdd<ShowCreateSpace>(qctx, input, std::move(spaceName));
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -421,6 +435,7 @@ class ShowCreateSpace final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   ShowCreateSpace(QueryContext* qctx, PlanNode* input, std::string spaceName)
       : SingleDependencyNode(qctx, Kind::kShowCreateSpace, input) {
     spaceName_ = std::move(spaceName);
@@ -433,10 +448,11 @@ class ShowCreateSpace final : public SingleDependencyNode {
 class CreateSnapshot final : public SingleDependencyNode {
  public:
   static CreateSnapshot* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new CreateSnapshot(qctx, input));
+    return qctx->objPool()->makeAndAdd<CreateSnapshot>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   CreateSnapshot(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kCreateSnapshot, input) {}
 };
@@ -444,7 +460,7 @@ class CreateSnapshot final : public SingleDependencyNode {
 class DropSnapshot final : public SingleDependencyNode {
  public:
   static DropSnapshot* make(QueryContext* qctx, PlanNode* input, std::string snapshotName) {
-    return qctx->objPool()->add(new DropSnapshot(qctx, input, std::move(snapshotName)));
+    return qctx->objPool()->makeAndAdd<DropSnapshot>(qctx, input, std::move(snapshotName));
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -454,6 +470,7 @@ class DropSnapshot final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   DropSnapshot(QueryContext* qctx, PlanNode* input, std::string snapshotName)
       : SingleDependencyNode(qctx, Kind::kDropSnapshot, input) {
     snapshotName_ = std::move(snapshotName);
@@ -466,10 +483,11 @@ class DropSnapshot final : public SingleDependencyNode {
 class ShowSnapshots final : public SingleDependencyNode {
  public:
   static ShowSnapshots* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowSnapshots(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowSnapshots>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowSnapshots(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowSnapshots, input) {}
 };
@@ -480,7 +498,7 @@ class AddListener final : public SingleDependencyNode {
                            PlanNode* input,
                            meta::cpp2::ListenerType type,
                            std::vector<HostAddr> hosts) {
-    return qctx->objPool()->add(new AddListener(qctx, input, std::move(type), std::move(hosts)));
+    return qctx->objPool()->makeAndAdd<AddListener>(qctx, input, std::move(type), std::move(hosts));
   }
 
   const meta::cpp2::ListenerType& type() const {
@@ -492,6 +510,7 @@ class AddListener final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   AddListener(QueryContext* qctx,
               PlanNode* input,
               meta::cpp2::ListenerType type,
@@ -509,7 +528,7 @@ class AddListener final : public SingleDependencyNode {
 class RemoveListener final : public SingleDependencyNode {
  public:
   static RemoveListener* make(QueryContext* qctx, PlanNode* input, meta::cpp2::ListenerType type) {
-    return qctx->objPool()->add(new RemoveListener(qctx, input, std::move(type)));
+    return qctx->objPool()->makeAndAdd<RemoveListener>(qctx, input, std::move(type));
   }
 
   const meta::cpp2::ListenerType& type() const {
@@ -517,6 +536,7 @@ class RemoveListener final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   RemoveListener(QueryContext* qctx, PlanNode* input, meta::cpp2::ListenerType type)
       : SingleDependencyNode(qctx, Kind::kRemoveListener, input) {
     type_ = std::move(type);
@@ -529,10 +549,11 @@ class RemoveListener final : public SingleDependencyNode {
 class ShowListener final : public SingleDependencyNode {
  public:
   static ShowListener* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowListener(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowListener>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowListener(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowListener, input) {}
 };
@@ -545,7 +566,7 @@ class CreateUser final : public CreateNode {
                           const std::string* username,
                           const std::string* password,
                           bool ifNotExists) {
-    return qctx->objPool()->add(new CreateUser(qctx, dep, username, password, ifNotExists));
+    return qctx->objPool()->makeAndAdd<CreateUser>(qctx, dep, username, password, ifNotExists);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -559,6 +580,7 @@ class CreateUser final : public CreateNode {
   }
 
  private:
+  friend ObjectPool;
   CreateUser(QueryContext* qctx,
              PlanNode* dep,
              const std::string* username,
@@ -579,7 +601,7 @@ class DropUser final : public DropNode {
                         PlanNode* dep,
                         const std::string* username,
                         bool ifNotExists) {
-    return qctx->objPool()->add(new DropUser(qctx, dep, username, ifNotExists));
+    return qctx->objPool()->makeAndAdd<DropUser>(qctx, dep, username, ifNotExists);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -589,6 +611,7 @@ class DropUser final : public DropNode {
   }
 
  private:
+  friend ObjectPool;
   DropUser(QueryContext* qctx, PlanNode* dep, const std::string* username, bool ifNotExists)
       : DropNode(qctx, Kind::kDropUser, dep, ifNotExists), username_(username) {}
 
@@ -602,7 +625,7 @@ class UpdateUser final : public SingleDependencyNode {
                           PlanNode* dep,
                           const std::string* username,
                           const std::string* password) {
-    return qctx->objPool()->add(new UpdateUser(qctx, dep, username, password));
+    return qctx->objPool()->makeAndAdd<UpdateUser>(qctx, dep, username, password);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -616,6 +639,7 @@ class UpdateUser final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   UpdateUser(QueryContext* qctx,
              PlanNode* dep,
              const std::string* username,
@@ -636,7 +660,7 @@ class GrantRole final : public SingleDependencyNode {
                          const std::string* username,
                          const std::string* spaceName,
                          meta::cpp2::RoleType role) {
-    return qctx->objPool()->add(new GrantRole(qctx, dep, username, spaceName, role));
+    return qctx->objPool()->makeAndAdd<GrantRole>(qctx, dep, username, spaceName, role);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -654,6 +678,7 @@ class GrantRole final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   GrantRole(QueryContext* qctx,
             PlanNode* dep,
             const std::string* username,
@@ -677,7 +702,7 @@ class RevokeRole final : public SingleDependencyNode {
                           const std::string* username,
                           const std::string* spaceName,
                           meta::cpp2::RoleType role) {
-    return qctx->objPool()->add(new RevokeRole(qctx, dep, username, spaceName, role));
+    return qctx->objPool()->makeAndAdd<RevokeRole>(qctx, dep, username, spaceName, role);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -695,6 +720,7 @@ class RevokeRole final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   RevokeRole(QueryContext* qctx,
              PlanNode* dep,
              const std::string* username,
@@ -718,7 +744,7 @@ class ChangePassword final : public SingleDependencyNode {
                               const std::string* username,
                               const std::string* password,
                               const std::string* newPassword) {
-    return qctx->objPool()->add(new ChangePassword(qctx, dep, username, password, newPassword));
+    return qctx->objPool()->makeAndAdd<ChangePassword>(qctx, dep, username, password, newPassword);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -736,6 +762,7 @@ class ChangePassword final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   ChangePassword(QueryContext* qctx,
                  PlanNode* dep,
                  const std::string* username,
@@ -755,7 +782,7 @@ class ChangePassword final : public SingleDependencyNode {
 class ListUserRoles final : public SingleDependencyNode {
  public:
   static ListUserRoles* make(QueryContext* qctx, PlanNode* dep, const std::string* username) {
-    return qctx->objPool()->add(new ListUserRoles(qctx, dep, username));
+    return qctx->objPool()->makeAndAdd<ListUserRoles>(qctx, dep, username);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -765,6 +792,7 @@ class ListUserRoles final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   ListUserRoles(QueryContext* qctx, PlanNode* dep, const std::string* username)
       : SingleDependencyNode(qctx, Kind::kListUserRoles, dep), username_(username) {}
 
@@ -775,10 +803,11 @@ class ListUserRoles final : public SingleDependencyNode {
 class ListUsers final : public SingleDependencyNode {
  public:
   static ListUsers* make(QueryContext* qctx, PlanNode* dep) {
-    return qctx->objPool()->add(new ListUsers(qctx, dep));
+    return qctx->objPool()->makeAndAdd<ListUsers>(qctx, dep);
   }
 
  private:
+  friend ObjectPool;
   ListUsers(QueryContext* qctx, PlanNode* dep)
       : SingleDependencyNode(qctx, Kind::kListUsers, dep) {}
 };
@@ -786,7 +815,7 @@ class ListUsers final : public SingleDependencyNode {
 class DescribeUser final : public SingleDependencyNode {
  public:
   static DescribeUser* make(QueryContext* qctx, PlanNode* dep, const std::string* username) {
-    return qctx->objPool()->add(new DescribeUser(qctx, dep, username));
+    return qctx->objPool()->makeAndAdd<DescribeUser>(qctx, dep, username);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -796,6 +825,7 @@ class DescribeUser final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   DescribeUser(QueryContext* qctx, PlanNode* dep, const std::string* username)
       : SingleDependencyNode(qctx, Kind::kDescribeUser, dep), username_(username) {}
 
@@ -805,7 +835,7 @@ class DescribeUser final : public SingleDependencyNode {
 class ListRoles final : public SingleDependencyNode {
  public:
   static ListRoles* make(QueryContext* qctx, PlanNode* dep, GraphSpaceID space) {
-    return qctx->objPool()->add(new ListRoles(qctx, dep, space));
+    return qctx->objPool()->makeAndAdd<ListRoles>(qctx, dep, space);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -815,6 +845,7 @@ class ListRoles final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   ListRoles(QueryContext* qctx, PlanNode* dep, GraphSpaceID space)
       : SingleDependencyNode(qctx, Kind::kListRoles, dep), space_(space) {}
 
@@ -827,7 +858,7 @@ class ShowParts final : public SingleDependencyNode {
                          PlanNode* input,
                          GraphSpaceID spaceId,
                          std::vector<PartitionID> partIds) {
-    return qctx->objPool()->add(new ShowParts(qctx, input, spaceId, std::move(partIds)));
+    return qctx->objPool()->makeAndAdd<ShowParts>(qctx, input, spaceId, std::move(partIds));
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -851,6 +882,7 @@ class ShowParts final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   GraphSpaceID spaceId_{-1};
   std::vector<PartitionID> partIds_;
 };
@@ -862,7 +894,7 @@ class SubmitJob final : public SingleDependencyNode {
                          meta::cpp2::JobOp op,
                          meta::cpp2::JobType type,
                          const std::vector<std::string>& params) {
-    return qctx->objPool()->add(new SubmitJob(qctx, dep, op, type, params));
+    return qctx->objPool()->makeAndAdd<SubmitJob>(qctx, dep, op, type, params);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -881,6 +913,7 @@ class SubmitJob final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   SubmitJob(QueryContext* qctx,
             PlanNode* dep,
             meta::cpp2::JobOp op,
@@ -897,10 +930,11 @@ class SubmitJob final : public SingleDependencyNode {
 class ShowCharset final : public SingleDependencyNode {
  public:
   static ShowCharset* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowCharset(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowCharset>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowCharset(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowCharset, input) {}
 };
@@ -908,10 +942,11 @@ class ShowCharset final : public SingleDependencyNode {
 class ShowCollation final : public SingleDependencyNode {
  public:
   static ShowCollation* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowCollation(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowCollation>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowCollation(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowCollation, input) {}
 };
@@ -923,8 +958,8 @@ class AddHostsIntoZone final : public SingleDependencyNode {
                                 std::string zoneName,
                                 std::vector<HostAddr> addresses,
                                 bool isNew) {
-    return qctx->objPool()->add(
-        new AddHostsIntoZone(qctx, input, std::move(zoneName), std::move(addresses), isNew));
+    return qctx->objPool()->makeAndAdd<AddHostsIntoZone>(
+        qctx, input, std::move(zoneName), std::move(addresses), isNew);
   }
 
   const std::string& zoneName() const {
@@ -940,6 +975,7 @@ class AddHostsIntoZone final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   AddHostsIntoZone(QueryContext* qctx,
                    PlanNode* input,
                    std::string zoneName,
@@ -963,8 +999,8 @@ class MergeZone final : public SingleDependencyNode {
                          PlanNode* input,
                          std::string zoneName,
                          std::vector<std::string> zoneNames) {
-    return qctx->objPool()->add(
-        new MergeZone(qctx, input, std::move(zoneName), std::move(zoneNames)));
+    return qctx->objPool()->makeAndAdd<MergeZone>(
+        qctx, input, std::move(zoneName), std::move(zoneNames));
   }
 
   const std::string& zoneName() const {
@@ -976,6 +1012,7 @@ class MergeZone final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   MergeZone(QueryContext* qctx,
             PlanNode* input,
             std::string zoneName,
@@ -996,8 +1033,8 @@ class RenameZone final : public SingleDependencyNode {
                           PlanNode* input,
                           std::string originalZoneName,
                           std::string zoneName) {
-    return qctx->objPool()->add(
-        new RenameZone(qctx, input, std::move(originalZoneName), std::move(zoneName)));
+    return qctx->objPool()->makeAndAdd<RenameZone>(
+        qctx, input, std::move(originalZoneName), std::move(zoneName));
   }
 
   const std::string& originalZoneName() const {
@@ -1009,6 +1046,7 @@ class RenameZone final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   RenameZone(QueryContext* qctx,
              PlanNode* input,
              std::string originalZoneName,
@@ -1026,7 +1064,7 @@ class RenameZone final : public SingleDependencyNode {
 class DropZone final : public SingleDependencyNode {
  public:
   static DropZone* make(QueryContext* qctx, PlanNode* input, std::string zoneName) {
-    return qctx->objPool()->add(new DropZone(qctx, input, std::move(zoneName)));
+    return qctx->objPool()->makeAndAdd<DropZone>(qctx, input, std::move(zoneName));
   }
 
   const std::string& zoneName() const {
@@ -1034,6 +1072,7 @@ class DropZone final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   DropZone(QueryContext* qctx, PlanNode* input, std::string zoneName)
       : SingleDependencyNode(qctx, Kind::kDropZone, input) {
     zoneName_ = std::move(zoneName);
@@ -1049,8 +1088,8 @@ class DivideZone final : public SingleDependencyNode {
                           PlanNode* input,
                           std::string zoneName,
                           std::unordered_map<std::string, std::vector<HostAddr>> zoneItems) {
-    return qctx->objPool()->add(
-        new DivideZone(qctx, input, std::move(zoneName), std::move(zoneItems)));
+    return qctx->objPool()->makeAndAdd<DivideZone>(
+        qctx, input, std::move(zoneName), std::move(zoneItems));
   }
 
   const std::string& zoneName() const {
@@ -1062,6 +1101,7 @@ class DivideZone final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   DivideZone(QueryContext* qctx,
              PlanNode* input,
              std::string zoneName,
@@ -1079,7 +1119,7 @@ class DivideZone final : public SingleDependencyNode {
 class DescribeZone final : public SingleDependencyNode {
  public:
   static DescribeZone* make(QueryContext* qctx, PlanNode* input, std::string zoneName) {
-    return qctx->objPool()->add(new DescribeZone(qctx, input, std::move(zoneName)));
+    return qctx->objPool()->makeAndAdd<DescribeZone>(qctx, input, std::move(zoneName));
   }
 
   const std::string& zoneName() const {
@@ -1087,6 +1127,7 @@ class DescribeZone final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   DescribeZone(QueryContext* qctx, PlanNode* input, std::string zoneName)
       : SingleDependencyNode(qctx, Kind::kDescribeZone, input) {
     zoneName_ = std::move(zoneName);
@@ -1099,10 +1140,11 @@ class DescribeZone final : public SingleDependencyNode {
 class ListZones final : public SingleDependencyNode {
  public:
   static ListZones* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ListZones(qctx, input));
+    return qctx->objPool()->makeAndAdd<ListZones>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ListZones(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowZones, input) {}
 };
@@ -1110,10 +1152,11 @@ class ListZones final : public SingleDependencyNode {
 class ShowZones final : public SingleDependencyNode {
  public:
   static ShowZones* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowZones(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowZones>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowZones(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowZones, input) {}
 };
@@ -1121,10 +1164,11 @@ class ShowZones final : public SingleDependencyNode {
 class ShowStats final : public SingleDependencyNode {
  public:
   static ShowStats* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowStats(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowStats>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowStats(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowStats, input) {}
 };
@@ -1134,7 +1178,7 @@ class ShowServiceClients final : public SingleDependencyNode {
   static ShowServiceClients* make(QueryContext* qctx,
                                   PlanNode* input,
                                   meta::cpp2::ExternalServiceType type) {
-    return qctx->objPool()->add(new ShowServiceClients(qctx, input, type));
+    return qctx->objPool()->makeAndAdd<ShowServiceClients>(qctx, input, type);
   }
 
   meta::cpp2::ExternalServiceType type() const {
@@ -1142,6 +1186,7 @@ class ShowServiceClients final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   ShowServiceClients(QueryContext* qctx, PlanNode* input, meta::cpp2::ExternalServiceType type)
       : SingleDependencyNode(qctx, Kind::kShowServiceClients, input), type_(type) {}
 
@@ -1155,7 +1200,7 @@ class SignInService final : public SingleDependencyNode {
                              PlanNode* input,
                              std::vector<meta::cpp2::ServiceClient> clients,
                              meta::cpp2::ExternalServiceType type) {
-    return qctx->objPool()->add(new SignInService(qctx, input, std::move(clients), type));
+    return qctx->objPool()->makeAndAdd<SignInService>(qctx, input, std::move(clients), type);
   }
 
   const std::vector<meta::cpp2::ServiceClient>& clients() const {
@@ -1167,6 +1212,7 @@ class SignInService final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   SignInService(QueryContext* qctx,
                 PlanNode* input,
                 std::vector<meta::cpp2::ServiceClient> clients,
@@ -1185,7 +1231,7 @@ class SignOutService final : public SingleDependencyNode {
   static SignOutService* make(QueryContext* qctx,
                               PlanNode* input,
                               meta::cpp2::ExternalServiceType type) {
-    return qctx->objPool()->add(new SignOutService(qctx, input, type));
+    return qctx->objPool()->makeAndAdd<SignOutService>(qctx, input, type);
   }
 
   meta::cpp2::ExternalServiceType type() const {
@@ -1193,6 +1239,7 @@ class SignOutService final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   SignOutService(QueryContext* qctx, PlanNode* input, meta::cpp2::ExternalServiceType type)
       : SingleDependencyNode(qctx, Kind::kSignOutService, input), type_(type) {}
 
@@ -1207,8 +1254,8 @@ class ShowSessions final : public SingleInputNode {
                             bool isSetSessionID,
                             SessionID sessionId,
                             bool isLocalCommand) {
-    return qctx->objPool()->add(
-        new ShowSessions(qctx, input, isSetSessionID, sessionId, isLocalCommand));
+    return qctx->objPool()->makeAndAdd<ShowSessions>(
+        qctx, input, isSetSessionID, sessionId, isLocalCommand);
   }
 
   bool isSetSessionID() const {
@@ -1222,6 +1269,7 @@ class ShowSessions final : public SingleInputNode {
   }
 
  private:
+  friend ObjectPool;
   ShowSessions(QueryContext* qctx,
                PlanNode* input,
                bool isSetSessionID,
@@ -1242,7 +1290,7 @@ class ShowSessions final : public SingleInputNode {
 class UpdateSession final : public SingleInputNode {
  public:
   static UpdateSession* make(QueryContext* qctx, PlanNode* input, meta::cpp2::Session session) {
-    return qctx->objPool()->add(new UpdateSession(qctx, input, std::move(session)));
+    return qctx->objPool()->makeAndAdd<UpdateSession>(qctx, input, std::move(session));
   }
 
   const meta::cpp2::Session& getSession() const {
@@ -1250,6 +1298,7 @@ class UpdateSession final : public SingleInputNode {
   }
 
  private:
+  friend ObjectPool;
   UpdateSession(QueryContext* qctx, PlanNode* input, meta::cpp2::Session session)
       : SingleInputNode(qctx, Kind::kUpdateSession, input), session_(std::move(session)) {}
 
@@ -1260,7 +1309,7 @@ class UpdateSession final : public SingleInputNode {
 class ShowQueries final : public SingleInputNode {
  public:
   static ShowQueries* make(QueryContext* qctx, PlanNode* input, bool isAll) {
-    return qctx->objPool()->add(new ShowQueries(qctx, input, isAll));
+    return qctx->objPool()->makeAndAdd<ShowQueries>(qctx, input, isAll);
   }
 
   bool isAll() const {
@@ -1270,6 +1319,7 @@ class ShowQueries final : public SingleInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   ShowQueries(QueryContext* qctx, PlanNode* input, bool isAll)
       : SingleInputNode(qctx, Kind::kShowQueries, input), isAll_(isAll) {}
 
@@ -1282,7 +1332,7 @@ class KillQuery final : public SingleInputNode {
                          PlanNode* input,
                          Expression* sessionId,
                          Expression* epId) {
-    return qctx->objPool()->add(new KillQuery(qctx, input, sessionId, epId));
+    return qctx->objPool()->makeAndAdd<KillQuery>(qctx, input, sessionId, epId);
   }
 
   Expression* sessionId() const {
@@ -1296,6 +1346,7 @@ class KillQuery final : public SingleInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   KillQuery(QueryContext* qctx, PlanNode* input, Expression* sessionId, Expression* epId)
       : SingleInputNode(qctx, Kind::kKillQuery, input), sessionId_(sessionId), epId_(epId) {}
 
diff --git a/src/graph/planner/plan/Algo.h b/src/graph/planner/plan/Algo.h
index 6b00d6f3e0e..68ae9bee51a 100644
--- a/src/graph/planner/plan/Algo.h
+++ b/src/graph/planner/plan/Algo.h
@@ -17,7 +17,7 @@ class MultiShortestPath : public BinaryInputNode {
                                  PlanNode* left,
                                  PlanNode* right,
                                  size_t steps) {
-    return qctx->objPool()->add(new MultiShortestPath(qctx, left, right, steps));
+    return qctx->objPool()->makeAndAdd<MultiShortestPath>(qctx, left, right, steps);
   }
 
   size_t steps() const {
@@ -51,6 +51,7 @@ class MultiShortestPath : public BinaryInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   MultiShortestPath(QueryContext* qctx, PlanNode* left, PlanNode* right, size_t steps)
       : BinaryInputNode(qctx, Kind::kMultiShortestPath, left, right), steps_(steps) {}
 
@@ -64,7 +65,7 @@ class MultiShortestPath : public BinaryInputNode {
 class BFSShortestPath : public BinaryInputNode {
  public:
   static BFSShortestPath* make(QueryContext* qctx, PlanNode* left, PlanNode* right, size_t steps) {
-    return qctx->objPool()->add(new BFSShortestPath(qctx, left, right, steps));
+    return qctx->objPool()->makeAndAdd<BFSShortestPath>(qctx, left, right, steps);
   }
 
   size_t steps() const {
@@ -90,6 +91,7 @@ class BFSShortestPath : public BinaryInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   BFSShortestPath(QueryContext* qctx, PlanNode* left, PlanNode* right, size_t steps)
       : BinaryInputNode(qctx, Kind::kBFSShortest, left, right), steps_(steps) {}
 
@@ -103,7 +105,7 @@ class ProduceAllPaths final : public BinaryInputNode {
  public:
   static ProduceAllPaths* make(
       QueryContext* qctx, PlanNode* left, PlanNode* right, size_t steps, bool noLoop) {
-    return qctx->objPool()->add(new ProduceAllPaths(qctx, left, right, steps, noLoop));
+    return qctx->objPool()->makeAndAdd<ProduceAllPaths>(qctx, left, right, steps, noLoop);
   }
 
   size_t steps() const {
@@ -133,6 +135,7 @@ class ProduceAllPaths final : public BinaryInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   ProduceAllPaths(QueryContext* qctx, PlanNode* left, PlanNode* right, size_t steps, bool noLoop)
       : BinaryInputNode(qctx, Kind::kProduceAllPaths, left, right),
         steps_(steps),
@@ -155,7 +158,7 @@ class ShortestPath final : public SingleInputNode {
                             PlanNode* node,
                             GraphSpaceID space,
                             bool singleShortest) {
-    return qctx->objPool()->add(new ShortestPath(qctx, node, space, singleShortest));
+    return qctx->objPool()->makeAndAdd<ShortestPath>(qctx, node, space, singleShortest);
   }
 
   PlanNode* clone() const override;
@@ -211,6 +214,7 @@ class ShortestPath final : public SingleInputNode {
   }
 
  private:
+  friend ObjectPool;
   ShortestPath(QueryContext* qctx, PlanNode* node, GraphSpaceID space, bool singleShortest)
       : SingleInputNode(qctx, Kind::kShortestPath, node),
         space_(space),
@@ -231,7 +235,7 @@ class ShortestPath final : public SingleInputNode {
 class CartesianProduct final : public SingleDependencyNode {
  public:
   static CartesianProduct* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new CartesianProduct(qctx, input));
+    return qctx->objPool()->makeAndAdd<CartesianProduct>(qctx, input);
   }
 
   Status addVar(std::string varName);
@@ -244,6 +248,7 @@ class CartesianProduct final : public SingleDependencyNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   CartesianProduct(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kCartesianProduct, input) {}
 
@@ -257,7 +262,7 @@ class Subgraph final : public SingleInputNode {
                         const std::string& resultVar,
                         const std::string& currentStepVar,
                         uint32_t steps) {
-    return qctx->objPool()->add(new Subgraph(qctx, input, resultVar, currentStepVar, steps));
+    return qctx->objPool()->makeAndAdd<Subgraph>(qctx, input, resultVar, currentStepVar, steps);
   }
 
   const std::string& resultVar() const {
@@ -281,6 +286,7 @@ class Subgraph final : public SingleInputNode {
   }
 
  private:
+  friend ObjectPool;
   Subgraph(QueryContext* qctx,
            PlanNode* input,
            const std::string& resultVar,
@@ -300,12 +306,13 @@ class Subgraph final : public SingleInputNode {
 class BiCartesianProduct final : public BinaryInputNode {
  public:
   static BiCartesianProduct* make(QueryContext* qctx, PlanNode* left, PlanNode* right) {
-    return qctx->objPool()->add(new BiCartesianProduct(qctx, left, right));
+    return qctx->objPool()->makeAndAdd<BiCartesianProduct>(qctx, left, right);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   BiCartesianProduct(QueryContext* qctx, PlanNode* left, PlanNode* right);
 };
 }  // namespace graph
diff --git a/src/graph/planner/plan/Logic.h b/src/graph/planner/plan/Logic.h
index ee34599c3e2..a8cbd9f791a 100644
--- a/src/graph/planner/plan/Logic.h
+++ b/src/graph/planner/plan/Logic.h
@@ -15,12 +15,13 @@ namespace graph {
 class StartNode final : public PlanNode {
  public:
   static StartNode* make(QueryContext* qctx) {
-    return qctx->objPool()->add(new StartNode(qctx));
+    return qctx->objPool()->makeAndAdd<StartNode>(qctx);
   }
 
   PlanNode* clone() const override;
 
  private:
+  friend ObjectPool;
   explicit StartNode(QueryContext* qctx) : PlanNode(qctx, Kind::kStart) {}
 
   void cloneMembers(const StartNode&);
@@ -56,7 +57,7 @@ class Select final : public BinarySelect {
                       PlanNode* ifBranch = nullptr,
                       PlanNode* elseBranch = nullptr,
                       Expression* condition = nullptr) {
-    return qctx->objPool()->add(new Select(qctx, input, ifBranch, elseBranch, condition));
+    return qctx->objPool()->makeAndAdd<Select>(qctx, input, ifBranch, elseBranch, condition);
   }
 
   void setIf(PlanNode* ifBranch) {
@@ -80,6 +81,7 @@ class Select final : public BinarySelect {
   PlanNode* clone() const override;
 
  private:
+  friend ObjectPool;
   Select(QueryContext* qctx,
          PlanNode* input,
          PlanNode* ifBranch,
@@ -101,7 +103,7 @@ class Loop final : public BinarySelect {
                     PlanNode* input,
                     PlanNode* body = nullptr,
                     Expression* condition = nullptr) {
-    return qctx->objPool()->add(new Loop(qctx, input, body, condition));
+    return qctx->objPool()->makeAndAdd<Loop>(qctx, input, body, condition);
   }
 
   void setBody(PlanNode* body) {
@@ -117,6 +119,7 @@ class Loop final : public BinarySelect {
   PlanNode* clone() const override;
 
  private:
+  friend ObjectPool;
   Loop(QueryContext* qctx, PlanNode* input, PlanNode* body, Expression* condition)
       : BinarySelect(qctx, Kind::kLoop, input, condition), body_(body) {}
 
@@ -130,12 +133,13 @@ class Loop final : public BinarySelect {
 class PassThroughNode final : public SingleInputNode {
  public:
   static PassThroughNode* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new PassThroughNode(qctx, input));
+    return qctx->objPool()->makeAndAdd<PassThroughNode>(qctx, input);
   }
 
   PlanNode* clone() const override;
 
  private:
+  friend ObjectPool;
   PassThroughNode(QueryContext* qctx, PlanNode* input)
       : SingleInputNode(qctx, Kind::kPassThrough, input) {}
 
@@ -146,7 +150,7 @@ class PassThroughNode final : public SingleInputNode {
 class Argument final : public SingleInputNode {
  public:
   static Argument* make(QueryContext* qctx, std::string alias, const PlanNode* dep = nullptr) {
-    return qctx->objPool()->add(new Argument(qctx, alias, dep));
+    return qctx->objPool()->makeAndAdd<Argument>(qctx, alias, dep);
   }
 
   PlanNode* clone() const override;
@@ -158,6 +162,7 @@ class Argument final : public SingleInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   Argument(QueryContext* qctx, std::string alias, const PlanNode* dep = nullptr);
 
   void cloneMembers(const Argument&);
diff --git a/src/graph/planner/plan/Maintain.h b/src/graph/planner/plan/Maintain.h
index ee3a7c9c127..ff8f7f6f752 100644
--- a/src/graph/planner/plan/Maintain.h
+++ b/src/graph/planner/plan/Maintain.h
@@ -54,11 +54,12 @@ class CreateTag final : public CreateSchemaNode {
                          std::string tagName,
                          meta::cpp2::Schema schema,
                          bool ifNotExists) {
-    return qctx->objPool()->add(
-        new CreateTag(qctx, input, std::move(tagName), std::move(schema), ifNotExists));
+    return qctx->objPool()->makeAndAdd<CreateTag>(
+        qctx, input, std::move(tagName), std::move(schema), ifNotExists);
   }
 
  private:
+  friend ObjectPool;
   CreateTag(QueryContext* qctx,
             PlanNode* input,
             std::string tagName,
@@ -75,11 +76,12 @@ class CreateEdge final : public CreateSchemaNode {
                           std::string edgeName,
                           meta::cpp2::Schema schema,
                           bool ifNotExists) {
-    return qctx->objPool()->add(
-        new CreateEdge(qctx, input, std::move(edgeName), std::move(schema), ifNotExists));
+    return qctx->objPool()->makeAndAdd<CreateEdge>(
+        qctx, input, std::move(edgeName), std::move(schema), ifNotExists);
   }
 
  private:
+  friend ObjectPool;
   CreateEdge(QueryContext* qctx,
              PlanNode* input,
              std::string edgeName,
@@ -138,11 +140,12 @@ class AlterTag final : public AlterSchemaNode {
                         std::string name,
                         std::vector<meta::cpp2::AlterSchemaItem> items,
                         meta::cpp2::SchemaProp schemaProp) {
-    return qctx->objPool()->add(
-        new AlterTag(qctx, input, space, std::move(name), std::move(items), std::move(schemaProp)));
+    return qctx->objPool()->makeAndAdd<AlterTag>(
+        qctx, input, space, std::move(name), std::move(items), std::move(schemaProp));
   }
 
  private:
+  friend ObjectPool;
   AlterTag(QueryContext* qctx,
            PlanNode* input,
            GraphSpaceID space,
@@ -166,11 +169,12 @@ class AlterEdge final : public AlterSchemaNode {
                          std::string name,
                          std::vector<meta::cpp2::AlterSchemaItem> items,
                          meta::cpp2::SchemaProp schemaProp) {
-    return qctx->objPool()->add(new AlterEdge(
-        qctx, input, space, std::move(name), std::move(items), std::move(schemaProp)));
+    return qctx->objPool()->makeAndAdd<AlterEdge>(
+        qctx, input, space, std::move(name), std::move(items), std::move(schemaProp));
   }
 
  private:
+  friend ObjectPool;
   AlterEdge(QueryContext* qctx,
             PlanNode* input,
             GraphSpaceID space,
@@ -205,10 +209,11 @@ class DescSchemaNode : public SingleDependencyNode {
 class DescTag final : public DescSchemaNode {
  public:
   static DescTag* make(QueryContext* qctx, PlanNode* input, std::string tagName) {
-    return qctx->objPool()->add(new DescTag(qctx, input, std::move(tagName)));
+    return qctx->objPool()->makeAndAdd<DescTag>(qctx, input, std::move(tagName));
   }
 
  private:
+  friend ObjectPool;
   DescTag(QueryContext* qctx, PlanNode* input, std::string tagName)
       : DescSchemaNode(qctx, input, Kind::kDescTag, std::move(tagName)) {}
 };
@@ -216,10 +221,11 @@ class DescTag final : public DescSchemaNode {
 class DescEdge final : public DescSchemaNode {
  public:
   static DescEdge* make(QueryContext* qctx, PlanNode* input, std::string edgeName) {
-    return qctx->objPool()->add(new DescEdge(qctx, input, std::move(edgeName)));
+    return qctx->objPool()->makeAndAdd<DescEdge>(qctx, input, std::move(edgeName));
   }
 
  private:
+  friend ObjectPool;
   DescEdge(QueryContext* qctx, PlanNode* input, std::string edgeName)
       : DescSchemaNode(qctx, input, Kind::kDescEdge, std::move(edgeName)) {}
 };
@@ -227,10 +233,11 @@ class DescEdge final : public DescSchemaNode {
 class ShowCreateTag final : public DescSchemaNode {
  public:
   static ShowCreateTag* make(QueryContext* qctx, PlanNode* input, std::string name) {
-    return qctx->objPool()->add(new ShowCreateTag(qctx, input, std::move(name)));
+    return qctx->objPool()->makeAndAdd<ShowCreateTag>(qctx, input, std::move(name));
   }
 
  private:
+  friend ObjectPool;
   ShowCreateTag(QueryContext* qctx, PlanNode* input, std::string name)
       : DescSchemaNode(qctx, input, Kind::kShowCreateTag, std::move(name)) {}
 };
@@ -238,10 +245,11 @@ class ShowCreateTag final : public DescSchemaNode {
 class ShowCreateEdge final : public DescSchemaNode {
  public:
   static ShowCreateEdge* make(QueryContext* qctx, PlanNode* input, std::string name) {
-    return qctx->objPool()->add(new ShowCreateEdge(qctx, input, std::move(name)));
+    return qctx->objPool()->makeAndAdd<ShowCreateEdge>(qctx, input, std::move(name));
   }
 
  private:
+  friend ObjectPool;
   ShowCreateEdge(QueryContext* qctx, PlanNode* input, std::string name)
       : DescSchemaNode(qctx, input, Kind::kShowCreateEdge, std::move(name)) {}
 };
@@ -249,10 +257,11 @@ class ShowCreateEdge final : public DescSchemaNode {
 class ShowTags final : public SingleDependencyNode {
  public:
   static ShowTags* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowTags(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowTags>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowTags(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowTags, input) {}
 };
@@ -260,10 +269,11 @@ class ShowTags final : public SingleDependencyNode {
 class ShowEdges final : public SingleDependencyNode {
  public:
   static ShowEdges* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowEdges(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowEdges>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowEdges(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowEdges, input) {}
 };
@@ -292,10 +302,11 @@ class DropSchemaNode : public SingleDependencyNode {
 class DropTag final : public DropSchemaNode {
  public:
   static DropTag* make(QueryContext* qctx, PlanNode* input, std::string name, bool ifExists) {
-    return qctx->objPool()->add(new DropTag(qctx, input, std::move(name), ifExists));
+    return qctx->objPool()->makeAndAdd<DropTag>(qctx, input, std::move(name), ifExists);
   }
 
  private:
+  friend ObjectPool;
   DropTag(QueryContext* qctx, PlanNode* input, std::string name, bool ifExists)
       : DropSchemaNode(qctx, Kind::kDropTag, input, std::move(name), ifExists) {}
 };
@@ -303,10 +314,11 @@ class DropTag final : public DropSchemaNode {
 class DropEdge final : public DropSchemaNode {
  public:
   static DropEdge* make(QueryContext* qctx, PlanNode* input, std::string name, bool ifExists) {
-    return qctx->objPool()->add(new DropEdge(qctx, input, std::move(name), ifExists));
+    return qctx->objPool()->makeAndAdd<DropEdge>(qctx, input, std::move(name), ifExists);
   }
 
  private:
+  friend ObjectPool;
   DropEdge(QueryContext* qctx, PlanNode* input, std::string name, bool ifExists)
       : DropSchemaNode(qctx, Kind::kDropEdge, input, std::move(name), ifExists) {}
 };
@@ -376,17 +388,18 @@ class CreateTagIndex final : public CreateIndexNode {
                               bool ifNotExists,
                               std::unique_ptr<meta::cpp2::IndexParams> indexParams,
                               const std::string* comment) {
-    return qctx->objPool()->add(new CreateTagIndex(qctx,
-                                                   input,
-                                                   std::move(tagName),
-                                                   std::move(indexName),
-                                                   std::move(fields),
-                                                   ifNotExists,
-                                                   std::move(indexParams),
-                                                   comment));
+    return qctx->objPool()->makeAndAdd<CreateTagIndex>(qctx,
+                                                       input,
+                                                       std::move(tagName),
+                                                       std::move(indexName),
+                                                       std::move(fields),
+                                                       ifNotExists,
+                                                       std::move(indexParams),
+                                                       comment);
   }
 
  private:
+  friend ObjectPool;
   CreateTagIndex(QueryContext* qctx,
                  PlanNode* input,
                  std::string tagName,
@@ -416,17 +429,18 @@ class CreateEdgeIndex final : public CreateIndexNode {
                                bool ifNotExists,
                                std::unique_ptr<meta::cpp2::IndexParams> indexParams,
                                const std::string* comment) {
-    return qctx->objPool()->add(new CreateEdgeIndex(qctx,
-                                                    input,
-                                                    std::move(edgeName),
-                                                    std::move(indexName),
-                                                    std::move(fields),
-                                                    ifNotExists,
-                                                    std::move(indexParams),
-                                                    comment));
+    return qctx->objPool()->makeAndAdd<CreateEdgeIndex>(qctx,
+                                                        input,
+                                                        std::move(edgeName),
+                                                        std::move(indexName),
+                                                        std::move(fields),
+                                                        ifNotExists,
+                                                        std::move(indexParams),
+                                                        comment);
   }
 
  private:
+  friend ObjectPool;
   CreateEdgeIndex(QueryContext* qctx,
                   PlanNode* input,
                   std::string edgeName,
@@ -465,10 +479,11 @@ class DescIndexNode : public SingleDependencyNode {
 class DescTagIndex final : public DescIndexNode {
  public:
   static DescTagIndex* make(QueryContext* qctx, PlanNode* input, std::string indexName) {
-    return qctx->objPool()->add(new DescTagIndex(qctx, input, std::move(indexName)));
+    return qctx->objPool()->makeAndAdd<DescTagIndex>(qctx, input, std::move(indexName));
   }
 
  private:
+  friend ObjectPool;
   DescTagIndex(QueryContext* qctx, PlanNode* input, std::string indexName)
       : DescIndexNode(qctx, input, Kind::kDescTagIndex, std::move(indexName)) {}
 };
@@ -476,10 +491,11 @@ class DescTagIndex final : public DescIndexNode {
 class DescEdgeIndex final : public DescIndexNode {
  public:
   static DescEdgeIndex* make(QueryContext* qctx, PlanNode* input, std::string indexName) {
-    return qctx->objPool()->add(new DescEdgeIndex(qctx, input, std::move(indexName)));
+    return qctx->objPool()->makeAndAdd<DescEdgeIndex>(qctx, input, std::move(indexName));
   }
 
  private:
+  friend ObjectPool;
   DescEdgeIndex(QueryContext* qctx, PlanNode* input, std::string indexName)
       : DescIndexNode(qctx, input, Kind::kDescEdgeIndex, std::move(indexName)) {}
 };
@@ -514,10 +530,11 @@ class DropTagIndex final : public DropIndexNode {
                             PlanNode* input,
                             std::string indexName,
                             bool ifExists) {
-    return qctx->objPool()->add(new DropTagIndex(qctx, input, std::move(indexName), ifExists));
+    return qctx->objPool()->makeAndAdd<DropTagIndex>(qctx, input, std::move(indexName), ifExists);
   }
 
  private:
+  friend ObjectPool;
   DropTagIndex(QueryContext* qctx, PlanNode* input, std::string indexName, bool ifExists)
       : DropIndexNode(qctx, Kind::kDropTagIndex, input, std::move(indexName), ifExists) {}
 };
@@ -528,10 +545,11 @@ class DropEdgeIndex final : public DropIndexNode {
                              PlanNode* input,
                              std::string indexName,
                              bool ifExists) {
-    return qctx->objPool()->add(new DropEdgeIndex(qctx, input, std::move(indexName), ifExists));
+    return qctx->objPool()->makeAndAdd<DropEdgeIndex>(qctx, input, std::move(indexName), ifExists);
   }
 
  private:
+  friend ObjectPool;
   DropEdgeIndex(QueryContext* qctx, PlanNode* input, std::string indexName, bool ifExists)
       : DropIndexNode(qctx, Kind::kDropEdgeIndex, input, std::move(indexName), ifExists) {}
 };
@@ -539,10 +557,11 @@ class DropEdgeIndex final : public DropIndexNode {
 class ShowCreateTagIndex final : public DescIndexNode {
  public:
   static ShowCreateTagIndex* make(QueryContext* qctx, PlanNode* input, std::string indexName) {
-    return qctx->objPool()->add(new ShowCreateTagIndex(qctx, input, std::move(indexName)));
+    return qctx->objPool()->makeAndAdd<ShowCreateTagIndex>(qctx, input, std::move(indexName));
   }
 
  private:
+  friend ObjectPool;
   ShowCreateTagIndex(QueryContext* qctx, PlanNode* input, std::string indexName)
       : DescIndexNode(qctx, input, Kind::kShowCreateTagIndex, std::move(indexName)) {}
 };
@@ -550,10 +569,11 @@ class ShowCreateTagIndex final : public DescIndexNode {
 class ShowCreateEdgeIndex final : public DescIndexNode {
  public:
   static ShowCreateEdgeIndex* make(QueryContext* qctx, PlanNode* input, std::string indexName) {
-    return qctx->objPool()->add(new ShowCreateEdgeIndex(qctx, input, std::move(indexName)));
+    return qctx->objPool()->makeAndAdd<ShowCreateEdgeIndex>(qctx, input, std::move(indexName));
   }
 
  private:
+  friend ObjectPool;
   ShowCreateEdgeIndex(QueryContext* qctx, PlanNode* input, std::string indexName)
       : DescIndexNode(qctx, input, Kind::kShowCreateEdgeIndex, std::move(indexName)) {}
 };
@@ -561,7 +581,7 @@ class ShowCreateEdgeIndex final : public DescIndexNode {
 class ShowTagIndexes final : public SingleDependencyNode {
  public:
   static ShowTagIndexes* make(QueryContext* qctx, PlanNode* input, std::string name) {
-    return qctx->objPool()->add(new ShowTagIndexes(qctx, input, std::move(name)));
+    return qctx->objPool()->makeAndAdd<ShowTagIndexes>(qctx, input, std::move(name));
   }
 
   const std::string& name() const {
@@ -569,6 +589,7 @@ class ShowTagIndexes final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   ShowTagIndexes(QueryContext* qctx, PlanNode* input, std::string name)
       : SingleDependencyNode(qctx, Kind::kShowTagIndexes, input) {
     name_ = std::move(name);
@@ -581,7 +602,7 @@ class ShowTagIndexes final : public SingleDependencyNode {
 class ShowEdgeIndexes final : public SingleDependencyNode {
  public:
   static ShowEdgeIndexes* make(QueryContext* qctx, PlanNode* input, std::string name) {
-    return qctx->objPool()->add(new ShowEdgeIndexes(qctx, input, std::move(name)));
+    return qctx->objPool()->makeAndAdd<ShowEdgeIndexes>(qctx, input, std::move(name));
   }
 
   const std::string& name() const {
@@ -589,6 +610,7 @@ class ShowEdgeIndexes final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   ShowEdgeIndexes(QueryContext* qctx, PlanNode* input, std::string name)
       : SingleDependencyNode(qctx, Kind::kShowEdgeIndexes, input) {
     name_ = std::move(name);
@@ -601,10 +623,11 @@ class ShowEdgeIndexes final : public SingleDependencyNode {
 class ShowTagIndexStatus final : public SingleDependencyNode {
  public:
   static ShowTagIndexStatus* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowTagIndexStatus(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowTagIndexStatus>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowTagIndexStatus(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowTagIndexStatus, input) {}
 };
@@ -612,10 +635,11 @@ class ShowTagIndexStatus final : public SingleDependencyNode {
 class ShowEdgeIndexStatus final : public SingleDependencyNode {
  public:
   static ShowEdgeIndexStatus* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowEdgeIndexStatus(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowEdgeIndexStatus>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowEdgeIndexStatus(QueryContext* qctx, PlanNode* input)
       : SingleDependencyNode(qctx, Kind::kShowEdgeIndexStatus, input) {}
 };
@@ -652,11 +676,12 @@ class CreateFTIndex final : public CreateFTIndexNode {
                              PlanNode* input,
                              std::string indexName,
                              meta::cpp2::FTIndex index) {
-    return qctx->objPool()->add(
-        new CreateFTIndex(qctx, input, std::move(indexName), std::move(index)));
+    return qctx->objPool()->makeAndAdd<CreateFTIndex>(
+        qctx, input, std::move(indexName), std::move(index));
   }
 
  private:
+  friend ObjectPool;
   CreateFTIndex(QueryContext* qctx,
                 PlanNode* input,
                 std::string indexName,
@@ -684,10 +709,11 @@ class DropFTIndexNode : public SingleInputNode {
 class DropFTIndex final : public DropFTIndexNode {
  public:
   static DropFTIndex* make(QueryContext* qctx, PlanNode* input, std::string name) {
-    return qctx->objPool()->add(new DropFTIndex(qctx, input, std::move(name)));
+    return qctx->objPool()->makeAndAdd<DropFTIndex>(qctx, input, std::move(name));
   }
 
  private:
+  friend ObjectPool;
   DropFTIndex(QueryContext* qctx, PlanNode* input, std::string name)
       : DropFTIndexNode(qctx, Kind::kDropFTIndex, input, std::move(name)) {}
 };
@@ -695,10 +721,11 @@ class DropFTIndex final : public DropFTIndexNode {
 class ShowFTIndexes final : public SingleInputNode {
  public:
   static ShowFTIndexes* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new ShowFTIndexes(qctx, input));
+    return qctx->objPool()->makeAndAdd<ShowFTIndexes>(qctx, input);
   }
 
  private:
+  friend ObjectPool;
   ShowFTIndexes(QueryContext* qctx, PlanNode* input)
       : SingleInputNode(qctx, Kind::kShowFTIndexes, input) {}
 };
diff --git a/src/graph/planner/plan/Mutate.h b/src/graph/planner/plan/Mutate.h
index a45d01dff69..4ee4e8d7b4c 100644
--- a/src/graph/planner/plan/Mutate.h
+++ b/src/graph/planner/plan/Mutate.h
@@ -22,13 +22,13 @@ class InsertVertices final : public SingleDependencyNode {
                               std::unordered_map<TagID, std::vector<std::string>> tagPropNames,
                               bool ifNotExists,
                               bool ignoreExistedIndex) {
-    return qctx->objPool()->add(new InsertVertices(qctx,
-                                                   input,
-                                                   spaceId,
-                                                   std::move(vertices),
-                                                   std::move(tagPropNames),
-                                                   ifNotExists,
-                                                   ignoreExistedIndex));
+    return qctx->objPool()->makeAndAdd<InsertVertices>(qctx,
+                                                       input,
+                                                       spaceId,
+                                                       std::move(vertices),
+                                                       std::move(tagPropNames),
+                                                       ifNotExists,
+                                                       ignoreExistedIndex);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -54,6 +54,7 @@ class InsertVertices final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   InsertVertices(QueryContext* qctx,
                  PlanNode* input,
                  GraphSpaceID spaceId,
@@ -86,14 +87,14 @@ class InsertEdges final : public SingleDependencyNode {
                            bool ifNotExists,
                            bool ignoreExistedIndex,
                            bool useChainInsert = false) {
-    return qctx->objPool()->add(new InsertEdges(qctx,
-                                                input,
-                                                spaceId,
-                                                std::move(edges),
-                                                std::move(propNames),
-                                                ifNotExists,
-                                                ignoreExistedIndex,
-                                                useChainInsert));
+    return qctx->objPool()->makeAndAdd<InsertEdges>(qctx,
+                                                    input,
+                                                    spaceId,
+                                                    std::move(edges),
+                                                    std::move(propNames),
+                                                    ifNotExists,
+                                                    ignoreExistedIndex,
+                                                    useChainInsert);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -123,6 +124,7 @@ class InsertEdges final : public SingleDependencyNode {
   }
 
  private:
+  friend ObjectPool;
   InsertEdges(QueryContext* qctx,
               PlanNode* input,
               GraphSpaceID spaceId,
@@ -183,6 +185,7 @@ class Update : public SingleDependencyNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  protected:
+  friend ObjectPool;
   Update(QueryContext* qctx,
          Kind kind,
          PlanNode* input,
@@ -225,17 +228,17 @@ class UpdateVertex final : public Update {
                             std::vector<std::string> returnProps,
                             std::string condition,
                             std::vector<std::string> yieldNames) {
-    return qctx->objPool()->add(new UpdateVertex(qctx,
-                                                 input,
-                                                 spaceId,
-                                                 std::move(name),
-                                                 std::move(vId),
-                                                 tagId,
-                                                 insertable,
-                                                 std::move(updatedProps),
-                                                 std::move(returnProps),
-                                                 std::move(condition),
-                                                 std::move(yieldNames)));
+    return qctx->objPool()->makeAndAdd<UpdateVertex>(qctx,
+                                                     input,
+                                                     spaceId,
+                                                     std::move(name),
+                                                     std::move(vId),
+                                                     tagId,
+                                                     insertable,
+                                                     std::move(updatedProps),
+                                                     std::move(returnProps),
+                                                     std::move(condition),
+                                                     std::move(yieldNames));
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -249,6 +252,7 @@ class UpdateVertex final : public Update {
   }
 
  private:
+  friend ObjectPool;
   UpdateVertex(QueryContext* qctx,
                PlanNode* input,
                GraphSpaceID spaceId,
@@ -293,19 +297,19 @@ class UpdateEdge final : public Update {
                           std::vector<std::string> returnProps,
                           std::string condition,
                           std::vector<std::string> yieldNames) {
-    return qctx->objPool()->add(new UpdateEdge(qctx,
-                                               input,
-                                               spaceId,
-                                               std::move(name),
-                                               std::move(srcId),
-                                               std::move(dstId),
-                                               edgeType,
-                                               rank,
-                                               insertable,
-                                               std::move(updatedProps),
-                                               std::move(returnProps),
-                                               std::move(condition),
-                                               std::move(yieldNames)));
+    return qctx->objPool()->makeAndAdd<UpdateEdge>(qctx,
+                                                   input,
+                                                   spaceId,
+                                                   std::move(name),
+                                                   std::move(srcId),
+                                                   std::move(dstId),
+                                                   edgeType,
+                                                   rank,
+                                                   insertable,
+                                                   std::move(updatedProps),
+                                                   std::move(returnProps),
+                                                   std::move(condition),
+                                                   std::move(yieldNames));
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -331,6 +335,7 @@ class UpdateEdge final : public Update {
   }
 
  private:
+  friend ObjectPool;
   UpdateEdge(QueryContext* qctx,
              PlanNode* input,
              GraphSpaceID spaceId,
@@ -372,7 +377,7 @@ class DeleteVertices final : public SingleInputNode {
                               PlanNode* input,
                               GraphSpaceID spaceId,
                               Expression* vidRef_) {
-    return qctx->objPool()->add(new DeleteVertices(qctx, input, spaceId, vidRef_));
+    return qctx->objPool()->makeAndAdd<DeleteVertices>(qctx, input, spaceId, vidRef_);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -386,6 +391,7 @@ class DeleteVertices final : public SingleInputNode {
   }
 
  private:
+  friend ObjectPool;
   DeleteVertices(QueryContext* qctx, PlanNode* input, GraphSpaceID spaceId, Expression* vidRef)
       : SingleInputNode(qctx, Kind::kDeleteVertices, input), space_(spaceId), vidRef_(vidRef) {}
 
@@ -401,7 +407,7 @@ class DeleteTags final : public SingleInputNode {
                           GraphSpaceID spaceId,
                           Expression* vidRef,
                           std::vector<TagID> tagIds) {
-    return qctx->objPool()->add(new DeleteTags(qctx, input, spaceId, vidRef, tagIds));
+    return qctx->objPool()->makeAndAdd<DeleteTags>(qctx, input, spaceId, vidRef, tagIds);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -419,6 +425,7 @@ class DeleteTags final : public SingleInputNode {
   }
 
  private:
+  friend ObjectPool;
   DeleteTags(QueryContext* qctx,
              PlanNode* input,
              GraphSpaceID spaceId,
@@ -441,7 +448,7 @@ class DeleteEdges final : public SingleInputNode {
                            PlanNode* input,
                            GraphSpaceID spaceId,
                            EdgeKeyRef* edgeKeyRef) {
-    return qctx->objPool()->add(new DeleteEdges(qctx, input, spaceId, edgeKeyRef));
+    return qctx->objPool()->makeAndAdd<DeleteEdges>(qctx, input, spaceId, edgeKeyRef);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -455,6 +462,7 @@ class DeleteEdges final : public SingleInputNode {
   }
 
  private:
+  friend ObjectPool;
   DeleteEdges(QueryContext* qctx, PlanNode* input, GraphSpaceID spaceId, EdgeKeyRef* edgeKeyRef)
       : SingleInputNode(qctx, Kind::kDeleteEdges, input),
         space_(spaceId),
diff --git a/src/graph/planner/plan/Query.cpp b/src/graph/planner/plan/Query.cpp
index b3b6403a086..aa1c8bed387 100644
--- a/src/graph/planner/plan/Query.cpp
+++ b/src/graph/planner/plan/Query.cpp
@@ -354,7 +354,7 @@ PlanNode* Project::clone() const {
 void Project::cloneMembers(const Project& p) {
   SingleInputNode::cloneMembers(p);
 
-  cols_ = qctx_->objPool()->add(new YieldColumns());
+  cols_ = qctx_->objPool()->makeAndAdd<YieldColumns>();
   for (const auto& col : p.columns()->columns()) {
     cols_->addColumn(col->clone().release());
   }
diff --git a/src/graph/planner/plan/Query.h b/src/graph/planner/plan/Query.h
index b9760ae4eb8..8144e27ef5d 100644
--- a/src/graph/planner/plan/Query.h
+++ b/src/graph/planner/plan/Query.h
@@ -138,7 +138,7 @@ using Direction = nebula::storage::cpp2::EdgeDirection;
 class GetNeighbors : public Explore {
  public:
   static GetNeighbors* make(QueryContext* qctx, PlanNode* input, GraphSpaceID space) {
-    return qctx->objPool()->add(new GetNeighbors(qctx, Kind::kGetNeighbors, input, space));
+    return qctx->objPool()->makeAndAdd<GetNeighbors>(qctx, Kind::kGetNeighbors, input, space);
   }
 
   static GetNeighbors* make(QueryContext* qctx,
@@ -240,6 +240,7 @@ class GetNeighbors : public Explore {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  protected:
+  friend ObjectPool;
   GetNeighbors(QueryContext* qctx, Kind kind, PlanNode* input, GraphSpaceID space)
       : Explore(qctx, kind, input, space) {
     setLimit(-1);
@@ -271,17 +272,17 @@ class GetVertices : public Explore {
                            std::vector<storage::cpp2::OrderBy> orderBy = {},
                            int64_t limit = std::numeric_limits<int64_t>::max(),
                            Expression* filter = nullptr) {
-    return qctx->objPool()->add(new GetVertices(qctx,
-                                                Kind::kGetVertices,
-                                                input,
-                                                space,
-                                                src,
-                                                std::move(props),
-                                                std::move(exprs),
-                                                dedup,
-                                                std::move(orderBy),
-                                                limit,
-                                                filter));
+    return qctx->objPool()->makeAndAdd<GetVertices>(qctx,
+                                                    Kind::kGetVertices,
+                                                    input,
+                                                    space,
+                                                    src,
+                                                    std::move(props),
+                                                    std::move(exprs),
+                                                    dedup,
+                                                    std::move(orderBy),
+                                                    limit,
+                                                    filter);
   }
 
   Expression* src() const {
@@ -312,6 +313,7 @@ class GetVertices : public Explore {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  protected:
+  friend ObjectPool;
   GetVertices(QueryContext* qctx,
               Kind kind,
               PlanNode* input,
@@ -355,19 +357,19 @@ class GetEdges final : public Explore {
                         int64_t limit = std::numeric_limits<int64_t>::max(),
                         std::vector<storage::cpp2::OrderBy> orderBy = {},
                         Expression* filter = nullptr) {
-    return qctx->objPool()->add(new GetEdges(qctx,
-                                             input,
-                                             space,
-                                             src,
-                                             type,
-                                             ranking,
-                                             dst,
-                                             std::move(props),
-                                             std::move(exprs),
-                                             dedup,
-                                             limit,
-                                             std::move(orderBy),
-                                             filter));
+    return qctx->objPool()->makeAndAdd<GetEdges>(qctx,
+                                                 input,
+                                                 space,
+                                                 src,
+                                                 type,
+                                                 ranking,
+                                                 dst,
+                                                 std::move(props),
+                                                 std::move(exprs),
+                                                 dedup,
+                                                 limit,
+                                                 std::move(orderBy),
+                                                 filter);
   }
 
   Expression* src() const {
@@ -406,6 +408,7 @@ class GetEdges final : public Explore {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   GetEdges(QueryContext* qctx,
            PlanNode* input,
            GraphSpaceID space,
@@ -458,18 +461,18 @@ class IndexScan : public Explore {
                          std::vector<storage::cpp2::OrderBy> orderBy = {},
                          int64_t limit = std::numeric_limits<int64_t>::max(),
                          Expression* filter = nullptr) {
-    return qctx->objPool()->add(new IndexScan(qctx,
-                                              input,
-                                              space,
-                                              std::move(contexts),
-                                              std::move(returnCols),
-                                              isEdge,
-                                              schemaId,
-                                              isEmptyResultSet,
-                                              dedup,
-                                              std::move(orderBy),
-                                              limit,
-                                              filter));
+    return qctx->objPool()->makeAndAdd<IndexScan>(qctx,
+                                                  input,
+                                                  space,
+                                                  std::move(contexts),
+                                                  std::move(returnCols),
+                                                  isEdge,
+                                                  schemaId,
+                                                  isEmptyResultSet,
+                                                  dedup,
+                                                  std::move(orderBy),
+                                                  limit,
+                                                  filter);
   }
 
   const std::vector<IndexQueryContext>& queryContext() const {
@@ -524,6 +527,7 @@ class IndexScan : public Explore {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  protected:
+  friend ObjectPool;
   IndexScan(QueryContext* qctx,
             PlanNode* input,
             GraphSpaceID space,
@@ -570,15 +574,15 @@ class ScanVertices final : public Explore {
                             std::vector<storage::cpp2::OrderBy> orderBy = {},
                             int64_t limit = -1,
                             Expression* filter = nullptr) {
-    return qctx->objPool()->add(new ScanVertices(qctx,
-                                                 input,
-                                                 space,
-                                                 std::move(props),
-                                                 std::move(exprs),
-                                                 dedup,
-                                                 std::move(orderBy),
-                                                 limit,
-                                                 filter));
+    return qctx->objPool()->makeAndAdd<ScanVertices>(qctx,
+                                                     input,
+                                                     space,
+                                                     std::move(props),
+                                                     std::move(exprs),
+                                                     dedup,
+                                                     std::move(orderBy),
+                                                     limit,
+                                                     filter);
   }
 
   const std::vector<VertexProp>* props() const {
@@ -601,6 +605,7 @@ class ScanVertices final : public Explore {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   ScanVertices(QueryContext* qctx,
                PlanNode* input,
                GraphSpaceID space,
@@ -635,15 +640,15 @@ class ScanEdges final : public Explore {
                          int64_t limit = -1,
                          std::vector<storage::cpp2::OrderBy> orderBy = {},
                          Expression* filter = nullptr) {
-    return qctx->objPool()->add(new ScanEdges(qctx,
-                                              input,
-                                              space,
-                                              std::move(props),
-                                              std::move(exprs),
-                                              dedup,
-                                              limit,
-                                              std::move(orderBy),
-                                              filter));
+    return qctx->objPool()->makeAndAdd<ScanEdges>(qctx,
+                                                  input,
+                                                  space,
+                                                  std::move(props),
+                                                  std::move(exprs),
+                                                  dedup,
+                                                  limit,
+                                                  std::move(orderBy),
+                                                  filter);
   }
 
   const std::vector<EdgeProp>* props() const {
@@ -666,6 +671,7 @@ class ScanEdges final : public Explore {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   ScanEdges(QueryContext* qctx,
             PlanNode* input,
             GraphSpaceID space,
@@ -695,7 +701,7 @@ class Filter final : public SingleInputNode {
                       PlanNode* input,
                       Expression* condition = nullptr,
                       bool needStableFilter = false) {
-    return qctx->objPool()->add(new Filter(qctx, input, condition, needStableFilter));
+    return qctx->objPool()->makeAndAdd<Filter>(qctx, input, condition, needStableFilter);
   }
 
   Expression* condition() const {
@@ -716,6 +722,7 @@ class Filter final : public SingleInputNode {
   void accept(PlanNodeVisitor* visitor) override;
 
  private:
+  friend ObjectPool;
   Filter(QueryContext* qctx, PlanNode* input, Expression* condition, bool needStableFilter);
   void cloneMembers(const Filter&);
 
@@ -743,12 +750,13 @@ class SetOp : public BinaryInputNode {
 class Union final : public SetOp {
  public:
   static Union* make(QueryContext* qctx, PlanNode* left, PlanNode* right) {
-    return qctx->objPool()->add(new Union(qctx, left, right));
+    return qctx->objPool()->makeAndAdd<Union>(qctx, left, right);
   }
 
   PlanNode* clone() const override;
 
  private:
+  friend ObjectPool;
   Union(QueryContext* qctx, PlanNode* left, PlanNode* right)
       : SetOp(qctx, Kind::kUnion, left, right) {}
 
@@ -759,12 +767,13 @@ class Union final : public SetOp {
 class Intersect final : public SetOp {
  public:
   static Intersect* make(QueryContext* qctx, PlanNode* left, PlanNode* right) {
-    return qctx->objPool()->add(new Intersect(qctx, left, right));
+    return qctx->objPool()->makeAndAdd<Intersect>(qctx, left, right);
   }
 
   PlanNode* clone() const override;
 
  private:
+  friend ObjectPool;
   Intersect(QueryContext* qctx, PlanNode* left, PlanNode* right)
       : SetOp(qctx, Kind::kIntersect, left, right) {}
 
@@ -775,12 +784,13 @@ class Intersect final : public SetOp {
 class Minus final : public SetOp {
  public:
   static Minus* make(QueryContext* qctx, PlanNode* left, PlanNode* right) {
-    return qctx->objPool()->add(new Minus(qctx, left, right));
+    return qctx->objPool()->makeAndAdd<Minus>(qctx, left, right);
   }
 
   PlanNode* clone() const override;
 
  private:
+  friend ObjectPool;
   Minus(QueryContext* qctx, PlanNode* left, PlanNode* right)
       : SetOp(qctx, Kind::kMinus, left, right) {}
 
@@ -791,7 +801,7 @@ class Minus final : public SetOp {
 class Project final : public SingleInputNode {
  public:
   static Project* make(QueryContext* qctx, PlanNode* input, YieldColumns* cols = nullptr) {
-    return qctx->objPool()->add(new Project(qctx, input, cols));
+    return qctx->objPool()->makeAndAdd<Project>(qctx, input, cols);
   }
 
   const YieldColumns* columns() const {
@@ -804,6 +814,7 @@ class Project final : public SingleInputNode {
   void accept(PlanNodeVisitor* visitor) override;
 
  private:
+  friend ObjectPool;
   Project(QueryContext* qctx, PlanNode* input, YieldColumns* cols);
 
   void cloneMembers(const Project&);
@@ -819,7 +830,7 @@ class Unwind final : public SingleInputNode {
                       PlanNode* input,
                       Expression* unwindExpr = nullptr,
                       std::string alias = "") {
-    return qctx->objPool()->add(new Unwind(qctx, input, unwindExpr, alias));
+    return qctx->objPool()->makeAndAdd<Unwind>(qctx, input, unwindExpr, alias);
   }
 
   Expression* unwindExpr() const {
@@ -834,6 +845,7 @@ class Unwind final : public SingleInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   Unwind(QueryContext* qctx, PlanNode* input, Expression* unwindExpr, std::string alias)
       : SingleInputNode(qctx, Kind::kUnwind, input), unwindExpr_(unwindExpr), alias_(alias) {}
 
@@ -850,7 +862,7 @@ class Sort final : public SingleInputNode {
   static Sort* make(QueryContext* qctx,
                     PlanNode* input,
                     std::vector<std::pair<size_t, OrderFactor::OrderType>> factors = {}) {
-    return qctx->objPool()->add(new Sort(qctx, input, std::move(factors)));
+    return qctx->objPool()->makeAndAdd<Sort>(qctx, input, std::move(factors));
   }
 
   const std::vector<std::pair<size_t, OrderFactor::OrderType>>& factors() const {
@@ -861,6 +873,7 @@ class Sort final : public SingleInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   Sort(QueryContext* qctx,
        PlanNode* input,
        std::vector<std::pair<size_t, OrderFactor::OrderType>> factors)
@@ -892,14 +905,14 @@ class Sort final : public SingleInputNode {
 class Limit final : public SingleInputNode {
  public:
   static Limit* make(QueryContext* qctx, PlanNode* input, int64_t offset = -1, int64_t count = -1) {
-    return qctx->objPool()->add(new Limit(qctx, input, offset, count));
+    return qctx->objPool()->makeAndAdd<Limit>(qctx, input, offset, count);
   }
 
   static Limit* make(QueryContext* qctx,
                      PlanNode* input,
                      int64_t offset = -1,
                      Expression* count = nullptr) {
-    return qctx->objPool()->add(new Limit(qctx, input, offset, count));
+    return qctx->objPool()->makeAndAdd<Limit>(qctx, input, offset, count);
   }
 
   int64_t offset() const {
@@ -927,6 +940,7 @@ class Limit final : public SingleInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   Limit(QueryContext* qctx, PlanNode* input, int64_t offset, int64_t count)
       : SingleInputNode(qctx, Kind::kLimit, input) {
     offset_ = offset;
@@ -954,7 +968,7 @@ class TopN final : public SingleInputNode {
                     std::vector<std::pair<size_t, OrderFactor::OrderType>> factors = {},
                     int64_t offset = 0,
                     int64_t count = 0) {
-    return qctx->objPool()->add(new TopN(qctx, input, std::move(factors), offset, count));
+    return qctx->objPool()->makeAndAdd<TopN>(qctx, input, std::move(factors), offset, count);
   }
 
   const std::vector<std::pair<size_t, OrderFactor::OrderType>>& factors() const {
@@ -973,6 +987,7 @@ class TopN final : public SingleInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   TopN(QueryContext* qctx,
        PlanNode* input,
        std::vector<std::pair<size_t, OrderFactor::OrderType>> factors,
@@ -1012,11 +1027,11 @@ class TopN final : public SingleInputNode {
 class Sample final : public SingleInputNode {
  public:
   static Sample* make(QueryContext* qctx, PlanNode* input, const int64_t count) {
-    return qctx->objPool()->add(new Sample(qctx, input, count));
+    return qctx->objPool()->makeAndAdd<Sample>(qctx, input, count);
   }
 
   static Sample* make(QueryContext* qctx, PlanNode* input, Expression* count) {
-    return qctx->objPool()->add(new Sample(qctx, input, count));
+    return qctx->objPool()->makeAndAdd<Sample>(qctx, input, count);
   }
 
   // Get constant count
@@ -1046,6 +1061,7 @@ class Sample final : public SingleInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   Sample(QueryContext* qctx, PlanNode* input, int64_t count)
       : SingleInputNode(qctx, Kind::kSample, input),
         count_(ConstantExpression::make(qctx->objPool(), count)) {}
@@ -1067,8 +1083,8 @@ class Aggregate final : public SingleInputNode {
                          PlanNode* input,
                          std::vector<Expression*>&& groupKeys = {},
                          std::vector<Expression*>&& groupItems = {}) {
-    return qctx->objPool()->add(
-        new Aggregate(qctx, input, std::move(groupKeys), std::move(groupItems)));
+    return qctx->objPool()->makeAndAdd<Aggregate>(
+        qctx, input, std::move(groupKeys), std::move(groupItems));
   }
 
   const std::vector<Expression*>& groupKeys() const {
@@ -1085,6 +1101,7 @@ class Aggregate final : public SingleInputNode {
   void accept(PlanNodeVisitor* visitor) override;
 
  private:
+  friend ObjectPool;
   Aggregate(QueryContext* qctx,
             PlanNode* input,
             std::vector<Expression*>&& groupKeys,
@@ -1105,7 +1122,7 @@ class Aggregate final : public SingleInputNode {
 class SwitchSpace final : public SingleInputNode {
  public:
   static SwitchSpace* make(QueryContext* qctx, PlanNode* input, std::string spaceName) {
-    return qctx->objPool()->add(new SwitchSpace(qctx, input, spaceName));
+    return qctx->objPool()->makeAndAdd<SwitchSpace>(qctx, input, spaceName);
   }
 
   const std::string& getSpaceName() const {
@@ -1116,6 +1133,7 @@ class SwitchSpace final : public SingleInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   SwitchSpace(QueryContext* qctx, PlanNode* input, std::string spaceName)
       : SingleInputNode(qctx, Kind::kSwitchSpace, input) {
     spaceName_ = std::move(spaceName);
@@ -1131,12 +1149,13 @@ class SwitchSpace final : public SingleInputNode {
 class Dedup final : public SingleInputNode {
  public:
   static Dedup* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new Dedup(qctx, input));
+    return qctx->objPool()->makeAndAdd<Dedup>(qctx, input);
   }
 
   PlanNode* clone() const override;
 
  private:
+  friend ObjectPool;
   Dedup(QueryContext* qctx, PlanNode* input);
 
   void cloneMembers(const Dedup&);
@@ -1156,7 +1175,7 @@ class DataCollect final : public VariableDependencyNode {
   };
 
   static DataCollect* make(QueryContext* qctx, DCKind kind) {
-    return qctx->objPool()->add(new DataCollect(qctx, kind));
+    return qctx->objPool()->makeAndAdd<DataCollect>(qctx, kind);
   }
 
   void setMToN(StepClause step) {
@@ -1206,6 +1225,7 @@ class DataCollect final : public VariableDependencyNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   DataCollect(QueryContext* qctx, DCKind kind)
       : VariableDependencyNode(qctx, Kind::kDataCollect), kind_(kind) {}
 
@@ -1287,18 +1307,19 @@ class LeftJoin final : public Join {
                         std::pair<std::string, int64_t> rightVar,
                         std::vector<Expression*> hashKeys = {},
                         std::vector<Expression*> probeKeys = {}) {
-    return qctx->objPool()->add(new LeftJoin(qctx,
-                                             input,
-                                             std::move(leftVar),
-                                             std::move(rightVar),
-                                             std::move(hashKeys),
-                                             std::move(probeKeys)));
+    return qctx->objPool()->makeAndAdd<LeftJoin>(qctx,
+                                                 input,
+                                                 std::move(leftVar),
+                                                 std::move(rightVar),
+                                                 std::move(hashKeys),
+                                                 std::move(probeKeys));
   }
 
   PlanNode* clone() const override;
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   LeftJoin(QueryContext* qctx,
            PlanNode* input,
            std::pair<std::string, int64_t> leftVar,
@@ -1325,18 +1346,19 @@ class InnerJoin final : public Join {
                          std::pair<std::string, int64_t> rightVar,
                          std::vector<Expression*> hashKeys = {},
                          std::vector<Expression*> probeKeys = {}) {
-    return qctx->objPool()->add(new InnerJoin(qctx,
-                                              input,
-                                              std::move(leftVar),
-                                              std::move(rightVar),
-                                              std::move(hashKeys),
-                                              std::move(probeKeys)));
+    return qctx->objPool()->makeAndAdd<InnerJoin>(qctx,
+                                                  input,
+                                                  std::move(leftVar),
+                                                  std::move(rightVar),
+                                                  std::move(hashKeys),
+                                                  std::move(probeKeys));
   }
 
   PlanNode* clone() const override;
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   InnerJoin(QueryContext* qctx,
             PlanNode* input,
             std::pair<std::string, int64_t> leftVar,
@@ -1358,7 +1380,7 @@ class InnerJoin final : public Join {
 class Assign final : public SingleInputNode {
  public:
   static Assign* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new Assign(qctx, input));
+    return qctx->objPool()->makeAndAdd<Assign>(qctx, input);
   }
 
   const std::vector<std::pair<std::string, Expression*>>& items() const {
@@ -1376,6 +1398,7 @@ class Assign final : public SingleInputNode {
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   Assign(QueryContext* qctx, PlanNode* input) : SingleInputNode(qctx, Kind::kAssign, input) {}
 
   void cloneMembers(const Assign&);
@@ -1389,12 +1412,13 @@ class Assign final : public SingleInputNode {
 class UnionAllVersionVar final : public SingleInputNode {
  public:
   static UnionAllVersionVar* make(QueryContext* qctx, PlanNode* input) {
-    return qctx->objPool()->add(new UnionAllVersionVar(qctx, input));
+    return qctx->objPool()->makeAndAdd<UnionAllVersionVar>(qctx, input);
   }
 
   PlanNode* clone() const override;
 
  private:
+  friend ObjectPool;
   UnionAllVersionVar(QueryContext* qctx, PlanNode* input)
       : SingleInputNode(qctx, Kind::kUnionAllVersionVar, input) {}
 
@@ -1410,7 +1434,7 @@ class Traverse final : public GetNeighbors {
   using Exprs = std::unique_ptr<std::vector<storage::cpp2::Expr>>;
 
   static Traverse* make(QueryContext* qctx, PlanNode* input, GraphSpaceID space) {
-    return qctx->objPool()->add(new Traverse(qctx, input, space));
+    return qctx->objPool()->makeAndAdd<Traverse>(qctx, input, space);
   }
 
   static Traverse* make(QueryContext* qctx,
@@ -1496,6 +1520,7 @@ class Traverse final : public GetNeighbors {
   }
 
  private:
+  friend ObjectPool;
   Traverse(QueryContext* qctx, PlanNode* input, GraphSpaceID space)
       : GetNeighbors(qctx, Kind::kTraverse, input, space) {
     setLimit(-1);
@@ -1516,7 +1541,7 @@ class Traverse final : public GetNeighbors {
 class AppendVertices final : public GetVertices {
  public:
   static AppendVertices* make(QueryContext* qctx, PlanNode* input, GraphSpaceID space) {
-    return qctx->objPool()->add(new AppendVertices(qctx, input, space));
+    return qctx->objPool()->makeAndAdd<AppendVertices>(qctx, input, space);
   }
 
   std::unique_ptr<PlanNodeDescription> explain() const override;
@@ -1542,6 +1567,7 @@ class AppendVertices final : public GetVertices {
   }
 
  private:
+  friend ObjectPool;
   AppendVertices(QueryContext* qctx, PlanNode* input, GraphSpaceID space)
       : GetVertices(qctx,
                     Kind::kAppendVertices,
@@ -1608,14 +1634,15 @@ class BiLeftJoin final : public BiJoin {
                           PlanNode* right,
                           std::vector<Expression*> hashKeys = {},
                           std::vector<Expression*> probeKeys = {}) {
-    return qctx->objPool()->add(
-        new BiLeftJoin(qctx, left, right, std::move(hashKeys), std::move(probeKeys)));
+    return qctx->objPool()->makeAndAdd<BiLeftJoin>(
+        qctx, left, right, std::move(hashKeys), std::move(probeKeys));
   }
 
   PlanNode* clone() const override;
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   BiLeftJoin(QueryContext* qctx,
              PlanNode* left,
              PlanNode* right,
@@ -1634,14 +1661,15 @@ class BiInnerJoin final : public BiJoin {
                            PlanNode* right,
                            std::vector<Expression*> hashKeys = {},
                            std::vector<Expression*> probeKeys = {}) {
-    return qctx->objPool()->add(
-        new BiInnerJoin(qctx, left, right, std::move(hashKeys), std::move(probeKeys)));
+    return qctx->objPool()->makeAndAdd<BiInnerJoin>(
+        qctx, left, right, std::move(hashKeys), std::move(probeKeys));
   }
 
   PlanNode* clone() const override;
   std::unique_ptr<PlanNodeDescription> explain() const override;
 
  private:
+  friend ObjectPool;
   BiInnerJoin(QueryContext* qctx,
               PlanNode* left,
               PlanNode* right,
@@ -1660,8 +1688,8 @@ class RollUpApply : public BinaryInputNode {
                            PlanNode* right,
                            std::vector<Expression*> compareCols,
                            InputPropertyExpression* collectCol) {
-    return qctx->objPool()->add(
-        new RollUpApply(qctx, Kind::kRollUpApply, left, right, std::move(compareCols), collectCol));
+    return qctx->objPool()->makeAndAdd<RollUpApply>(
+        qctx, Kind::kRollUpApply, left, right, std::move(compareCols), collectCol);
   }
 
   const std::vector<Expression*>& compareCols() const {
@@ -1682,6 +1710,7 @@ class RollUpApply : public BinaryInputNode {
   void accept(PlanNodeVisitor* visitor) override;
 
  protected:
+  friend ObjectPool;
   RollUpApply(QueryContext* qctx,
               Kind kind,
               PlanNode* left,
diff --git a/src/graph/planner/plan/Scan.h b/src/graph/planner/plan/Scan.h
index 375c78b800e..4e370601443 100644
--- a/src/graph/planner/plan/Scan.h
+++ b/src/graph/planner/plan/Scan.h
@@ -69,18 +69,18 @@ class EdgeIndexPrefixScan : public EdgeIndexScan {
                                    std::vector<storage::cpp2::OrderBy> orderBy = {},
                                    int64_t limit = std::numeric_limits<int64_t>::max(),
                                    Expression* filter = nullptr) {
-    return qctx->objPool()->add(new EdgeIndexPrefixScan(qctx,
-                                                        input,
-                                                        edgeType,
-                                                        space,
-                                                        std::move(contexts),
-                                                        std::move(returnCols),
-                                                        schemaId,
-                                                        isEmptyResultSet,
-                                                        dedup,
-                                                        std::move(orderBy),
-                                                        limit,
-                                                        filter));
+    return qctx->objPool()->makeAndAdd<EdgeIndexPrefixScan>(qctx,
+                                                            input,
+                                                            edgeType,
+                                                            space,
+                                                            std::move(contexts),
+                                                            std::move(returnCols),
+                                                            schemaId,
+                                                            isEmptyResultSet,
+                                                            dedup,
+                                                            std::move(orderBy),
+                                                            limit,
+                                                            filter);
   }
 
   PlanNode* clone() const override {
@@ -90,6 +90,7 @@ class EdgeIndexPrefixScan : public EdgeIndexScan {
   }
 
  private:
+  friend ObjectPool;
   EdgeIndexPrefixScan(QueryContext* qctx,
                       PlanNode* input,
                       const std::string& edgeType,
@@ -131,18 +132,18 @@ class EdgeIndexRangeScan : public EdgeIndexScan {
                                   std::vector<storage::cpp2::OrderBy> orderBy = {},
                                   int64_t limit = std::numeric_limits<int64_t>::max(),
                                   Expression* filter = nullptr) {
-    return qctx->objPool()->add(new EdgeIndexRangeScan(qctx,
-                                                       input,
-                                                       edgeType,
-                                                       space,
-                                                       std::move(contexts),
-                                                       std::move(returnCols),
-                                                       schemaId,
-                                                       isEmptyResultSet,
-                                                       dedup,
-                                                       std::move(orderBy),
-                                                       limit,
-                                                       filter));
+    return qctx->objPool()->makeAndAdd<EdgeIndexRangeScan>(qctx,
+                                                           input,
+                                                           edgeType,
+                                                           space,
+                                                           std::move(contexts),
+                                                           std::move(returnCols),
+                                                           schemaId,
+                                                           isEmptyResultSet,
+                                                           dedup,
+                                                           std::move(orderBy),
+                                                           limit,
+                                                           filter);
   }
 
   PlanNode* clone() const override {
@@ -152,6 +153,7 @@ class EdgeIndexRangeScan : public EdgeIndexScan {
   }
 
  private:
+  friend ObjectPool;
   EdgeIndexRangeScan(QueryContext* qctx,
                      PlanNode* input,
                      const std::string& edgeType,
@@ -193,18 +195,18 @@ class EdgeIndexFullScan final : public EdgeIndexScan {
                                  std::vector<storage::cpp2::OrderBy> orderBy = {},
                                  int64_t limit = std::numeric_limits<int64_t>::max(),
                                  Expression* filter = nullptr) {
-    return qctx->objPool()->add(new EdgeIndexFullScan(qctx,
-                                                      input,
-                                                      edgeType,
-                                                      space,
-                                                      std::move(contexts),
-                                                      std::move(returnCols),
-                                                      schemaId,
-                                                      isEmptyResultSet,
-                                                      dedup,
-                                                      std::move(orderBy),
-                                                      limit,
-                                                      filter));
+    return qctx->objPool()->makeAndAdd<EdgeIndexFullScan>(qctx,
+                                                          input,
+                                                          edgeType,
+                                                          space,
+                                                          std::move(contexts),
+                                                          std::move(returnCols),
+                                                          schemaId,
+                                                          isEmptyResultSet,
+                                                          dedup,
+                                                          std::move(orderBy),
+                                                          limit,
+                                                          filter);
   }
 
   PlanNode* clone() const override {
@@ -214,6 +216,7 @@ class EdgeIndexFullScan final : public EdgeIndexScan {
   }
 
  private:
+  friend ObjectPool;
   EdgeIndexFullScan(QueryContext* qctx,
                     PlanNode* input,
                     const std::string& edgeType,
@@ -300,18 +303,18 @@ class TagIndexPrefixScan : public TagIndexScan {
                                   std::vector<storage::cpp2::OrderBy> orderBy = {},
                                   int64_t limit = std::numeric_limits<int64_t>::max(),
                                   Expression* filter = nullptr) {
-    return qctx->objPool()->add(new TagIndexPrefixScan(qctx,
-                                                       input,
-                                                       tagName,
-                                                       space,
-                                                       std::move(contexts),
-                                                       std::move(returnCols),
-                                                       schemaId,
-                                                       isEmptyResultSet,
-                                                       dedup,
-                                                       std::move(orderBy),
-                                                       limit,
-                                                       filter));
+    return qctx->objPool()->makeAndAdd<TagIndexPrefixScan>(qctx,
+                                                           input,
+                                                           tagName,
+                                                           space,
+                                                           std::move(contexts),
+                                                           std::move(returnCols),
+                                                           schemaId,
+                                                           isEmptyResultSet,
+                                                           dedup,
+                                                           std::move(orderBy),
+                                                           limit,
+                                                           filter);
   }
 
   PlanNode* clone() const {
@@ -321,6 +324,7 @@ class TagIndexPrefixScan : public TagIndexScan {
   }
 
  private:
+  friend ObjectPool;
   TagIndexPrefixScan(QueryContext* qctx,
                      PlanNode* input,
                      const std::string& tagName,
@@ -362,18 +366,18 @@ class TagIndexRangeScan : public TagIndexScan {
                                  std::vector<storage::cpp2::OrderBy> orderBy = {},
                                  int64_t limit = std::numeric_limits<int64_t>::max(),
                                  Expression* filter = nullptr) {
-    return qctx->objPool()->add(new TagIndexRangeScan(qctx,
-                                                      input,
-                                                      tagName,
-                                                      space,
-                                                      std::move(contexts),
-                                                      std::move(returnCols),
-                                                      schemaId,
-                                                      isEmptyResultSet,
-                                                      dedup,
-                                                      std::move(orderBy),
-                                                      limit,
-                                                      filter));
+    return qctx->objPool()->makeAndAdd<TagIndexRangeScan>(qctx,
+                                                          input,
+                                                          tagName,
+                                                          space,
+                                                          std::move(contexts),
+                                                          std::move(returnCols),
+                                                          schemaId,
+                                                          isEmptyResultSet,
+                                                          dedup,
+                                                          std::move(orderBy),
+                                                          limit,
+                                                          filter);
   }
 
   PlanNode* clone() const {
@@ -383,6 +387,7 @@ class TagIndexRangeScan : public TagIndexScan {
   }
 
  private:
+  friend ObjectPool;
   TagIndexRangeScan(QueryContext* qctx,
                     PlanNode* input,
                     const std::string& tagName,
@@ -424,18 +429,18 @@ class TagIndexFullScan final : public TagIndexScan {
                                 std::vector<storage::cpp2::OrderBy> orderBy = {},
                                 int64_t limit = std::numeric_limits<int64_t>::max(),
                                 Expression* filter = nullptr) {
-    return qctx->objPool()->add(new TagIndexFullScan(qctx,
-                                                     input,
-                                                     tagName,
-                                                     space,
-                                                     std::move(contexts),
-                                                     std::move(returnCols),
-                                                     schemaId,
-                                                     isEmptyResultSet,
-                                                     dedup,
-                                                     std::move(orderBy),
-                                                     limit,
-                                                     filter));
+    return qctx->objPool()->makeAndAdd<TagIndexFullScan>(qctx,
+                                                         input,
+                                                         tagName,
+                                                         space,
+                                                         std::move(contexts),
+                                                         std::move(returnCols),
+                                                         schemaId,
+                                                         isEmptyResultSet,
+                                                         dedup,
+                                                         std::move(orderBy),
+                                                         limit,
+                                                         filter);
   }
 
   PlanNode* clone() const {
@@ -445,6 +450,7 @@ class TagIndexFullScan final : public TagIndexScan {
   }
 
  private:
+  friend ObjectPool;
   TagIndexFullScan(QueryContext* qctx,
                    PlanNode* input,
                    const std::string& tagName,
diff --git a/src/graph/util/PlannerUtil.cpp b/src/graph/util/PlannerUtil.cpp
index 45b2e8a1fdf..4f87d9ebd87 100644
--- a/src/graph/util/PlannerUtil.cpp
+++ b/src/graph/util/PlannerUtil.cpp
@@ -31,7 +31,7 @@ void PlannerUtil::buildConstantInput(QueryContext* qctx, Starts& starts, std::st
 // static
 SubPlan PlannerUtil::buildRuntimeInput(QueryContext* qctx, Starts& starts) {
   auto pool = qctx->objPool();
-  auto* columns = pool->add(new YieldColumns());
+  auto* columns = pool->makeAndAdd<YieldColumns>();
   auto* column = new YieldColumn(starts.originalSrc->clone(), kVid);
   columns->addColumn(column);
 
@@ -65,7 +65,7 @@ PlanNode* PlannerUtil::extractDstFromGN(QueryContext* qctx,
                                         PlanNode* gn,
                                         const std::string& output) {
   auto pool = qctx->objPool();
-  auto* columns = pool->add(new YieldColumns());
+  auto* columns = pool->makeAndAdd<YieldColumns>();
   auto* column = new YieldColumn(EdgePropertyExpression::make(pool, "*", kDst), kVid);
   columns->addColumn(column);
 
diff --git a/src/graph/validator/FetchEdgesValidator.cpp b/src/graph/validator/FetchEdgesValidator.cpp
index c7b4c1700c5..bcc45c9f6fd 100644
--- a/src/graph/validator/FetchEdgesValidator.cpp
+++ b/src/graph/validator/FetchEdgesValidator.cpp
@@ -157,7 +157,7 @@ Status FetchEdgesValidator::validateYield(const YieldClause *yield) {
   outputs_.reserve(size);
 
   auto pool = qctx_->objPool();
-  auto *newCols = pool->add(new YieldColumns());
+  auto *newCols = pool->makeAndAdd<YieldColumns>();
   for (auto col : yield->columns()) {
     if (ExpressionUtils::hasAny(col->expr(), {Expression::Kind::kVertex})) {
       return Status::SemanticError("illegal yield clauses `%s'", col->toString().c_str());
diff --git a/src/graph/validator/FetchVerticesValidator.cpp b/src/graph/validator/FetchVerticesValidator.cpp
index 38e10fb2e86..bf0e02a70b7 100644
--- a/src/graph/validator/FetchVerticesValidator.cpp
+++ b/src/graph/validator/FetchVerticesValidator.cpp
@@ -62,7 +62,7 @@ Status FetchVerticesValidator::validateYield(YieldClause *yield) {
   outputs_.reserve(size);
 
   auto pool = qctx_->objPool();
-  auto *newCols = pool->add(new YieldColumns());
+  auto *newCols = pool->makeAndAdd<YieldColumns>();
 
   auto &exprProps = fetchCtx_->exprProps;
   for (auto col : yield->columns()) {
diff --git a/src/graph/validator/GoValidator.cpp b/src/graph/validator/GoValidator.cpp
index 1013a5c6978..3c0a4b8d153 100644
--- a/src/graph/validator/GoValidator.cpp
+++ b/src/graph/validator/GoValidator.cpp
@@ -235,15 +235,15 @@ Status GoValidator::buildColumns() {
 
   auto pool = qctx_->objPool();
   if (!exprProps.isAllPropsEmpty() || from.fromType != FromType::kInstantExpr) {
-    goCtx_->srcEdgePropsExpr = pool->add(new YieldColumns());
+    goCtx_->srcEdgePropsExpr = pool->makeAndAdd<YieldColumns>();
   }
 
   if (!dstTagProps.empty()) {
-    goCtx_->dstPropsExpr = pool->add(new YieldColumns());
+    goCtx_->dstPropsExpr = pool->makeAndAdd<YieldColumns>();
   }
 
   if (!inputProps.empty() || !varProps.empty()) {
-    inputPropCols_ = pool->add(new YieldColumns());
+    inputPropCols_ = pool->makeAndAdd<YieldColumns>();
   }
 
   std::unordered_set<std::string> uniqueEdgeVertexExpr;
@@ -253,7 +253,7 @@ Status GoValidator::buildColumns() {
     goCtx_->filter = rewrite2VarProp(filter);
   }
 
-  auto* newYieldExpr = pool->add(new YieldColumns());
+  auto* newYieldExpr = pool->makeAndAdd<YieldColumns>();
   for (auto* col : goCtx_->yieldExpr->columns()) {
     extractPropExprs(col->expr(), uniqueEdgeVertexExpr);
     newYieldExpr->addColumn(new YieldColumn(rewrite2VarProp(col->expr()), col->alias()));
diff --git a/src/graph/validator/GroupByValidator.cpp b/src/graph/validator/GroupByValidator.cpp
index 8441b72668b..ec61cff8d0f 100644
--- a/src/graph/validator/GroupByValidator.cpp
+++ b/src/graph/validator/GroupByValidator.cpp
@@ -40,7 +40,7 @@ Status GroupByValidator::validateYield(const YieldClause* yieldClause) {
   }
 
   auto* pool = qctx_->objPool();
-  projCols_ = pool->add(new YieldColumns);
+  projCols_ = pool->makeAndAdd<YieldColumns>();
   for (auto* col : columns) {
     auto colOldName = col->name();
     auto* colExpr = col->expr();
diff --git a/src/graph/validator/LookupValidator.cpp b/src/graph/validator/LookupValidator.cpp
index 812735e4258..9a5a73fd93d 100644
--- a/src/graph/validator/LookupValidator.cpp
+++ b/src/graph/validator/LookupValidator.cpp
@@ -160,7 +160,7 @@ Status LookupValidator::validateYield() {
     return Status::SemanticError("Missing yield clause.");
   }
   lookupCtx_->dedup = yieldClause->isDistinct();
-  lookupCtx_->yieldExpr = qctx_->objPool()->add(new YieldColumns());
+  lookupCtx_->yieldExpr = qctx_->objPool()->makeAndAdd<YieldColumns>();
 
   if (lookupCtx_->isEdge) {
     idxReturnCols_.emplace_back(nebula::kSrc);
diff --git a/src/graph/validator/MatchValidator.cpp b/src/graph/validator/MatchValidator.cpp
index 8bbea0b1144..99914c78d14 100644
--- a/src/graph/validator/MatchValidator.cpp
+++ b/src/graph/validator/MatchValidator.cpp
@@ -400,7 +400,7 @@ Status MatchValidator::buildColumnsForAllNamedAliases(const std::vector<QueryPar
 Status MatchValidator::validateReturn(MatchReturn *ret,
                                       const std::vector<QueryPart> &queryParts,
                                       ReturnClauseContext &retClauseCtx) {
-  YieldColumns *columns = saveObject(new YieldColumns());
+  YieldColumns *columns = retClauseCtx.qctx->objPool()->makeAndAdd<YieldColumns>();
   if (ret->returnItems()->allNamedAliases() && !queryParts.empty()) {
     auto status = buildColumnsForAllNamedAliases(queryParts, columns);
     if (!status.ok()) {
@@ -494,7 +494,7 @@ Status MatchValidator::validateStepRange(const MatchStepRange *range) const {
 Status MatchValidator::validateWith(const WithClause *with,
                                     const std::vector<QueryPart> &queryParts,
                                     WithClauseContext &withClauseCtx) {
-  YieldColumns *columns = saveObject(new YieldColumns());
+  YieldColumns *columns = withClauseCtx.qctx->objPool()->makeAndAdd<YieldColumns>();
   if (with->returnItems()->allNamedAliases() && !queryParts.empty()) {
     auto status = buildColumnsForAllNamedAliases(queryParts, columns);
     if (!status.ok()) {
@@ -847,7 +847,7 @@ Status MatchValidator::validateYield(YieldClauseContext &yieldCtx) {
     return Status::OK();
   }
 
-  yieldCtx.projCols_ = yieldCtx.qctx->objPool()->add(new YieldColumns());
+  yieldCtx.projCols_ = yieldCtx.qctx->objPool()->makeAndAdd<YieldColumns>();
   if (!yieldCtx.hasAgg_) {
     for (auto &col : yieldCtx.yieldColumns->columns()) {
       NG_RETURN_IF_ERROR(
diff --git a/src/graph/validator/MatchValidator.h b/src/graph/validator/MatchValidator.h
index b30fa8784d5..b33feede7dc 100644
--- a/src/graph/validator/MatchValidator.h
+++ b/src/graph/validator/MatchValidator.h
@@ -63,11 +63,6 @@ class MatchValidator final : public Validator {
 
   static Expression *andConnect(ObjectPool *pool, Expression *left, Expression *right);
 
-  template <typename T>
-  T *saveObject(T *obj) const {
-    return qctx_->objPool()->add(obj);
-  }
-
   Status buildNodeInfo(const MatchPath *path,
                        std::vector<NodeInfo> &edgeInfos,
                        std::unordered_map<std::string, AliasType> &aliases);
diff --git a/src/graph/validator/MutateValidator.cpp b/src/graph/validator/MutateValidator.cpp
index 8a4e948aee2..41f1f6fb14f 100644
--- a/src/graph/validator/MutateValidator.cpp
+++ b/src/graph/validator/MutateValidator.cpp
@@ -379,11 +379,11 @@ Status DeleteVerticesValidator::toPlan() {
     DCHECK(edgeTypes_.size() == edgeNames_.size());
     auto *pool = qctx_->objPool();
     for (auto &name : edgeNames_) {
-      auto *edgeKeyRef = new EdgeKeyRef(EdgeSrcIdExpression::make(pool, name),
-                                        EdgeDstIdExpression::make(pool, name),
-                                        EdgeRankExpression::make(pool, name));
+      auto *edgeKeyRef =
+          qctx_->objPool()->makeAndAdd<EdgeKeyRef>(EdgeSrcIdExpression::make(pool, name),
+                                                   EdgeDstIdExpression::make(pool, name),
+                                                   EdgeRankExpression::make(pool, name));
       edgeKeyRef->setType(EdgeTypeExpression::make(pool, name));
-      qctx_->objPool()->add(edgeKeyRef);
       edgeKeyRefs_.emplace_back(edgeKeyRef);
 
       storage::cpp2::EdgeProp edgeProp;
@@ -566,9 +566,8 @@ Status DeleteEdgesValidator::buildEdgeKeyRef(const std::vector<EdgeKey *> &edgeK
   auto *typeExpr = InputPropertyExpression::make(pool, kType);
   auto *rankExpr = InputPropertyExpression::make(pool, kRank);
   auto *dstIdExpr = InputPropertyExpression::make(pool, kDst);
-  auto *edgeKeyRef = new EdgeKeyRef(srcIdExpr, dstIdExpr, rankExpr);
+  auto *edgeKeyRef = qctx_->objPool()->makeAndAdd<EdgeKeyRef>(srcIdExpr, dstIdExpr, rankExpr);
   edgeKeyRef->setType(typeExpr);
-  qctx_->objPool()->add(edgeKeyRef);
 
   edgeKeyRefs_.emplace_back(edgeKeyRef);
   return Status::OK();
diff --git a/src/graph/validator/YieldValidator.cpp b/src/graph/validator/YieldValidator.cpp
index 64c367481f3..5aaf7d88af3 100644
--- a/src/graph/validator/YieldValidator.cpp
+++ b/src/graph/validator/YieldValidator.cpp
@@ -86,8 +86,8 @@ Status YieldValidator::makeOutputColumn(YieldColumn *column) {
 
 // Create GroupByValidator according to implicit group by in yield sentence.
 Status YieldValidator::makeImplicitGroupByValidator() {
-  auto *groupSentence = qctx()->objPool()->add(new GroupBySentence(
-      static_cast<YieldSentence *>(sentence_)->yield()->clone().release(), nullptr, nullptr));
+  auto *groupSentence = qctx()->objPool()->makeAndAdd<GroupBySentence>(
+      static_cast<YieldSentence *>(sentence_)->yield()->clone().release(), nullptr, nullptr);
   groupByValidator_ = std::make_unique<GroupByValidator>(groupSentence, qctx());
   groupByValidator_->setInputCols(inputs_);
 
@@ -113,7 +113,7 @@ Status YieldValidator::validateImplicitGroupBy() {
 Status YieldValidator::validateYieldAndBuildOutputs(const YieldClause *clause) {
   auto columns = clause->columns();
   auto *pool = qctx_->objPool();
-  columns_ = pool->add(new YieldColumns);
+  columns_ = pool->makeAndAdd<YieldColumns>();
   for (auto column : columns) {
     auto expr = DCHECK_NOTNULL(column->expr());
     NG_RETURN_IF_ERROR(ValidateUtil::invalidLabelIdentifiers(expr));
diff --git a/src/graph/validator/test/ValidatorTestBase.h b/src/graph/validator/test/ValidatorTestBase.h
index 84c6e67c837..baa9e163f7b 100644
--- a/src/graph/validator/test/ValidatorTestBase.h
+++ b/src/graph/validator/test/ValidatorTestBase.h
@@ -53,15 +53,15 @@ class ValidatorTestBase : public ::testing::Test {
     }
     NG_RETURN_IF_ERROR(AstUtils::reprAstCheck(*result.value(), qctx));
 
-    auto sentences = pool_->add(std::move(result).value().release());
-    NG_RETURN_IF_ERROR(Validator::validate(sentences, qctx));
+    sentences_.emplace_back(std::move(result).value());
+    NG_RETURN_IF_ERROR(Validator::validate(sentences_.back().get(), qctx));
     return qctx;
   }
 
   QueryContext* buildContext() {
     auto rctx = std::make_unique<RequestContext<ExecutionResponse>>();
     rctx->setSession(session_);
-    auto qctx = pool_->add(new QueryContext());
+    auto qctx = pool_->makeAndAdd<QueryContext>();
     qctx->setRCtx(std::move(rctx));
     qctx->setSchemaManager(schemaMng_.get());
     qctx->setIndexManager(indexMng_.get());
@@ -125,7 +125,7 @@ class ValidatorTestBase : public ::testing::Test {
   std::shared_ptr<ClientSession> session_;
   std::unique_ptr<MockSchemaManager> schemaMng_;
   std::unique_ptr<MockIndexManager> indexMng_{nullptr};
-  std::unique_ptr<Sentence> sentences_;
+  std::vector<std::unique_ptr<Sentence>> sentences_;
   std::unique_ptr<ObjectPool> pool_;
 };