impl uuid_short

Author: elianddb

enginetest/memory_engine_test.go

@@ -203,19 +203,44 @@ func TestSingleScript(t *testing.T) {
 	t.Skip()
 	var scripts = []queries.ScriptTest{
 		{
-			Name:        "AS OF propagates to nested CALLs",
+			// https://github.com/dolthub/dolt/issues/9857
+			Name:        "UUID_SHORT() function returns 64-bit unsigned integers with proper construction",
 			SetUpScript: []string{},
 			Assertions: []queries.ScriptTestAssertion{
 				{
-					Query: "create procedure create_proc() create table t (i int primary key, j int);",
+					Query: "SELECT UUID_SHORT() > 0",
 					Expected: []sql.Row{
-						{types.NewOkResult(0)},
+						{true}, // Should return positive values
 					},
 				},
 				{
-					Query: "call create_proc()",
+					Query: "SELECT UUID_SHORT() != UUID_SHORT()",
 					Expected: []sql.Row{
-						{types.NewOkResult(0)},
+						{true}, // Should return different values on each call
+					},
+				},
+				{
+					Query: "SELECT UUID_SHORT() + 0 > 0",
+					Expected: []sql.Row{
+						{true}, // Should work in arithmetic expressions
+					},
+				},
+				{
+					Query: "SELECT CAST(UUID_SHORT() AS CHAR) != ''",
+					Expected: []sql.Row{
+						{true}, // Should cast to non-empty string
+					},
+				},
+				{
+					Query: "SELECT UUID_SHORT() BETWEEN 1 AND 18446744073709551615",
+					Expected: []sql.Row{
+						{true}, // Should be within uint64 range
+					},
+				},
+				{
+					Query: "SELECT (UUID_SHORT() & 0xFF00000000000000) >> 56 BETWEEN 0 AND 255",
+					Expected: []sql.Row{
+						{true}, // Server ID should be 0-255
 					},
 				},
 			},

sql/expression/function/registry.go

@@ -318,6 +318,7 @@ var BuiltIns = []sql.Function{
 	sql.NewFunction0("user", NewUser),
 	sql.FunctionN{Name: "utc_timestamp", Fn: NewUTCTimestamp},
 	sql.Function0{Name: "uuid", Fn: NewUUIDFunc},
+	sql.Function0{Name: "uuid_short", Fn: NewUUIDShortFunc},
 	sql.FunctionN{Name: "uuid_to_bin", Fn: NewUUIDToBin},
 	sql.FunctionN{Name: "week", Fn: NewWeek},
 	sql.Function1{Name: "values", Fn: NewValues},

sql/expression/function/uuid.go

@@ -16,6 +16,8 @@ package function
 
 import (
 	"fmt"
+	"sync"
+	"time"
 
 	"github.com/dolthub/vitess/go/sqltypes"
 	"github.com/dolthub/vitess/go/vt/proto/query"
@@ -25,6 +27,14 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
+// Global state for UUID_SHORT function
+var (
+	uuidShortMu        sync.Mutex
+	uuidShortCounter   uint64
+	uuidShortStartup   = uint64(time.Now().Unix())
+	uuidShortServerID  = uint64(1) // Default server ID
+)
+
 // UUID()
 //
 // Returns a Universal Unique Identifier (UUID) generated according to RFC 4122, “A Universally Unique IDentifier (UUID)
@@ -528,3 +538,91 @@ func (bu BinToUUID) Children() []sql.Expression {
 func (bu BinToUUID) IsNullable() bool {
 	return false
 }
+
+// UUID_SHORT()
+//
+// Returns a "short" universal identifier as a 64-bit unsigned integer. Values returned by UUID_SHORT() differ from the
+// string-format 128-bit identifiers returned by the UUID() function and have different uniqueness properties. The value
+// of UUID_SHORT() is guaranteed to be unique if the following conditions hold:
+//
+// The server_id value of the current server is between 0 and 255 and is unique among your set of source and replica servers
+// You do not set back the system time for your server host between mysqld restarts
+// You invoke UUID_SHORT() on average fewer than 16 million times per second between mysqld restarts
+//
+// The UUID_SHORT() return value is constructed this way:
+//   (server_id & 255) << 56
+// + (server_startup_time_in_seconds << 24)
+// + incremented_variable++;
+//
+// Note: UUID_SHORT() does not work with statement-based replication.
+// https://dev.mysql.com/doc/refman/8.4/en/miscellaneous-functions.html#function_uuid-short
+
+type UUIDShortFunc struct{}
+
+var _ sql.FunctionExpression = &UUIDShortFunc{}
+var _ sql.CollationCoercible = &UUIDShortFunc{}
+
+func NewUUIDShortFunc() sql.Expression {
+	return &UUIDShortFunc{}
+}
+
+// Description implements sql.FunctionExpression
+func (u UUIDShortFunc) Description() string {
+	return "returns a short universal identifier as a 64-bit unsigned integer."
+}
+
+func (u UUIDShortFunc) String() string {
+	return "UUID_SHORT()"
+}
+
+func (u UUIDShortFunc) Type() sql.Type {
+	return types.Uint64
+}
+
+// CollationCoercibility implements the interface sql.CollationCoercible.
+func (UUIDShortFunc) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte) {
+	return sql.Collation_binary, 5
+}
+
+func (u *UUIDShortFunc) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
+	uuidShortMu.Lock()
+	defer uuidShortMu.Unlock()
+	
+	uuidShortCounter++
+	
+	// Construct the UUID_SHORT value according to MySQL specification:
+	// (server_id & 255) << 56 + (server_startup_time_in_seconds << 24) + incremented_variable
+	result := ((uuidShortServerID & 255) << 56) + (uuidShortStartup << 24) + uuidShortCounter
+	
+	return result, nil
+}
+
+func (u UUIDShortFunc) WithChildren(children ...sql.Expression) (sql.Expression, error) {
+	if len(children) != 0 {
+		return nil, sql.ErrInvalidChildrenNumber.New(u, len(children), 0)
+	}
+
+	return &UUIDShortFunc{}, nil
+}
+
+func (u UUIDShortFunc) FunctionName() string {
+	return "UUID_SHORT"
+}
+
+func (u UUIDShortFunc) Resolved() bool {
+	return true
+}
+
+// Children returns the children expressions of this expression.
+func (u UUIDShortFunc) Children() []sql.Expression {
+	return nil
+}
+
+// IsNullable returns whether the expression can be null.
+func (u UUIDShortFunc) IsNullable() bool {
+	return false
+}
+
+func (u UUIDShortFunc) IsNonDeterministic() bool {
+	return true
+}

sql/expression/function/uuid_test.go

@@ -215,3 +215,81 @@ func TestBinToUUIDFailing(t *testing.T) {
 		})
 	}
 }
+
+func TestUUIDShort(t *testing.T) {
+	ctx := sql.NewEmptyContext()
+	uuidShortE := NewUUIDShortFunc()
+
+	// Test that UUID_SHORT returns sequential values
+	result1, err := uuidShortE.Eval(ctx, sql.Row{nil})
+	require.NoError(t, err)
+	require.IsType(t, uint64(0), result1)
+
+	result2, err := uuidShortE.Eval(ctx, sql.Row{nil})
+	require.NoError(t, err)
+	require.IsType(t, uint64(0), result2)
+
+	result3, err := uuidShortE.Eval(ctx, sql.Row{nil})
+	require.NoError(t, err)
+	require.IsType(t, uint64(0), result3)
+
+	// Values should be sequential (incrementing by 1)
+	require.Equal(t, result1.(uint64)+1, result2.(uint64))
+	require.Equal(t, result2.(uint64)+1, result3.(uint64))
+
+	// Test that values are 64-bit unsigned integers
+	require.Greater(t, result1.(uint64), uint64(0))
+	require.Greater(t, result2.(uint64), uint64(0))
+	require.Greater(t, result3.(uint64), uint64(0))
+}
+
+func TestUUIDShortMultipleInstances(t *testing.T) {
+	ctx := sql.NewEmptyContext()
+	
+	// Create multiple instances to test that they share the global counter (like MySQL)
+	uuidShort1 := NewUUIDShortFunc()
+	uuidShort2 := NewUUIDShortFunc()
+
+	result1, err := uuidShort1.Eval(ctx, sql.Row{nil})
+	require.NoError(t, err)
+
+	result2, err := uuidShort2.Eval(ctx, sql.Row{nil})
+	require.NoError(t, err)
+
+	// Both should return sequential values from the global counter
+	require.IsType(t, uint64(0), result1)
+	require.IsType(t, uint64(0), result2)
+	require.Greater(t, result1.(uint64), uint64(0))
+	require.Greater(t, result2.(uint64), uint64(0))
+	
+	// Values should be sequential (global counter)
+	require.Equal(t, result1.(uint64)+1, result2.(uint64))
+}
+
+func TestUUIDShortWithChildren(t *testing.T) {
+	uuidShortE := NewUUIDShortFunc()
+
+	// Test WithChildren with no arguments (should work)
+	newExpr, err := uuidShortE.WithChildren()
+	require.NoError(t, err)
+	require.NotNil(t, newExpr)
+
+	// Test WithChildren with arguments (should fail)
+	_, err = uuidShortE.WithChildren(expression.NewLiteral(1, types.Int64))
+	require.Error(t, err)
+	require.Contains(t, err.Error(), "invalid children number")
+}
+
+func TestUUIDShortProperties(t *testing.T) {
+	uuidShortE := NewUUIDShortFunc().(*UUIDShortFunc)
+
+	// Test function properties
+	require.Equal(t, "UUID_SHORT", uuidShortE.FunctionName())
+	require.Equal(t, "returns a short universal identifier as a 64-bit unsigned integer.", uuidShortE.Description())
+	require.Equal(t, "UUID_SHORT()", uuidShortE.String())
+	require.Equal(t, types.Uint64, uuidShortE.Type())
+	require.True(t, uuidShortE.Resolved())
+	require.False(t, uuidShortE.IsNullable())
+	require.True(t, uuidShortE.IsNonDeterministic())
+	require.Nil(t, uuidShortE.Children())
+}