diff --git a/src/common/types/types.cpp b/src/common/types/types.cpp
index 185c8e42abb..b700371a33b 100644
--- a/src/common/types/types.cpp
+++ b/src/common/types/types.cpp
@@ -155,14 +155,14 @@ bool LogicalType::operator==(const LogicalType& other) const {
     if (typeID != other.typeID) {
         return false;
     }
-    switch (other.typeID) {
-    case LogicalTypeID::VAR_LIST:
+    switch (other.getPhysicalType()) {
+    case PhysicalTypeID::VAR_LIST:
         return *reinterpret_cast<VarListTypeInfo*>(extraTypeInfo.get()) ==
                *reinterpret_cast<VarListTypeInfo*>(other.extraTypeInfo.get());
-    case LogicalTypeID::FIXED_LIST:
+    case PhysicalTypeID::FIXED_LIST:
         return *reinterpret_cast<FixedListTypeInfo*>(extraTypeInfo.get()) ==
                *reinterpret_cast<FixedListTypeInfo*>(other.extraTypeInfo.get());
-    case LogicalTypeID::STRUCT:
+    case PhysicalTypeID::STRUCT:
         return *reinterpret_cast<StructTypeInfo*>(extraTypeInfo.get()) ==
                *reinterpret_cast<StructTypeInfo*>(other.extraTypeInfo.get());
     default:
@@ -228,6 +228,7 @@ void LogicalType::setPhysicalType() {
         physicalType = PhysicalTypeID::STRING;
     } break;
     case LogicalTypeID::RECURSIVE_REL:
+    case LogicalTypeID::MAP:
     case LogicalTypeID::VAR_LIST: {
         physicalType = PhysicalTypeID::VAR_LIST;
     } break;
@@ -322,6 +323,12 @@ LogicalTypeID LogicalTypeUtils::dataTypeIDFromString(const std::string& dataType
 
 std::string LogicalTypeUtils::dataTypeToString(const LogicalType& dataType) {
     switch (dataType.typeID) {
+    case LogicalTypeID::MAP: {
+        auto structType = common::VarListType::getChildType(&dataType);
+        auto fieldTypes = common::StructType::getFieldTypes(structType);
+        return "MAP(" + dataTypeToString(*fieldTypes[0]) + ": " + dataTypeToString(*fieldTypes[1]) +
+               ")";
+    }
     case LogicalTypeID::VAR_LIST: {
         auto varListTypeInfo = reinterpret_cast<VarListTypeInfo*>(dataType.extraTypeInfo.get());
         return dataTypeToString(*varListTypeInfo->getChildType()) + "[]";
@@ -407,6 +414,8 @@ std::string LogicalTypeUtils::dataTypeToString(LogicalTypeID dataTypeID) {
         return "STRUCT";
     case LogicalTypeID::SERIAL:
         return "SERIAL";
+    case LogicalTypeID::MAP:
+        return "MAP";
     default:
         throw NotImplementedException("LogicalTypeUtils::dataTypeToString.");
     }
@@ -484,7 +493,8 @@ std::vector<LogicalTypeID> LogicalTypeUtils::getNumericalLogicalTypeIDs() {
 }
 
 std::vector<LogicalTypeID> LogicalTypeUtils::getAllValidLogicTypeIDs() {
-    // TODO(Ziyi): Add FIX_LIST,STRUCT type to allValidTypeID when we support functions on VAR_LIST.
+    // TODO(Ziyi): Add FIX_LIST,STRUCT,MAP type to allValidTypeID when we support functions on
+    // FIXED_LIST,STRUCT,MAP.
     return std::vector<LogicalTypeID>{LogicalTypeID::INTERNAL_ID, LogicalTypeID::BOOL,
         LogicalTypeID::INT64, LogicalTypeID::INT32, LogicalTypeID::INT16, LogicalTypeID::DOUBLE,
         LogicalTypeID::STRING, LogicalTypeID::DATE, LogicalTypeID::TIMESTAMP,
@@ -578,16 +588,16 @@ uint64_t SerDeser::deserializeValue(
 template<>
 uint64_t SerDeser::serializeValue(const LogicalType& value, FileInfo* fileInfo, uint64_t offset) {
     offset = SerDeser::serializeValue(value.getLogicalTypeID(), fileInfo, offset);
-    switch (value.getLogicalTypeID()) {
-    case LogicalTypeID::VAR_LIST: {
+    switch (value.getPhysicalType()) {
+    case PhysicalTypeID::VAR_LIST: {
         auto varListTypeInfo = reinterpret_cast<VarListTypeInfo*>(value.extraTypeInfo.get());
         offset = serializeValue(*varListTypeInfo, fileInfo, offset);
     } break;
-    case LogicalTypeID::FIXED_LIST: {
+    case PhysicalTypeID::FIXED_LIST: {
         auto fixedListTypeInfo = reinterpret_cast<FixedListTypeInfo*>(value.extraTypeInfo.get());
         offset = serializeValue(*fixedListTypeInfo, fileInfo, offset);
     } break;
-    case LogicalTypeID::STRUCT: {
+    case PhysicalTypeID::STRUCT: {
         auto structTypeInfo = reinterpret_cast<StructTypeInfo*>(value.extraTypeInfo.get());
         offset = serializeValue(*structTypeInfo, fileInfo, offset);
     } break;
@@ -601,19 +611,19 @@ template<>
 uint64_t SerDeser::deserializeValue(LogicalType& value, FileInfo* fileInfo, uint64_t offset) {
     offset = SerDeser::deserializeValue(value.typeID, fileInfo, offset);
     value.setPhysicalType();
-    switch (value.getLogicalTypeID()) {
-    case LogicalTypeID::VAR_LIST: {
+    switch (value.getPhysicalType()) {
+    case PhysicalTypeID::VAR_LIST: {
         value.extraTypeInfo = std::make_unique<VarListTypeInfo>();
         offset = deserializeValue(
             *reinterpret_cast<VarListTypeInfo*>(value.extraTypeInfo.get()), fileInfo, offset);
 
     } break;
-    case LogicalTypeID::FIXED_LIST: {
+    case PhysicalTypeID::FIXED_LIST: {
         value.extraTypeInfo = std::make_unique<FixedListTypeInfo>();
         offset = deserializeValue(
             *reinterpret_cast<FixedListTypeInfo*>(value.extraTypeInfo.get()), fileInfo, offset);
     } break;
-    case LogicalTypeID::STRUCT: {
+    case PhysicalTypeID::STRUCT: {
         value.extraTypeInfo = std::make_unique<StructTypeInfo>();
         offset = deserializeValue(
             *reinterpret_cast<StructTypeInfo*>(value.extraTypeInfo.get()), fileInfo, offset);
diff --git a/src/common/types/value.cpp b/src/common/types/value.cpp
index 1f27ffdc0b9..548a7160081 100644
--- a/src/common/types/value.cpp
+++ b/src/common/types/value.cpp
@@ -1,7 +1,6 @@
 #include "common/types/value.h"
 
 #include "common/null_buffer.h"
-#include "common/string_utils.h"
 #include "storage/storage_utils.h"
 
 namespace kuzu {
@@ -66,6 +65,7 @@ Value Value::createDefaultValue(const LogicalType& dataType) {
     case LogicalTypeID::FLOAT:
         return Value((float_t)0);
     case LogicalTypeID::RECURSIVE_REL:
+    case LogicalTypeID::MAP:
     case LogicalTypeID::VAR_LIST:
     case LogicalTypeID::FIXED_LIST:
     case LogicalTypeID::STRUCT:
@@ -282,6 +282,17 @@ std::string Value::toString() const {
         return TypeUtils::toString(val.internalIDVal);
     case LogicalTypeID::STRING:
         return strVal;
+    case LogicalTypeID::MAP: {
+        std::string result = "{";
+        for (auto i = 0u; i < nestedTypeVal.size(); ++i) {
+            auto structVal = nestedTypeVal[i].get();
+            result += structVal->nestedTypeVal[0]->toString();
+            result += "=";
+            result += structVal->nestedTypeVal[1]->toString();
+            result += (i == nestedTypeVal.size() - 1 ? "}" : ", ");
+        }
+        return result;
+    }
     case LogicalTypeID::RECURSIVE_REL:
     case LogicalTypeID::VAR_LIST:
     case LogicalTypeID::FIXED_LIST: {
diff --git a/src/common/vector/auxiliary_buffer.cpp b/src/common/vector/auxiliary_buffer.cpp
index f5843d2efe8..5685297acfa 100644
--- a/src/common/vector/auxiliary_buffer.cpp
+++ b/src/common/vector/auxiliary_buffer.cpp
@@ -46,18 +46,15 @@ list_entry_t ListAuxiliaryBuffer::addList(uint64_t listSize) {
 
 std::unique_ptr<AuxiliaryBuffer> AuxiliaryBufferFactory::getAuxiliaryBuffer(
     LogicalType& type, storage::MemoryManager* memoryManager) {
-    switch (type.getLogicalTypeID()) {
-    case LogicalTypeID::STRING:
+    switch (type.getPhysicalType()) {
+    case PhysicalTypeID::STRING:
         return std::make_unique<StringAuxiliaryBuffer>(memoryManager);
-    case LogicalTypeID::STRUCT:
+    case PhysicalTypeID::STRUCT:
         return std::make_unique<StructAuxiliaryBuffer>(type, memoryManager);
-    case LogicalTypeID::RECURSIVE_REL:
-        return std::make_unique<ListAuxiliaryBuffer>(
-            common::LogicalType(common::LogicalTypeID::INTERNAL_ID), memoryManager);
-    case LogicalTypeID::VAR_LIST:
+    case PhysicalTypeID::VAR_LIST:
         return std::make_unique<ListAuxiliaryBuffer>(
             *VarListType::getChildType(&type), memoryManager);
-    case LogicalTypeID::ARROW_COLUMN:
+    case PhysicalTypeID::ARROW_COLUMN:
         return std::make_unique<ArrowColumnAuxiliaryBuffer>();
     default:
         return nullptr;
diff --git a/src/common/vector/value_vector.cpp b/src/common/vector/value_vector.cpp
index 07b0681634a..76f2d3715b5 100644
--- a/src/common/vector/value_vector.cpp
+++ b/src/common/vector/value_vector.cpp
@@ -57,12 +57,12 @@ void ValueVector::setValue(uint32_t pos, std::string val) {
 }
 
 void ValueVector::resetAuxiliaryBuffer() {
-    switch (dataType.getLogicalTypeID()) {
-    case LogicalTypeID::STRING: {
+    switch (dataType.getPhysicalType()) {
+    case PhysicalTypeID::STRING: {
         reinterpret_cast<StringAuxiliaryBuffer*>(auxiliaryBuffer.get())->resetOverflowBuffer();
         return;
     }
-    case LogicalTypeID::VAR_LIST: {
+    case PhysicalTypeID::VAR_LIST: {
         reinterpret_cast<ListAuxiliaryBuffer*>(auxiliaryBuffer.get())->resetSize();
         return;
     }
@@ -72,22 +72,21 @@ void ValueVector::resetAuxiliaryBuffer() {
 }
 
 uint32_t ValueVector::getDataTypeSize(const LogicalType& type) {
-    switch (type.getLogicalTypeID()) {
-    case common::LogicalTypeID::STRING: {
+    switch (type.getPhysicalType()) {
+    case PhysicalTypeID::STRING: {
         return sizeof(common::ku_string_t);
     }
-    case common::LogicalTypeID::FIXED_LIST: {
+    case PhysicalTypeID::FIXED_LIST: {
         return getDataTypeSize(*common::FixedListType::getChildType(&type)) *
                common::FixedListType::getNumElementsInList(&type);
     }
-    case LogicalTypeID::STRUCT: {
+    case PhysicalTypeID::STRUCT: {
         return sizeof(struct_entry_t);
     }
-    case LogicalTypeID::RECURSIVE_REL:
-    case LogicalTypeID::VAR_LIST: {
+    case PhysicalTypeID::VAR_LIST: {
         return sizeof(list_entry_t);
     }
-    case LogicalTypeID::ARROW_COLUMN: {
+    case PhysicalTypeID::ARROW_COLUMN: {
         return 0;
     }
     default: {
diff --git a/src/common/vector/value_vector_utils.cpp b/src/common/vector/value_vector_utils.cpp
index 09d71b05623..8ca20bd0589 100644
--- a/src/common/vector/value_vector_utils.cpp
+++ b/src/common/vector/value_vector_utils.cpp
@@ -9,8 +9,8 @@ using namespace common;
 
 void ValueVectorUtils::copyNonNullDataWithSameTypeIntoPos(
     ValueVector& resultVector, uint64_t pos, const uint8_t* srcData) {
-    switch (resultVector.dataType.getLogicalTypeID()) {
-    case LogicalTypeID::STRUCT: {
+    switch (resultVector.dataType.getPhysicalType()) {
+    case PhysicalTypeID::STRUCT: {
         auto structFields = StructVector::getChildrenVectors(&resultVector);
         auto structNullBytes = srcData;
         auto structValues =
@@ -25,8 +25,7 @@ void ValueVectorUtils::copyNonNullDataWithSameTypeIntoPos(
             structValues += processor::FactorizedTable::getDataTypeSize(structField->dataType);
         }
     } break;
-    case LogicalTypeID::RECURSIVE_REL:
-    case LogicalTypeID::VAR_LIST: {
+    case PhysicalTypeID::VAR_LIST: {
         auto srcKuList = *(ku_list_t*)srcData;
         auto srcNullBytes = reinterpret_cast<uint8_t*>(srcKuList.overflowPtr);
         auto srcListValues = srcNullBytes + NullBuffer::getNumBytesForNullValues(srcKuList.size);
@@ -46,7 +45,7 @@ void ValueVectorUtils::copyNonNullDataWithSameTypeIntoPos(
             srcListValues += numBytesPerValue;
         }
     } break;
-    case LogicalTypeID::STRING: {
+    case PhysicalTypeID::STRING: {
         auto dstData = resultVector.getData() +
                        pos * processor::FactorizedTable::getDataTypeSize(resultVector.dataType);
         InMemOverflowBufferUtils::copyString(*(ku_string_t*)srcData, *(ku_string_t*)dstData,
@@ -61,8 +60,8 @@ void ValueVectorUtils::copyNonNullDataWithSameTypeIntoPos(
 
 void ValueVectorUtils::copyNonNullDataWithSameTypeOutFromPos(const ValueVector& srcVector,
     uint64_t pos, uint8_t* dstData, InMemOverflowBuffer& dstOverflowBuffer) {
-    switch (srcVector.dataType.getLogicalTypeID()) {
-    case LogicalTypeID::STRUCT: {
+    switch (srcVector.dataType.getPhysicalType()) {
+    case PhysicalTypeID::STRUCT: {
         // The storage structure of STRUCT type in factorizedTable is:
         // [NULLBYTES, FIELD1, FIELD2, ...]
         auto structFields = StructVector::getChildrenVectors(&srcVector);
@@ -81,8 +80,7 @@ void ValueVectorUtils::copyNonNullDataWithSameTypeOutFromPos(const ValueVector&
             structValues += processor::FactorizedTable::getDataTypeSize(structField->dataType);
         }
     } break;
-    case LogicalTypeID::RECURSIVE_REL:
-    case LogicalTypeID::VAR_LIST: {
+    case PhysicalTypeID::VAR_LIST: {
         auto srcListEntry = srcVector.getValue<list_entry_t>(pos);
         auto srcListDataVector = common::ListVector::getDataVector(&srcVector);
         ku_list_t dstList;
@@ -108,7 +106,7 @@ void ValueVectorUtils::copyNonNullDataWithSameTypeOutFromPos(const ValueVector&
         }
         memcpy(dstData, &dstList, sizeof(dstList));
     } break;
-    case LogicalTypeID::STRING: {
+    case PhysicalTypeID::STRING: {
         auto srcData = srcVector.getData() +
                        pos * processor::FactorizedTable::getDataTypeSize(srcVector.dataType);
         InMemOverflowBufferUtils::copyString(
@@ -123,9 +121,8 @@ void ValueVectorUtils::copyNonNullDataWithSameTypeOutFromPos(const ValueVector&
 
 void ValueVectorUtils::copyValue(uint8_t* dstValue, common::ValueVector& dstVector,
     const uint8_t* srcValue, const common::ValueVector& srcVector) {
-    switch (srcVector.dataType.getLogicalTypeID()) {
-    case LogicalTypeID::RECURSIVE_REL:
-    case LogicalTypeID::VAR_LIST: {
+    switch (srcVector.dataType.getPhysicalType()) {
+    case PhysicalTypeID::VAR_LIST: {
         auto srcList = reinterpret_cast<const common::list_entry_t*>(srcValue);
         auto dstList = reinterpret_cast<common::list_entry_t*>(dstValue);
         *dstList = ListVector::addList(&dstVector, srcList->size);
@@ -144,7 +141,7 @@ void ValueVectorUtils::copyValue(uint8_t* dstValue, common::ValueVector& dstVect
             dstValues += numBytesPerValue;
         }
     } break;
-    case LogicalTypeID::STRUCT: {
+    case PhysicalTypeID::STRUCT: {
         auto srcFields = common::StructVector::getChildrenVectors(&srcVector);
         auto dstFields = common::StructVector::getChildrenVectors(&dstVector);
         auto srcPos = *(int64_t*)srcValue;
@@ -160,7 +157,7 @@ void ValueVectorUtils::copyValue(uint8_t* dstValue, common::ValueVector& dstVect
             }
         }
     } break;
-    case LogicalTypeID::STRING: {
+    case PhysicalTypeID::STRING: {
         common::InMemOverflowBufferUtils::copyString(*(common::ku_string_t*)srcValue,
             *(common::ku_string_t*)dstValue, *StringVector::getInMemOverflowBuffer(&dstVector));
     } break;
diff --git a/src/function/CMakeLists.txt b/src/function/CMakeLists.txt
index 8f02fe52a2b..24e688482b6 100644
--- a/src/function/CMakeLists.txt
+++ b/src/function/CMakeLists.txt
@@ -14,7 +14,8 @@ add_library(kuzu_function
         vector_null_operations.cpp
         vector_string_operations.cpp
         vector_timestamp_operations.cpp
-        vector_struct_operations.cpp)
+        vector_struct_operations.cpp
+        vector_map_operation.cpp)
 
 set(ALL_OBJECT_FILES
         ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:kuzu_function>
diff --git a/src/function/built_in_vector_operations.cpp b/src/function/built_in_vector_operations.cpp
index f88f90bced9..a9b12425a39 100644
--- a/src/function/built_in_vector_operations.cpp
+++ b/src/function/built_in_vector_operations.cpp
@@ -6,6 +6,7 @@
 #include "function/date/vector_date_operations.h"
 #include "function/interval/vector_interval_operations.h"
 #include "function/list/vector_list_operations.h"
+#include "function/map/vector_map_operations.h"
 #include "function/schema/vector_offset_operations.h"
 #include "function/string/vector_string_operations.h"
 #include "function/struct/vector_struct_operations.h"
@@ -25,7 +26,8 @@ void BuiltInVectorOperations::registerVectorOperations() {
     registerStringOperations();
     registerCastOperations();
     registerListOperations();
-    registerStructOperation();
+    registerStructOperations();
+    registerMapOperations();
     // register internal offset operation
     vectorOperations.insert({OFFSET_FUNC_NAME, OffsetVectorOperation::getDefinitions()});
 }
@@ -478,11 +480,15 @@ void BuiltInVectorOperations::registerListOperations() {
         {LIST_ANY_VALUE_FUNC_NAME, ListAnyValueVectorOperation::getDefinitions()});
 }
 
-void BuiltInVectorOperations::registerStructOperation() {
+void BuiltInVectorOperations::registerStructOperations() {
     vectorOperations.insert({STRUCT_PACK_FUNC_NAME, StructPackVectorOperations::getDefinitions()});
     vectorOperations.insert(
         {STRUCT_EXTRACT_FUNC_NAME, StructExtractVectorOperations::getDefinitions()});
 }
 
+void BuiltInVectorOperations::registerMapOperations() {
+    vectorOperations.insert({MAP_FUNC_NAME, MapVectorOperations::getDefinitions()});
+}
+
 } // namespace function
 } // namespace kuzu
diff --git a/src/function/vector_arithmetic_operations.cpp b/src/function/vector_arithmetic_operations.cpp
index 55d9b335059..d8b0362bfd2 100644
--- a/src/function/vector_arithmetic_operations.cpp
+++ b/src/function/vector_arithmetic_operations.cpp
@@ -5,8 +5,8 @@ using namespace kuzu::common;
 namespace kuzu {
 namespace function {
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> AddVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors AddVectorOperation::getDefinitions() {
+    operation_vectors result;
     for (auto typeID : LogicalTypeUtils::getNumericalLogicalTypeIDs()) {
         result.push_back(getBinaryDefinition<operation::Add>(ADD_FUNC_NAME, typeID));
     }
@@ -42,8 +42,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> AddVectorOperation::getD
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> SubtractVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors SubtractVectorOperation::getDefinitions() {
+    operation_vectors result;
     for (auto typeID : LogicalTypeUtils::getNumericalLogicalTypeIDs()) {
         result.push_back(getBinaryDefinition<operation::Subtract>(SUBTRACT_FUNC_NAME, typeID));
     }
@@ -72,16 +72,16 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> SubtractVectorOperation:
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> MultiplyVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors MultiplyVectorOperation::getDefinitions() {
+    operation_vectors result;
     for (auto typeID : LogicalTypeUtils::getNumericalLogicalTypeIDs()) {
         result.push_back(getBinaryDefinition<operation::Multiply>(MULTIPLY_FUNC_NAME, typeID));
     }
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> DivideVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors DivideVectorOperation::getDefinitions() {
+    operation_vectors result;
     for (auto typeID : LogicalTypeUtils::getNumericalLogicalTypeIDs()) {
         result.push_back(getBinaryDefinition<operation::Divide>(DIVIDE_FUNC_NAME, typeID));
     }
@@ -93,183 +93,183 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> DivideVectorOperation::g
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> ModuloVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ModuloVectorOperation::getDefinitions() {
+    operation_vectors result;
     for (auto typeID : LogicalTypeUtils::getNumericalLogicalTypeIDs()) {
         result.push_back(getBinaryDefinition<operation::Modulo>(MODULO_FUNC_NAME, typeID));
     }
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> PowerVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors PowerVectorOperation::getDefinitions() {
+    operation_vectors result;
     // double_t ^ double_t -> double_t
     result.push_back(getBinaryDefinition<operation::Power, double_t>(
         POWER_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> NegateVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors NegateVectorOperation::getDefinitions() {
+    operation_vectors result;
     for (auto& typeID : LogicalTypeUtils::getNumericalLogicalTypeIDs()) {
         result.push_back(getUnaryDefinition<operation::Negate>(NEGATE_FUNC_NAME, typeID));
     }
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> AbsVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors AbsVectorOperation::getDefinitions() {
+    operation_vectors result;
     for (auto& typeID : LogicalTypeUtils::getNumericalLogicalTypeIDs()) {
         result.push_back(getUnaryDefinition<operation::Abs>(ABS_FUNC_NAME, typeID));
     }
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> FloorVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors FloorVectorOperation::getDefinitions() {
+    operation_vectors result;
     for (auto& typeID : LogicalTypeUtils::getNumericalLogicalTypeIDs()) {
         result.push_back(getUnaryDefinition<operation::Floor>(FLOOR_FUNC_NAME, typeID));
     }
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> CeilVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CeilVectorOperation::getDefinitions() {
+    operation_vectors result;
     for (auto& typeID : LogicalTypeUtils::getNumericalLogicalTypeIDs()) {
         result.push_back(getUnaryDefinition<operation::Ceil>(CEIL_FUNC_NAME, typeID));
     }
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> SinVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors SinVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Sin, double_t>(
         SIN_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> CosVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CosVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Cos, double_t>(
         COS_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> TanVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors TanVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Tan, double_t>(
         TAN_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> CotVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CotVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Cot, double_t>(
         COT_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> AsinVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors AsinVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Asin, double_t>(
         ASIN_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> AcosVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors AcosVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Acos, double_t>(
         ACOS_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> AtanVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors AtanVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Atan, double_t>(
         ATAN_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> FactorialVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors FactorialVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(FACTORIAL_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::INT64}, LogicalTypeID::INT64,
         UnaryExecFunction<int64_t, int64_t, operation::Factorial>));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> SqrtVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors SqrtVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Sqrt, double_t>(
         SQRT_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> CbrtVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CbrtVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Cbrt, double_t>(
         CBRT_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> GammaVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors GammaVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Gamma, double_t>(
         GAMMA_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> LgammaVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors LgammaVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Lgamma, double_t>(
         LGAMMA_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> LnVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors LnVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Ln, double_t>(
         LN_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> LogVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors LogVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Log, double_t>(
         LOG_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> Log2VectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors Log2VectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Log2, double_t>(
         LOG2_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> DegreesVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors DegreesVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Degrees, double_t>(
         DEGREES_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> RadiansVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors RadiansVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Radians, double_t>(
         RADIANS_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> EvenVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors EvenVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Even, double_t>(
         EVEN_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> SignVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors SignVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getUnaryDefinition<operation::Sign, int64_t>(
         SIGN_FUNC_NAME, LogicalTypeID::INT64, LogicalTypeID::INT64));
     result.push_back(getUnaryDefinition<operation::Sign, int64_t>(
@@ -279,62 +279,58 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> SignVectorOperation::get
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> Atan2VectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors Atan2VectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getBinaryDefinition<operation::Atan2, double_t>(
         ATAN2_FUNC_NAME, LogicalTypeID::DOUBLE, LogicalTypeID::DOUBLE));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> RoundVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors RoundVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(ROUND_FUNC_NAME,
         std::vector<common::LogicalTypeID>{LogicalTypeID::DOUBLE, LogicalTypeID::INT64},
         LogicalTypeID::DOUBLE, BinaryExecFunction<double_t, int64_t, double_t, operation::Round>));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-BitwiseXorVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors BitwiseXorVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getBinaryDefinition<operation::BitwiseXor, int64_t>(
         BITWISE_XOR_FUNC_NAME, LogicalTypeID::INT64, LogicalTypeID::INT64));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-BitwiseAndVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors BitwiseAndVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getBinaryDefinition<operation::BitwiseAnd, int64_t>(
         BITWISE_AND_FUNC_NAME, LogicalTypeID::INT64, LogicalTypeID::INT64));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> BitwiseOrVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors BitwiseOrVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getBinaryDefinition<operation::BitwiseOr, int64_t>(
         BITWISE_OR_FUNC_NAME, LogicalTypeID::INT64, LogicalTypeID::INT64));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-BitShiftLeftVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors BitShiftLeftVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getBinaryDefinition<operation::BitShiftLeft, int64_t>(
         BITSHIFT_LEFT_FUNC_NAME, LogicalTypeID::INT64, LogicalTypeID::INT64));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-BitShiftRightVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors BitShiftRightVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(getBinaryDefinition<operation::BitShiftRight, int64_t>(
         BITSHIFT_RIGHT_FUNC_NAME, LogicalTypeID::INT64, LogicalTypeID::INT64));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> PiVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors PiVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(
         make_unique<VectorOperationDefinition>(PI_FUNC_NAME, std::vector<LogicalTypeID>{},
             LogicalTypeID::DOUBLE, ConstExecFunction<double_t, operation::Pi>));
diff --git a/src/function/vector_cast_operations.cpp b/src/function/vector_cast_operations.cpp
index 2f618f8b5ab..336e34e3c04 100644
--- a/src/function/vector_cast_operations.cpp
+++ b/src/function/vector_cast_operations.cpp
@@ -113,36 +113,32 @@ void VectorCastOperations::bindImplicitCastFunc(common::LogicalTypeID sourceType
     }
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-CastToDateVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CastToDateVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(CAST_TO_DATE_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING}, LogicalTypeID::DATE,
         UnaryExecFunction<ku_string_t, date_t, operation::CastStringToDate>));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-CastToTimestampVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CastToTimestampVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(CAST_TO_TIMESTAMP_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING}, LogicalTypeID::TIMESTAMP,
         UnaryExecFunction<ku_string_t, timestamp_t, operation::CastStringToTimestamp>));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-CastToIntervalVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CastToIntervalVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(CAST_TO_INTERVAL_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING}, LogicalTypeID::INTERVAL,
         UnaryExecFunction<ku_string_t, interval_t, operation::CastStringToInterval>));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-CastToStringVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CastToStringVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(CAST_TO_STRING_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::BOOL}, LogicalTypeID::STRING,
         UnaryCastExecFunction<bool, ku_string_t, operation::CastToString>));
@@ -185,9 +181,8 @@ CastToStringVectorOperation::getDefinitions() {
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-CastToDoubleVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CastToDoubleVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(bindVectorOperation<int16_t, double_t, operation::CastToDouble>(
         CAST_TO_DOUBLE_FUNC_NAME, LogicalTypeID::INT16, LogicalTypeID::DOUBLE));
     result.push_back(bindVectorOperation<int32_t, double_t, operation::CastToDouble>(
@@ -199,9 +194,8 @@ CastToDoubleVectorOperation::getDefinitions() {
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-CastToFloatVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CastToFloatVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(bindVectorOperation<int16_t, float_t, operation::CastToFloat>(
         CAST_TO_FLOAT_FUNC_NAME, LogicalTypeID::INT16, LogicalTypeID::FLOAT));
     result.push_back(bindVectorOperation<int32_t, float_t, operation::CastToFloat>(
@@ -214,9 +208,8 @@ CastToFloatVectorOperation::getDefinitions() {
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-CastToInt64VectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CastToInt64VectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(bindVectorOperation<int16_t, int64_t, operation::CastToInt64>(
         CAST_TO_INT64_FUNC_NAME, LogicalTypeID::INT16, LogicalTypeID::INT64));
     result.push_back(bindVectorOperation<int32_t, int64_t, operation::CastToInt64>(
@@ -229,9 +222,8 @@ CastToInt64VectorOperation::getDefinitions() {
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-CastToInt32VectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CastToInt32VectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(bindVectorOperation<int16_t, int32_t, operation::CastToInt32>(
         CAST_TO_INT32_FUNC_NAME, LogicalTypeID::INT16, LogicalTypeID::INT32));
     // down cast
@@ -244,9 +236,8 @@ CastToInt32VectorOperation::getDefinitions() {
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-CastToInt16VectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CastToInt16VectorOperation::getDefinitions() {
+    operation_vectors result;
     // down cast
     result.push_back(bindVectorOperation<int32_t, int16_t, operation::CastToInt16>(
         CAST_TO_INT16_FUNC_NAME, LogicalTypeID::INT32, LogicalTypeID::INT16));
diff --git a/src/function/vector_date_operations.cpp b/src/function/vector_date_operations.cpp
index e8085e37a62..1654d3396cf 100644
--- a/src/function/vector_date_operations.cpp
+++ b/src/function/vector_date_operations.cpp
@@ -7,8 +7,8 @@ using namespace kuzu::common;
 namespace kuzu {
 namespace function {
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> DatePartVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors DatePartVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(DATE_PART_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::DATE},
         LogicalTypeID::INT64,
@@ -24,8 +24,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> DatePartVectorOperation:
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> DateTruncVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors DateTruncVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(DATE_TRUNC_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::DATE}, LogicalTypeID::DATE,
         BinaryExecFunction<ku_string_t, date_t, date_t, operation::DateTrunc>));
@@ -36,8 +36,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> DateTruncVectorOperation
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> DayNameVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors DayNameVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(DAYNAME_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::DATE}, LogicalTypeID::STRING,
         UnaryExecFunction<date_t, ku_string_t, operation::DayName>));
@@ -47,8 +47,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> DayNameVectorOperation::
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> GreatestVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors GreatestVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(GREATEST_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::DATE, LogicalTypeID::DATE}, LogicalTypeID::DATE,
         BinaryExecFunction<date_t, date_t, date_t, operation::Greatest>));
@@ -59,8 +59,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> GreatestVectorOperation:
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> LastDayVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors LastDayVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(LAST_DAY_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::DATE}, LogicalTypeID::DATE,
         UnaryExecFunction<date_t, date_t, operation::LastDay>));
@@ -70,8 +70,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> LastDayVectorOperation::
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> LeastVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors LeastVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(LEAST_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::DATE, LogicalTypeID::DATE}, LogicalTypeID::DATE,
         BinaryExecFunction<date_t, date_t, date_t, operation::Least>));
@@ -82,8 +82,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> LeastVectorOperation::ge
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> MakeDateVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors MakeDateVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(MAKE_DATE_FUNC_NAME,
         std::vector<LogicalTypeID>{
             LogicalTypeID::INT64, LogicalTypeID::INT64, LogicalTypeID::INT64},
@@ -92,8 +92,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> MakeDateVectorOperation:
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> MonthNameVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors MonthNameVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(MONTHNAME_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::DATE}, LogicalTypeID::STRING,
         UnaryExecFunction<date_t, ku_string_t, operation::MonthName>));
diff --git a/src/function/vector_list_operation.cpp b/src/function/vector_list_operation.cpp
index 4686ee745ad..6f8eb3d73ad 100644
--- a/src/function/vector_list_operation.cpp
+++ b/src/function/vector_list_operation.cpp
@@ -89,17 +89,16 @@ std::unique_ptr<FunctionBindData> ListCreationVectorOperation::bindFunc(
     return std::make_unique<FunctionBindData>(resultType);
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ListCreationVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListCreationVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_CREATION_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::ANY}, LogicalTypeID::VAR_LIST, execFunc, nullptr,
         bindFunc, true /*  isVarLength */));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> ListLenVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListLenVectorOperation::getDefinitions() {
+    operation_vectors result;
     auto execFunc = UnaryExecFunction<list_entry_t, int64_t, operation::ListLen>;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_LEN_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::VAR_LIST}, LogicalTypeID::INT64, execFunc,
@@ -168,9 +167,8 @@ std::unique_ptr<FunctionBindData> ListExtractVectorOperation::bindFunc(
     return std::make_unique<FunctionBindData>(*resultType);
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ListExtractVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListExtractVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_EXTRACT_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::VAR_LIST, LogicalTypeID::INT64},
         LogicalTypeID::ANY, nullptr, nullptr, bindFunc, false /* isVarlength*/));
@@ -182,9 +180,8 @@ ListExtractVectorOperation::getDefinitions() {
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ListConcatVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListConcatVectorOperation::getDefinitions() {
+    operation_vectors result;
     auto execFunc =
         BinaryListExecFunction<list_entry_t, list_entry_t, list_entry_t, operation::ListConcat>;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_CONCAT_FUNC_NAME,
@@ -267,9 +264,8 @@ std::unique_ptr<FunctionBindData> ListAppendVectorOperation::bindFunc(
     return std::make_unique<FunctionBindData>(resultType);
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ListAppendVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListAppendVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_APPEND_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::VAR_LIST, LogicalTypeID::ANY},
         LogicalTypeID::VAR_LIST, nullptr, nullptr, bindFunc, false /* isVarlength*/));
@@ -341,29 +337,26 @@ std::unique_ptr<FunctionBindData> ListPrependVectorOperation::bindFunc(
     return std::make_unique<FunctionBindData>(resultType);
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ListPrependVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListPrependVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_PREPEND_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::ANY, LogicalTypeID::VAR_LIST},
         LogicalTypeID::VAR_LIST, nullptr, nullptr, bindFunc, false /* isVarlength */));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ListPositionVectorOperation::getDefinitions() {
+operation_vectors ListPositionVectorOperation::getDefinitions() {
     return getBinaryListOperationDefinitions<operation::ListPosition, int64_t>(
         LIST_POSITION_FUNC_NAME, LogicalTypeID::INT64);
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ListContainsVectorOperation::getDefinitions() {
+operation_vectors ListContainsVectorOperation::getDefinitions() {
     return getBinaryListOperationDefinitions<operation::ListContains, uint8_t>(
         LIST_CONTAINS_FUNC_NAME, LogicalTypeID::BOOL);
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> ListSliceVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListSliceVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_SLICE_FUNC_NAME,
         std::vector<LogicalTypeID>{
             LogicalTypeID::VAR_LIST, LogicalTypeID::INT64, LogicalTypeID::INT64},
@@ -386,8 +379,8 @@ std::unique_ptr<FunctionBindData> ListSliceVectorOperation::bindFunc(
     return std::make_unique<FunctionBindData>(arguments[0]->getDataType());
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> ListSortVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListSortVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_SORT_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::VAR_LIST}, LogicalTypeID::VAR_LIST, nullptr,
         nullptr, bindFunc, false /* isVarlength*/));
@@ -462,9 +455,8 @@ void ListSortVectorOperation::getExecFunction(
     }
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ListReverseSortVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListReverseSortVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_REVERSE_SORT_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::VAR_LIST}, LogicalTypeID::VAR_LIST, nullptr,
         nullptr, bindFunc, false /* isVarlength*/));
@@ -531,8 +523,8 @@ void ListReverseSortVectorOperation::getExecFunction(
     }
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> ListSumVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListSumVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_SUM_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::VAR_LIST}, LogicalTypeID::INT64, nullptr, nullptr,
         bindFunc, false /* isVarlength*/));
@@ -572,9 +564,8 @@ std::unique_ptr<FunctionBindData> ListSumVectorOperation::bindFunc(
     return std::make_unique<FunctionBindData>(*resultType);
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ListDistinctVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListDistinctVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_DISTINCT_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::VAR_LIST}, LogicalTypeID::VAR_LIST, nullptr,
         nullptr, bindFunc, false /* isVarlength*/));
@@ -637,9 +628,8 @@ std::unique_ptr<FunctionBindData> ListDistinctVectorOperation::bindFunc(
     return std::make_unique<FunctionBindData>(arguments[0]->getDataType());
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ListUniqueVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListUniqueVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_UNIQUE_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::VAR_LIST}, LogicalTypeID::INT64, nullptr, nullptr,
         bindFunc, false /* isVarlength*/));
@@ -702,9 +692,8 @@ std::unique_ptr<FunctionBindData> ListUniqueVectorOperation::bindFunc(
     return std::make_unique<FunctionBindData>(LogicalType(LogicalTypeID::INT64));
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ListAnyValueVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ListAnyValueVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(std::make_unique<VectorOperationDefinition>(LIST_ANY_VALUE_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::VAR_LIST}, LogicalTypeID::ANY, nullptr, nullptr,
         bindFunc, false /* isVarlength*/));
diff --git a/src/function/vector_map_operation.cpp b/src/function/vector_map_operation.cpp
new file mode 100644
index 00000000000..b960e15e175
--- /dev/null
+++ b/src/function/vector_map_operation.cpp
@@ -0,0 +1,36 @@
+#include "function/list/vector_list_operations.h"
+#include "function/map/operations/map_operation.h"
+#include "function/map/vector_map_operations.h"
+
+namespace kuzu {
+namespace function {
+
+operation_vectors MapVectorOperations::getDefinitions() {
+    operation_vectors definitions;
+    auto excFunct = VectorListOperations::BinaryListExecFunction<common::list_entry_t,
+        common::list_entry_t, common::list_entry_t, operation::Map>;
+    definitions.push_back(make_unique<VectorOperationDefinition>(common::MAP_FUNC_NAME,
+        std::vector<common::LogicalTypeID>{
+            common::LogicalTypeID::VAR_LIST, common::LogicalTypeID::VAR_LIST},
+        common::LogicalTypeID::MAP, excFunct, nullptr, bindFunc, false /* isVarLength */));
+    return definitions;
+}
+
+std::unique_ptr<FunctionBindData> MapVectorOperations::bindFunc(
+    const binder::expression_vector& arguments, kuzu::function::FunctionDefinition* definition) {
+    auto keyType = common::VarListType::getChildType(&arguments[0]->dataType);
+    auto valueType = common::VarListType::getChildType(&arguments[1]->dataType);
+    std::vector<std::unique_ptr<common::StructField>> structFields;
+    structFields.emplace_back(std::make_unique<common::StructField>(
+        "key", std::make_unique<common::LogicalType>(*keyType)));
+    structFields.emplace_back(std::make_unique<common::StructField>(
+        "value", std::make_unique<common::LogicalType>(*valueType)));
+    auto mapStructType = std::make_unique<common::LogicalType>(common::LogicalTypeID::STRUCT,
+        std::make_unique<common::StructTypeInfo>(std::move(structFields)));
+    auto resultType = common::LogicalType(common::LogicalTypeID::MAP,
+        std::make_unique<common::VarListTypeInfo>(std::move(mapStructType)));
+    return std::make_unique<FunctionBindData>(resultType);
+}
+
+} // namespace function
+} // namespace kuzu
diff --git a/src/function/vector_string_operations.cpp b/src/function/vector_string_operations.cpp
index b39fcbf05fe..d45ffe2034d 100644
--- a/src/function/vector_string_operations.cpp
+++ b/src/function/vector_string_operations.cpp
@@ -23,9 +23,8 @@ using namespace kuzu::common;
 namespace kuzu {
 namespace function {
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ArrayExtractVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors ArrayExtractVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(ARRAY_EXTRACT_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::INT64},
         LogicalTypeID::STRING,
@@ -34,8 +33,8 @@ ArrayExtractVectorOperation::getDefinitions() {
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> ConcatVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors ConcatVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(CONCAT_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::STRING},
         LogicalTypeID::STRING,
@@ -44,8 +43,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> ConcatVectorOperation::g
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> ContainsVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors ContainsVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(CONTAINS_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::STRING},
         LogicalTypeID::BOOL,
@@ -55,8 +54,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> ContainsVectorOperation:
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> EndsWithVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors EndsWithVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(ENDS_WITH_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::STRING},
         LogicalTypeID::BOOL,
@@ -66,8 +65,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> EndsWithVectorOperation:
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> LeftVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors LeftVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(LEFT_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::INT64},
         LogicalTypeID::STRING,
@@ -76,16 +75,16 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> LeftVectorOperation::get
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> LengthVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors LengthVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(LENGTH_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING}, LogicalTypeID::INT64,
         UnaryExecFunction<ku_string_t, int64_t, operation::Length>, false /* isVarLength */));
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> LpadVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors LpadVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(LPAD_FUNC_NAME,
         std::vector<LogicalTypeID>{
             LogicalTypeID::STRING, LogicalTypeID::INT64, LogicalTypeID::STRING},
@@ -95,8 +94,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> LpadVectorOperation::get
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> RepeatVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors RepeatVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(REPEAT_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::INT64},
         LogicalTypeID::STRING,
@@ -105,8 +104,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> RepeatVectorOperation::g
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> RightVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors RightVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(RIGHT_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::INT64},
         LogicalTypeID::STRING,
@@ -115,8 +114,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> RightVectorOperation::ge
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> RpadVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors RpadVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(RPAD_FUNC_NAME,
         std::vector<LogicalTypeID>{
             LogicalTypeID::STRING, LogicalTypeID::INT64, LogicalTypeID::STRING},
@@ -126,9 +125,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> RpadVectorOperation::get
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-StartsWithVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors StartsWithVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(STARTS_WITH_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::STRING},
         LogicalTypeID::BOOL,
@@ -138,8 +136,8 @@ StartsWithVectorOperation::getDefinitions() {
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> SubStrVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors SubStrVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(SUBSTRING_FUNC_NAME,
         std::vector<LogicalTypeID>{
             LogicalTypeID::STRING, LogicalTypeID::INT64, LogicalTypeID::INT64},
@@ -149,9 +147,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> SubStrVectorOperation::g
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-RegexpFullMatchVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors RegexpFullMatchVectorOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(REGEXP_FULL_MATCH_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::STRING},
         LogicalTypeID::BOOL,
@@ -161,8 +158,8 @@ RegexpFullMatchVectorOperation::getDefinitions() {
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> RegexpMatchesOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors RegexpMatchesOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(REGEXP_MATCHES_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::STRING},
         LogicalTypeID::BOOL,
@@ -172,8 +169,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> RegexpMatchesOperation::
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> RegexpReplaceOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors RegexpReplaceOperation::getDefinitions() {
+    operation_vectors definitions;
     // Todo: Implement a function with modifiers
     //  regexp_replace(string, regex, replacement, modifiers)
     definitions.emplace_back(make_unique<VectorOperationDefinition>(REGEXP_REPLACE_FUNC_NAME,
@@ -186,8 +183,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> RegexpReplaceOperation::
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> RegexpExtractOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors RegexpExtractOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(REGEXP_EXTRACT_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::STRING},
         LogicalTypeID::STRING,
@@ -203,9 +200,8 @@ std::vector<std::unique_ptr<VectorOperationDefinition>> RegexpExtractOperation::
     return definitions;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-RegexpExtractAllOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors RegexpExtractAllOperation::getDefinitions() {
+    operation_vectors definitions;
     definitions.emplace_back(make_unique<VectorOperationDefinition>(REGEXP_EXTRACT_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::STRING, LogicalTypeID::STRING},
         LogicalTypeID::VAR_LIST,
diff --git a/src/function/vector_struct_operations.cpp b/src/function/vector_struct_operations.cpp
index 403e8776a76..9e40f21b58d 100644
--- a/src/function/vector_struct_operations.cpp
+++ b/src/function/vector_struct_operations.cpp
@@ -8,9 +8,8 @@
 namespace kuzu {
 namespace function {
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-StructPackVectorOperations::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors StructPackVectorOperations::getDefinitions() {
+    operation_vectors definitions;
     definitions.push_back(make_unique<VectorOperationDefinition>(common::STRUCT_PACK_FUNC_NAME,
         std::vector<common::LogicalTypeID>{common::LogicalTypeID::ANY},
         common::LogicalTypeID::STRUCT, execFunc, nullptr, bindFunc, true /* isVarLength */));
@@ -79,9 +78,8 @@ void StructPackVectorOperations::copyParameterValueToStructFieldVector(
     }
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-StructExtractVectorOperations::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+operation_vectors StructExtractVectorOperations::getDefinitions() {
+    operation_vectors definitions;
     definitions.push_back(make_unique<VectorOperationDefinition>(common::STRUCT_EXTRACT_FUNC_NAME,
         std::vector<common::LogicalTypeID>{
             common::LogicalTypeID::STRUCT, common::LogicalTypeID::STRING},
diff --git a/src/function/vector_timestamp_operations.cpp b/src/function/vector_timestamp_operations.cpp
index d6bfab1df4d..f7bb6d7902a 100644
--- a/src/function/vector_timestamp_operations.cpp
+++ b/src/function/vector_timestamp_operations.cpp
@@ -7,25 +7,24 @@ using namespace kuzu::common;
 namespace kuzu {
 namespace function {
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> CenturyVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors CenturyVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(CENTURY_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::TIMESTAMP}, LogicalTypeID::INT64,
         UnaryExecFunction<timestamp_t, int64_t, operation::Century>));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>> EpochMsVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors EpochMsVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(EPOCH_MS_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::INT64}, LogicalTypeID::TIMESTAMP,
         UnaryExecFunction<int64_t, timestamp_t, operation::EpochMs>));
     return result;
 }
 
-std::vector<std::unique_ptr<VectorOperationDefinition>>
-ToTimestampVectorOperation::getDefinitions() {
-    std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+operation_vectors ToTimestampVectorOperation::getDefinitions() {
+    operation_vectors result;
     result.push_back(make_unique<VectorOperationDefinition>(TO_TIMESTAMP_FUNC_NAME,
         std::vector<LogicalTypeID>{LogicalTypeID::INT64}, LogicalTypeID::TIMESTAMP,
         UnaryExecFunction<int64_t, timestamp_t, operation::ToTimestamp>));
diff --git a/src/include/common/expression_type.h b/src/include/common/expression_type.h
index 9380cceb3bd..dda14fd4462 100644
--- a/src/include/common/expression_type.h
+++ b/src/include/common/expression_type.h
@@ -66,6 +66,9 @@ const std::string LIST_ANY_VALUE_FUNC_NAME = "LIST_ANY_VALUE";
 const std::string STRUCT_PACK_FUNC_NAME = "STRUCT_PACK";
 const std::string STRUCT_EXTRACT_FUNC_NAME = "STRUCT_EXTRACT";
 
+// map
+const std::string MAP_FUNC_NAME = "MAP";
+
 // comparison
 const std::string EQUALS_FUNC_NAME = "EQUALS";
 const std::string NOT_EQUALS_FUNC_NAME = "NOT_EQUALS";
diff --git a/src/include/common/types/types.h b/src/include/common/types/types.h
index ecabdf6ddb8..18fcdb760d2 100644
--- a/src/include/common/types/types.h
+++ b/src/include/common/types/types.h
@@ -84,6 +84,7 @@ KUZU_API enum class LogicalTypeID : uint8_t {
     STRING = 50,
     VAR_LIST = 52,
     STRUCT = 53,
+    MAP = 54,
 };
 
 enum class PhysicalTypeID : uint8_t {
@@ -233,8 +234,7 @@ class LogicalType {
 
 struct VarListType {
     static inline LogicalType* getChildType(const LogicalType* type) {
-        assert(type->getLogicalTypeID() == LogicalTypeID::VAR_LIST ||
-               type->getLogicalTypeID() == LogicalTypeID::RECURSIVE_REL);
+        assert(type->getPhysicalType() == PhysicalTypeID::VAR_LIST);
         auto varListTypeInfo = reinterpret_cast<VarListTypeInfo*>(type->extraTypeInfo.get());
         return varListTypeInfo->getChildType();
     }
@@ -256,30 +256,30 @@ struct FixedListType {
 
 struct StructType {
     static inline std::vector<LogicalType*> getFieldTypes(const LogicalType* type) {
-        assert(type->getLogicalTypeID() == LogicalTypeID::STRUCT);
+        assert(type->getPhysicalType() == PhysicalTypeID::STRUCT);
         auto structTypeInfo = reinterpret_cast<StructTypeInfo*>(type->extraTypeInfo.get());
         return structTypeInfo->getChildrenTypes();
     }
 
     static inline std::vector<std::string> getFieldNames(const LogicalType* type) {
-        assert(type->getLogicalTypeID() == LogicalTypeID::STRUCT);
+        assert(type->getPhysicalType() == PhysicalTypeID::STRUCT);
         auto structTypeInfo = reinterpret_cast<StructTypeInfo*>(type->extraTypeInfo.get());
         return structTypeInfo->getChildrenNames();
     }
 
     static inline uint64_t getNumFields(const LogicalType* type) {
-        assert(type->getLogicalTypeID() == LogicalTypeID::STRUCT);
+        assert(type->getPhysicalType() == PhysicalTypeID::STRUCT);
         return getFieldTypes(type).size();
     }
 
     static inline std::vector<StructField*> getFields(const LogicalType* type) {
-        assert(type->getLogicalTypeID() == LogicalTypeID::STRUCT);
+        assert(type->getPhysicalType() == PhysicalTypeID::STRUCT);
         auto structTypeInfo = reinterpret_cast<StructTypeInfo*>(type->extraTypeInfo.get());
         return structTypeInfo->getStructFields();
     }
 
     static inline struct_field_idx_t getFieldIdx(const LogicalType* type, std::string& key) {
-        assert(type->getLogicalTypeID() == LogicalTypeID::STRUCT);
+        assert(type->getPhysicalType() == PhysicalTypeID::STRUCT);
         auto structTypeInfo = reinterpret_cast<StructTypeInfo*>(type->extraTypeInfo.get());
         return structTypeInfo->getStructFieldIdx(key);
     }
diff --git a/src/include/common/vector/value_vector.h b/src/include/common/vector/value_vector.h
index 3f5c37b418b..a85e71524e3 100644
--- a/src/include/common/vector/value_vector.h
+++ b/src/include/common/vector/value_vector.h
@@ -86,13 +86,14 @@ class ValueVector {
 class StringVector {
 public:
     static inline InMemOverflowBuffer* getInMemOverflowBuffer(ValueVector* vector) {
-        assert(vector->dataType.getLogicalTypeID() == LogicalTypeID::STRING);
+        assert(vector->dataType.getPhysicalType() == PhysicalTypeID::STRING);
         return reinterpret_cast<StringAuxiliaryBuffer*>(vector->auxiliaryBuffer.get())
             ->getOverflowBuffer();
     }
 
     static inline void addString(
         common::ValueVector* vector, uint32_t pos, char* value, uint64_t len) {
+        assert(vector->dataType.getPhysicalType() == PhysicalTypeID::STRING);
         reinterpret_cast<StringAuxiliaryBuffer*>(vector->auxiliaryBuffer.get())
             ->addString(vector, pos, value, len);
     }
@@ -101,27 +102,23 @@ class StringVector {
 class ListVector {
 public:
     static inline ValueVector* getDataVector(const ValueVector* vector) {
-        assert(vector->dataType.getLogicalTypeID() == LogicalTypeID::VAR_LIST ||
-               vector->dataType.getLogicalTypeID() == LogicalTypeID::RECURSIVE_REL);
+        assert(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST);
         return reinterpret_cast<ListAuxiliaryBuffer*>(vector->auxiliaryBuffer.get())
             ->getDataVector();
     }
     static inline uint8_t* getListValues(const ValueVector* vector, const list_entry_t& listEntry) {
-        assert(vector->dataType.getLogicalTypeID() == LogicalTypeID::VAR_LIST ||
-               vector->dataType.getLogicalTypeID() == LogicalTypeID::RECURSIVE_REL);
+        assert(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST);
         auto dataVector = getDataVector(vector);
         return dataVector->getData() + dataVector->getNumBytesPerValue() * listEntry.offset;
     }
     static inline uint8_t* getListValuesWithOffset(const ValueVector* vector,
         const list_entry_t& listEntry, common::offset_t elementOffsetInList) {
-        assert(vector->dataType.getLogicalTypeID() == LogicalTypeID::VAR_LIST ||
-               vector->dataType.getLogicalTypeID() == LogicalTypeID::RECURSIVE_REL);
+        assert(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST);
         return getListValues(vector, listEntry) +
                elementOffsetInList * getDataVector(vector)->getNumBytesPerValue();
     }
     static inline list_entry_t addList(ValueVector* vector, uint64_t listSize) {
-        assert(vector->dataType.getLogicalTypeID() == LogicalTypeID::VAR_LIST ||
-               vector->dataType.getLogicalTypeID() == LogicalTypeID::RECURSIVE_REL);
+        assert(vector->dataType.getPhysicalType() == PhysicalTypeID::VAR_LIST);
         return reinterpret_cast<ListAuxiliaryBuffer*>(vector->auxiliaryBuffer.get())
             ->addList(listSize);
     }
diff --git a/src/include/function/arithmetic/vector_arithmetic_operations.h b/src/include/function/arithmetic/vector_arithmetic_operations.h
index 9e958ba3ec3..c2a70a6643a 100644
--- a/src/include/function/arithmetic/vector_arithmetic_operations.h
+++ b/src/include/function/arithmetic/vector_arithmetic_operations.h
@@ -110,151 +110,151 @@ class VectorArithmeticOperations : public VectorOperations {
 };
 
 struct AddVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct SubtractVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct MultiplyVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct DivideVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct ModuloVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct PowerVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct AbsVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct AcosVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct AsinVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct AtanVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct Atan2VectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct BitwiseXorVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct BitwiseAndVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct BitwiseOrVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct BitShiftLeftVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct BitShiftRightVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CbrtVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CeilVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CosVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CotVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct DegreesVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct EvenVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct FactorialVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct FloorVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct GammaVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct LgammaVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct LnVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct LogVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct Log2VectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct NegateVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct PiVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct RadiansVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct RoundVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct SinVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct SignVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct SqrtVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct TanVectorOperation : public VectorArithmeticOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 } // namespace function
diff --git a/src/include/function/built_in_vector_operations.h b/src/include/function/built_in_vector_operations.h
index dbee5595492..3d26e313709 100644
--- a/src/include/function/built_in_vector_operations.h
+++ b/src/include/function/built_in_vector_operations.h
@@ -71,11 +71,11 @@ class BuiltInVectorOperations {
     void registerStringOperations();
     void registerCastOperations();
     void registerListOperations();
-    void registerStructOperation();
+    void registerStructOperations();
+    void registerMapOperations();
 
 private:
-    std::unordered_map<std::string, std::vector<std::unique_ptr<VectorOperationDefinition>>>
-        vectorOperations;
+    std::unordered_map<std::string, operation_vectors> vectorOperations;
 };
 
 } // namespace function
diff --git a/src/include/function/cast/vector_cast_operations.h b/src/include/function/cast/vector_cast_operations.h
index eeef59ded85..19df21773ff 100644
--- a/src/include/function/cast/vector_cast_operations.h
+++ b/src/include/function/cast/vector_cast_operations.h
@@ -73,39 +73,39 @@ class VectorCastOperations : public VectorOperations {
 };
 
 struct CastToDateVectorOperation : public VectorCastOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CastToTimestampVectorOperation : public VectorCastOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CastToIntervalVectorOperation : public VectorCastOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CastToStringVectorOperation : public VectorCastOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CastToDoubleVectorOperation : public VectorCastOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CastToFloatVectorOperation : public VectorCastOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CastToInt64VectorOperation : public VectorCastOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CastToInt32VectorOperation : public VectorCastOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct CastToInt16VectorOperation : public VectorCastOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 } // namespace function
diff --git a/src/include/function/comparison/vector_comparison_operations.h b/src/include/function/comparison/vector_comparison_operations.h
index 5a8a120bf9e..10dad5f2720 100644
--- a/src/include/function/comparison/vector_comparison_operations.h
+++ b/src/include/function/comparison/vector_comparison_operations.h
@@ -10,9 +10,8 @@ namespace function {
 class VectorComparisonOperations : public VectorOperations {
 protected:
     template<typename FUNC>
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions(
-        const std::string& name) {
-        std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+    static operation_vectors getDefinitions(const std::string& name) {
+        operation_vectors definitions;
         for (auto& comparableType : common::LogicalTypeUtils::getAllValidComparableLogicalTypes()) {
             definitions.push_back(getDefinition<FUNC>(name, comparableType, comparableType));
         }
@@ -141,42 +140,42 @@ class VectorComparisonOperations : public VectorOperations {
 };
 
 struct EqualsVectorOperation : public VectorComparisonOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorComparisonOperations::getDefinitions<operation::Equals>(
             common::EQUALS_FUNC_NAME);
     }
 };
 
 struct NotEqualsVectorOperation : public VectorComparisonOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorComparisonOperations::getDefinitions<operation::NotEquals>(
             common::NOT_EQUALS_FUNC_NAME);
     }
 };
 
 struct GreaterThanVectorOperation : public VectorComparisonOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorComparisonOperations::getDefinitions<operation::GreaterThan>(
             common::GREATER_THAN_FUNC_NAME);
     }
 };
 
 struct GreaterThanEqualsVectorOperation : public VectorComparisonOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorComparisonOperations::getDefinitions<operation::GreaterThanEquals>(
             common::GREATER_THAN_EQUALS_FUNC_NAME);
     }
 };
 
 struct LessThanVectorOperation : public VectorComparisonOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorComparisonOperations::getDefinitions<operation::LessThan>(
             common::LESS_THAN_FUNC_NAME);
     }
 };
 
 struct LessThanEqualsVectorOperation : public VectorComparisonOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorComparisonOperations::getDefinitions<operation::LessThanEquals>(
             common::LESS_THAN_EQUALS_FUNC_NAME);
     }
diff --git a/src/include/function/date/vector_date_operations.h b/src/include/function/date/vector_date_operations.h
index 8b1cb5c1d31..b1a89c442d4 100644
--- a/src/include/function/date/vector_date_operations.h
+++ b/src/include/function/date/vector_date_operations.h
@@ -7,35 +7,35 @@ namespace function {
 class VectorDateOperations : public VectorOperations {};
 
 struct DatePartVectorOperation : public VectorDateOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct DateTruncVectorOperation : public VectorDateOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct DayNameVectorOperation : public VectorDateOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct GreatestVectorOperation : public VectorDateOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct LastDayVectorOperation : public VectorDateOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct LeastVectorOperation : public VectorDateOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct MakeDateVectorOperation : public VectorDateOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct MonthNameVectorOperation : public VectorDateOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 } // namespace function
diff --git a/src/include/function/interval/vector_interval_operations.h b/src/include/function/interval/vector_interval_operations.h
index 524c0561e16..db051361f97 100644
--- a/src/include/function/interval/vector_interval_operations.h
+++ b/src/include/function/interval/vector_interval_operations.h
@@ -9,9 +9,8 @@ namespace function {
 class VectorIntervalOperations : public VectorOperations {
 public:
     template<class OPERATION>
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>>
-    getUnaryIntervalFunctionDefintion(std::string funcName) {
-        std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+    static inline operation_vectors getUnaryIntervalFunctionDefintion(std::string funcName) {
+        operation_vectors result;
         result.push_back(std::make_unique<VectorOperationDefinition>(funcName,
             std::vector<common::LogicalTypeID>{common::LogicalTypeID::INT64},
             common::LogicalTypeID::INTERVAL,
@@ -21,56 +20,56 @@ class VectorIntervalOperations : public VectorOperations {
 };
 
 struct ToYearsVectorOperation : public VectorIntervalOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorIntervalOperations::getUnaryIntervalFunctionDefintion<operation::ToYears>(
             common::TO_YEARS_FUNC_NAME);
     }
 };
 
 struct ToMonthsVectorOperation : public VectorIntervalOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorIntervalOperations::getUnaryIntervalFunctionDefintion<operation::ToMonths>(
             common::TO_MONTHS_FUNC_NAME);
     }
 };
 
 struct ToDaysVectorOperation : public VectorIntervalOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorIntervalOperations::getUnaryIntervalFunctionDefintion<operation::ToDays>(
             common::TO_DAYS_FUNC_NAME);
     }
 };
 
 struct ToHoursVectorOperation : public VectorIntervalOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorIntervalOperations::getUnaryIntervalFunctionDefintion<operation::ToHours>(
             common::TO_HOURS_FUNC_NAME);
     }
 };
 
 struct ToMinutesVectorOperation : public VectorIntervalOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorIntervalOperations::getUnaryIntervalFunctionDefintion<operation::ToMinutes>(
             common::TO_MINUTES_FUNC_NAME);
     }
 };
 
 struct ToSecondsVectorOperation : public VectorIntervalOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorIntervalOperations::getUnaryIntervalFunctionDefintion<operation::ToSeconds>(
             common::TO_SECONDS_FUNC_NAME);
     }
 };
 
 struct ToMillisecondsVectorOperation : public VectorIntervalOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorIntervalOperations::getUnaryIntervalFunctionDefintion<
             operation::ToMilliseconds>(common::TO_MILLISECONDS_FUNC_NAME);
     }
 };
 
 struct ToMicrosecondsVectorOperation : public VectorIntervalOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return VectorIntervalOperations::getUnaryIntervalFunctionDefintion<
             operation::ToMicroseconds>(common::TO_MICROSECONDS_FUNC_NAME);
     }
diff --git a/src/include/function/list/vector_list_operations.h b/src/include/function/list/vector_list_operations.h
index 2ad19bf5e82..1a88334c7d4 100644
--- a/src/include/function/list/vector_list_operations.h
+++ b/src/include/function/list/vector_list_operations.h
@@ -33,9 +33,9 @@ struct VectorListOperations : public VectorOperations {
     }
 
     template<typename OPERATION, typename RESULT_TYPE>
-    static std::vector<std::unique_ptr<VectorOperationDefinition>>
-    getBinaryListOperationDefinitions(std::string funcName, common::LogicalTypeID resultTypeID) {
-        std::vector<std::unique_ptr<VectorOperationDefinition>> result;
+    static operation_vectors getBinaryListOperationDefinitions(
+        std::string funcName, common::LogicalTypeID resultTypeID) {
+        operation_vectors result;
         scalar_exec_func execFunc;
         for (auto& rightTypeID : std::vector<common::LogicalTypeID>{common::LogicalTypeID::BOOL,
                  common::LogicalTypeID::INT64, common::LogicalTypeID::DOUBLE,
@@ -88,7 +88,7 @@ struct VectorListOperations : public VectorOperations {
 };
 
 struct ListCreationVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
     static void execFunc(const std::vector<std::shared_ptr<common::ValueVector>>& parameters,
@@ -96,49 +96,49 @@ struct ListCreationVectorOperation : public VectorListOperations {
 };
 
 struct ListLenVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct ListExtractVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
 };
 
 struct ListConcatVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
 };
 
 struct ListAppendVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
 };
 
 struct ListPrependVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
 };
 
 struct ListPositionVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct ListContainsVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct ListSliceVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
 };
 
 struct ListSortVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
     template<typename T>
@@ -146,7 +146,7 @@ struct ListSortVectorOperation : public VectorListOperations {
 };
 
 struct ListReverseSortVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
     template<typename T>
@@ -154,25 +154,25 @@ struct ListReverseSortVectorOperation : public VectorListOperations {
 };
 
 struct ListSumVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
 };
 
 struct ListDistinctVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
 };
 
 struct ListUniqueVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
 };
 
 struct ListAnyValueVectorOperation : public VectorListOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
 };
diff --git a/src/include/function/map/operations/map_operation.h b/src/include/function/map/operations/map_operation.h
new file mode 100644
index 00000000000..6ed5f67ba3b
--- /dev/null
+++ b/src/include/function/map/operations/map_operation.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <cassert>
+#include <cstring>
+
+#include "common/vector/value_vector.h"
+#include "common/vector/value_vector_utils.h"
+
+namespace kuzu {
+namespace function {
+namespace operation {
+
+struct Map {
+    static void operation(common::list_entry_t& keyEntry, common::list_entry_t& valueEntry,
+        common::list_entry_t& resultEntry, common::ValueVector& keyVector,
+        common::ValueVector& valueVector, common::ValueVector& resultVector) {
+        if (keyEntry.size != valueEntry.size) {
+            throw common::RuntimeException{"Unaligned key list and value list."};
+        }
+        resultEntry = common::ListVector::addList(&resultVector, keyEntry.size);
+        auto resultStructVector = common::ListVector::getDataVector(&resultVector);
+        copyListEntry(resultEntry,
+            common::StructVector::getChildVector(resultStructVector, 0 /* keyVector */).get(),
+            keyEntry, &keyVector);
+        copyListEntry(resultEntry,
+            common::StructVector::getChildVector(resultStructVector, 1 /* valueVector */).get(),
+            valueEntry, &valueVector);
+    }
+
+    static void copyListEntry(common::list_entry_t& resultEntry, common::ValueVector* resultVector,
+        common::list_entry_t& srcEntry, common::ValueVector* srcVector) {
+        auto resultValues =
+            resultVector->getData() + resultVector->getNumBytesPerValue() * resultEntry.offset;
+        auto srcValues = common::ListVector::getListValues(srcVector, srcEntry);
+        auto srcDataVector = common::ListVector::getDataVector(srcVector);
+        for (auto i = 0u; i < srcEntry.size; i++) {
+            common::ValueVectorUtils::copyValue(
+                resultValues, *resultVector, srcValues, *srcDataVector);
+            srcValues += srcDataVector->getNumBytesPerValue();
+            resultValues += resultVector->getNumBytesPerValue();
+        }
+    }
+};
+
+} // namespace operation
+} // namespace function
+} // namespace kuzu
diff --git a/src/include/function/map/vector_map_operations.h b/src/include/function/map/vector_map_operations.h
new file mode 100644
index 00000000000..56d223ea37a
--- /dev/null
+++ b/src/include/function/map/vector_map_operations.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include "common/vector/value_vector_utils.h"
+#include "function/vector_operations.h"
+
+namespace kuzu {
+namespace function {
+
+struct MapVectorOperations {
+    static operation_vectors getDefinitions();
+    static std::unique_ptr<FunctionBindData> bindFunc(
+        const binder::expression_vector& arguments, FunctionDefinition* definition);
+};
+
+} // namespace function
+} // namespace kuzu
diff --git a/src/include/function/schema/vector_offset_operations.h b/src/include/function/schema/vector_offset_operations.h
index 28da693c76c..e1cc0d56e5e 100644
--- a/src/include/function/schema/vector_offset_operations.h
+++ b/src/include/function/schema/vector_offset_operations.h
@@ -14,8 +14,8 @@ struct OffsetVectorOperation {
             *params[0], result);
     }
 
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
-        std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+    static operation_vectors getDefinitions() {
+        operation_vectors definitions;
         definitions.push_back(make_unique<VectorOperationDefinition>(common::OFFSET_FUNC_NAME,
             std::vector<common::LogicalTypeID>{common::LogicalTypeID::INTERNAL_ID},
             common::LogicalTypeID::INT64, OffsetVectorOperation::execFunction));
diff --git a/src/include/function/string/vector_string_operations.h b/src/include/function/string/vector_string_operations.h
index a31a6f15552..e5324291f1b 100644
--- a/src/include/function/string/vector_string_operations.h
+++ b/src/include/function/string/vector_string_operations.h
@@ -40,9 +40,8 @@ struct VectorStringOperations : public VectorOperations {
     }
 
     template<class OPERATION>
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>>
-    getUnaryStrFunctionDefintion(std::string funcName) {
-        std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+    static inline operation_vectors getUnaryStrFunctionDefintion(std::string funcName) {
+        operation_vectors definitions;
         definitions.emplace_back(std::make_unique<VectorOperationDefinition>(funcName,
             std::vector<common::LogicalTypeID>{common::LogicalTypeID::STRING},
             common::LogicalTypeID::STRING,
@@ -53,107 +52,107 @@ struct VectorStringOperations : public VectorOperations {
 };
 
 struct ArrayExtractVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct ConcatVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct ContainsVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct EndsWithVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct LeftVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct LengthVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct LowerVectorOperation : public VectorStringOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return getUnaryStrFunctionDefintion<operation::Lower>(common::LOWER_FUNC_NAME);
     }
 };
 
 struct LpadVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct LtrimVectorOperation : public VectorStringOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return getUnaryStrFunctionDefintion<operation::Ltrim>(common::LTRIM_FUNC_NAME);
     }
 };
 
 struct RepeatVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct ReverseVectorOperation : public VectorStringOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return getUnaryStrFunctionDefintion<operation::Reverse>(common::REVERSE_FUNC_NAME);
     }
 };
 
 struct RightVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct RpadVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct RtrimVectorOperation : public VectorStringOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return getUnaryStrFunctionDefintion<operation::Rtrim>(common::RTRIM_FUNC_NAME);
     }
 };
 
 struct StartsWithVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct SubStrVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct TrimVectorOperation : public VectorStringOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return getUnaryStrFunctionDefintion<operation::Trim>(common::TRIM_FUNC_NAME);
     }
 };
 
 struct UpperVectorOperation : public VectorStringOperations {
-    static inline std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+    static inline operation_vectors getDefinitions() {
         return getUnaryStrFunctionDefintion<operation::Upper>(common::UPPER_FUNC_NAME);
     }
 };
 
 struct RegexpFullMatchVectorOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct RegexpMatchesOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct RegexpReplaceOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct RegexpExtractOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct RegexpExtractAllOperation : public VectorStringOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
 };
diff --git a/src/include/function/struct/vector_struct_operations.h b/src/include/function/struct/vector_struct_operations.h
index 40c0ceb45e9..6bee1540a1e 100644
--- a/src/include/function/struct/vector_struct_operations.h
+++ b/src/include/function/struct/vector_struct_operations.h
@@ -7,7 +7,7 @@ namespace kuzu {
 namespace function {
 
 struct StructPackVectorOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
     static void execFunc(const std::vector<std::shared_ptr<common::ValueVector>>& parameters,
@@ -24,7 +24,7 @@ struct StructExtractBindData : public FunctionBindData {
 };
 
 struct StructExtractVectorOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
     static std::unique_ptr<FunctionBindData> bindFunc(
         const binder::expression_vector& arguments, FunctionDefinition* definition);
     static void execFunc(const std::vector<std::shared_ptr<common::ValueVector>>& parameters,
diff --git a/src/include/function/timestamp/vector_timestamp_operations.h b/src/include/function/timestamp/vector_timestamp_operations.h
index 9b4175f835e..7c1727a9df6 100644
--- a/src/include/function/timestamp/vector_timestamp_operations.h
+++ b/src/include/function/timestamp/vector_timestamp_operations.h
@@ -7,15 +7,15 @@ namespace function {
 class VectorTimestampOperations : public VectorOperations {};
 
 struct CenturyVectorOperation : public VectorTimestampOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct EpochMsVectorOperation : public VectorTimestampOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 struct ToTimestampVectorOperation : public VectorTimestampOperations {
-    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions();
+    static operation_vectors getDefinitions();
 };
 
 } // namespace function
diff --git a/src/include/function/vector_operations.h b/src/include/function/vector_operations.h
index 46d02d5e740..9710858d569 100644
--- a/src/include/function/vector_operations.h
+++ b/src/include/function/vector_operations.h
@@ -16,6 +16,7 @@ using scalar_exec_func = std::function<void(
     const std::vector<std::shared_ptr<common::ValueVector>>&, common::ValueVector&)>;
 using scalar_select_func = std::function<bool(
     const std::vector<std::shared_ptr<common::ValueVector>>&, common::SelectionVector&)>;
+using operation_vectors = std::vector<std::unique_ptr<VectorOperationDefinition>>;
 
 struct VectorOperationDefinition : public FunctionDefinition {
 
@@ -82,7 +83,7 @@ struct VectorOperations {
     template<typename RESULT_TYPE, typename FUNC>
     static void ConstExecFunction(const std::vector<std::shared_ptr<common::ValueVector>>& params,
         common::ValueVector& result) {
-        assert(params.size() == 0);
+        assert(params.empty());
         ConstOperationExecutor::execute<RESULT_TYPE, FUNC>(result);
     }
 };
diff --git a/src/processor/result/factorized_table.cpp b/src/processor/result/factorized_table.cpp
index 760a9b1a08c..77994579083 100644
--- a/src/processor/result/factorized_table.cpp
+++ b/src/processor/result/factorized_table.cpp
@@ -333,19 +333,18 @@ int64_t FactorizedTable::findValueInFlatColumn(ft_col_idx_t colIdx, int64_t valu
 }
 
 uint32_t FactorizedTable::getDataTypeSize(const common::LogicalType& type) {
-    switch (type.getLogicalTypeID()) {
-    case LogicalTypeID::STRING: {
+    switch (type.getPhysicalType()) {
+    case PhysicalTypeID::STRING: {
         return sizeof(ku_string_t);
     }
-    case LogicalTypeID::FIXED_LIST: {
+    case PhysicalTypeID::FIXED_LIST: {
         return getDataTypeSize(*FixedListType::getChildType(&type)) *
                FixedListType::getNumElementsInList(&type);
     }
-    case LogicalTypeID::RECURSIVE_REL:
-    case LogicalTypeID::VAR_LIST: {
+    case PhysicalTypeID::VAR_LIST: {
         return sizeof(ku_list_t);
     }
-    case LogicalTypeID::STRUCT: {
+    case PhysicalTypeID::STRUCT: {
         uint32_t size = 0;
         auto fieldsTypes = StructType::getFieldTypes(&type);
         for (auto fieldType : fieldsTypes) {
@@ -676,16 +675,15 @@ void FactorizedTable::readFlatColToUnflatVector(uint8_t** tuplesToRead, ft_col_i
 
 void FactorizedTable::copyOverflowIfNecessary(
     uint8_t* dst, uint8_t* src, const LogicalType& type, DiskOverflowFile* diskOverflowFile) {
-    switch (type.getLogicalTypeID()) {
-    case LogicalTypeID::STRING: {
+    switch (type.getPhysicalType()) {
+    case PhysicalTypeID::STRING: {
         ku_string_t* stringToWriteFrom = (ku_string_t*)src;
         if (!ku_string_t::isShortString(stringToWriteFrom->len)) {
             diskOverflowFile->writeStringOverflowAndUpdateOverflowPtr(
                 *stringToWriteFrom, *(ku_string_t*)dst);
         }
     } break;
-    case LogicalTypeID::RECURSIVE_REL:
-    case LogicalTypeID::VAR_LIST: {
+    case PhysicalTypeID::VAR_LIST: {
         diskOverflowFile->writeListOverflowAndUpdateOverflowPtr(
             *(ku_list_t*)src, *(ku_list_t*)dst, type);
     } break;
diff --git a/src/storage/storage_utils.cpp b/src/storage/storage_utils.cpp
index daaabcbbf4f..35a7bc47126 100644
--- a/src/storage/storage_utils.cpp
+++ b/src/storage/storage_utils.cpp
@@ -258,18 +258,18 @@ void StorageUtils::createFileForRelListsPropertyWithDefaultVal(table_id_t relTab
 }
 
 uint32_t StorageUtils::getDataTypeSize(const common::LogicalType& type) {
-    switch (type.getLogicalTypeID()) {
-    case common::LogicalTypeID::STRING: {
+    switch (type.getPhysicalType()) {
+    case common::PhysicalTypeID::STRING: {
         return sizeof(common::ku_string_t);
     }
-    case common::LogicalTypeID::FIXED_LIST: {
+    case common::PhysicalTypeID::FIXED_LIST: {
         return getDataTypeSize(*common::FixedListType::getChildType(&type)) *
                common::FixedListType::getNumElementsInList(&type);
     }
-    case common::LogicalTypeID::VAR_LIST: {
+    case common::PhysicalTypeID::VAR_LIST: {
         return sizeof(common::ku_list_t);
     }
-    case common::LogicalTypeID::STRUCT: {
+    case common::PhysicalTypeID::STRUCT: {
         uint32_t size = 0;
         auto fieldsTypes = common::StructType::getFieldTypes(&type);
         for (auto fieldType : fieldsTypes) {
diff --git a/test/test_files/tinysnb/exception/exception.test b/test/test_files/tinysnb/exception/exception.test
index cc404a2d0d7..39b0b9c496a 100644
--- a/test/test_files/tinysnb/exception/exception.test
+++ b/test/test_files/tinysnb/exception/exception.test
@@ -32,3 +32,8 @@ Runtime exception: Cast failed. 10000000000 is not in INT16 range.
 -STATEMENT CREATE NODE TABLE play(a INT32, PRIMARY KEY (a))
 ---- error
 Binder exception: Invalid primary key type: INT32. Expected STRING or INT64.
+
+-CASE UnalignedKeyAndValueList
+-QUERY RETURN MAP([4],[3,2])
+---- error
+Runtime exception: Unaligned key list and value list.
diff --git a/test/test_files/tinysnb/projection/single_label.test b/test/test_files/tinysnb/projection/single_label.test
index 966d6ba73f8..3c287cdfbc4 100644
--- a/test/test_files/tinysnb/projection/single_label.test
+++ b/test/test_files/tinysnb/projection/single_label.test
@@ -536,3 +536,86 @@ Dan|Carol
 [{DESCRIPTION: {PROPA: [2,1], PROPB: 2000-01-01}, NAME: Dan},{DESCRIPTION: {PROPA: [5,3], PROPB: 1950-07-23}, NAME: Carol}]
 [{DESCRIPTION: {PROPA: [1,2], PROPB: 1905-12-12}, NAME: Elizabeth},{DESCRIPTION: {PROPA: [7,8], PROPB: 1980-10-26}, NAME: Farooq}]
 [{DESCRIPTION: {PROPA: [1,2], PROPB: 1905-12-12}, NAME: Elizabeth},{DESCRIPTION: {PROPA: [7,9], PROPB: 1980-10-26}, NAME: Greg}]
+
+-NAME ReturnMapLiteral
+-QUERY RETURN map(['Alice', 'Bob', 'Carol', 'Dan'], [20, 34, 50, 22]);
+---- 1
+{Alice=20, Bob=34, Carol=50, Dan=22}
+
+-NAME ReturnMapLiteralWithProp
+-QUERY MATCH (p:person) RETURN map([p.ID, p.age], [p.fName, p.fName]);
+---- 8
+{0=Alice, 35=Alice}
+{2=Bob, 30=Bob}
+{3=Carol, 45=Carol}
+{5=Dan, 20=Dan}
+{7=Elizabeth, 20=Elizabeth}
+{8=Farooq, 25=Farooq}
+{9=Greg, 40=Greg}
+{10=Hubert Blaine Wolfeschlegelsteinhausenbergerdorff, 83=Hubert Blaine Wolfeschlegelsteinhausenbergerdorff}
+
+-NAME ReturnMapLiteralWithFlatUnflatProp
+-QUERY MATCH (p:person)-[:knows]->(p1:person) RETURN map([p.fName, p1.fName], [p.age, p1.age]);
+---- 14
+{Alice=35, Bob=30}
+{Alice=35, Carol=45}
+{Alice=35, Dan=20}
+{Bob=30, Alice=35}
+{Bob=30, Carol=45}
+{Bob=30, Dan=20}
+{Carol=45, Alice=35}
+{Carol=45, Bob=30}
+{Carol=45, Dan=20}
+{Dan=20, Alice=35}
+{Dan=20, Bob=30}
+{Dan=20, Carol=45}
+{Elizabeth=20, Farooq=25}
+{Elizabeth=20, Greg=40}
+
+-NAME ReturnMapLiteralWithFlatUnflatProp1
+-QUERY MATCH (p:person)-[:knows]->(p1:person) RETURN map([p.fName], [p1.age]);
+---- 14
+{Alice=30}
+{Alice=45}
+{Alice=20}
+{Bob=35}
+{Bob=45}
+{Bob=20}
+{Carol=35}
+{Carol=30}
+{Carol=20}
+{Dan=35}
+{Dan=30}
+{Dan=45}
+{Elizabeth=25}
+{Elizabeth=40}
+
+-NAME ReturnMapLiteralWithNestedType
+-QUERY MATCH (p:person)-[:knows]->(p1:person) RETURN map([p.workedHours, p1.workedHours], [p.courseScoresPerTerm, p1.courseScoresPerTerm]);
+---- 14
+{[10,5]=[[10,8],[6,7,8]], [12,8]=[[8,9],[9,10]]}
+{[10,5]=[[10,8],[6,7,8]], [4,5]=[[8,10]]}
+{[10,5]=[[10,8],[6,7,8]], [1,9]=[[7,4],[8,8],[9]]}
+{[12,8]=[[8,9],[9,10]], [10,5]=[[10,8],[6,7,8]]}
+{[12,8]=[[8,9],[9,10]], [4,5]=[[8,10]]}
+{[12,8]=[[8,9],[9,10]], [1,9]=[[7,4],[8,8],[9]]}
+{[4,5]=[[8,10]], [10,5]=[[10,8],[6,7,8]]}
+{[4,5]=[[8,10]], [12,8]=[[8,9],[9,10]]}
+{[4,5]=[[8,10]], [1,9]=[[7,4],[8,8],[9]]}
+{[1,9]=[[7,4],[8,8],[9]], [10,5]=[[10,8],[6,7,8]]}
+{[1,9]=[[7,4],[8,8],[9]], [12,8]=[[8,9],[9,10]]}
+{[1,9]=[[7,4],[8,8],[9]], [4,5]=[[8,10]]}
+{[2]=[[6],[7],[8]], [3,4,5,6,7]=[[8]]}
+{[2]=[[6],[7],[8]], [1]=[[10]]}
+
+-NAME ReturnMapLiteralWithNestedType1
+-QUERY MATCH (p:person) RETURN map([map([p.ID], [p.fName])], [p.age]);
+---- 8
+{{0=Alice}=35}
+{{2=Bob}=30}
+{{3=Carol}=45}
+{{5=Dan}=20}
+{{7=Elizabeth}=20}
+{{8=Farooq}=25}
+{{9=Greg}=40}
+{{10=Hubert Blaine Wolfeschlegelsteinhausenbergerdorff}=83}