public JoinReader(IReference reference)
{
IReferenceMetadata metadata = reference.List ?? reference.Find(ReferenceFlags.Child).Metadata;
this.Metadata = metadata.Identity.Require <IBindingMetadata>();
this.Identity = this.Metadata.Identity;
}
private ProjectionMetadataFlags GetFlags(ProjectionMetadata metadata)
{
IdAttribute id = metadata.Relation.Annotations?.OfType <IdAttribute>().FirstOrDefault();
OutAttribute out0 = metadata.Relation.Annotations?.OfType <OutAttribute>().FirstOrDefault();
InAttribute in0 = metadata.Relation.Annotations?.OfType <InAttribute>().FirstOrDefault();
IReferenceMetadata reference = metadata.Identity.GetMetadata <IReferenceMetadata>();
ProjectionMetadataFlags flags = ProjectionMetadataFlags.None;
if (id != null)
{
flags |= ProjectionMetadataFlags.Identity;
}
if (in0 != null || out0 != null)
{
flags |= in0 != null ? ProjectionMetadataFlags.Input : ProjectionMetadataFlags.None;
flags |= out0 != null ? ProjectionMetadataFlags.Output : ProjectionMetadataFlags.None;
}
else if (id != null)
{
flags |= ProjectionMetadataFlags.Output;
}
else if (reference != null && reference.HasAnyFlag(ReferenceMetadataFlags.Key))
{
flags |= ProjectionMetadataFlags.Input | ProjectionMetadataFlags.Output;
}
else
{
flags |= ProjectionMetadataFlags.Input;
}
return(flags);
}
private void AddNullKeys(IEnumerable <MetadataNode> itemNodes)
{
foreach (MetadataNode itemNode in itemNodes)
{
foreach (MetadataNode node in itemNode.Tree())
{
IReferenceMetadata metadata = node.GetMetadata <IReferenceMetadata>();
IEnumerable <IReferenceMetadata> properties = metadata?.Properties.Where(m => m.HasFlag(ReferenceMetadataFlags.PrimaryKey)) ?? Array.Empty <IReferenceMetadata>();
IList <MetadataNode> keyValues = properties.Select(m => itemNode.FindNode(m)).NotNull().ToList();
if (keyValues.Any())
{
node.NullKey = new KeyNode()
{
Value = keyValues,
};
foreach (MetadataNode keyValue in keyValues)
{
keyValue.Flags |= NodeFlags.Key;
}
}
}
}
}
private IEnumerable <IReference> GetValidReferences(IBindingMetadata metadata)
{
IReferenceMetadata referenceMetadata = metadata.Identity.Lookup <IReferenceMetadata>();
if (referenceMetadata != null)
{
return(referenceMetadata.References.Where(IsValid).OrderBy(r => r.Priority));
}
return(Array.Empty <IReference>());
bool IsValid(IReference reference)
{
if (!reference.HasFlag(ReferenceFlags.Many) && !reference.Other.HasFlag(ReferenceFlags.Many))
{
return(false);
}
IBindingMetadata metadata = reference.Find(ReferenceFlags.Child).Metadata.Identity.Lookup <IBindingMetadata>();
if (this.QueryType == QueryType.Aggregate && this.IsAggregateList(metadata))
{
return(false);
}
return(true);
}
}
private bool HasJoinKeyOverride(NewReader reader, KeyReader joinKey)
{
IReference childReference = joinKey.Reference.Find(ReferenceFlags.Child);
IReferenceMetadata targetMetadata = childReference.List ?? childReference.Metadata;
return(reader.Properties.Any(r => r.Metadata.Identity.Equals(targetMetadata.Identity)));
}
private static bool HasValidReference(IBindingMetadata metadata)
{
IReferenceMetadata referenceMetadata = metadata.Identity.Lookup <IReferenceMetadata>();
if (referenceMetadata != null)
{
IEnumerable <IReference> childReferences = referenceMetadata.References.Where(r => r.HasFlag(ReferenceFlags.Child));
return(childReferences.Any(r => r.HasFlag(ReferenceFlags.Many) || r.Other.HasFlag(ReferenceFlags.Many)));
}
return(false);
}
private IReference GetRecursiveReference(IReference reference)
{
IReferenceMetadata metadata = reference.Metadata;
foreach (IReference otherReference in metadata.References.Where(r => r.HasFlag(ReferenceFlags.Child) && !r.HasFlag(ReferenceFlags.Self)))
{
if (reference.Other.Key.Equals(otherReference.Key) || reference.Key.Equals(otherReference.Key))
{
return(otherReference);
}
}
return(null);
}
private void AddPrimaryKey(NewReader binder)
{
IReferenceMetadata metadata = binder.Metadata.Identity.Lookup <IReferenceMetadata>();
IEnumerable <IReferenceKey> primaryKeys = metadata?.Keys.Where(k => k.HasFlag(ReferenceKeyFlags.Primary)).ToList();
IEnumerable <KeyReader> keys = primaryKeys?.Select(k => this.FindPrimaryKey(binder, k)).ToList();
binder.PrimaryKey = keys?.NotNull().FirstOrDefault();
if (binder.PrimaryKey != null)
{
foreach (DataReader valueReader in binder.PrimaryKey.Values)
{
valueReader.CanBeDbNull = false;
}
}
}
private IEnumerable <KeyNode> GetChildKeys(MetadataNode itemNode)
{
IList <MetadataNode> allNodes = itemNode.Tree().ToList();
IReferenceMetadata metadata = itemNode.GetMetadata <IReferenceMetadata>();
IEnumerable <IReference> references = metadata?.References.Where(r => r.HasFlag(ReferenceFlags.Child)) ?? Array.Empty <IReference>();
foreach (IReference reference in references.Where(this.IsValidJoinReference))
{
KeyNode childKey = this.CreateKey(allNodes, reference);
if (childKey != null)
{
yield return(childKey);
}
}
}
private void CreateInputMetadata(IMetadataBuilderContext context, ProjectionMetadata metadata, IProjectionMetadata parent)
{
if (parent?.Reference != null)
{
IEnumerable <IReference> references = parent.Reference.References.Where(r => r.HasFlag(ReferenceFlags.Foreign) && !r.HasFlag(ReferenceFlags.Self));
foreach (IReference reference in references.OrderBy(r => r.Priority))
{
int valueIndex = reference.Key.Properties.IndexOf(m => m.Identity.Equals(metadata.Identity));
if (valueIndex > -1 && !reference.Other.Metadata.Relation.HasFlag(RelationMetadataFlags.Recursive))
{
IReferenceMetadata valueMetadata = reference.Other.Key.Properties[valueIndex];
metadata.Input = new Lazy <IProjectionMetadata>(() => this.GetMetadata(context, valueMetadata.Relation));
metadata.Flags |= ProjectionMetadataFlags.Cascade;
return;
}
}
}
metadata.Input = new Lazy <IProjectionMetadata>(() => metadata);
}
public static bool HasAnyFlag(this IReferenceMetadata metadata, RelationMetadataFlags flag) => metadata.Relation.HasAnyFlag(flag);
public static bool HasAnyFlag(this IReferenceMetadata metadata, ReferenceMetadataFlags flag) => (metadata.Flags & flag) != ReferenceMetadataFlags.None;
public static bool HasFlag(this IReferenceMetadata metadata, ReferenceMetadataFlags flag) => (metadata.Flags & flag) == flag;
public bool Equals(IReferenceMetadata other) => Equality.Combine(this.Identity, other?.Identity);
public NewReader(IReferenceMetadata metadata)
: this(metadata.Identity.Require <IBindingMetadata>())
{
}
