Method parseInfix

parser/parser_column.go:80–220

(expr Expr, precedence int)

}

func (p *Parser) parseInfix(expr Expr, precedence int) (Expr, error) {
	switch {
	case p.matchTokenKind(TokenKindSingleEQ), p.matchTokenKind(TokenKindLT), p.matchTokenKind(TokenKindLE),
		p.matchTokenKind(TokenKindGE), p.matchTokenKind(TokenKindGT),
		p.matchTokenKind(TokenKindNE), p.matchTokenKind("<>"),
		p.matchTokenKind(TokenKindMinus), p.matchTokenKind(TokenKindPlus), p.matchTokenKind(TokenKindMul),
		p.matchTokenKind(TokenKindDiv), p.matchTokenKind(TokenKindMod), p.matchTokenKind(TokenKindConcat),
		p.matchKeyword(KeywordIn), p.matchKeyword(KeywordLike),
		p.matchKeyword(KeywordIlike), p.matchKeyword(KeywordAnd), p.matchKeyword(KeywordOr),
		p.matchTokenKind(TokenKindArrow), p.matchTokenKind(TokenKindDoubleEQ):
		op := p.last().ToString()
		_ = p.lexer.consumeToken()
		rightExpr, err := p.parseSubExpr(p.Pos(), precedence)
		if err != nil {
			return nil, err
		}
		return &BinaryOperation{
			LeftExpr:  expr,
			Operation: TokenKind(op),
			RightExpr: rightExpr,
		}, nil
	case p.matchTokenKind(TokenKindDash):
		_ = p.lexer.consumeToken()

		if p.matchTokenKind(TokenKindIdent) && p.last().String == "Tuple" {
			name, err := p.parseIdent()
			if err != nil {
				return nil, err
			}
			if err := p.expectTokenKind(TokenKindLParen); err != nil {
				return nil, err
			}
			// it's a tuple type definition after "::" operator
			rightExpr, err := p.parseNestedType(name, p.Pos())
			if err != nil {
				return nil, err
			}
			return &BinaryOperation{
				LeftExpr:  expr,
				Operation: TokenKindDash,
				RightExpr: rightExpr,
			}, nil
		}

		rightExpr, err := p.parseSubExpr(p.Pos(), precedence)
		if err != nil {
			return nil, err
		}
		return &BinaryOperation{
			LeftExpr:  expr,
			Operation: TokenKindDash,
			RightExpr: rightExpr,
		}, nil
	case p.matchKeyword(KeywordBetween):
		return p.parseBetweenClause(expr)
	case p.matchKeyword(KeywordGlobal):
		_ = p.lexer.consumeToken()
		if p.expectKeyword(KeywordIn) != nil {