Syntax linter

kuzudb · Jun 28, 2023 · d6e4a8e · d6e4a8e
1 parent 4b15763
commit d6e4a8e
Show file tree

Hide file tree

Showing 9 changed files with 31 additions and 27 deletions.
diff --git a/src/common/copier_config/copier_config.cpp b/src/common/copier_config/copier_config.cpp
@@ -7,9 +7,10 @@ using namespace kuzu::utf8proc;
 
 namespace kuzu {
 namespace common {
-CopyDescription::CopyDescription(CopyDirection copyDirection, const std::vector<std::string>& filePaths,
-    CSVReaderConfig csvReaderConfig, FileType fileType)
-    : copyDirection{copyDirection}, filePaths{filePaths}, csvReaderConfig{nullptr}, fileType{fileType} {
+CopyDescription::CopyDescription(CopyDirection copyDirection,
+    const std::vector<std::string>& filePaths, CSVReaderConfig csvReaderConfig, FileType fileType)
+    : copyDirection{copyDirection}, filePaths{filePaths}, csvReaderConfig{nullptr}, fileType{
+                                                                                        fileType} {
     if (fileType == FileType::CSV) {
         this->csvReaderConfig = std::make_unique<CSVReaderConfig>(csvReaderConfig);
     }

diff --git a/src/include/parser/copy.h b/src/include/parser/copy.h
@@ -11,8 +11,8 @@ namespace parser {
 
 class Copy : public Statement {
 public:
-    explicit Copy(common::CopyDescription::CopyDirection copyDirection, std::vector<std::string> filePaths,
-        std::string tableName,
+    explicit Copy(common::CopyDescription::CopyDirection copyDirection,
+        std::vector<std::string> filePaths, std::string tableName,
         std::unordered_map<std::string, std::unique_ptr<ParsedExpression>> parsingOptions,
         common::CopyDescription::FileType fileType)
         : Statement{common::StatementType::COPY}, copyDirection{copyDirection},

diff --git a/src/include/planner/logical_plan/logical_operator/logical_copy_to.h b/src/include/planner/logical_plan/logical_operator/logical_copy_to.h
@@ -21,9 +21,13 @@ class LogicalCopyTo : public LogicalOperator {
 
     inline common::table_id_t getTableID() const { return tableID; }
 
-    void computeFactorizedSchema() override;
+    inline void computeFactorizedSchema() { copyChildSchema(0); }
 
-    void computeFlatSchema() override;
+    inline void computeFlatSchema() { copyChildSchema(0); }
+
+    //    void computeFactorizedSchema() override;
+
+    //    void computeFlatSchema() override;
 
     inline std::unique_ptr<LogicalOperator> copy() override {
         return make_unique<LogicalCopyTo>(copyDescription, tableID, tableName, outputExpression);

diff --git a/src/include/processor/operator/copy_to/copy_to.h b/src/include/processor/operator/copy_to/copy_to.h
@@ -1,8 +1,8 @@
 #pragma once
 
 #include "common/copier_config/copier_config.h"
-#include "processor/operator/physical_operator.h"
 #include "common/task_system/task_scheduler.h"
+#include "processor/operator/physical_operator.h"
 #include "processor/result/result_set.h"
 
 namespace kuzu {
@@ -12,16 +12,16 @@ class CopyTo : public PhysicalOperator {
 public:
     CopyTo(const common::CopyDescription& copyDescription, uint32_t id,
         const std::string& paramsString)
-        : PhysicalOperator{PhysicalOperatorType::COPY_TO, id, paramsString}, copyDescription{copyDescription} {}
+        : PhysicalOperator{PhysicalOperatorType::COPY_TO, id, paramsString}, copyDescription{
+                                                                                 copyDescription} {}
 
     bool getNextTuplesInternal(ExecutionContext* context) override {
-        throw common::InternalException(
-            "to be implemented?");
+        throw common::InternalException("to be implemented?");
     }
 
     std::string execute(common::TaskScheduler* taskScheduler, ExecutionContext* executionContext);
 
-//    void initLocalStateInternal(ResultSet* resultSet, ExecutionContext* context) override;
+    //    void initLocalStateInternal(ResultSet* resultSet, ExecutionContext* context) override;
 
     std::unique_ptr<PhysicalOperator> clone() override {
         return make_unique<CopyTo>(copyDescription, id, paramsString);

diff --git a/src/parser/transformer.cpp b/src/parser/transformer.cpp
@@ -1051,7 +1051,7 @@ std::string Transformer::transformPrimaryKey(CypherParser::KU_CreateNodeConstrai
 
 std::unique_ptr<Statement> Transformer::transformCopyCSV(CypherParser::KU_CopyCSVContext& ctx) {
     auto copyDirection = ctx.FROM() ? common::CopyDescription::CopyDirection::FROM :
-                                  common::CopyDescription::CopyDirection::TO;
+                                      common::CopyDescription::CopyDirection::TO;
     auto filePaths = transformFilePaths(ctx.kU_FilePaths()->StringLiteral());
     auto tableName = transformSchemaName(*ctx.oC_SchemaName());
     auto parsingOptions = ctx.kU_ParsingOptions() ?
@@ -1063,7 +1063,7 @@ std::unique_ptr<Statement> Transformer::transformCopyCSV(CypherParser::KU_CopyCS
 
 std::unique_ptr<Statement> Transformer::transformCopyNPY(CypherParser::KU_CopyNPYContext& ctx) {
     auto copyDirection = ctx.FROM() ? common::CopyDescription::CopyDirection::FROM :
-                                  common::CopyDescription::CopyDirection::TO;
+                                      common::CopyDescription::CopyDirection::TO;
     auto filePaths = transformFilePaths(ctx.StringLiteral());
     auto tableName = transformSchemaName(*ctx.oC_SchemaName());
     auto parsingOptions = std::unordered_map<std::string, std::unique_ptr<ParsedExpression>>();

diff --git a/src/planner/operator/logical_copy_to.cpp b/src/planner/operator/logical_copy_to.cpp
@@ -3,13 +3,13 @@
 namespace kuzu {
 namespace planner {
 
-void LogicalCopyTo::computeFactorizedSchema() {
-    createEmptySchema();
-}
-
-void LogicalCopyTo::computeFlatSchema() {
-    createEmptySchema();
-}
+// void LogicalCopyTo::computeFactorizedSchema() {
+//     createEmptySchema();
+// }
+//
+// void LogicalCopyTo::computeFlatSchema() {
+//     createEmptySchema();
+// }
 
 } // namespace planner
 } // namespace kuzu
diff --git a/src/planner/planner.cpp b/src/planner/planner.cpp
@@ -156,7 +156,8 @@ std::unique_ptr<LogicalPlan> Planner::planRenameProperty(const BoundStatement& s
 std::unique_ptr<LogicalPlan> Planner::planCopy(
     const catalog::Catalog& catalog, const BoundStatement& statement) {
     auto& boundCopyStatement = (BoundCopy&)statement;
-    if (boundCopyStatement.getCopyDescription().copyDirection == CopyDescription::CopyDirection::FROM) {
+    if (boundCopyStatement.getCopyDescription().copyDirection ==
+        CopyDescription::CopyDirection::FROM) {
         return planCopyFrom(catalog, statement);
     } else {
         return planCopyTo(catalog, statement);

diff --git a/src/processor/mapper/map_ddl.cpp b/src/processor/mapper/map_ddl.cpp
@@ -61,7 +61,8 @@ std::unique_ptr<PhysicalOperator> PlanMapper::mapLogicalCopyToToPhysical(
     auto tableName = catalog->getReadOnlyVersion()->getTableName(copy->getTableID());
     // stuff...
 
-    return std::make_unique<CopyTo>(copy->getCopyDescription(), getOperatorID(), copy->getExpressionsForPrinting());
+    return std::make_unique<CopyTo>(
+        copy->getCopyDescription(), getOperatorID(), copy->getExpressionsForPrinting());
 }
 
 std::unique_ptr<PhysicalOperator> PlanMapper::mapLogicalCopyToPhysical(

diff --git a/src/processor/operator/copy_to/copy_to.cpp b/src/processor/operator/copy_to/copy_to.cpp
@@ -5,8 +5,5 @@
 using namespace kuzu::common;
 
 namespace kuzu {
-namespace processor {
-
-
-} // namespace processor
+namespace processor {} // namespace processor
 } // namespace kuzu