@@ -40,7 +40,6 @@ import (

 	"github.com/docker/docker/libcontainerd"

 	"github.com/docker/docker/migrate/v1"

 	"github.com/docker/docker/pkg/fileutils"

-	"github.com/docker/docker/pkg/graphdb"

 	"github.com/docker/docker/pkg/idtools"

 	"github.com/docker/docker/pkg/plugingetter"

 	"github.com/docker/docker/pkg/progress"

@@ -158,7 +157,6 @@ func (daemon *Daemon) restore() error {

 		}

 	}

-	var migrateLegacyLinks bool

 	removeContainers := make(map[string]*container.Container)

 	restartContainers := make(map[*container.Container]chan struct{})

 	activeSandboxes := make(map[string]interface{})

@@ -190,6 +188,8 @@ func (daemon *Daemon) restore() error {

 			}

 		}

 	}

+

+	var migrateLegacyLinks bool // Not relevant on Windows

 	var wg sync.WaitGroup

 	var mapLock sync.Mutex

 	for _, c := range containers {

@@ -265,24 +265,15 @@ func (daemon *Daemon) restore() error {

 		return fmt.Errorf("Error initializing network controller: %v", err)

 	}

-	// migrate any legacy links from sqlite

-	linkdbFile := filepath.Join(daemon.root, "linkgraph.db")

-	var legacyLinkDB *graphdb.Database

+	// Perform migration of legacy sqlite links (no-op on Windows)

 	if migrateLegacyLinks {

-		legacyLinkDB, err = graphdb.NewSqliteConn(linkdbFile)

-		if err != nil {

-			return fmt.Errorf("error connecting to legacy link graph DB %s, container links may be lost: %v", linkdbFile, err)

+		if err := daemon.sqliteMigration(containers); err != nil {

+			return err

 		}

-		defer legacyLinkDB.Close()

 	}

 	// Now that all the containers are registered, register the links

 	for _, c := range containers {

-		if migrateLegacyLinks {

-			if err := daemon.migrateLegacySqliteLinks(legacyLinkDB, c); err != nil {

-				return err

-			}

-		}

 		if err := daemon.registerLinks(c, c.HostConfig); err != nil {

 			logrus.Errorf("failed to register link for container %s: %v", c.ID, err)

 		}

@@ -1,12 +1,9 @@

 package daemon

 import (

-	"strings"

 	"sync"

-	"github.com/Sirupsen/logrus"

 	"github.com/docker/docker/container"

-	"github.com/docker/docker/pkg/graphdb"

 )

 // linkIndex stores link relationships between containers, including their specified alias

@@ -88,41 +85,3 @@ func (l *linkIndex) delete(container *container.Container) {

 	delete(l.childIdx, container)

 	l.mu.Unlock()

 }

-

-// migrateLegacySqliteLinks migrates sqlite links to use links from HostConfig

-// when sqlite links were used, hostConfig.Links was set to nil

-func (daemon *Daemon) migrateLegacySqliteLinks(db *graphdb.Database, container *container.Container) error {

-	// if links is populated (or an empty slice), then this isn't using sqlite links and can be skipped

-	if container.HostConfig == nil || container.HostConfig.Links != nil {

-		return nil

-	}

-

-	logrus.Debugf("migrating legacy sqlite link info for container: %s", container.ID)

-

-	fullName := container.Name

-	if fullName[0] != '/' {

-		fullName = "/" + fullName

-	}

-

-	// don't use a nil slice, this ensures that the check above will skip once the migration has completed

-	links := []string{}

-	children, err := db.Children(fullName, 0)

-	if err != nil {

-		if !strings.Contains(err.Error(), "Cannot find child for") {

-			return err

-		}

-		// else continue... it's ok if we didn't find any children, it'll just be nil and we can continue the migration

-	}

-

-	for _, child := range children {

-		c, err := daemon.GetContainer(child.Entity.ID())

-		if err != nil {

-			return err

-		}

-

-		links = append(links, c.Name+":"+child.Edge.Name)

-	}

-

-	container.HostConfig.Links = links

-	return container.WriteHostConfig()

-}

new file mode 100644

@@ -0,0 +1,72 @@

+package daemon

+

+import (

+	"fmt"

+	"path/filepath"

+	"strings"

+

+	"github.com/Sirupsen/logrus"

+	"github.com/docker/docker/container"

+	"github.com/docker/docker/pkg/graphdb"

+)

+

+// migrateLegacySqliteLinks migrates sqlite links to use links from HostConfig

+// when sqlite links were used, hostConfig.Links was set to nil

+func (daemon *Daemon) migrateLegacySqliteLinks(db *graphdb.Database, container *container.Container) error {

+	// if links is populated (or an empty slice), then this isn't using sqlite links and can be skipped

+	if container.HostConfig == nil || container.HostConfig.Links != nil {

+		return nil

+	}

+

+	logrus.Debugf("migrating legacy sqlite link info for container: %s", container.ID)

+

+	fullName := container.Name

+	if fullName[0] != '/' {

+		fullName = "/" + fullName

+	}

+

+	// don't use a nil slice, this ensures that the check above will skip once the migration has completed

+	links := []string{}

+	children, err := db.Children(fullName, 0)

+	if err != nil {

+		if !strings.Contains(err.Error(), "Cannot find child for") {

+			return err

+		}

+		// else continue... it's ok if we didn't find any children, it'll just be nil and we can continue the migration

+	}

+

+	for _, child := range children {

+		c, err := daemon.GetContainer(child.Entity.ID())

+		if err != nil {

+			return err

+		}

+

+		links = append(links, c.Name+":"+child.Edge.Name)

+	}

+

+	container.HostConfig.Links = links

+	return container.WriteHostConfig()

+}

+

+// sqliteMigration performs the link graph DB migration.

+func (daemon *Daemon) sqliteMigration(containers map[string]*container.Container) error {

+	// migrate any legacy links from sqlite

+	linkdbFile := filepath.Join(daemon.root, "linkgraph.db")

+	var (

+		legacyLinkDB *graphdb.Database

+		err          error

+	)

+

+	legacyLinkDB, err = graphdb.NewSqliteConn(linkdbFile)

+	if err != nil {

+		return fmt.Errorf("error connecting to legacy link graph DB %s, container links may be lost: %v", linkdbFile, err)

+	}

+	defer legacyLinkDB.Close()

+

+	for _, c := range containers {

+		if err := daemon.migrateLegacySqliteLinks(legacyLinkDB, c); err != nil {

+			return err

+		}

+	}

+	return nil

+}

new file mode 100644

@@ -0,0 +1,98 @@

+package daemon

+

+import (

+	"encoding/json"

+	"io/ioutil"

+	"os"

+	"path"

+	"path/filepath"

+	"testing"

+

+	containertypes "github.com/docker/docker/api/types/container"

+	"github.com/docker/docker/container"

+	"github.com/docker/docker/pkg/graphdb"

+	"github.com/docker/docker/pkg/stringid"

+)

+

+func TestMigrateLegacySqliteLinks(t *testing.T) {

+	tmpDir, err := ioutil.TempDir("", "legacy-qlite-links-test")

+	if err != nil {

+		t.Fatal(err)

+	}

+	defer os.RemoveAll(tmpDir)

+

+	name1 := "test1"

+	c1 := &container.Container{

+		CommonContainer: container.CommonContainer{

+			ID:         stringid.GenerateNonCryptoID(),

+			Name:       name1,

+			HostConfig: &containertypes.HostConfig{},

+		},

+	}

+	c1.Root = tmpDir

+

+	name2 := "test2"

+	c2 := &container.Container{

+		CommonContainer: container.CommonContainer{

+			ID:   stringid.GenerateNonCryptoID(),

+			Name: name2,

+		},

+	}

+

+	store := container.NewMemoryStore()

+	store.Add(c1.ID, c1)

+	store.Add(c2.ID, c2)

+

+	d := &Daemon{root: tmpDir, containers: store}

+	db, err := graphdb.NewSqliteConn(filepath.Join(d.root, "linkgraph.db"))

+	if err != nil {

+		t.Fatal(err)

+	}

+

+	if _, err := db.Set("/"+name1, c1.ID); err != nil {

+		t.Fatal(err)

+	}

+

+	if _, err := db.Set("/"+name2, c2.ID); err != nil {

+		t.Fatal(err)

+	}

+

+	alias := "hello"

+	if _, err := db.Set(path.Join(c1.Name, alias), c2.ID); err != nil {

+		t.Fatal(err)

+	}

+

+	if err := d.migrateLegacySqliteLinks(db, c1); err != nil {

+		t.Fatal(err)

+	}

+

+	if len(c1.HostConfig.Links) != 1 {

+		t.Fatal("expected links to be populated but is empty")

+	}

+

+	expected := name2 + ":" + alias

+	actual := c1.HostConfig.Links[0]

+	if actual != expected {

+		t.Fatalf("got wrong link value, expected: %q, got: %q", expected, actual)

+	}

+

+	// ensure this is persisted

+	b, err := ioutil.ReadFile(filepath.Join(c1.Root, "hostconfig.json"))

+	if err != nil {

+		t.Fatal(err)

+	}

+	type hc struct {

+		Links []string

+	}

+	var cfg hc

+	if err := json.Unmarshal(b, &cfg); err != nil {

+		t.Fatal(err)

+	}

+

+	if len(cfg.Links) != 1 {

+		t.Fatalf("expected one entry in links, got: %d", len(cfg.Links))

+	}

+	if cfg.Links[0] != expected { // same expected as above

+		t.Fatalf("got wrong link value, expected: %q, got: %q", expected, cfg.Links[0])

+	}

+}

new file mode 100644

@@ -0,0 +1,10 @@

+// +build !linux

+

+package daemon

+

+import "github.com/docker/docker/container"

+

+// sqliteMigration performs the link graph DB migration. No-op on platforms other than Linux

+func (daemon *Daemon) sqliteMigration(_ map[string]*container.Container) error {

+	return nil

+}

deleted file mode 100644

@@ -1,98 +0,0 @@

-package daemon

-

-import (

-	"encoding/json"

-	"io/ioutil"

-	"os"

-	"path"

-	"path/filepath"

-	"testing"

-

-	containertypes "github.com/docker/docker/api/types/container"

-	"github.com/docker/docker/container"

-	"github.com/docker/docker/pkg/graphdb"

-	"github.com/docker/docker/pkg/stringid"

-)

-

-func TestMigrateLegacySqliteLinks(t *testing.T) {

-	tmpDir, err := ioutil.TempDir("", "legacy-qlite-links-test")

-	if err != nil {

-		t.Fatal(err)

-	}

-	defer os.RemoveAll(tmpDir)

-

-	name1 := "test1"

-	c1 := &container.Container{

-		CommonContainer: container.CommonContainer{

-			ID:         stringid.GenerateNonCryptoID(),

-			Name:       name1,

-			HostConfig: &containertypes.HostConfig{},

-		},

-	}

-	c1.Root = tmpDir

-

-	name2 := "test2"

-	c2 := &container.Container{

-		CommonContainer: container.CommonContainer{

-			ID:   stringid.GenerateNonCryptoID(),

-			Name: name2,

-		},

-	}

-

-	store := container.NewMemoryStore()

-	store.Add(c1.ID, c1)

-	store.Add(c2.ID, c2)

-

-	d := &Daemon{root: tmpDir, containers: store}

-	db, err := graphdb.NewSqliteConn(filepath.Join(d.root, "linkgraph.db"))

-	if err != nil {

-		t.Fatal(err)

-	}

-

-	if _, err := db.Set("/"+name1, c1.ID); err != nil {

-		t.Fatal(err)

-	}

-

-	if _, err := db.Set("/"+name2, c2.ID); err != nil {

-		t.Fatal(err)

-	}

-

-	alias := "hello"

-	if _, err := db.Set(path.Join(c1.Name, alias), c2.ID); err != nil {

-		t.Fatal(err)

-	}

-

-	if err := d.migrateLegacySqliteLinks(db, c1); err != nil {

-		t.Fatal(err)

-	}

-

-	if len(c1.HostConfig.Links) != 1 {

-		t.Fatal("expected links to be populated but is empty")

-	}

-

-	expected := name2 + ":" + alias

-	actual := c1.HostConfig.Links[0]

-	if actual != expected {

-		t.Fatalf("got wrong link value, expected: %q, got: %q", expected, actual)

-	}

-

-	// ensure this is persisted

-	b, err := ioutil.ReadFile(filepath.Join(c1.Root, "hostconfig.json"))

-	if err != nil {

-		t.Fatal(err)

-	}

-	type hc struct {

-		Links []string

-	}

-	var cfg hc

-	if err := json.Unmarshal(b, &cfg); err != nil {

-		t.Fatal(err)

-	}

-

-	if len(cfg.Links) != 1 {

-		t.Fatalf("expected one entry in links, got: %d", len(cfg.Links))

-	}

-	if cfg.Links[0] != expected { // same expected as above

-		t.Fatalf("got wrong link value, expected: %q, got: %q", expected, cfg.Links[0])

-	}

-}

deleted file mode 100644

@@ -1,15 +0,0 @@

-// +build cgo

-

-package graphdb

-

-import "database/sql"

-

-// NewSqliteConn opens a connection to a sqlite

-// database.

-func NewSqliteConn(root string) (*Database, error) {

-	conn, err := sql.Open("sqlite3", root)

-	if err != nil {

-		return nil, err

-	}

-	return NewDatabase(conn)

-}

new file mode 100644

@@ -0,0 +1,19 @@

+// +build cgo

+

+package graphdb

+

+import (

+	"database/sql"

+

+	_ "github.com/mattn/go-sqlite3" // registers sqlite

+)

+

+// NewSqliteConn opens a connection to a sqlite

+// database.

+func NewSqliteConn(root string) (*Database, error) {

+	conn, err := sql.Open("sqlite3", root)

+	if err != nil {

+		return nil, err

+	}

+	return NewDatabase(conn)

+}

deleted file mode 100644

@@ -1,7 +0,0 @@

-// +build cgo,!windows

-

-package graphdb

-

-import (

-	_ "github.com/mattn/go-sqlite3" // registers sqlite

-)

deleted file mode 100644

@@ -1,7 +0,0 @@

-// +build cgo,windows

-

-package graphdb

-

-import (

-	_ "github.com/mattn/go-sqlite3" // registers sqlite

-)

deleted file mode 100644

@@ -1,8 +0,0 @@

-// +build !cgo

-

-package graphdb

-

-// NewSqliteConn return a new sqlite connection.

-func NewSqliteConn(root string) (*Database, error) {

-	panic("Not implemented")

-}

deleted file mode 100644

@@ -1,551 +0,0 @@

-package graphdb

-

-import (

-	"database/sql"

-	"fmt"

-	"path"

-	"strings"

-	"sync"

-)

-

-const (

-	createEntityTable = `

-    CREATE TABLE IF NOT EXISTS entity (

-        id text NOT NULL PRIMARY KEY

-    );`

-

-	createEdgeTable = `

-    CREATE TABLE IF NOT EXISTS edge (

-        "entity_id" text NOT NULL,

-        "parent_id" text NULL,

-        "name" text NOT NULL,

-        CONSTRAINT "parent_fk" FOREIGN KEY ("parent_id") REFERENCES "entity" ("id"),

-        CONSTRAINT "entity_fk" FOREIGN KEY ("entity_id") REFERENCES "entity" ("id")

-        );

-    `

-

-	createEdgeIndices = `

-    CREATE UNIQUE INDEX IF NOT EXISTS "name_parent_ix" ON "edge" (parent_id, name);

-    `

-)

-

-// Entity with a unique id.

-type Entity struct {

-	id string

-}

-

-// An Edge connects two entities together.

-type Edge struct {

-	EntityID string

-	Name     string

-	ParentID string

-}

-

-// Entities stores the list of entities.

-type Entities map[string]*Entity

-

-// Edges stores the relationships between entities.

-type Edges []*Edge

-

-// WalkFunc is a function invoked to process an individual entity.

-type WalkFunc func(fullPath string, entity *Entity) error

-

-// Database is a graph database for storing entities and their relationships.

-type Database struct {

-	conn *sql.DB

-	mux  sync.RWMutex

-}

-

-// IsNonUniqueNameError processes the error to check if it's caused by

-// a constraint violation.

-// This is necessary because the error isn't the same across various

-// sqlite versions.

-func IsNonUniqueNameError(err error) bool {

-	str := err.Error()

-	// sqlite 3.7.17-1ubuntu1 returns:

-	// Set failure: Abort due to constraint violation: columns parent_id, name are not unique

-	if strings.HasSuffix(str, "name are not unique") {

-		return true

-	}

-	// sqlite-3.8.3-1.fc20 returns:

-	// Set failure: Abort due to constraint violation: UNIQUE constraint failed: edge.parent_id, edge.name

-	if strings.Contains(str, "UNIQUE constraint failed") && strings.Contains(str, "edge.name") {

-		return true

-	}

-	// sqlite-3.6.20-1.el6 returns:

-	// Set failure: Abort due to constraint violation: constraint failed

-	if strings.HasSuffix(str, "constraint failed") {

-		return true

-	}

-	return false

-}

-

-// NewDatabase creates a new graph database initialized with a root entity.

-func NewDatabase(conn *sql.DB) (*Database, error) {

-	if conn == nil {

-		return nil, fmt.Errorf("Database connection cannot be nil")

-	}

-	db := &Database{conn: conn}

-

-	// Create root entities

-	tx, err := conn.Begin()

-	if err != nil {

-		return nil, err

-	}

-

-	if _, err := tx.Exec(createEntityTable); err != nil {

-		return nil, err

-	}

-	if _, err := tx.Exec(createEdgeTable); err != nil {

-		return nil, err

-	}

-	if _, err := tx.Exec(createEdgeIndices); err != nil {

-		return nil, err

-	}

-

-	if _, err := tx.Exec("DELETE FROM entity where id = ?", "0"); err != nil {

-		tx.Rollback()

-		return nil, err

-	}

-

-	if _, err := tx.Exec("INSERT INTO entity (id) VALUES (?);", "0"); err != nil {

-		tx.Rollback()

-		return nil, err

-	}

-

-	if _, err := tx.Exec("DELETE FROM edge where entity_id=? and name=?", "0", "/"); err != nil {

-		tx.Rollback()

-		return nil, err

-	}

-

-	if _, err := tx.Exec("INSERT INTO edge (entity_id, name) VALUES(?,?);", "0", "/"); err != nil {

-		tx.Rollback()

-		return nil, err

-	}

-

-	if err := tx.Commit(); err != nil {

-		return nil, err

-	}

-

-	return db, nil

-}

-

-// Close the underlying connection to the database.

-func (db *Database) Close() error {

-	return db.conn.Close()

-}

-

-// Set the entity id for a given path.

-func (db *Database) Set(fullPath, id string) (*Entity, error) {

-	db.mux.Lock()

-	defer db.mux.Unlock()

-

-	tx, err := db.conn.Begin()

-	if err != nil {

-		return nil, err

-	}

-

-	var entityID string

-	if err := tx.QueryRow("SELECT id FROM entity WHERE id = ?;", id).Scan(&entityID); err != nil {

-		if err == sql.ErrNoRows {

-			if _, err := tx.Exec("INSERT INTO entity (id) VALUES(?);", id); err != nil {

-				tx.Rollback()

-				return nil, err

-			}

-		} else {

-			tx.Rollback()

-			return nil, err

-		}

-	}

-	e := &Entity{id}

-

-	parentPath, name := splitPath(fullPath)

-	if err := db.setEdge(parentPath, name, e, tx); err != nil {

-		tx.Rollback()

-		return nil, err

-	}

-

-	if err := tx.Commit(); err != nil {

-		return nil, err

-	}

-	return e, nil

-}

-

-// Exists returns true if a name already exists in the database.

-func (db *Database) Exists(name string) bool {

-	db.mux.RLock()

-	defer db.mux.RUnlock()

-

-	e, err := db.get(name)

-	if err != nil {

-		return false

-	}

-	return e != nil

-}

-

-func (db *Database) setEdge(parentPath, name string, e *Entity, tx *sql.Tx) error {

-	parent, err := db.get(parentPath)

-	if err != nil {

-		return err

-	}

-	if parent.id == e.id {

-		return fmt.Errorf("Cannot set self as child")

-	}

-

-	if _, err := tx.Exec("INSERT INTO edge (parent_id, name, entity_id) VALUES (?,?,?);", parent.id, name, e.id); err != nil {

-		return err

-	}

-	return nil

-}

-

-// RootEntity returns the root "/" entity for the database.

-func (db *Database) RootEntity() *Entity {

-	return &Entity{

-		id: "0",

-	}

-}

-

-// Get returns the entity for a given path.

-func (db *Database) Get(name string) *Entity {

-	db.mux.RLock()

-	defer db.mux.RUnlock()

-

-	e, err := db.get(name)

-	if err != nil {

-		return nil

-	}

-	return e

-}

-

-func (db *Database) get(name string) (*Entity, error) {

-	e := db.RootEntity()

-	// We always know the root name so return it if

-	// it is requested

-	if name == "/" {

-		return e, nil

-	}

-

-	parts := split(name)

-	for i := 1; i < len(parts); i++ {

-		p := parts[i]

-		if p == "" {

-			continue

-		}

-

-		next := db.child(e, p)

-		if next == nil {

-			return nil, fmt.Errorf("Cannot find child for %s", name)

-		}

-		e = next

-	}

-	return e, nil

-

-}

-

-// List all entities by from the name.

-// The key will be the full path of the entity.

-func (db *Database) List(name string, depth int) Entities {

-	db.mux.RLock()

-	defer db.mux.RUnlock()

-

-	out := Entities{}

-	e, err := db.get(name)

-	if err != nil {

-		return out

-	}

-

-	children, err := db.children(e, name, depth, nil)

-	if err != nil {

-		return out

-	}

-

-	for _, c := range children {

-		out[c.FullPath] = c.Entity

-	}

-	return out

-}

-

-// Walk through the child graph of an entity, calling walkFunc for each child entity.

-// It is safe for walkFunc to call graph functions.

-func (db *Database) Walk(name string, walkFunc WalkFunc, depth int) error {

-	children, err := db.Children(name, depth)

-	if err != nil {

-		return err

-	}

-

-	// Note: the database lock must not be held while calling walkFunc

-	for _, c := range children {

-		if err := walkFunc(c.FullPath, c.Entity); err != nil {

-			return err

-		}

-	}

-	return nil

-}

-

-// Children returns the children of the specified entity.

-func (db *Database) Children(name string, depth int) ([]WalkMeta, error) {

-	db.mux.RLock()

-	defer db.mux.RUnlock()

-

-	e, err := db.get(name)

-	if err != nil {

-		return nil, err

-	}

-

-	return db.children(e, name, depth, nil)

-}

-

-// Parents returns the parents of a specified entity.

-func (db *Database) Parents(name string) ([]string, error) {

-	db.mux.RLock()

-	defer db.mux.RUnlock()

-

-	e, err := db.get(name)

-	if err != nil {

-		return nil, err

-	}

-	return db.parents(e)

-}

-

-// Refs returns the reference count for a specified id.

-func (db *Database) Refs(id string) int {

-	db.mux.RLock()

-	defer db.mux.RUnlock()

-

-	var count int

-	if err := db.conn.QueryRow("SELECT COUNT(*) FROM edge WHERE entity_id = ?;", id).Scan(&count); err != nil {

-		return 0

-	}

-	return count

-}

-

-// RefPaths returns all the id's path references.

-func (db *Database) RefPaths(id string) Edges {

-	db.mux.RLock()

-	defer db.mux.RUnlock()

-

-	refs := Edges{}

-

-	rows, err := db.conn.Query("SELECT name, parent_id FROM edge WHERE entity_id = ?;", id)

-	if err != nil {

-		return refs

-	}

-	defer rows.Close()

-

-	for rows.Next() {

-		var name string

-		var parentID string

-		if err := rows.Scan(&name, &parentID); err != nil {

-			return refs

-		}

-		refs = append(refs, &Edge{

-			EntityID: id,

-			Name:     name,

-			ParentID: parentID,

-		})

-	}

-	return refs

-}

-

-// Delete the reference to an entity at a given path.

-func (db *Database) Delete(name string) error {

-	db.mux.Lock()

-	defer db.mux.Unlock()

-

-	if name == "/" {

-		return fmt.Errorf("Cannot delete root entity")

-	}

-

-	parentPath, n := splitPath(name)

-	parent, err := db.get(parentPath)

-	if err != nil {

-		return err

-	}

-

-	if _, err := db.conn.Exec("DELETE FROM edge WHERE parent_id = ? AND name = ?;", parent.id, n); err != nil {

-		return err

-	}

-	return nil

-}

-

-// Purge removes the entity with the specified id

-// Walk the graph to make sure all references to the entity

-// are removed and return the number of references removed

-func (db *Database) Purge(id string) (int, error) {

-	db.mux.Lock()

-	defer db.mux.Unlock()

-

-	tx, err := db.conn.Begin()

-	if err != nil {

-		return -1, err

-	}

-

-	// Delete all edges

-	rows, err := tx.Exec("DELETE FROM edge WHERE entity_id = ?;", id)

-	if err != nil {

-		tx.Rollback()

-		return -1, err

-	}

-	changes, err := rows.RowsAffected()

-	if err != nil {

-		return -1, err

-	}

-

-	// Clear who's using this id as parent

-	refs, err := tx.Exec("DELETE FROM edge WHERE parent_id = ?;", id)

-	if err != nil {

-		tx.Rollback()

-		return -1, err

-	}

-	refsCount, err := refs.RowsAffected()

-	if err != nil {

-		return -1, err