Method parseCastLike

pkg/sql/parser/expressions_complex.go:149–233

parseCastLike implements the body shared between CAST and TRY_CAST. The caller is responsible for ensuring the current token is the leading keyword.

(try bool)

// parseCastLike implements the body shared between CAST and TRY_CAST. The
// caller is responsible for ensuring the current token is the leading keyword.
func (p *Parser) parseCastLike(try bool) (*ast.CastExpression, error) {
	// Consume CAST / TRY_CAST keyword
	p.advance()

	// Expect opening parenthesis
	if !p.isType(models.TokenTypeLParen) {
		return nil, p.expectedError("(")
	}
	p.advance() // Consume (

	// Parse the expression to be cast
	expr, err := p.parseExpression()
	if err != nil {
		return nil, err
	}

	// Expect AS keyword
	if !p.isType(models.TokenTypeAs) {
		return nil, p.expectedError("AS")
	}
	p.advance() // Consume AS

	// Parse the target data type
	// The type can be:
	// - Simple type: VARCHAR, INT, DECIMAL, etc.
	// - Type with precision: VARCHAR(100), DECIMAL(10,2), etc.
	if !p.isType(models.TokenTypeIdentifier) {
		return nil, p.expectedError("data type")
	}

	dataType := p.currentToken.Token.Value
	p.advance() // Consume type name

	// Check for type parameters (e.g., VARCHAR(100), DECIMAL(10,2))
	if p.isType(models.TokenTypeLParen) {
		p.advance() // Consume (

		// Build the full type string including parameters
		typeParams := "("
		paramCount := 0

		for !p.isType(models.TokenTypeRParen) {
			if paramCount > 0 {
				if !p.isType(models.TokenTypeComma) {
					return nil, p.expectedError(", or )")
				}
				typeParams += p.currentToken.Token.Value
				p.advance() // Consume comma
			}

			// Parse parameter (should be a number)
			if !p.isNumericLiteral() && !p.isType(models.TokenTypeIdentifier) {
				return nil, goerrors.InvalidSyntaxError(
					"expected numeric type parameter",
					p.currentLocation(),
					"Use CAST(expr AS TYPE(precision[, scale]))",
				)
			}