Respect orderable constraint in ArgumentTypeFuzzer (#6950)

Summary: PR #6906 added support to restricting arguments as orderable. This PR changes ArgumentTypeFuzzer to respect this constraint. Part of #6718 Pull Request resolved: #6950 Reviewed By: Yuhta Differential Revision: D50212902 Pulled By: mbasmanova fbshipit-source-id: 318b5e443baba7b6800539fafcf34946e6f0e91d
facebookincubator · Oct 12, 2023 · 30e1854 · 30e1854
1 parent 3cfafbd
commit 30e1854
Show file tree

Hide file tree

Showing 3 changed files with 89 additions and 1 deletion.
diff --git a/velox/expression/tests/ArgumentTypeFuzzer.cpp b/velox/expression/tests/ArgumentTypeFuzzer.cpp
@@ -48,14 +48,22 @@ void ArgumentTypeFuzzer::determineUnboundedTypeVariables() {
     // Random randomType() never generates unknown here.
     // TODO: we should extend randomType types and exclude unknown based
     // on variableInfo.
-    bindings_[variableName] = randType();
+    if (variableInfo.orderableTypesOnly()) {
+      bindings_[variableName] = randOrderableType();
+    } else {
+      bindings_[variableName] = randType();
+    }
   }
 }
 
 TypePtr ArgumentTypeFuzzer::randType() {
   return velox::randType(rng_, 2);
 }
 
+TypePtr ArgumentTypeFuzzer::randOrderableType() {
+  return velox::randOrderableType(rng_, 2);
+}
+
 bool ArgumentTypeFuzzer::fuzzArgumentTypes(uint32_t maxVariadicArgs) {
   const auto& formalArgs = signature_.argumentTypes();
   auto formalArgsCnt = formalArgs.size();

diff --git a/velox/expression/tests/ArgumentTypeFuzzer.h b/velox/expression/tests/ArgumentTypeFuzzer.h
@@ -71,6 +71,9 @@ class ArgumentTypeFuzzer {
 
   TypePtr randType();
 
+  /// Generates an orderable random type, including structs, and arrays.
+  TypePtr randOrderableType();
+
   const exec::FunctionSignature& signature_;
 
   TypePtr returnType_;

diff --git a/velox/expression/tests/ArgumentTypeFuzzerTest.cpp b/velox/expression/tests/ArgumentTypeFuzzerTest.cpp
@@ -326,4 +326,81 @@ TEST_F(ArgumentTypeFuzzerTest, unconstrainedSignatureTemplate) {
   ASSERT_EQ(argumentTypes[0]->childAt(0), argumentTypes[1]);
 }
 
+TEST_F(ArgumentTypeFuzzerTest, orderableConstraint) {
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .orderableTypeVariable("T")
+                         .returnType("bigint")
+                         .argumentType("T")
+                         .build();
+
+    for (size_t i = 0; i < 100; ++i) {
+      std::mt19937 rng(i);
+      ArgumentTypeFuzzer fuzzer{*signature, nullptr, rng};
+      fuzzer.fuzzArgumentTypes(kMaxVariadicArgs);
+      ASSERT_TRUE(fuzzer.argumentTypes()[0]->isOrderable())
+          << fuzzer.argumentTypes()[0]->toString();
+    }
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .orderableTypeVariable("T")
+                         .returnType("T")
+                         .argumentType("T")
+                         .build();
+    testFuzzingFailure(signature, MAP(VARCHAR(), BIGINT()));
+    testFuzzingFailure(signature, ARRAY(MAP(VARCHAR(), BIGINT())));
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .orderableTypeVariable("T")
+                         .returnType("array(T)")
+                         .argumentType("array(T)")
+                         .build();
+
+    testFuzzingSuccess(signature, ARRAY(DOUBLE()), {ARRAY(DOUBLE())});
+    testFuzzingSuccess(
+        signature, ARRAY(ROW({DOUBLE()})), {ARRAY(ROW({DOUBLE()}))});
+    testFuzzingFailure(signature, MAP(VARCHAR(), BIGINT()));
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .orderableTypeVariable("U")
+                         .returnType("row(T, U)")
+                         .argumentType("T")
+                         .argumentType("row(T,U)")
+                         .build();
+
+    testFuzzingSuccess(
+        signature,
+        ROW({MAP(BIGINT(), BIGINT()), BIGINT()}),
+        {MAP(BIGINT(), BIGINT()), ROW({MAP(BIGINT(), BIGINT()), BIGINT()})});
+
+    testFuzzingFailure(signature, ROW({BIGINT(), MAP(VARCHAR(), BIGINT())}));
+  }
+
+  {
+    auto signature = exec::FunctionSignatureBuilder()
+                         .typeVariable("T")
+                         .orderableTypeVariable("U")
+                         .returnType("row(T,U)")
+                         .argumentType("T")
+                         .argumentType("function(T,U)")
+                         .build();
+
+    testFuzzingSuccess(
+        signature,
+        ROW({MAP(BIGINT(), BIGINT()), BIGINT()}),
+        {MAP(BIGINT(), BIGINT()),
+         std::make_shared<FunctionType>(
+             std::vector<TypePtr>{MAP(BIGINT(), BIGINT())}, BIGINT())});
+
+    testFuzzingFailure(signature, ROW({BIGINT(), MAP(VARCHAR(), BIGINT())}));
+  }
+}
+
 } // namespace facebook::velox::test