Merge pull request #150 from erizocosmico/feature/commit-contains-udf

internal/function: implement commit_contains function

Author: erizocosmico

internal/function/commit_contains.go

@@ -0,0 +1,165 @@
+package function
+
+import (
+	"io"
+
+	"github.com/src-d/gitquery"
+	"gopkg.in/src-d/go-git.v4/plumbing"
+	"gopkg.in/src-d/go-git.v4/plumbing/object"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+)
+
+// CommitContains is a function that checks whether a blob is in a commit.
+type CommitContains struct {
+	commitHash sql.Expression
+	blob       sql.Expression
+}
+
+// NewCommitContains creates a new commit_contains function.
+func NewCommitContains(commitHash, blob sql.Expression) sql.Expression {
+	return &CommitContains{
+		commitHash: commitHash,
+		blob:       blob,
+	}
+}
+
+// Type implements the Expression interface.
+func (CommitContains) Type() sql.Type {
+	return sql.Boolean
+}
+
+// Eval implements the Expression interface.
+func (f *CommitContains) Eval(session sql.Session, row sql.Row) (interface{}, error) {
+	s, ok := session.(*gitquery.Session)
+	if !ok {
+		return nil, gitquery.ErrInvalidGitQuerySession.New(session)
+	}
+
+	commitHash, err := f.commitHash.Eval(s, row)
+	if err != nil {
+		return nil, err
+	}
+
+	if commitHash == nil {
+		return nil, err
+	}
+
+	commitHash, err = sql.Text.Convert(commitHash)
+	if err != nil {
+		return nil, err
+	}
+
+	blob, err := f.blob.Eval(s, row)
+	if err != nil {
+		return nil, err
+	}
+
+	if blob == nil {
+		return nil, err
+	}
+
+	blob, err = sql.Text.Convert(blob)
+	if err != nil {
+		return nil, err
+	}
+
+	return f.commitContains(
+		s.Pool,
+		plumbing.NewHash(commitHash.(string)),
+		plumbing.NewHash(blob.(string)),
+	)
+}
+
+func (f *CommitContains) commitContains(
+	pool *gitquery.RepositoryPool,
+	commitHash, blob plumbing.Hash,
+) (bool, error) {
+	iter, err := pool.RepoIter()
+	if err != nil {
+		return false, err
+	}
+
+	for {
+		repository, err := iter.Next()
+		if err == io.EOF {
+			break
+		}
+
+		if err != nil {
+			return false, err
+		}
+
+		repo := repository.Repo
+		commit, err := repo.CommitObject(commitHash)
+		if err == plumbing.ErrObjectNotFound {
+			continue
+		}
+
+		if err != nil {
+			return false, err
+		}
+
+		tree, err := commit.Tree()
+		if err != nil {
+			return false, err
+		}
+
+		contained, err := hashInTree(blob, tree)
+		if err != nil {
+			return false, err
+		}
+
+		if contained {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+func hashInTree(hash plumbing.Hash, tree *object.Tree) (bool, error) {
+	var contained bool
+	err := tree.Files().ForEach(func(f *object.File) error {
+		if f.Blob.Hash == hash {
+			contained = true
+			return io.EOF
+		}
+		return nil
+	})
+
+	if err != nil && err != io.EOF {
+		return false, err
+	}
+
+	return contained, nil
+}
+
+// Name implements the Expression interface.
+func (CommitContains) Name() string {
+	return "commit_contains"
+}
+
+// IsNullable implements the Expression interface.
+func (f CommitContains) IsNullable() bool {
+	return f.commitHash.IsNullable() || f.blob.IsNullable()
+}
+
+// Resolved implements the Expression interface.
+func (f CommitContains) Resolved() bool {
+	return f.commitHash.Resolved() && f.blob.Resolved()
+}
+
+// TransformUp implements the Expression interface.
+func (f CommitContains) TransformUp(fn func(sql.Expression) (sql.Expression, error)) (sql.Expression, error) {
+	commitHash, err := f.commitHash.TransformUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	blob, err := f.blob.TransformUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	return fn(NewCommitContains(commitHash, blob))
+}

internal/function/commit_contains_test.go

@@ -0,0 +1,56 @@
+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 TestCommitContains(t *testing.T) {
+	require.NoError(t, fixtures.Init())
+	defer func() {
+		require.NoError(t, fixtures.Clean())
+	}()
+
+	f := NewCommitContains(
+		expression.NewGetField(0, sql.Text, "commit_hash", true),
+		expression.NewGetField(1, sql.Text, "blob", 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
+	}{
+		{"commit hash is null", sql.NewRow(nil, "foo"), nil, false},
+		{"blob hash is null", sql.NewRow("foo", nil), nil, false},
+		{"blob is not on commit", sql.NewRow("35e85108805c84807bc66a02d91535e1e24b38b9", "9dea2395f5403188298c1dabe8bdafe562c491e3"), false, false},
+		{"blob is on commit", sql.NewRow("6ecf0ef2c2dffb796033e5a02219af86ec6584e5", "9dea2395f5403188298c1dabe8bdafe562c491e3"), true, 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

@@ -3,8 +3,9 @@ package function
 import "gopkg.in/src-d/go-mysql-server.v0/sql"
 
 var functions = map[string]sql.Function{
-	"is_tag":    sql.Function1(NewIsTag),
-	"is_remote": sql.Function1(NewIsRemote),
+	"is_tag":          sql.Function1(NewIsTag),
+	"is_remote":       sql.Function1(NewIsRemote),
+	"commit_contains": sql.Function2(NewCommitContains),
 }
 
 // Register all the gitquery functions in the SQL catalog.

session.go

@@ -3,6 +3,7 @@ package gitquery
 import (
 	"context"
 
+	errors "gopkg.in/src-d/go-errors.v0"
 	"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"
@@ -28,3 +29,7 @@ func NewSessionBuilder(pool *RepositoryPool) server.SessionBuilder {
 		return NewSession(ctx, pool)
 	}
 }
+
+// ErrInvalidGitQuerySession is returned when some node expected a GitQuery
+// session but received something else.
+var ErrInvalidGitQuerySession = errors.NewKind("expecting gitquery session, but received: %T")