Merge pull request #151 from erizocosmico/feature/history_idx-udf

Feature/history idx udf

Author: erizocosmico

internal/function/history_idx.go

@@ -0,0 +1,177 @@
+package function
+
+import (
+	"io"
+
+	"github.com/src-d/gitquery"
+	git "gopkg.in/src-d/go-git.v4"
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+	"gopkg.in/src-d/go-mysql-server.v0/sql/expression"
+)
+
+// HistoryIdx is a function that returns the index of a commit in the history
+// of another commit.
+type HistoryIdx struct {
+	expression.BinaryExpression
+}
+
+// NewHistoryIdx creates a new HistoryIdx udf.
+func NewHistoryIdx(start, target sql.Expression) sql.Expression {
+	return &HistoryIdx{expression.BinaryExpression{Left: start, Right: target}}
+}
+
+// Name implements the Expression interface.
+func (HistoryIdx) Name() string { return "history_idx" }
+
+// Eval implements the Expression interface.
+func (f *HistoryIdx) Eval(session sql.Session, row sql.Row) (interface{}, error) {
+	s, ok := session.(*gitquery.Session)
+	if !ok {
+		return nil, gitquery.ErrInvalidGitQuerySession.New(session)
+	}
+
+	left, err := f.Left.Eval(session, row)
+	if err != nil {
+		return nil, err
+	}
+
+	if left == nil {
+		return nil, nil
+	}
+
+	left, err = sql.Text.Convert(left)
+	if err != nil {
+		return nil, err
+	}
+
+	right, err := f.Right.Eval(session, row)
+	if err != nil {
+		return nil, err
+	}
+
+	if right == nil {
+		return nil, nil
+	}
+
+	right, err = sql.Text.Convert(right)
+	if err != nil {
+		return nil, err
+	}
+
+	start := plumbing.NewHash(left.(string))
+	target := plumbing.NewHash(right.(string))
+
+	// fast path for equal hashes
+	if start == target {
+		return int64(0), nil
+	}
+
+	return f.historyIdx(s.Pool, start, target)
+}
+
+func (f *HistoryIdx) historyIdx(pool *gitquery.RepositoryPool, start, target plumbing.Hash) (int64, error) {
+	iter, err := pool.RepoIter()
+	if err != nil {
+		return 0, err
+	}
+
+	for {
+		repo, err := iter.Next()
+		if err == io.EOF {
+			return -1, nil
+		}
+
+		if err != nil {
+			return 0, err
+		}
+
+		idx, err := f.repoHistoryIdx(repo.Repo, start, target)
+		if err != nil {
+			return 0, err
+		}
+
+		if idx > -1 {
+			return idx, nil
+		}
+	}
+}
+
+type stackFrame struct {
+	// idx from the start commit
+	idx int64
+	// pos in the hashes slice
+	pos    int
+	hashes []plumbing.Hash
+}
+
+func (f *HistoryIdx) repoHistoryIdx(repo *git.Repository, start, target plumbing.Hash) (int64, error) {
+	// If the target is not on the repo we can avoid starting to traverse the
+	// tree completely.
+	_, err := repo.CommitObject(target)
+	if err == plumbing.ErrObjectNotFound {
+		return -1, nil
+	}
+
+	if err != nil {
+		return 0, err
+	}
+
+	// Since commits can have multiple parents we cannot just do a repo.Log and
+	// keep counting with an index how far it is, because it might go back in
+	// the history and try another branch.
+	// Because of that, the traversal of the history is done manually using a
+	// stack with frames with N commit hashes, representing each level in the
+	// history. Because the frame keeps track of which was its index, we can
+	// return accurate indexes even if there are multiple branches.
+	stack := []*stackFrame{{0, 0, []plumbing.Hash{start}}}
+
+	for {
+		if len(stack) == 0 {
+			return -1, nil
+		}
+
+		frame := stack[len(stack)-1]
+
+		c, err := repo.CommitObject(frame.hashes[frame.pos])
+		if err == plumbing.ErrObjectNotFound {
+			return -1, nil
+		}
+
+		if err != nil {
+			return 0, err
+		}
+
+		frame.pos++
+
+		if c.Hash == target {
+			return frame.idx, nil
+		}
+
+		if frame.pos >= len(frame.hashes) {
+			stack = stack[:len(stack)-1]
+		}
+
+		if c.NumParents() > 0 {
+			stack = append(stack, &stackFrame{frame.idx + 1, 0, c.ParentHashes})
+		}
+	}
+}
+
+// Type implements the Expression interface.
+func (HistoryIdx) Type() sql.Type { return sql.Int64 }
+
+// TransformUp implements the Expression interface.
+func (f *HistoryIdx) TransformUp(fn func(sql.Expression) (sql.Expression, error)) (sql.Expression, error) {
+	left, err := f.Left.TransformUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	right, err := f.Right.TransformUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	return fn(NewHistoryIdx(left, right))
+}

internal/function/history_idx_test.go

@@ -0,0 +1,64 @@
+package function
+
+import (
+	"context"
+	"testing"
+
+	"github.com/src-d/gitquery"
+	"github.com/stretchr/testify/require"
+	fixtures "gopkg.in/src-d/go-git-fixtures.v3"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+	"gopkg.in/src-d/go-mysql-server.v0/sql/expression"
+)
+
+func TestHistoryIdx(t *testing.T) {
+	require.NoError(t, fixtures.Init())
+	defer func() {
+		require.NoError(t, 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(context.TODO(), &pool)
+
+	testCases := []struct {
+		name     string
+		row      sql.Row
+		expected interface{}
+		err      bool
+	}{
+		{"start is null", sql.NewRow(nil, "foo"), nil, false},
+		{"target is null", sql.NewRow("foo", nil), nil, false},
+		{"target is not on start history", sql.NewRow("b029517f6300c2da0f4b651b8642506cd6aaf45d", "6ecf0ef2c2dffb796033e5a02219af86ec6584e5"), int64(-1), false},
+		{"commits are equal", sql.NewRow("35e85108805c84807bc66a02d91535e1e24b38b9", "35e85108805c84807bc66a02d91535e1e24b38b9"), int64(0), false},
+		{"target is on commit history", sql.NewRow("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "b029517f6300c2da0f4b651b8642506cd6aaf45d"), int64(5), false},
+		{"target is on commit history with a multi parent", sql.NewRow("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "b8e471f58bcbca63b07bda20e428190409c2db47"), int64(5), false},
+		{
+			"target is on commit history and is not first in the pool",
+			sql.NewRow("b685400c1f9316f350965a5993d350bc746b0bf4", "c7431b5bc9d45fb64a87d4a895ce3d1073c898d2"),
+			int64(3),
+			false,
+		},
+	}
+
+	for _, tt := range testCases {
+		t.Run(tt.name, func(t *testing.T) {
+			require := require.New(t)
+			val, err := f.Eval(session, tt.row)
+			if tt.err {
+				require.Error(err)
+			} else {
+				require.NoError(err)
+				require.Equal(tt.expected, val)
+			}
+		})
+	}
+}

internal/function/registry.go

@@ -6,6 +6,7 @@ var functions = map[string]sql.Function{
 	"is_tag":          sql.Function1(NewIsTag),
 	"is_remote":       sql.Function1(NewIsRemote),
 	"commit_contains": sql.Function2(NewCommitContains),
+	"history_idx":     sql.Function2(NewHistoryIdx),
 }
 
 // Register all the gitquery functions in the SQL catalog.

session.go

@@ -3,7 +3,7 @@ package gitquery
 import (
 	"context"
 
-	errors "gopkg.in/src-d/go-errors.v0"
+	errors "gopkg.in/src-d/go-errors.v1"
 	"gopkg.in/src-d/go-mysql-server.v0/server"
 	"gopkg.in/src-d/go-mysql-server.v0/sql"
 	"gopkg.in/src-d/go-vitess.v0/mysql"