Method parseJSONExpression

pkg/sql/parser/expressions.go:210–285

parseJSONExpression parses JSON/JSONB operators (PostgreSQL) and type casting Handles: ->, ->>, #>, #>>, @>, <@, ?, ?|, ?&, #-, ::

()

// parseJSONExpression parses JSON/JSONB operators (PostgreSQL) and type casting
// Handles: ->, ->>, #>, #>>, @>, <@, ?, ?|, ?&, #-, ::
func (p *Parser) parseJSONExpression() (ast.Expression, error) {
	// Parse the left side using primary expression
	left, err := p.parsePrimaryExpression()
	if err != nil {
		return nil, err
	}

	// Snowflake VARIANT path: `expr:field[.field|[idx]]*`. Must run before
	// the `::` cast loop so that `col:a.b::int` casts the full path rather
	// than treating the path as a bare expression.
	if p.dialect == string(keywords.DialectSnowflake) && p.isType(models.TokenTypeColon) {
		vp, err := p.parseSnowflakeVariantPath(left)
		if err != nil {
			return nil, err
		}
		left = vp
	}

	// Handle type casting (::) with highest precedence
	// PostgreSQL: expr::type (e.g., '123'::integer, column::text)
	for p.isType(models.TokenTypeDoubleColon) {
		p.advance() // Consume ::

		// Parse the target data type
		dataType, err := p.parseDataType()
		if err != nil {
			return nil, err
		}

		left = &ast.CastExpression{
			Expr: left,
			Type: dataType,
		}
	}

	// Handle JSON operators (left-associative for chaining like data->'a'->'b')
	for p.isJSONOperator() {
		opPos := p.currentLocation()
		operator := p.currentToken.Token.Value
		operatorType := p.currentToken.Token.Type
		p.advance() // Consume JSON operator

		// Parse the right side
		right, err := p.parsePrimaryExpression()
		if err != nil {
			return nil, err
		}

		left = &ast.BinaryExpression{
			Left:     left,
			Operator: operator,
			Right:    right,
			Pos:      opPos,
		}

		// Store operator type for semantic analysis if needed
		_ = operatorType