Method parse_parenthesized_fragment

src/sql-parser/src/parser.rs:750–828

Parses an expression list that appears in parentheses, like `(1 + 1)`, `(SELECT 1)`, or `(1, 2)`. Assumes that the opening parenthesis has already been parsed. Parses up to the closing parenthesis without consuming it.

(&mut self)

    /// already been parsed. Parses up to the closing parenthesis without
    /// consuming it.
    fn parse_parenthesized_fragment(&mut self) -> Result<ParenthesizedFragment, ParserError> {
        // The SQL grammar has an irritating ambiguity that presents here.
        // Consider these two expression fragments:
        //
        //     SELECT (((SELECT 2)) + 3)
        //     SELECT (((SELECT 2)) UNION SELECT 2)
        //             ^           ^
        //            (1)         (2)
        // When we see the parenthesis marked (1), we have no way to know ahead
        // of time whether that parenthesis is part of a `SetExpr::Query` inside
        // of an `Expr::Subquery` or whether it introduces an `Expr::Nested`.
        // The approach taken here avoids backtracking by deferring the decision
        // of whether to parse as a subquery or a nested expression until we get
        // to the point marked (2) above. Once there, we know that the presence
        // of a set operator implies that the parentheses belonged to the
        // subquery; otherwise, they belonged to the expression.
        //
        // See also PostgreSQL's comments on the matter:
        // https://github.com/postgres/postgres/blob/42c63ab/src/backend/parser/gram.y#L11125-L11136
        //
        // Each call of this function handles one layer of parentheses. Before
        // every call, the parser must be positioned after an opening
        // parenthesis; upon non-error return, the parser will be positioned
        // before the corresponding close parenthesis. Somewhat weirdly, the
        // returned expression semantically includes the opening/closing
        // parentheses, even though this function is not responsible for parsing
        // them.

        if self.peek_one_of_keywords(QUERY_START_KEYWORDS) {
            // Easy case one: unambiguously a subquery.
            Ok(ParenthesizedFragment::Query(self.parse_query()?))
        } else if !self.consume_token(&Token::LParen) {
            // Easy case two: unambiguously an expression.
            let exprs = self.parse_comma_separated(Parser::parse_expr)?;
            Ok(ParenthesizedFragment::Exprs(exprs))
        } else {
            // Hard case: we have an open parenthesis, and we need to decide
            // whether it belongs to the inner expression or the outer
            // expression.

            // Parse to the closing parenthesis.
            let fragment = self.checked_recur_mut(Parser::parse_parenthesized_fragment)?;
            self.expect_token(&Token::RParen)?;

            // Decide if we need to associate any tokens after the closing
            // parenthesis with what we've parsed so far.
            match (fragment, self.peek_token()) {
                // We have a subquery and the next token is a set operator or a
                // closing parenthesis. That implies we have a partially-parsed
                // subquery (or a syntax error). Hop into parsing a set
                // expression where our subquery is the LHS of the set operator.
                (
                    ParenthesizedFragment::Query(query),
                    Some(Token::RParen | Token::Keyword(UNION | INTERSECT | EXCEPT)),
                ) => {
                    let query = SetExpr::Query(Box::new(query));
                    let ctes = CteBlock::empty();
                    let body = self.parse_query_body_seeded(SetPrecedence::Zero, query)?;