Extract the definition of Vector::Options::TimestampPrecision to Util.h

Differential Revision: D65576378
facebookincubator · Nov 15, 2024 · de89b8f · de89b8f
1 parent 3eb2fa4
commit de89b8f
Show file tree

Hide file tree

Showing 23 changed files with 50 additions and 69 deletions.
diff --git a/velox/exec/fuzzer/AggregationFuzzer.cpp b/velox/exec/fuzzer/AggregationFuzzer.cpp
@@ -60,7 +60,7 @@ class AggregationFuzzer : public AggregationFuzzerBase {
       const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
           customInputGenerators,
       const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-      VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+      FuzzerTimestampPrecision timestampPrecision,
       const std::unordered_map<std::string, std::string>& queryConfigs,
       const std::unordered_map<std::string, std::string>& hiveConfigs,
       bool orderableGroupKeys,
@@ -214,7 +214,7 @@ void aggregateFuzzer(
     const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
         customInputGenerators,
     const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    FuzzerTimestampPrecision timestampPrecision,
     const std::unordered_map<std::string, std::string>& queryConfigs,
     const std::unordered_map<std::string, std::string>& hiveConfigs,
     bool orderableGroupKeys,
@@ -245,7 +245,7 @@ AggregationFuzzer::AggregationFuzzer(
     const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
         customInputGenerators,
     const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    FuzzerTimestampPrecision timestampPrecision,
     const std::unordered_map<std::string, std::string>& queryConfigs,
     const std::unordered_map<std::string, std::string>& hiveConfigs,
     bool orderableGroupKeys,

diff --git a/velox/exec/fuzzer/AggregationFuzzer.h b/velox/exec/fuzzer/AggregationFuzzer.h
@@ -42,7 +42,7 @@ void aggregateFuzzer(
     const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
         customInputGenerators,
     const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    FuzzerTimestampPrecision timestampPrecision,
     const std::unordered_map<std::string, std::string>& queryConfigs,
     const std::unordered_map<std::string, std::string>& hiveConfigs,
     bool orderableGroupKeys,

diff --git a/velox/exec/fuzzer/AggregationFuzzerBase.h b/velox/exec/fuzzer/AggregationFuzzerBase.h
@@ -63,7 +63,7 @@ class AggregationFuzzerBase {
           customVerificationFunctions,
       const std::unordered_map<std::string, std::shared_ptr<InputGenerator>>&
           customInputGenerators,
-      VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+      FuzzerTimestampPrecision timestampPrecision,
       const std::unordered_map<std::string, std::string>& queryConfigs,
       const std::unordered_map<std::string, std::string>& hiveConfigs,
       bool orderableGroupKeys,
@@ -151,7 +151,7 @@ class AggregationFuzzerBase {
   PlanWithSplits deserialize(const folly::dynamic& obj);
 
   static VectorFuzzer::Options getFuzzerOptions(
-      VectorFuzzer::Options::TimestampPrecision timestampPrecision) {
+      FuzzerTimestampPrecision timestampPrecision) {
     VectorFuzzer::Options opts;
     opts.vectorSize = FLAGS_batch_size;
     opts.stringVariableLength = true;

diff --git a/velox/exec/fuzzer/AggregationFuzzerOptions.h b/velox/exec/fuzzer/AggregationFuzzerOptions.h
@@ -51,8 +51,8 @@ struct AggregationFuzzerOptions {
   std::unordered_set<std::string> orderDependentFunctions;
 
   /// Timestamp precision to use when generating inputs of type TIMESTAMP.
-  VectorFuzzer::Options::TimestampPrecision timestampPrecision{
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds};
+  FuzzerTimestampPrecision timestampPrecision{
+      FuzzerTimestampPrecision::kMilliSeconds};
 
   /// A set of configuration properties to use when running query plans.
   /// Could be used to specify timezone or enable/disable settings that

diff --git a/velox/exec/fuzzer/JoinFuzzer.cpp b/velox/exec/fuzzer/JoinFuzzer.cpp
@@ -112,8 +112,7 @@ class JoinFuzzer {
     opts.stringVariableLength = true;
     opts.stringLength = 100;
     opts.nullRatio = FLAGS_null_ratio;
-    opts.timestampPrecision =
-        VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+    opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
     return opts;
   }
 

diff --git a/velox/exec/fuzzer/WindowFuzzer.cpp b/velox/exec/fuzzer/WindowFuzzer.cpp
@@ -758,7 +758,7 @@ void windowFuzzer(
         customInputGenerators,
     const std::unordered_set<std::string>& orderDependentFunctions,
     const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    FuzzerTimestampPrecision timestampPrecision,
     const std::unordered_map<std::string, std::string>& queryConfigs,
     const std::unordered_map<std::string, std::string>& hiveConfigs,
     bool orderableGroupKeys,

diff --git a/velox/exec/fuzzer/WindowFuzzer.h b/velox/exec/fuzzer/WindowFuzzer.h
@@ -39,7 +39,7 @@ class WindowFuzzer : public AggregationFuzzerBase {
           customInputGenerators,
       const std::unordered_set<std::string>& orderDependentFunctions,
       const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-      VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+      FuzzerTimestampPrecision timestampPrecision,
       const std::unordered_map<std::string, std::string>& queryConfigs,
       const std::unordered_map<std::string, std::string>& hiveConfigs,
       bool orderableGroupKeys,
@@ -243,7 +243,7 @@ void windowFuzzer(
         customInputGenerators,
     const std::unordered_set<std::string>& orderDependentFunctions,
     const std::unordered_map<std::string, DataSpec>& functionDataSpec,
-    VectorFuzzer::Options::TimestampPrecision timestampPrecision,
+    FuzzerTimestampPrecision timestampPrecision,
     const std::unordered_map<std::string, std::string>& queryConfigs,
     const std::unordered_map<std::string, std::string>& hiveConfigs,
     bool orderableGroupKeys,

diff --git a/velox/exec/fuzzer/WriterFuzzer.cpp b/velox/exec/fuzzer/WriterFuzzer.cpp
@@ -87,8 +87,7 @@ class WriterFuzzer {
     opts.vectorSize = FLAGS_batch_size;
     opts.stringLength = 10;
     opts.nullRatio = FLAGS_null_ratio;
-    opts.timestampPrecision =
-        VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+    opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
     return opts;
   }
 

diff --git a/velox/exec/tests/ExchangeFuzzer.cpp b/velox/exec/tests/ExchangeFuzzer.cpp
@@ -365,7 +365,7 @@ class ExchangeFuzzer : public VectorTestBase {
       options_.maxConstantContainerSize = 2;
       options_.normalizeMapKeys = fuzzer_.coinToss(0.95);
       options_.timestampPrecision =
-          static_cast<VectorFuzzer::Options::TimestampPrecision>(randInt(0, 3));
+          static_cast<FuzzerTimestampPrecision>(randInt(0, 3));
       options_.allowLazyVector = false;
 
       fuzzer_.setOptions(options_);

diff --git a/velox/expression/fuzzer/FuzzerRunner.cpp b/velox/expression/fuzzer/FuzzerRunner.cpp
@@ -170,8 +170,7 @@ VectorFuzzer::Options getVectorFuzzerOptions() {
   opts.stringVariableLength = true;
   opts.stringLength = 100;
   opts.nullRatio = FLAGS_null_ratio;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   return opts;
 }
 

diff --git a/velox/functions/lib/window/tests/WindowTestBase.cpp b/velox/functions/lib/window/tests/WindowTestBase.cpp
@@ -123,8 +123,7 @@ VectorPtr WindowTestBase::makeRandomInputVector(
   VectorFuzzer::Options options;
   options.vectorSize = size;
   options.nullRatio = nullRatio;
-  options.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMicroSeconds;
+  options.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds;
   VectorFuzzer fuzzer(options, pool_.get(), 0);
   return fuzzer.fuzzFlat(type);
 }

diff --git a/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp b/velox/functions/prestosql/fuzzer/AggregationFuzzerTest.cpp
@@ -194,7 +194,7 @@ int main(int argc, char** argv) {
   options.customInputGenerators =
       facebook::velox::exec::test::getCustomInputGenerators();
   options.timestampPrecision =
-      facebook::velox::VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+      facebook::velox::FuzzerTimestampPrecision::kMilliSeconds;
   std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
       facebook::velox::memory::memoryManager()->addRootPool()};
 

diff --git a/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp b/velox/functions/prestosql/fuzzer/WindowFuzzerTest.cpp
@@ -180,7 +180,7 @@ int main(int argc, char** argv) {
       facebook::velox::exec::test::getCustomInputGenerators();
   options.orderDependentFunctions = orderDependentFunctions;
   options.timestampPrecision =
-      facebook::velox::VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+      facebook::velox::FuzzerTimestampPrecision::kMilliSeconds;
   std::shared_ptr<facebook::velox::memory::MemoryPool> rootPool{
       facebook::velox::memory::memoryManager()->addRootPool()};
   return Runner::run(

diff --git a/velox/row/benchmarks/DynamicRowVectorDeserializeBenchmark.cpp b/velox/row/benchmarks/DynamicRowVectorDeserializeBenchmark.cpp
@@ -80,8 +80,7 @@ class BenchmarkHelper {
     opts.stringVariableLength = true;
     opts.stringLength = 20;
     // Spark uses microseconds to store timestamp
-    opts.timestampPrecision =
-        VectorFuzzer::Options::TimestampPrecision::kMicroSeconds;
+    opts.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds;
 
     auto seed = folly::Random::rand32();
     VectorFuzzer fuzzer(opts, pool_.get(), seed);

diff --git a/velox/row/tests/CompactRowTest.cpp b/velox/row/tests/CompactRowTest.cpp
@@ -554,8 +554,7 @@ TEST_F(CompactRowTest, fuzz) {
   opts.complexElementsMaxSize = 1'000;
 
   // Spark uses microseconds to store timestamp
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMicroSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds;
 
   VectorFuzzer fuzzer(opts, pool_.get());
 

diff --git a/velox/row/tests/UnsafeRowFuzzTest.cpp b/velox/row/tests/UnsafeRowFuzzTest.cpp
@@ -59,8 +59,7 @@ class UnsafeRowFuzzTests : public ::testing::Test {
     opts.complexElementsMaxSize = 10'000;
 
     // Spark uses microseconds to store timestamp
-    opts.timestampPrecision =
-        VectorFuzzer::Options::TimestampPrecision::kMicroSeconds,
+    opts.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds,
     opts.containerLength = 10;
 
     VectorFuzzer fuzzer(opts, pool_.get());

diff --git a/velox/serializers/tests/CompactRowSerializerTest.cpp b/velox/serializers/tests/CompactRowSerializerTest.cpp
@@ -170,8 +170,7 @@ TEST_P(CompactRowSerializerTest, fuzz) {
   opts.containerVariableLength = false;
 
   // Spark uses microseconds to store timestamp
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMicroSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds;
   opts.containerLength = 10;
 
   const auto seed = folly::Random::rand32();

diff --git a/velox/serializers/tests/PrestoSerializerTest.cpp b/velox/serializers/tests/PrestoSerializerTest.cpp
@@ -502,7 +502,7 @@ class PrestoSerializerTest
     options.normalizeMapKeys = randInt(0, 20) < 16;
     if (isFirst) {
       options.timestampPrecision =
-          static_cast<VectorFuzzer::Options::TimestampPrecision>(randInt(0, 3));
+          static_cast<FuzzerTimestampPrecision>(randInt(0, 3));
     }
     options.allowLazyVector = false;
   }
@@ -1291,8 +1291,7 @@ TEST_P(PrestoSerializerTest, lazy) {
 
 TEST_P(PrestoSerializerTest, ioBufRoundTrip) {
   VectorFuzzer::Options opts;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   opts.nullRatio = 0.1;
   VectorFuzzer fuzzer(opts, pool_.get());
 
@@ -1310,13 +1309,11 @@ TEST_P(PrestoSerializerTest, ioBufRoundTrip) {
 
 TEST_P(PrestoSerializerTest, roundTrip) {
   VectorFuzzer::Options opts;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   opts.nullRatio = 0.1;
   VectorFuzzer fuzzer(opts, pool_.get());
   VectorFuzzer::Options nonNullOpts;
-  nonNullOpts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  nonNullOpts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   nonNullOpts.nullRatio = 0;
   VectorFuzzer nonNullFuzzer(nonNullOpts, pool_.get());
 
@@ -1335,8 +1332,7 @@ TEST_P(PrestoSerializerTest, roundTrip) {
 
 TEST_P(PrestoSerializerTest, encodedRoundtrip) {
   VectorFuzzer::Options opts;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   opts.nullRatio = 0.1;
   opts.dictionaryHasNulls = false;
   VectorFuzzer fuzzer(opts, pool_.get());
@@ -1474,13 +1470,11 @@ TEST_P(PrestoSerializerTest, typeMismatch) {
 
 TEST_P(PrestoSerializerTest, lexer) {
   VectorFuzzer::Options opts;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   opts.nullRatio = 0.1;
   VectorFuzzer fuzzer(opts, pool_.get());
   VectorFuzzer::Options nonNullOpts;
-  nonNullOpts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  nonNullOpts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   nonNullOpts.nullRatio = 0;
   VectorFuzzer nonNullFuzzer(nonNullOpts, pool_.get());
 
@@ -1609,8 +1603,7 @@ TEST_F(PrestoSerializerTest, serdeSingleColumn) {
   opts.stringVariableLength = true;
   opts.stringLength = 20;
   opts.containerVariableLength = false;
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMilliSeconds;
   opts.containerLength = 10;
 
   auto seed = 0;

diff --git a/velox/serializers/tests/UnsafeRowSerializerTest.cpp b/velox/serializers/tests/UnsafeRowSerializerTest.cpp
@@ -350,8 +350,7 @@ TEST_P(UnsafeRowSerializerTest, types) {
   opts.containerVariableLength = false;
 
   // Spark uses microseconds to store timestamp
-  opts.timestampPrecision =
-      VectorFuzzer::Options::TimestampPrecision::kMicroSeconds;
+  opts.timestampPrecision = FuzzerTimestampPrecision::kMicroSeconds;
   opts.containerLength = 10;
 
   auto seed = folly::Random::rand32();

diff --git a/velox/vector/fuzzer/Utils.h b/velox/vector/fuzzer/Utils.h
@@ -23,6 +23,13 @@ namespace facebook::velox {
 
 using FuzzerGenerator = std::mt19937;
 
+enum class FuzzerTimestampPrecision : int8_t {
+  kNanoSeconds = 0,
+  kMicroSeconds = 1,
+  kMilliSeconds = 2,
+  kSeconds = 3,
+};
+
 namespace generator_spec_utils {
 
 bool coinToss(FuzzerGenerator& rng, double threshold);

diff --git a/velox/vector/fuzzer/VectorFuzzer.cpp b/velox/vector/fuzzer/VectorFuzzer.cpp
@@ -149,18 +149,18 @@ Timestamp randTimestamp(FuzzerGenerator& rng, VectorFuzzer::Options opts) {
   constexpr int64_t millisInSecond = 1'000;
 
   switch (opts.timestampPrecision) {
-    case VectorFuzzer::Options::TimestampPrecision::kNanoSeconds:
+    case FuzzerTimestampPrecision::kNanoSeconds:
       return Timestamp(
           rand<int64_t>(rng, min, max), (rand<int64_t>(rng) % MAX_NANOS));
-    case VectorFuzzer::Options::TimestampPrecision::kMicroSeconds:
+    case FuzzerTimestampPrecision::kMicroSeconds:
       return Timestamp::fromMicros(
           rand<int64_t>(rng, min, max) * microInSecond +
           rand<int64_t>(rng, -microInSecond, microInSecond));
-    case VectorFuzzer::Options::TimestampPrecision::kMilliSeconds:
+    case FuzzerTimestampPrecision::kMilliSeconds:
       return Timestamp::fromMillis(
           rand<int64_t>(rng, min, max) * millisInSecond +
           rand<int64_t>(rng, -millisInSecond, millisInSecond));
-    case VectorFuzzer::Options::TimestampPrecision::kSeconds:
+    case FuzzerTimestampPrecision::kSeconds:
       return Timestamp(rand<int64_t>(rng, min, max), 0);
   }
   return {}; // no-op.

diff --git a/velox/vector/fuzzer/VectorFuzzer.h b/velox/vector/fuzzer/VectorFuzzer.h
@@ -23,6 +23,7 @@
 #include "velox/vector/BaseVector.h"
 #include "velox/vector/ComplexVector.h"
 #include "velox/vector/fuzzer/GeneratorSpec.h"
+#include "velox/vector/fuzzer/Utils.h"
 
 namespace facebook::velox {
 
@@ -140,13 +141,8 @@ class VectorFuzzer {
 
     /// Control the precision of timestamps generated. By default generate using
     /// nanoseconds precision.
-    enum class TimestampPrecision : int8_t {
-      kNanoSeconds = 0,
-      kMicroSeconds = 1,
-      kMilliSeconds = 2,
-      kSeconds = 3,
-    };
-    TimestampPrecision timestampPrecision{TimestampPrecision::kNanoSeconds};
+    FuzzerTimestampPrecision timestampPrecision{
+        FuzzerTimestampPrecision::kNanoSeconds};
 
     /// If true, fuzz() will randomly generate lazy vectors and fuzzInputRow()
     /// will generate a raw vector with children that can randomly be lazy

diff --git a/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp b/velox/vector/fuzzer/tests/VectorFuzzerTest.cpp
@@ -581,7 +581,7 @@ TEST_F(VectorFuzzerTest, containerHasNulls) {
 }
 
 FlatVectorPtr<Timestamp> genTimestampVector(
-    VectorFuzzer::Options::TimestampPrecision precision,
+    FuzzerTimestampPrecision precision,
     size_t vectorSize,
     memory::MemoryPool* pool) {
   VectorFuzzer::Options opts;
@@ -598,7 +598,7 @@ TEST_F(VectorFuzzerTest, timestamp) {
 
   // Second granularity.
   auto secTsVector = genTimestampVector(
-      VectorFuzzer::Options::TimestampPrecision::kSeconds, vectorSize, pool());
+      FuzzerTimestampPrecision::kSeconds, vectorSize, pool());
 
   for (size_t i = 0; i < vectorSize; ++i) {
     auto ts = secTsVector->valueAt(i);
@@ -607,9 +607,7 @@ TEST_F(VectorFuzzerTest, timestamp) {
 
   // Millisecond granularity.
   auto milliTsVector = genTimestampVector(
-      VectorFuzzer::Options::TimestampPrecision::kMilliSeconds,
-      vectorSize,
-      pool());
+      FuzzerTimestampPrecision::kMilliSeconds, vectorSize, pool());
 
   for (size_t i = 0; i < vectorSize; ++i) {
     auto ts = milliTsVector->valueAt(i);
@@ -618,9 +616,7 @@ TEST_F(VectorFuzzerTest, timestamp) {
 
   // Microsecond granularity.
   auto microTsVector = genTimestampVector(
-      VectorFuzzer::Options::TimestampPrecision::kMicroSeconds,
-      vectorSize,
-      pool());
+      FuzzerTimestampPrecision::kMicroSeconds, vectorSize, pool());
 
   for (size_t i = 0; i < vectorSize; ++i) {
     auto ts = microTsVector->valueAt(i);
@@ -629,9 +625,7 @@ TEST_F(VectorFuzzerTest, timestamp) {
 
   // Nanosecond granularity.
   auto nanoTsVector = genTimestampVector(
-      VectorFuzzer::Options::TimestampPrecision::kNanoSeconds,
-      vectorSize,
-      pool());
+      FuzzerTimestampPrecision::kNanoSeconds, vectorSize, pool());
 
   // Check that at least one timestamp has nano > 0.
   bool nanosFound = false;