Method parseExpr

database/postgres/parser.go:535–894

(stmt *pgquery.Node)

}

func (p PostgresParser) parseExpr(stmt *pgquery.Node) (parser.Expr, error) {
	switch node := stmt.Node.(type) {
	case *pgquery.Node_AArrayExpr:
		var elements parser.Exprs
		for _, element := range node.AArrayExpr.Elements {
			node, err := p.parseExpr(element)
			if err != nil {
				return nil, err
			}

			elem, err := p.parseArrayElement(node)
			if err != nil {
				return nil, err
			}
			elements = append(elements, elem)
		}
		return &parser.ArrayConstructor{
			Elements: elements,
		}, nil
	case *pgquery.Node_AConst:
		switch cNode := node.AConst.Val.(type) {
		case *pgquery.A_Const_Ival:
			return parser.NewIntVal(fmt.Sprint(cNode.Ival.Ival)), nil
		case *pgquery.A_Const_Fval:
			return parser.NewFloatVal(fmt.Sprint(cNode.Fval.Fval)), nil
		case *pgquery.A_Const_Boolval:
			return parser.NewBoolVal(cNode.Boolval.Boolval), nil
		case *pgquery.A_Const_Sval:
			return parser.NewStrVal(cNode.Sval.Sval), nil
		case *pgquery.A_Const_Bsval:
			return parser.NewBitVal(cNode.Bsval.Bsval), nil
		case nil:
			return &parser.NullVal{}, nil
		default:
			return nil, fmt.Errorf("unknown AConst val type in parseExpr: %#v", cNode)
		}
	case *pgquery.Node_BoolExpr:
		expr, err := p.parseExpr(node.BoolExpr.Args[0])
		if err != nil {
			return nil, err
		}

		if node.BoolExpr.Boolop == pgquery.BoolExprType_NOT_EXPR {
			return &parser.NotExpr{
				Expr: expr,
			}, nil
		}

		for _, arg := range node.BoolExpr.Args[1:] {
			right, err := p.parseExpr(arg)
			if err != nil {
				return nil, err
			}

			switch node.BoolExpr.Boolop {
			case pgquery.BoolExprType_AND_EXPR:
				expr = &parser.AndExpr{
					Left:  expr,