fix(fuzzer): Remove hardcoded table names in Fuzzers (facebookincubat…

…or#12120)

Summary:

Looking into the failed fuzzer job in D68359107 shows that the table name, "t_values", in the query does not match the table name of the created table, "tmp". This is because of a change made in D66977480 which updated the toSql(ValuesNode) method to return "t_<id>" instead of "tmp". That change ensured unique table names since PlanNode ids are unique within a plan.

The change in this diff deprecates hardcoding "tmp" as table names in place of using toSql. A toSql method was also added for TableScanNodes. There are many instances of this hardcoding which makes this diff a bit large.

Differential Revision: D68400743

velox/core/PlanNode.h

@@ -589,6 +589,8 @@ class TableScanNode : public PlanNode {
           assignments_;
 };
 
+using TableScanNodePtr = std::shared_ptr<const TableScanNode>;
+
 class AggregationNode : public PlanNode {
  public:
   enum class Step {

velox/exec/fuzzer/AggregationFuzzer.cpp

@@ -722,7 +722,7 @@ bool AggregationFuzzer::verifyWindow(
     if (!customVerification && enableWindowVerification) {
       if (resultOrError.result) {
         auto referenceResult =
-            computeReferenceResults(plan, input, referenceQueryRunner_.get());
+            computeReferenceResults(plan, referenceQueryRunner_.get());
         stats_.updateReferenceQueryStats(referenceResult.second);
         if (auto expectedResult = referenceResult.first) {
           ++stats_.numVerified;
@@ -1018,7 +1018,7 @@ void AggregationFuzzer::verifyAggregation(
   std::optional<MaterializedRowMultiset> expectedResult;
   if (!customVerification) {
     auto referenceResult =
-        computeReferenceResults(plan, input, referenceQueryRunner_.get());
+        computeReferenceResults(plan, referenceQueryRunner_.get());
     stats_.updateReferenceQueryStats(referenceResult.second);
     expectedResult = referenceResult.first;
   }
@@ -1099,8 +1099,8 @@ bool AggregationFuzzer::compareEquivalentPlanResults(
 
     if (resultOrError.result != nullptr) {
       if (!customVerification) {
-        auto referenceResult = computeReferenceResults(
-            firstPlan, input, referenceQueryRunner_.get());
+        auto referenceResult =
+            computeReferenceResults(firstPlan, referenceQueryRunner_.get());
         stats_.updateReferenceQueryStats(referenceResult.second);
         auto expectedResult = referenceResult.first;
 
@@ -1118,7 +1118,7 @@ bool AggregationFuzzer::compareEquivalentPlanResults(
         if (isSupportedType(firstPlan->outputType()) &&
             isSupportedType(input.front()->type())) {
           auto referenceResult = computeReferenceResultsAsVector(
-              firstPlan, input, referenceQueryRunner_.get());
+              firstPlan, referenceQueryRunner_.get());
           stats_.updateReferenceQueryStats(referenceResult.second);
 
           if (referenceResult.first) {

velox/exec/fuzzer/DuckQueryRunner.cpp

@@ -134,15 +134,6 @@ DuckQueryRunner::execute(const core::PlanNodePtr& plan) {
       std::nullopt, ReferenceQueryErrorCode::kReferenceQueryUnsupported);
 }
 
-std::multiset<std::vector<velox::variant>> DuckQueryRunner::execute(
-    const std::string& sql,
-    const std::vector<RowVectorPtr>& input,
-    const RowTypePtr& resultType) {
-  DuckDbQueryRunner queryRunner;
-  queryRunner.createTable("tmp", input);
-  return queryRunner.execute(sql, resultType);
-}
-
 std::optional<std::string> DuckQueryRunner::toSql(
     const core::PlanNodePtr& plan) {
   if (!isSupportedType(plan->outputType())) {
@@ -190,6 +181,11 @@ std::optional<std::string> DuckQueryRunner::toSql(
     return toSql(valuesNode);
   }
 
+  if (const auto tableScanNode =
+          std::dynamic_pointer_cast<const core::TableScanNode>(plan)) {
+    return toSql(tableScanNode);
+  }
+
   VELOX_NYI();
 }
 
@@ -254,7 +250,12 @@ std::optional<std::string> DuckQueryRunner::toSql(
     }
   }
 
-  sql << " FROM tmp";
+  // AggregationNode should have a single source.
+  std::optional<std::string> source = toSql(aggregationNode->sources()[0]);
+  if (!source) {
+    return std::nullopt;
+  }
+  sql << " FROM " << *source;
 
   if (!groupingKeys.empty()) {
     sql << " GROUP BY " << folly::join(", ", groupingKeys);
@@ -335,7 +336,12 @@ std::optional<std::string> DuckQueryRunner::toSql(
     }
   }
 
-  sql << ") FROM tmp";
+  // WindowNode should have a single source.
+  std::optional<std::string> source = toSql(windowNode->sources()[0]);
+  if (!source) {
+    return std::nullopt;
+  }
+  sql << ") FROM " << *source;
 
   return sql.str();
 }
@@ -362,7 +368,12 @@ std::optional<std::string> DuckQueryRunner::toSql(
     }
   }
 
-  sql << ") as row_number FROM tmp";
+  // RowNumberNode should have a single source.
+  std::optional<std::string> source = toSql(rowNumberNode->sources()[0]);
+  if (!source) {
+    return std::nullopt;
+  }
+  sql << ") as row_number FROM " << *source;
 
   return sql.str();
 }

velox/exec/fuzzer/DuckQueryRunner.h

@@ -50,20 +50,15 @@ class DuckQueryRunner : public ReferenceQueryRunner {
   /// Assumes that source of AggregationNode or Window Node is 'tmp' table.
   std::optional<std::string> toSql(const core::PlanNodePtr& plan) override;
 
-  /// Executes the plan and returns the result along with success or fail error
-  /// code.
+  // Converts 'plan' into an SQL query and executes it. Result is returned as a
+  // MaterializedRowMultiset with the ReferenceQueryErrorCode::kSuccess if
+  // successful, or an std::nullopt with a ReferenceQueryErrorCode if the query
+  // fails.
   std::pair<
       std::optional<std::multiset<std::vector<velox::variant>>>,
       ReferenceQueryErrorCode>
   execute(const core::PlanNodePtr& plan) override;
 
-  /// Creates 'tmp' table with 'input' data and runs 'sql' query. Returns
-  /// results according to 'resultType' schema.
-  std::multiset<std::vector<velox::variant>> execute(
-      const std::string& sql,
-      const std::vector<RowVectorPtr>& input,
-      const RowTypePtr& resultType) override;
-
  private:
   using ReferenceQueryRunner::toSql;
 

velox/exec/fuzzer/FuzzerUtil.cpp

@@ -381,48 +381,14 @@ void registerHiveConnector(
 std::pair<std::optional<MaterializedRowMultiset>, ReferenceQueryErrorCode>
 computeReferenceResults(
     const core::PlanNodePtr& plan,
-    const std::vector<RowVectorPtr>& input,
     ReferenceQueryRunner* referenceQueryRunner) {
-  if (auto sql = referenceQueryRunner->toSql(plan)) {
-    try {
-      return std::make_pair(
-          referenceQueryRunner->execute(sql.value(), input, plan->outputType()),
-          ReferenceQueryErrorCode::kSuccess);
-    } catch (...) {
-      LOG(WARNING) << "Query failed in the reference DB";
-      return std::make_pair(
-          std::nullopt, ReferenceQueryErrorCode::kReferenceQueryFail);
-    }
-  }
-
-  LOG(INFO) << "Query not supported by the reference DB";
-  return std::make_pair(
-      std::nullopt, ReferenceQueryErrorCode::kReferenceQueryUnsupported);
+  return referenceQueryRunner->execute(plan);
 }
 
 std::pair<std::optional<std::vector<RowVectorPtr>>, ReferenceQueryErrorCode>
 computeReferenceResultsAsVector(
     const core::PlanNodePtr& plan,
-    const std::vector<RowVectorPtr>& input,
     ReferenceQueryRunner* referenceQueryRunner) {
-  VELOX_CHECK(referenceQueryRunner->supportsVeloxVectorResults());
-
-  if (auto sql = referenceQueryRunner->toSql(plan)) {
-    try {
-      return std::make_pair(
-          referenceQueryRunner->executeVector(
-              sql.value(), input, plan->outputType()),
-          ReferenceQueryErrorCode::kSuccess);
-    } catch (...) {
-      LOG(WARNING) << "Query failed in the reference DB";
-      return std::make_pair(
-          std::nullopt, ReferenceQueryErrorCode::kReferenceQueryFail);
-    }
-  } else {
-    LOG(INFO) << "Query not supported by the reference DB";
-  }
-
-  return std::make_pair(
-      std::nullopt, ReferenceQueryErrorCode::kReferenceQueryUnsupported);
+  return referenceQueryRunner->executeAndReturnVector(plan);
 }
 } // namespace facebook::velox::exec::test

velox/exec/fuzzer/FuzzerUtil.h

@@ -131,14 +131,13 @@ void setupMemory(
 void registerHiveConnector(
     const std::unordered_map<std::string, std::string>& hiveConfigs);
 
-// Converts 'plan' into an SQL query and runs it on 'input' in the reference DB.
+// Converts 'plan' into an SQL query and runs in the reference DB.
 // Result is returned as a MaterializedRowMultiset with the
 // ReferenceQueryErrorCode::kSuccess if successful, or an std::nullopt with a
 // ReferenceQueryErrorCode if the query fails.
 std::pair<std::optional<MaterializedRowMultiset>, ReferenceQueryErrorCode>
 computeReferenceResults(
     const core::PlanNodePtr& plan,
-    const std::vector<RowVectorPtr>& input,
     ReferenceQueryRunner* referenceQueryRunner);
 
 // Similar to computeReferenceResults(), but returns the result as a
@@ -147,7 +146,6 @@ computeReferenceResults(
 std::pair<std::optional<std::vector<RowVectorPtr>>, ReferenceQueryErrorCode>
 computeReferenceResultsAsVector(
     const core::PlanNodePtr& plan,
-    const std::vector<RowVectorPtr>& input,
     ReferenceQueryRunner* referenceQueryRunner);
 
 } // namespace facebook::velox::exec::test