public QueryResult <T> Invoke <T>(RecordSetReader recordSetReader, Session session, ParameterContext parameterContext)
{
var reader = (IMaterializingReader <T>)
materializeMethod.Invoke(recordSetReader, session, parameterContext);
return(new QueryResult <T>(reader, session.GetLifetimeToken()));
}
/// <summary>
/// Gets <see cref="RecordSetReader"/> bound to the specified <paramref name="session"/>.
/// </summary>
/// <param name="session">Session to bind.</param>
/// <param name="parameterContext"><see cref="ParameterContext"/> instance with
/// the values of query parameters.</param>
/// <returns>New <see cref="RecordSetReader"/> bound to specified <paramref name="session"/>.</returns>
public RecordSetReader GetRecordSetReader(Session session, ParameterContext parameterContext)
{
ArgumentValidator.EnsureArgumentNotNull(session, nameof(session));
var enumerationContext = session.CreateEnumerationContext(parameterContext);
return(RecordSetReader.Create(enumerationContext, this));
}
public void RecordSetReader()
{
var testRS = generateRecordSet();
var rdr = new RecordSetReader(testRS);
Assert.True(rdr.HasRows);
Assert.Throws <InvalidOperationException>(() => { var o = rdr[0]; });
Assert.True(rdr.Read());
Assert.Equal(4, rdr.FieldCount);
Assert.Equal("id", rdr.GetName(0));
Assert.Equal(2, rdr.GetOrdinal("amount"));
Assert.Equal("added_date", rdr.GetName(3));
Assert.Throws <IndexOutOfRangeException>(() => { var o = rdr.GetName(4); });
Assert.Equal(0, rdr.GetInt32(0));
Assert.Equal(0, rdr[0]);
Assert.Equal("Name0", rdr[1]);
Assert.Equal(0, rdr[2]);
Assert.Equal(1, rdr.GetDateTime(3).Month);
int cnt = 1;
while (rdr.Read())
{
Assert.Equal(cnt, rdr[0]);
cnt++;
}
Assert.Throws <InvalidOperationException>(() => { var o = rdr[0]; });
rdr.Dispose();
Assert.Throws <InvalidOperationException>(() => { var o = rdr.FieldCount; });
Assert.Throws <InvalidOperationException>(() => { var o = rdr.GetOrdinal("id"); });
Assert.Equal(100, cnt);
// read RS from RecordSetReader
var testRSCopy = RecordSet.FromReader(new RecordSetReader(testRS));
Assert.Equal(testRS.Count, testRSCopy.Count);
Assert.Equal(testRS.Columns.Count, testRSCopy.Columns.Count);
var testRSCopyOneRec = RecordSet.FromReader(new RecordSetReader(testRS), 1);
Assert.Equal(1, testRSCopyOneRec.Count);
// read into initialized RecordSet
var newRS = new RecordSet(
new[] {
new RecordSet.Column("id", typeof(int)),
new RecordSet.Column("name", typeof(string))
}
);
newRS.Load(new RecordSetReader(testRS));
Assert.Equal(testRS.Count, newRS.Count);
Assert.Equal("Name99", newRS[99].Field <string>("name"));
}
/// <summary>
/// Transforms current <see cref="ExecutableProvider"/> instance to <see cref="IEnumerable{T}"/>
/// sequence of <see cref="Tuple"/>s.
/// </summary>
/// <param name="context">The <see cref="EnumerationContext"/> instance where to perform enumeration.</param>
/// <returns>Sequence of <see cref="Tuple"/>s.</returns>
public IEnumerable <Tuple> ToEnumerable(EnumerationContext context)
{
using var tupleReader = RecordSetReader.Create(context, this);
while (tupleReader.MoveNext())
{
yield return(tupleReader.Current);
}
}
/// <summary>
/// Asynchronously gets <see cref="RecordSetReader"/> bound to the specified <paramref name="session"/>.
/// </summary>
/// <remarks> Multiple active operations are not supported. Use <see langword="await"/>
/// to ensure that all asynchronous operations have completed.</remarks>
/// <param name="session">Session to bind.</param>
/// <param name="parameterContext"><see cref="ParameterContext"/> instance with
/// the values of query parameters.</param>
/// <param name="token">Token to cancel operation.</param>
/// <returns>Task performing this operation.</returns>
public async Task <RecordSetReader> GetRecordSetReaderAsync(
Session session, ParameterContext parameterContext, CancellationToken token)
{
ArgumentValidator.EnsureArgumentNotNull(session, nameof(session));
var enumerationContext =
await session.CreateEnumerationContextAsync(parameterContext, token).ConfigureAwait(false);
return(await RecordSetReader.CreateAsync(enumerationContext, this, token).ConfigureAwait(false));
}
/// <summary>
/// Wraps <see cref="RecordSetReader"/> by adding <see cref="Tuple"/> to <typeparamref name="TResult"/>
/// conversion for individual records.
/// </summary>
/// <typeparam name="TResult">The type of the result.</typeparam>
/// <param name="recordSetReader">The reader over raw data source.</param>
/// <param name="context">The context.</param>
/// <param name="parameterContext">The parameter context.</param>
/// <param name="itemMaterializer">The materialization delegate performing
/// <see cref="Tuple"/> instance to instance of <typeparamref name="TResult"/> type conversion.</param>
public static object Materialize <TResult>(
RecordSetReader recordSetReader,
MaterializationContext context,
ParameterContext parameterContext,
IItemMaterializer <TResult> itemMaterializer)
{
var enumerationContext = (EnumerationContext)recordSetReader.Context;
if (enumerationContext != null)
{
enumerationContext.MaterializationContext = context;
}
return(new MaterializingReader <TResult>(recordSetReader, context, parameterContext, itemMaterializer));
}
public Entity Materialize(int entityIndex, int typeIdIndex, TypeInfo type, Pair <int>[] entityColumns, Tuple tuple)
{
var result = entities[entityIndex];
if (result != null)
{
return(result);
}
TypeReferenceAccuracy accuracy;
int typeId = RecordSetReader.ExtractTypeId(type, typeIdRegistry, tuple, typeIdIndex, out accuracy);
if (typeId == TypeInfo.NoTypeId)
{
return(null);
}
bool canCache = accuracy == TypeReferenceAccuracy.ExactType;
var materializationInfo = MaterializationContext.GetTypeMapping(entityIndex, type, typeId, entityColumns);
Key key;
var keyIndexes = materializationInfo.KeyIndexes;
if (!KeyFactory.IsValidKeyTuple(tuple, keyIndexes))
{
return(null);
}
if (keyIndexes.Length <= WellKnown.MaxGenericKeyLength)
{
key = KeyFactory.Materialize(Session.Domain, Session.StorageNodeId, materializationInfo.Type, tuple, accuracy, canCache, keyIndexes);
}
else
{
var keyTuple = materializationInfo.KeyTransform.Apply(TupleTransformType.TransformedTuple, tuple);
key = KeyFactory.Materialize(Session.Domain, Session.StorageNodeId, materializationInfo.Type, keyTuple, accuracy, canCache, null);
}
if (accuracy == TypeReferenceAccuracy.ExactType)
{
var entityTuple = materializationInfo.Transform.Apply(TupleTransformType.Tuple, tuple);
var entityState = Session.Handler.UpdateState(key, entityTuple);
result = entityState.Entity;
}
else
{
result = Session.Query.SingleOrDefault(key);
}
entities[entityIndex] = result;
return(result);
}
// Constructors
internal Domain(DomainConfiguration configuration, object upgradeContextCookie, SqlConnection singleConnection, DefaultSchemaInfo defaultSchemaInfo)
{
Configuration = configuration;
Handlers = new HandlerAccessor(this);
GenericKeyFactories = new ConcurrentDictionary <TypeInfo, GenericKeyFactory>();
RecordSetReader = new RecordSetReader(this);
KeyGenerators = new KeyGeneratorRegistry();
PrefetchFieldDescriptorCache = new ConcurrentDictionary <TypeInfo, ReadOnlyList <PrefetchFieldDescriptor> >();
KeyCache = new LruCache <Key, Key>(Configuration.KeyCacheSize, k => k);
QueryCache = new LruCache <object, Pair <object, TranslatedQuery> >(Configuration.QueryCacheSize, k => k.First);
PrefetchActionMap = new Dictionary <TypeInfo, Action <SessionHandler, IEnumerable <Key> > >();
Extensions = new ExtensionCollection();
UpgradeContextCookie = upgradeContextCookie;
SingleConnection = singleConnection;
StorageNodeManager = new StorageNodeManager(Handlers);
}
internal MaterializingReader(RecordSetReader recordSetReader, MaterializationContext context,
ParameterContext parameterContext, IItemMaterializer <TItem> itemMaterializer)
{
this.recordSetReader = recordSetReader;
this.context = context;
this.parameterContext = parameterContext;
this.itemMaterializer = itemMaterializer;
if (context.MaterializationQueue == null)
{
context.MaterializationQueue = materializationQueue = new Queue <Action>();
}
else
{
materializationQueue = null;
}
}
private void PutLoadedStatesInCache(IEnumerable <Tuple> queryResult, RecordSetReader reader,
HashSet <Key> foundedKeys)
{
var records = reader.Read(queryResult, Provider.Header, manager.Owner.Session);
foreach (var record in records)
{
if (record != null)
{
var fetchedKey = record.GetKey();
var tuple = record.GetTuple();
if (tuple != null)
{
manager.SaveStrongReference(manager.Owner.UpdateState(fetchedKey, tuple));
foundedKeys.Add(fetchedKey);
}
}
}
}
private void UpdateCache(Session session, RecordSetReader source)
{
var reader = Domain.EntityDataReader;
foreach (var record in reader.Read(source.ToEnumerable(), source.Header, session))
{
for (int i = 0; i < record.Count; i++)
{
var key = record.GetKey(i);
if (key == null)
{
continue;
}
var tuple = record.GetTuple(i);
if (tuple == null)
{
continue;
}
session.UpdateStateInCache(key, tuple);
}
}
}
public void RecordSetReader()
{
var testRS = new RecordSet(new [] {
new RecordSet.Column("id", typeof(int)),
new RecordSet.Column("name", typeof(string)),
new RecordSet.Column("amount", typeof(decimal)),
new RecordSet.Column("added_date", typeof(DateTime))
});
for (int i = 0; i < 100; i++)
{
testRS.Add(new object[] {
i, "Name" + i.ToString(), i % 20, new DateTime(2000, 1, 1).AddMonths(i)
});
}
var rdr = new RecordSetReader(testRS);
Assert.True(rdr.HasRows);
Assert.Throws <InvalidOperationException>(() => { var o = rdr[0]; });
Assert.True(rdr.Read());
Assert.Equal(4, rdr.FieldCount);
Assert.Equal("id", rdr.GetName(0));
Assert.Equal(2, rdr.GetOrdinal("amount"));
Assert.Equal("added_date", rdr.GetName(3));
Assert.Throws <IndexOutOfRangeException>(() => { var o = rdr.GetName(4); });
Assert.Equal(0, rdr.GetInt32(0));
Assert.Equal(0, rdr[0]);
Assert.Equal("Name0", rdr[1]);
Assert.Equal(0, rdr[2]);
Assert.Equal(1, rdr.GetDateTime(3).Month);
int cnt = 1;
while (rdr.Read())
{
Assert.Equal(cnt, rdr[0]);
cnt++;
}
Assert.Throws <InvalidOperationException>(() => { var o = rdr[0]; });
rdr.Dispose();
Assert.Throws <InvalidOperationException>(() => { var o = rdr.FieldCount; });
Assert.Throws <InvalidOperationException>(() => { var o = rdr.GetOrdinal("id"); });
Assert.Equal(100, cnt);
// read RS from RecordSetReader
var testRSCopy = RecordSet.FromReader(new RecordSetReader(testRS));
Assert.Equal(testRS.Count, testRSCopy.Count);
Assert.Equal(testRS.Columns.Count, testRSCopy.Columns.Count);
// read into initialized RecordSet
var newRS = new RecordSet(
new[] {
new RecordSet.Column("id", typeof(int)),
new RecordSet.Column("name", typeof(string))
}
);
newRS.Load(new RecordSetReader(testRS));
Assert.Equal(testRS.Count, newRS.Count);
Assert.Equal("Name99", newRS[99].Field <string>("name"));
}
