Add internal offset function

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/schema/vector_offset_operations.h"
 #include "function/string/vector_string_operations.h"
 #include "function/timestamp/vector_timestamp_operations.h"
 
@@ -24,6 +25,8 @@ void BuiltInVectorOperations::registerVectorOperations() {
     registerCastOperations();
     registerListOperations();
     registerInternalIDOperation();
+    // register internal offset operation
+    vectorOperations.insert({OFFSET_FUNC_NAME, OffsetVectorOperation::getDefinitions()});
 }
 
 bool BuiltInVectorOperations::canApplyStaticEvaluation(

src/include/common/expression_type.h

@@ -163,6 +163,7 @@ const std::string TO_MICROSECONDS_FUNC_NAME = "TO_MICROSECONDS";
 // Node/Rel functions.
 const std::string ID_FUNC_NAME = "ID";
 const std::string LABEL_FUNC_NAME = "LABEL";
+const std::string OFFSET_FUNC_NAME = "OFFSET";
 
 enum ExpressionType : uint8_t {
 

src/include/function/built_in_vector_operations.h

@@ -51,6 +51,7 @@ class BuiltInVectorOperations {
     void registerCastOperations();
     void registerListOperations();
     void registerInternalIDOperation();
+    void registerInternalOffsetOperation();
 
 private:
     std::unordered_map<std::string, std::vector<std::unique_ptr<VectorOperationDefinition>>>

src/include/function/schema/offset_operations.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "common/type_utils.h"
+
+namespace kuzu {
+namespace function {
+namespace operation {
+
+struct Offset {
+    static inline void operation(common::internalID_t& input, int64_t& result) {
+        result = input.offset;
+    }
+};
+
+} // namespace operation
+} // namespace function
+} // namespace kuzu

src/include/function/schema/vector_offset_operations.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "function/vector_operations.h"
+#include "offset_operations.h"
+
+namespace kuzu {
+namespace function {
+
+struct OffsetVectorOperation : public VectorOperations {
+    static void execFunction(const std::vector<std::shared_ptr<common::ValueVector>>& params,
+        common::ValueVector& result) {
+        assert(params.size() == 1);
+        UnaryOperationExecutor::execute<common::internalID_t, int64_t, operation::Offset>(
+            *params[0], result);
+    }
+
+    static std::vector<std::unique_ptr<VectorOperationDefinition>> getDefinitions() {
+        std::vector<std::unique_ptr<VectorOperationDefinition>> definitions;
+        definitions.push_back(make_unique<VectorOperationDefinition>(common::OFFSET_FUNC_NAME,
+            std::vector<common::DataTypeID>{common::INTERNAL_ID}, common::INT64,
+            OffsetVectorOperation::execFunction));
+        return definitions;
+    }
+};
+
+} // namespace function
+} // namespace kuzu

test/runner/e2e_read_test.cpp

@@ -41,6 +41,7 @@ TEST_F(TinySnbReadTest, Filter) {
 }
 
 TEST_F(TinySnbReadTest, Function) {
+    runTest(TestHelper::appendKuzuRootPath("test/test_files/tinysnb/function/offset.test"));
     runTest(TestHelper::appendKuzuRootPath("test/test_files/tinysnb/function/date.test"));
     runTest(TestHelper::appendKuzuRootPath("test/test_files/tinysnb/function/timestamp.test"));
     runTest(TestHelper::appendKuzuRootPath("test/test_files/tinysnb/function/interval.test"));

test/test_files/tinysnb/function/offset.test

@@ -0,0 +1,30 @@
+-NAME NodeOffsetTest1
+-QUERY MATCH (a:person) RETURN id(a), offset(id(a))
+---- 8
+0:0|0
+0:1|1
+0:2|2
+0:3|3
+0:4|4
+0:5|5
+0:6|6
+0:7|7
+
+-NAME NodeOffsetTest2
+-QUERY MATCH (a:organisation) RETURN id(a), offset(id(a))
+---- 3
+1:0|0
+1:1|1
+1:2|2
+
+-NAME NodeOffsetTest3
+-QUERY MATCH (a:person) WHERE  offset(id(a))=0 RETURN a.fName
+---- 1
+Alice
+
+-NAME RelOffsetTest2
+-QUERY MATCH (:person)-[e:studyAt]->(:organisation) RETURN id(e), offset(id(e))
+---- 3
+4:0|0
+4:1|1
+4:2|2