public override void VisitJoinClause(Remotion.Linq.Clauses.JoinClause joinClause, QueryModel queryModel, int index)
{
_isInstanceQuery = false;
_queryBuilder.AddFromPart(joinClause);
var inner = SparqlGeneratorWhereExpressionTreeVisitor.GetSparqlExpression(joinClause.InnerKeySelector, _queryBuilder);
var outer = SparqlGeneratorWhereExpressionTreeVisitor.GetSparqlExpression(joinClause.OuterKeySelector, _queryBuilder);
if (inner is SelectVariableNameExpression && outer is SelectVariableNameExpression)
{
var innerVar = inner as SelectVariableNameExpression;
var outerVar = outer as SelectVariableNameExpression;
if (innerVar.BindingType == VariableBindingType.Literal ||
outerVar.BindingType == VariableBindingType.Literal)
{
_queryBuilder.AddFilterExpression(string.Format("(?{0}=?{1})", innerVar.Name, outerVar.Name));
}
else
{
_queryBuilder.AddFilterExpression(string.Format("(sameTerm(?{0}, ?{1}))", innerVar.Name, outerVar.Name));
}
}
else
{
throw new NotSupportedException(
String.Format("No support for joining expressions of type {0} and {1}", inner.NodeType,
outer.NodeType));
}
}
public static Expression GetSparqlExpression(Expression expression, SparqlQueryBuilder queryBuilder)
{
var visitor = new SparqlGeneratorWhereExpressionTreeVisitor(queryBuilder);
var returnedExpression = visitor.VisitExpression(expression);
if (returnedExpression is SelectVariableNameExpression && expression.Type.Equals(typeof(bool)))
{
var svn = (SelectVariableNameExpression)returnedExpression;
// Single boolean member expression requires a special case addition to the filter
queryBuilder.AddFilterExpression("(?" + svn.Name + " = true)");
}
queryBuilder.AddFilterExpression(visitor.FilterExpression);
return(returnedExpression);
}
public static Expression GetSparqlExpression(Expression expression, SparqlQueryBuilder queryBuilder, bool filterOptimizationEnabled)
{
var canOptimizeFilter = filterOptimizationEnabled && CanOptimizeFilter(expression, queryBuilder);
var visitor = new SparqlGeneratorWhereExpressionTreeVisitor(queryBuilder, canOptimizeFilter, expression.Type == typeof(bool));
var returnedExpression = visitor.VisitExpression(expression);
var svn = returnedExpression as SelectVariableNameExpression;
if (svn != null && expression.Type == typeof(bool))
{
// Single boolean member expression requires a special case addition to the filter
queryBuilder.AddFilterExpression("(?" + svn.Name + " = true)");
}
queryBuilder.AddFilterExpression(visitor.FilterExpression);
return(returnedExpression);
}
protected bool HandleAddressOrIdEquals(Expression left, Expression right)
{
string itemName = null;
PropertyHint propertyHint = GetPropertyHint(left);
if (propertyHint == null ||
!(propertyHint.MappingType == PropertyMappingType.Address ||
propertyHint.MappingType == PropertyMappingType.Id))
{
return(false);
}
if (left is SelectVariableNameExpression)
{
itemName = (left as SelectVariableNameExpression).Name;
}
else if (left is MemberExpression)
{
var m = left as MemberExpression;
if (m.Expression is QuerySourceReferenceExpression)
{
itemName = (m.Expression as QuerySourceReferenceExpression).ReferencedQuerySource.ItemName;
}
else
{
var visitResult = VisitMemberExpression(m);
if (visitResult is SelectVariableNameExpression)
{
itemName = (visitResult as SelectVariableNameExpression).Name;
}
}
}
if (itemName == null)
{
return(false);
}
var constantExpression = right as ConstantExpression;
if (constantExpression == null)
{
return(false);
}
string address = null;
if (propertyHint.MappingType == PropertyMappingType.Id)
{
address = MakeResourceAddress(GetPropertyInfo(left), constantExpression.Value.ToString());
}
else if (propertyHint.MappingType == PropertyMappingType.Address)
{
address = constantExpression.Value.ToString();
}
if (address != null)
{
if (QueryBuilder.SelectVariables.Contains(itemName))
{
QueryBuilder.AddFilterExpression(String.Format("(?{0}=<{1}>)", itemName, address));
}
else
{
QueryBuilder.ConvertVariableToConstantUri(itemName, address);
}
return(true);
}
return(false);
}
