XML parsing with Golang (abuse of entity attributes)

I have an XML formatted like this, coming from a dump of a database

<table name="table1">
    <row>
        <col name="col1">value</col>
        <col name="col2">value</col>
        <col name="col3">value</col>
    </row>
   ...
</table>
<table name="table2">
    <row>
        <col name="col1">value</col>
        <col name="col2">value</col>
        <col name="col3">value</col>
        <col name="col4">value</col>
    </row>
   ...
</table>

I am trying to parse this in Go with xml.Decode() function but I can't handle such an XML.
I tried to match some of the examples found googling XML parsing in Golang, but nothing suits this kind of format (with name attributes all over the entities).

Update

Thanks for the answers! What I'd like to achieve is: let's say I have a Table called "users" and a table called "categories", I'd like to create as many User and Category objects starting from that XML.
Based on your first answers I can easily use the Table objects parsed and then create my own objects, but I'd like to know if I can skip that and decode directly my objects instead.

I don't know what kind of issue you're dealing with, but your XML actually looks like a stream of XML values, so you should decode it as such:

type Table struct {
	Name string `xml:"name,attr"`
	Rows []Row  `xml:"row"`
}

type Row struct {
	Cols []Col `xml:"col"`
}

type Col struct {
	Name  string `xml:"name,attr"`
	Value string `xml:",chardata"`
}

//...

var err error
dec := xml.NewDecoder(bytes.NewReader(b))
for err == nil {
	t := Table{}
	err = dec.Decode(&t)
	fmt.Printf("%v, %+v\n", err, t)
}

Playground: https://play.golang.org/p/w4PqLv-Uc0.

EDIT: If you want to decode such XML directly into appropriate structs, you'll need a more complex machinery. Here's an example for users:

type User struct {
	ID      int
	Name    string
	Surname string
}

func (u *User) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error {
	var err error

	type col struct {
		Name  string `xml:"name,attr"`
		Value string `xml:",chardata"`
	}

	for {
		c := col{}
		err = d.Decode(&c)
		if err != nil {
			if err == io.EOF {
				break
			}

			return err
		}
		switch c.Name {
		case "id":
			u.ID, err = strconv.Atoi(c.Value)
			if err != nil {
				return err
			}
		case "name":
			u.Name = c.Value
			continue
		case "surname":
			u.Surname = c.Value
		}
	}

	return nil
}

type UserTable struct {
	Users []User `xml:"row"`
}

Playground: https://play.golang.org/p/Hqta3Ngjo3.

The doc of the xml.Unmarshal() function describes how the mapping between XML documents and structs work (supplemented by doc of json.Marshal()). If you're not familiar with struct tags, check out this answer: https://stackoverflow.com/questions/10858787/what-are-the-uses-for-tags-in-go/30889373#30889373

First you need to model the XML document. Note that if you don't have a wrapper XML element around all the others, that is not 1 XML document but multiple, such as your case. You have multiple <table> documents.

You can model them like this:

type Col struct {
	Name  string `xml:"name,attr"`
	Value string `xml:",chardata"`
}

type Row struct {
	Cols []Col `xml:"col"`
}

type Table struct {
	Name string `xml:"name,attr"`
	Rows []Row  `xml:"row"`
}

And since you have multiple <table> elements, easiest is to create an xml.Decoder() and parse each separately with a Decoder.Decode() call (Decoder.Decode() will attempt to parse 1 XML document from its source reader).

This is how it can be done:

d := xml.NewDecoder(strings.NewReader(data))
for {
	var table Table
	if err := d.Decode(&table); err != nil {
		fmt.Println(err)
		break
	}
	fmt.Printf("%+v\n", table)
}

When there are no more data in the source string, Decoder.Decode() will report io.EOF. Running the above cod with the following data string:

const data = `<table name="table1">
    <row>
        <col name="col1">value1</col>
        <col name="col2">value2</col>
        <col name="col3">value3</col>
    </row>
    <row>
        <col name="col1">value4</col>
        <col name="col2">value5</col>
        <col name="col3">value6</col>
    </row>
</table>
<table name="table2">
    <row>
        <col name="col1">value7</col>
        <col name="col2">value8</col>
        <col name="col3">value9</col>
        <col name="col4">valueA</col>
    </row>
</table>`

The output is:

{Name:table1 Rows:[{Cols:[{Name:col1 Value:value1} {Name:col2 Value:value2} {Name:col3 Value:value3}]} {Cols:[{Name:col1 Value:value4} {Name:col2 Value:value5} {Name:col3 Value:value6}]}]}
{Name:table2 Rows:[{Cols:[{Name:col1 Value:value7} {Name:col2 Value:value8} {Name:col3 Value:value9} {Name:col4 Value:valueA}]}]}
EOF

Try it on the Go Playground.

To unmarshal each field into a different type based on the name, you'll need to get each start element token, check the name, and then decode as appropriate. Something like the following (where getName is a function that returns the name attribute; see the playground link for a minimal working example):

d := xml.NewDecoder(…)
for {
	tok, err := d.Token()
	if err != nil {
		log.Fatal(err)
	}

	start, ok := tok.(xml.StartElement)
	if !ok {
		// This is chardata or some other token.
		// If it's bad XML, it will be caught on the next call to Token()
		continue
	}
	switch getName(start) {
	case "user":
		u := &User{}
		err = d.DecodeElement(u, &start)
		if err != nil {
			log.Fatal(err)
		}
		// Do whatever you want to do with your struct here.
		fmt.Printf("Decoded a user: %+v\n", u)
	case "category":
		u := &Category{}
		err = d.DecodeElement(u, &start)
		if err != nil {
			log.Fatal(err)
		}
		fmt.Printf("Decoded a category: %+v\n", u)
	default:
		// If the name is unrecognized, skip the rest of the element.
		// We could also return an error
		d.Skip()
	}
}

https://play.golang.org/p/l7Vmj_8Igp