internal/function: add cache for history_idx

This commit adds a LRU cache to the history_idx function, caching the indexes in which a commit is from another in the history.

Before:

BenchmarkHistoryIdx/history_idx-4                   2000            789749 ns/op          415896 B/op       1519 allocs/op
PASS
ok      github.com/src-d/gitquery/internal/function     2.189s

After:

BenchmarkHistoryIdx/history_idx-4                1000000              1063 ns/op             256 B/op          9 allocs/op
PASS
ok      github.com/src-d/gitquery/internal/function     1.607s

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

Author: erizocosmico

internal/function/history_idx.go

@@ -4,6 +4,8 @@ import (
 	"fmt"
 	"io"
 
+	"github.com/hashicorp/golang-lru"
+
 	"github.com/src-d/gitquery"
 	git "gopkg.in/src-d/go-git.v4"
 	"gopkg.in/src-d/go-git.v4/plumbing"
@@ -15,17 +17,25 @@ import (
 // of another commit.
 type HistoryIdx struct {
 	expression.BinaryExpression
+	cache *lru.ARCCache
 }
 
+const historyIdxCacheSize = 300
+
 // NewHistoryIdx creates a new HistoryIdx udf.
 func NewHistoryIdx(start, target sql.Expression) sql.Expression {
-	return &HistoryIdx{expression.BinaryExpression{Left: start, Right: target}}
+	cache, _ := lru.NewARC(historyIdxCacheSize)
+	return &HistoryIdx{expression.BinaryExpression{Left: start, Right: target}, cache}
 }
 
 func (f HistoryIdx) String() string {
 	return fmt.Sprintf("history_idx(%s, %s)", f.Left, f.Right)
 }
 
+type historyKey struct {
+	start, target plumbing.Hash
+}
+
 // Eval implements the Expression interface.
 func (f *HistoryIdx) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	s, ok := ctx.Session.(*gitquery.Session)
@@ -64,6 +74,10 @@ func (f *HistoryIdx) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	start := plumbing.NewHash(left.(string))
 	target := plumbing.NewHash(right.(string))
 
+	if val, ok := f.cache.Get(historyKey{start, target}); ok {
+		return val.(int64), nil
+	}
+
 	// fast path for equal hashes
 	if start == target {
 		return int64(0), nil
@@ -131,6 +145,7 @@ func (f *HistoryIdx) repoHistoryIdx(repo *git.Repository, start, target plumbing
 
 	for {
 		if len(stack) == 0 {
+			f.cache.Add(historyKey{start, target}, int64(-1))
 			return -1, nil
 		}
 
@@ -152,6 +167,8 @@ func (f *HistoryIdx) repoHistoryIdx(repo *git.Repository, start, target plumbing
 
 		frame.pos++
 
+		f.cache.Add(historyKey{start, c.Hash}, frame.idx)
+
 		if c.Hash == target {
 			return frame.idx, nil
 		}

internal/function/history_idx_test.go

@@ -63,3 +63,57 @@ func TestHistoryIdx(t *testing.T) {
 		})
 	}
 }
+
+func BenchmarkHistoryIdx(b *testing.B) {
+	require.NoError(b, fixtures.Init())
+	defer func() {
+		require.NoError(b, fixtures.Clean())
+	}()
+
+	f := NewHistoryIdx(
+		expression.NewGetField(0, sql.Text, "start", true),
+		expression.NewGetField(1, sql.Text, "target", 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)
+
+	cases := []struct {
+		row sql.Row
+		idx int64
+	}{
+		{
+			sql.NewRow("b029517f6300c2da0f4b651b8642506cd6aaf45d", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"),
+			-1,
+		},
+		{
+			sql.NewRow("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "b029517f6300c2da0f4b651b8642506cd6aaf45d"),
+			5,
+		},
+		{
+			sql.NewRow("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "b8e471f58bcbca63b07bda20e428190409c2db47"),
+			5,
+		},
+		{
+			sql.NewRow("b685400c1f9316f350965a5993d350bc746b0bf4", "c7431b5bc9d45fb64a87d4a895ce3d1073c898d2"),
+			3,
+		},
+	}
+
+	n := len(cases)
+	b.Run("history_idx", func(b *testing.B) {
+		require := require.New(b)
+
+		for i := 0; i < b.N; i++ {
+			cs := cases[i%n]
+			val, err := f.Eval(ctx, cs.row)
+			require.NoError(err)
+			require.Equal(cs.idx, val)
+		}
+	})
+}