functions: COMMIT_STATS, function implementation

Signed-off-by: Máximo Cuadros <[email protected]>

Author: mcuadros

internal/function/commit_stats.go

@@ -0,0 +1,147 @@
+package function
+
+import (
+	"fmt"
+
+	"github.com/src-d/gitbase"
+	"github.com/src-d/gitbase/internal/commitstats"
+
+	"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"
+)
+
+// CommitStats calculates the diff stats for a given commit.
+type CommitStats struct {
+	Repository sql.Expression
+	From       sql.Expression
+	To         sql.Expression
+}
+
+// NewCommitStats creates a new COMMIT_STATS function.
+func NewCommitStats(args ...sql.Expression) (sql.Expression, error) {
+	f := &CommitStats{}
+	switch len(args) {
+	case 2:
+		f.Repository, f.To = args[0], args[1]
+	case 3:
+		f.Repository, f.From, f.To = args[0], args[1], args[2]
+	default:
+		return nil, sql.ErrInvalidArgumentNumber.New("COMMIT_STATS", "2 or 3", len(args))
+	}
+
+	return f, nil
+}
+
+func (f *CommitStats) String() string {
+	if f.From == nil {
+		return fmt.Sprintf("commit_stats(%s, %s)", f.Repository, f.To)
+	}
+
+	return fmt.Sprintf("commit_stats(%s, %s, %s)", f.Repository, f.From, f.To)
+}
+
+// Type implements the Expression interface.
+func (CommitStats) Type() sql.Type {
+	return sql.JSON
+}
+
+// TransformUp implements the Expression interface.
+func (f *CommitStats) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error) {
+	repo, err := f.Repository.TransformUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	to, err := f.To.TransformUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	if f.From == nil {
+		return fn(&CommitStats{Repository: repo, To: to})
+	}
+
+	from, err := f.From.TransformUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	return fn(&CommitStats{Repository: repo, From: from, To: to})
+}
+
+// Children implements the Expression interface.
+func (f *CommitStats) Children() []sql.Expression {
+	if f.From == nil {
+		return []sql.Expression{f.Repository, f.To}
+	}
+
+	return []sql.Expression{f.Repository, f.From, f.To}
+}
+
+// IsNullable implements the Expression interface.
+func (*CommitStats) IsNullable() bool {
+	return false
+}
+
+// Resolved implements the Expression interface.
+func (f *CommitStats) Resolved() bool {
+	return f.To.Resolved() && (f.From == nil || f.From.Resolved())
+}
+
+// Eval implements the Expression interface.
+func (f *CommitStats) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	span, ctx := ctx.Span("gitbase.CommitStats")
+	defer span.Finish()
+
+	r, err := f.resolveRepo(ctx, row)
+	if err != nil {
+		return nil, err
+	}
+
+	to, err := f.resolveCommit(ctx, r, row, f.To)
+	if err != nil {
+		return nil, err
+	}
+
+	from, err := f.resolveCommit(ctx, r, row, f.From)
+	if err != nil {
+		return nil, err
+	}
+
+	return commitstats.Calculate(r.Repository, from, to)
+}
+
+func (f *CommitStats) resolveRepo(ctx *sql.Context, r sql.Row) (*gitbase.Repository, error) {
+	repoID, err := exprToString(ctx, f.Repository, r)
+	if err != nil {
+		return nil, err
+	}
+	s, ok := ctx.Session.(*gitbase.Session)
+	if !ok {
+		return nil, gitbase.ErrInvalidGitbaseSession.New(ctx.Session)
+	}
+	return s.Pool.GetRepo(repoID)
+}
+
+func (f *CommitStats) resolveCommit(
+	ctx *sql.Context, r *gitbase.Repository, row sql.Row, e sql.Expression,
+) (*object.Commit, error) {
+
+	str, err := exprToString(ctx, e, row)
+	if err != nil {
+		return nil, err
+	}
+
+	if str == "" {
+		return nil, nil
+	}
+
+	commitHash, err := r.ResolveRevision(plumbing.Revision(str))
+	if err != nil {
+		h := plumbing.NewHash(str)
+		commitHash = &h
+	}
+
+	return r.CommitObject(*commitHash)
+}

internal/function/commit_stats_test.go

@@ -0,0 +1,67 @@
+package function
+
+import (
+	"context"
+	"testing"
+
+	"github.com/src-d/gitbase"
+	"github.com/src-d/gitbase/internal/commitstats"
+	"github.com/stretchr/testify/require"
+
+	"gopkg.in/src-d/go-git-fixtures.v3"
+	"gopkg.in/src-d/go-git.v4/plumbing/cache"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+	"gopkg.in/src-d/go-mysql-server.v0/sql/expression"
+)
+
+func TestCommitStatsEval(t *testing.T) {
+	require.NoError(t, fixtures.Init())
+	defer func() {
+		require.NoError(t, fixtures.Clean())
+	}()
+
+	path := fixtures.ByTag("worktree").One().Worktree().Root()
+
+	pool := gitbase.NewRepositoryPool(cache.DefaultMaxSize)
+	require.NoError(t, pool.AddGitWithID("worktree", path))
+
+	session := gitbase.NewSession(pool)
+	ctx := sql.NewContext(context.TODO(), sql.WithSession(session))
+
+	testCases := []struct {
+		name     string
+		repo     sql.Expression
+		from     sql.Expression
+		to       sql.Expression
+		row      sql.Row
+		expected *commitstats.CommitStats
+	}{
+		{
+			name: "init commit",
+			repo: expression.NewGetField(0, sql.Text, "repository_id", false),
+			from: nil,
+			to:   expression.NewGetField(1, sql.Text, "commit_hash", false),
+			row:  sql.NewRow("worktree", "b029517f6300c2da0f4b651b8642506cd6aaf45d"),
+			expected: &commitstats.CommitStats{
+				Files: 2,
+				Other: commitstats.KindStats{Additions: 22, Deletions: 0},
+				Total: commitstats.KindStats{Additions: 22, Deletions: 0},
+			},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			diff, err := NewCommitStats(tc.repo, tc.from, tc.to)
+			require.NoError(t, err)
+
+			result, err := diff.Eval(ctx, tc.row)
+			require.NoError(t, err)
+
+			stats, ok := result.(*commitstats.CommitStats)
+			require.True(t, ok)
+
+			require.EqualValues(t, tc.expected, stats)
+		})
+	}
+}

internal/function/registry.go

@@ -4,6 +4,7 @@ import "gopkg.in/src-d/go-mysql-server.v0/sql"
 
 // Functions for gitbase queries.
 var Functions = []sql.Function{
+	sql.FunctionN{Name: "commit_stats", Fn: NewCommitStats},
 	sql.Function1{Name: "is_tag", Fn: NewIsTag},
 	sql.Function1{Name: "is_remote", Fn: NewIsRemote},
 	sql.FunctionN{Name: "language", Fn: NewLanguage},