private void ToSparqlString(SparqlSettings settings, StringBuilder dest, string indentation)
{
foreach (var triple in this.triples)
{
dest.AppendLine(indentation + triple.ToSparqlString(settings));
}
}
protected override void ToSparqlString(SparqlSettings settings, StringBuilder dest, string indentation)
{
dest.AppendLine(indentation + "ASK");
dest.AppendLine(indentation + "WHERE {");
dest.Append(Graph.ToSparqlString(settings, new HashSet <Variable>(ProjectedVariables), indentation + settings.BlockIndentation));
dest.AppendLine(indentation + "}");
}
public string ToSparqlString(SparqlSettings settings, bool includePrefixes, string indentation)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
var result = new StringBuilder();
var queryBody = new StringBuilder();
ToSparqlString(settings, queryBody, indentation);
if (includePrefixes && settings.PrefixingService.KnownPrefixes.Any())
{
result.AppendLine(settings.PrefixingService.ToSparqlString(settings));
}
result.Append(queryBody.ToString());
if (groupBy.Count > 0)
{
var groupByClause = new StringBuilder("GROUP BY ");
foreach (var gc in groupBy)
{
groupByClause.Append(" ");
groupByClause.Append(gc.ToSparqlString(settings));
}
result.AppendLine(groupByClause.ToString());
}
if (groupRestriction != null)
{
result.AppendLine("HAVING(" + groupRestriction.ToSparqlString(settings) + ")");
}
if (orderBy.Count > 0)
{
var orderByClause = new StringBuilder("ORDER BY");
foreach (var oc in orderBy)
{
orderByClause.Append(" ");
orderByClause.Append(oc.ToSparqlString(settings));
}
result.AppendLine(orderByClause.ToString());
}
if (restrictions.HasOffset)
{
result.AppendLine(indentation + "OFFSET " + restrictions.Offset.ToString());
}
if (restrictions.HasLimit)
{
result.AppendLine(indentation + "LIMIT " + restrictions.Limit.ToString());
}
return(result.ToString());
}
public string ToSparqlString(SparqlSettings settings, ISet <Variable> exportedVariables, string indentation)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
var result = new StringBuilder();
ToSparqlString(settings, result, exportedVariables, new HashSet <Variable>(), indentation);
return(result.ToString());
}
public string ToSparqlString(SparqlSettings settings, string indentation)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
var result = new StringBuilder();
ToSparqlString(settings, result, indentation);
return(result.ToString());
}
private static void AlternativesToSparqlString(QueryGraph[] alternatives, SparqlSettings settings, StringBuilder dest, ISet <Variable> exportedVariables, ISet <Variable> subqueriedVars, string indentation)
{
var nextSubqueriedVars = new HashSet <Variable>();
for (int j = 0; j < alternatives.Length; j++)
{
string subgraphBodyIndentation;
var currentSubqueriedVars = new HashSet <Variable>(subqueriedVars);
if (j > 0)
{
dest.AppendLine(" UNION {");
subgraphBodyIndentation = indentation + settings.BlockIndentation;
}
else
{
if (alternatives.Length > 1)
{
dest.AppendLine(indentation + "{");
subgraphBodyIndentation = indentation + settings.BlockIndentation;
}
else
{
subgraphBodyIndentation = indentation;
}
}
var g = alternatives[j];
g.ToSparqlString(settings, dest, exportedVariables, currentSubqueriedVars, subgraphBodyIndentation);
if (alternatives.Length > 1)
{
dest.Append(indentation + "}");
}
nextSubqueriedVars.UnionWith(currentSubqueriedVars);
}
if (alternatives.Length > 1)
{
dest.AppendLine(".");
}
subqueriedVars.UnionWith(nextSubqueriedVars);
}
protected override void ToSparqlString(SparqlSettings settings, StringBuilder dest, string indentation)
{
dest.Append(indentation + "SELECT");
if (distinctResults)
{
dest.Append(" DISTINCT");
}
foreach (var column in resultColumns)
{
dest.Append(" " + column.ToSparqlString(settings));
}
dest.AppendLine();
dest.AppendLine(indentation + "WHERE {");
dest.Append(Graph.ToSparqlString(settings, new HashSet <Variable>(ProjectedVariables), indentation + settings.BlockIndentation));
dest.AppendLine(indentation + "}");
}
private void ToSparqlString(SparqlSettings settings, StringBuilder dest, ISet <Variable> exportedVariables, ISet <Variable> subqueriedVars, string indentation)
{
QueryGraph g = new QueryGraph();
g.UseSameData(this);
var restrictedVars = g.LocalNamedThings.OfType <Variable>().Distinct().Where(v => v.IsRestricted).Where(v => !subqueriedVars.Contains(v)).ToArray();
switch (restrictedVars.Length)
{
case 0:
break;
case 1:
{
var variable = restrictedVars[0];
var varR = variable.Restrictions;
variable.Restrictions = null;
try {
var subQuery = new SelectQuery();
subQuery.Restrictions.CopyFrom(varR);
subQuery.Graph.UseSameData(this);
var newOptionalAlternativeIndices = new List <int>();
for (int i = 0; i < subQuery.Graph.alternativeGraphs.Count; i++)
{
if (subQuery.Graph.optionalAlternativeIndices.Contains(i))
{
var possiblyObsoleteGraphs = subQuery.Graph.alternativeGraphs[i];
var namedThingsInPossiblyObsoleteGraphs = new HashSet <NamedThing>();
foreach (var pog in possiblyObsoleteGraphs)
{
foreach (var nt in pog.AllNamedThings)
{
namedThingsInPossiblyObsoleteGraphs.Add(nt);
}
}
var namedThingsNotInPossiblyObsoleteGraphs = new HashSet <NamedThing>();
foreach (var stmt in subQuery.Graph.statements)
{
foreach (var nt in stmt.References)
{
namedThingsNotInPossiblyObsoleteGraphs.Add(nt);
}
}
foreach (var otherAltGraphs in subQuery.Graph.alternativeGraphs)
{
if (otherAltGraphs != possiblyObsoleteGraphs)
{
foreach (var otherAltGraph in otherAltGraphs)
{
foreach (var nt in otherAltGraph.AllNamedThings)
{
namedThingsNotInPossiblyObsoleteGraphs.Add(nt);
}
}
}
}
namedThingsInPossiblyObsoleteGraphs.IntersectWith(namedThingsNotInPossiblyObsoleteGraphs);
if (namedThingsInPossiblyObsoleteGraphs.Count < 2)
{
subQuery.Graph.alternativeGraphs.RemoveAt(i);
i--;
}
else
{
newOptionalAlternativeIndices.Add(i);
}
}
}
subQuery.Graph.optionalAlternativeIndices.Clear();
foreach (int newIdx in newOptionalAlternativeIndices)
{
subQuery.Graph.optionalAlternativeIndices.Add(newIdx);
}
subQuery.ResultColumns.Add(new ColumnExpressions.VariableColumn(variable));
dest.AppendLine(indentation + "{");
dest.Append(subQuery.ToSparqlString(settings, false, indentation + settings.BlockIndentation));
dest.AppendLine(indentation + "}.");
}
finally {
variable.Restrictions = varR;
}
subqueriedVars.Add(variable);
var ignore = subqueriedVars.ToArray();
for (int i = g.statements.Count - 1; i >= 0; i--)
{
if (!g.ReachableNamedThings(g.statements[i], ignore).OfType <Variable>().Any(exportedVariables.Contains))
{
g.statements.RemoveAt(i);
}
}
}
break;
default:
throw new InvalidOperationException(string.Format(System.Globalization.CultureInfo.InvariantCulture,
"Only one variable can be restricted, but the graph contains {0}.",
restrictedVars.Length));
}
var filterConjunction = new List <Expressions.Expression>();
foreach (var stmt in g.statements)
{
var f = stmt as Filters.ExpressionFilter;
if (f == null)
{
dest.AppendLine(indentation + stmt.ToSparqlString(settings));
}
else
{
filterConjunction.Add(f.Expression);
}
}
if (filterConjunction.Count > 0)
{
var f = new Filters.ExpressionFilter(new Expressions.AndExpression(filterConjunction));
dest.AppendLine(indentation + f.ToSparqlString(settings));
}
// simplify subgraphs to combined filter expressions, where possible
var altGraphs = new List <Tuple <QueryGraph[], Expressions.Expression[], bool> >();
var altFilters = new List <Expressions.Expression>();
for (int i = 0; i < g.alternativeGraphs.Count; i++)
{
var alternatives = g.alternativeGraphs[i].Where(gr => !gr.IsEmpty).ToArray();
if (alternatives.Length > 0)
{
bool isOptional = g.optionalAlternativeIndices.Contains(i);
var graphs = new List <QueryGraph>();
var filterGraphs = new List <QueryGraph>();
foreach (var alt in alternatives)
{
if (alt.ContainsOnlyExpressionFilters)
{
filterGraphs.Add(alt);
}
else
{
graphs.Add(alt);
}
}
var filters = filterGraphs.Select(fg => fg.AsFilterExpression());
if (graphs.Count > 0)
{
altGraphs.Add(new Tuple <QueryGraph[], Expressions.Expression[], bool>(graphs.ToArray(), filters.ToArray(), isOptional));
}
else
{
if (!isOptional)
{
altFilters.Add(new Expressions.OrExpression(filters));
}
}
}
}
// output subgraph contents
foreach (var ag in altGraphs)
{
QueryGraph[] alternatives;
if (ag.Item2.Length > 0)
{
var qg = new QueryGraph();
qg.Add(new Filters.ExpressionFilter(new Expressions.OrExpression(ag.Item2)));
alternatives = ag.Item1.Concat(new QueryGraph[] { qg }).ToArray();
}
else
{
alternatives = ag.Item1;
}
if (ag.Item3)
{
dest.AppendLine(indentation + "OPTIONAL {");
AlternativesToSparqlString(alternatives, settings, dest, exportedVariables, subqueriedVars, indentation + settings.BlockIndentation);
dest.AppendLine(indentation + "}.");
}
else
{
AlternativesToSparqlString(alternatives, settings, dest, exportedVariables, subqueriedVars, indentation);
}
}
if (altFilters.Count > 0)
{
var f = new Filters.ExpressionFilter(new Expressions.AndExpression(altFilters));
dest.AppendLine(indentation + f.ToSparqlString(settings));
}
}
public string ToSparqlString(SparqlSettings settings, ISet <Variable> exportedVariables)
{
return(ToSparqlString(settings, exportedVariables, ""));
}
public string ToSparqlString(SparqlSettings settings)
{
return(ToSparqlString(settings, ""));
}
public string ToSparqlString(SparqlSettings settings, string indentation)
{
return(ToSparqlString(settings, true, indentation));
}
public string ToSparqlString(SparqlSettings settings, bool includePrefixes)
{
return(ToSparqlString(settings, includePrefixes, ""));
}
protected abstract void ToSparqlString(SparqlSettings settings, StringBuilder dest, string indentation);
