/// <summary> /// Iterates an IDataReader and skips by the skip parameter returns the maximum remaining defined by the take parameter. /// </summary> /// <typeparam name="T">The return type of the transform function.</typeparam> /// <param name="command">The IExecuteReader to iterate.</param> /// <param name="skip">The number of entries to skip before starting to take results.</param> /// <param name="take">The maximum number of records to return.</param> /// <param name="transform">The transform function to process each IDataRecord.</param> /// <returns>The results from the skip, transform and take operation.</returns> public static List <T> SkipThenTake <T>(this IExecuteReader command, int skip, int take, Func <IDataRecord, T> transform) { if (command is null) { throw new ArgumentNullException(nameof(command)); } if (transform is null) { throw new ArgumentNullException(nameof(transform)); } if (skip < 0) { throw new ArgumentOutOfRangeException(nameof(skip), skip, "Cannot be negative."); } if (take < 0) { throw new ArgumentOutOfRangeException(nameof(take), take, "Cannot be negative."); } Contract.EndContractBlock(); return(take == 0 ? new List <T>() : command.ExecuteReader( reader => reader.Select(transform).Skip(skip).Take(take).ToList(), CommandBehavior.SingleResult)); }
/// <summary> /// Iterates all records within the current result set using an IDataReader and returns the desired results. /// DBNull values are left unchanged (retained). /// </summary> /// <param name="command">The IExecuteReader to iterate.</param> /// <param name="n">The first ordinal to include in the request to the reader for each record.</param> /// <param name="others">The remaining 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 QueryResultQueue <object[]> Retrieve(this IExecuteReader command, int n, params int[] others) { if (command is null) { throw new ArgumentNullException(nameof(command)); } Contract.EndContractBlock(); return(command.ExecuteReader( reader => reader.Retrieve(n, others), CommandBehavior.SingleResult)); }
/// <summary> /// Iterates all records within the current result set using an IDataReader and returns the desired results. /// DBNull values are left unchanged (retained). /// </summary> /// <param name="command">The IExecuteReader to iterate.</param> /// <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 QueryResultQueue <object[]> Retrieve(this IExecuteReader command, IEnumerable <int> ordinals) { if (command is null) { throw new ArgumentNullException(nameof(command)); } Contract.EndContractBlock(); return(command.ExecuteReader( reader => reader.Retrieve(ordinals), CommandBehavior.SingleResult)); }
/// <summary> /// Iterates all records within the first result set using an IDataReader and returns the results. /// DBNull values are left unchanged (retained). /// </summary> /// <param name="command">The IExecuteReader to iterate.</param> /// <returns>The QueryResult that contains all the results and the column mappings.</returns> public static QueryResultQueue <object[]> Retrieve(this IExecuteReader command) { if (command is null) { throw new ArgumentNullException(nameof(command)); } Contract.EndContractBlock(); return(command.ExecuteReader( reader => reader.Retrieve(), CommandBehavior.SequentialAccess | CommandBehavior.SingleResult)); }
/// <summary> /// Iterates all records within the current result set using an IDataReader and returns the desired results. /// DBNull values are left unchanged (retained). /// </summary> /// <param name="command">The IExecuteReader to iterate.</param> /// <param name="c">The first column name to include in the request to the reader for each record.</param> /// <param name="others">The remaining column names to request from the reader for each record.</param> /// <returns>The QueryResult that contains all the results and the column mappings.</returns> public static QueryResultQueue <object[]> Retrieve(this IExecuteReader command, string c, params string[] others) { if (command is null) { throw new ArgumentNullException(nameof(command)); } //if (c is null) throw new ArgumentNullException(nameof(c)); //if (others.Any(e => e is null)) throw new ArgumentNullException(nameof(c)); Contract.EndContractBlock(); return(command.ExecuteReader( reader => reader.Retrieve(c, others), CommandBehavior.SingleResult)); }
/// <summary> /// Iterates a reader on a command while the handler function returns true. /// </summary> /// <param name="command">The IExecuteReader to iterate.</param> /// <param name="handler">The handler function for each IDataRecord.</param> /// <param name="behavior">The behavior to use with the data reader.</param> public static void IterateReaderWhile(this IExecuteReader command, Func <IDataRecord, bool> handler, CommandBehavior behavior = CommandBehavior.Default) { if (command is null) { throw new ArgumentNullException(nameof(command)); } if (handler is null) { throw new ArgumentNullException(nameof(handler)); } Contract.EndContractBlock(); command.ExecuteReader( reader => reader.IterateWhile(handler), behavior | CommandBehavior.SingleResult); }
/// <summary> /// Converts all IDataRecords into an immutable array using a transform function. /// </summary> /// <typeparam name="T">The expected return type.</typeparam> /// <param name="command">The IExecuteReader to iterate.</param> /// <param name="transform">The transform function.</param> /// <param name="behavior">The command behavior for once the command the reader is complete.</param> /// <returns>The array of transformed records.</returns> public static ImmutableArray <T> ToImmutableArray <T>(this IExecuteReader command, Func <IDataRecord, T> transform, CommandBehavior behavior = CommandBehavior.Default) { if (command is null) { throw new ArgumentNullException(nameof(command)); } if (transform is null) { throw new ArgumentNullException(nameof(transform)); } Contract.EndContractBlock(); return(command.ExecuteReader( reader => reader.Select(transform).ToImmutableArray(), behavior | CommandBehavior.SingleResult)); }
/// <summary> /// Iterates an IDataReader and returns the first result through a transform function. Returns default(T) if none. Throws if more than one entry. /// </summary> /// <typeparam name="T">The return type of the transform function.</typeparam> /// <param name="command">The IExecuteReader to iterate.</param> /// <param name="transform">The transform function to process each IDataRecord.</param> /// <returns>The value from the transform.</returns> public static T SingleOrDefault <T>(this IExecuteReader command, Func <IDataRecord, T> transform) { if (command is null) { throw new ArgumentNullException(nameof(command)); } if (transform is null) { throw new ArgumentNullException(nameof(transform)); } Contract.EndContractBlock(); return(command.ExecuteReader( reader => reader.Select(transform).SingleOrDefault(), CommandBehavior.SingleResult)); }
/// <summary> /// Iterates each record and attempts to map the fields to type T. /// Data is temporarily stored (buffered in entirety) in a queue before applying the transform for each iteration. /// </summary> /// <param name="command">The IExecuteReader to iterate.</param> /// <typeparam name="T">The model type to map the values to (using reflection).</typeparam> /// <param name="fieldMappingOverrides">An optional override map of field names to column names where the keys are the property names, and values are the column names.</param> /// <returns>The enumerable to pull the transformed results from.</returns> public static IEnumerable <T> Results <T>(this IExecuteReader command, IEnumerable <KeyValuePair <string, string?> > fieldMappingOverrides) where T : new() { if (command is null) { throw new ArgumentNullException(nameof(command)); } if (fieldMappingOverrides is null) { throw new ArgumentNullException(nameof(fieldMappingOverrides)); } Contract.EndContractBlock(); return(command.ExecuteReader( reader => reader.ResultsBuffered <T>(fieldMappingOverrides), CommandBehavior.SingleResult)); }
/// <summary> /// Executes a reader on a command with a transform function. /// </summary> /// <typeparam name="TEntity">The return type of the transform function applied to each record.</typeparam> /// <typeparam name="TResult">The type returned by the selector.</typeparam> /// <param name="command">The IExecuteReader to iterate.</param> /// <param name="transform">The transform function for each IDataRecord.</param> /// <param name="selector">Provides an IEnumerable<TEntity> to select individual results by.</param> /// <param name="behavior">The behavior to use with the data reader.</param> /// <returns>The result of the transform.</returns> public static TResult IterateReader <TEntity, TResult>( this IExecuteReader command, Func <IDataRecord, TEntity> transform, Func <IEnumerable <TEntity>, TResult> selector, CommandBehavior behavior = CommandBehavior.Default) { if (command is null) { throw new ArgumentNullException(nameof(command)); } if (transform is null) { throw new ArgumentNullException(nameof(transform)); } Contract.EndContractBlock(); return(command.ExecuteReader( reader => selector(reader.Select(transform)), behavior | CommandBehavior.SingleResult)); }
/// <summary> /// Iterates an IDataReader and skips the first number of results defined by the count. /// </summary> /// <typeparam name="T">The return type of the transform function.</typeparam> /// <param name="command">The IExecuteReader to iterate.</param> /// <param name="count">The number of records to skip.</param> /// <param name="transform">The transform function to process each IDataRecord.</param> /// <returns>The results from the transform after the skip count.</returns> public static List <T> Skip <T>(this IExecuteReader command, int count, Func <IDataRecord, T> transform) { if (command is null) { throw new ArgumentNullException(nameof(command)); } if (transform is null) { throw new ArgumentNullException(nameof(transform)); } if (count < 0) { throw new ArgumentOutOfRangeException(nameof(count), count, "Cannot be negative."); } Contract.EndContractBlock(); return(command.ExecuteReader( reader => count == 0 ? reader.ToList(transform) : reader.Select(transform).Skip(count).ToList(), CommandBehavior.SingleResult)); }