Merge pull request #15 from jfontan/repository-pool

Repository pool

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,47 @@ func (r *blobsTable) TransformExpressionsUp(f func(sql.Expression) sql.Expressio
 }
 
 func (r blobsTable) RowIter() (sql.RowIter, error) {
-	bIter, err := r.r.BlobObjects()
+	iter := &blobIter{}
+
+	repoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
-	iter := &blobIter{i: bIter}
-	return iter, nil
+
+	return repoIter, nil
 }
 
 func (blobsTable) Children() []sql.Node {
 	return []sql.Node{}
 }
 
 type blobIter struct {
-	i *object.BlobIter
+	iter *object.BlobIter
+}
+
+func (i *blobIter) NewIterator(repo *Repository) (RowRepoIter, error) {
+	iter, err := repo.Repo.BlobObjects()
+	if err != nil {
+		return nil, err
+	}
+
+	return &blobIter{iter: iter}, 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

@@ -3,12 +3,10 @@ package main
 import (
 	"io"
 	"os"
-	"path/filepath"
 
 	"github.com/src-d/gitquery"
 	"github.com/src-d/gitquery/internal/format"
 
-	gogit "gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/utils/ioutil"
 	sqle "gopkg.in/src-d/go-mysql-server.v0"
 	"gopkg.in/src-d/go-mysql-server.v0/sql"
@@ -17,7 +15,7 @@ import (
 type cmdQueryBase struct {
 	cmd
 
-	Path string `short:"p" long:"path" description:"Path where the git repository is located"`
+	Path string `short:"p" long:"path" description:"Path where the git repositories are located, one per dir"`
 
 	engine *sqle.Engine
 	name   string
@@ -31,13 +29,15 @@ func (c *cmdQueryBase) buildDatabase() error {
 	c.print("opening %q repository...\n", c.Path)
 
 	var err error
-	r, err := gogit.PlainOpen(c.Path)
+
+	pool := gitquery.NewRepositoryPool()
+	err = pool.AddDir(c.Path)
 	if err != nil {
+		println("ERR", err.Error())
 		return err
 	}
 
-	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,47 @@ func (r *commitsTable) TransformExpressionsUp(f func(sql.Expression) sql.Express
 }
 
 func (r commitsTable) RowIter() (sql.RowIter, error) {
-	cIter, err := r.r.CommitObjects()
+	iter := &commitIter{}
+
+	repoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
-	iter := &commitIter{i: cIter}
-	return iter, nil
+
+	return repoIter, nil
 }
 
 func (commitsTable) Children() []sql.Node {
 	return []sql.Node{}
 }
 
 type commitIter struct {
-	i object.CommitIter
+	iter object.CommitIter
+}
+
+func (i *commitIter) NewIterator(repo *Repository) (RowRepoIter, error) {
+	iter, err := repo.Repo.CommitObjects()
+	if err != nil {
+		return nil, err
+	}
+
+	return &commitIter{iter: iter}, 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,35 @@ func (r *objectsTable) TransformExpressionsUp(f func(sql.Expression) sql.Express
 }
 
 func (r objectsTable) RowIter() (sql.RowIter, error) {
-	oIter, err := r.r.Objects()
+	iter := &objectIter{}
+
+	repoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
-	iter := &objectIter{i: oIter}
-	return iter, nil
+
+	return repoIter, nil
 }
 
 func (objectsTable) Children() []sql.Node {
 	return []sql.Node{}
 }
 
 type objectIter struct {
-	i *object.ObjectIter
+	iter *object.ObjectIter
+}
+
+func (i *objectIter) NewIterator(repo *Repository) (RowRepoIter, error) {
+	iter, err := repo.Repo.Objects()
+	if err != nil {
+		return nil, err
+	}
+
+	return &objectIter{iter: iter}, 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 +75,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,47 @@ func (r *referencesTable) TransformExpressionsUp(f func(sql.Expression) sql.Expr
 }
 
 func (r referencesTable) RowIter() (sql.RowIter, error) {
-	rIter, err := r.r.References()
+	iter := &referenceIter{}
+
+	repoIter, err := NewRowRepoIter(r.pool, iter)
 	if err != nil {
 		return nil, err
 	}
-	iter := &referenceIter{i: rIter}
-	return iter, nil
+
+	return repoIter, nil
 }
 
 func (referencesTable) Children() []sql.Node {
 	return []sql.Node{}
 }
 
 type referenceIter struct {
-	i storer.ReferenceIter
+	iter storer.ReferenceIter
+}
+
+func (i *referenceIter) NewIterator(repo *Repository) (RowRepoIter, error) {
+	iter, err := repo.Repo.References()
+	if err != nil {
+		return nil, err
+	}
+
+	return &referenceIter{iter: iter}, 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
 }