internal/function: implement language function

Gopkg.toml

@@ -41,3 +41,7 @@
 [[override]]
   name = "github.com/satori/go.uuid"
   revision = "36e9d2ebbde5e3f13ab2e25625fd453271d6522e"
+
+[[constraint]]
+  name = "gopkg.in/src-d/enry.v1"
+  version = "1.6.3"

internal/function/language.go

@@ -0,0 +1,120 @@
+package function
+
+import (
+	"fmt"
+
+	enry "gopkg.in/src-d/enry.v1"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+)
+
+// Language gets the language of a file given its path and
+// the optional content of the file.
+type Language struct {
+	Left  sql.Expression
+	Right sql.Expression
+}
+
+// NewLanguage creates a new Language UDF.
+func NewLanguage(args ...sql.Expression) (sql.Expression, error) {
+	var left, right sql.Expression
+	switch len(args) {
+	case 1:
+		left = args[0]
+	case 2:
+		left = args[0]
+		right = args[1]
+	default:
+		return nil, sql.ErrInvalidArgumentNumber.New("1 or 2", len(args))
+	}
+
+	return &Language{left, right}, nil
+}
+
+// Resolved implements the Expression interface.
+func (f *Language) Resolved() bool {
+	return f.Left.Resolved() && (f.Right == nil || f.Right.Resolved())
+}
+
+func (f *Language) String() string {
+	if f.Right == nil {
+		return fmt.Sprintf("language(%s)", f.Left)
+	}
+	return fmt.Sprintf("language(%s, %s)", f.Left, f.Right)
+}
+
+// IsNullable implements the Expression interface.
+func (f *Language) IsNullable() bool {
+	return f.Left.IsNullable() || (f.Right != nil && f.Right.IsNullable())
+}
+
+// Type implements the Expression interface.
+func (Language) Type() sql.Type {
+	return sql.Text
+}
+
+// TransformUp implements the Expression interface.
+func (f *Language) TransformUp(fn sql.TransformExprFunc) (sql.Expression, error) {
+	left, err := f.Left.TransformUp(fn)
+	if err != nil {
+		return nil, err
+	}
+
+	var right sql.Expression
+	if f.Right != nil {
+		right, err = f.Right.TransformUp(fn)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return fn(&Language{left, right})
+}
+
+// Eval implements the Expression interface.
+func (f *Language) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	left, err := f.Left.Eval(ctx, 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
+	}
+
+	path := left.(string)
+	var blob []byte
+
+	if f.Right != nil {
+		right, err := f.Right.Eval(ctx, row)
+		if err != nil {
+			return nil, err
+		}
+
+		if right == nil {
+			return nil, nil
+		}
+
+		right, err = sql.Blob.Convert(right)
+		if err != nil {
+			return nil, err
+		}
+
+		blob = right.([]byte)
+	}
+
+	return enry.GetLanguage(path, blob), nil
+}
+
+// Children implements the Expression interface.
+func (f *Language) Children() []sql.Expression {
+	if f.Right == nil {
+		return []sql.Expression{f.Left}
+	}
+
+	return []sql.Expression{f.Left, f.Right}
+}

internal/function/language_test.go

@@ -0,0 +1,53 @@
+package function
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	errors "gopkg.in/src-d/go-errors.v1"
+	"gopkg.in/src-d/go-mysql-server.v0/sql"
+	"gopkg.in/src-d/go-mysql-server.v0/sql/expression"
+)
+
+func TestLanguage(t *testing.T) {
+	testCases := []struct {
+		name     string
+		row      sql.Row
+		expected interface{}
+		err      *errors.Kind
+	}{
+		{"left is null", sql.NewRow(nil), nil, nil},
+		{"right is null", sql.NewRow("foo", nil), nil, nil},
+		{"both are null", sql.NewRow(nil, nil), nil, nil},
+		{"only path is given", sql.NewRow("foo.rb"), "Ruby", nil},
+		{"too many args given", sql.NewRow("foo.rb", "bar", "baz"), nil, sql.ErrInvalidArgumentNumber},
+		{"path and blob are given", sql.NewRow("foo", "#!/usr/bin/env python\n\nprint 'foo'"), "Python", nil},
+		{"invalid blob type given", sql.NewRow("foo", 5), nil, sql.ErrInvalidType},
+	}
+
+	for _, tt := range testCases {
+		t.Run(tt.name, func(t *testing.T) {
+			require := require.New(t)
+
+			var args = make([]sql.Expression, len(tt.row))
+			for i := range tt.row {
+				args[i] = expression.NewGetField(i, sql.Text, "", false)
+			}
+
+			f, err := NewLanguage(args...)
+			if err == nil {
+				var val interface{}
+				val, err = f.Eval(nil, tt.row)
+				if tt.err == nil {
+					require.NoError(err)
+					require.Equal(tt.expected, val)
+				}
+			}
+
+			if tt.err != nil {
+				require.Error(err)
+				require.True(tt.err.Is(err))
+			}
+		})
+	}
+}

internal/function/registry.go

@@ -8,4 +8,5 @@ var Functions = sql.Functions{
 	"commit_has_blob": sql.Function2(NewCommitHasBlob),
 	"history_idx":     sql.Function2(NewHistoryIdx),
 	"commit_has_tree": sql.Function2(NewCommitHasTree),
+	"language":        sql.FunctionN(NewLanguage),
 }