Ensure that generated GUIDs conform to the RFC 4122 standard.

src/EFCore.MySql/Storage/Internal/MySqlConnectionSettings.cs

@@ -35,8 +35,8 @@ public MySqlConnectionSettings(string connectionString)
  TreatTinyAsBoolean = csb.TreatTinyAsBoolean;
  }
 
- public MySqlGuidFormat GuidFormat { get; }
- public bool TreatTinyAsBoolean { get; }
+ public virtual MySqlGuidFormat GuidFormat { get; }
+ public virtual bool TreatTinyAsBoolean { get; }
 
  protected bool Equals(MySqlConnectionSettings other)
  {

src/EFCore.MySql/ValueGeneration/Internal/MySqlSequentialGuidValueGenerator.cs

@@ -22,16 +22,39 @@ public MySqlSequentialGuidValueGenerator(IMySqlOptions options)
  /// <summary>
  /// Gets a value to be assigned to a property.
  /// Creates a GUID where the first 8 bytes are the current UTC date/time (in ticks)
- /// and the last 8 bytes are cryptographically random.  This allows for better performance
+ /// and the rest are cryptographically random. This allows for better performance
  /// in clustered index scenarios.
  /// </summary>
  /// <para>The change tracking entry of the entity for which the value is being generated.</para>
  /// <returns> The value to be assigned to a property. </returns>
  public override Guid Next(EntityEntry entry)
  {
- var randomBytes = new byte[8];
+ return Next();
+ }
+
+ public Guid Next()
+ {
+ return Next(DateTimeOffset.UtcNow);
+ }
+
+ public Guid Next(DateTimeOffset timeNow)
+ {
+ // According to RFC 4122:
+ // dddddddd-dddd-Mddd-Ndrr-rrrrrrrrrrrr
+ // - M = RFC version, in this case '4' for random UUID
+ // - N = RFC variant (plus other bits), in this case 0b1000 for variant 1
+ // - d = nibbles based on UTC date/time in ticks
+ // - r = nibbles based on random bytes
+
+ var randomBytes = new byte[7];
  _rng.GetBytes(randomBytes);
- var ticks = (ulong) DateTime.UtcNow.Ticks;
+ var ticks = (ulong) timeNow.Ticks;
+
+ var uuidVersion = (ushort) 4;
+ var uuidVariant = (ushort) 0b1000;
+
+ var ticksAndVersion = (ushort)((ticks << 48 >> 52) | (ushort)(uuidVersion << 12));
+ var ticksAndVariant = (byte) ((ticks << 60 >> 60) | (byte) (uuidVariant << 4));
 
  if (_options.ConnectionSettings.GuidFormat == MySqlGuidFormat.LittleEndianBinary16)
  {
@@ -42,21 +65,24 @@ public override Guid Next(EntityEntry entry)
  Array.Reverse(tickBytes);
  }
 
- Buffer.BlockCopy(tickBytes, 0, guidBytes, 0, 8);
- Buffer.BlockCopy(randomBytes, 0, guidBytes, 8, 8);
+ Buffer.BlockCopy(tickBytes, 0, guidBytes, 0, 6);
+ guidBytes[6] = (byte)(ticksAndVersion << 8 >> 8);
+ guidBytes[7] = (byte)(ticksAndVersion >> 8);
+ guidBytes[8] = ticksAndVariant;
+ Buffer.BlockCopy(randomBytes, 0, guidBytes, 9, 7);
 
  return new Guid(guidBytes);
  }
 
- var guid = new Guid((uint) (ticks >> 32), (ushort) (ticks << 32 >> 48), (ushort) (ticks << 48 >> 48),
+ var guid = new Guid((uint) (ticks >> 32), (ushort) (ticks << 32 >> 48), ticksAndVersion,
+ ticksAndVariant,
  randomBytes[0],
  randomBytes[1],
  randomBytes[2],
  randomBytes[3],
  randomBytes[4],
  randomBytes[5],
- randomBytes[6],
- randomBytes[7]);
+ randomBytes[6]);
 
  return guid;
  }

test/EFCore.MySql.Tests/ValueGeneration/Internal/MysqlSequentialGuidValueGeneratorTest.cs

@@ -0,0 +1,132 @@
+using System;
+using System.Linq;
+using Moq;
+using MySql.Data.MySqlClient;
+using Pomelo.EntityFrameworkCore.MySql.Internal;
+using Pomelo.EntityFrameworkCore.MySql.Storage.Internal;
+using Pomelo.EntityFrameworkCore.MySql.ValueGeneration.Internal;
+using Xunit;
+
+namespace Pomelo.EntityFrameworkCore.MySql.Tests.ValueGeneration.Internal
+{
+ public class MysqlSequentialGuidValueGeneratorTest
+ {
+ private MySqlSequentialGuidValueGenerator GetGenerator(bool mysqlGuidFormatIsLittleEndianBinary16) {
+ var connectionSettings = new Mock<MySqlConnectionSettings>();
+ connectionSettings.SetupGet(x => x.GuidFormat).Returns(mysqlGuidFormatIsLittleEndianBinary16 ? MySqlGuidFormat.LittleEndianBinary16 : MySqlGuidFormat.None);
+
+ var options = new Mock<MySqlOptions>();
+ options.SetupGet(x => x.ConnectionSettings).Returns(connectionSettings.Object);
+
+ return new MySqlSequentialGuidValueGenerator(options.Object);
+ }
+
+ [Fact]
+ public void Next_returns_new_Guid()
+ {
+ var guid = GetGenerator(false).Next();
+ Assert.NotEqual(Guid.Empty, guid);
+ }
+
+ [Fact]
+ public void Next_returns_new_Guid_LittleEndianBinary16()
+ {
+ var guid = GetGenerator(true).Next();
+ Assert.NotEqual(Guid.Empty, guid);
+ }
+
+ [Fact]
+ public void Next_returns_loosely_sorted_Guid()
+ {
+ // GUIDs are loosely sorted on time. When one GUID is generated at
+ // least one tick (100 ns) after the last, it is sorted higher than
+ // the previous one. This property gives us a performance benefit
+ // on sorting in the database.
+ var generator = GetGenerator(false);
+
+ var timeNow = DateTimeOffset.UtcNow;
+ var lastGuid = generator.Next(timeNow);
+ for(var i = 0; i < 100; ++i) {
+ timeNow = timeNow.AddTicks(1);
+ var guid = generator.Next(timeNow);
+ Assert.True(string.Compare(guid.ToString(), lastGuid.ToString()) > 0);
+ lastGuid = guid;
+ }
+ }
+
+ [Fact]
+ public void Next_returns_loosely_sorted_Guid_LittleEndianBinary16()
+ {
+ // GUIDs are loosely sorted on time. When one GUID is generated at
+ // least one tick (100 ns) after the last, it is sorted higher than
+ // the previous one. This property gives us a performance benefit
+ // on sorting in the database.
+ var generator = GetGenerator(true);
+
+ var timeNow = DateTimeOffset.UtcNow;
+ var lastGuid = generator.Next(timeNow);
+ for(var i = 0; i < 100; ++i) {
+ timeNow = timeNow.AddTicks(1);
+ var guid = generator.Next(timeNow);
+ Assert.True(string.Compare(guid.ToString(), lastGuid.ToString()) > 0);
+ lastGuid = guid;
+ }
+ }
+
+ [Fact]
+ public void Next_returns_valid_Rfc4122_random_Guid()
+ {
+ var generator = GetGenerator(false);
+
+ // Since the values are based on randomness and time, perform this test
+ // multiple times to increase the chance of finding incorrect values.
+ for(var i = 0; i < 100; ++i) {
+ var guid = generator.Next();
+ var bytes = guid.ToByteArray();
+ // Version, indicated by the 13th nibble, must be 4
+ var version = bytes[7] >> 4;
+ Assert.Equal(4, version);
+ // Variant, indicated by the first bits of the 17th nibble, must be 0b10xx
+ var variant = (bytes[8] >> 4) & 0b1100;
+ Assert.Equal(0b1000, variant);
+ }
+ }
+
+ [Fact]
+ public void Next_returns_valid_Rfc4122_random_Guid_LittleEndianBinary16()
+ {
+ var generator = GetGenerator(true);
+
+ // Since the values are based on randomness and time, perform this test
+ // multiple times to increase the chance of finding incorrect values.
+ for(var i = 0; i < 100; ++i) {
+ var guid = generator.Next();
+ var bytes = guid.ToByteArray();
+ // Version, indicated by the 13th nibble, must be 4
+ var version = bytes[7] >> 4;
+ Assert.Equal(4, version);
+ // Variant, indicated by the first bits of the 17th nibble, must be 0b10xx
+ var variant = (bytes[8] >> 4) & 0b1100;
+ Assert.Equal(0b1000, variant);
+ }
+ }
+
+ [Fact]
+ public void Next_returns_unique_Guid()
+ {
+ var generator = GetGenerator(false);
+
+ var guids = Enumerable.Range(0, 100).Select(_ => generator.Next()).ToArray();
+ Assert.Equal(guids.Distinct().Count(), guids.Length);
+ }
+
+ [Fact]
+ public void Next_returns_unique_Guid_LittleEndianBinary16()
+ {
+ var generator = GetGenerator(true);
+
+ var guids = Enumerable.Range(0, 100).Select(_ => generator.Next()).ToArray();
+ Assert.Equal(guids.Distinct().Count(), guids.Length);
+ }
+ }
+}