internal/function: add cache to commit_has_tree

Adds an LRU cache to commit_has_tree so it does not have to go to disk all the time to check if a tree is inside a commit or not.

Before:

BenchmarkCommitHasTree/commit_has_tree-4                    3000            519234 ns/op          297322 B/op       1276 allocs/op
PASS
ok      github.com/src-d/gitquery/internal/function     2.154s

After:

BenchmarkCommitHasTree/commit_has_tree-4                 1000000              1036 ns/op             240 B/op          7 allocs/op
PASS
ok      github.com/src-d/gitquery/internal/function     1.593s

Signed-off-by: Miguel Molina <[email protected]>

Author: erizocosmico

internal/function/commit_has_tree.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"io"
 
+	"github.com/hashicorp/golang-lru"
+
 	"gopkg.in/src-d/go-git.v4/plumbing/filemode"
 	"gopkg.in/src-d/go-git.v4/plumbing/object"
 
@@ -18,14 +20,21 @@ import (
 // or not.
 type CommitHasTree struct {
 	expression.BinaryExpression
+	cache *lru.ARCCache
 }
 
+// TODO: set as config
+const commitHasTreeCacheSize = 100
+
 // NewCommitHasTree creates a new CommitHasTree function.
 func NewCommitHasTree(commit, tree sql.Expression) sql.Expression {
+	// NewARC can only fail if size is negative, and we know it is not,
+	// so it is safe to ignore the error here.
+	cache, _ := lru.NewARC(commitHasTreeCacheSize)
 	return &CommitHasTree{expression.BinaryExpression{
 		Left:  commit,
 		Right: tree,
-	}}
+	}, cache}
 }
 
 func (f CommitHasTree) String() string {
@@ -73,6 +82,10 @@ func (f *CommitHasTree) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
 	commitHash := plumbing.NewHash(left.(string))
 	treeHash := plumbing.NewHash(right.(string))
 
+	if val, ok := f.cache.Get(cacheKey{commitHash, treeHash}); ok {
+		return val.(bool), nil
+	}
+
 	iter, err := s.Pool.RepoIter()
 	if err != nil {
 		return nil, err
@@ -88,7 +101,7 @@ func (f *CommitHasTree) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
 			return nil, err
 		}
 
-		ok, err := commitHasTree(repo.Repo, commitHash, treeHash)
+		ok, err := f.commitHasTree(repo.Repo, commitHash, treeHash)
 		if err == plumbing.ErrObjectNotFound {
 			continue
 		}
@@ -97,7 +110,12 @@ func (f *CommitHasTree) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
 	}
 }
 
-func commitHasTree(
+type cacheKey struct {
+	commit plumbing.Hash
+	tree   plumbing.Hash
+}
+
+func (f *CommitHasTree) commitHasTree(
 	repo *git.Repository,
 	commitHash, treeHash plumbing.Hash,
 ) (bool, error) {
@@ -106,6 +124,8 @@ func commitHasTree(
 		return false, err
 	}
 
+	f.cache.Add(cacheKey{commitHash, commit.TreeHash}, true)
+
 	if commit.TreeHash == treeHash {
 		return true, nil
 	}
@@ -115,13 +135,13 @@ func commitHasTree(
 		return false, err
 	}
 
-	return treeInEntries(repo, tree.Entries, treeHash)
+	return f.treeInEntries(repo, tree.Entries, commitHash, treeHash)
 }
 
-func treeInEntries(
+func (f *CommitHasTree) treeInEntries(
 	repo *git.Repository,
 	entries []object.TreeEntry,
-	hash plumbing.Hash,
+	commitHash, hash plumbing.Hash,
 ) (bool, error) {
 	type stackFrame struct {
 		pos     int
@@ -131,6 +151,7 @@ func treeInEntries(
 
 	for {
 		if len(stack) == 0 {
+			f.cache.Add(cacheKey{commitHash, hash}, false)
 			return false, nil
 		}
 
@@ -143,6 +164,7 @@ func treeInEntries(
 		entry := frame.entries[frame.pos]
 		frame.pos++
 		if entry.Mode == filemode.Dir {
+			f.cache.Add(cacheKey{commitHash, entry.Hash}, true)
 			if entry.Hash == hash {
 				return true, nil
 			}

internal/function/commit_has_tree_test.go

@@ -56,3 +56,44 @@ func TestCommitHasTree(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkCommitHasTree(b *testing.B) {
+	require.NoError(b, fixtures.Init())
+	defer func() {
+		require.NoError(b, fixtures.Clean())
+	}()
+
+	f := NewCommitHasTree(
+		expression.NewGetField(0, sql.Text, "commit_hash", true),
+		expression.NewGetField(1, sql.Text, "tree_hash", true),
+	)
+
+	pool := gitquery.NewRepositoryPool()
+	for _, f := range fixtures.ByTag("worktree") {
+		pool.AddGit(f.Worktree().Root())
+	}
+
+	session := gitquery.NewSession(&pool)
+	ctx := sql.NewContext(context.TODO(), session)
+
+	rows := []sql.Row{
+		// tree is not on commit
+		sql.NewRow("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "c2d30fa8ef288618f65f6eed6e168e0d514886f4"),
+		// subtree is on commit
+		sql.NewRow("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "5a877e6a906a2743ad6e45d99c1793642aaf8eda"),
+	}
+
+	b.Run("commit_has_tree", func(b *testing.B) {
+		require := require.New(b)
+
+		for i := 0; i < b.N; i++ {
+			val, err := f.Eval(ctx, rows[i%2])
+			require.NoError(err)
+			if i%2 == 1 {
+				require.Equal(true, val)
+			} else {
+				require.Equal(false, val)
+			}
+		}
+	})
+}