shed: allow to change the index name for easier migrations (#1912)

Author: janos

shed/schema.go

@@ -46,20 +46,20 @@ type fieldSpec struct {
 	Type string `json:"type"`
 }
 
-// indxSpec holds information about a particular index.
+// indexSpec holds information about a particular index.
 // It does not contain index type, as indexes do not have type.
 type indexSpec struct {
 	Name string `json:"name"`
 }
 
 // schemaFieldKey retrieves the complete LevelDB key for
-// a particular field form the schema definition.
+// a particular field from the schema definition.
 func (db *DB) schemaFieldKey(name, fieldType string) (key []byte, err error) {
 	if name == "" {
-		return nil, errors.New("field name can not be blank")
+		return nil, errors.New("field name cannot be blank")
 	}
 	if fieldType == "" {
-		return nil, errors.New("field type can not be blank")
+		return nil, errors.New("field type cannot be blank")
 	}
 	s, err := db.getSchema()
 	if err != nil {
@@ -86,11 +86,40 @@ func (db *DB) schemaFieldKey(name, fieldType string) (key []byte, err error) {
 	return append([]byte{keyPrefixFields}, []byte(name)...), nil
 }
 
+// RenameIndex changes the schema so that an existing index name is changed
+// while preserving its data by keeping the same internal key prefix.
+// Renaming indexes is useful when encoding functions can be backward compatible
+// to avoid data migrations.
+func (db *DB) RenameIndex(name, newName string) (renamed bool, err error) {
+	if name == "" {
+		return false, errors.New("index name cannot be blank")
+	}
+	if newName == "" {
+		return false, errors.New("new index name cannot be blank")
+	}
+	if newName == name {
+		return false, nil
+	}
+	s, err := db.getSchema()
+	if err != nil {
+		return false, err
+	}
+	for i, f := range s.Indexes {
+		if f.Name == name {
+			s.Indexes[i] = indexSpec{
+				Name: newName,
+			}
+			return true, db.putSchema(s)
+		}
+	}
+	return false, nil
+}
+
 // schemaIndexID retrieves the complete LevelDB prefix for
 // a particular index.
 func (db *DB) schemaIndexPrefix(name string) (id byte, err error) {
 	if name == "" {
-		return 0, errors.New("index name can not be blank")
+		return 0, errors.New("index name cannot be blank")
 	}
 	s, err := db.getSchema()
 	if err != nil {

shed/schema_test.go

@@ -29,16 +29,16 @@ func TestDB_schemaFieldKey(t *testing.T) {
 	t.Run("empty name or type", func(t *testing.T) {
 		_, err := db.schemaFieldKey("", "")
 		if err == nil {
-			t.Errorf("error not returned, but expected")
+			t.Error("error not returned, but expected")
 		}
 		_, err = db.schemaFieldKey("", "type")
 		if err == nil {
-			t.Errorf("error not returned, but expected")
+			t.Error("error not returned, but expected")
 		}
 
 		_, err = db.schemaFieldKey("test", "")
 		if err == nil {
-			t.Errorf("error not returned, but expected")
+			t.Error("error not returned, but expected")
 		}
 	})
 
@@ -82,7 +82,7 @@ func TestDB_schemaFieldKey(t *testing.T) {
 
 		_, err = db.schemaFieldKey("the-field", "another-type")
 		if err == nil {
-			t.Errorf("error not returned, but expected")
+			t.Error("error not returned, but expected")
 		}
 	})
 }
@@ -124,3 +124,119 @@ func TestDB_schemaIndexPrefix(t *testing.T) {
 		}
 	})
 }
+
+// TestDB_RenameIndex checks if index name is correctly changed.
+func TestDB_RenameIndex(t *testing.T) {
+
+	t.Run("empty names", func(t *testing.T) {
+		db, cleanupFunc := newTestDB(t)
+		defer cleanupFunc()
+
+		// empty names
+		renamed, err := db.RenameIndex("", "")
+		if err == nil {
+			t.Error("error not returned, but expected")
+		}
+		if renamed {
+			t.Fatal("index should not be renamed")
+		}
+
+		// empty index name
+		renamed, err = db.RenameIndex("", "new")
+		if err == nil {
+			t.Error("error not returned, but expected")
+		}
+		if renamed {
+			t.Fatal("index should not be renamed")
+		}
+
+		// empty new index name
+		renamed, err = db.RenameIndex("current", "")
+		if err == nil {
+			t.Error("error not returned, but expected")
+		}
+		if renamed {
+			t.Fatal("index should not be renamed")
+		}
+	})
+
+	t.Run("same names", func(t *testing.T) {
+		db, cleanupFunc := newTestDB(t)
+		defer cleanupFunc()
+
+		renamed, err := db.RenameIndex("index1", "index1")
+		if err != nil {
+			t.Error(err)
+		}
+		if renamed {
+			t.Fatal("index should not be renamed")
+		}
+	})
+
+	t.Run("unknown name", func(t *testing.T) {
+		db, cleanupFunc := newTestDB(t)
+		defer cleanupFunc()
+
+		renamed, err := db.RenameIndex("index1", "index1new")
+		if err != nil {
+			t.Error(err)
+		}
+		if renamed {
+			t.Fatal("index should not be renamed")
+		}
+	})
+
+	t.Run("valid names", func(t *testing.T) {
+		db, cleanupFunc := newTestDB(t)
+		defer cleanupFunc()
+
+		// initial indexes
+		key1, err := db.schemaIndexPrefix("index1")
+		if err != nil {
+			t.Fatal(err)
+		}
+		key2, err := db.schemaIndexPrefix("index2")
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		// name the first one
+		renamed, err := db.RenameIndex("index1", "index1new")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !renamed {
+			t.Fatal("index not renamed")
+		}
+
+		// validate that the index key stays the same
+		key1same, err := db.schemaIndexPrefix("index1new")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if key1 != key1same {
+			t.Fatal("indexes renamed, but keys are not the same")
+		}
+
+		// validate that the independent index is not changed
+		key2same, err := db.schemaIndexPrefix("index2")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if key2 != key2same {
+			t.Fatal("independent index key has changed")
+		}
+
+		// validate that it is safe to create a new index with previous name
+		key1renew, err := db.schemaIndexPrefix("index1")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if key1 == key1renew {
+			t.Fatal("renewed index and the original one have the same key")
+		}
+		if key2 == key1renew {
+			t.Fatal("renewed index and the independent one have the same key")
+		}
+	})
+}