Add parsed statement visitor

src/binder/bound_statement_visitor.cpp

@@ -1,7 +1,7 @@
 #include "binder/bound_statement_visitor.h"
 
 #include "binder/bound_explain.h"
-#include "common/exception/not_implemented.h"
+#include "binder/query/bound_regular_query.h"
 
 using namespace kuzu::common;
 
@@ -11,7 +11,7 @@ namespace binder {
 void BoundStatementVisitor::visit(const kuzu::binder::BoundStatement& statement) {
     switch (statement.getStatementType()) {
     case StatementType::QUERY: {
-        visitRegularQuery((BoundRegularQuery&)statement);
+        visitRegularQuery(statement);
     } break;
     case StatementType::CREATE_TABLE: {
         visitCreateTable(statement);
@@ -43,12 +43,15 @@ void BoundStatementVisitor::visit(const kuzu::binder::BoundStatement& statement)
     case StatementType::TRANSACTION: {
         visitTransaction(statement);
     } break;
+        // LCOV_EXCL_START
     default:
-        throw NotImplementedException("BoundStatementVisitor::visit");
+        KU_UNREACHABLE;
+        // LCOV_EXCL_STOP
     }
 }
 
-void BoundStatementVisitor::visitRegularQuery(const BoundRegularQuery& regularQuery) {
+void BoundStatementVisitor::visitRegularQuery(const BoundStatement& statement) {
+    auto& regularQuery = reinterpret_cast<const BoundRegularQuery&>(statement);
     for (auto i = 0u; i < regularQuery.getNumSingleQueries(); ++i) {
         visitSingleQuery(*regularQuery.getSingleQuery(i));
     }
@@ -93,8 +96,10 @@ void BoundStatementVisitor::visitReadingClause(const BoundReadingClause& reading
     case ClauseType::LOAD_FROM: {
         visitLoadFrom(readingClause);
     } break;
+        // LCOV_EXCL_START
     default:
-        throw NotImplementedException("BoundStatementVisitor::visitReadingClause");
+        KU_UNREACHABLE;
+        // LCOV_EXCL_STOP
     }
 }
 
@@ -112,8 +117,10 @@ void BoundStatementVisitor::visitUpdatingClause(const BoundUpdatingClause& updat
     case ClauseType::MERGE: {
         visitMerge(updatingClause);
     } break;
+        // LCOV_EXCL_START
     default:
-        throw NotImplementedException("BoundStatementVisitor::visitUpdatingClause");
+        KU_UNREACHABLE;
+        // LCOV_EXCL_STOP
     }
 }
 

src/binder/visitor/CMakeLists.txt

@@ -1,8 +1,7 @@
 add_library(
         kuzu_binder_visitor
         OBJECT
-        property_collector.cpp
-        statement_read_write_analyzer.cpp)
+        property_collector.cpp)
 
 set(ALL_OBJECT_FILES
         ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:kuzu_binder_visitor>

src/include/binder/bound_statement_visitor.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include "binder/query/bound_regular_query.h"
+#include "binder/query/normalized_single_query.h"
 #include "bound_statement.h"
 
 namespace kuzu {
@@ -13,9 +13,7 @@ class BoundStatementVisitor {
 
     void visit(const BoundStatement& statement);
 
-    virtual void visitRegularQuery(const BoundRegularQuery& regularQuery);
     virtual void visitSingleQuery(const NormalizedSingleQuery& singleQuery);
-    virtual void visitQueryPart(const NormalizedQueryPart& queryPart);
 
 protected:
     virtual void visitCreateTable(const BoundStatement& statement) {}
@@ -29,6 +27,8 @@ class BoundStatementVisitor {
     virtual void visitCreateMacro(const BoundStatement& statement) {}
     virtual void visitTransaction(const BoundStatement& statement) {}
 
+    virtual void visitRegularQuery(const BoundStatement& statement);
+    virtual void visitQueryPart(const NormalizedQueryPart& queryPart);
     void visitReadingClause(const BoundReadingClause& readingClause);
     virtual void visitMatch(const BoundReadingClause& readingClause) {}
     virtual void visitUnwind(const BoundReadingClause& readingClause) {}

src/include/parser/parsed_statement_visitor.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include "statement.h"
+
+namespace kuzu {
+namespace parser {
+
+class SingleQuery;
+class QueryPart;
+class ReadingClause;
+class UpdatingClause;
+class WithClause;
+class ReturnClause;
+
+class StatementVisitor {
+public:
+    StatementVisitor() = default;
+    virtual ~StatementVisitor() = default;
+
+    void visit(const Statement& statement);
+
+private:
+    virtual void visitQuery(const Statement& statement);
+    virtual void visitSingleQuery(const SingleQuery* singleQuery);
+    virtual void visitQueryPart(const QueryPart* queryPart);
+    virtual void visitReadingClause(const ReadingClause* readingClause);
+    virtual void visitMatch(const ReadingClause* readingClause) {}
+    virtual void visitUnwind(const ReadingClause* readingClause) {}
+    virtual void visitInQueryCall(const ReadingClause* readingClause) {}
+    virtual void visitLoadFrom(const ReadingClause* readingClause) {}
+    virtual void visitUpdatingClause(const UpdatingClause* updatingClause);
+    virtual void visitSet(const UpdatingClause* updatingClause) {}
+    virtual void visitDelete(const UpdatingClause* updatingClause) {}
+    virtual void visitInsert(const UpdatingClause* updatingClause) {}
+    virtual void visitMerge(const UpdatingClause* updatingClause) {}
+    virtual void visitWithClause(const WithClause* withClause) {}
+    virtual void visitReturnClause(const ReturnClause* returnClause) {}
+
+    virtual void visitCreateTable(const Statement& statement) {}
+    virtual void visitDropTable(const Statement& statement) {}
+    virtual void visitAlter(const Statement& statement) {}
+    virtual void visitCopyFrom(const Statement& statement) {}
+    virtual void visitCopyTo(const Statement& statement) {}
+    virtual void visitStandaloneCall(const Statement& statement) {}
+    virtual void visitExplain(const Statement& statement);
+    virtual void visitCreateMacro(const Statement& statement) {}
+    virtual void visitCommentOn(const Statement& statement) {}
+    virtual void visitTransaction(const Statement& statement) {}
+};
+
+} // namespace parser
+} // namespace kuzu

src/include/parser/visitor/statement_read_write_analyzer.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "parser/parsed_statement_visitor.h"
+
+namespace kuzu {
+namespace parser {
+
+class StatementReadWriteAnalyzer final : public StatementVisitor {
+public:
+    StatementReadWriteAnalyzer() : StatementVisitor{}, readOnly{true} {}
+
+    bool isReadOnly(const Statement& statement);
+
+private:
+    inline void visitCreateTable(const Statement& /*statement*/) { readOnly = false; }
+    inline void visitDropTable(const Statement& /*statement*/) { readOnly = false; }
+    inline void visitAlter(const Statement& /*statement*/) { readOnly = false; }
+    inline void visitCopyFrom(const Statement& /*statement*/) { readOnly = false; }
+    inline void visitStandaloneCall(const Statement& /*statement*/) { readOnly = false; }
+    inline void visitCreateMacro(const Statement& /*statement*/) { readOnly = false; }
+    inline void visitCommentOn(const Statement& /*statement*/) { readOnly = false; }
+
+    inline void visitUpdatingClause(const UpdatingClause* /*updatingClause*/) { readOnly = false; }
+
+private:
+    bool readOnly;
+};
+
+} // namespace parser
+} // namespace kuzu

src/main/connection.cpp

@@ -1,10 +1,10 @@
 #include "main/connection.h"
 
 #include "binder/binder.h"
-#include "binder/visitor/statement_read_write_analyzer.h"
 #include "common/exception/connection.h"
 #include "main/database.h"
 #include "optimizer/optimizer.h"
+#include "parser//visitor/statement_read_write_analyzer.h"
 #include "parser/parser.h"
 #include "planner/operator/logical_plan_util.h"
 #include "planner/planner.h"
@@ -96,13 +96,12 @@ std::unique_ptr<PreparedStatement> Connection::prepareNoLock(
     try {
         // parsing
         auto statement = Parser::parseQuery(query);
+        preparedStatement->readOnly = parser::StatementReadWriteAnalyzer().isReadOnly(*statement);
         // binding
         auto binder = Binder(*database->catalog, database->memoryManager.get(),
             database->storageManager.get(), clientContext.get());
         auto boundStatement = binder.bind(*statement);
         preparedStatement->preparedSummary.statementType = boundStatement->getStatementType();
-        preparedStatement->readOnly =
-            binder::StatementReadWriteAnalyzer().isReadOnly(*boundStatement);
         preparedStatement->parameterMap = binder.getParameterMap();
         preparedStatement->statementResult = boundStatement->getStatementResult()->copy();
         // planning

src/parser/CMakeLists.txt

@@ -1,13 +1,15 @@
 add_subdirectory(antlr_parser)
 add_subdirectory(expression)
 add_subdirectory(transform)
+add_subdirectory(visitor)
 
 add_library(kuzu_parser
         OBJECT
         create_macro.cpp
+        parsed_expression_visitor.cpp
         parser.cpp
-        transformer.cpp
-        parsed_expression_visitor.cpp)
+        parsed_statement_visitor.cpp
+        transformer.cpp)
 
 set(ALL_OBJECT_FILES
         ${ALL_OBJECT_FILES} $<TARGET_OBJECTS:kuzu_parser>