protected override Expression VisitMember(MemberExpression member)
{
ISparqlQueryGenerator g = QueryGeneratorTree.CurrentGenerator;
SparqlVariable o = g.VariableGenerator.TryGetObjectVariable(member);
if (o == null)
{
// We have not visited the member before. It might be accessed in an order by clause..
if (g.QueryModel.HasOrdering(member))
{
o = g.VariableGenerator.CreateObjectVariable(member);
g.Where(member, o);
}
else if (member.Type == typeof(bool))
{
ConstantExpression constantExpression = Expression.Constant(true);
g.WhereEqual(member, constantExpression);
}
}
else
{
// We have visited the member before, either in the FromExpression or a SubQueryExpression.
g.Where(member, o);
}
return(member);
}
public override void OnBeforeFromClauseVisited(Expression expression)
{
base.OnBeforeFromClauseVisited(expression);
// TODO: Move into OnBeforeSelectClauseVisited.
if (expression is ConstantExpression)
{
ConstantExpression constantExpression = expression as ConstantExpression;
IQueryable queryable = constantExpression.Value as IQueryable;
if (queryable != null && typeof(Resource).IsAssignableFrom(queryable.ElementType))
{
SparqlVariable s = VariableGenerator.GlobalSubject;
SetSubjectVariable(s);
VariableGenerator.SetSubjectVariable(expression, s);
}
else
{
throw new NotSupportedException(constantExpression.Value.GetType().ToString());
}
}
else
{
// TODO: Create unit test for QuerySourceReferenceExpression, SubQueryExpression
throw new NotImplementedException(expression.GetType().ToString());
}
}
public void SetSubjectVariable(Expression expression, SparqlVariable s)
{
string key = GetKey(expression);
if (!_subjectVariables.ContainsKey(key) || _subjectVariables[key] != s)
{
_subjectVariables[key] = s;
}
}
public static string GetProjectedName(this SparqlVariable variable)
{
if (variable.IsAggregate)
{
return(variable.Aggregate.GetProjectedName(variable.Name));
}
else
{
return(variable.Name);
}
}
public override void OnBeforeFromClauseVisited(Expression expression)
{
SparqlVariable s = null;
SparqlVariable o = null;
if (expression is MemberExpression)
{
QuerySourceReferenceExpression sourceExpression = expression.TryGetQuerySourceReference();
s = VariableGenerator.TryGetSubjectVariable(sourceExpression) ?? VariableGenerator.TryGetObjectVariable(sourceExpression);
o = VariableGenerator.CreateObjectVariable(expression);
// The from clause is parsed first when handling a query. This allows us to detect if the
// query source is a subquery and proceed with implementing it _before_ hanlding its results.
MemberExpression memberExpression = expression as MemberExpression;
if (s.IsGlobal())
{
Type type = memberExpression.Member.DeclaringType;
if (type.IsSubclassOf(typeof(Resource)))
{
WhereResourceOfType(s, type);
}
}
// If the query model has a numeric result operator, we make all the following
// expressions optional in order to also allow to count zero occurences.
if (QueryModel.HasNumericResultOperator())
{
GraphPatternBuilder optionalBuilder = new GraphPatternBuilder(GraphPatternType.Optional);
Child(optionalBuilder);
PatternBuilder = optionalBuilder;
}
}
else
{
s = VariableGenerator.TryGetSubjectVariable(expression);
o = VariableGenerator.TryGetObjectVariable(expression);
}
if (s != null && o != null)
{
// Set the variable name of the query source reference as subject of the current query.
SetSubjectVariable(s, true);
SetObjectVariable(o, true);
}
}
public override void OnSelectClauseVisited(Expression selector)
{
base.OnSelectClauseVisited(selector);
// If we are in the root query generator and have not yet selected the
// subject variable, set it from the given selector.
if (IsRoot && !SelectedVariables.Any())
{
SparqlVariable o = VariableGenerator.TryGetObjectVariable(selector);
if (o != null && !IsSelectedVariable(o))
{
SelectVariable(o);
}
}
}
public Expression VisitOrdering(Ordering ordering, int index)
{
Visit(ordering.Expression);
ISparqlQueryGenerator g = QueryGeneratorTree.CurrentGenerator;
// Either the member or aggregate variable has already been created previously by a SubQuery or a SelectClause..
SparqlVariable o = g.VariableGenerator.TryGetObjectVariable(ordering.Expression);
if (o != null)
{
// In case the query has a LastResultOperator, we invert the direction of the first
// ordering to retrieve the last element of the result set.
// See: SelectQueryGenerator.SetObjectOperator()
if (g.QueryModel.HasResultOperator <LastResultOperator>() && index == 0)
{
if (ordering.OrderingDirection == OrderingDirection.Asc)
{
g.OrderByDescending(o);
}
else
{
g.OrderBy(o);
}
}
else
{
if (ordering.OrderingDirection == OrderingDirection.Asc)
{
g.OrderBy(o);
}
else
{
g.OrderByDescending(o);
}
}
return(ordering.Expression);
}
else
{
throw new ArgumentException(ordering.Expression.ToString());
}
}
private void VisitBinaryQuerySourceReferenceExpression(ExpressionType type, QuerySourceReferenceExpression sourceExpression, ConstantExpression constant)
{
ISparqlQueryGenerator g = QueryGeneratorTree.CurrentGenerator;
SparqlVariable s = g.VariableGenerator.TryGetSubjectVariable(sourceExpression) ?? g.VariableGenerator.GlobalSubject;
switch (type)
{
case ExpressionType.Equal:
g.WhereEqual(s, constant);
break;
case ExpressionType.NotEqual:
g.WhereNotEqual(s, constant);
break;
default:
throw new NotSupportedException(type.ToString());
}
}
private void VisitBinaryMethodCallExpression(ExpressionType type, MethodCallExpression methodCall, ConstantExpression constant)
{
string method = methodCall.Method.Name;
switch (method)
{
case "GetType":
{
ISparqlQueryGenerator g = QueryGeneratorTree.CurrentGenerator;
// Make sure that the method call object (i.e. a MemberExpression) has been visited before.
SparqlVariable o = g.VariableGenerator.TryGetObjectVariable(methodCall.Object);
if (o == null)
{
o = g.VariableGenerator.CreateObjectVariable(methodCall.Object);
Visit(methodCall.Object);
}
// Now create a type constraint on the method call object.
if (type == ExpressionType.NotEqual || (type == ExpressionType.Equal && Trace.Any(e => e.NodeType == ExpressionType.Not)))
{
g.WhereResourceNotOfType(methodCall.Object, (Type)constant.Value);
}
else
{
g.WhereResourceOfType(methodCall.Object, (Type)constant.Value);
}
break;
}
default:
{
throw new NotSupportedException(methodCall.Method.ToString());
}
}
}
public override void Run(SelectableSource source, QueryResultSink resultsink)
{
if (!(query is SelectQuery))
throw new InvalidOperationException("Only SELECT queries are supported by this method (" + query.GetType() + ").");
// Perform the query
SelectQuery squery = (SelectQuery)query;
RdfSourceWrapper sourcewrapper = BindLogic(source);
RdfBindingSet results;
try {
results = squery.execute(sourcewrapper);
} catch (name.levering.ryan.sparql.common.QueryException e) {
throw new QueryExecutionException("Error executing query: " + e.Message, e);
}
// Prepare binding objects
java.util.List vars = results.getVariables();
SparqlVariable[] svars = new SparqlVariable[vars.size()];
SemWebVariable[] vars2 = new SemWebVariable[vars.size()];
for (int i = 0; i < svars.Length; i++) {
svars[i] = (SparqlVariable)vars.get(i);
vars2[i] = new SemWebVariable(svars[i].getName());
}
// Initialize the result sink
resultsink.Init(vars2); // set distinct and ordered
// Set the comments
resultsink.AddComments(queryString + "\n");
resultsink.AddComments(sourcewrapper.GetLog());
// Iterate the bindings
java.util.Iterator iter = results.iterator();
long ctr = -1, ctr2 = 0;
while (iter.hasNext()) {
RdfBindingRow row = (RdfBindingRow)iter.next();
// Since SPARQL processing may be lazy-delayed,
// add any new comments that might have been logged.
resultsink.AddComments(sourcewrapper.GetLog());
ctr++;
if (ctr < ReturnStart && ReturnStart != -1) continue;
Resource[] bindings = new Resource[vars2.Length];
for (int i = 0; i < bindings.Length; i++) {
Resource r = sourcewrapper.ToResource(row.getValue(svars[i]));
r = sourcewrapper.Persist(r);
bindings[i] = r;
}
resultsink.AddComments(sourcewrapper.GetLog());
resultsink.Add(new VariableBindings(vars2, bindings));
ctr2++;
if (ctr2 >= ReturnLimit && ReturnLimit != -1) break;
}
resultsink.AddComments(sourcewrapper.GetLog());
// Close the result sink.
resultsink.Finished();
}
