/// <summary> /// Execute the query and return a new instance of T with the first row of results /// </summary> /// <typeparam name="T">Object type</typeparam> /// <returns>First row of results</returns> /// <example> /// <code> /// Employee emp = cmd.ExecuteRow<Employee>(); /// </code> /// <remarks> /// Result object property (ex. Employee.Name) may be tagged with the ColumnAttribute /// to set which column name (ex. [Column("Name")] must be associated to this property. /// </remarks> /// </example> public virtual T ExecuteRow <T>() { // Primitive type: Executable<string>() if (TypeExtension.IsPrimitive(typeof(T))) { return(this.ExecuteScalar <T>()); } else { // Get DataTable var rows = ExecuteInternalCommand(() => { using (DbDataReader dr = this.Command.ExecuteReader(System.Data.CommandBehavior.SingleRow)) { // Dynamic type: Executable<dynamic>() if (DynamicConvertor.IsDynamic(typeof(T))) { return(DataReaderConvertor.ToDynamic <T>(dr)); } // Object type: Executable<Employee>() else { return(DataReaderConvertor.ToType <T>(dr).Rows); } } }); // Return return(rows?.Any() == true?rows.First() : default(T)); } }
/// <summary> /// Execute the query and return an array of new instances of typed results filled with data table result. /// </summary> /// <typeparam name="T">Object type</typeparam> /// <returns>Array of typed results</returns> /// <example> /// <code> /// Employee[] emp = cmd.ExecuteTable<Employee>(); /// var x = cmd.ExecuteTable<Employee>(); /// </code> /// <remarks> /// Result object property (ex. Employee.Name) may be tagged with the ColumnAttribute /// to set which column name (ex. [Column("Name")] must be associated to this property. /// </remarks> /// </example> public async virtual Task <IEnumerable <T> > ExecuteTableAsync <T>() { return(await ExecuteInternalCommand(async() => { using (DbDataReader dr = await this.Command.ExecuteReaderAsync()) { // Primitive type: Executable<string>() if (TypeExtension.IsPrimitive(typeof(T))) { return await DataReaderConvertor.ToPrimitivesAsync <T>(dr); } // Dynamic type: Executable<dynamic>() else if (DynamicConvertor.IsDynamic(typeof(T))) { return await DataReaderConvertor.ToDynamicAsync <T>(dr); } // Object type: Executable<Employee>() else { return (await DataReaderConvertor.ToTypeAsync <T>(dr)).Rows; } } })); }
/// <summary> /// Execute the query and return an array of new instances of typed results filled with data table result. /// </summary> /// <typeparam name="T">Object type</typeparam> /// <returns>Array of typed results</returns> /// <example> /// <code> /// Employee[] emp = cmd.ExecuteTable<Employee>(); /// var x = cmd.ExecuteTable<Employee>(); /// </code> /// <remarks> /// Result object property (ex. Employee.Name) may be tagged with the ColumnAttribute /// to set which column name (ex. [Column("Name")] must be associated to this property. /// </remarks> /// </example> public virtual IEnumerable <T> ExecuteTable <T>() { return(ExecuteInternalCommand(() => { using (DbDataReader dr = this.Command.ExecuteReader()) { // Primitive type: Executable<string>() if (TypeExtension.IsPrimitive(typeof(T))) { return DataReaderConvertor.ToPrimitives <T>(dr); } // Dynamic type: Executable<dynamic>() else if (DynamicConvertor.IsDynamic(typeof(T))) { return DataReaderConvertor.ToDynamic <T>(dr); } // Object type: Executable<Employee>() else { return DataReaderConvertor.ToType <T>(dr).Rows; } } })); }
/// <summary> /// Execute the query and return a <see cref="System.Data.DataSet"/> object filled with data table results. /// </summary> /// <returns>Classic <see cref="System.Data.DataSet"/> object.</returns> public virtual System.Data.DataSet ExecuteDataSet() { return(ExecuteInternalCommand(() => { using (DbDataReader dr = this.Command.ExecuteReader(System.Data.CommandBehavior.KeyInfo)) { return DataReaderConvertor.ToSystemDataSet(dr); } })); }
/// <summary> /// Execute the query and return a <see cref="System.Data.DataSet"/> object filled with data table results. /// </summary> /// <returns>Classic <see cref="System.Data.DataSet"/> object.</returns> public async virtual Task <System.Data.DataSet> ExecuteDataSetAsync() { return(await ExecuteInternalCommand(async() => { using (DbDataReader dr = await this.Command.ExecuteReaderAsync(System.Data.CommandBehavior.KeyInfo)) { return DataReaderConvertor.ToSystemDataSet(dr); } })); }
/// <summary> /// Execute the query and return a list or array of new instances of typed results filled with data table results. /// </summary> /// <typeparam name="T">Object type for first table</typeparam> /// <typeparam name="U">Object type for second table</typeparam> /// <returns>List of array of typed results</returns> /// <example> /// <code> /// var data = cmd.ExecuteDataSet<Employee, Department>(); /// var employees = data.Item1; /// var departments = data.Item2; /// </code> /// </example> public virtual Tuple <IEnumerable <T>, IEnumerable <U> > ExecuteDataSet <T, U>(T typeOfItem1, U typeOfItem2) { var datasets = ExecuteInternalCommand(() => { using (DbDataReader dr = this.Command.ExecuteReader()) { return(DataReaderConvertor.ToMultipleTypes <T, U, NoType, NoType, NoType>(dr, forAnonymousTypes: true)); } }); return(new Tuple <IEnumerable <T>, IEnumerable <U> > ( datasets.Item1, datasets.Item2 )); }
/// <summary> /// Execute the query and return a list or array of new instances of typed results filled with data table results. /// </summary> /// <typeparam name="T">Object type for first table</typeparam> /// <typeparam name="U">Object type for second table</typeparam> /// <returns>List of array of typed results</returns> /// <example> /// <code> /// var data = cmd.ExecuteDataSet<Employee, Department>(); /// var employees = data.Item1; /// var departments = data.Item2; /// </code> /// </example> public async virtual Task <Tuple <IEnumerable <T>, IEnumerable <U> > > ExecuteDataSetAsync <T, U>(T typeOfItem1, U typeOfItem2) { var datasets = await ExecuteInternalCommand(async() => { using (DbDataReader dr = await this.Command.ExecuteReaderAsync()) { return(await DataReaderConvertor.ToMultipleTypesAsync <T, U, NoType, NoType, NoType>(dr, forAnonymousTypes: true)); } }); return(new Tuple <IEnumerable <T>, IEnumerable <U> > ( datasets.Item1, datasets.Item2 )); }
/// <summary> /// Execute the query and return an array of new instances of typed results filled with data table result. /// </summary> /// <typeparam name="T">Object type</typeparam> /// <param name="itemOftype"></param> /// <returns>Array of typed results</returns> /// <example> /// <code> /// Employee emp = new Employee(); /// var x = cmd.ExecuteTable(new { emp.Age, emp.Name }); /// var y = cmd.ExecuteTable(new { Age = 0, Name = "" }); /// </code> /// <remarks> /// Result object property (ex. Employee.Name) may be tagged with the ColumnAttribute /// to set which column name (ex. [Column("Name")] must be associated to this property. /// </remarks> /// </example> public virtual IEnumerable <T> ExecuteTable <T>(T itemOftype) { return(ExecuteInternalCommand(() => { using (DbDataReader dr = this.Command.ExecuteReader()) { if (TypeExtension.IsPrimitive(typeof(T))) { return DataReaderConvertor.ToPrimitives <T>(dr); } else { return DataReaderConvertor.ToAnonymous <T>(dr); } } })); }
/// <summary> /// Execute the query and return a list or array of new instances of typed results filled with data table results. /// </summary> /// <typeparam name="T">Object type for first table</typeparam> /// <typeparam name="U">Object type for second table</typeparam> /// <typeparam name="V">Object type for third table</typeparam> /// <returns>List of array of typed results</returns> /// <example> /// <code> /// var data = cmd.ExecuteDataSet<Employee, Department>(); /// var employees = data.Item1; /// var departments = data.Item2; /// </code> /// </example> public virtual Tuple <IEnumerable <T>, IEnumerable <U>, IEnumerable <V> > ExecuteDataSet <T, U, V>() { var datasets = ExecuteInternalCommand(() => { using (DbDataReader dr = this.Command.ExecuteReader()) { return(DataReaderConvertor.ToMultipleTypes <T, U, V, NoType, NoType>(dr)); } }); return(new Tuple <IEnumerable <T>, IEnumerable <U>, IEnumerable <V> > ( datasets.Item1, datasets.Item2, datasets.Item3 )); }
/// <summary> /// Execute the query and return an array of new instances of typed results filled with data table result. /// </summary> /// <typeparam name="T">Object type</typeparam> /// <param name="itemOftype"></param> /// <returns>Array of typed results</returns> /// <example> /// <code> /// Employee emp = new Employee(); /// var x = cmd.ExecuteTable(new { emp.Age, emp.Name }); /// var y = cmd.ExecuteTable(new { Age = 0, Name = "" }); /// </code> /// <remarks> /// Result object property (ex. Employee.Name) may be tagged with the ColumnAttribute /// to set which column name (ex. [Column("Name")] must be associated to this property. /// </remarks> /// </example> public async virtual Task <IEnumerable <T> > ExecuteTableAsync <T>(T itemOftype) { return(await ExecuteInternalCommand(async() => { using (DbDataReader dr = await this.Command.ExecuteReaderAsync()) { if (TypeExtension.IsPrimitive(typeof(T))) { return await DataReaderConvertor.ToPrimitivesAsync <T>(dr); } else { return await DataReaderConvertor.ToAnonymousAsync <T>(dr); } } })); }
/// <summary> /// Execute the query and return a list or array of new instances of typed results filled with data table results. /// </summary> /// <typeparam name="T">Object type for first table</typeparam> /// <typeparam name="U">Object type for second table</typeparam> /// <typeparam name="V">Object type for third table</typeparam> /// <returns>List of array of typed results</returns> /// <example> /// <code> /// var data = cmd.ExecuteDataSet<Employee, Department>(); /// var employees = data.Item1; /// var departments = data.Item2; /// </code> /// </example> public async virtual Task <Tuple <IEnumerable <T>, IEnumerable <U>, IEnumerable <V> > > ExecuteDataSetAsync <T, U, V>() { var datasets = await ExecuteInternalCommand(async() => { using (DbDataReader dr = await this.Command.ExecuteReaderAsync()) { return(await DataReaderConvertor.ToMultipleTypesAsync <T, U, V, NoType, NoType>(dr)); } }); return(new Tuple <IEnumerable <T>, IEnumerable <U>, IEnumerable <V> > ( datasets.Item1, datasets.Item2, datasets.Item3 )); }
/// <summary> /// Execute the query and return an array of new instances of typed results filled with data table result. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="converter"></param> /// <returns>Array of typed results</returns> public virtual IEnumerable <T> ExecuteTable <T>(Func <Schema.DataRow, T> converter) { var table = ExecuteInternalCommand(() => { using (DbDataReader dr = this.Command.ExecuteReader()) { return(DataReaderConvertor.ToDataTable(dr)); } }); if (table != null && table.Rows != null) { return(table.Rows.Select(row => converter.Invoke(row))); } else { return new T[] { } }; }
/// <summary> /// Execute the query and return an array of new instances of typed results filled with data table result. /// </summary> /// <typeparam name="T"></typeparam> /// <param name="converter"></param> /// <returns>Array of typed results</returns> public async virtual Task <IEnumerable <T> > ExecuteTableAsync <T>(Func <Schema.DataRow, Task <T> > converter) { var table = await ExecuteInternalCommand(async() => { using (DbDataReader dr = await this.Command.ExecuteReaderAsync()) { return(await DataReaderConvertor.ToDataTableAsync(dr)); } }); if (table != null && table.Rows != null) { return(table.Rows.Select(async row => await converter.Invoke(row)).Select(i => i.GetAwaiter().GetResult())); } else { return new T[] { } }; }
/// <summary> /// Execute the query and fill the specified T object with the first row of results /// </summary> /// <typeparam name="T">Object type</typeparam> /// <param name="itemOftype"></param> /// <returns>First row of results</returns> /// <example> /// <code> /// Employee emp = new Employee(); /// var x = cmd.ExecuteRow(new { emp.Age, emp.Name }); /// var y = cmd.ExecuteRow(new { Age = 0, Name = "" }); /// var z = cmd.ExecuteRow(emp); /// </code> /// <remarks> /// Result object property (ex. Employee.Name) may be tagged with the ColumnAttribute /// to set which column name (ex. [Column("Name")] must be associated to this property. /// </remarks> /// </example> public virtual T ExecuteRow <T>(T itemOftype) { if (TypeExtension.IsPrimitive(typeof(T))) { return(this.ExecuteScalar <T>()); } else { // Get DataTable var rows = ExecuteInternalCommand(() => { using (DbDataReader dr = this.Command.ExecuteReader(System.Data.CommandBehavior.SingleRow)) { return(DataReaderConvertor.ToAnonymous <T>(dr)); } }); // Return return(rows?.Any() == true?rows.First() : default(T)); } }
/// <summary> /// Execute the query and fill the specified T object with the first row of results /// </summary> /// <typeparam name="T">Object type</typeparam> /// <param name="converter"></param> /// <returns>First row of results</returns> public virtual T ExecuteRow <T>(Func <Schema.DataRow, T> converter) { if (TypeExtension.IsPrimitive(typeof(T))) { return(this.ExecuteScalar <T>()); } else { // Get DataRow var table = ExecuteInternalCommand(() => { using (DbDataReader dr = this.Command.ExecuteReader(System.Data.CommandBehavior.SingleRow)) { return(DataReaderConvertor.ToDataTable(dr)); } }); var row = table?.Rows?.FirstOrDefault(); // Return return(row != null?converter.Invoke(row) : default(T)); } }
/// <summary> /// Execute the query and fill the specified T object with the first row of results /// </summary> /// <typeparam name="T">Object type</typeparam> /// <param name="converter"></param> /// <returns>First row of results</returns> public async virtual Task <T> ExecuteRowAsync <T>(Func <Schema.DataRow, Task <T> > converter) { if (TypeExtension.IsPrimitive(typeof(T))) { return(await this.ExecuteScalarAsync <T>()); } else { // Get DataRow var table = await ExecuteInternalCommand(async() => { using (DbDataReader dr = await this.Command.ExecuteReaderAsync(System.Data.CommandBehavior.SingleRow)) { return(await DataReaderConvertor.ToDataTableAsync(dr)); } }); var row = table?.Rows?.FirstOrDefault(); // Return return(row != null ? await converter.Invoke(row) : default(T)); } }