Merge pull request #3209 from dolthub/angela/bitlength

Convert values to strings when evaluating `bit_length`

Author: angelamayxie

enginetest/queries/function_queries.go

@@ -569,9 +569,26 @@ var FunctionQueryTests = []QueryTest{
 	{
 		Query: "SELECT BIT_LENGTH(i) from mytable order by i limit 1",
 		Expected: []sql.Row{
-			{64},
+			{8},
 		},
 	},
+	{
+		// https://github.com/dolthub/dolt/issues/9818
+		Query:    "select bit_length(10)",
+		Expected: []sql.Row{{16}},
+	},
+	{
+		Query:    "select bit_length(now())",
+		Expected: []sql.Row{{152}},
+	},
+	{
+		Query:    "select bit_length(-10)",
+		Expected: []sql.Row{{24}},
+	},
+	{
+		Query:    "select bit_length(true)",
+		Expected: []sql.Row{{8}},
+	},
 	{
 		Query: "select date_format(datetime_col, '%D') from datetime_table order by 1",
 		Expected: []sql.Row{

enginetest/queries/script_queries.go

@@ -9466,6 +9466,14 @@ where
 					{"hijkl", 5},
 				},
 			},
+			{
+				Query: "select e, bit_length(e) from t order by e;",
+				Expected: []sql.Row{
+					{"abc", 24},
+					{"defg", 32},
+					{"hijkl", 40},
+				},
+			},
 			{
 				Query: "select e, concat(e, 'test') from t order by e;",
 				Expected: []sql.Row{
@@ -10129,6 +10137,15 @@ where
 					{"abc,defg,hijkl", 14},
 				},
 			},
+			{
+				Query: "select s, bit_length(s) from t order by s;",
+				Expected: []sql.Row{
+					{"abc", 24},
+					{"defg", 32},
+					{"abc,defg", 64},
+					{"abc,defg,hijkl", 112},
+				},
+			},
 			{
 				Query: "select s, concat(s, 'test') from t order by s;",
 				Expected: []sql.Row{

sql/expression/function/string.go

@@ -552,7 +552,7 @@ func (h *Bin) convertToInt64(v interface{}) (int64, error) {
 	}
 }
 
-// Bitlength implements the sql function "bit_length" which returns the data length of the argument in bits
+// Bitlength implements the sql function "bit_length" which returns the length of a string in bits
 type Bitlength struct {
 	*UnaryFunc
 }
@@ -590,24 +590,12 @@ func (h *Bitlength) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 		return nil, nil
 	}
 
-	switch val := arg.(type) {
-	case uint8, int8, bool:
-		return 8, nil
-	case uint16, int16:
-		return 16, nil
-	case int, uint, uint32, int32, float32:
-		return 32, nil
-	case uint64, int64, float64:
-		return 64, nil
-	case string:
-		return 8 * len([]byte(val)), nil
-	case []byte:
-		return 8 * len(val), nil
-	case time.Time:
-		return 128, nil
+	content, _, err := types.ConvertToCollatedString(ctx, arg, h.Child.Type())
+	if err != nil {
+		return nil, err
 	}
 
-	return nil, sql.ErrInvalidArgumentDetails.New("bit_length", fmt.Sprint(arg))
+	return 8 * len(content), nil
 }
 
 // WithChildren implements the sql.Expression interface

sql/expression/function/string_test.go

@@ -143,24 +143,14 @@ func TestBinFunc(t *testing.T) {
 }
 
 func TestBitLength(t *testing.T) {
-	f := sql.Function1{Name: "bin", Fn: NewBitlength}
+	f := sql.Function1{Name: "bit_length", Fn: NewBitlength}
 	tf := NewTestFactory(f.Fn)
 	tf.AddSucceeding(nil, nil)
 	tf.AddSucceeding(32, "test")
 	tf.AddSucceeding(8, true)
-	tf.AddSucceeding(8, int8(0))
-	tf.AddSucceeding(8, uint8(0))
-	tf.AddSucceeding(16, int16(0))
-	tf.AddSucceeding(16, uint16(0))
-	tf.AddSucceeding(32, uint32(0))
-	tf.AddSucceeding(32, int32(0))
-	tf.AddSucceeding(32, uint(0))
-	tf.AddSucceeding(32, 0)
-	tf.AddSucceeding(64, uint64(0))
-	tf.AddSucceeding(64, int64(0))
-	tf.AddSucceeding(64, float64(0))
-	tf.AddSucceeding(32, float32(0))
-	tf.AddSucceeding(128, time.Now())
+	tf.AddSucceeding(8, 0)
+	tf.AddSucceeding(16, 10)
+	tf.AddSucceeding(24, -10)
 	tf.Test(t, nil, nil)
 }