protected override IEnumerable <EntitySetHandle> OnVisitItems(EvaluationContext evalContext) { // The relationship (definition) being accessed // (don't evaluate in loop for now ... OK while they're just literals) IEntity relationship = Right.EvaluateEntity(evalContext); IEntity current = Left.EvaluateEntity(evalContext); if (current == null) { yield break; } // Relationship data IEntityRelationshipCollection <IEntity> values = current.GetRelationships(relationship, Direction); foreach (var pair in values) { var result = new EntitySetHandle { Entity = pair != null ? pair.Entity : null, Expression = this }; yield return(result); } }
public void AddParent(EntitySetHandle parent) { if (Parents == null) { Parents = new List <EntitySetHandle>(); } Parents.Add(parent); }
protected override IEnumerable <EntitySetHandle> OnVisitItems(EvaluationContext evalContext) { EntitySetHandle handle = new EntitySetHandle { Expression = this }; yield return(handle); }
protected override IEnumerable <EntitySetHandle> OnVisitItems(EvaluationContext evalContext) { var result = new EntitySetHandle { Entity = evalContext.Settings.ContextEntity, Expression = this }; yield return(result); }
protected override IEnumerable <EntitySetHandle> OnVisitItems(EvaluationContext evalContext) { // The instances passed in via the parameter IEnumerable <IEntity> instances = GetParameterList(evalContext); foreach (var instance in instances) { var result = new EntitySetHandle { Entity = instance, Expression = this }; yield return(result); } }
protected virtual IEnumerable <EntitySetHandle> OnVisitAllItems(EvaluationContext evalContext) { // Yes .. this is a hack // The problem is its not necessarily the case that children should or should not constrain the parent // The problem is that the tree itself is built wrong.. the root node should be the 'where' node if the overall result set is to be filtered. bool childrenWillContrainParent = ChildContainer.ChildEntityNodes.Any(node => node is WhereNode); // Return handle to Visit each entity IEnumerable <EntitySetHandle> handles = OnVisitItems(evalContext).Select(handle => { handle.Activate(evalContext); return(handle); }); // (Wraps are used to track if any of the joins were non-default-nulls) var handleWraps = handles.Select(h => new HandleWrap { Handle = h, IsNotEmpty = !childrenWillContrainParent }); // And cross-join all child nodes against each other. // Note: these are effectively left-joined to the parent. (We use the DefaultIfEmpty to ensure that each set returns at least one value, to ensure they act as a left join). var handlesEx = ChildContainer.ChildEntityNodes.Aggregate ( seed: handleWraps, func: (accumHandles, joinNode) => accumHandles.SelectMany( collectionSelector: handle => AddDefaultRowIfRequired(joinNode.VisitItems(evalContext), evalContext), resultSelector: (parent, child) => { bool wasEmpty = child == null; if (wasEmpty) { child = new EntitySetHandle { Expression = joinNode } } ; child.AddParent(parent.Handle); return(new HandleWrap { Handle = child, IsNotEmpty = !wasEmpty }); } ) ); if (childrenWillContrainParent) { handlesEx = handlesEx.Where(hw => hw.IsNotEmpty); } return(handlesEx.Select(hw => hw.Handle)); }
protected override IEnumerable <EntitySetHandle> OnVisitItems(EvaluationContext evalContext) { IEntity instance = Instance.Entity; if (instance == null) { yield break; } var result = new EntitySetHandle { Entity = instance, Expression = this }; yield return(result); }
protected override IEnumerable <EntitySetHandle> OnVisitItems(EvaluationContext evalContext) { // The type of instances to load IEntity type = Argument.EvaluateEntity(evalContext); // Get instances IEnumerable <IEntity> instances = Entity.GetInstancesOfType(new EntityRef(type.Id), true); foreach (var instance in instances) { var result = new EntitySetHandle { Entity = instance, Expression = this }; yield return(result); } }