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);