Method parse_set_comparison_subquery

datafusion/sql/src/expr/subquery.rs:163–207

(
        &self,
        left_expr: SQLExpr,
        subquery: Query,
        compare_op: &BinaryOperator,
        quantifier: SetQuantifier,
        input_schema: &DFSchema,
        planner_context: 

    }

    pub(super) fn parse_set_comparison_subquery(
        &self,
        left_expr: SQLExpr,
        subquery: Query,
        compare_op: &BinaryOperator,
        quantifier: SetQuantifier,
        input_schema: &DFSchema,
        planner_context: &mut PlannerContext,
    ) -> Result<Expr> {
        planner_context.append_outer_query_schema(Arc::new(input_schema.clone()));

        let mut spans = Spans::new();
        if let SetExpr::Select(select) = subquery.body.as_ref() {
            for item in &select.projection {
                if let SelectItem::ExprWithAlias { alias, .. } = item
                    && let Some(span) = Span::try_from_sqlparser_span(alias.span)
                {
                    spans.add_span(span);
                }
            }
        }

        let sub_plan = self.query_to_plan(subquery, planner_context)?;
        let outer_ref_columns = sub_plan.all_out_ref_exprs();
        planner_context.pop_outer_query_schema();

        self.validate_single_column(
            &sub_plan,
            &spans,
            "Too many columns! The subquery should only return one column",
            "Select only one column in the subquery",
        )?;

        let expr_obj = self.sql_to_expr(left_expr, input_schema, planner_context)?;
        Ok(Expr::SetComparison(SetComparison::new(
            Box::new(expr_obj),
            Subquery {
                subquery: Arc::new(sub_plan),
                outer_ref_columns,
                spans,
            },
            self.parse_sql_binary_op(compare_op)?,
            quantifier,
        )))
    }
}