builtin: add oct built-in function

expression/builtin_string.go

@@ -22,6 +22,7 @@ import (
 	"encoding/hex"
 	"fmt"
 	"math"
+	"strconv"
 	"strings"
 
 	"github.com/juju/errors"
@@ -1445,7 +1446,50 @@ type builtinOctSig struct {
 
 // See https://dev.mysql.com/doc/refman/5.7/en/string-functions.html#function_oct
 func (b *builtinOctSig) eval(row []types.Datum) (d types.Datum, err error) {
-	return d, errFunctionNotExists.GenByArgs("oct")
+	args, err := b.evalArgs(row)
+	if err != nil {
+		return d, errors.Trace(err)
+	}
+	var (
+		negative bool
+		overflow bool
+	)
+	arg := args[0]
+	if arg.IsNull() {
+		return d, nil
+	}
+	n, err := arg.ToString()
+	if err != nil {
+		return d, errors.Trace(err)
+	}
+	n = getValidPrefix(strings.TrimSpace(n), 10)
+	if len(n) == 0 {
+		d.SetString("0")
+		return d, nil
+	}
+	if n[0] == '-' {
+		negative = true
+		n = n[1:]
+	}
+	val, err := strconv.ParseUint(n, 10, 64)
+	if err != nil {
+		if numError, ok := err.(*strconv.NumError); ok {
+			if numError.Err == strconv.ErrRange {
+				overflow = true
+			} else {
+				return d, errors.Trace(err)
+			}
+		} else {
+			return d, errors.Trace(err)
+		}
+	}
+
+	if negative && !overflow {
+		val = -val
+	}
+	str := strconv.FormatUint(val, 8)
+	d.SetString(str)
+	return d, nil
 }
 
 type ordFunctionClass struct {

expression/builtin_string_test.go

@@ -1009,3 +1009,48 @@ func (s *testEvaluatorSuite) TestMakeSet(c *C) {
 		c.Assert(r, testutil.DatumEquals, types.NewDatum(t.ret))
 	}
 }
+
+func (s *testEvaluatorSuite) TestOct(c *C) {
+	defer testleak.AfterTest(c)()
+	octCases := []struct {
+		origin interface{}
+		ret    string
+	}{
+		{"-2.7", "1777777777777777777776"},
+		{-1.5, "1777777777777777777777"},
+		{-1, "1777777777777777777777"},
+		{"0", "0"},
+		{"1", "1"},
+		{"8", "10"},
+		{"12", "14"},
+		{"20", "24"},
+		{"100", "144"},
+		{"1024", "2000"},
+		{"2048", "4000"},
+		{1.0, "1"},
+		{9.5, "11"},
+		{13, "15"},
+		{1025, "2001"},
+		{"8a8", "10"},
+		{"abc", "0"},
+		//overflow uint64
+		{"9999999999999999999999999", "1777777777777777777777"},
+		{"-9999999999999999999999999", "1777777777777777777777"},
+	}
+	fc := funcs[ast.Oct]
+	for _, test := range octCases {
+		in := types.NewDatum(test.origin)
+		f, _ := fc.getFunction(datumsToConstants([]types.Datum{in}), s.ctx)
+		r, err := f.eval(nil)
+		c.Assert(err, IsNil)
+		res, err := r.ToString()
+		c.Assert(err, IsNil)
+		c.Assert(res, Equals, test.ret)
+	}
+	// test NULL input for sha
+	var argNull types.Datum
+	f, _ := fc.getFunction(datumsToConstants([]types.Datum{argNull}), s.ctx)
+	r, err := f.eval(nil)
+	c.Assert(err, IsNil)
+	c.Assert(r.IsNull(), IsTrue)
+}

plan/typeinferer.go

@@ -375,7 +375,7 @@ func (v *typeInferrer) handleFuncCallExpr(x *ast.FuncCallExpr) {
 		"concat", "concat_ws", "left", "lcase", "lower", "repeat",
 		"replace", "ucase", "upper", "convert", "substring",
 		"substring_index", "trim", "ltrim", "rtrim", "reverse", "hex", "unhex",
-		"date_format", "rpad", "lpad", "char_func", "conv", "make_set":
+		"date_format", "rpad", "lpad", "char_func", "conv", "make_set", "oct":
 		tp = types.NewFieldType(mysql.TypeVarString)
 		chs = v.defaultCharset
 	case "strcmp", "isnull", "bit_length", "char_length", "character_length", "crc32", "timestampdiff", "sign":

plan/typeinferer_test.go

@@ -249,6 +249,7 @@ func (ts *testTypeInferrerSuite) TestInferType(c *C) {
 		{`coalesce(1, "1" + 1)`, mysql.TypeDouble, charset.CharsetBin},
 		{`coalesce(1, "abc")`, mysql.TypeVarString, charset.CharsetUTF8},
 		{`make_set(1 | 3, "hello", "nice", null, "world")`, mysql.TypeVarString, charset.CharsetUTF8},
+		{`oct(12)`, mysql.TypeVarString, charset.CharsetUTF8},
 		{`exp(1)`, mysql.TypeDouble, charset.CharsetBin},
 		{`exp(1.23)`, mysql.TypeDouble, charset.CharsetBin},
 		{`exp('1.23')`, mysql.TypeDouble, charset.CharsetBin},