internal RecordState(RecordStateFactory recordStateFactory, CoordinatorFactory coordinatorFactory)
{
RecordStateFactory = recordStateFactory;
CoordinatorFactory = coordinatorFactory;
CurrentColumnValues = new object[RecordStateFactory.ColumnCount];
PendingColumnValues = new object[RecordStateFactory.ColumnCount];
}
private void SetShaper(Shaper<RecordState> shaper, CoordinatorFactory<RecordState> coordinatorFactory, int depth)
{
_shaper = shaper;
_coordinatorFactory = coordinatorFactory;
_dataRecord = new BridgeDataRecord(shaper, depth);
// To determine whether there are any rows for this coordinator at this place in
// the root enumerator, we pretty much just look at it's current record (we'll read
// one if there isn't one waiting) and if it matches our coordinator, we've got rows.
_hasRows = false;
if (!_shaper.DataWaiting)
{
_shaper.DataWaiting = _shaper.RootEnumerator.MoveNext();
}
if (_shaper.DataWaiting)
{
var currentRecord = _shaper.RootEnumerator.Current;
if (null != currentRecord)
{
_hasRows = (currentRecord.CoordinatorFactory == _coordinatorFactory);
}
}
// Once we've created the root enumerator, we can get the default record state
_defaultRecordState = coordinatorFactory.GetDefaultRecordState(_shaper);
Debug.Assert(null != _defaultRecordState, "no default?");
}
internal CoordinatorFactory Compile()
{
RecordStateFactory[] recordStateFactoryArray;
if (this._recordStateScratchpads != null)
{
recordStateFactoryArray = new RecordStateFactory[this._recordStateScratchpads.Count];
for (int index = 0; index < recordStateFactoryArray.Length; ++index)
{
recordStateFactoryArray[index] = this._recordStateScratchpads[index].Compile();
}
}
else
{
recordStateFactoryArray = new RecordStateFactory[0];
}
CoordinatorFactory[] coordinatorFactoryArray = new CoordinatorFactory[this._nestedCoordinatorScratchpads.Count];
for (int index = 0; index < coordinatorFactoryArray.Length; ++index)
{
coordinatorFactoryArray[index] = this._nestedCoordinatorScratchpads[index].Compile();
}
Expression expression1 = new CoordinatorScratchpad.ReplacementExpressionVisitor((Dictionary <Expression, Expression>)null, this._inlineDelegates).Visit(this.Element);
Expression expression2 = new CoordinatorScratchpad.ReplacementExpressionVisitor(this._expressionWithErrorHandlingMap, this._inlineDelegates).Visit(this.Element);
return((CoordinatorFactory)Activator.CreateInstance(typeof(CoordinatorFactory <>).MakeGenericType(this._elementType), (object)this.Depth, (object)this.StateSlotNumber, (object)this.HasData, (object)this.SetKeys, (object)this.CheckKeys, (object)coordinatorFactoryArray, (object)expression1, (object)expression2, (object)this.InitializeCollection, (object)recordStateFactoryArray));
}
internal RecordState(RecordStateFactory recordStateFactory, CoordinatorFactory coordinatorFactory)
{
RecordStateFactory = recordStateFactory;
CoordinatorFactory = coordinatorFactory;
CurrentColumnValues = new object[RecordStateFactory.ColumnCount];
PendingColumnValues = new object[RecordStateFactory.ColumnCount];
}
internal ShaperFactory(
int stateCount, CoordinatorFactory <T> rootCoordinatorFactory, MergeOption mergeOption)
{
_stateCount = stateCount;
_rootCoordinatorFactory = rootCoordinatorFactory;
_mergeOption = mergeOption;
}
internal ShaperFactory(
int stateCount, CoordinatorFactory <T> rootCoordinatorFactory, Action checkPermissions, MergeOption mergeOption)
{
_stateCount = stateCount;
_rootCoordinatorFactory = rootCoordinatorFactory;
_checkPermissions = checkPermissions;
_mergeOption = mergeOption;
}
internal ShaperFactory(
int stateCount, CoordinatorFactory <T> rootCoordinatorFactory, Type[] columnTypes, bool[] nullableColumns, MergeOption mergeOption)
{
_stateCount = stateCount;
_rootCoordinatorFactory = rootCoordinatorFactory;
ColumnTypes = columnTypes;
NullableColumns = nullableColumns;
_mergeOption = mergeOption;
}
internal RecordState(
RecordStateFactory recordStateFactory,
CoordinatorFactory coordinatorFactory)
{
this.RecordStateFactory = recordStateFactory;
this.CoordinatorFactory = coordinatorFactory;
this.CurrentColumnValues = new object[this.RecordStateFactory.ColumnCount];
this.PendingColumnValues = new object[this.RecordStateFactory.ColumnCount];
}
protected CoordinatorFactory(
int depth, int stateSlot, Func<Shaper, bool> hasData, Func<Shaper, bool> setKeys, Func<Shaper, bool> checkKeys,
CoordinatorFactory[] nestedCoordinators, RecordStateFactory[] recordStateFactories)
{
Depth = depth;
StateSlot = stateSlot;
// figure out if there are any nested coordinators
IsLeafResult = 0 == nestedCoordinators.Length;
// if there is no explicit 'has data' discriminator, it means all rows contain data for the coordinator
if (hasData == null)
{
HasData = _alwaysTrue;
}
else
{
HasData = hasData;
}
// if there is no explicit set key delegate, just return true (the value is not used anyways)
if (setKeys == null)
{
SetKeys = _alwaysTrue;
}
else
{
SetKeys = setKeys;
}
// If there are no keys, it means different things depending on whether we are a leaf
// coordinator or an inner (or 'driving') coordinator. For a leaf coordinator, it means
// that every row is a new result. For an inner coordinator, it means that there is no
// key to check. This should only occur where there is a SingleRowTable (in other words,
// all rows are elements of a single child collection).
if (checkKeys == null)
{
if (IsLeafResult)
{
CheckKeys = _alwaysFalse; // every row is a new result (the keys don't match)
}
else
{
CheckKeys = _alwaysTrue; // every row belongs to a single child collection
}
}
else
{
CheckKeys = checkKeys;
}
NestedCoordinators = new ReadOnlyCollection<CoordinatorFactory>(nestedCoordinators);
RecordStateFactories = new ReadOnlyCollection<RecordStateFactory>(recordStateFactories);
// Determines whether this coordinator can be handled by a 'simple' enumerator. See IsSimple for details.
IsSimple = IsLeafResult && null == checkKeys && null == hasData;
}
internal BridgeDataReader(
Shaper<RecordState> shaper, CoordinatorFactory<RecordState> coordinatorFactory, int depth,
IEnumerator<KeyValuePair<Shaper<RecordState>, CoordinatorFactory<RecordState>>> nextResultShaperInfos)
{
Contract.Requires(null != shaper);
Contract.Requires(null != coordinatorFactory);
Contract.Requires(depth == 0 || nextResultShaperInfos == null, "Nested data readers should not have multiple result sets.");
_nextResultShaperInfoEnumerator = nextResultShaperInfos;
SetShaper(shaper, coordinatorFactory, depth);
}
private void InitializeRecordStates(CoordinatorFactory coordinatorFactory)
{
foreach (RecordStateFactory recordStateFactory in coordinatorFactory.RecordStateFactories)
{
this.State[recordStateFactory.StateSlotNumber] = (object)recordStateFactory.Create(coordinatorFactory);
}
foreach (CoordinatorFactory nestedCoordinator in coordinatorFactory.NestedCoordinators)
{
this.InitializeRecordStates(nestedCoordinator);
}
}
// <summary>
// Initialize the RecordStateFactory objects in their StateSlots.
// </summary>
private void InitializeRecordStates(CoordinatorFactory coordinatorFactory)
{
foreach (var recordStateFactory in coordinatorFactory.RecordStateFactories)
{
State[recordStateFactory.StateSlotNumber] = recordStateFactory.Create(coordinatorFactory);
}
foreach (var nestedCoordinatorFactory in coordinatorFactory.NestedCoordinators)
{
InitializeRecordStates(nestedCoordinatorFactory);
}
}
internal Shaper(
DbDataReader reader, ObjectContext context, MetadataWorkspace workspace, MergeOption mergeOption,
int stateCount, CoordinatorFactory <T> rootCoordinatorFactory, bool readerOwned, bool streaming)
: base(reader, context, workspace, mergeOption, stateCount, streaming)
{
DebugCheck.NotNull(rootCoordinatorFactory);
RootCoordinator = (Coordinator <T>)rootCoordinatorFactory.CreateCoordinator(parent: null, next: null);
_isObjectQuery = !(typeof(T) == typeof(RecordState));
_isActive = true;
RootCoordinator.Initialize(this);
_readerOwned = readerOwned;
}
// <summary>
// Use the information stored on the scratchpad to compile an immutable factory used
// to construct the coordinators used at runtime when materializing results.
// </summary>
internal CoordinatorFactory Compile()
{
RecordStateFactory[] recordStateFactories;
if (null != _recordStateScratchpads)
{
recordStateFactories = new RecordStateFactory[_recordStateScratchpads.Count];
for (var i = 0; i < recordStateFactories.Length; i++)
{
recordStateFactories[i] = _recordStateScratchpads[i].Compile();
}
}
else
{
recordStateFactories = new RecordStateFactory[0];
}
var nestedCoordinators = new CoordinatorFactory[_nestedCoordinatorScratchpads.Count];
for (var i = 0; i < nestedCoordinators.Length; i++)
{
nestedCoordinators[i] = _nestedCoordinatorScratchpads[i].Compile();
}
// compile inline delegates
var replacementVisitor = new ReplacementExpressionVisitor(null, _inlineDelegates);
var element = replacementVisitor.Visit(Element);
// substitute expressions that have error handlers into a new expression (used
// when a more detailed exception message is needed)
replacementVisitor = new ReplacementExpressionVisitor(_expressionWithErrorHandlingMap, _inlineDelegates);
var elementWithErrorHandling = replacementVisitor.Visit(Element);
var result =
(CoordinatorFactory)Activator.CreateInstance(
typeof(CoordinatorFactory <>).MakeGenericType(_elementType), new object[]
{
Depth,
StateSlotNumber,
HasData,
SetKeys,
CheckKeys,
nestedCoordinators,
element,
elementWithErrorHandling,
InitializeCollection,
recordStateFactories
});
return(result);
}
internal Coordinator(
CoordinatorFactory <T> coordinatorFactory,
Coordinator parent,
Coordinator next)
: base((CoordinatorFactory)coordinatorFactory, parent, next)
{
this.TypedCoordinatorFactory = coordinatorFactory;
Coordinator next1 = (Coordinator)null;
foreach (CoordinatorFactory coordinatorFactory1 in coordinatorFactory.NestedCoordinators.Reverse <CoordinatorFactory>())
{
this.Child = coordinatorFactory1.CreateCoordinator((Coordinator)this, next1);
next1 = this.Child;
}
this.IsUsingElementCollection = !this.IsRoot && typeof(T) != typeof(RecordState);
}
internal Coordinator(CoordinatorFactory <T> coordinatorFactory, Coordinator parent, Coordinator next)
: base(coordinatorFactory, parent, next)
{
TypedCoordinatorFactory = coordinatorFactory;
// generate all children
Coordinator nextChild = null;
foreach (var nestedCoordinator in coordinatorFactory.NestedCoordinators.Reverse())
{
// last child processed is first child...
Child = nestedCoordinator.CreateCoordinator(this, nextChild);
nextChild = Child;
}
IsUsingElementCollection = !IsRoot && (typeof(T) != typeof(RecordState));
}
internal Shaper(
DbDataReader reader,
ObjectContext context,
MetadataWorkspace workspace,
MergeOption mergeOption,
int stateCount,
CoordinatorFactory <T> rootCoordinatorFactory,
bool readerOwned,
bool streaming)
: base(reader, context, workspace, mergeOption, stateCount, streaming)
{
this.RootCoordinator = (Coordinator <T>)rootCoordinatorFactory.CreateCoordinator((Coordinator)null, (Coordinator)null);
this._isObjectQuery = !(typeof(T) == typeof(RecordState));
this._isActive = true;
this.RootCoordinator.Initialize((Shaper)this);
this._readerOwned = readerOwned;
}
internal CoordinatorFactory(
int depth,
int stateSlot,
Expression <Func <Shaper, bool> > hasData,
Expression <Func <Shaper, bool> > setKeys,
Expression <Func <Shaper, bool> > checkKeys,
CoordinatorFactory[] nestedCoordinators,
Expression <Func <Shaper, TElement> > element,
Expression <Func <Shaper, IEntityWrapper> > wrappedElement,
Expression <Func <Shaper, TElement> > elementWithErrorHandling,
Expression <Func <Shaper, ICollection <TElement> > > initializeCollection,
RecordStateFactory[] recordStateFactories)
: base(depth, stateSlot, CoordinatorFactory <TElement> .CompilePredicate(hasData), CoordinatorFactory <TElement> .CompilePredicate(setKeys), CoordinatorFactory <TElement> .CompilePredicate(checkKeys), nestedCoordinators, recordStateFactories)
{
this.WrappedElement = wrappedElement == null ? (Func <Shaper, IEntityWrapper>)null : wrappedElement.Compile();
this.Element = element == null ? (Func <Shaper, TElement>)null : element.Compile();
this.ElementWithErrorHandling = elementWithErrorHandling.Compile();
this.InitializeCollection = initializeCollection == null ? (Func <Shaper, ICollection <TElement> >)(s => (ICollection <TElement>) new List <TElement>()) : initializeCollection.Compile();
this.Description = new StringBuilder().Append("HasData: ").AppendLine(CoordinatorFactory <TElement> .DescribeExpression((Expression)hasData)).Append("SetKeys: ").AppendLine(CoordinatorFactory <TElement> .DescribeExpression((Expression)setKeys)).Append("CheckKeys: ").AppendLine(CoordinatorFactory <TElement> .DescribeExpression((Expression)checkKeys)).Append("Element: ").AppendLine(element == null ? CoordinatorFactory <TElement> .DescribeExpression((Expression)wrappedElement) : CoordinatorFactory <TElement> .DescribeExpression((Expression)element)).Append("ElementWithExceptionHandling: ").AppendLine(CoordinatorFactory <TElement> .DescribeExpression((Expression)elementWithErrorHandling)).Append("InitializeCollection: ").AppendLine(CoordinatorFactory <TElement> .DescribeExpression((Expression)initializeCollection)).ToString();
}
/// <summary>
/// Use the information stored on the scratchpad to compile an immutable factory used
/// to construct the coordinators used at runtime when materializing results.
/// </summary>
internal CoordinatorFactory Compile()
{
RecordStateFactory[] recordStateFactories;
if (null != _recordStateScratchpads)
{
recordStateFactories = new RecordStateFactory[_recordStateScratchpads.Count];
for (var i = 0; i < recordStateFactories.Length; i++)
{
recordStateFactories[i] = _recordStateScratchpads[i].Compile();
}
}
else
{
recordStateFactories = new RecordStateFactory[0];
}
var nestedCoordinators = new CoordinatorFactory[_nestedCoordinatorScratchpads.Count];
for (var i = 0; i < nestedCoordinators.Length; i++)
{
nestedCoordinators[i] = _nestedCoordinatorScratchpads[i].Compile();
}
// compile inline delegates
var replacementVisitor = new ReplacementExpressionVisitor(null, _inlineDelegates);
var element = replacementVisitor.Visit(Element);
// substitute expressions that have error handlers into a new expression (used
// when a more detailed exception message is needed)
replacementVisitor = new ReplacementExpressionVisitor(_expressionWithErrorHandlingMap, _inlineDelegates);
var elementWithErrorHandling = replacementVisitor.Visit(Element);
var result =
(CoordinatorFactory)Activator.CreateInstance(
typeof(CoordinatorFactory<>).MakeGenericType(_elementType), new object[]
{
Depth,
StateSlotNumber,
HasData,
SetKeys,
CheckKeys,
nestedCoordinators,
element,
elementWithErrorHandling,
InitializeCollection,
recordStateFactories
});
return result;
}
/// <summary>
/// It's GO time, create the record state.
/// </summary>
internal RecordState Create(CoordinatorFactory coordinatorFactory)
{
return new RecordState(this, coordinatorFactory);
}
// <summary>
// It's GO time, create the record state.
// </summary>
internal RecordState Create(CoordinatorFactory coordinatorFactory)
{
return(new RecordState(this, coordinatorFactory));
}
protected Coordinator(CoordinatorFactory coordinatorFactory, Coordinator parent, Coordinator next)
{
CoordinatorFactory = coordinatorFactory;
Parent = parent;
Next = next;
}