feat(sqlsmith): fuzz query support sqllogic test cases (#17216)

Author: b41sh

src/query/expression/src/property.rs

@@ -252,6 +252,10 @@ impl Domain {
                 min: this.min.min(other.min),
                 max: this.max.max(other.max),
             }),
+            (Domain::Interval(this), Domain::Interval(other)) => Domain::Interval(SimpleDomain {
+                min: this.min.min(other.min),
+                max: this.max.max(other.max),
+            }),
             (
                 Domain::Nullable(NullableDomain {
                     has_null: true,
@@ -389,6 +393,9 @@ impl Domain {
                 Some(Scalar::Timestamp(*min))
             }
             Domain::Date(SimpleDomain { min, max }) if min == max => Some(Scalar::Date(*min)),
+            Domain::Interval(SimpleDomain { min, max }) if min == max => {
+                Some(Scalar::Interval(*min))
+            }
             Domain::Nullable(NullableDomain {
                 has_null: true,
                 value: None,

src/query/expression/src/utils/column_from.rs

@@ -71,6 +71,7 @@ impl_from_data! { VariantType }
 impl_from_data! { BitmapType }
 impl_from_data! { GeometryType }
 impl_from_data! { GeographyType }
+impl_from_data! { IntervalType }
 
 impl<'a> FromData<&'a [u8]> for BinaryType {
     fn from_data(d: Vec<&'a [u8]>) -> Column {

src/query/expression/src/values.rs

@@ -1325,7 +1325,17 @@ impl Column {
                     .map(|_| rng.gen_range(DATE_MIN..=DATE_MAX))
                     .collect::<Vec<i32>>(),
             ),
-            DataType::Interval => unimplemented!(),
+            DataType::Interval => IntervalType::from_data(
+                (0..len)
+                    .map(|_| {
+                        months_days_micros::new(
+                            rng.gen::<i32>(),
+                            rng.gen::<i32>(),
+                            rng.gen::<i64>(),
+                        )
+                    })
+                    .collect::<Vec<months_days_micros>>(),
+            ),
             DataType::Nullable(ty) => NullableColumn::new_column(
                 Column::random(ty, len, options),
                 Bitmap::from((0..len).map(|_| rng.gen_bool(0.5)).collect::<Vec<bool>>()),

src/query/sql/src/planner/binder/bind_query/bind_select.rs

@@ -241,7 +241,7 @@ impl Binder {
 
         s_expr = self.bind_projection(&mut from_context, &projections, &scalar_items, s_expr)?;
 
-        if !order_by.is_empty() {
+        if !order_items.items.is_empty() {
             s_expr = self.bind_order_by(&from_context, order_items, &select_list, s_expr)?;
         }
 

src/query/sql/src/planner/semantic/type_check.rs

@@ -2622,6 +2622,12 @@ impl<'a> TypeChecker<'a> {
                 )
                 .set_span(span));
             }
+            ExprContext::QualifyClause => {
+                return Err(ErrorCode::SemanticError(
+                    "set-returning functions cannot be used in QUALIFY clause".to_string(),
+                )
+                .set_span(span));
+            }
             _ => {}
         }
 

src/tests/sqlsmith/src/bin/main.rs

@@ -48,6 +48,10 @@ pub struct Args {
     /// The number of timeout seconds of one query.
     #[clap(long, default_value = "5")]
     timeout: u64,
+
+    /// The fuzz query test file path.
+    #[clap(long, default_value = "")]
+    fuzz_path: String,
 }
 
 #[tokio::main(flavor = "multi_thread", worker_threads = 5)]
@@ -70,7 +74,12 @@ async fn main() -> Result<()> {
         args.timeout,
     )
     .await?;
-    runner.run().await?;
+
+    if !args.fuzz_path.is_empty() {
+        runner.run_fuzz(&args.fuzz_path).await?;
+    } else {
+        runner.run().await?;
+    }
 
     Ok(())
 }