diff --git a/pkg/expression/builtin.go b/pkg/expression/builtin.go index e1e9ce707458e..7421f8bfc4dc9 100644 --- a/pkg/expression/builtin.go +++ b/pkg/expression/builtin.go @@ -868,7 +868,11 @@ var funcs = map[string]functionClass{ ast.NameConst: &nameConstFunctionClass{baseFunctionClass{ast.NameConst, 2, 2}}, ast.ReleaseAllLocks: &releaseAllLocksFunctionClass{baseFunctionClass{ast.ReleaseAllLocks, 0, 0}}, ast.UUID: &uuidFunctionClass{baseFunctionClass{ast.UUID, 0, 0}}, + ast.UUIDv4: &uuidv4FunctionClass{baseFunctionClass{ast.UUIDv4, 0, 0}}, + ast.UUIDv7: &uuidv7FunctionClass{baseFunctionClass{ast.UUIDv7, 0, 0}}, ast.UUIDShort: &uuidShortFunctionClass{baseFunctionClass{ast.UUIDShort, 0, 0}}, + ast.UUIDVersion: &uuidVersionFunctionClass{baseFunctionClass{ast.UUIDVersion, 1, 1}}, + ast.UUIDTimestamp: &uuidTimestampFunctionClass{baseFunctionClass{ast.UUIDTimestamp, 1, 1}}, ast.VitessHash: &vitessHashFunctionClass{baseFunctionClass{ast.VitessHash, 1, 1}}, ast.UUIDToBin: &uuidToBinFunctionClass{baseFunctionClass{ast.UUIDToBin, 1, 2}}, ast.BinToUUID: &binToUUIDFunctionClass{baseFunctionClass{ast.BinToUUID, 1, 2}}, diff --git a/pkg/expression/builtin_miscellaneous.go b/pkg/expression/builtin_miscellaneous.go index 9de055363c34e..def439f441684 100644 --- a/pkg/expression/builtin_miscellaneous.go +++ b/pkg/expression/builtin_miscellaneous.go @@ -39,66 +39,78 @@ import ( ) var ( - _ functionClass = &sleepFunctionClass{} - _ functionClass = &lockFunctionClass{} - _ functionClass = &releaseLockFunctionClass{} _ functionClass = &anyValueFunctionClass{} + _ functionClass = &binToUUIDFunctionClass{} _ functionClass = &defaultFunctionClass{} - _ functionClass = &inetAtonFunctionClass{} - _ functionClass = &inetNtoaFunctionClass{} _ functionClass = &inet6AtonFunctionClass{} _ functionClass = &inet6NtoaFunctionClass{} + _ functionClass = &inetAtonFunctionClass{} + _ functionClass = &inetNtoaFunctionClass{} _ functionClass = &isFreeLockFunctionClass{} - _ functionClass = &isIPv4FunctionClass{} _ functionClass = &isIPv4CompatFunctionClass{} + _ functionClass = &isIPv4FunctionClass{} _ functionClass = &isIPv4MappedFunctionClass{} _ functionClass = &isIPv6FunctionClass{} _ functionClass = &isUsedLockFunctionClass{} + _ functionClass = &isUUIDFunctionClass{} + _ functionClass = &lockFunctionClass{} _ functionClass = &nameConstFunctionClass{} _ functionClass = &releaseAllLocksFunctionClass{} + _ functionClass = &releaseLockFunctionClass{} + _ functionClass = &sleepFunctionClass{} + _ functionClass = &tidbRowChecksumFunctionClass{} + _ functionClass = &tidbShardFunctionClass{} _ functionClass = &uuidFunctionClass{} _ functionClass = &uuidShortFunctionClass{} - _ functionClass = &vitessHashFunctionClass{} + _ functionClass = &uuidTimestampFunctionClass{} _ functionClass = &uuidToBinFunctionClass{} - _ functionClass = &binToUUIDFunctionClass{} - _ functionClass = &isUUIDFunctionClass{} - _ functionClass = &tidbShardFunctionClass{} + _ functionClass = &uuidv4FunctionClass{} + _ functionClass = &uuidv7FunctionClass{} + _ functionClass = &uuidVersionFunctionClass{} + _ functionClass = &vitessHashFunctionClass{} ) var ( - _ builtinFunc = &builtinSleepSig{} - _ builtinFunc = &builtinLockSig{} - _ builtinFunc = &builtinReleaseLockSig{} - _ builtinFunc = &builtinReleaseAllLocksSig{} + _ builtinFunc = &builtinBinToUUIDSig{} _ builtinFunc = &builtinDecimalAnyValueSig{} _ builtinFunc = &builtinDurationAnyValueSig{} - _ builtinFunc = &builtinIntAnyValueSig{} - _ builtinFunc = &builtinJSONAnyValueSig{} - _ builtinFunc = &builtinRealAnyValueSig{} - _ builtinFunc = &builtinStringAnyValueSig{} - _ builtinFunc = &builtinTimeAnyValueSig{} - _ builtinFunc = &builtinInetAtonSig{} - _ builtinFunc = &builtinInetNtoaSig{} + _ builtinFunc = &builtinFreeLockSig{} _ builtinFunc = &builtinInet6AtonSig{} _ builtinFunc = &builtinInet6NtoaSig{} - _ builtinFunc = &builtinIsIPv4Sig{} + _ builtinFunc = &builtinInetAtonSig{} + _ builtinFunc = &builtinInetNtoaSig{} + _ builtinFunc = &builtinIntAnyValueSig{} _ builtinFunc = &builtinIsIPv4CompatSig{} _ builtinFunc = &builtinIsIPv4MappedSig{} + _ builtinFunc = &builtinIsIPv4Sig{} _ builtinFunc = &builtinIsIPv6Sig{} _ builtinFunc = &builtinIsUUIDSig{} - _ builtinFunc = &builtinUUIDSig{} - _ builtinFunc = &builtinVitessHashSig{} - _ builtinFunc = &builtinUUIDToBinSig{} - _ builtinFunc = &builtinBinToUUIDSig{} - - _ builtinFunc = &builtinNameConstIntSig{} - _ builtinFunc = &builtinNameConstRealSig{} + _ builtinFunc = &builtinJSONAnyValueSig{} + _ builtinFunc = &builtinLockSig{} _ builtinFunc = &builtinNameConstDecimalSig{} - _ builtinFunc = &builtinNameConstTimeSig{} _ builtinFunc = &builtinNameConstDurationSig{} - _ builtinFunc = &builtinNameConstStringSig{} + _ builtinFunc = &builtinNameConstIntSig{} _ builtinFunc = &builtinNameConstJSONSig{} + _ builtinFunc = &builtinNameConstRealSig{} + _ builtinFunc = &builtinNameConstStringSig{} + _ builtinFunc = &builtinNameConstTimeSig{} + _ builtinFunc = &builtinNameConstVectorFloat32Sig{} + _ builtinFunc = &builtinRealAnyValueSig{} + _ builtinFunc = &builtinReleaseAllLocksSig{} + _ builtinFunc = &builtinReleaseLockSig{} + _ builtinFunc = &builtinSleepSig{} + _ builtinFunc = &builtinStringAnyValueSig{} _ builtinFunc = &builtinTidbShardSig{} + _ builtinFunc = &builtinTimeAnyValueSig{} + _ builtinFunc = &builtinUsedLockSig{} + _ builtinFunc = &builtinUUIDSig{} + _ builtinFunc = &builtinUUIDTimestampSig{} + _ builtinFunc = &builtinUUIDToBinSig{} + _ builtinFunc = &builtinUUIDv4Sig{} + _ builtinFunc = &builtinUUIDv7Sig{} + _ builtinFunc = &builtinUUIDVersionSig{} + _ builtinFunc = &builtinVectorFloat32AnyValueSig{} + _ builtinFunc = &builtinVitessHashSig{} ) const ( @@ -1497,7 +1509,9 @@ func (b *builtinUUIDSig) Clone() builtinFunc { } // evalString evals a builtinUUIDSig. -// See https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_uuid +// See: +// - https://dev.mysql.com/doc/refman/8.4/en/miscellaneous-functions.html#function_uuid +// - https://datatracker.ietf.org/doc/html/rfc9562 func (b *builtinUUIDSig) evalString(ctx EvalContext, row chunk.Row) (d string, isNull bool, err error) { var id uuid.UUID id, err = uuid.NewUUID() @@ -1508,11 +1522,225 @@ func (b *builtinUUIDSig) evalString(ctx EvalContext, row chunk.Row) (d string, i return } +// Function: UUID_V4() +type uuidv4FunctionClass struct { + baseFunctionClass +} + +func (c *uuidv4FunctionClass) getFunction(ctx BuildContext, args []Expression) (builtinFunc, error) { + if err := c.verifyArgs(args); err != nil { + return nil, err + } + bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, types.ETString) + if err != nil { + return nil, err + } + charset, collate := ctx.GetCharsetInfo() + bf.tp.SetCharset(charset) + bf.tp.SetCollate(collate) + bf.tp.SetFlen(36) + sig := &builtinUUIDv4Sig{bf} + sig.setPbCode(tipb.ScalarFuncSig_UUID) + return sig, nil +} + +type builtinUUIDv4Sig struct { + baseBuiltinFunc + + // NOTE: Any new fields added here must be thread-safe or immutable during execution, + // as this expression may be shared across sessions. + // If a field does not meet these requirements, set SafeToShareAcrossSession to false. +} + +func (b *builtinUUIDv4Sig) Clone() builtinFunc { + newSig := &builtinUUIDv4Sig{} + newSig.cloneFrom(&b.baseBuiltinFunc) + return newSig +} + +// evalString evals a builtinUUIDv4Sig. +func (b *builtinUUIDv4Sig) evalString(ctx EvalContext, row chunk.Row) (d string, isNull bool, err error) { + var id uuid.UUID + id, err = uuid.NewRandom() + if err != nil { + return + } + d = id.String() + return +} + +// Function: UUID_V7() +type uuidv7FunctionClass struct { + baseFunctionClass +} + +func (c *uuidv7FunctionClass) getFunction(ctx BuildContext, args []Expression) (builtinFunc, error) { + if err := c.verifyArgs(args); err != nil { + return nil, err + } + bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, types.ETString) + if err != nil { + return nil, err + } + charset, collate := ctx.GetCharsetInfo() + bf.tp.SetCharset(charset) + bf.tp.SetCollate(collate) + bf.tp.SetFlen(36) + sig := &builtinUUIDv7Sig{bf} + sig.setPbCode(tipb.ScalarFuncSig_UUID) + return sig, nil +} + +type builtinUUIDv7Sig struct { + baseBuiltinFunc + + // NOTE: Any new fields added here must be thread-safe or immutable during execution, + // as this expression may be shared across sessions. + // If a field does not meet these requirements, set SafeToShareAcrossSession to false. +} + +func (b *builtinUUIDv7Sig) Clone() builtinFunc { + newSig := &builtinUUIDv7Sig{} + newSig.cloneFrom(&b.baseBuiltinFunc) + return newSig +} + +// evalString evals a builtinUUIDv7Sig. +func (b *builtinUUIDv7Sig) evalString(ctx EvalContext, row chunk.Row) (d string, isNull bool, err error) { + var id uuid.UUID + id, err = uuid.NewV7() + if err != nil { + return + } + d = id.String() + return +} + +// Function: UUID_VERSION() +type uuidVersionFunctionClass struct { + baseFunctionClass +} + +func (c *uuidVersionFunctionClass) getFunction(ctx BuildContext, args []Expression) (builtinFunc, error) { + if err := c.verifyArgs(args); err != nil { + return nil, err + } + bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, types.ETInt, types.ETString) + if err != nil { + return nil, err + } + bf.tp.SetFlen(10) + sig := &builtinUUIDVersionSig{bf} + return sig, nil +} + +type builtinUUIDVersionSig struct { + baseBuiltinFunc + + // NOTE: Any new fields added here must be thread-safe or immutable during execution, + // as this expression may be shared across sessions. + // If a field does not meet these requirements, set SafeToShareAcrossSession to false. +} + +func (b *builtinUUIDVersionSig) Clone() builtinFunc { + newSig := &builtinUUIDVersionSig{} + newSig.cloneFrom(&b.baseBuiltinFunc) + return newSig +} + +// evalInt evaluates a builtinUUIDVersionSig. +func (b *builtinUUIDVersionSig) evalInt(ctx EvalContext, row chunk.Row) (int64, bool, error) { + val, isNull, err := b.args[0].EvalString(ctx, row) + if isNull || err != nil { + return 0, isNull, err + } + u, err := uuid.Parse(val) + if err != nil { + return 0, isNull, err + } + return int64(u.Version()), false, nil +} + +// Function: UUID_TIMESTAMP() +type uuidTimestampFunctionClass struct { + baseFunctionClass +} + +func (c *uuidTimestampFunctionClass) getFunction(ctx BuildContext, args []Expression) (builtinFunc, error) { + if err := c.verifyArgs(args); err != nil { + return nil, err + } + bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, types.ETDecimal, types.ETString) + if err != nil { + return nil, err + } + bf.tp.SetFlen(18) + bf.tp.SetDecimalUnderLimit(6) + sig := &builtinUUIDTimestampSig{bf} + return sig, nil +} + +type builtinUUIDTimestampSig struct { + baseBuiltinFunc + + // NOTE: Any new fields added here must be thread-safe or immutable during execution, + // as this expression may be shared across sessions. + // If a field does not meet these requirements, set SafeToShareAcrossSession to false. +} + +func (b *builtinUUIDTimestampSig) Clone() builtinFunc { + newSig := &builtinUUIDTimestampSig{} + newSig.cloneFrom(&b.baseBuiltinFunc) + return newSig +} + +// evalInt evaluates a builtinUUIDTimestampSig. +func (b *builtinUUIDTimestampSig) evalDecimal(ctx EvalContext, row chunk.Row) (*types.MyDecimal, bool, error) { + val, isNull, err := b.args[0].EvalString(ctx, row) + if isNull || err != nil { + return new(types.MyDecimal), isNull, err + } + u, err := uuid.Parse(val) + if err != nil { + return new(types.MyDecimal), isNull, err + } + + switch u.Version() { + case 1: + case 6: + case 7: + default: + // No timestamp, return NULL + return new(types.MyDecimal), true, nil + } + + s, ns := u.Time().UnixTime() + r := new(types.MyDecimal) + r.FromInt((s * 1000000) + (ns / 1000)) + err = r.Shift(-6) + if err != nil { + return new(types.MyDecimal), isNull, err + } + err = r.Round(r, 6, types.ModeHalfUp) + if err != nil { + return new(types.MyDecimal), isNull, err + } + + return r, false, nil +} + type uuidShortFunctionClass struct { baseFunctionClass } func (c *uuidShortFunctionClass) getFunction(ctx BuildContext, args []Expression) (builtinFunc, error) { + // This should be: + // + // (server_id & 255) << 56 + // + (server_startup_time_in_seconds << 24) + // + incremented_variable++; + // + // But we have a noop server_id return nil, ErrFunctionNotExists.GenWithStackByArgs("FUNCTION", "UUID_SHORT") } diff --git a/pkg/expression/builtin_threadsafe_generated.go b/pkg/expression/builtin_threadsafe_generated.go index a544361dc90d0..5a5bb756a4c45 100644 --- a/pkg/expression/builtin_threadsafe_generated.go +++ b/pkg/expression/builtin_threadsafe_generated.go @@ -2399,11 +2399,31 @@ func (s *builtinUUIDSig) SafeToShareAcrossSession() bool { return safeToShareAcrossSession(&s.safeToShareAcrossSessionFlag, s.args) } +// SafeToShareAcrossSession implements BuiltinFunc.SafeToShareAcrossSession. +func (s *builtinUUIDTimestampSig) SafeToShareAcrossSession() bool { + return safeToShareAcrossSession(&s.safeToShareAcrossSessionFlag, s.args) +} + // SafeToShareAcrossSession implements BuiltinFunc.SafeToShareAcrossSession. func (s *builtinUUIDToBinSig) SafeToShareAcrossSession() bool { return safeToShareAcrossSession(&s.safeToShareAcrossSessionFlag, s.args) } +// SafeToShareAcrossSession implements BuiltinFunc.SafeToShareAcrossSession. +func (s *builtinUUIDVersionSig) SafeToShareAcrossSession() bool { + return safeToShareAcrossSession(&s.safeToShareAcrossSessionFlag, s.args) +} + +// SafeToShareAcrossSession implements BuiltinFunc.SafeToShareAcrossSession. +func (s *builtinUUIDv4Sig) SafeToShareAcrossSession() bool { + return safeToShareAcrossSession(&s.safeToShareAcrossSessionFlag, s.args) +} + +// SafeToShareAcrossSession implements BuiltinFunc.SafeToShareAcrossSession. +func (s *builtinUUIDv7Sig) SafeToShareAcrossSession() bool { + return safeToShareAcrossSession(&s.safeToShareAcrossSessionFlag, s.args) +} + // SafeToShareAcrossSession implements BuiltinFunc.SafeToShareAcrossSession. func (s *builtinUnHexSig) SafeToShareAcrossSession() bool { return safeToShareAcrossSession(&s.safeToShareAcrossSessionFlag, s.args) diff --git a/pkg/expression/function_traits.go b/pkg/expression/function_traits.go index 586afeb1801c7..fec212fbc5c76 100644 --- a/pkg/expression/function_traits.go +++ b/pkg/expression/function_traits.go @@ -51,6 +51,8 @@ var unFoldableFunctions = map[string]struct{}{ ast.FoundRows: {}, ast.Rand: {}, ast.UUID: {}, + ast.UUIDv4: {}, + ast.UUIDv7: {}, ast.Sleep: {}, ast.RowFunc: {}, ast.Values: {}, @@ -134,6 +136,8 @@ var IllegalFunctions4GeneratedColumns = map[string]struct{}{ ast.UTCTime: {}, ast.UTCTimestamp: {}, ast.UUID: {}, + ast.UUIDv4: {}, + ast.UUIDv7: {}, ast.UUIDShort: {}, ast.Values: {}, ast.Version: {}, @@ -250,6 +254,8 @@ var mutableEffectsFunctions = map[string]struct{}{ ast.Rand: {}, ast.RandomBytes: {}, ast.UUID: {}, + ast.UUIDv4: {}, + ast.UUIDv7: {}, ast.UUIDShort: {}, ast.Sleep: {}, ast.SetVar: {}, diff --git a/pkg/expression/function_traits_test.go b/pkg/expression/function_traits_test.go index 8256727d7db1b..8864e60478829 100644 --- a/pkg/expression/function_traits_test.go +++ b/pkg/expression/function_traits_test.go @@ -276,7 +276,9 @@ func TestIllegalFunctions4GeneratedColumns(t *testing.T) { "uncompressed_length", "unhex", "upper", + "uuid_timestamp", "uuid_to_bin", + "uuid_version", "validate_password_strength", "vec_as_text", "vec_cosine_distance", diff --git a/pkg/parser/ast/functions.go b/pkg/parser/ast/functions.go index f6ce1c22a0ee9..ea7fbcce8ae1b 100644 --- a/pkg/parser/ast/functions.go +++ b/pkg/parser/ast/functions.go @@ -293,6 +293,10 @@ const ( ReleaseAllLocks = "release_all_locks" Sleep = "sleep" UUID = "uuid" + UUIDv4 = "uuid_v4" + UUIDv7 = "uuid_v7" + UUIDVersion = "uuid_version" + UUIDTimestamp = "uuid_timestamp" UUIDShort = "uuid_short" UUIDToBin = "uuid_to_bin" BinToUUID = "bin_to_uuid" diff --git a/pkg/table/constraint.go b/pkg/table/constraint.go index cfa0f490ec935..96ffdafc9082c 100644 --- a/pkg/table/constraint.go +++ b/pkg/table/constraint.go @@ -120,6 +120,8 @@ var unsupportedNodeForCheckConstraint = map[string]struct{}{ ast.ReleaseAllLocks: {}, ast.LoadFile: {}, ast.UUID: {}, + ast.UUIDv4: {}, + ast.UUIDv7: {}, ast.UUIDShort: {}, ast.Sleep: {}, } diff --git a/tests/integrationtest/r/executor/show.result b/tests/integrationtest/r/executor/show.result index b27486339654b..69793e37958fd 100644 --- a/tests/integrationtest/r/executor/show.result +++ b/tests/integrationtest/r/executor/show.result @@ -869,7 +869,11 @@ utc_time utc_timestamp uuid uuid_short +uuid_timestamp uuid_to_bin +uuid_v4 +uuid_v7 +uuid_version validate_password_strength vec_as_text vec_cosine_distance diff --git a/tests/integrationtest/r/expression/uuid.result b/tests/integrationtest/r/expression/uuid.result new file mode 100644 index 0000000000000..013965c315bad --- /dev/null +++ b/tests/integrationtest/r/expression/uuid.result @@ -0,0 +1,47 @@ +SELECT IS_UUID(UUID()); +IS_UUID(UUID()) +1 +SELECT IS_UUID(UUID_V4()); +IS_UUID(UUID_V4()) +1 +SELECT IS_UUID(UUID_V7()); +IS_UUID(UUID_V7()) +1 +SELECT UUID_VERSION(UUID()); +UUID_VERSION(UUID()) +1 +SELECT UUID_VERSION(UUID_V4()); +UUID_VERSION(UUID_V4()) +4 +SELECT UUID_VERSION(UUID_V7()); +UUID_VERSION(UUID_V7()) +7 +SELECT UUID_TIMESTAMP('5f13f854-d74a-11f0-9b7a-0ae0156bd76b'); +UUID_TIMESTAMP('5f13f854-d74a-11f0-9b7a-0ae0156bd76b') +1765537487.118139 +SELECT FROM_UNIXTIME(UUID_TIMESTAMP('5f13f854-d74a-11f0-9b7a-0ae0156bd76b')); +FROM_UNIXTIME(UUID_TIMESTAMP('5f13f854-d74a-11f0-9b7a-0ae0156bd76b')) +2025-12-12 19:04:47.118139 +SELECT UUID_TIMESTAMP('a3e3b4a1-ea6d-471e-9860-8303a8b261f6'); +UUID_TIMESTAMP('a3e3b4a1-ea6d-471e-9860-8303a8b261f6') +NULL +SELECT UUID_TIMESTAMP('019b1440-87b7-7380-ab00-ce413e795004'); +UUID_TIMESTAMP('019b1440-87b7-7380-ab00-ce413e795004') +1765571332.023000 +SELECT UUID_SHORT(); +Error 1305 (42000): FUNCTION UUID_SHORT does not exist +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) AS (UUID())); +Error 3102 (HY000): Expression of generated column 'uuid' contains a disallowed function. +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) AS (UUID_V4())); +Error 3102 (HY000): Expression of generated column 'uuid' contains a disallowed function. +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) AS (UUID_V7())); +Error 3102 (HY000): Expression of generated column 'uuid' contains a disallowed function. +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) DEFAULT (UUID())); +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) DEFAULT (UUID_V4())); +Error 3770 (HY000): Default value expression of column 'uuid' contains a disallowed function: `UUID_V4`. +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) DEFAULT (UUID_V7())); +Error 3770 (HY000): Default value expression of column 'uuid' contains a disallowed function: `UUID_V7`. +CREATE TABLE t1234 (id int PRIMARY KEY, uuid BINARY(16) DEFAULT (UUID_TO_BIN(UUID()))); +CREATE TABLE t12345 (id int PRIMARY KEY, uuid BINARY(16) DEFAULT (UUID_TO_BIN(UUID_V4()))); +CREATE TABLE t12346 (id int PRIMARY KEY, uuid BINARY(16) DEFAULT (UUID_TO_BIN(UUID_V7()))); +DROP TABLE IF EXISTS t123, t1234, t12345, t12346; diff --git a/tests/integrationtest/t/expression/uuid.test b/tests/integrationtest/t/expression/uuid.test new file mode 100644 index 0000000000000..fe30bd8e520a6 --- /dev/null +++ b/tests/integrationtest/t/expression/uuid.test @@ -0,0 +1,44 @@ +SELECT IS_UUID(UUID()); +SELECT IS_UUID(UUID_V4()); +SELECT IS_UUID(UUID_V7()); + +SELECT UUID_VERSION(UUID()); +SELECT UUID_VERSION(UUID_V4()); +SELECT UUID_VERSION(UUID_V7()); + +# UUIDv1 +SELECT UUID_TIMESTAMP('5f13f854-d74a-11f0-9b7a-0ae0156bd76b'); +SELECT FROM_UNIXTIME(UUID_TIMESTAMP('5f13f854-d74a-11f0-9b7a-0ae0156bd76b')); + +# UUIDv3 +SELECT UUID_TIMESTAMP('a3e3b4a1-ea6d-471e-9860-8303a8b261f6'); + +# UUIDv7 +SELECT UUID_TIMESTAMP('019b1440-87b7-7380-ab00-ce413e795004'); + +-- error 1305 +SELECT UUID_SHORT(); + +-- error 3102 +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) AS (UUID())); + +-- error 3102 +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) AS (UUID_V4())); + +-- error 3102 +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) AS (UUID_V7())); + +# For now UUID() is allowed, but UUID_V4() and UUID_V7() are not yet allowed. +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) DEFAULT (UUID())); + +-- error 3770 +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) DEFAULT (UUID_V4())); + +-- error 3770 +CREATE TABLE t123 (id int PRIMARY KEY, uuid VARCHAR(255) DEFAULT (UUID_V7())); + +CREATE TABLE t1234 (id int PRIMARY KEY, uuid BINARY(16) DEFAULT (UUID_TO_BIN(UUID()))); +CREATE TABLE t12345 (id int PRIMARY KEY, uuid BINARY(16) DEFAULT (UUID_TO_BIN(UUID_V4()))); +CREATE TABLE t12346 (id int PRIMARY KEY, uuid BINARY(16) DEFAULT (UUID_TO_BIN(UUID_V7()))); + +DROP TABLE IF EXISTS t123, t1234, t12345, t12346;