feat(SqlSmith): gen Table Subquery EXISTS (risingwavelabs#4431)

* Implement exists

* Fix formatting

* Add correlated query

* Restore unwanted changes

* Edit Syntax error

* Allow subquery without agg

* Workaround subquery and inside_agg but there is a few problem yet

* Test changed to no subquery first

* Done implementation

Co-authored-by: mergify[bot] <37929162+mergify[bot]@users.noreply.github.com>

src/tests/sqlsmith/src/expr.rs

@@ -84,7 +84,8 @@ impl<'a, R: Rng> SqlGenerator<'a, R> {
         let range = if can_agg & !inside_agg { 99 } else { 90 };
 
         match self.rng.gen_range(0..=range) {
-            0..=80 => self.gen_func(typ, can_agg, inside_agg),
+            0..=70 => self.gen_func(typ, can_agg, inside_agg),
+            71..=80 => self.gen_exists(typ, inside_agg),
             81..=90 => self.gen_cast(typ, can_agg, inside_agg),
             91..=99 => self.gen_agg(typ),
             // TODO: There are more that are not in the functions table, e.g. CAST.
@@ -242,6 +243,22 @@ impl<'a, R: Rng> SqlGenerator<'a, R> {
             .unwrap_or_else(|| self.gen_simple_scalar(ret))
     }
 
+    fn gen_exists(&mut self, ret: DataTypeName, inside_agg: bool) -> Expr {
+        // TODO: Streaming nested loop join is not implemented yet.
+        // Tracked by: <https://github.com/singularity-data/risingwave/issues/2655>.
+
+        // Generation of subquery inside aggregation is now workaround.
+        // Tracked by: <https://github.com/risingwavelabs/risingwave/issues/3896>.
+        if self.is_mview || ret != DataTypeName::Boolean || inside_agg {
+            return self.gen_simple_scalar(ret);
+        };
+        // TODO: Feature is not yet implemented: correlated subquery in HAVING or SELECT with agg
+        // let (subquery, _) = self.gen_correlated_query();
+        // Tracked by: <https://github.com/risingwavelabs/risingwave/issues/2275>
+        let (subquery, _) = self.gen_local_query();
+        Expr::Exists(Box::new(subquery))
+    }
+
     fn gen_agg(&mut self, ret: DataTypeName) -> Expr {
         // TODO: workaround for <https://github.com/risingwavelabs/risingwave/issues/4508>
         if ret == DataTypeName::Interval {

src/tests/sqlsmith/src/lib.rs

@@ -210,14 +210,24 @@ impl<'a, R: Rng> SqlGenerator<'a, R> {
     }
 
     /// Generates a query with local context.
-    /// Used by `WITH`, subquery
+    /// Used by `WITH`, `Table Subquery` in Relation
     fn gen_local_query(&mut self) -> (Query, Vec<Column>) {
         let old_ctxt = self.new_local_context();
         let t = self.gen_query();
         self.restore_context(old_ctxt);
         t
     }
 
+    /// Generates a query with correlated context to ensure proper recursion.
+    /// Used by Exists `Subquery`
+    /// TODO: <https://github.com/risingwavelabs/risingwave/pull/4431#issuecomment-1327417328>
+    fn _gen_correlated_query(&mut self) -> (Query, Vec<Column>) {
+        let old_ctxt = self._clone_local_context();
+        let t = self.gen_query();
+        self.restore_context(old_ctxt);
+        t
+    }
+
     fn gen_with(&mut self) -> (Option<With>, Vec<Table>) {
         match self.flip_coin() {
             true => (None, vec![]),

src/tests/sqlsmith/src/utils.rs

@@ -36,6 +36,13 @@ impl<'a, R: Rng> SqlGenerator<'a, R> {
         self.bound_relations = old_rels;
         self.bound_columns = old_cols;
     }
+
+    // TODO: <https://github.com/risingwavelabs/risingwave/pull/4431#issuecomment-1327417328>
+    pub(crate) fn _clone_local_context(&mut self) -> Context {
+        let current_bound_relations = self.bound_relations.clone();
+        let current_bound_columns = self.bound_columns.clone();
+        (current_bound_columns, current_bound_relations)
+    }
 }
 
 /// Gen utils