internal static StrongEntityAccessor GetEntityAccessor(this IQueryVisitor visitor, Remotion.Linq.Clauses.FromClauseBase sourceExpression)
{
StrongEntityAccessor entityAccessor = null;
if (typeof(IEntity).GetTypeInfo().IsAssignableFrom(sourceExpression.ItemType))
{
sourceExpression = visitor.TransformFromExpression(sourceExpression);
entityAccessor = visitor.Query.FindAllComponents <StrongEntityAccessor>().FirstOrDefault(item => item.SourceExpression.EqualsTo(sourceExpression));
if (entityAccessor == null)
{
Identifier identifier = visitor.Query.FindAllComponents <EntityConstrain>()
.Where(item => (item.TargetExpression.EqualsTo(sourceExpression.FromExpression)) && (item.Value is Identifier))
.Select(item => (Identifier)item.Value)
.FirstOrDefault() ?? new Identifier(visitor.Query.CreateVariableName(sourceExpression.ItemName), sourceExpression.ItemType.FindEntityType());
entityAccessor = new StrongEntityAccessor(identifier, sourceExpression);
entityAccessor.UnboundGraphName = entityAccessor.About;
EntityTypeConstrain constrain = visitor.CreateTypeConstrain(sourceExpression);
if ((constrain != null) && (!entityAccessor.Elements.Contains(constrain)))
{
entityAccessor.Elements.Add(constrain);
}
}
}
return(entityAccessor);
}
/// <summary>Visits a type binary expression.</summary>
/// <param name="expression">Expression to be visited.</param>
/// <returns>Expression visited</returns>
protected override System.Linq.Expressions.Expression VisitTypeBinary(System.Linq.Expressions.TypeBinaryExpression expression)
{
var classMappings = MappingsRepository.FindMappedClasses(expression.TypeOperand);
if (classMappings.Any())
{
Remotion.Linq.Clauses.FromClauseBase sourceExpression = GetSourceExpression(expression.Expression);
StrongEntityAccessor entityAccessor = _query.FindAllComponents <StrongEntityAccessor>().FirstOrDefault(item => item.SourceExpression == sourceExpression);
if (entityAccessor == null)
{
entityAccessor = this.GetEntityAccessor(sourceExpression);
_query.Elements.Add(entityAccessor);
}
EntityTypeConstrain typeConstrain = this.CreateTypeConstrain(expression.TypeOperand, entityAccessor.SourceExpression.FromExpression);
_lastComponent = typeConstrain;
if ((_currentComponent.Count > 0) && (_currentComponent.Peek() is BinaryOperatorNavigator))
{
HandleComponent(typeConstrain);
}
else if (!entityAccessor.Elements.Contains(typeConstrain))
{
entityAccessor.Elements.Add(typeConstrain);
}
}
else
{
return(base.VisitTypeBinary(expression));
}
return(expression);
}
internal static EntityTypeConstrain CreateTypeConstrain(this IQueryVisitor visitor, Remotion.Linq.Clauses.FromClauseBase sourceExpression)
{
EntityTypeConstrain result = null;
Type entityType = sourceExpression.ItemType.FindEntityType();
if ((entityType != null) && (entityType != typeof(IEntity)))
{
result = visitor.CreateTypeConstrain(entityType, sourceExpression.FromExpression);
}
return(result);
}
/// <summary>Visits an <see cref="EntityExtensions.Is(RomanticWeb.Entities.IEntity,System.Uri)" /> method call.</summary>
/// <param name="expression">Expression to be visited.</param>
/// <returns>Returns visited expression.</returns>
protected virtual System.Linq.Expressions.Expression VisitIsMethodCall(System.Linq.Expressions.MethodCallExpression expression)
{
object objectValue = ((System.Linq.Expressions.ConstantExpression)expression.Arguments[1]).Value;
if (objectValue != null)
{
if (objectValue is Uri)
{
objectValue = new EntityId[] { new EntityId((Uri)objectValue) };
}
else if (objectValue is EntityId)
{
objectValue = new EntityId[] { (EntityId)objectValue };
}
else if ((objectValue is IEnumerable) && (objectValue.GetType().FindItemType() == typeof(Uri)))
{
objectValue = ((IEnumerable)objectValue).Cast <Uri>().Select(item => new EntityId(item));
}
if ((objectValue is IEnumerable) && (objectValue.GetType().FindItemType() == typeof(EntityId)))
{
var types = (IEnumerable <EntityId>)objectValue;
int count = types.Count();
if (count > 0)
{
StrongEntityAccessor entityAccessor = this.GetEntityAccessor(this.GetSourceExpression(expression.Arguments[0]));
if (entityAccessor != null)
{
EntityTypeConstrain constrain = new EntityTypeConstrain(
types.Select(item => item.Uri).First(),
entityAccessor.SourceExpression.FromExpression,
(count > 1 ? types.Skip(1).Select(item => item.Uri).ToArray() : new Uri[0]));
entityAccessor.Elements.Add(constrain);
HandleComponent(constrain);
_lastComponent = constrain;
}
}
return(expression);
}
else
{
return(base.VisitMethodCall(expression));
}
}
else
{
return(base.VisitMethodCall(expression));
}
}
internal static EntityTypeConstrain CreateTypeConstrain(this IQueryVisitor visitor, Type entityType, System.Linq.Expressions.Expression sourceExpression)
{
EntityTypeConstrain result = null;
if (entityType != null)
{
var classMappings = visitor.MappingsRepository.FindMappedClasses(entityType);
if (classMappings == null)
{
throw new UnMappedTypeException(entityType);
}
if (classMappings.Any())
{
Uri primaryTypeUri = classMappings.First();
IEnumerable <Type> inheritedTypes = entityType.GetImplementingTypes();
IList <Uri> inheritedTypeUris = new List <Uri>();
if (inheritedTypes.Any())
{
foreach (Type inheritedType in inheritedTypes)
{
classMappings = visitor.MappingsRepository.FindMappedClasses(inheritedType);
if (classMappings == null)
{
throw new UnMappedTypeException(entityType);
}
if (classMappings.Any())
{
Uri inheritedTypeUri = classMappings.First();
if ((primaryTypeUri.AbsoluteUri != inheritedTypeUri.AbsoluteUri) && (!inheritedTypeUris.Contains(inheritedTypeUri, AbsoluteUriComparer.Default)))
{
inheritedTypeUris.Add(inheritedTypeUri);
}
}
}
}
result = new EntityTypeConstrain(primaryTypeUri, sourceExpression, inheritedTypeUris.ToArray());
}
}
return(result);
}
/// <summary>Visit an entity type constrain.</summary>
/// <param name="entityTypeConstrain">Entity type constrain to be visited.</param>
protected override void VisitEntityTypeConstrain(EntityTypeConstrain entityTypeConstrain)
{
if (entityTypeConstrain.InheritedTypes.Any())
{
if (_entityAccessorToExpand != null)
{
_commandText.Append(Indentation);
VisitComponent(_entityAccessorToExpand.About);
_commandText.AppendFormat(" <{0}> ?{1}_type . ", Rdf.type, (_variableNameOverride.ContainsKey(_entityAccessorToExpand.About) ? _variableNameOverride[_entityAccessorToExpand.About] : _entityAccessorToExpand.About.Name));
_commandText.AppendLine();
}
_commandText.Append("FILTER ( EXISTS { ");
_commandText.AppendLine();
_commandText.Append(Indentation);
_commandText.AppendFormat("?{0} ", _currentEntityAccessor.Peek().About.Name);
VisitComponent(entityTypeConstrain.Predicate);
_commandText.Append(" ");
VisitComponent(entityTypeConstrain.Value);
_commandText.Append(" . } ");
_commandText.AppendLine();
foreach (Literal inheritedType in entityTypeConstrain.InheritedTypes)
{
_commandText.Append("|| EXISTS { ");
_commandText.AppendLine();
_commandText.Append(Indentation);
_commandText.AppendFormat("?{0} ", _currentEntityAccessor.Peek().About.Name);
VisitComponent(entityTypeConstrain.Predicate);
_commandText.Append(" ");
VisitComponent(inheritedType);
_commandText.Append(" . } ");
_commandText.AppendLine();
}
_commandText.Append(") ");
}
else
{
VisitEntityConstrain(entityTypeConstrain);
}
}
/// <summary>Default constructor with nagivated entity type constrain.</summary>
/// <param name="entityTypeConstrain">Nagivated entity typeconstrain.</param>
internal EntityTypeConstrainNavigator(EntityTypeConstrain entityTypeConstrain)
: base(entityTypeConstrain)
{
}
/// <summary>Visit an entity type constrain.</summary> /// <param name="entityTypeConstrain">Entity type constrain to be visited.</param> protected abstract void VisitEntityTypeConstrain(EntityTypeConstrain entityTypeConstrain);
/// <summary>Default constructor with nagivated entity type constrain.</summary>
/// <param name="entityTypeConstrain">Nagivated entity typeconstrain.</param>
internal EntityTypeConstrainNavigator(EntityTypeConstrain entityTypeConstrain)
: base(entityTypeConstrain)
{
}
