/// <summary>
/// Converts an IDataReader to a single object.
/// </summary>
/// <typeparam name="T">The expected type of the object.</typeparam>
/// <param name="reader">The data reader.</param>
/// <param name="withGraph">The type of object graph to use to deserialize the object.</param>
/// <returns>A list of objects.</returns>
public static T Single <T>(this IDataReader reader, Type withGraph)
{
T t = reader.AsEnumerable <T>(withGraph).FirstOrDefault();
reader.Advance();
return(t);
}
/// <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="reader">The IDataReader to read results from.</param>
/// <returns>The QueryResult that contains all the results and the column mappings.</returns>
public static QueryResultQueue <object[]> Retrieve(this IDataReader reader)
{
var names = reader.GetNames();
return(new QueryResultQueue <object[]>(
Enumerable.Range(0, names.Length), names,
new Queue <object[]>(reader.AsEnumerable())));
}
public static IEnumerable <t> ReadAs <t> (this IDataReader records) where t : new()
{
foreach (var item in records
.AsEnumerable()
.Select(a => a.CastAs <t>()))
{
yield return(item);
}
}
public Task WriteToServerAsync(IDataReader reader, CancellationToken token)
{
if (reader is null)
{
throw new ArgumentNullException(nameof(reader));
}
return(WriteToServerAsync(reader.AsEnumerable(), reader.GetColumnNames(), token));
}
static void Query_AsEnumerable()
{
using (IDbConnection connection = Database.Open())
using (IDataReader reader = connection.GetReader("FindBeers", new { Name = "IPA" }))
{
foreach (Beer beer in reader.AsEnumerable <Beer>())
{
// drink?
}
}
}
/// <inheritdoc/>
public virtual IList <T> Read(IDbCommand command, IDataReader reader)
{
var results = new List <T>();
// read the main recordset from the reader
foreach (var record in reader.AsEnumerable(RecordReader))
{
results.Add(record);
}
ReadChildren(reader, results);
return(results);
}
/// <summary>
/// Converts an IDataReader to an enumerable. The reader is closed after all records are read.
/// </summary>
/// <typeparam name="T">The expected type of the object.</typeparam>
/// <param name="reader">The data reader.</param>
/// <param name="withGraph">An optional type to specify the types of objects in the returned graph.</param>
/// <param name="callback">An optional callback that allows you to assemble the object graph.</param>
/// <param name="idColumns">An optional dictionary of the names of the ID fields of the types in the graph.</param>
/// <returns>An enumerable over the return results.</returns>
/// <remarks>
/// If you use this method and are relying on CommandBehavior.CloseConnection to close the connection, note that if all of the records are not read
/// (due to an exception or otherwise), then the connection will leak until GC is run. Your code is responsible for closing the connection.
/// </remarks>
public static IEnumerable <T> AsEnumerable <T>(
this IDataReader reader,
Type withGraph = null,
Action <object[]> callback = null,
Dictionary <Type, string> idColumns = null)
{
Action <T> handler = null;
if (callback != null)
{
handler = (T t1) => callback(new object[] { t1 });
}
var oneToOne = Graph.GetOneToOne <T>(withGraph, callback, idColumns) ?? new OneToOne <T>(handler, null, idColumns);
return(reader.AsEnumerable(oneToOne));
}
public Task <AsyncResult <IEnumerable <Tuple <string, int, string> > > > GetUserSelectedAdditionalDataListAsync(Guid profileId, string[] keys, bool sortByKey = false, SortDirection sortDirection = SortDirection.Ascending,
uint?offset = null, uint?limit = null)
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
int dataNoIndex;
int dataIndex;
int keyIndex;
List <Tuple <string, int, string> > list = new List <Tuple <string, int, string> >();
using (IDbCommand command = UserProfileDataManagement_SubSchema.SelectUserAdditionalDataListCommand(transaction, profileId,
keys, sortByKey, sortDirection, out keyIndex, out dataNoIndex, out dataIndex))
{
using (IDataReader reader = command.ExecuteReader())
{
var records = reader.AsEnumerable();
if (offset.HasValue)
{
records = records.Skip((int)offset.Value);
}
if (limit.HasValue)
{
records = records.Take((int)limit.Value);
}
foreach (var record in records)
{
list.Add(new Tuple <string, int, string>(database.ReadDBValue <string>(record, keyIndex), database.ReadDBValue <int>(record, dataNoIndex),
database.ReadDBValue <string>(record, dataIndex)));
}
}
}
IEnumerable <Tuple <string, int, string> > data = null;
if (list.Count > 0)
{
data = list;
}
return(Task.FromResult(new AsyncResult <IEnumerable <Tuple <string, int, string> > >(data != null, data)));
}
finally
{
transaction.Dispose();
}
}
/// <summary>
/// Converts an IDataReader to an enumerable. The reader is closed after all records are read.
/// </summary>
/// <typeparam name="T">The expected type of the object.</typeparam>
/// <typeparam name="TSub1">The expected type of sub object 1.</typeparam>
/// <param name="reader">The data reader.</param>
/// <param name="callback">A callback for custom sub-object mapping.</param>
/// <param name="idColumns">A list of names of columns that identify the start of a new type.</param>
/// <returns>An enumerable over the return results.</returns>
/// <remarks>
/// If you use this method and are relying on CommandBehavior.CloseConnection to close the connection, note that if all of the records are not read
/// (due to an exception or otherwise), then the connection will leak until GC is run. Your code is responsible for closing the connection.
/// </remarks>
public static IEnumerable <T> AsEnumerable <T, TSub1>(
this IDataReader reader,
Action <T, TSub1> callback = null,
Dictionary <Type, string> idColumns = null)
{
Action <object[]> action = null;
if (callback != null)
{
action = (object[] objects) =>
{
callback(
(T)objects[0],
(TSub1)objects[1]);
};
}
return(reader.AsEnumerable <T>(typeof(Graph <T, TSub1>), action, idColumns));
}
private static void SetGeneratedPropertyValues(IReadOnlyList <object> dataEntities, IDataReader generatedValues)
{
var map = generatedValues.AsEnumerable().Select(r => new
{
StatementId = r.GetInt32(r.GetOrdinal("StatementId")),
GeneratedId = r.GetValue(r.GetOrdinal("GeneratedId")),
ParameterName = r.GetString(r.GetOrdinal("ParameterName")),
PropertyName = r.GetString(r.GetOrdinal("PropertyName"))
}).ToDictionary(r => r.StatementId, r => Tuple.Create(r.GeneratedId, r.ParameterName, r.PropertyName));
for (var i = 0; i < dataEntities.Count; i++)
{
if (!map.TryGetValue(i, out var value))
{
continue;
}
dataEntities[i].Property(value.Item3, value.Item1);
dataEntities[i].Cascade(value.Item3, value.Item1);
}
}
public virtual IEnumerable <T> ExecuteWithQuery <T>(string queryText, Func <IDataRecord, T> select)
{
var command = this.BuildCommand(queryText);
IDataReader reader = null;
try
{
reader = command.ExecuteReader();
var rows = reader.AsEnumerable(select);
return(new DisposableEnumeration <T>(rows, reader, command, this));
}
catch (Exception)
{
if (reader != null)
{
reader.Dispose();
}
command.Dispose();
throw;
}
}
/// <summary>
/// Converts an IDataReader to an enumerable. The reader is closed after all records are read.
/// </summary>
/// <param name="reader">The data reader.</param>
/// <returns>An enumerable over the return results.</returns>
/// <remarks>
/// If you use this method and are relying on CommandBehavior.CloseConnection to close the connection, note that if all of the records are not read
/// (due to an exception or otherwise), then the connection will leak until GC is run. Your code is responsible for closing the connection.
/// </remarks>
public static IEnumerable <FastExpando> AsEnumerable(this IDataReader reader)
{
return(reader.AsEnumerable <FastExpando>());
}
public IList <MediaItem> QueryList()
{
ISQLDatabase database = ServiceRegistration.Get <ISQLDatabase>();
ITransaction transaction = database.BeginTransaction();
try
{
string statementStr;
IList <BindVar> bindVars;
// 1. Request all complex attributes
IDictionary <Guid, IDictionary <MediaItemAspectMetadata.AttributeSpecification, ICollection <object> > > complexAttributeValues =
new Dictionary <Guid, IDictionary <MediaItemAspectMetadata.AttributeSpecification, ICollection <object> > >();
foreach (MediaItemAspectMetadata.AttributeSpecification attr in _explicitSelectAttributes)
{
ComplexAttributeQueryBuilder complexAttributeQueryBuilder = new ComplexAttributeQueryBuilder(
_miaManagement, attr, null, _necessaryRequestedMIAs, _filter);
using (IDbCommand command = transaction.CreateCommand())
{
string mediaItemIdAlias;
string valueAlias;
complexAttributeQueryBuilder.GenerateSqlStatement(out mediaItemIdAlias, out valueAlias,
out statementStr, out bindVars);
command.CommandText = statementStr;
foreach (BindVar bindVar in bindVars)
{
database.AddParameter(command, bindVar.Name, bindVar.Value, bindVar.VariableType);
}
Type valueType = attr.AttributeType;
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
Guid mediaItemId = database.ReadDBValue <Guid>(reader, reader.GetOrdinal(mediaItemIdAlias));
object value = database.ReadDBValue(valueType, reader, reader.GetOrdinal(valueAlias));
IDictionary <MediaItemAspectMetadata.AttributeSpecification, ICollection <object> > attributeValues;
if (!complexAttributeValues.TryGetValue(mediaItemId, out attributeValues))
{
attributeValues = complexAttributeValues[mediaItemId] =
new Dictionary <MediaItemAspectMetadata.AttributeSpecification, ICollection <object> >();
}
ICollection <object> attrValues;
if (!attributeValues.TryGetValue(attr, out attrValues))
{
attrValues = attributeValues[attr] = new HashSet <object>();
}
attrValues.Add(value);
}
}
}
}
// 2. Main query
MainQueryBuilder mainQueryBuilder = new MainQueryBuilder(_miaManagement,
_mainSelectAttributes.Values, null, _necessaryRequestedMIAs, _optionalRequestedMIAs, _filter, _sortInformation, _limit, _offset);
using (IDbCommand command = transaction.CreateCommand())
{
string mediaItemIdAlias2;
IDictionary <MediaItemAspectMetadata, string> miamAliases;
// Maps (selected and filtered) QueryAttributes to CompiledQueryAttributes in the SQL query
IDictionary <QueryAttribute, string> qa2a;
mainQueryBuilder.GenerateSqlStatement(out mediaItemIdAlias2, out miamAliases, out qa2a,
out statementStr, out bindVars);
// Try to use SQL side paging, which gives best performance if supported
ISQLDatabasePaging paging = database as ISQLDatabasePaging;
if (paging != null)
{
paging.Process(ref statementStr, ref bindVars, ref _offset, ref _limit);
}
command.CommandText = statementStr;
foreach (BindVar bindVar in bindVars)
{
database.AddParameter(command, bindVar.Name, bindVar.Value, bindVar.VariableType);
}
IEnumerable <MediaItemAspectMetadata> selectedMIAs = _necessaryRequestedMIAs.Union(_optionalRequestedMIAs);
ICollection <Guid> mediaItems = new HashSet <Guid>();
using (IDataReader fullReader = command.ExecuteReader())
{
IList <MediaItem> result = new List <MediaItem>();
var records = fullReader.AsEnumerable();
if (_offset.HasValue)
{
records = records.Skip((int)_offset.Value);
}
if (_limit.HasValue)
{
records = records.Take((int)_limit.Value);
}
foreach (var reader in records)
{
Guid mediaItemId = database.ReadDBValue <Guid>(reader, reader.GetOrdinal(mediaItemIdAlias2));
if (mediaItems.Contains(mediaItemId))
{
// Media item was already added to result - query results are not always unique because of JOINs used for filtering
continue;
}
mediaItems.Add(mediaItemId);
IDictionary <MediaItemAspectMetadata.AttributeSpecification, ICollection <object> > attributeValues;
if (!complexAttributeValues.TryGetValue(mediaItemId, out attributeValues))
{
attributeValues = null;
}
MediaItem mediaItem = new MediaItem(mediaItemId);
foreach (MediaItemAspectMetadata miam in selectedMIAs)
{
if (reader.IsDBNull(reader.GetOrdinal(miamAliases[miam])))
{
// MIAM is not available for current media item
continue;
}
MediaItemAspect mia = new MediaItemAspect(miam);
foreach (MediaItemAspectMetadata.AttributeSpecification attr in miam.AttributeSpecifications.Values)
{
if (attr.Cardinality == Cardinality.Inline)
{
QueryAttribute qa = _mainSelectAttributes[attr];
string alias = qa2a[qa];
mia.SetAttribute(attr, database.ReadDBValue(attr.AttributeType, reader, reader.GetOrdinal(alias)));
}
else
{
ICollection <object> attrValues;
if (attributeValues != null && attributeValues.TryGetValue(attr, out attrValues))
{
mia.SetCollectionAttribute(attr, attrValues);
}
}
}
mediaItem.Aspects[miam.AspectId] = mia;
}
result.Add(mediaItem);
}
return(result);
}
}
}
finally
{
transaction.Dispose();
}
}
private IList <MediaItem> GetMediaItems(ISQLDatabase database, ITransaction transaction, bool singleMode, IEnumerable <MediaItemAspectMetadata> selectedMIAs, out IList <Guid> mediaItemIds, out IDictionary <Guid, IList <Guid> > complexMediaItems)
{
string statementStr;
IList <BindVar> bindVars;
MIAQueryBuilder builder = new MIAQueryBuilder(_miaManagement,
_mainSelectAttributes.Values, null, _necessaryRequestedMIAs, _optionalRequestedMIAs, _filter, _subqueryFilter, _sortInformation);
using (IDbCommand command = transaction.CreateCommand())
{
string mediaItemIdAlias2;
IDictionary <MediaItemAspectMetadata, string> miamAliases;
// Maps (selected and filtered) QueryAttributes to CompiledQueryAttributes in the SQL query
IDictionary <QueryAttribute, string> qa2a;
builder.GenerateSqlStatement(out mediaItemIdAlias2, out miamAliases, out qa2a,
out statementStr, out bindVars);
// Try to use SQL side paging, which gives best performance if supported
ISQLDatabasePaging paging = database as ISQLDatabasePaging;
if (paging != null)
{
paging.Process(ref statementStr, ref bindVars, ref _offset, ref _limit);
}
command.CommandText = statementStr;
foreach (BindVar bindVar in bindVars)
{
database.AddParameter(command, bindVar.Name, bindVar.Value, bindVar.VariableType);
}
using (IDataReader fullReader = command.ExecuteReader())
{
IList <MediaItem> result = new List <MediaItem>();
mediaItemIds = new List <Guid>();
complexMediaItems = new Dictionary <Guid, IList <Guid> >();
var records = fullReader.AsEnumerable();
if (_offset.HasValue)
{
records = records.Skip((int)_offset.Value);
}
if (_limit.HasValue)
{
records = records.Take((int)_limit.Value);
}
foreach (var reader in records)
{
Guid mediaItemId = database.ReadDBValue <Guid>(reader, reader.GetOrdinal(mediaItemIdAlias2));
if (mediaItemIds.Contains(mediaItemId))
{
// Media item was already added to result - query results are not always unique because of JOINs used for filtering
continue;
}
mediaItemIds.Add(mediaItemId);
MediaItem mediaItem = new MediaItem(mediaItemId);
foreach (SingleMediaItemAspectMetadata miam in selectedMIAs.Where(x => x is SingleMediaItemAspectMetadata))
{
string name;
if (!miamAliases.TryGetValue(miam, out name) || reader.IsDBNull(reader.GetOrdinal(name)))
{
// MIAM is not available for current media item
continue;
}
IList <Guid> complexIds;
if (!complexMediaItems.TryGetValue(miam.AspectId, out complexIds))
{
complexMediaItems[miam.AspectId] = complexIds = new List <Guid>();
}
complexIds.Add(mediaItemId);
SingleMediaItemAspect mia = new SingleMediaItemAspect(miam);
foreach (MediaItemAspectMetadata.AttributeSpecification attr in miam.AttributeSpecifications.Values)
{
if (attr.Cardinality == Cardinality.Inline)
{
QueryAttribute qa = _mainSelectAttributes[attr];
string alias = qa2a[qa];
mia.SetAttribute(attr, database.ReadDBValue(attr.AttributeType, reader, reader.GetOrdinal(alias)));
}
}
MediaItemAspect.SetAspect(mediaItem.Aspects, mia);
}
result.Add(mediaItem);
if (singleMode)
{
break;
}
}
return(result);
}
}
}
/// <inheritdoc/>
public override void Read(IEnumerable <TParent> parents, IDataReader reader)
{
_mapper.MapChildren(parents, reader.AsEnumerable(_recordReader));
}
/// <summary>
/// Converts an IDataReader to a list of objects.
/// </summary>
/// <typeparam name="T">The expected type of the object.</typeparam>
/// <param name="reader">The data reader.</param>
/// <param name="withGraph">The graph to use to deserialize the object.</param>
/// <returns>A list of objects.</returns>
public static IList <T> ToList <T>(this IDataReader reader, Type withGraph)
{
return(reader.AsEnumerable <T>(withGraph).ToList());
}
/// <summary>
/// Converts an IDataReader to a list of objects, using the specified record reader.
/// </summary>
/// <typeparam name="T">The type of object to return.</typeparam>
/// <param name="reader">The data reader.</param>
/// <param name="recordReader">The record reader to use.</param>
/// <returns>A list of objects.</returns>
public static IList <T> ToList <T>(this IDataReader reader, IRecordReader <T> recordReader)
{
return(reader.AsEnumerable(recordReader).ToList());
}
/// <summary>
/// Maps an <see cref="IDataReader"/> to a sequence of <typeparamref name="T"/> objects.
/// </summary>
/// <typeparam name="T">The type of instance to create</typeparam>
/// <param name="reader">The reader.</param>
/// <returns>An <see cref="IEnumerable{T}"/></returns>
public static IEnumerable <T> MapToEnumerable <T>(this IDataReader reader) where T : class, new()
{
Guard.ArgumentNotNull(reader, "reader");
return(reader.AsEnumerable().Select(r => r.MapObject <T>()));
}
/// <summary>
/// Transforms the <paramref name="dataReader"/> into an instance of <typeparamref name="T"/>.
/// </summary>
/// <typeparam name="T">The type of object to be created from the <paramref name="dataReader"/>.</typeparam>
/// <param name="dataReader">The target <see cref="IDataReader"/>.</param>
/// <returns>An instance of <typeparamref name="T"/>.</returns>
public static T As <T>(this IDataReader dataReader) where T : class
{
return(dataReader.AsEnumerable <T>().FirstOrDefault());
}
