Fix kuzu version function

src/antlr4/Cypher.g4

@@ -188,7 +188,7 @@ oC_ReadingClause
         ;
 
 kU_InQueryCall
-    : CALL SP oC_FunctionName SP? '(' oC_Literal? ')' ;
+    : CALL SP oC_FunctionName SP? '(' oC_Literal* ')' ;
 
 oC_Match
     : ( OPTIONAL SP )? MATCH SP? oC_Pattern (SP? oC_Where)? ;

src/binder/bind/bind_reading_clause.cpp

@@ -2,7 +2,7 @@
 #include "binder/call/bound_in_query_call.h"
 #include "binder/expression/literal_expression.h"
 #include "binder/query/reading_clause/bound_unwind_clause.h"
-#include "parser/call/in_query_call.h"
+#include "parser/query/reading_clause/in_query_call_clause.h"
 #include "parser/query/reading_clause/unwind_clause.h"
 
 using namespace kuzu::common;
@@ -20,7 +20,7 @@ std::unique_ptr<BoundReadingClause> Binder::bindReadingClause(const ReadingClaus
         return bindUnwindClause((UnwindClause&)readingClause);
     }
     case ClauseType::InQueryCall: {
-        return bindInQueryCall((InQueryCall&)readingClause);
+        return bindInQueryCall((InQueryCallClause&)readingClause);
     }
     default:
         throw NotImplementedException("bindReadingClause().");
@@ -58,14 +58,16 @@ std::unique_ptr<BoundReadingClause> Binder::bindUnwindClause(const ReadingClause
 }
 
 std::unique_ptr<BoundReadingClause> Binder::bindInQueryCall(const ReadingClause& readingClause) {
-    auto& callStatement = reinterpret_cast<const parser::InQueryCall&>(readingClause);
+    auto& callStatement = reinterpret_cast<const parser::InQueryCallClause&>(readingClause);
     auto tableFunctionDefinition =
         catalog.getBuiltInTableFunction()->mathTableFunction(callStatement.getFuncName());
-    auto boundExpr = expressionBinder.bindLiteralExpression(*callStatement.getParameter());
-    auto inputValue = reinterpret_cast<LiteralExpression*>(boundExpr.get())->getValue();
+    auto inputValues = std::vector<common::Value>{};
+    for (auto& parameter : callStatement.getParameters()) {
+        auto boundExpr = expressionBinder.bindLiteralExpression(*parameter);
+        inputValues.push_back(*reinterpret_cast<LiteralExpression*>(boundExpr.get())->getValue());
+    }
     auto bindData = tableFunctionDefinition->bindFunc(clientContext,
-        function::TableFuncBindInput{std::vector<common::Value>{*inputValue}},
-        catalog.getReadOnlyVersion());
+        function::TableFuncBindInput{std::move(inputValues)}, catalog.getReadOnlyVersion());
     expression_vector outputExpressions;
     for (auto i = 0u; i < bindData->returnColumnNames.size(); i++) {
         outputExpressions.push_back(

src/function/table_functions.cpp

@@ -65,7 +65,7 @@ std::unique_ptr<TableFuncBindData> DBVersionFunction::bindFunc(main::ClientConte
     kuzu::function::TableFuncBindInput input, catalog::CatalogContent* catalog) {
     std::vector<std::string> returnColumnNames;
     std::vector<common::LogicalType> returnTypes;
-    returnColumnNames.emplace_back("KUZU_Version");
+    returnColumnNames.emplace_back("version");
     returnTypes.emplace_back(common::LogicalTypeID::STRING);
     return std::make_unique<TableFuncBindData>(
         std::move(returnTypes), std::move(returnColumnNames), 1 /* one row result */);

src/include/parser/call/in_query_call.h → src/include/parser/query/reading_clause/in_query_call_clause.h

@@ -6,19 +6,20 @@
 namespace kuzu {
 namespace parser {
 
-class InQueryCall : public ReadingClause {
+class InQueryCallClause : public ReadingClause {
 public:
-    InQueryCall(std::string optionName, std::unique_ptr<ParsedExpression> optionValue)
+    InQueryCallClause(
+        std::string optionName, std::vector<std::unique_ptr<ParsedExpression>> parameters)
         : ReadingClause{common::ClauseType::InQueryCall}, funcName{std::move(optionName)},
-          parameter{std::move(optionValue)} {}
+          parameters{std::move(parameters)} {}
 
     inline std::string getFuncName() const { return funcName; }
 
-    inline ParsedExpression* getParameter() const { return parameter.get(); }
+    std::vector<ParsedExpression*> getParameters() const;
 
 private:
     std::string funcName;
-    std::unique_ptr<ParsedExpression> parameter;
+    std::vector<std::unique_ptr<ParsedExpression>> parameters;
 };
 
 } // namespace parser

src/parser/query/CMakeLists.txt

@@ -1,3 +1,5 @@
+add_subdirectory(reading_clause)
+
 add_library(kuzu_parser_query
         OBJECT
         single_query.cpp)

src/parser/query/reading_clause/CMakeLists.txt

@@ -0,0 +1,7 @@
+add_library(kuzu_reading_clause
+        OBJECT
+        in_query_call_clause.cpp)
+
+set(ALL_OBJECT_FILES
+        ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:kuzu_reading_clause>
+        PARENT_SCOPE)

src/parser/query/reading_clause/in_query_call_clause.cpp

@@ -0,0 +1,16 @@
+#include "parser/query/reading_clause/in_query_call_clause.h"
+
+namespace kuzu {
+namespace parser {
+
+std::vector<ParsedExpression*> InQueryCallClause::getParameters() const {
+    std::vector<ParsedExpression*> parametersToReturn;
+    parametersToReturn.reserve(parameters.size());
+    for (auto& parameter : parameters) {
+        parametersToReturn.push_back(parameter.get());
+    }
+    return parametersToReturn;
+}
+
+} // namespace parser
+} // namespace kuzu

src/parser/transformer.cpp

@@ -2,7 +2,6 @@
 
 #include "common/copier_config/copier_config.h"
 #include "common/string_utils.h"
-#include "parser/call/in_query_call.h"
 #include "parser/call/standalone_call.h"
 #include "parser/copy.h"
 #include "parser/ddl/add_property.h"
@@ -20,6 +19,7 @@
 #include "parser/expression/parsed_property_expression.h"
 #include "parser/expression/parsed_subquery_expression.h"
 #include "parser/expression/parsed_variable_expression.h"
+#include "parser/query/reading_clause/in_query_call_clause.h"
 #include "parser/query/reading_clause/unwind_clause.h"
 #include "parser/query/updating_clause/create_clause.h"
 #include "parser/query/updating_clause/delete_clause.h"
@@ -150,8 +150,11 @@ std::unique_ptr<ReadingClause> Transformer::transformUnwind(CypherParser::OC_Unw
 std::unique_ptr<ReadingClause> Transformer::transformInQueryCall(
     CypherParser::KU_InQueryCallContext& ctx) {
     auto funcName = transformFunctionName(*ctx.oC_FunctionName());
-    auto parameter = transformLiteral(*ctx.oC_Literal());
-    return std::make_unique<InQueryCall>(std::move(funcName), std::move(parameter));
+    std::vector<std::unique_ptr<ParsedExpression>> parameter;
+    for (auto& literal : ctx.oC_Literal()) {
+        parameter.push_back(transformLiteral(*literal));
+    }
+    return std::make_unique<InQueryCallClause>(std::move(funcName), std::move(parameter));
 }
 
 std::unique_ptr<UpdatingClause> Transformer::transformCreate(CypherParser::OC_CreateContext& ctx) {

test/test_files/tinysnb/function/table.test

@@ -77,6 +77,6 @@ height
 <FILE>:function_table_info_answer.txt
 
 -LOG ReturnDBVersion
--STATEMENT CALL db_version('') RETURN KUZU_Version
+-STATEMENT CALL db_version() RETURN version
 ---- 1
 v0.4.0