Method parseJoinClauses

pkg/sql/parser/select_clauses.go:117–170

parseJoinClauses parses zero or more JOIN clauses that follow the FROM table list. firstRef is the primary (left-most) table, used for building JoinClause.Left.

(firstRef ast.TableReference)

// parseJoinClauses parses zero or more JOIN clauses that follow the FROM table list.
// firstRef is the primary (left-most) table, used for building JoinClause.Left.
func (p *Parser) parseJoinClauses(firstRef ast.TableReference) ([]ast.JoinClause, error) {
	joins := []ast.JoinClause{}

	for p.isJoinKeyword() {
		joinPos := p.currentLocation()
		joinType, isNatural, err := p.parseJoinType()
		if err != nil {
			return nil, err
		}

		// Expect JOIN keyword (APPLY variants skip it)
		isApply := joinType == "CROSS APPLY" || joinType == "OUTER APPLY"
		if !isApply {
			if !p.isType(models.TokenTypeJoin) {
				return nil, goerrors.ExpectedTokenError(
					"JOIN after "+joinType,
					p.currentToken.Token.Type.String(),
					p.currentLocation(),
					"",
				)
			}
			p.advance() // Consume JOIN
		}

		joinedTableRef, err := p.parseJoinedTableRef(joinType)
		if err != nil {
			return nil, err
		}

		joinCondition, err := p.parseJoinCondition(joinType, isNatural, isApply)
		if err != nil {
			return nil, err
		}

		// Build left-side reference (synthetic for chained joins)
		var leftTable ast.TableReference
		if len(joins) == 0 {
			leftTable = firstRef
		} else {
			leftTable = ast.TableReference{
				Name: fmt.Sprintf("(%s_with_%d_joins)", firstRef.Name, len(joins)),
			}
		}

		joins = append(joins, ast.JoinClause{
			Type:      joinType,
			Left:      leftTable,
			Right:     joinedTableRef,
			Condition: joinCondition,
			Pos:       joinPos,
		})
	}
	return joins, nil
}

// parseJoinType parses the optional NATURAL keyword and the join-type keywords
// (LEFT, RIGHT, FULL, INNER, CROSS, OUTER APPLY, …) that precede the JOIN keyword.