Check statement read only through visitor pattern

src/binder/visitor/CMakeLists.txt

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

src/binder/visitor/statement_read_write_analyzer.cpp

@@ -0,0 +1,16 @@
+#include "binder/visitor/statement_read_write_analyzer.h"
+
+namespace kuzu {
+namespace binder {
+
+bool StatementReadWriteAnalyzer::isReadOnly(const kuzu::binder::BoundStatement& statement) {
+    visit(statement);
+    return readOnly;
+}
+
+void StatementReadWriteAnalyzer::visitQueryPart(const NormalizedQueryPart& queryPart) {
+    readOnly = !queryPart.hasUpdatingClause();
+}
+
+} // namespace binder
+} // namespace kuzu

src/include/binder/bound_statement.h

@@ -18,8 +18,6 @@ class BoundStatement {
 
     inline BoundStatementResult* getStatementResult() const { return statementResult.get(); }
 
-    virtual inline bool isReadOnly() const { return false; }
-
 private:
     common::StatementType statementType;
     std::unique_ptr<BoundStatementResult> statementResult;

src/include/binder/bound_statement_visitor.h

@@ -13,9 +13,9 @@ class BoundStatementVisitor {
 
     void visit(const BoundStatement& statement);
 
-    void visitRegularQuery(const BoundRegularQuery& regularQuery);
-    void visitSingleQuery(const NormalizedSingleQuery& singleQuery);
-    void visitQueryPart(const NormalizedQueryPart& queryPart);
+    virtual void visitRegularQuery(const BoundRegularQuery& regularQuery);
+    virtual void visitSingleQuery(const NormalizedSingleQuery& singleQuery);
+    virtual void visitQueryPart(const NormalizedQueryPart& queryPart);
 
 protected:
     virtual void visitCreateNodeTable(const BoundStatement& statement) {}

src/include/binder/query/bound_regular_query.h

@@ -15,15 +15,6 @@ class BoundRegularQuery : public BoundStatement {
 
     ~BoundRegularQuery() override = default;
 
-    inline bool isReadOnly() const override {
-        for (auto& singleQuery : singleQueries) {
-            if (!singleQuery->isReadOnly()) {
-                return false;
-            }
-        }
-        return true;
-    }
-
     inline void addSingleQuery(std::unique_ptr<NormalizedSingleQuery> singleQuery) {
         singleQueries.push_back(std::move(singleQuery));
     }

src/include/binder/query/normalized_single_query.h

@@ -11,15 +11,6 @@ class NormalizedSingleQuery {
     NormalizedSingleQuery() = default;
     ~NormalizedSingleQuery() = default;
 
-    inline bool isReadOnly() const {
-        for (auto& queryPart : queryParts) {
-            if (queryPart->hasUpdatingClause()) {
-                return false;
-            }
-        }
-        return true;
-    }
-
     inline void appendQueryPart(std::unique_ptr<NormalizedQueryPart> queryPart) {
         queryParts.push_back(std::move(queryPart));
     }

src/include/binder/visitor/statement_read_write_analyzer.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "binder/bound_statement_visitor.h"
+
+namespace kuzu {
+namespace binder {
+
+class StatementReadWriteAnalyzer : public BoundStatementVisitor {
+public:
+    StatementReadWriteAnalyzer() : BoundStatementVisitor(), readOnly{false} {}
+
+    bool isReadOnly(const BoundStatement& statement);
+
+private:
+    void visitQueryPart(const NormalizedQueryPart& queryPart) final;
+
+private:
+    bool readOnly;
+};
+
+} // namespace binder
+} // namespace kuzu

src/main/connection.cpp

@@ -1,6 +1,7 @@
 #include "main/connection.h"
 
 #include "binder/binder.h"
+#include "binder/visitor/statement_read_write_analyzer.h"
 #include "json.hpp"
 #include "main/database.h"
 #include "main/plan_printer.h"
@@ -165,7 +166,8 @@ std::unique_ptr<PreparedStatement> Connection::prepareNoLock(
         auto binder = Binder(*database->catalog);
         auto boundStatement = binder.bind(*statement);
         preparedStatement->statementType = boundStatement->getStatementType();
-        preparedStatement->readOnly = boundStatement->isReadOnly();
+        preparedStatement->readOnly =
+            binder::StatementReadWriteAnalyzer().isReadOnly(*boundStatement);
         preparedStatement->parameterMap = binder.getParameterMap();
         preparedStatement->statementResult = boundStatement->getStatementResult()->copy();
         // planning