/// <summary> /// Executes a Graph Pattern style query against the Source /// </summary> /// <param name="graph">Graph Pattern</param> /// <param name="options">Query Options</param> /// <param name="sink">Results Sink</param> /// <remarks> /// <para> /// This is implemented by transforming the Graph Pattern which is a set of SemWeb Statement templates into a SPARQL Algebra BGP. The resulting algebra is then executed using the Leviathan engine and the results converted into VariableBindings for SemWeb /// </para> /// <para> /// The only Query Option that is supported is the Limit option /// </para> /// </remarks> public void Query(Statement[] graph, SW.Query.QueryOptions options, SW.Query.QueryResultSink sink) { ISparqlAlgebra algebra = this.ToAlgebra(graph); SparqlEvaluationContext context = new SparqlEvaluationContext(null, new InMemoryDataset(this._store)); BaseMultiset results = context.Evaluate(algebra);//algebra.Evaluate(context); sink.Init(results.Variables.Select(v => new Variable(v)).ToArray()); if (results.Count > 0) { int c = 0; foreach (Set s in results.Sets) { //Apply Limit if applicable if (options.Limit > 0 && c >= options.Limit) { sink.Finished(); return; } //Convert the Set to VariableBindings for SemWeb Variable[] vars = s.Variables.Select(v => new Variable(v)).ToArray(); Resource[] resources = s.Variables.Select(v => SemWebConverter.ToSemWeb(s[v], this.GetMapping(s[v].Graph))).ToArray(); SW.Query.VariableBindings bindings = new SW.Query.VariableBindings(vars, resources); //Keep adding results until the sink tells us to stop if (!sink.Add(bindings)) { sink.Finished(); return; } c++; } sink.Finished(); } else { sink.Finished(); } }
public void Query(Statement[] graph, SemWeb.Query.QueryOptions options, SemWeb.Query.QueryResultSink sink) { if (graph.Length == 0) throw new ArgumentException("graph array must have at least one element"); // This method translates the graph pattern into a single SQL statement. Each graph statement // corresponds to a new use of the _statements table in the FROM clause. For instance: // ?a foaf:knows ?b . ?b foaf:name ?c . // translates to // SELECT // g0.subject, v0.value, // g0.object, v1.value, // g1.object, v2.value, v2lit.value, v2lit.language, v2lit.datatype // FROM // db_tables as g0 LEFT JOIN db_entities AS v0 ON g0.subject=v0.id LEFT JOIN db_entities AS v1 ON g0.object=v1.id, // db_tables as g1 LEFT JOIN db_entities AS v2 ON g1.object=v2.id LEFT JOIN db_literals AS v2lit ON g1.object=v2lit.id // WHERE // g0.predicate = <the id of the foaf:knows entity> AND // g1.predicate = <the id of the foaf:name entity> AND // g0.object = g1.subject // // If any variable column is an *undistinguished* variable --- which is to say that the caller // says it is a variable, but is not concerned with its values --- then we want to apply // DISTINCT to the SELECT statement. This is because while in the normal case we may get // duplicates, we expect that to not occur more than the caller expects, but in the latter // case there will often be many duplicates. Consider the SPARQL query: // SELECT DISTINCT ?p WHERE { ?s ?p ?o } // to get a list of predicates in the dataset, which corresponds to the graph query // ?s ?p ?o // where only ?p is distinguished. // This normally translates to: // SELECT // g0.predicate, v0.value, // FROM // db_tables as g0 LEFT JOIN db_entities AS v0 ON g0.predicate=v0.id // which of course is going to return a result for every triple in the database. // So we add DISTINCT to beginning ("SELECT DISTINCT"). // Unfortunately, MySQL performs the DISTINCT bit only after the LEFT JOINs (which makes sense normally). // That means that MySQL is repeatedly fetching the URI values of the predicates and checking // if a new unique row has been created, and this is very slow. What we want is to get the distinct // IDs of the predicates first, and then get their URIs. // I first tried implementing this with VIEWs, but it didn't always speed things up, and it was // difficult to manage the creation and deletion of VIEWs. // So instead, in this case, we do the query in two parts. First we get the IDs of the variables, // and then we get their URIs. options = options.Clone(); // because we modify the knownvalues array // Order the variables mentioned in the graph. Variable[] varOrder; ResSet distinguishedVars = null; bool useDistinct = false; { if (options.DistinguishedVariables != null) distinguishedVars = new ResSet(options.DistinguishedVariables); else distinguishedVars = new ResSet(); Hashtable seenvars = new Hashtable(); foreach (Statement filter in graph) { for (int i = 0; i < 4; i++) { Resource r = filter.GetComponent(i); if (r == null) throw new ArgumentException("The graph may not have any null components. Use Variables instead."); if (r is Variable) { if (options.DistinguishedVariables != null) { if (!distinguishedVars.Contains(r)) { // If we are omitting a column from the results because it is // not distinguished, and it's not a meta column, then we'll // use DISTINCT. if (i != 3) useDistinct = true; // Don't put this into seenvars. continue; } } else { distinguishedVars.Add(r); // all variables are distinguished } seenvars[r] = r; } } } varOrder = new Variable[seenvars.Count]; int ctr = 0; foreach (Variable v in seenvars.Keys) varOrder[ctr++] = v; } // Set the initial bindings to the result sink sink.Init(varOrder); Hashtable varLitFilters = new Hashtable(); // Prefetch the IDs of all resources mentioned in the graph and in variable known values. // For Resources in the graph that are not in the store, the query immediately fails. { ArrayList graphResources = new ArrayList(); foreach (Statement s in graph) { for (int i = 0; i < 4; i++) { Resource r = s.GetComponent(i); if (!(r is BNode)) // definitely exclude variables, but bnodes are useless too graphResources.Add(r); } } if (options.VariableKnownValues != null) foreach (ICollection values in options.VariableKnownValues.Values) graphResources.AddRange(values); PrefetchResourceIds(graphResources); // Check resources in graph and fail fast if any is not in the store. foreach (Statement s in graph) { for (int i = 0; i < 4; i++) { Resource r = s.GetComponent(i); if (r is Variable) continue; if ((object)r != (object)Statement.DefaultMeta && GetResourceKey(r) == null) { sink.AddComments("Resource " + r + " is not contained in the data model."); sink.Finished(); return; } } } // Check variable known values and remove any values not in the store. // Don't do any fail-fasting here because there might be entries in this // dictionary that aren't even used in this query (yes, poor design). // We check later anyway. if (options.VariableKnownValues != null) { #if !DOTNET2 foreach (Variable v in new ArrayList(options.VariableKnownValues.Keys)) { #else foreach (Variable v in new System.Collections.Generic.List<Variable>(options.VariableKnownValues.Keys)) { #endif #if !DOTNET2 ArrayList newvalues = new ArrayList(); #else System.Collections.Generic.List<Resource> newvalues = new System.Collections.Generic.List<Resource>(); #endif foreach (Resource r in (ICollection)options.VariableKnownValues[v]) { if ((object)r == (object)Statement.DefaultMeta || GetResourceKey(r) != null) newvalues.Add(r); } options.VariableKnownValues[v] = newvalues; } } } // Helpers string[] colnames = { "subject", "predicate", "object", "meta" }; // we initialize these things while locked, but use them after we release the lock ArrayList results = new ArrayList(); Hashtable resourceCache = new Hashtable(); // map resource ID to Resource instances // We can either include JOINs to the entities and literals table for every variable // in the query, or we can delay fetching that information to separate SELECTs // after the main part of the query is done. If we are including DISTINCT, then we // don't want to do the JOINs because the JOINs happen before the DISTINCT and will // be unnecessarily repeated. Also if the query has many variables, say more than 6, // then it may slow down query planning (the MySQL optimizer) to include them all in // one query. bool joinEntitiesAndLiterals = true; if (useDistinct) joinEntitiesAndLiterals = false; if (varOrder.Length > 6) joinEntitiesAndLiterals = false; // Lock the store and make sure we are initialized and any pending add's have been committed. lock (syncroot) { Init(); RunAddBuffer(); // Compile the SQL statement. Hashtable varRef = new Hashtable(); // the column name representing the variable, as in "g0.subject" Hashtable varRef2 = new Hashtable(); // the index of the variable, for accessing the entities and literals joined tables Hashtable varSelectedLiteral = new Hashtable(); // whether the variable is in a literal column and a LEFT JOIN for the literals table was used for it Hashtable varCouldBeLiteral = new Hashtable(); // whether the variable is only in literal columns Hashtable varSelectedEntity = new Hashtable(); // whether a LEFT JOIN for the entities table was used for a variable StringBuilder fromClause = new StringBuilder(); StringBuilder whereClause = new StringBuilder(); for (int f = 0; f < graph.Length; f++) { // For each filter, we select FROM the statements table with an // alias: q#, where # is the filter's index. if (f > 0) fromClause.Append(','); fromClause.Append(table); fromClause.Append("_statements AS g"); fromClause.Append(f); // For each component of the filter... for (int i = 0; i < 4; i++) { // This has the name of the column corresponding to this variable (i.e. "g1.predicate"). string myRef = "g" + f + "." + colnames[i]; Variable v = graph[f].GetComponent(i) as Variable; if (v != null) { // If the component is a variable, then if this is // the first time we're seeing the variable, we don't // add any restrictions to the WHERE clause, but we // note the variable's "name" in the world of SQL // so we can refer back to it later and we add the // necessary FROM tables so we can get its URI and // literal value if it is a reported variable. // If this isn't the first time, then we add a WHERE restriction so // that the proper columns here and in a previous // filter are forced to have the same value. if (!varRef.ContainsKey(v)) { // This is the first time we are seeing this variable. // Record the column name for the variable (i.e. g0.subject). varRef[v] = myRef; // Record an index for the variable (i.e. 0, 1, 2, ...) int vIndex = varRef.Count; varRef2[v] = vIndex; varCouldBeLiteral[v] = (i == 2); // LEFT JOIN the entities table for this variable to get its URI // only if it is a distinguished variable and we are not using DISTINCT. varSelectedEntity[v] = false; if (joinEntitiesAndLiterals && distinguishedVars.Contains(v)) { varSelectedEntity[v] = true; // Record that we are selecting the entities table for this variable. fromClause.Append(" LEFT JOIN "); fromClause.Append(table); fromClause.Append("_entities AS vent"); fromClause.Append(vIndex); fromClause.Append(" ON "); fromClause.Append(myRef); fromClause.Append("="); fromClause.Append("vent" + vIndex + ".id "); } // LEFT JOIN the literals table for this variable: // if it is in an object position // to get its value, language, and datatype only if it is a distinguished variable and we are not using DISTINCT // to apply a literal value filter (which will be done later) #if !DOTNET2 bool hasLitFilter = (options.VariableLiteralFilters != null && options.VariableLiteralFilters[v] != null); #else bool hasLitFilter = (options.VariableLiteralFilters != null && options.VariableLiteralFilters.ContainsKey(v)); #endif varSelectedLiteral[v] = false; if (i == 2 && ((joinEntitiesAndLiterals && distinguishedVars.Contains(v)) || hasLitFilter)) { varSelectedLiteral[v] = true; // Record that we are selecting the literals table for this variable. fromClause.Append(" LEFT JOIN "); fromClause.Append(table); fromClause.Append("_literals AS vlit"); fromClause.Append(vIndex); fromClause.Append(" ON "); fromClause.Append(myRef); fromClause.Append("="); fromClause.Append("vlit" + vIndex + ".id "); } // If this variable has known values, then we must restrict what values can appear using a WHERE clause. if (options.VariableKnownValues != null) { ICollection values = null; #if DOTNET2 if (options.VariableKnownValues.ContainsKey(v)) #endif values = (ICollection)options.VariableKnownValues[v]; if (values != null) { if (values.Count == 0) { sink.Finished(); return; } Resource r = ToMultiRes((Resource[])new ArrayList(values).ToArray(typeof(Resource))); if (!WhereItem(myRef, r, whereClause, whereClause.Length != 0)) { // We know at this point that the query cannot return any results. sink.Finished(); return; } } } } else { // We've seen this variable before, so link up the column in this // statement to the corresponding column in a previous (or this) statement. if (whereClause.Length != 0) whereClause.Append(" AND "); whereClause.Append('('); whereClause.Append((string)varRef[v]); whereClause.Append('='); whereClause.Append(myRef); whereClause.Append(')'); if (i != 2) varCouldBeLiteral[v] = false; } } else { // If this is not a variable, then it is a resource. // Append something into the WHERE clause to make sure this component gets // the right fixed value. If we cannot add the component to the WHERE clause // because the fixed value isn't even known in the data source, we can stop early. if (!WhereItem(myRef, graph[f].GetComponent(i), whereClause, whereClause.Length != 0)) { // We know at this point that the query cannot return any results. sink.Finished(); return; } } } } // graph filter 0...n // Add literal filters to the WHERE clause foreach (Variable v in varOrder) { // Is there a literal value filter? if (options.VariableLiteralFilters == null) continue; #if !DOTNET2 if (options.VariableLiteralFilters[v] == null) continue; #else if (!options.VariableLiteralFilters.ContainsKey(v)) continue; #endif // If this variable was not used in a literal column, then // we cannot filter its value. Really, it will never be a literal. if (!(bool)varSelectedLiteral[v]) continue; foreach (LiteralFilter filter in (ICollection)options.VariableLiteralFilters[v]) { string s = FilterToSQL(filter, "vlit" + (int)varRef2[v] + ".value"); if (s == null) continue; if (whereClause.Length != 0) whereClause.Append(" AND "); whereClause.Append(s); } } // Put the parts of the SQL statement together StringBuilder cmd = new StringBuilder(); cmd.Append("SELECT "); if (useDistinct) cmd.Append("DISTINCT "); if (!SupportsLimitClause && options.Limit > 0) { cmd.Append("TOP "); cmd.Append(options.Limit); cmd.Append(' '); } // Add all of the distinguished variables to the SELECT clause. bool firstvar = true; foreach (Variable v in varOrder) { if (!firstvar) cmd.Append(','); firstvar = false; cmd.Append((string)varRef[v]); if ((bool)varSelectedEntity[v]) { cmd.Append(", vent" + (int)varRef2[v] + ".value"); } if ((bool)varSelectedLiteral[v]) { cmd.Append(", vlit" + (int)varRef2[v] + ".value"); cmd.Append(", vlit" + (int)varRef2[v] + ".language"); cmd.Append(", vlit" + (int)varRef2[v] + ".datatype"); } } cmd.Append(" FROM "); cmd.Append(fromClause.ToString()); if (whereClause.Length > 0) cmd.Append(" WHERE "); cmd.Append(whereClause.ToString()); if (SupportsLimitClause && options.Limit > 0) { cmd.Append(" LIMIT "); cmd.Append(options.Limit); } cmd.Append(';'); if (Debug) { string cmd2 = cmd.ToString(); //if (cmd2.Length > 80) cmd2 = cmd2.Substring(0, 80); Console.Error.WriteLine(cmd2); } // Execute the query. // When we use DISTINCT and don't select URI and literal values at first, // we have to select them after. And since we can't maintain two IDataReaders // simultaneously, that means we have to pull the first set of results into // memory. It would be nice to not have to do that when we don't use DISTINCT, // but in practice it doesn't really matter since in SPARQL it's all sucked // into memory anyway. using (IDataReader reader = RunReader(cmd.ToString())) { while (reader.Read()) { QueryResultRowVariable[] row = new QueryResultRowVariable[varOrder.Length]; results.Add(row); int col = 0; for (int i = 0; i < varOrder.Length; i++) { Variable v = varOrder[i]; row[i].id = reader.GetInt64(col++); if ((bool)varSelectedEntity[v]) { row[i].uri = AsString(reader[col++]); } if ((bool)varSelectedLiteral[v]) { row[i].litvalue = AsString(reader[col++]); row[i].litlanguage = AsString(reader[col++]); row[i].litdatatype = AsString(reader[col++]); } } } } // For any distinguished variable that we did not select URIs or literal values for, // select that information now. for (int i = 0; i < varOrder.Length; i++) { Variable v = varOrder[i]; if ((bool)varSelectedEntity[v] && (!(bool)varCouldBeLiteral[v] || (bool)varSelectedLiteral[v])) continue; // Get the list of resource IDs found for this variable. ArrayList rids = new ArrayList(); foreach (QueryResultRowVariable[] row in results) { if (row[i].id <= 1) continue; // can't fetch for Statement.DefaultMeta if (resourceCache.ContainsKey(row[i].id)) continue; // we've already fetched it rids.Add(row[i].id); // probably no need to remove duplicates } if (rids.Count > 0) { // Fetch what we can for entities. if (!(bool)varSelectedEntity[v]) { StringBuilder cmd2 = new StringBuilder(); cmd2.Append("SELECT id, value FROM "); cmd2.Append(table); cmd2.Append("_entities WHERE id IN ("); bool first = true; foreach (Int64 id in rids) { if (!first) cmd2.Append(','); first = false; cmd2.Append(id); } cmd2.Append(")"); if (Debug) { Console.Error.WriteLine(cmd2.ToString()); } using (IDataReader reader = RunReader(cmd2.ToString())) { while (reader.Read()) { Int64 id = reader.GetInt64(0); string uri = AsString(reader[1]); resourceCache[id] = MakeEntity(id, uri, null); } } } // Fetch what we can for literals. if ((bool)varCouldBeLiteral[v] && !(bool)varSelectedLiteral[v]) { StringBuilder cmd2 = new StringBuilder(); cmd2.Append("SELECT id, value, language, datatype FROM "); cmd2.Append(table); cmd2.Append("_literals WHERE id IN ("); bool first = true; foreach (Int64 id in rids) { if (!first) cmd2.Append(','); first = false; cmd2.Append(id); } cmd2.Append(")"); if (Debug) { Console.Error.WriteLine(cmd2.ToString()); } using (IDataReader reader = RunReader(cmd2.ToString())) { while (reader.Read()) { Int64 id = reader.GetInt64(0); string value = AsString(reader[1]); string language = AsString(reader[2]); string datatype = AsString(reader[3]); Literal lit = new Literal(value, language, datatype); SetResourceKey(lit, new ResourceKey(id)); resourceCache[id] = lit; } } } // Any ids not found so far are bnodes. foreach (Int64 id in rids) { if (!resourceCache.ContainsKey(id)) { BNode b = new BNode(); SetResourceKey(b, new ResourceKey(id)); resourceCache[id] = b; } } } } } // lock // Now loop through the binding results. foreach (QueryResultRowVariable[] row in results) { bool match = true; Resource[] variableBindings = new Resource[varOrder.Length]; for (int i = 0; i < varOrder.Length; i++) { Int64 id = row[i].id; if (resourceCache.ContainsKey(id)) { variableBindings[i] = (Resource)resourceCache[id]; } else { if (row[i].litvalue == null) { variableBindings[i] = MakeEntity(id, row[i].uri, null); } else { Literal lit = new Literal(row[i].litvalue, row[i].litlanguage, row[i].litdatatype); ArrayList litFilters = (ArrayList)varLitFilters[varOrder[i]]; if (litFilters != null && !LiteralFilter.MatchesFilters(lit, (LiteralFilter[])litFilters.ToArray(typeof(LiteralFilter)), this)) { match = false; break; } SetResourceKey(lit, new ResourceKey(id)); variableBindings[i] = lit; } // reuse this entity later resourceCache[id] = variableBindings[i]; } } if (!match) continue; if (!sink.Add(new SemWeb.Query.VariableBindings(varOrder, variableBindings))) return; } sink.Finished(); }
public void Select (SemWeb.StatementSink sink) { Entity keywords = null; foreach (DataSet data in sets) { switch (data.ID) { case DataSetID.CopyrightNotice: MetadataStore.AddLiteral (sink, "dc:rights", "rdf:Alt", new SemWeb.Literal (data.XmpObject, "x-default", null)); break; case DataSetID.ByLine: MetadataStore.AddLiteral (sink, "dc:creator", "rdf:Seq", new SemWeb.Literal (data.XmpObject, "x-default", null)); break; case DataSetID.CaptionAbstract: MetadataStore.AddLiteral (sink, "dc:description", "rdf:Alt", new SemWeb.Literal (data.XmpObject, "x-default", null)); break; case DataSetID.ObjectName: MetadataStore.AddLiteral (sink, "dc:title", "rdf:Alt", new SemWeb.Literal (data.XmpObject, "x-default", null)); break; case DataSetID.Keywords: if (keywords == null) { keywords = new BNode (); sink.Add (new Statement (MetadataStore.FSpotXMPBase, MetadataStore.Namespaces.Resolve ("dc:subject"), keywords)); sink.Add (new Statement (keywords, (Entity)MetadataStore.Namespaces.Resolve ("rdf:type"), (Entity)MetadataStore.Namespaces.Resolve ("rdf:Bag"))); } sink.Add (new Statement (keywords, MetadataStore.Namespaces.Resolve ("rdf:li"), new SemWeb.Literal (data.XmpObject, "x-default", null))); break; default: if (data.XmpPredicate != null) { sink.Add (new Statement (MetadataStore.FSpotXMPBase, (Entity)data.XmpPredicate, new SemWeb.Literal (data.XmpObject))); } break; } } }
/// <summary> /// Queries the Store using the Graph Pattern specified by the set of Statement Patterns /// </summary> /// <param name="graph">Graph Pattern</param> /// <param name="options">Query Options</param> /// <param name="sink">Results Sink</param> /// <remarks> /// <para> /// Implemented by converting the Statement Patterns into a SPARQL SELECT query and executing that against the underlying Store's SPARQL engine /// </para> /// <para> /// The only Query Option that is supported is the Limit option /// </para> /// </remarks> public void Query(Statement[] graph, SW.Query.QueryOptions options, SW.Query.QueryResultSink sink) { //Implement as a SPARQL SELECT SparqlParameterizedString queryString = new SparqlParameterizedString(); queryString.QueryText = "SELECT * WHERE {"; int p = 0; foreach (Statement stmt in graph) { //Add Subject queryString.QueryText += "\n"; if (stmt.Subject is Variable) { queryString.QueryText += stmt.Subject.ToString(); } else { queryString.QueryText += "@param" + p; queryString.SetParameter("param" + p, SemWebConverter.FromSemWeb(stmt.Subject, this._mapping)); p++; } queryString.QueryText += " "; //Add Predicate if (stmt.Predicate is Variable) { queryString.QueryText += stmt.Predicate.ToString(); } else { queryString.QueryText += "@param" + p; queryString.SetParameter("param" + p, SemWebConverter.FromSemWeb(stmt.Predicate, this._mapping)); p++; } queryString.QueryText += " "; //Add Object if (stmt.Object is Variable) { queryString.QueryText += stmt.Object.ToString(); } else { queryString.QueryText += "@param" + p; queryString.SetParameter("param" + p, SemWebConverter.FromSemWeb(stmt.Object, this._mapping)); p++; } queryString.QueryText += " ."; } queryString.QueryText += "}"; //Execute the Query and convert the Results Object results = this._store.ExecuteQuery(queryString.ToString()); if (results is SparqlResultSet) { SparqlResultSet rset = (SparqlResultSet)results; sink.Init(rset.Variables.Select(v => new Variable(v)).ToArray()); if (rset.Count > 0) { int c = 0; foreach (SparqlResult r in rset) { //Apply Limit if applicable if (options.Limit > 0 && c >= options.Limit) { sink.Finished(); return; } //Convert the Set to VariableBindings for SemWeb Variable[] vars = r.Variables.Select(v => new Variable(v)).ToArray(); Resource[] resources = r.Variables.Select(v => SemWebConverter.ToSemWeb(r[v], this._mapping)).ToArray(); SW.Query.VariableBindings bindings = new SW.Query.VariableBindings(vars, resources); //Keep adding results until the sink tells us to stop if (!sink.Add(bindings)) { sink.Finished(); return; } c++; } sink.Finished(); } else { sink.Finished(); } } else { throw new RdfQueryException("Query returned an unexpected result where a SPARQL Result Set was expected"); } }
public override void Query(Statement[] graph, SemWeb.Query.QueryOptions options, SelectableSource targetModel, SemWeb.Query.QueryResultSink sink) { QueryCheckArg(graph); // Try to do the inferencing. ArrayList evidence = prove(rules, targetModel, graph, -1); if (evidence == null) return; // not provable (in max number of steps, if that were given) // Then send the possible bindings to the QueryResultSink. // Map variables to indexes. Hashtable vars = new Hashtable(); foreach (Statement s in graph) { if (s.Subject is Variable && !vars.ContainsKey(s.Subject)) vars[s.Subject] = vars.Count; if (s.Predicate is Variable && !vars.ContainsKey(s.Predicate)) vars[s.Predicate] = vars.Count; if (s.Object is Variable && !vars.ContainsKey(s.Object)) vars[s.Object] = vars.Count; } // Prepare the bindings array. Variable[] varOrder = new Variable[vars.Count]; foreach (Variable v in vars.Keys) varOrder[(int)vars[v]] = v; // Initialize the sink. sink.Init(varOrder); // Send a binding set for each piece of evidence. foreach (EvidenceItem ei in evidence) { // Write a comment to the results with the actual proof. (nifty actually) sink.AddComments(ei.ToProof().ToString()); // Create the binding array and send it on Resource[] variableBindings = new Resource[varOrder.Length]; foreach (Variable v in vars.Keys) if (ei.env.ContainsKey(v)) variableBindings[(int)vars[v]] = (Resource)ei.env[v]; sink.Add(new SemWeb.Query.VariableBindings(varOrder, variableBindings)); } // Close the sink. sink.Finished(); }