Support subquery in having clause with correlated predicate

Author: chenboy

src/include/optimizer/operators.h

@@ -226,6 +226,9 @@ class LogicalAggregateAndGroupBy
  public:
   static Operator make();
 
+  static Operator make(
+      std::vector<std::shared_ptr<expression::AbstractExpression>> &columns);
+
   static Operator make(
       std::vector<std::shared_ptr<expression::AbstractExpression>> &columns,
       std::vector<AnnotatedExpression> &having);

src/include/optimizer/query_to_operator_transformer.h

@@ -81,7 +81,9 @@ class QueryToOperatorTransformer : public SqlNodeVisitor {
    *
    * @param expr The original predicate
    */
-  void CollectPredicates(expression::AbstractExpression *expr);
+  std::vector<AnnotatedExpression> CollectPredicates(
+      expression::AbstractExpression *expr,
+      std::vector<AnnotatedExpression> predicates = {});
 
   // TODO(boweic): Since we haven't migrated all the functionalities needed to
   // generate mark-join and single-join to the optimizer, currently this

src/include/optimizer/util.h

@@ -33,73 +33,80 @@ class DataTable;
 namespace optimizer {
 namespace util {
 
-inline void to_lower_string(std::string& str) {
+inline void to_lower_string(std::string &str) {
   std::transform(str.begin(), str.end(), str.begin(), ::tolower);
 }
 
 template <class T>
-bool IsSubset(const std::unordered_set<T>& super_set,
-              const std::unordered_set<T>& child_set) {
+bool IsSubset(const std::unordered_set<T> &super_set,
+              const std::unordered_set<T> &child_set) {
   for (auto element : child_set) {
     if (super_set.find(element) == super_set.end()) return false;
   }
   return true;
 }
 
 template <class T>
-void SetUnion(std::unordered_set<T>& new_set, std::unordered_set<T>& old_set) {
+void SetUnion(std::unordered_set<T> &new_set, std::unordered_set<T> &old_set) {
   for (auto element : old_set) new_set.insert(element);
 }
 
 // get the column IDs evaluated in a predicate
-void GetPredicateColumns(const catalog::Schema* schema,
-                         expression::AbstractExpression* expression,
-                         std::vector<oid_t>& column_ids,
-                         std::vector<ExpressionType>& expr_types,
-                         std::vector<type::Value>& values,
-                         bool& index_searchable);
-
-bool CheckIndexSearchable(storage::DataTable* target_table,
-                          expression::AbstractExpression* expression,
-                          std::vector<oid_t>& key_column_ids,
-                          std::vector<ExpressionType>& expr_types,
-                          std::vector<type::Value>& values, oid_t& index_id);
-
-void SplitPredicates(expression::AbstractExpression* expr,
-                     std::vector<expression::AbstractExpression*>& predicates);
-
-expression::AbstractExpression* CombinePredicates(
+void GetPredicateColumns(const catalog::Schema *schema,
+                         expression::AbstractExpression *expression,
+                         std::vector<oid_t> &column_ids,
+                         std::vector<ExpressionType> &expr_types,
+                         std::vector<type::Value> &values,
+                         bool &index_searchable);
+
+bool CheckIndexSearchable(storage::DataTable *target_table,
+                          expression::AbstractExpression *expression,
+                          std::vector<oid_t> &key_column_ids,
+                          std::vector<ExpressionType> &expr_types,
+                          std::vector<type::Value> &values, oid_t &index_id);
+
+void SplitPredicates(expression::AbstractExpression *expr,
+                     std::vector<expression::AbstractExpression *> &predicates);
+
+expression::AbstractExpression *CombinePredicates(
     std::vector<std::shared_ptr<expression::AbstractExpression>> predicates);
 
-expression::AbstractExpression* CombinePredicates(
+expression::AbstractExpression *CombinePredicates(
     std::vector<AnnotatedExpression> predicates);
 
-void ExtractPredicates(expression::AbstractExpression* expr,
-                       std::vector<AnnotatedExpression>& annotated_predicates);
+std::vector<AnnotatedExpression> ExtractPredicates(
+    expression::AbstractExpression *expr,
+    std::vector<AnnotatedExpression> annotated_predicates = {});
 
-expression::AbstractExpression* ConstructJoinPredicate(
-    std::unordered_set<std::string>& table_alias_set,
-    MultiTablePredicates& join_predicates);
+expression::AbstractExpression *ConstructJoinPredicate(
+    std::unordered_set<std::string> &table_alias_set,
+    MultiTablePredicates &join_predicates);
 
-bool ContainsJoinColumns(const std::unordered_set<std::string>& l_group_alias,
-                         const std::unordered_set<std::string>& r_group_alias,
-                         const expression::AbstractExpression* expr);
+bool ContainsJoinColumns(const std::unordered_set<std::string> &l_group_alias,
+                         const std::unordered_set<std::string> &r_group_alias,
+                         const expression::AbstractExpression *expr);
 
 std::unique_ptr<planner::AbstractPlan> CreateCopyPlan(
-    parser::CopyStatement* copy_stmt);
+    parser::CopyStatement *copy_stmt);
 
 std::unordered_map<std::string, std::shared_ptr<expression::AbstractExpression>>
-ConstructSelectElementMap(std::vector<std::unique_ptr<expression::AbstractExpression>> &select_list);
-
-expression::AbstractExpression*
-TransformQueryDerivedTablePredicates(const std::unordered_map<std::string, std::shared_ptr<expression::AbstractExpression>>& alias_to_expr_map,
-                                     expression::AbstractExpression* expr);
-
-// Extract equi-join keys from the join predicates (conjunction is already removed in each unit)
-void ExtractEquiJoinKeys(const std::vector<AnnotatedExpression> join_predicates,
-                         std::vector<std::unique_ptr<expression::AbstractExpression>>& left_keys,
-                         std::vector<std::unique_ptr<expression::AbstractExpression>>& right_keys,
-                         const std::unordered_set<std::string>& left_alias, const std::unordered_set<std::string>& right_alias);
+ConstructSelectElementMap(
+    std::vector<std::unique_ptr<expression::AbstractExpression>> &select_list);
+
+expression::AbstractExpression *TransformQueryDerivedTablePredicates(
+    const std::unordered_map<std::string,
+                             std::shared_ptr<expression::AbstractExpression>>
+        &alias_to_expr_map,
+    expression::AbstractExpression *expr);
+
+// Extract equi-join keys from the join predicates (conjunction is already
+// removed in each unit)
+void ExtractEquiJoinKeys(
+    const std::vector<AnnotatedExpression> join_predicates,
+    std::vector<std::unique_ptr<expression::AbstractExpression>> &left_keys,
+    std::vector<std::unique_ptr<expression::AbstractExpression>> &right_keys,
+    const std::unordered_set<std::string> &left_alias,
+    const std::unordered_set<std::string> &right_alias);
 
 }  // namespace util
 }  // namespace optimizer

src/optimizer/input_column_deriver.cpp

@@ -275,7 +275,7 @@ void InputColumnDeriver::JoinHelper(const BaseOperatorNode *op) {
   }
   ExprMap output_cols_map;
   for (auto expr : required_cols_) {
-    expression::ExpressionUtil::GetTupleValueExprs(output_cols_map, expr);
+    expression::ExpressionUtil::GetTupleAndAggregateExprs(output_cols_map, expr);
   }
   for (auto &expr_idx_pair : output_cols_map) {
     input_cols_set.insert(expr_idx_pair.first);