replace read async with read of SqlReader for perf

src/SqlAsyncCollector.cs

@@ -183,7 +183,6 @@ private async Task UpsertRowsAsync(IList<T> rows, SqlAttribute attribute, IConfi
                 string cacheKey = $"{connection.ConnectionString.GetHashCode()}-{fullTableName}";
 
                 ObjectCache cachedTables = MemoryCache.Default;
-                var tableInfo = cachedTables[cacheKey] as TableInformation;
 
                 int timeout = AZ_FUNC_TABLE_INFO_CACHE_TIMEOUT_MINUTES;
                 string timeoutEnvVar = Environment.GetEnvironmentVariable("AZ_FUNC_TABLE_INFO_CACHE_TIMEOUT_MINUTES");
@@ -199,11 +198,11 @@ private async Task UpsertRowsAsync(IList<T> rows, SqlAttribute attribute, IConfi
                     }
                 }
 
-                if (tableInfo == null)
+                if (!(cachedTables[cacheKey] is TableInformation tableInfo))
                 {
                     TelemetryInstance.TrackEvent(TelemetryEventName.TableInfoCacheMiss, props);
                     // set the columnNames for supporting T as JObject since it doesn't have columns in the member info.
-                    tableInfo = await TableInformation.RetrieveTableInformationAsync(connection, fullTableName, this._logger, GetColumnNamesFromItem(rows.First()), this._serverProperties);
+                    tableInfo = TableInformation.RetrieveTableInformation(connection, fullTableName, this._logger, GetColumnNamesFromItem(rows.First()), this._serverProperties);
                     var policy = new CacheItemPolicy
                     {
                         // Re-look up the primary key(s) after timeout (default timeout is 10 minutes)
@@ -550,7 +549,7 @@ WHEN NOT MATCHED THEN
             /// <param name="objectColumnNames">Column names from the object</param>
             /// <param name="serverProperties">EngineEdition and Edition of the target Sql Server.</param>
             /// <returns>TableInformation object containing primary keys, column types, etc.</returns>
-            public static async Task<TableInformation> RetrieveTableInformationAsync(SqlConnection sqlConnection, string fullName, ILogger logger, IEnumerable<string> objectColumnNames, ServerProperties serverProperties)
+            public static TableInformation RetrieveTableInformation(SqlConnection sqlConnection, string fullName, ILogger logger, IEnumerable<string> objectColumnNames, ServerProperties serverProperties)
             {
                 Dictionary<TelemetryPropertyName, string> sqlConnProps = sqlConnection.AsConnectionProps(serverProperties);
                 var table = new SqlObject(fullName);
@@ -564,9 +563,9 @@ public static async Task<TableInformation> RetrieveTableInformationAsync(SqlConn
                 {
                     string getColumnDefinitionsQuery = GetColumnDefinitionsQuery(table);
                     var cmdColDef = new SqlCommand(getColumnDefinitionsQuery, sqlConnection);
-                    using (SqlDataReader rdr = await cmdColDef.ExecuteReaderAsyncWithLogging(logger, CancellationToken.None))
+                    using (SqlDataReader rdr = cmdColDef.ExecuteReaderWithLogging(logger))
                     {
-                        while (await rdr.ReadAsync())
+                        while (rdr.Read())
                         {
                             string columnName = rdr[ColumnName].ToString();
                             columnDefinitionsFromSQL.Add(columnName, rdr[ColumnDefinition].ToString());
@@ -599,9 +598,9 @@ public static async Task<TableInformation> RetrieveTableInformationAsync(SqlConn
                 {
                     string getPrimaryKeysQuery = GetPrimaryKeysQuery(table);
                     var cmd = new SqlCommand(getPrimaryKeysQuery, sqlConnection);
-                    using (SqlDataReader rdr = await cmd.ExecuteReaderAsyncWithLogging(logger, CancellationToken.None))
+                    using (SqlDataReader rdr = cmd.ExecuteReaderWithLogging(logger))
                     {
-                        while (await rdr.ReadAsync())
+                        while (rdr.Read())
                         {
                             string columnName = rdr[ColumnName].ToString();
                             primaryKeys.Add(new PrimaryKey(columnName, bool.Parse(rdr[IsIdentity].ToString()), bool.Parse(rdr[HasDefault].ToString())));
@@ -656,7 +655,7 @@ public static async Task<TableInformation> RetrieveTableInformationAsync(SqlConn
                 sqlConnProps.Add(TelemetryPropertyName.QueryType, queryType.ToString());
                 sqlConnProps.Add(TelemetryPropertyName.HasIdentityColumn, hasIdentityColumnPrimaryKeys.ToString());
                 TelemetryInstance.TrackDuration(TelemetryEventName.GetTableInfo, tableInfoSw.ElapsedMilliseconds, sqlConnProps, durations);
-                logger.LogDebug($"RetrieveTableInformationAsync DB and Table: {sqlConnection.Database}.{fullName}. Primary keys: [{string.Join(",", primaryKeys.Select(pk => pk.Name))}].\nSQL Column and Definitions:  [{string.Join(",", columnDefinitionsFromSQL)}]\nObject columns: [{string.Join(",", objectColumnNames)}]");
+                logger.LogDebug($"RetrieveTableInformation DB and Table: {sqlConnection.Database}.{fullName}. Primary keys: [{string.Join(",", primaryKeys.Select(pk => pk.Name))}].\nSQL Column and Definitions:  [{string.Join(",", columnDefinitionsFromSQL)}]\nObject columns: [{string.Join(",", objectColumnNames)}]");
                 return new TableInformation(primaryKeys, primaryKeyProperties, columnDefinitionsFromSQL, queryType, hasIdentityColumnPrimaryKeys);
             }
         }

src/SqlAsyncEnumerable.cs

@@ -90,7 +90,7 @@ public ValueTask DisposeAsync()
             /// </returns>
             public ValueTask<bool> MoveNextAsync()
             {
-                return new ValueTask<bool>(this.GetNextRowAsync());
+                return new ValueTask<bool>(this.GetNextRow());
             }
 
             /// <summary>
@@ -99,7 +99,7 @@ public ValueTask<bool> MoveNextAsync()
             /// <returns>
             /// True if there is another row left in the query to process, or false if this was the last row
             /// </returns>
-            private async Task<bool> GetNextRowAsync()
+            private bool GetNextRow()
             {
                 // check connection state before trying to access the reader
                 // if DisposeAsync has already closed it due to the issue described here https://github.com/Azure/azure-functions-sql-extension/issues/350
@@ -109,10 +109,10 @@ private async Task<bool> GetNextRowAsync()
                     {
                         using (SqlCommand command = SqlBindingUtilities.BuildCommand(this._attribute, this._connection))
                         {
-                            this._reader = await command.ExecuteReaderAsync();
+                            this._reader = command.ExecuteReader();
                         }
                     }
-                    if (await this._reader.ReadAsync())
+                    if (this._reader.Read())
                     {
                         this.Current = Utils.JsonDeserializeObject<T>(this.SerializeRow());
                         return true;

src/SqlBindingUtilities.cs

@@ -194,7 +194,7 @@ public static async Task VerifyDatabaseSupported(SqlConnection connection, ILogg
             string verifyDatabaseSupportedQuery = $"SELECT compatibility_level FROM sys.databases WHERE Name = DB_NAME()";
 
             using (var verifyDatabaseSupportedCommand = new SqlCommand(verifyDatabaseSupportedQuery, connection))
-            using (SqlDataReader reader = await verifyDatabaseSupportedCommand.ExecuteReaderAsyncWithLogging(logger, cancellationToken))
+            using (SqlDataReader reader = verifyDatabaseSupportedCommand.ExecuteReaderWithLogging(logger))
             {
                 if (!await reader.ReadAsync(cancellationToken))
                 {
@@ -326,7 +326,7 @@ public static async Task<ServerProperties> GetServerTelemetryProperties(SqlConne
                     string serverPropertiesQuery = $"SELECT SERVERPROPERTY('EngineEdition'), SERVERPROPERTY('Edition')";
 
                     using (var selectServerEditionCommand = new SqlCommand(serverPropertiesQuery, connection))
-                    using (SqlDataReader reader = await selectServerEditionCommand.ExecuteReaderAsyncWithLogging(logger, cancellationToken))
+                    using (SqlDataReader reader = selectServerEditionCommand.ExecuteReaderWithLogging(logger))
                     {
                         if (await reader.ReadAsync(cancellationToken))
                         {
@@ -431,22 +431,21 @@ public static async Task<int> ExecuteNonQueryAsyncWithLogging(this SqlCommand cm
         }
 
         /// <summary>
-        /// Calls ExecuteReaderAsync and logs an error if it fails before rethrowing.
+        /// Calls ExecuteReader and logs an error if it fails before rethrowing.
         /// </summary>
         /// <param name="cmd">The SqlCommand being executed</param>
         /// <param name="logger">The logger</param>
-        /// <param name="cancellationToken">The cancellation token to pass to the call</param>
         /// <param name="logCommand">Defaults to false and when set logs the command being executed</param>
         /// <returns>The result of the call</returns>
-        public static async Task<SqlDataReader> ExecuteReaderAsyncWithLogging(this SqlCommand cmd, ILogger logger, CancellationToken cancellationToken, bool logCommand = false)
+        public static SqlDataReader ExecuteReaderWithLogging(this SqlCommand cmd, ILogger logger, bool logCommand = false)
         {
             try
             {
                 if (logCommand)
                 {
                     logger.LogDebug($"Executing query={cmd.CommandText}");
                 }
-                return await cmd.ExecuteReaderAsync(cancellationToken);
+                return cmd.ExecuteReader();
             }
             catch (Exception e)
             {

src/TriggerBinding/SqlTableChangeMonitor.cs

@@ -295,10 +295,11 @@ private async Task GetTableChangesAsync(SqlConnection connection, CancellationTo
                         {
                             var commandSw = Stopwatch.StartNew();
 
-                            using (SqlDataReader reader = await getChangesCommand.ExecuteReaderAsync(token))
+                            using (SqlDataReader reader = getChangesCommand.ExecuteReader())
                             {
-                                while (await reader.ReadAsync(token))
+                                while (reader.Read())
                                 {
+                                    token.ThrowIfCancellationRequested();
                                     rows.Add(SqlBindingUtilities.BuildDictionaryFromSqlRow(reader));
                                 }
                             }

src/TriggerBinding/SqlTriggerListener.cs

@@ -122,8 +122,8 @@ public async Task StartAsync(CancellationToken cancellationToken)
                     await VerifyDatabaseSupported(connection, this._logger, cancellationToken);
 
                     int userTableId = await GetUserTableIdAsync(connection, this._userTable, this._logger, cancellationToken);
-                    IReadOnlyList<(string name, string type)> primaryKeyColumns = await GetPrimaryKeyColumnsAsync(connection, userTableId, this._logger, this._userTable.FullName, cancellationToken);
-                    IReadOnlyList<string> userTableColumns = await this.GetUserTableColumnsAsync(connection, userTableId, cancellationToken);
+                    IReadOnlyList<(string name, string type)> primaryKeyColumns = GetPrimaryKeyColumnsAsync(connection, userTableId, this._logger, this._userTable.FullName, cancellationToken);
+                    IReadOnlyList<string> userTableColumns = this.GetUserTableColumns(connection, userTableId, cancellationToken);
 
                     string bracketedLeasesTableName = GetBracketedLeasesTableName(this._userDefinedLeasesTableName, this._userFunctionId, userTableId);
                     this._telemetryProps[TelemetryPropertyName.LeasesTableName] = bracketedLeasesTableName;
@@ -208,7 +208,7 @@ public Task StopAsync(CancellationToken cancellationToken)
         /// <summary>
         /// Gets the column names of the user table.
         /// </summary>
-        private async Task<IReadOnlyList<string>> GetUserTableColumnsAsync(SqlConnection connection, int userTableId, CancellationToken cancellationToken)
+        private IReadOnlyList<string> GetUserTableColumns(SqlConnection connection, int userTableId, CancellationToken cancellationToken)
         {
             const int NameIndex = 0, TypeIndex = 1, IsAssemblyTypeIndex = 2;
             string getUserTableColumnsQuery = $@"
@@ -222,13 +222,14 @@ FROM sys.columns AS c
             ";
 
             using (var getUserTableColumnsCommand = new SqlCommand(getUserTableColumnsQuery, connection))
-            using (SqlDataReader reader = await getUserTableColumnsCommand.ExecuteReaderAsyncWithLogging(this._logger, cancellationToken))
+            using (SqlDataReader reader = getUserTableColumnsCommand.ExecuteReaderWithLogging(this._logger))
             {
                 var userTableColumns = new List<string>();
                 var userDefinedTypeColumns = new List<(string name, string type)>();
 
-                while (await reader.ReadAsync(cancellationToken))
+                while (reader.Read())
                 {
+                    cancellationToken.ThrowIfCancellationRequested();
                     string columnName = reader.GetString(NameIndex);
                     string columnType = reader.GetString(TypeIndex);
                     bool isAssemblyType = reader.GetBoolean(IsAssemblyTypeIndex);
@@ -373,7 +374,7 @@ private async Task<long> InsertGlobalStateTableRowAsync(SqlConnection connection
             string getMinValidVersionQuery = $"SELECT CHANGE_TRACKING_MIN_VALID_VERSION({userTableId});";
 
             using (var getMinValidVersionCommand = new SqlCommand(getMinValidVersionQuery, connection, transaction))
-            using (SqlDataReader reader = await getMinValidVersionCommand.ExecuteReaderAsyncWithLogging(this._logger, cancellationToken))
+            using (SqlDataReader reader = getMinValidVersionCommand.ExecuteReaderWithLogging(this._logger))
             {
                 if (!await reader.ReadAsync(cancellationToken))
                 {

src/TriggerBinding/SqlTriggerMetricsProvider.cs

@@ -56,7 +56,7 @@ private async Task<long> GetUnprocessedChangeCountAsync()
                     await connection.OpenAsync();
 
                     int userTableId = await GetUserTableIdAsync(connection, this._userTable, this._logger, CancellationToken.None);
-                    IReadOnlyList<(string name, string type)> primaryKeyColumns = await GetPrimaryKeyColumnsAsync(connection, userTableId, this._logger, this._userTable.FullName, CancellationToken.None);
+                    IReadOnlyList<(string name, string type)> primaryKeyColumns = GetPrimaryKeyColumnsAsync(connection, userTableId, this._logger, this._userTable.FullName, CancellationToken.None);
 
                     // Use a transaction to automatically release the app lock when we're done executing the query
                     using (SqlTransaction transaction = connection.BeginTransaction(IsolationLevel.RepeatableRead))

src/TriggerBinding/SqlTriggerUtils.cs

@@ -27,7 +27,7 @@ public static class SqlTriggerUtils
         /// <exception cref="InvalidOperationException">
         /// Thrown if there are no primary key columns present in the user table or if their names conflict with columns in leases table.
         /// </exception>
-        public static async Task<IReadOnlyList<(string name, string type)>> GetPrimaryKeyColumnsAsync(SqlConnection connection, int userTableId, ILogger logger, string userTableName, CancellationToken cancellationToken)
+        public static IReadOnlyList<(string name, string type)> GetPrimaryKeyColumnsAsync(SqlConnection connection, int userTableId, ILogger logger, string userTableName, CancellationToken cancellationToken)
         {
             const int NameIndex = 0, TypeIndex = 1, LengthIndex = 2, PrecisionIndex = 3, ScaleIndex = 4;
             string getPrimaryKeyColumnsQuery = $@"
@@ -44,15 +44,16 @@ FROM sys.indexes AS i
                 WHERE i.is_primary_key = 1 AND i.object_id = {userTableId};
             ";
             using (var getPrimaryKeyColumnsCommand = new SqlCommand(getPrimaryKeyColumnsQuery, connection))
-            using (SqlDataReader reader = await getPrimaryKeyColumnsCommand.ExecuteReaderAsyncWithLogging(logger, cancellationToken))
+            using (SqlDataReader reader = getPrimaryKeyColumnsCommand.ExecuteReaderWithLogging(logger))
             {
                 string[] variableLengthTypes = new[] { "varchar", "nvarchar", "nchar", "char", "binary", "varbinary" };
                 string[] variablePrecisionTypes = new[] { "numeric", "decimal" };
 
                 var primaryKeyColumns = new List<(string name, string type)>();
 
-                while (await reader.ReadAsync(cancellationToken))
+                while (reader.Read())
                 {
+                    cancellationToken.ThrowIfCancellationRequested();
                     string name = reader.GetString(NameIndex);
                     string type = reader.GetString(TypeIndex);
 
@@ -96,7 +97,7 @@ internal static async Task<int> GetUserTableIdAsync(SqlConnection connection, Sq
             string getObjectIdQuery = $"SELECT OBJECT_ID(N{userTable.QuotedFullName}, 'U');";
 
             using (var getObjectIdCommand = new SqlCommand(getObjectIdQuery, connection))
-            using (SqlDataReader reader = await getObjectIdCommand.ExecuteReaderAsyncWithLogging(logger, cancellationToken))
+            using (SqlDataReader reader = getObjectIdCommand.ExecuteReaderWithLogging(logger))
             {
                 if (!await reader.ReadAsync(cancellationToken))
                 {