Use RepositoryPool instead of git.Repository

Signed-off-by: Javi Fontan <[email protected]>

Author: jfontan

blobs.go

@@ -3,16 +3,15 @@ package gitquery
 import (
 	"gopkg.in/src-d/go-mysql-server.v0/sql"
 
-	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/plumbing/object"
 )
 
 type blobsTable struct {
-	r *git.Repository
+	pool *RepositoryPool
 }
 
-func newBlobsTable(r *git.Repository) sql.Table {
-	return &blobsTable{r: r}
+func newBlobsTable(pool *RepositoryPool) sql.Table {
+	return &blobsTable{pool: pool}
 }
 
 func (blobsTable) Resolved() bool {
@@ -39,33 +38,49 @@ func (r *blobsTable) TransformExpressionsUp(f func(sql.Expression) sql.Expressio
 }
 
 func (r blobsTable) RowIter() (sql.RowIter, error) {
-	bIter, err := r.r.BlobObjects()
+	iter := &blobIter{}
+
+	rowRepoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
-	iter := &blobIter{i: bIter}
-	return iter, nil
+
+	return &rowRepoIter, nil
 }
 
 func (blobsTable) Children() []sql.Node {
 	return []sql.Node{}
 }
 
 type blobIter struct {
-	i *object.BlobIter
+	iter *object.BlobIter
+}
+
+func (i *blobIter) InitRepository(repo Repository) error {
+	iter, err := repo.Repo.BlobObjects()
+	if err != nil {
+		return err
+	}
+
+	i.iter = iter
+
+	return nil
 }
 
 func (i *blobIter) Next() (sql.Row, error) {
-	blob, err := i.i.Next()
+	o, err := i.iter.Next()
 	if err != nil {
 		return nil, err
 	}
 
-	return blobToRow(blob), nil
+	return blobToRow(o), nil
 }
 
 func (i *blobIter) Close() error {
-	i.i.Close()
+	if i.iter != nil {
+		i.iter.Close()
+	}
+
 	return nil
 }
 

cmd/gitquery/query_base.go

@@ -36,8 +36,11 @@ func (c *cmdQueryBase) buildDatabase() error {
 		return err
 	}
 
+	pool := gitquery.NewRepositoryPool()
+	pool.Add(c.Path, r)
+
 	c.name = filepath.Base(filepath.Join(c.Path, ".."))
-	c.engine.AddDatabase(gitquery.NewDatabase(c.name, r))
+	c.engine.AddDatabase(gitquery.NewDatabase(c.name, &pool))
 	return err
 }
 

commits.go

@@ -3,16 +3,15 @@ package gitquery
 import (
 	"gopkg.in/src-d/go-mysql-server.v0/sql"
 
-	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/plumbing/object"
 )
 
 type commitsTable struct {
-	r *git.Repository
+	pool *RepositoryPool
 }
 
-func newCommitsTable(r *git.Repository) sql.Table {
-	return &commitsTable{r: r}
+func newCommitsTable(pool *RepositoryPool) sql.Table {
+	return &commitsTable{pool: pool}
 }
 
 func (commitsTable) Resolved() bool {
@@ -45,32 +44,49 @@ func (r *commitsTable) TransformExpressionsUp(f func(sql.Expression) sql.Express
 }
 
 func (r commitsTable) RowIter() (sql.RowIter, error) {
-	cIter, err := r.r.CommitObjects()
+	iter := &commitIter{}
+
+	rowRepoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
-	iter := &commitIter{i: cIter}
-	return iter, nil
+
+	return &rowRepoIter, nil
 }
 
 func (commitsTable) Children() []sql.Node {
 	return []sql.Node{}
 }
 
 type commitIter struct {
-	i object.CommitIter
+	iter object.CommitIter
+}
+
+func (i *commitIter) InitRepository(repo Repository) error {
+	iter, err := repo.Repo.CommitObjects()
+	if err != nil {
+		return err
+	}
+
+	i.iter = iter
+
+	return nil
 }
 
 func (i *commitIter) Next() (sql.Row, error) {
-	commit, err := i.i.Next()
+	o, err := i.iter.Next()
 	if err != nil {
 		return nil, err
 	}
-	return commitToRow(commit), nil
+
+	return commitToRow(o), nil
 }
 
 func (i *commitIter) Close() error {
-	i.i.Close()
+	if i.iter != nil {
+		i.iter.Close()
+	}
+
 	return nil
 }
 

database.go

@@ -2,8 +2,6 @@ package gitquery
 
 import (
 	"gopkg.in/src-d/go-mysql-server.v0/sql"
-
-	"gopkg.in/src-d/go-git.v4"
 )
 
 const (
@@ -26,15 +24,15 @@ type Database struct {
 	or   sql.Table
 }
 
-func NewDatabase(name string, r *git.Repository) sql.Database {
+func NewDatabase(name string, pool *RepositoryPool) sql.Database {
 	return &Database{
 		name: name,
-		cr:   newCommitsTable(r),
-		rr:   newReferencesTable(r),
-		tr:   newTagsTable(r),
-		br:   newBlobsTable(r),
-		ter:  newTreeEntriesTable(r),
-		or:   newObjectsTable(r),
+		cr:   newCommitsTable(pool),
+		rr:   newReferencesTable(pool),
+		tr:   newTagsTable(pool),
+		br:   newBlobsTable(pool),
+		ter:  newTreeEntriesTable(pool),
+		or:   newObjectsTable(pool),
 	}
 }
 

database_test.go

@@ -64,7 +64,10 @@ func getDB(require *require.Assertions, fixture *fixtures.Fixture,
 	r, err := git.Open(s, memfs.New())
 	require.NoError(err)
 
-	db := NewDatabase(name, r)
+	pool := NewRepositoryPool()
+	pool.Add("repo", r)
+
+	db := NewDatabase(name, &pool)
 	require.NotNil(db)
 
 	return db

objects.go

@@ -3,16 +3,15 @@ package gitquery
 import (
 	"gopkg.in/src-d/go-mysql-server.v0/sql"
 
-	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/plumbing/object"
 )
 
 type objectsTable struct {
-	r *git.Repository
+	pool *RepositoryPool
 }
 
-func newObjectsTable(r *git.Repository) sql.Table {
-	return &objectsTable{r: r}
+func newObjectsTable(pool *RepositoryPool) sql.Table {
+	return &objectsTable{pool: pool}
 }
 
 func (objectsTable) Resolved() bool {
@@ -39,24 +38,37 @@ func (r *objectsTable) TransformExpressionsUp(f func(sql.Expression) sql.Express
 }
 
 func (r objectsTable) RowIter() (sql.RowIter, error) {
-	oIter, err := r.r.Objects()
+	iter := &objectIter{}
+
+	rowRepoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
-	iter := &objectIter{i: oIter}
-	return iter, nil
+
+	return &rowRepoIter, nil
 }
 
 func (objectsTable) Children() []sql.Node {
 	return []sql.Node{}
 }
 
 type objectIter struct {
-	i *object.ObjectIter
+	iter *object.ObjectIter
+}
+
+func (i *objectIter) InitRepository(repo Repository) error {
+	iter, err := repo.Repo.Objects()
+	if err != nil {
+		return err
+	}
+
+	i.iter = iter
+
+	return nil
 }
 
 func (i *objectIter) Next() (sql.Row, error) {
-	o, err := i.i.Next()
+	o, err := i.iter.Next()
 	if err != nil {
 		return nil, err
 	}
@@ -65,10 +77,12 @@ func (i *objectIter) Next() (sql.Row, error) {
 }
 
 func (i *objectIter) Close() error {
-	i.i.Close()
+	if i.iter != nil {
+		i.iter.Close()
+	}
+
 	return nil
 }
-
 func objectToRow(o object.Object) sql.Row {
 	return sql.NewRow(
 		o.ID().String(),

references.go

@@ -3,17 +3,16 @@ package gitquery
 import (
 	"gopkg.in/src-d/go-mysql-server.v0/sql"
 
-	"gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/plumbing"
 	"gopkg.in/src-d/go-git.v4/plumbing/storer"
 )
 
 type referencesTable struct {
-	r *git.Repository
+	pool *RepositoryPool
 }
 
-func newReferencesTable(r *git.Repository) sql.Table {
-	return &referencesTable{r: r}
+func newReferencesTable(pool *RepositoryPool) sql.Table {
+	return &referencesTable{pool: pool}
 }
 
 func (referencesTable) Resolved() bool {
@@ -46,33 +45,49 @@ func (r *referencesTable) TransformExpressionsUp(f func(sql.Expression) sql.Expr
 }
 
 func (r referencesTable) RowIter() (sql.RowIter, error) {
-	rIter, err := r.r.References()
+	iter := &referenceIter{}
+
+	rowRepoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
-	iter := &referenceIter{i: rIter}
-	return iter, nil
+
+	return &rowRepoIter, nil
 }
 
 func (referencesTable) Children() []sql.Node {
 	return []sql.Node{}
 }
 
 type referenceIter struct {
-	i storer.ReferenceIter
+	iter storer.ReferenceIter
+}
+
+func (i *referenceIter) InitRepository(repo Repository) error {
+	iter, err := repo.Repo.References()
+	if err != nil {
+		return err
+	}
+
+	i.iter = iter
+
+	return nil
 }
 
 func (i *referenceIter) Next() (sql.Row, error) {
-	reference, err := i.i.Next()
+	o, err := i.iter.Next()
 	if err != nil {
 		return nil, err
 	}
 
-	return referenceToRow(reference), nil
+	return referenceToRow(o), nil
 }
 
 func (i *referenceIter) Close() error {
-	i.i.Close()
+	if i.iter != nil {
+		i.iter.Close()
+	}
+
 	return nil
 }