override public void Print(ISparqlPrinter p)
{
IVariable asVar = getAs();
if (asVar != null)
{
p.print("(");
}
INode aggType = this.getObject(RDF.PropertyType);
String aggName = Aggregations.getName(aggType);
p.printKeyword(aggName);
p.print("(");
if (isDistinct())
{
p.print("DISTINCT ");
}
Triple exprS = this.getProperty(SP.PropertyExpression);
if (exprS != null && !(exprS.Object is ILiteralNode))
{
IResource r = Resource.Get(exprS.Object, getModel());
IResource expr = SPINFactory.asExpression(r);
if (expr is IPrintable)
{
((IPrintable)expr).Print(p);
}
else
{
p.printURIResource(r);
}
}
else
{
p.print("*");
}
String separator = getString(SP.PropertySeparator);
if (separator != null)
{
p.print("; ");
p.printKeyword("SEPARATOR");
p.print("=''"); //"='" + DatasetUtil.escapeString(separator) + "'");
}
if (asVar != null)
{
p.print(") ");
p.printKeyword("AS");
p.print(" ");
p.print(asVar.ToString());
}
p.print(")");
}
public List <IResource> getResultVariables()
{
List <IResource> results = new List <IResource>();
foreach (IResource node in getList(SP.PropertyResultVariables))
{
results.Add(SPINFactory.asExpression(node));
}
return(results);
}
public ICommand getBody()
{
IResource node = null; //ModulesUtil.getBody(this);
if (node is IResource)
{
return(SPINFactory.asCommand(node));
}
else
{
return(null);
}
}
public IVariable getAs()
{
IResource node = this.getObject(SP.PropertyAs);
if (node != null)
{
return(SPINFactory.asVariable(node));
}
else
{
return(null);
}
}
public IQuery getQuery()
{
IResource r = getResource(SP.PropertyQuery);
if (r != null)
{
return(SPINFactory.asQuery(r));
}
else
{
return(null);
}
}
private void printProjectExpression(ISparqlPrinter p, IVariable var)
{
p.print("((");
IResource expr = var.getResource(SP.PropertyExpression);
IPrintable expression = (IPrintable)SPINFactory.asExpression(expr);
expression.Print(p);
p.print(") ");
p.printKeyword("AS");
p.print(" ");
p.print(var.ToString());
p.print(")");
}
public IResource getExpression()
{
IResource expr = getObject(SP.PropertyExpression);
if (expr != null)
{
return(SPINFactory.asExpression(expr));
}
else
{
return(null);
}
}
public List <IElement> getElements(INode predicate)
{
List <IElement> results = new List <IElement>();
foreach (IResource node in getList(predicate))
{
if (node != null && !node.isLiteral())
{
results.Add(SPINFactory.asElement(node));
}
}
return(results);
}
public IElementList getWhere()
{
IResource whereS = this.getResource(SP.PropertyWhere);
if (whereS != null)
{
return((IElementList)SPINFactory.asElement(whereS));
}
else
{
return(null);
}
}
public IVariable getServiceVariable()
{
IResource s = getResource(SP.PropertyServiceURI);
if (s != null)
{
IVariable variable = SPINFactory.asVariable(s);
if (variable != null)
{
return(variable);
}
}
return(null);
}
public Uri getServiceURI()
{
IResource s = getResource(SP.PropertyServiceURI);
if (s != null && s.isUri())
{
IVariable variable = SPINFactory.asVariable(s);
if (variable == null)
{
return(s.Uri);
}
}
return(null);
}
public List <IResource> getArguments()
{
Dictionary <IResource, IResource> values = getArgumentsMap();
IResource[] ps = getArgumentProperties(values);
List <IResource> results = new List <IResource>(ps.Length);
foreach (IResource key in ps)
{
IResource node = values[key];
results.Add(SPINFactory.asExpression(node));
}
return(results);
}
public IElementList getWhere()
{
IResource whereS = getResource(SP.PropertyWhere);
if (whereS != null)
{
IElement element = SPINFactory.asElement(whereS);
return((IElementList)element);
}
else
{
return(null);
}
}
public List <IResource> getResultNodes()
{
List <IResource> results = new List <IResource>();
foreach (IResource node in getList(SP.PropertyResultNodes))
{
IVariable variable = SPINFactory.asVariable(node);
if (variable != null)
{
results.Add(variable);
}
else if (node.isUri())
{
results.Add(node);
}
}
return(results);
}
public new List <IElement> getElements()
{
List <IElement> results = new List <IElement>();
IEnumerator <IResource> it = AsList().GetEnumerator();
while (it.MoveNext())
{
IResource node = it.Current;
if (!(node.isLiteral()))
{
IElement element = SPINFactory.asElement(node);
if (element != null)
{
results.Add(element);
}
}
}
return(results);
}
private void printOrderByExpression(ISparqlPrinter sb, IResource node)
{
// TODO check for real test
if (node is INode)
{
IResource resource = (IResource)node;
IFunctionCall call = SPINFactory.asFunctionCall(resource);
if (call != null)
{
sb.print("(");
ISparqlPrinter pc = sb.clone();
pc.setNested(true);
call.Print(pc);
sb.print(")");
return;
}
}
printNestedExpressionString(sb, node, true);
}
protected IResource getRDFNodeOrVariable(INode predicate)
{
IResource node = getResource(predicate);
if (node != null)
{
IVariable var = SPINFactory.asVariable(node);
if (var != null)
{
return(var);
}
else
{
return(node);
}
}
else
{
return(null);
}
}
public IResource getNameNode()
{
IResource r = getObject(SP.PropertyGraphNameNode);
if (r != null)
{
IVariable variable = SPINFactory.asVariable(r);
if (variable != null)
{
return(variable);
}
else
{
return(r);
}
}
else
{
return(null);
}
}
public static void printVarOrResource(ISparqlPrinter p, IResource resource)
{
IVariable variable = SPINFactory.asVariable(resource);
if (variable != null)
{
variable.Print(p);
}
else if (resource.isUri())
{
p.printURIResource(resource);
}
else if (p.isNamedBNodeMode())
{
// TODO is this correct ?
p.print(resource.ToString());
}
else
{
p.print("[]");
}
}
public ICommand getBody()
{
IResource node = null;
return(SPINFactory.asCommand(node));
}
public bool isAbstract()
{
return(SPINFactory.isAbstract(this));
}
