public bool Add(Statement s)
{
if (filters != null && filters.Length > 0 &&
!LiteralFilter.MatchesFilters(s.Object, filters, model))
{
return(true);
}
return(sink.Add(s));
}
public override bool Add(VariableBindings result)
{
Resource subj = si == -1 ? d.Subject : result.Values[si];
Resource pred = pi == -1 ? d.Predicate : result.Values[pi];
Resource obj = oi == -1 ? d.Object : result.Values[oi];
if (!(subj is Entity) || !(pred is Entity))
{
return(true);
}
if (litFilters != null && !LiteralFilter.MatchesFilters(obj, litFilters, null))
{
return(true);
}
return(sink.Add(new Statement((Entity)subj, (Entity)pred, obj)));
}
} // not sure...
public override void Select(SelectFilter filter, SelectableSource targetModel, StatementSink sink)
{
if (filter.Subjects == null)
{
filter.Subjects = new Entity[] { new Variable("subject") }
}
;
if (filter.Predicates == null)
{
filter.Predicates = new Entity[] { new Variable("predicate") }
}
;
if (filter.Objects == null)
{
filter.Objects = new Entity[] { new Variable("object") }
}
;
if (filter.Metas == null)
{
filter.Metas = new Entity[] { Statement.DefaultMeta }
}
;
foreach (Statement s in filter) // until we can operate on filter directly
{
ArrayList evidence = prove(rules, targetModel, new Statement[] { s }, -1);
if (evidence == null)
{
continue; // not provable (in max number of steps, if that were given)
}
foreach (EvidenceItem ei in evidence)
{
foreach (Statement h in ei.head) // better be just one statement
{
if (filter.LiteralFilters != null &&
!LiteralFilter.MatchesFilters(h.Object, filter.LiteralFilters, targetModel))
{
continue;
}
sink.Add(h);
}
}
}
}
bool Select(Entity[] subjects, Entity[] predicates, Resource[] objects, Entity[] metas, LiteralFilter[] litFilters, int limit, StatementSink sink, bool ask)
{
// TODO: Change meta into named graphs. Anything but a null or DefaultMeta
// meta returns no statements immediately.
if (metas != null && (metas.Length != 1 || metas[0] != Statement.DefaultMeta))
{
return(false);
}
string query;
bool nonull = false;
if (subjects != null && subjects.Length == 1 &&
predicates != null && predicates.Length == 1 &&
objects != null && objects.Length == 1)
{
query = "ASK WHERE { " + S(subjects[0], null) + " " + S(predicates[0], null) + " " + S(objects[0], null) + "}";
nonull = true;
}
else
{
if (ask)
{
query = "ASK";
}
else
{
query = "SELECT *";
}
query += " WHERE { ";
query += S(subjects, "subject");
query += " ";
query += S(predicates, "predicate");
query += " ";
query += S(objects, "object");
query += " . ";
query += SL(subjects, "subject");
query += SL(predicates, "predicate");
query += SL(objects, "object");
query += " }";
// TODO: Pass literal filters to server.
}
if (limit >= 1)
{
query += " LIMIT " + limit;
}
XmlDocument result = Load(query);
if (ask || nonull)
{
foreach (XmlElement boolean in result.DocumentElement)
{
if (boolean.Name != "boolean")
{
continue;
}
bool ret = boolean.InnerText == "true";
if (ask)
{
return(ret);
}
else if (ret)
{
sink.Add(new Statement(subjects[0], predicates[0], objects[0]));
}
return(false);
}
throw new ApplicationException("Invalid server response: No boolean node.");
}
XmlElement bindings = null;
foreach (XmlElement e in result.DocumentElement)
{
if (e.Name == "results")
{
bindings = e;
}
}
if (bindings == null)
{
throw new ApplicationException("Invalid server response: No result node.");
}
MemoryStore distinctCheck = null;
if (bindings.GetAttribute("distinct") != "true")
{
distinctCheck = new MemoryStore();
}
Hashtable bnodes = new Hashtable();
foreach (XmlNode bindingnode in bindings)
{
if (!(bindingnode is XmlElement))
{
continue;
}
XmlElement binding = (XmlElement)bindingnode;
Resource subj = GetBinding(binding, "subject", subjects, bnodes);
Resource pred = GetBinding(binding, "predicate", predicates, bnodes);
Resource obj = GetBinding(binding, "object", objects, bnodes);
if (!(subj is Entity) || !(pred is Entity))
{
continue;
}
Statement s = new Statement((Entity)subj, (Entity)pred, obj);
if (distinctCheck != null && distinctCheck.Contains(s))
{
continue;
}
if (litFilters != null && !LiteralFilter.MatchesFilters(s.Object, litFilters, this))
{
continue;
}
if (!sink.Add(s))
{
return(true);
}
if (distinctCheck != null)
{
distinctCheck.Add(s);
}
}
return(true);
}
/// <summary>
/// Selects Statements from the Source based on a Filter
/// </summary>
/// <param name="filter">Statement Filter</param>
/// <param name="sink">Sink to stream results to</param>
public void Select(SelectFilter filter, StatementSink sink)
{
//Don't support filters on Metas for the Graph Source
if (filter.Metas != null)
{
throw new RdfException("The dotNetRDF GraphSource does not support SemWeb filters which use Meta filters");
}
//Want to build an IEnumerable based on the Filter
IEnumerable <Triple> ts = Enumerable.Empty <Triple>();
INode s, p, o;
if (filter.Subjects != null)
{
if (filter.Predicates != null)
{
//Subject-Predicate filter
foreach (Entity subj in filter.Subjects)
{
s = SemWebConverter.FromSemWeb(subj, this._mapping);
foreach (Entity pred in filter.Predicates)
{
p = SemWebConverter.FromSemWeb(pred, this._mapping);
ts = ts.Concat(this._g.GetTriplesWithSubjectPredicate(s, p));
}
}
}
else if (filter.Objects != null)
{
//Subject-Object filter
foreach (Entity subj in filter.Subjects)
{
s = SemWebConverter.FromSemWeb(subj, this._mapping);
foreach (Resource obj in filter.Objects)
{
o = SemWebConverter.FromSemWeb(obj, this._mapping);
ts = ts.Concat(this._g.GetTriplesWithSubjectObject(s, o));
}
}
}
else
{
//Subjects filter
foreach (Entity subj in filter.Subjects)
{
s = SemWebConverter.FromSemWeb(subj, this._mapping);
ts = ts.Concat(this._g.GetTriplesWithSubject(s));
}
}
}
else if (filter.Predicates != null)
{
if (filter.Objects != null)
{
//Predicate-Object Filter
foreach (Entity pred in filter.Predicates)
{
p = SemWebConverter.FromSemWeb(pred, this._mapping);
foreach (Resource obj in filter.Objects)
{
o = SemWebConverter.FromSemWeb(obj, this._mapping);
ts = ts.Concat(this._g.GetTriplesWithPredicateObject(p, o));
}
}
}
else
{
//Predicate Filter
foreach (Entity pred in filter.Predicates)
{
p = SemWebConverter.FromSemWeb(pred, this._mapping);
ts = ts.Concat(this._g.GetTriplesWithPredicate(p));
}
}
}
else if (filter.Objects != null)
{
//Object Filter
foreach (Resource obj in filter.Objects)
{
o = SemWebConverter.FromSemWeb(obj, this._mapping);
ts = ts.Concat(this._g.GetTriplesWithObject(o));
}
}
else
{
//Everything is null so this is a Select All
ts = this._g.Triples;
}
int count = 0;
foreach (Triple t in ts)
{
//Apply limit if applicable
if (filter.Limit > 0 && count >= filter.Limit)
{
return;
}
//Convert to a Statement and apply applicable Literal Filters
Statement stmt = SemWebConverter.ToSemWeb(t, this._mapping);
if (filter.LiteralFilters != null)
{
if (LiteralFilter.MatchesFilters(stmt.Object, filter.LiteralFilters, this))
{
//If the Object matched the filters then we return the Triple and stop
//streaming if the sink tells us to
if (!sink.Add(stmt))
{
return;
}
count++;
}
//If it doesn't match the filter it is ignored
}
else
{
//Just add the statement and stop if the sink tells us to stop streaming
if (!sink.Add(stmt))
{
return;
}
count++;
}
}
}
private void Select2(SelectFilter filter, StatementSink result)
{
// Don't select on columns that we already know from the template.
SelectColumnFilter columns = new SelectColumnFilter();
columns.Subject = (filter.Subjects == null) || (filter.Subjects.Length > 1);
columns.Predicate = (filter.Predicates == null) || (filter.Predicates.Length > 1);
columns.Object = (filter.Objects == null) || (filter.Objects.Length > 1);
columns.Meta = (filter.Metas == null) || (filter.Metas.Length > 1);;
if (filter.Predicates != null | Array.IndexOf(filter.Predicates, rdfs_member) != 1)
{
columns.Predicate = true;
}
// Have to select something
if (!columns.Subject && !columns.Predicate && !columns.Object && !columns.Meta)
{
columns.Subject = true;
}
System.Text.StringBuilder cmd = new System.Text.StringBuilder("SELECT ");
if (!connection.AreStatementsUnique)
{
cmd.Append("DISTINCT ");
}
ArrayList cols = new ArrayList();
if (columns.Subject)
{
cols.Add("sinfo.type"); cols.Add("sinfo.value");
}
if (columns.Predicate)
{
cols.Add("pinfo.type"); cols.Add("pinfo.value");
}
if (columns.Object)
{
cols.Add("oinfo.type"); cols.Add("oinfo.value"); cols.Add("oinfo.language"); cols.Add("oinfo.datatype");
}
if (columns.Meta)
{
cols.Add("minfo.type"); cols.Add("minfo.value");
}
cmd.Append(String.Join(", ", (String[])cols.ToArray(typeof(String))));
cmd.Append(" FROM ");
cmd.Append(prefix);
cmd.Append("_statements AS q");
if (columns.Subject)
{
cmd.Append(" LEFT JOIN ");
cmd.Append(prefix);
cmd.Append("_values AS sinfo ON q.subject = sinfo.id");
}
if (columns.Predicate)
{
cmd.Append(" LEFT JOIN ");
cmd.Append(prefix);
cmd.Append("_values AS pinfo ON q.predicate = pinfo.id");
}
if (columns.Object)
{
cmd.Append(" LEFT JOIN ");
cmd.Append(prefix);
cmd.Append("_values AS oinfo ON q.object = oinfo.id");
}
if (columns.Meta)
{
cmd.Append(" LEFT JOIN ");
cmd.Append(prefix);
cmd.Append("_values AS minfo ON q.meta = minfo.id");
}
cmd.Append(' ');
bool wroteWhere = WhereClause(filter, cmd);
// Transform literal filters into SQL.
if (filter.LiteralFilters != null)
{
foreach (LiteralFilter f in filter.LiteralFilters)
{
string s = FilterToSQL(f, "oinfo.value");
if (s != null)
{
if (!wroteWhere)
{
cmd.Append(" WHERE "); wroteWhere = true;
}
else
{
cmd.Append(" AND ");
}
cmd.Append(' ');
cmd.Append(s);
}
}
}
if (filter.Limit >= 1)
{
cmd.Append(" LIMIT ");
cmd.Append(filter.Limit);
}
cmd.Append(';');
if (Debug)
{
string cmd2 = cmd.ToString();
//if (cmd2.Length > 80) cmd2 = cmd2.Substring(0, 80);
Console.Error.WriteLine(cmd2);
}
using (IDataReader reader = connection.RunReader(cmd.ToString())) {
while (reader.Read())
{
Entity s = columns.Subject ? null : filter.Subjects[0];
Entity p = columns.Predicate ? null : filter.Predicates[0];
Resource o = columns.Object ? null : filter.Objects[0];
Entity m = columns.Meta ? null : filter.Metas[0];
int col = 0;
if (columns.Subject)
{
s = SelectEntity(reader.GetInt32(col++), reader.GetString(col++));
}
if (columns.Predicate)
{
p = SelectEntity(reader.GetInt32(col++), reader.GetString(col++));
}
if (columns.Object)
{
o = SelectResource(reader.GetInt32(col++), reader.GetString(col++), reader.GetString(col++), reader.GetString(col++));
}
if (columns.Meta)
{
m = SelectEntity(reader.GetInt32(col++), reader.GetString(col++));
}
if (filter.LiteralFilters != null && !LiteralFilter.MatchesFilters(o, filter.LiteralFilters, this))
{
continue;
}
bool ret = result.Add(new Statement(s, p, o, m));
if (!ret)
{
break;
}
}
}
}
/// <summary>
/// Selects Statements from the Source based on a Filter
/// </summary>
/// <param name="filter">Statement Filter</param>
/// <param name="sink">Sink to stream results to</param>
public void Select(SelectFilter filter, StatementSink sink)
{
IEnumerable <Triple> ts = Enumerable.Empty <Triple>();
if (filter.Metas != null)
{
//This applies over some Graphs
foreach (Entity meta in filter.Metas)
{
if (meta.Uri != null)
{
Uri graphUri = new Uri(meta.Uri);
if (this._store.HasGraph(graphUri))
{
ts = ts.Concat(this.FilterToEnumerable(filter, this._store.Graph(graphUri)));
}
}
}
}
else
{
//This applies over all Graphs
foreach (IGraph g in this._store.Graphs)
{
ts = ts.Concat(this.FilterToEnumerable(filter, g));
}
}
int count = 0;
foreach (Triple t in ts)
{
//Apply limit if applicable
if (filter.Limit > 0 && count >= filter.Limit)
{
return;
}
Statement stmt = SemWebConverter.ToSemWeb(t, this.GetMapping(t.Graph));
stmt.Meta = new Entity(t.GraphUri.ToString());
if (filter.LiteralFilters != null)
{
if (LiteralFilter.MatchesFilters(stmt.Object, filter.LiteralFilters, this))
{
//If the Object matched the filters then we return the Triple and stop
//streaming if the sink tells us to
if (!sink.Add(stmt))
{
return;
}
count++;
}
}
else
{
//Just add the statement and stop if the sink tells us to stop streaming
if (!sink.Add(stmt))
{
return;
}
count++;
}
}
}
protected void LoadToSink(SourceDescriptor sourceDescr, IList <object> ids, IList <FieldDescriptor> predFlds, Resource[] vals, StatementSink sink, SelectFilter flt)
{
// todo: more effective impl using IDbDalc datareader
var ds = new DataSet();
var q = new Query(sourceDescr.SourceName);
var flds = predFlds ?? sourceDescr.Fields;
var loadType = flt.Predicates == null || flt.Predicates.Contains(NS.Rdf.typeEntity);
q.Fields = new string[flds.Count + 1];
q.Fields[0] = sourceDescr.IdFieldName;
for (int i = 0; i < flds.Count; i++)
{
q.Fields[i + 1] = flds[i].FieldName;
}
// compose query condition
var condition = new QueryGroupNode(GroupType.And);
if (ids != null)
{
condition.Nodes.Add(ComposeCondition(sourceDescr.IdFieldName, ids.ToArray()));
}
if (vals != null && !loadType)
{
var orGrp = new QueryGroupNode(GroupType.Or);
for (int i = 0; i < flds.Count; i++)
{
var valCnd = ComposeCondition(flds[i], vals);
if (valCnd != null)
{
orGrp.Nodes.Add(valCnd);
}
}
if (orGrp.Nodes.Count == 0)
{
return; //values are not for this source
}
condition.Nodes.Add(orGrp);
}
if (flt.LiteralFilters != null)
{
var literalFltCondition = ComposeLiteralFilter(flds, flt.LiteralFilters);
if (literalFltCondition != null)
{
condition.Nodes.Add(literalFltCondition);
}
}
q.Root = condition;
if (flt.Limit > 0)
{
q.RecordCount = flt.Limit;
}
// log
log.Write(LogEvent.Debug, q);
Console.WriteLine(q.ToString());
// query result handler
Action <IDataReader> loadToSinkAction = delegate(IDataReader dataReader) {
int recIndex = 0;
while (dataReader.Read() && (recIndex < q.RecordCount))
{
recIndex++;
var itemEntity = GetSourceItemEntity(sourceDescr, dataReader[sourceDescr.IdFieldName]);
for (int j = 0; j < flds.Count; j++)
{
var f = flds[j];
var obj = PrepareResource(f, dataReader[f.FieldName]);
if (vals == null || vals.Contains(obj))
{
// literals post-filter
if (flt.LiteralFilters != null && !LiteralFilter.MatchesFilters(obj, flt.LiteralFilters, this))
{
continue;
}
if (!sink.Add(new Statement(itemEntity, EntityFieldHash[f], obj)))
{
return;
}
}
}
// type predicate
if (loadType && flt.LiteralFilters == null)
{
if (vals == null || vals.Contains(EntitySourceHash[sourceDescr]))
{
if (!sink.Add(
new Statement(itemEntity, NS.Rdf.typeEntity, EntitySourceHash[sourceDescr])))
{
return;
}
}
}
}
};
// DB DALC datareader optimization
if (Dalc is IDbDalc)
{
var dbDalc = (IDbDalc)Dalc;
bool closeConn = false;
try {
if (dbDalc.Connection.State != ConnectionState.Open)
{
dbDalc.Connection.Open();
closeConn = true;
}
IDataReader rdr = dbDalc.LoadReader(q);
try {
loadToSinkAction(rdr);
} finally {
rdr.Close();
}
} finally {
if (closeConn)
{
dbDalc.Connection.Close();
}
}
}
else
{
Dalc.Load(ds, q);
var tblRdr = ds.Tables[q.SourceName].CreateDataReader();
try {
loadToSinkAction(tblRdr);
} finally {
tblRdr.Close();
}
}
}