Method parseExclusion

database/postgres/parser.go:1068–1116

(constraint *pgquery.Constraint)

}

func (p PostgresParser) parseExclusion(constraint *pgquery.Constraint) (*parser.ExclusionDefinition, error) {
	var exs []parser.ExclusionPair
	for _, ex := range constraint.Exclusions {
		nl := ex.GetList()
		if nl == nil {
			return nil, fmt.Errorf("require node list on exclusion: %#v", ex)
		}
		nItems := nl.GetItems()
		if nItems == nil {
			return nil, fmt.Errorf("require items on node list: %#v", nl)
		}
		excludeElement := nItems[0].GetIndexElem()
		if excludeElement == nil {
			return nil, errors.New("require exclude element")
		}
		var expr parser.Expr
		if n := excludeElement.GetExpr(); n != nil {
			parsedExpr, err := p.parseExpr(n)
			if err != nil {
				return nil, err
			}
			expr = parsedExpr
		} else {
			// If there's no expression, just use the column name as an expression
			expr = &parser.ColName{Name: parser.NewIdent(excludeElement.Name, false)}
		}

		opList := nItems[1].GetList()
		opItems := opList.GetItems()
		exs = append(exs, parser.ExclusionPair{
			Expression: expr,
			Operator:   opItems[0].Node.(*pgquery.Node_String_).String_.Sval},
		)
	}
	var whereExpr parser.Expr
	if whereClause := constraint.GetWhereClause(); whereClause != nil {
		expr, err := p.parseExpr(whereClause)
		if err != nil {
			return nil, err
		}
		whereExpr = expr
	}
	return &parser.ExclusionDefinition{
		ConstraintName: parser.NewIdent(constraint.Conname, false),
		IndexType:      parser.NewIdent(constraint.GetAccessMethod(), false),
		Exclusions:     exs,
		Where:          parser.NewWhere(parser.WhereStr, whereExpr),
	}, nil
}

func (p PostgresParser) parseForeignKey(constraint *pgquery.Constraint) (*parser.ForeignKeyDefinition, error) {
	idxCols := util.TransformSlice(constraint.FkAttrs, func(fkAttr *pgquery.Node) parser.Ident {