ParseUUIDSet works unexpected #467

mysql/mysql_gtid.go

@@ -207,31 +207,61 @@ type UUIDSet struct {
 	Intervals IntervalSlice
 }
 
-func ParseUUIDSet(str string) (*UUIDSet, error) {
-	str = strings.TrimSpace(str)
-	sep := strings.Split(str, ":")
-	if len(sep) < 2 {
-		return nil, errors.Errorf("invalid GTID format, must UUID:interval[:interval]")
-	}
-
-	var err error
-	s := new(UUIDSet)
-	if s.SID, err = uuid.Parse(sep[0]); err != nil {
-		return nil, errors.Trace(err)
-	}
-
-	// Handle interval
-	for i := 1; i < len(sep); i++ {
-		if in, err := parseInterval(sep[i]); err != nil {
-			return nil, errors.Trace(err)
-		} else {
-			s.Intervals = append(s.Intervals, in)
-		}
-	}
-
-	s.Intervals = s.Intervals.Normalize()
-
-	return s, nil
+// ParseUUIDSet parses a GTID set string into a map of UUIDSet structs keyed by their SID.
+// Supports multi-UUID sets like "uuid1:1-10,uuid2:5-15".
+func ParseUUIDSet(s string) (map[string]*UUIDSet, error) {
+    if s == "" {
+        return nil, nil
+    }
+
+    uuidSets := strings.Split(strings.TrimSpace(s), ",")
+    if len(uuidSets) == 0 {
+        return nil, fmt.Errorf("empty UUID set")
+    }
+
+    result := make(map[string]*UUIDSet)
+    for _, set := range uuidSets {
+        set = strings.TrimSpace(set)
+        if set == "" {
+            continue
+        }
+
+        parts := strings.SplitN(set, ":", 2)
+        if len(parts) != 2 {
+            return nil, fmt.Errorf("invalid UUID set format: %s", set)
+        }
+
+        sid, err := uuid.Parse(parts[0])
+        if err != nil {
+            return nil, fmt.Errorf("invalid UUID: %s", parts[0])
+        }
+
+        // Check if this SID already exists in the map
+        uuidSet, exists := result[sid.String()]
+        if !exists {
+            uuidSet = &UUIDSet{SID: sid}
+            result[sid.String()] = uuidSet
+        }
+
+        intervals := strings.Split(parts[1], ":")
+        for _, intervalStr := range intervals {
+            interval, err := parseInterval(intervalStr)
+            if err != nil {
+                return nil, fmt.Errorf("invalid interval in UUID set %s: %v", set, err)
+            }
+            uuidSet.Intervals = append(uuidSet.Intervals, interval)
+        }
+
+        if len(uuidSet.Intervals) == 0 {
+            return nil, fmt.Errorf("no valid intervals in UUID set: %s", set)
+        }
+        uuidSet.Intervals = uuidSet.Intervals.Normalize() // Normalize intervals after adding
+    }
+
+    if len(result) == 0 {
+        return nil, fmt.Errorf("no valid UUID sets parsed from: %s", s)
+    }
+    return result, nil
 }
 
 func NewUUIDSet(sid uuid.UUID, in ...Interval) *UUIDSet {
@@ -398,23 +428,20 @@ type MysqlGTIDSet struct {
 var _ GTIDSet = &MysqlGTIDSet{}
 
 func ParseMysqlGTIDSet(str string) (GTIDSet, error) {
-	s := new(MysqlGTIDSet)
-	s.Sets = make(map[string]*UUIDSet)
-	if str == "" {
-		return s, nil
-	}
-
-	sp := strings.Split(str, ",")
-
-	// todo, handle redundant same uuid
-	for i := 0; i < len(sp); i++ {
-		if set, err := ParseUUIDSet(sp[i]); err != nil {
-			return nil, errors.Trace(err)
-		} else {
-			s.AddSet(set)
-		}
-	}
-	return s, nil
+    s := new(MysqlGTIDSet)
+    s.Sets = make(map[string]*UUIDSet)
+    if str == "" {
+        return s, nil
+    }
+
+    sets, err := ParseUUIDSet(str) // Use the updated ParseUUIDSet
+    if err != nil {
+        return nil, errors.Trace(err)
+    }
+    for sid, set := range sets {
+        s.Sets[sid] = set
+    }
+    return s, nil
 }
 
 func DecodeMysqlGTIDSet(data []byte) (*MysqlGTIDSet, error) {

mysql/mysql_gtid_test.go

@@ -0,0 +1,91 @@
+package mysql
+
+import (
+    "reflect"
+    "testing"
+
+    "github.com/google/uuid"
+)
+
+func TestParseUUIDSet(t *testing.T) {
+    tests := []struct {
+        input    string
+        expected map[string]*UUIDSet
+        wantErr  bool
+    }{
+        {
+            input: "0b8beec9-911e-11e9-9f7b-8a057645f3f6:1-1175877800",
+            expected: map[string]*UUIDSet{
+                "0b8beec9-911e-11e9-9f7b-8a057645f3f6": {
+                    SID:       uuid.Must(uuid.Parse("0b8beec9-911e-11e9-9f7b-8a057645f3f6")),
+                    Intervals: []Interval{{Start: 1, Stop: 1175877801}}, // Stop is Start+1 for single intervals
+                },
+            },
+            wantErr: false,
+        },
+        {
+            input: "0b8beec9-911e-11e9-9f7b-8a057645f3f6:1-1175877800,246e88bd-0288-11e8-9cee-230cd2fc765b:1-592884032",
+            expected: map[string]*UUIDSet{
+                "0b8beec9-911e-11e9-9f7b-8a057645f3f6": {
+                    SID:       uuid.Must(uuid.Parse("0b8beec9-911e-11e9-9f7b-8a057645f3f6")),
+                    Intervals: []Interval{{Start: 1, Stop: 1175877801}},
+                },
+                "246e88bd-0288-11e8-9cee-230cd2fc765b": {
+                    SID:       uuid.Must(uuid.Parse("246e88bd-0288-11e8-9cee-230cd2fc765b")),
+                    Intervals: []Interval{{Start: 1, Stop: 592884033}},
+                },
+            },
+            wantErr: false,
+        },
+        {
+            input:   "invalid",
+            wantErr: true,
+        },
+        {
+            input:    "",
+            expected: nil,
+            wantErr:  false,
+        },
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.input, func(t *testing.T) {
+            got, err := ParseUUIDSet(tt.input)
+            if (err != nil) != tt.wantErr {
+                t.Errorf("ParseUUIDSet() error = %v, wantErr %v", err, tt.wantErr)
+                return
+            }
+            if !reflect.DeepEqual(got, tt.expected) {
+                t.Errorf("ParseUUIDSet() = %v, want %v", got, tt.expected)
+            }
+        })
+    }
+}
+
+func TestParseMysqlGTIDSet(t *testing.T) {
+    input := "0b8beec9-911e-11e9-9f7b-8a057645f3f6:1-1175877800,246e88bd-0288-11e8-9cee-230cd2fc765b:1-592884032"
+    expected := &MysqlGTIDSet{
+        Sets: map[string]*UUIDSet{
+            "0b8beec9-911e-11e9-9f7b-8a057645f3f6": {
+                SID:       uuid.Must(uuid.Parse("0b8beec9-911e-11e9-9f7b-8a057645f3f6")),
+                Intervals: []Interval{{Start: 1, Stop: 1175877801}},
+            },
+            "246e88bd-0288-11e8-9cee-230cd2fc765b": {
+                SID:       uuid.Must(uuid.Parse("246e88bd-0288-11e8-9cee-230cd2fc765b")),
+                Intervals: []Interval{{Start: 1, Stop: 592884033}},
+            },
+        },
+    }
+
+    got, err := ParseMysqlGTIDSet(input)
+    if err != nil {
+        t.Fatalf("ParseMysqlGTIDSet() error = %v", err)
+    }
+    if !reflect.DeepEqual(got, expected) {
+        t.Errorf("ParseMysqlGTIDSet() = %v, want %v", got, expected)
+    }
+
+    if got.String() != input {
+        t.Errorf("String() = %v, want %v", got.String(), input)
+    }
+}