Fix unique db object name issues

src/Microsoft.Data.SqlClient/tests/ManualTests/AlwaysEncrypted/ApiShould.cs

@@ -166,8 +166,8 @@ public void SqlParameterProperties(string connection)
             const string firstColumnName = @"firstColumn";
             const string secondColumnName = @"secondColumn";
             const string thirdColumnName = @"thirdColumn";
-            string inputProcedureName = DataTestUtility.GetUniqueName("InputProc").ToString();
-            string outputProcedureName = DataTestUtility.GetUniqueName("OutputProc").ToString();
+            string inputProcedureName = DataTestUtility.GetShortName("InputProc").ToString();
+            string outputProcedureName = DataTestUtility.GetShortName("OutputProc").ToString();
             const int charColumnSize = 100;
             const int decimalColumnPrecision = 10;
             const int decimalColumnScale = 4;
@@ -722,7 +722,7 @@ public void TestExecuteReader(string connection)
         [ClassData(typeof(AEConnectionStringProvider))]
         public async Task TestExecuteReaderAsyncWithLargeQuery(string connectionString)
         {
-            string randomName = DataTestUtility.GetUniqueName(Guid.NewGuid().ToString().Replace("-", ""), false);
+            string randomName = DataTestUtility.GetShortName(Guid.NewGuid().ToString().Replace("-", ""), false);
             if (randomName.Length > 50)
             {
                 randomName = randomName.Substring(0, 50);
@@ -912,8 +912,8 @@ public void TestEnclaveStoredProceduresWithAndWithoutParameters(string connectio
             using SqlCommand sqlCommand = new("", sqlConnection, transaction: null,
                 columnEncryptionSetting: SqlCommandColumnEncryptionSetting.Enabled);
 
-            string procWithoutParams = DataTestUtility.GetUniqueName("EnclaveWithoutParams", withBracket: false);
-            string procWithParam = DataTestUtility.GetUniqueName("EnclaveWithParams", withBracket: false);
+            string procWithoutParams = DataTestUtility.GetShortName("EnclaveWithoutParams", withBracket: false);
+            string procWithParam = DataTestUtility.GetShortName("EnclaveWithParams", withBracket: false);
 
             try
             {

src/Microsoft.Data.SqlClient/tests/ManualTests/DataCommon/DataTestUtility.cs

@@ -556,59 +556,159 @@ public static bool DoesHostAddressContainBothIPv4AndIPv6()
             }
         }
 
+        // Generate a new GUID and return the characters from its 1st and 4th
+        // parts, as shown here:
+        //
+        //   7ff01cb8-88c7-11f0-b433-00155d7e531e
+        //   ^^^^^^^^           ^^^^
+        //
+        // These 12 characters are concatenated together without any
+        // separators.  These 2 parts typically comprise a timestamp and clock
+        // sequence, most likely to be unique for tests that generate names in
+        // quick succession.
+        private static string GetGuidParts()
+        {
+            var guid = Guid.NewGuid().ToString();
+            // GOTCHA: The slice operator is inclusive of the start index and
+            // exclusive of the end index!
+            return guid[0..8] + guid[19..23];
+        }
+
         /// <summary>
-        /// Generate a unique name to use in Sql Server; 
-        /// some providers does not support names (Oracle supports up to 30).
+        /// Generate a short unique database object name, whose maximum length
+        /// is 30 characters, with the format:
+        ///
+        ///   <GUID-Parts>-<Suffix>
+        ///
+        /// The GUID Parts will be the characters from the 1st and 4th blocks
+        /// from a traditional string representation, as shown here:
+        ///
+        ///   7ff01cb8-88c7-11f0-b433-00155d7e531e
+        ///   ^^^^^^^^           ^^^^
+        ///
+        /// These 12 characters are concatenated together without any
+        /// separators.  These 2 parts typically comprise a timestamp and clock
+        /// sequence, most likely to be unique for tests that generate names in
+        /// quick succession.
+        ///
+        /// The Suffix will be truncated to satisfy the overall maximum length.
         /// </summary>
-        /// <param name="prefix">The name length will be no more then (16 + prefix.Length + escapeLeft.Length + escapeRight.Length).</param>
-        /// <param name="withBracket">Name without brackets.</param>
-        /// <returns>Unique name by considering the Sql Server naming rules.</returns>
-        public static string GetUniqueName(string prefix, bool withBracket = true)
-        {
-            string escapeLeft = withBracket ? "[" : string.Empty;
-            string escapeRight = withBracket ? "]" : string.Empty;
-            string uniqueName = string.Format("{0}{1}_{2}_{3}{4}",
-                escapeLeft,
-                prefix,
-                DateTime.Now.Ticks.ToString("X", CultureInfo.InvariantCulture), // up to 8 characters
-                Guid.NewGuid().ToString().Substring(0, 6), // take the first 6 characters only
-                escapeRight);
-            return uniqueName;
+        /// 
+        /// <param name="suffix">
+        /// The suffix to use when generating the unique name, truncated to at
+        /// most 18 characters when withBracket is false, and 16 characters when
+        /// withBracket is true.
+        /// </param>
+        /// 
+        /// <param name="withBracket">
+        /// When true, the entire generated name will be enclosed in square
+        /// brackets, for example:
+        /// 
+        ///   [7ff01cb811f0-MySuffix]
+        /// </param>
+        /// 
+        /// <returns>
+        /// A unique database object name, no more than 30 characters long.
+        /// </returns>
+        public static string GetShortName(string suffix, bool withBracket = true)
+        {
+            StringBuilder name = new(30);
+
+            if (withBracket)
+            {
+                name.Append('[');
+            }
+
+            name.Append(GetGuidParts());
+            name.Append('-');
+
+            int maxSuffixLength = withBracket ? 16 : 18;
+            if (suffix.Length > maxSuffixLength)
+            {
+                suffix = suffix[0..maxSuffixLength];
+            }
+            name.Append(suffix);
+
+            if (withBracket)
+            {
+                name.Append(']');
+            }
+
+            return name.ToString();
         }
 
         /// <summary>
-        /// Uses environment values `UserName` and `MachineName` in addition to the specified `prefix` and current date
-        /// to generate a unique name to use in Sql Server; 
-        /// SQL Server supports long names (up to 128 characters), add extra info for troubleshooting.
+        /// Generate a long unique database object name, whose maximum length is
+        /// 96 characters, with the format:
+        /// 
+        ///   <GUID-Parts>-<Suffix>-<UserName>-<MachineName>
+        ///
+        /// The GUID Parts will be the characters from the 1st and 4th blocks
+        /// from a traditional string representation, as shown here:
+        ///
+        ///   7ff01cb8-88c7-11f0-b433-00155d7e531e
+        ///   ^^^^^^^^           ^^^^
+        ///
+        /// These 12 characters are concatenated together without any
+        /// separators.  These 2 parts typically comprise a timestamp and clock
+        /// sequence, most likely to be unique for tests that generate names in
+        /// quick succession.
+        ///
+        /// The UserName and MachineName are obtained from the Environment,
+        /// and will be truncated to satisfy the maximum overall length.
         /// </summary>
-        /// <param name="prefix">Add the prefix to the generate string.</param>
-        /// <param name="withBracket">Database name must be pass with brackets by default.</param>
-        /// <returns>Unique name by considering the Sql Server naming rules, never longer than 96 characters.</returns>
-        public static string GetUniqueNameForSqlServer(string prefix, bool withBracket = true)
-        {
-            string extendedPrefix = string.Format(
-                "{0}_{1}_{2}@{3}",
-                prefix,
-                Environment.UserName,
-                Environment.MachineName,
-                DateTime.Now.ToString("yyyy_MM_dd", CultureInfo.InvariantCulture));
-            string name = GetUniqueName(extendedPrefix, withBracket);
-
-            // Truncate to no more than 96 characters.
-            const int maxLen = 96;
-            if (name.Length > maxLen)
-            {
-                if (withBracket)
-                {
-                    name = name.Substring(0, maxLen - 1) + ']';
-                }
-                else
-                {
-                    name = name.Substring(0, maxLen);
-                }
+        /// 
+        /// <param name="suffix">
+        /// The suffix to use when generating the unique name, truncated to at
+        /// most 32 characters.
+        /// </param>
+        /// 
+        /// <param name="withBracket">
+        /// When true, the entire generated name will be enclosed in square
+        /// brackets, for example:
+        /// 
+        ///   [7ff01cb811f0-MySuffix-test_user-ci_agent_machine_name]
+        /// </param>
+        /// 
+        /// <returns>
+        /// A unique database object name, no more than 30 characters long.
+        /// </returns>
+        public static string GetLongName(string suffix, bool withBracket = true)
+        {
+            StringBuilder name = new(96);
+
+            if (withBracket)
+            {
+                name.Append('[');
+            }
+
+            name.Append(GetGuidParts());
+            name.Append('-');
+
+            if (suffix.Length > 32)
+            {
+                suffix = suffix[0..32];
+            }
+
+            suffix =
+              suffix + '-' +
+              Environment.UserName + '-' +
+              Environment.MachineName;
+
+            int maxSuffixLength = withBracket ? 82 : 84;
+            if (suffix.Length > maxSuffixLength)
+            {
+                suffix = suffix[0..maxSuffixLength];
+            }
+
+            name.Append(suffix);
+
+            if (withBracket)
+            {
+                name.Append(']');
             }
 
-            return name;
+            return name.ToString();
         }
 
         public static void CreateTable(SqlConnection sqlConnection, string tableName, string createBody)

src/Microsoft.Data.SqlClient/tests/ManualTests/ProviderAgnostic/ReaderTest/ReaderTest.cs

@@ -19,7 +19,7 @@ public static void TestMain()
         {
             string connectionString = DataTestUtility.TCPConnectionString;
 
-            string tempTable = DataTestUtility.GetUniqueNameForSqlServer("table");
+            string tempTable = DataTestUtility.GetLongName("table");
 
             DbProviderFactory provider = SqlClientFactory.Instance;
             try
@@ -275,7 +275,7 @@ public static void TestMain()
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
         public static void SqlDataReader_SqlBuffer_GetFieldValue()
         {
-            string tableName = DataTestUtility.GetUniqueNameForSqlServer("SqlBuffer_GetFieldValue");
+            string tableName = DataTestUtility.GetLongName("SqlBuffer_GetFieldValue");
             DateTimeOffset dtoffset = DateTimeOffset.Now;
             DateTime dt = DateTime.Now;
             //Exclude the millisecond because of rounding at some points by SQL Server.
@@ -374,7 +374,7 @@ public static void SqlDataReader_SqlBuffer_GetFieldValue()
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
         public static async Task SqlDataReader_SqlBuffer_GetFieldValue_Async()
         {
-            string tableName = DataTestUtility.GetUniqueNameForSqlServer("SqlBuffer_GetFieldValue_Async");
+            string tableName = DataTestUtility.GetLongName("SqlBuffer_GetFieldValue_Async");
             DateTimeOffset dtoffset = DateTimeOffset.Now;
             DateTime dt = DateTime.Now;
             //Exclude the millisecond because of rounding at some points by SQL Server.

src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/AdapterTest/AdapterTest.cs

@@ -54,7 +54,7 @@ public class AdapterTest
         public AdapterTest()
         {
             // create random name for temp tables
-            _tempTable = DataTestUtility.GetUniqueName("AdapterTest");
+            _tempTable = DataTestUtility.GetShortName("AdapterTest");
             _tempTable = _tempTable.Replace('-', '_');
 
             _randomGuid = Guid.NewGuid().ToString();
@@ -555,7 +555,7 @@ public void ParameterTest_AllTypes()
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
         public void ParameterTest_InOut()
         {
-            string procName = DataTestUtility.GetUniqueName("P");
+            string procName = DataTestUtility.GetShortName("P");
             // input, output
             string spCreateInOut =
                 "CREATE PROCEDURE " + procName + " @in int, @inout int OUTPUT, @out nvarchar(8) OUTPUT " +
@@ -836,13 +836,13 @@ public void BulkUpdateTest()
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
         public void UpdateRefreshTest()
         {
-            string identTableName = DataTestUtility.GetUniqueName("ID_");
+            string identTableName = DataTestUtility.GetShortName("ID_");
             string createIdentTable =
                 $"CREATE TABLE {identTableName} (id int IDENTITY," +
                 "LastName nvarchar(50) NULL," +
                 "Firstname nvarchar(50) NULL)";
 
-            string spName = DataTestUtility.GetUniqueName("sp_insert", withBracket: false);
+            string spName = DataTestUtility.GetShortName("sp_insert", withBracket: false);
             string spCreateInsert =
                 $"CREATE PROCEDURE {spName}" +
                 "(@FirstName nvarchar(50), @LastName nvarchar(50), @id int OUTPUT) " +
@@ -1155,7 +1155,7 @@ public void AutoGenUpdateTest()
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse))]
         public void AutoGenErrorTest()
         {
-            string identTableName = DataTestUtility.GetUniqueName("ID_");
+            string identTableName = DataTestUtility.GetShortName("ID_");
             string createIdentTable =
                 $"CREATE TABLE {identTableName} (id int IDENTITY," +
                 "LastName nvarchar(50) NULL," +

src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/ConnectivityTests/ConnectivityTest.cs

@@ -393,7 +393,7 @@ public static async Task ConnectionOpenAsyncDisableRetry()
         {
             SqlConnectionStringBuilder connectionStringBuilder = new(DataTestUtility.TCPConnectionString)
             {
-                InitialCatalog = DataTestUtility.GetUniqueNameForSqlServer("DoesNotExist", false),
+                InitialCatalog = DataTestUtility.GetLongName("DoesNotExist", false),
                 Pooling = false,
                 ConnectTimeout = 15,
                 ConnectRetryCount = 3

src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/DataClassificationTest/DataClassificationTest.cs

@@ -18,7 +18,7 @@ public static class DataClassificationTest
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsNotAzureSynapse), nameof(DataTestUtility.IsSupportedDataClassification))]
         public static void TestDataClassificationResultSetRank()
         {
-            s_tableName = DataTestUtility.GetUniqueNameForSqlServer("DC");
+            s_tableName = DataTestUtility.GetLongName("DC");
             using (SqlConnection sqlConnection = new SqlConnection(DataTestUtility.TCPConnectionString))
             using (SqlCommand sqlCommand = sqlConnection.CreateCommand())
             {
@@ -41,7 +41,7 @@ public static void TestDataClassificationResultSetRank()
         [ConditionalFact(typeof(DataTestUtility), nameof(DataTestUtility.AreConnStringsSetup), nameof(DataTestUtility.IsSupportedDataClassification))]
         public static void TestDataClassificationResultSet()
         {
-            s_tableName = DataTestUtility.GetUniqueNameForSqlServer("DC");
+            s_tableName = DataTestUtility.GetLongName("DC");
             using (SqlConnection sqlConnection = new SqlConnection(DataTestUtility.TCPConnectionString))
             using (SqlCommand sqlCommand = sqlConnection.CreateCommand())
             {
@@ -232,7 +232,7 @@ public static void TestDataClassificationBulkCopy()
             data.Rows.Add(Guid.NewGuid(), "Company 2", "[email protected]", 1);
             data.Rows.Add(Guid.NewGuid(), "Company 3", "[email protected]", 1);
 
-            var tableName = DataTestUtility.GetUniqueNameForSqlServer("DC");
+            var tableName = DataTestUtility.GetLongName("DC");
 
             using (var connection = new SqlConnection(DataTestUtility.TCPConnectionString))
             {

src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/DataReaderTest/DataReaderTest.cs

@@ -131,7 +131,7 @@ public static void CheckSparseColumnBit()
         [InlineData("Georgian_Modern_Sort_CI_AS")]
         public static void CollatedDataReaderTest(string collation)
         {
-            string dbName = DataTestUtility.GetUniqueName("CollationTest", false);
+            string dbName = DataTestUtility.GetShortName("CollationTest", false);
 
             SqlConnectionStringBuilder builder = new(DataTestUtility.TCPConnectionString)
             {

src/Microsoft.Data.SqlClient/tests/ManualTests/SQL/DataStreamTest/DataStreamTest.cs

@@ -52,7 +52,7 @@ public static async Task AsyncMultiPacketStreamRead()
 
             byte[] inputData = null;
             byte[] outputData = null;
-            string tableName = DataTestUtility.GetUniqueNameForSqlServer("data");
+            string tableName = DataTestUtility.GetLongName("data");
 
             using (SqlConnection connection = new(connectionString))
             {
@@ -556,7 +556,7 @@ private static void RowBuffer(string connectionString)
 
         private static void TimestampRead(string connectionString)
         {
-            string tempTable = DataTestUtility.GetUniqueNameForSqlServer("##Temp");
+            string tempTable = DataTestUtility.GetLongName("##Temp");
             tempTable = tempTable.Replace('-', '_');
 
             using (SqlConnection conn = new SqlConnection(connectionString))
@@ -1062,7 +1062,7 @@ private static void SequentialAccess(string connectionString)
 
         private static void NumericRead(string connectionString)
         {
-            string tempTable = DataTestUtility.GetUniqueNameForSqlServer("##Temp");
+            string tempTable = DataTestUtility.GetLongName("##Temp");
             tempTable = tempTable.Replace('-', '_');
 
             using (SqlConnection conn = new SqlConnection(connectionString))
@@ -1892,8 +1892,8 @@ private static void StreamingBlobDataTypes(string connectionString)
 
         private static void VariantCollationsTest(string connectionString)
         {
-            string dbName = DataTestUtility.GetUniqueName("JPN");
-            string tableName = DataTestUtility.GetUniqueName("T");
+            string dbName = DataTestUtility.GetShortName("JPN");
+            string tableName = DataTestUtility.GetShortName("T");
 
             using (SqlConnection connection = new SqlConnection(connectionString))
             {