Interfaces and final touches.

electricessence · electricessence · commit 26e002dfb9d1 · 2019-03-16T22:50:52.000-07:00
diff --git a/ArrayPoolExtensions.cs b/ArrayPoolExtensions.cs
diff --git a/ExpressiveCommandBase.cs b/ExpressiveCommandBase.cs
@@ -824,9 +824,8 @@ void I() => ExecuteReader(reader =>
 				var ordinalValues = columns.Select(c => c.Ordinal).ToArray();
 				deferred(new QueryResult<IEnumerable<object[]>>(
 					ordinalValues,
-					columns.Select(c => c.Name).ToArray(),
+					columns.Select(c => c.Name),
 					reader.AsEnumerable(ordinalValues)));
-
 			});
 
 			if (synchronousExecution) I();
diff --git a/Extensions.ConnectionFactory.cs b/Extensions.ConnectionFactory.cs
@@ -272,10 +272,9 @@ public static async Task<T> OpenAsync<TConn, T>(this IDbConnectionFactory<TConn>
 
 			using (var conn = connectionFactory.Create())
 			{
-				var c = conn as DbConnection;
-				if (c == null) conn.Open();
-				else await c.OpenAsync();
-				return await action(conn).ConfigureAwait(false);
+                if (conn is DbConnection c) await c.OpenAsync();
+                else conn.Open();
+                return await action(conn).ConfigureAwait(false);
 			}
 		}
 
@@ -294,10 +293,9 @@ public static async Task OpenAsync<TConn>(this IDbConnectionFactory<TConn> conne
 
 			using (var conn = connectionFactory.Create())
 			{
-				var c = conn as DbConnection;
-				if (c == null) conn.Open();
-				else await c.OpenAsync();
-				await action(conn).ConfigureAwait(false);
+                if (conn is DbConnection c) await c.OpenAsync();
+                else conn.Open();
+                await action(conn).ConfigureAwait(false);
 			}
 		}
 
@@ -318,10 +316,9 @@ public static async Task<T> OpenAsync<TConn, T>(this Func<TConn> connectionFacto
 
 			using (var conn = connectionFactory())
 			{
-				var c = conn as DbConnection;
-				if (c == null) conn.Open();
-				else await c.OpenAsync();
-				return await action(conn).ConfigureAwait(false);
+                if (conn is DbConnection c) await c.OpenAsync();
+                else conn.Open();
+                return await action(conn).ConfigureAwait(false);
 			}
 		}
 
@@ -340,15 +337,12 @@ public static async Task OpenAsync<TConn>(this Func<TConn> connectionFactory, Fu
 
 			using (var conn = connectionFactory())
 			{
-				var c = conn as DbConnection;
-				if (c == null) conn.Open();
-				else await c.OpenAsync();
-				await action(conn).ConfigureAwait(false);
+                if (conn is DbConnection c) await c.OpenAsync();
+                else conn.Open();
+                await action(conn).ConfigureAwait(false);
 			}
 		}
 
-
-
 		/// <summary>
 		/// Creates an ExpressiveDbCommand for subsequent configuration and execution.
 		/// </summary>
diff --git a/Extensions.Results.cs b/Extensions.Results.cs
@@ -29,8 +29,8 @@ public static IEnumerable<T> Results<T>(this IDataReader reader, IEnumerable<(st
 			var columns = reader.GetMatchingOrdinals(x.ColumnNames, true);
 
 			return x.AsDequeueingEnumerable(RetrieveInternal(reader,
-				columns.Select(c => c.Ordinal).ToArray(),
-				columns.Select(c => c.Name).ToArray(), readStarted: true));
+				columns.Select(c => c.Ordinal),
+				columns.Select(c => c.Name), readStarted: true));
 		}
 
 		/// <summary>
@@ -111,8 +111,10 @@ public static IEnumerable<T> Results<T>(this IDbCommand command, IEnumerable<Key
 			var columns = reader.GetMatchingOrdinals(x.ColumnNames, true);
 
 			return x.AsDequeueingEnumerable(await RetrieveAsyncInternal(reader, token,
-				columns.Select(c => c.Ordinal).ToArray(),
-				columns.Select(c => c.Name).ToArray(), readStarted: true, useReadAsync: useReadAsync));
+				columns.Select(c => c.Ordinal),
+				columns.Select(c => c.Name),
+                readStarted: true,
+                useReadAsync: useReadAsync));
 		}
 
 		/// <summary>
diff --git a/Extensions.Retrieve.cs b/Extensions.Retrieve.cs
@@ -13,15 +13,11 @@ namespace Open.Database.Extensions
 	public static partial class Extensions
 	{
 
-		static QueryResult<Queue<object[]>> RetrieveInternal(this IDataReader reader, int[] ordinals, string[] columnNames = null, bool readStarted = false)
+		static QueryResult<Queue<object[]>> RetrieveInternal(this IDataReader reader, IEnumerable<int> ordinals, IEnumerable<string> columnNames = null, bool readStarted = false)
 		{
-			var fieldCount = ordinals.Length;
-			if (columnNames == null) columnNames = ordinals.Select(reader.GetName).ToArray();
-			else if (columnNames.Length != fieldCount) throw new ArgumentException("Mismatched array lengths of ordinals and names.");
-
+            var o = ordinals as IList<int> ?? ordinals.ToArray();
 			return new QueryResult<Queue<object[]>>(
-				ordinals,
-				columnNames,
+				o, columnNames as IList<string> ?? columnNames.ToArray(),
 				new Queue<object[]>(AsEnumerableInternal(reader, ordinals, readStarted)));
 		}
 
@@ -35,8 +31,7 @@ public static QueryResult<Queue<object[]>> Retrieve(this IDataReader reader)
 		{
 			var names = reader.GetNames();
 			return new QueryResult<Queue<object[]>>(
-				Enumerable.Range(0, names.Length).ToArray(),
-				names,
+				Enumerable.Range(0, names.Length), names,
 				new Queue<object[]>(AsEnumerable(reader)));
 		}
 
@@ -48,7 +43,7 @@ public static QueryResult<Queue<object[]>> Retrieve(this IDataReader reader)
 		/// <param name="ordinals">The ordinals to request from the reader for each record.</param>
 		/// <returns>The QueryResult that contains all the results and the column mappings.</returns>
 		public static QueryResult<Queue<object[]>> Retrieve(this IDataReader reader, IEnumerable<int> ordinals)
-			=> RetrieveInternal(reader, ordinals.ToArray());
+			=> RetrieveInternal(reader, ordinals);
 
 		/// <summary>
 		/// Iterates all records within the current result set using an IDataReader and returns the desired results.
@@ -71,8 +66,9 @@ public static QueryResult<Queue<object[]>> Retrieve(this IDataReader reader, int
 		public static QueryResult<Queue<object[]>> Retrieve(this IDataReader reader, IEnumerable<string> columnNames)
 		{
 			var columns = reader.GetOrdinalMapping(columnNames);
-			var ordinalValues = columns.Select(c => c.Ordinal).ToArray();
-			return RetrieveInternal(reader, ordinalValues, columns.Select(c => c.Name).ToArray());
+			return RetrieveInternal(reader,
+                columns.Select(c => c.Ordinal),
+                columns.Select(c => c.Name));
 		}
 
 		/// <summary>
@@ -162,29 +158,35 @@ public static async Task<QueryResult<Queue<object[]>>> RetrieveAsync(this DbData
 			if (!useReadAsync) token.ThrowIfCancellationRequested();
 
 			return new QueryResult<Queue<object[]>>(
-				Enumerable.Range(0, names.Length).ToArray(),
+				Enumerable.Range(0, names.Length),
 				names,
 				buffer);
 		}
 
-		static async Task<QueryResult<Queue<object[]>>> RetrieveAsyncInternal(DbDataReader reader, CancellationToken token, int[] ordinals, string[] columnNames = null, bool readStarted = false, bool useReadAsync = true)
+		static async Task<QueryResult<Queue<object[]>>> RetrieveAsyncInternal(DbDataReader reader, CancellationToken token, IEnumerable<int> ordinals, IEnumerable<string> columnNames = null, bool readStarted = false, bool useReadAsync = true)
 		{
-			var fieldCount = ordinals.Length;
-			if (columnNames == null) columnNames = ordinals.Select(reader.GetName).ToArray();
-			else if (columnNames.Length != fieldCount) throw new ArgumentException("Mismatched array lengths of ordinals and names.");
+            var buffer
+                = new Queue<object[]>();
+
+            var result
+                = new QueryResult<Queue<object[]>>(
+                   ordinals,
+                   columnNames ?? ordinals.Select(reader.GetName),
+                   buffer);
+
+            var fieldCount = result.ColumnCount;
+            var o = result.Ordinals;
 
 			Func<IDataRecord, object[]> handler;
 			if (fieldCount == 0) handler = record => Array.Empty<object>();
 			else handler = record =>
 			{
 				var row = new object[fieldCount];
 				for (var i = 0; i < fieldCount; i++)
-					row[i] = reader.GetValue(ordinals[i]);
+					row[i] = reader.GetValue(o[i]);
 				return row;
 			};
 
-            var buffer = new Queue<object[]>();
-
 			if (readStarted)
 				buffer.Enqueue(handler(reader));
 
@@ -194,13 +196,9 @@ static async Task<QueryResult<Queue<object[]>>> RetrieveAsyncInternal(DbDataRead
 			if (!useReadAsync)
 				token.ThrowIfCancellationRequested();
 
-			return new QueryResult<Queue<object[]>>(
-				ordinals,
-				columnNames,
-				buffer);
+			return result;
 		}
 
-
 		/// <summary>
 		/// Asynchronously enumerates all the remaining values of the current result set of a data reader.
 		/// DBNull values are left unchanged (retained).
@@ -211,7 +209,7 @@ static async Task<QueryResult<Queue<object[]>>> RetrieveAsyncInternal(DbDataRead
 		/// <param name="useReadAsync">If true (default) will iterate the results using .ReadAsync() otherwise will only Execute the reader asynchronously and then use .Read() to iterate the results but still allowing cancellation.</param>
 		/// <returns>The QueryResult that contains a buffer block of the results and the column mappings.</returns>
 		public static Task<QueryResult<Queue<object[]>>> RetrieveAsync(this DbDataReader reader, IEnumerable<int> ordinals, CancellationToken token = default, bool useReadAsync = true)
-			=> RetrieveAsyncInternal(reader, token, ordinals as int[] ?? ordinals.ToArray(), useReadAsync: useReadAsync);
+			=> RetrieveAsyncInternal(reader, token, ordinals, useReadAsync: useReadAsync);
 
 		/// <summary>
 		/// Asynchronously enumerates all the remaining values of the current result set of a data reader.
@@ -250,11 +248,9 @@ public static Task<QueryResult<Queue<object[]>>> RetrieveAsync(this DbDataReader
 		{
 			// Validate columns first.
 			var columns = reader.GetOrdinalMapping(columnNames, normalizeColumnOrder);
-
 			return RetrieveAsyncInternal(reader, token,
-
-				columns.Select(c => c.Ordinal).ToArray(),
-				columns.Select(c => c.Name).ToArray(), useReadAsync: useReadAsync);
+				columns.Select(c => c.Ordinal),
+				columns.Select(c => c.Name), useReadAsync: useReadAsync);
 		}
 
 		/// <summary>
@@ -291,7 +287,7 @@ public static Task<QueryResult<Queue<object[]>>> RetrieveAsync(this DbDataReader
 		public static Task<QueryResult<Queue<object[]>>> RetrieveAsync(this DbCommand command, CancellationToken token = default, bool useReadAsync = true)
 			=> command.ExecuteReaderAsync(reader => RetrieveAsync(reader, token, useReadAsync), CommandBehavior.SequentialAccess, token);
 
-		static Task<QueryResult<Queue<object[]>>> RetrieveAsyncInternal(DbCommand command, CancellationToken token, int[] ordinals, string[] columnNames = null, bool useReadAsync = true)
+		static Task<QueryResult<Queue<object[]>>> RetrieveAsyncInternal(DbCommand command, CancellationToken token, IEnumerable<int> ordinals, IEnumerable<string> columnNames = null, bool useReadAsync = true)
 			=> command.ExecuteReaderAsync(reader => RetrieveAsyncInternal(reader, token, ordinals, columnNames, useReadAsync: useReadAsync), token: token);
 
 		/// <summary>
@@ -304,7 +300,7 @@ static Task<QueryResult<Queue<object[]>>> RetrieveAsyncInternal(DbCommand comman
 		/// <param name="useReadAsync">If true (default) will iterate the results using .ReadAsync() otherwise will only Execute the reader asynchronously and then use .Read() to iterate the results but still allowing cancellation.</param>
 		/// <returns>The QueryResult that contains a buffer block of the results and the column mappings.</returns>
 		public static Task<QueryResult<Queue<object[]>>> RetrieveAsync(this DbCommand command, IEnumerable<int> ordinals, CancellationToken token = default, bool useReadAsync = true)
-			=> RetrieveAsyncInternal(command, token, ordinals as int[] ?? ordinals.ToArray(), useReadAsync: useReadAsync);
+			=> RetrieveAsyncInternal(command, token, ordinals, useReadAsync: useReadAsync);
 
 		/// <summary>
 		/// Asynchronously enumerates all the remaining values of the current result set of a data reader.
diff --git a/Extensions.cs b/Extensions.cs
@@ -1193,7 +1193,7 @@ public static async Task ForEachAsync(this DbCommand command,
             if (handler == null) throw new ArgumentNullException(nameof(handler));
             Contract.EndContractBlock();
 
-            var state = await command.Connection.EnsureOpenAsync(t);
+            var state = await command.Connection.EnsureOpenAsync(token);
             if (state == ConnectionState.Closed) behavior |= CommandBehavior.CloseConnection;
             using (var reader = await command.ExecuteReaderAsync(behavior, token))
             {
diff --git a/Open.Database.Extensions.csproj b/Open.Database.Extensions.csproj
@@ -11,9 +11,9 @@
     <Description>Useful set of utilities and abstractions for simplifying modern data-access operations and ensuring DI compatibility.</Description>
     <RepositoryUrl>https://github.com/electricessence/Open.Database.Extensions</RepositoryUrl>
     <RepositoryType>git</RepositoryType>
-    <Version>5.13.3</Version>
-    <AssemblyVersion>5.13.3.0</AssemblyVersion>
-    <FileVersion>5.13.3.0</FileVersion>
+    <Version>5.14.0</Version>
+    <AssemblyVersion>5.14.0.0</AssemblyVersion>
+    <FileVersion>5.14.0.0</FileVersion>
     <PackageReleaseNotes>Reduced array allocation.</PackageReleaseNotes>
     <LangVersion>latest</LangVersion>
   </PropertyGroup>
diff --git a/QueryResult.cs b/QueryResult.cs
diff --git a/Transformer.cs b/Transformer.cs

Original file line number	Diff line number	Diff line change
`@@ -272,10 +272,9 @@ public static async Task<T> OpenAsync<TConn, T>(this IDbConnectionFactory<TConn>`
`272`	`272`
`273`	`273`	`using (var conn = connectionFactory.Create())`
`274`	`274`	`{`
`275`		`- var c = conn as DbConnection;`
`276`		`- if (c == null) conn.Open();`
`277`		`- else await c.OpenAsync();`
`278`		`- return await action(conn).ConfigureAwait(false);`
	`275`	`+ if (conn is DbConnection c) await c.OpenAsync();`
	`276`	`+ else conn.Open();`
	`277`	`+ return await action(conn).ConfigureAwait(false);`
`279`	`278`	`}`
`280`	`279`	`}`
`281`	`280`
`@@ -294,10 +293,9 @@ public static async Task OpenAsync<TConn>(this IDbConnectionFactory<TConn> conne`
`294`	`293`
`295`	`294`	`using (var conn = connectionFactory.Create())`
`296`	`295`	`{`
`297`		`- var c = conn as DbConnection;`
`298`		`- if (c == null) conn.Open();`
`299`		`- else await c.OpenAsync();`
`300`		`- await action(conn).ConfigureAwait(false);`
	`296`	`+ if (conn is DbConnection c) await c.OpenAsync();`
	`297`	`+ else conn.Open();`
	`298`	`+ await action(conn).ConfigureAwait(false);`
`301`	`299`	`}`
`302`	`300`	`}`
`303`	`301`
`@@ -318,10 +316,9 @@ public static async Task<T> OpenAsync<TConn, T>(this Func<TConn> connectionFacto`
`318`	`316`
`319`	`317`	`using (var conn = connectionFactory())`
`320`	`318`	`{`
`321`		`- var c = conn as DbConnection;`
`322`		`- if (c == null) conn.Open();`
`323`		`- else await c.OpenAsync();`
`324`		`- return await action(conn).ConfigureAwait(false);`
	`319`	`+ if (conn is DbConnection c) await c.OpenAsync();`
	`320`	`+ else conn.Open();`
	`321`	`+ return await action(conn).ConfigureAwait(false);`
`325`	`322`	`}`
`326`	`323`	`}`
`327`	`324`
`@@ -340,15 +337,12 @@ public static async Task OpenAsync<TConn>(this Func<TConn> connectionFactory, Fu`
`340`	`337`
`341`	`338`	`using (var conn = connectionFactory())`
`342`	`339`	`{`
`343`		`- var c = conn as DbConnection;`
`344`		`- if (c == null) conn.Open();`
`345`		`- else await c.OpenAsync();`
`346`		`- await action(conn).ConfigureAwait(false);`
	`340`	`+ if (conn is DbConnection c) await c.OpenAsync();`
	`341`	`+ else conn.Open();`
	`342`	`+ await action(conn).ConfigureAwait(false);`
`347`	`343`	`}`
`348`	`344`	`}`
`349`	`345`
`350`		`-`
`351`		`-`
`352`	`346`	`/// <summary>`
`353`	`347`	`/// Creates an ExpressiveDbCommand for subsequent configuration and execution.`
`354`	`348`	`/// </summary>`
Original file line number	Diff line number	Diff line change
`@@ -1193,7 +1193,7 @@ public static async Task ForEachAsync(this DbCommand command,`
`1193`	`1193`	`if (handler == null) throw new ArgumentNullException(nameof(handler));`
`1194`	`1194`	`Contract.EndContractBlock();`
`1195`	`1195`
`1196`		`- var state = await command.Connection.EnsureOpenAsync(t);`
	`1196`	`+ var state = await command.Connection.EnsureOpenAsync(token);`
`1197`	`1197`	`if (state == ConnectionState.Closed) behavior \|= CommandBehavior.CloseConnection;`
`1198`	`1198`	`using (var reader = await command.ExecuteReaderAsync(behavior, token))`
`1199`	`1199`	`{`