public void TestSelectRegexFilter()
{
// Arrange
graph = new RDFGraph();
RDFSelectQuery query;
BuildGraph(graph);
// Act
query = new RDFSelectQuery();
var x = new RDFVariable("x");
var y = new RDFVariable("y");
var z = new RDFVariable("z");
var patternGroup = new RDFPatternGroup("PatternGroup1").AddPattern(new RDFPattern(x, y, z));
var filter = new RDFRegexFilter(x, new Regex(@".1$", RegexOptions.IgnoreCase)); // Filter subjects ending with 1
patternGroup.AddFilter(filter);
query.AddPatternGroup(patternGroup)
.AddProjectionVariable(x)
.AddProjectionVariable(y)
.AddProjectionVariable(z);
var result = query.ApplyToGraph(graph);
// Assert
Assert.AreEqual(3, result.SelectResultsCount);
}
public void TestSelectNumericAggregators()
{
// Arrange
graph = new RDFGraph();
RDFSelectQuery query;
BuildGraphWithValues(graph);
// Act
query = new RDFSelectQuery();
var x = new RDFVariable("x");
var type = new RDFVariable("type");
var value = new RDFVariable("value");
var patternGroup1 = new RDFPatternGroup("PatternGroup1").AddPattern(new RDFPattern(x, RDF.TYPE, type));
var patternGroup2 = new RDFPatternGroup("PatternGroup2").AddPattern(new RDFPattern(x, RDF.VALUE, value));
query.AddPatternGroup(patternGroup1)
.AddPatternGroup(patternGroup2)
.AddProjectionVariable(type);
var gm = new RDFGroupByModifier(new List <RDFVariable>()
{
type
});
gm.AddAggregator(new RDFAvgAggregator(value, new RDFVariable("avg")));
gm.AddAggregator(new RDFSumAggregator(value, new RDFVariable("sum")));
gm.AddAggregator(new RDFCountAggregator(value, new RDFVariable("count")));
gm.AddAggregator(new RDFMinAggregator(value, new RDFVariable("min"), RDFQueryEnums.RDFMinMaxAggregatorFlavors.Numeric));
gm.AddAggregator(new RDFMaxAggregator(value, new RDFVariable("max"), RDFQueryEnums.RDFMinMaxAggregatorFlavors.Numeric));
query.AddModifier(gm);
var result = query.ApplyToGraph(graph);
// Assert
var row = result.SelectResults.AsEnumerable().ElementAt(0);
// average
string resultStr = (string)row.ItemArray.ElementAt(1);
int resultNum = int.Parse(resultStr.Split('^')[0]);
Assert.AreEqual(30, resultNum);
// sum
resultStr = (string)row.ItemArray.ElementAt(2);
resultNum = int.Parse(resultStr.Split('^')[0]);
Assert.AreEqual(150, resultNum);
// count
resultStr = (string)row.ItemArray.ElementAt(3);
resultNum = int.Parse(resultStr.Split('^')[0]);
Assert.AreEqual(5, resultNum);
// min
resultStr = (string)row.ItemArray.ElementAt(4);
resultNum = int.Parse(resultStr.Split('^')[0]);
Assert.AreEqual(10, resultNum);
// max
resultStr = (string)row.ItemArray.ElementAt(5);
resultNum = int.Parse(resultStr.Split('^')[0]);
Assert.AreEqual(50, resultNum);
}
public void CreateVariableTest()
{
//Arrange
var x = new RDFVariable("x");
//Assert
Assert.Equal("?X", x.VariableName);
}
/// <summary>
/// Compacts the reified quadruples by removing their 4 standard statements
/// </summary>
public override RDFStore UnreifyQuadruples()
{
//Create SPARQL SELECT query for detecting reified quadruples
var T = new RDFVariable("T", true);
var C = new RDFVariable("C", true);
var S = new RDFVariable("S", true);
var P = new RDFVariable("P", true);
var O = new RDFVariable("O", true);
var Q = new RDFSelectQuery()
.AddPatternGroup(new RDFPatternGroup("UnreifyQuadruples")
.AddPattern(new RDFPattern(C, T, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.STATEMENT))
.AddPattern(new RDFPattern(C, T, RDFVocabulary.RDF.SUBJECT, S))
.AddPattern(new RDFPattern(C, T, RDFVocabulary.RDF.PREDICATE, P))
.AddPattern(new RDFPattern(C, T, RDFVocabulary.RDF.OBJECT, O))
.AddFilter(new RDFIsUriFilter(C))
.AddFilter(new RDFIsUriFilter(T))
.AddFilter(new RDFIsUriFilter(S))
.AddFilter(new RDFIsUriFilter(P))
);
//Apply it to the store
var R = Q.ApplyToStore(this);
//Iterate results
var reifiedQuadruples = R.SelectResults.Rows.GetEnumerator();
while (reifiedQuadruples.MoveNext())
{
//Get reification data (T, C, S, P, O)
var tRepresent = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)reifiedQuadruples.Current)["?T"].ToString());
var tContext = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)reifiedQuadruples.Current)["?C"].ToString());
var tSubject = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)reifiedQuadruples.Current)["?S"].ToString());
var tPredicate = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)reifiedQuadruples.Current)["?P"].ToString());
var tObject = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)reifiedQuadruples.Current)["?O"].ToString());
//Cleanup store from detected reifications
if (tObject is RDFResource)
{
this.AddQuadruple(new RDFQuadruple(new RDFContext(((RDFResource)tContext).URI), (RDFResource)tSubject, (RDFResource)tPredicate, (RDFResource)tObject));
this.RemoveQuadruple(new RDFQuadruple(new RDFContext(((RDFResource)tContext).URI), (RDFResource)tRepresent, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.STATEMENT));
this.RemoveQuadruple(new RDFQuadruple(new RDFContext(((RDFResource)tContext).URI), (RDFResource)tRepresent, RDFVocabulary.RDF.SUBJECT, (RDFResource)tSubject));
this.RemoveQuadruple(new RDFQuadruple(new RDFContext(((RDFResource)tContext).URI), (RDFResource)tRepresent, RDFVocabulary.RDF.PREDICATE, (RDFResource)tPredicate));
this.RemoveQuadruple(new RDFQuadruple(new RDFContext(((RDFResource)tContext).URI), (RDFResource)tRepresent, RDFVocabulary.RDF.OBJECT, (RDFResource)tObject));
}
else
{
this.AddQuadruple(new RDFQuadruple(new RDFContext(((RDFResource)tContext).URI), (RDFResource)tSubject, (RDFResource)tPredicate, (RDFLiteral)tObject));
this.RemoveQuadruple(new RDFQuadruple(new RDFContext(((RDFResource)tContext).URI), (RDFResource)tRepresent, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.STATEMENT));
this.RemoveQuadruple(new RDFQuadruple(new RDFContext(((RDFResource)tContext).URI), (RDFResource)tRepresent, RDFVocabulary.RDF.SUBJECT, (RDFResource)tSubject));
this.RemoveQuadruple(new RDFQuadruple(new RDFContext(((RDFResource)tContext).URI), (RDFResource)tRepresent, RDFVocabulary.RDF.PREDICATE, (RDFResource)tPredicate));
this.RemoveQuadruple(new RDFQuadruple(new RDFContext(((RDFResource)tContext).URI), (RDFResource)tRepresent, RDFVocabulary.RDF.OBJECT, (RDFLiteral)tObject));
}
}
return(this);
}
public void CreateLangMatchesFilter()
{
//Arrange
var n = new RDFVariable("n");
var filter = new RDFLangMatchesFilter(n, "it-IT");
var pg1 = new RDFPatternGroup("PG1");
//Act
pg1.AddFilter(filter);
//Assert
Assert.Contains(filter.ToString(), pg1.ToString());
}
public void CreateIsNumericFilter()
{
//Arrange
var x = new RDFVariable("x");
var filter = new RDFIsUriFilter(x);
var pg1 = new RDFPatternGroup("PG1");
//Act
pg1.AddFilter(filter);
//Assert
Assert.Contains(filter.ToString(), pg1.ToString());
}
public void CreateSameTermFilter()
{
//Arrange
var x = new RDFVariable("x");
var filter = new RDFSameTermFilter(x, donaldduck);
var pg1 = new RDFPatternGroup("PG1");
//Act
pg1.AddFilter(filter);
//Assert
Assert.Contains(filter.ToString(), pg1.ToString());
}
public void AddOrderByModifierAscToQueryTest()
{
//Arrange
var n = new RDFVariable("n");
var query = new RDFSelectQuery();
var modifier = new RDFOrderByModifier(n, RDFQueryEnums.RDFOrderByFlavors.ASC);
//Act
query.AddModifier(modifier);
//Assert
Assert.Contains($"order by {modifier}".ToUpper(), query.ToString().ToUpper());
}
public void CreateTriplePatternTest()
{
//Arrange
var x = new RDFVariable("x");
var y = new RDFVariable("y");
var dogOf = new RDFResource(RDFVocabulary.DC.BASE_URI + "dogOf");
//Act
var y_dogOf_x = new RDFPattern(y, dogOf, x);
//Assert
Assert.Equal(x, y_dogOf_x.Object);
}
public void CreateComparisonFilter()
{
//Arrange
var y = new RDFVariable("y");
var filter = new RDFComparisonFilter(RDFQueryEnums.RDFComparisonFlavors.LessThan, y, new RDFPlainLiteral("25"));
var pg1 = new RDFPatternGroup("PG1");
//Act
pg1.AddFilter(filter);
//Assert
Assert.Contains(filter.ToString(), pg1.ToString());
}
public void CreateRegexFilter()
{
//Arrange
var n = new RDFVariable("n");
var filter = new RDFRegexFilter(n, new Regex(@"Mouse", RegexOptions.IgnoreCase));
var pg1 = new RDFPatternGroup("PG1");
//Act
pg1.AddFilter(filter);
//Assert
Assert.Contains(filter.ToString(), pg1.ToString());
}
/// <summary>
/// Compacts the reified triples by removing their 4 standard statements
/// </summary>
public void UnreifyTriples()
{
//Create SPARQL SELECT query for detecting reified triples
var T = new RDFVariable("T");
var S = new RDFVariable("S");
var P = new RDFVariable("P");
var O = new RDFVariable("O");
var Q = new RDFSelectQuery()
.AddPatternGroup(new RDFPatternGroup("UnreifyTriples")
.AddPattern(new RDFPattern(T, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.STATEMENT))
.AddPattern(new RDFPattern(T, RDFVocabulary.RDF.SUBJECT, S))
.AddPattern(new RDFPattern(T, RDFVocabulary.RDF.PREDICATE, P))
.AddPattern(new RDFPattern(T, RDFVocabulary.RDF.OBJECT, O))
.AddFilter(new RDFIsUriFilter(T))
.AddFilter(new RDFIsUriFilter(S))
.AddFilter(new RDFIsUriFilter(P))
);
//Apply it to the graph
var R = Q.ApplyToGraph(this);
//Iterate results
var reifiedTriples = R.SelectResults.Rows.GetEnumerator();
while (reifiedTriples.MoveNext())
{
//Get reification data (T, S, P, O)
var tRepresent = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)reifiedTriples.Current)["?T"].ToString());
var tSubject = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)reifiedTriples.Current)["?S"].ToString());
var tPredicate = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)reifiedTriples.Current)["?P"].ToString());
var tObject = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)reifiedTriples.Current)["?O"].ToString());
//Cleanup graph from detected reifications
if (tObject is RDFResource)
{
this.AddTriple(new RDFTriple((RDFResource)tSubject, (RDFResource)tPredicate, (RDFResource)tObject));
this.RemoveTriple(new RDFTriple((RDFResource)tRepresent, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.STATEMENT));
this.RemoveTriple(new RDFTriple((RDFResource)tRepresent, RDFVocabulary.RDF.SUBJECT, (RDFResource)tSubject));
this.RemoveTriple(new RDFTriple((RDFResource)tRepresent, RDFVocabulary.RDF.PREDICATE, (RDFResource)tPredicate));
this.RemoveTriple(new RDFTriple((RDFResource)tRepresent, RDFVocabulary.RDF.OBJECT, (RDFResource)tObject));
}
else
{
this.AddTriple(new RDFTriple((RDFResource)tSubject, (RDFResource)tPredicate, (RDFLiteral)tObject));
this.RemoveTriple(new RDFTriple((RDFResource)tRepresent, RDFVocabulary.RDF.TYPE, RDFVocabulary.RDF.STATEMENT));
this.RemoveTriple(new RDFTriple((RDFResource)tRepresent, RDFVocabulary.RDF.SUBJECT, (RDFResource)tSubject));
this.RemoveTriple(new RDFTriple((RDFResource)tRepresent, RDFVocabulary.RDF.PREDICATE, (RDFResource)tPredicate));
this.RemoveTriple(new RDFTriple((RDFResource)tRepresent, RDFVocabulary.RDF.OBJECT, (RDFLiteral)tObject));
}
}
}
public List <String> GetCategoriesOfRooms()
{
List <String> categoreies = new List <string>();
RDFVariable typesRooms = new RDFVariable("TYPESROOM");
RDFSelectQuery query = new RDFSelectQuery()
.AddPatternGroup(new RDFPatternGroup("PG1")
.AddPattern(new RDFPattern(typesRooms, RDFVocabulary.RDFS.SUB_CLASS_OF, GetClassResource("Room"))))
.AddProjectionVariable(typesRooms);
RDFSelectQueryResult resultDetectedObject = query.ApplyToGraph(ontology.ToRDFGraph(RDFSemanticsEnums.RDFOntologyInferenceExportBehavior.ModelAndData));
categoreies = (from r in resultDetectedObject.SelectResults.AsEnumerable() select GetNameWithoutURI(r["?TYPESROOM"].ToString())).Distinct().ToList();
return(categoreies);
}
//public List<SemanticObject> GetSemanticObjectsInTheRoom(string room) {
// RDFVariable id = new RDFVariable("ID");
// RDFVariable type = new RDFVariable("TYPE");
// RDFVariable score = new RDFVariable("SCORE");
// RDFVariable detections = new RDFVariable("DETECTIONS");
// RDFVariable position = new RDFVariable("POSITION");
// RDFVariable rotation = new RDFVariable("ROTATION");
// RDFVariable scale = new RDFVariable("SCALE");
// RDFVariable father = new RDFVariable("FATHER");
// RDFSelectQuery query = new RDFSelectQuery()
// .AddPatternGroup(new RDFPatternGroup("PG1")
// .AddPattern(new RDFPattern(id, RDFVocabulary.RDF.TYPE, type))
// .AddPattern(new RDFPattern(id, GetResource("position"), position))
// .AddPattern(new RDFPattern(id, GetResource("rotation"), rotation))
// .AddPattern(new RDFPattern(id, GetResource("score"), score))
// .AddPattern(new RDFPattern(id, GetResource("detections"), detections))
// .AddPattern(new RDFPattern(id, GetResource("size"), scale))
// .AddPattern(new RDFPattern(id, GetResource("isIn"), GetClassResource(room)))
// .AddPattern(new RDFPattern(type, RDFVocabulary.RDFS.SUB_CLASS_OF, GetClassResource("Furniture")).UnionWithNext())
// .AddPattern(new RDFPattern(type, RDFVocabulary.RDFS.SUB_CLASS_OF, GetClassResource("Appliance")))
// .AddPattern(new RDFPattern(id, GetResource("isPartOf"), father).Optional()))
// .AddProjectionVariable(id)
// .AddProjectionVariable(type)
// .AddProjectionVariable(score)
// .AddProjectionVariable(detections)
// .AddProjectionVariable(position)
// .AddProjectionVariable(rotation)
// .AddProjectionVariable(scale)
// .AddProjectionVariable(father);
// query.AddModifier(new RDFDistinctModifier());
// RDFSelectQueryResult resultDetectedObject = query.ApplyToGraph(_ontology.ToRDFGraph(RDFSemanticsEnums.RDFOntologyInferenceExportBehavior.ModelAndData));
// List<SemanticObject> result = new List<SemanticObject>();
// foreach (DataRow row in resultDetectedObject.SelectResults.AsEnumerable()) {
// //if (row.Field<string>("?FATHER") == null)
// //{
// // result.Add(new SemanticObject(row.Field<string>("?ID"),
// // row.Field<string>("?TYPE"),
// // float.Parse(row.Field<string>("?SCORE")),
// // int.Parse(row.Field<string>("?DETECTIONS")),
// // StringToVector3(row.Field<string>("?POSITION")),
// // StringToVector3(row.Field<string>("?SCALE")),
// // StringToQuaternion(row.Field<string>("?ROTATION")),
// // _semanticRoomManager._semantic_rooms.Find(r => r._id.Equals(room))
// // ));
// //}
// }
// return result;
//}
#endregion
#region Private Functions
private void UpdateListOfObjectsClassInOntology()
{
RDFVariable c = new RDFVariable("CLASS");
RDFVariable tc = new RDFVariable("TCLASS");
RDFSelectQuery query = new RDFSelectQuery()
.AddPatternGroup(new RDFPatternGroup("PG1")
.AddPattern(new RDFPattern(c, RDFVocabulary.RDFS.SUB_CLASS_OF, tc))
.AddPattern(new RDFPattern(tc, RDFVocabulary.RDFS.SUB_CLASS_OF, GetClassResource("Object"))))
.AddProjectionVariable(c);
RDFSelectQueryResult resultDetectedObject = query.ApplyToGraph(ontology.ToRDFGraph(RDFSemanticsEnums.RDFOntologyInferenceExportBehavior.ModelAndData));
objectClassInOntology = (from r in resultDetectedObject.SelectResults.AsEnumerable() select GetNameWithoutURI(r["?CLASS"].ToString())).Distinct().ToList();
}
public void CreateQuadruplePatternTest()
{
//Arrange
var x = new RDFVariable("x");
var y = new RDFVariable("y");
var n = new RDFVariable("n");
var dogOf = new RDFResource(RDFVocabulary.DC.BASE_URI + "dogOf");
//Act
var n_y_dogOf_x = new RDFPattern(n, y, dogOf, x);
//Assert
Assert.Equal(y, n_y_dogOf_x.Subject);
}
public void AskQueryResultFalseTest()
{
//Arrange
var y = new RDFVariable("y");
var askQuery = new RDFAskQuery();
var patternGroup = new RDFPatternGroup("PatternGroup");
patternGroup.AddPattern(new RDFPattern(donaldduck, y, new RDFTypedLiteral("90", RDFModelEnums.RDFDatatypes.XSD_INTEGER)));
askQuery.AddPatternGroup(patternGroup);
//Act
var result = askQuery.ApplyToGraph(graph);
//Assert
Assert.False(result.AskResult);
}
public void SelectQueryResultTest()
{
//Arrange
var x = new RDFVariable("x");
var q = new RDFSelectQuery();
var patternGroup = new RDFPatternGroup("PatternGroup");
patternGroup.AddPattern(new RDFPattern(x, RDFVocabulary.FOAF.AGE, new RDFTypedLiteral("85", RDFModelEnums.RDFDatatypes.XSD_INTEGER)));
q.AddPatternGroup(patternGroup);
//Act
var selectResult = q.ApplyToGraph(graph);
//Assert
Assert.Equal(2, selectResult.SelectResultsCount);
}
private void GetProbabilityRoomByClass()
{
RDFVariable objectClass = new RDFVariable("OBJECTCLASS");
RDFVariable categoryRoom = new RDFVariable("CATEGORYROOM");
RDFVariable Bnode = new RDFVariable("bnode");
RDFSelectQuery query = new RDFSelectQuery()
.AddPatternGroup(new RDFPatternGroup("PG1")
.AddPattern(new RDFPattern(objectClass, RDFVocabulary.RDFS.SUB_CLASS_OF, Bnode))
.AddPattern(new RDFPattern(objectClass, RDFVocabulary.RDFS.SUB_CLASS_OF, GetClassResource("Furniture")).UnionWithNext())
.AddPattern(new RDFPattern(objectClass, RDFVocabulary.RDFS.SUB_CLASS_OF, GetClassResource("Appliance")))
.AddPattern(new RDFPattern(Bnode, RDFVocabulary.OWL.ON_PROPERTY, GetResource("isIn")))
.AddPattern(new RDFPattern(Bnode, RDFVocabulary.OWL.SOME_VALUES_FROM, categoryRoom)))
.AddProjectionVariable(objectClass)
.AddProjectionVariable(categoryRoom);
RDFSelectQueryResult resultDetectedObject = query.ApplyToGraph(ontology.ToRDFGraph(RDFSemanticsEnums.RDFOntologyInferenceExportBehavior.ModelAndData));
objectClassInRooms = (from r in resultDetectedObject.SelectResults.AsEnumerable() select r["?OBJECTCLASS"].ToString()).Distinct().ToList();
probabilityRoomByClass = new Dictionary <string, Dictionary <string, float> >();
var _roomCategoriesInOntology = GetCategoriesOfRooms();
foreach (string category in _roomCategoriesInOntology)
{
Dictionary <string, float> probabilityRoom = new Dictionary <string, float>();
foreach (string objClass in objectClassInRooms)
{
List <string> posibilities = (from r in resultDetectedObject.SelectResults.AsEnumerable().Where(r => r.Field <string>("?OBJECTCLASS") == objClass) select GetNameWithoutURI(r["?CATEGORYROOM"].ToString())).ToList();
if (posibilities.Contains(category))
{
probabilityRoom.Add(objClass, (float)0.9 / posibilities.Count);
}
else
{
probabilityRoom.Add(objClass, (float)0.1 / (_roomCategoriesInOntology.Count - posibilities.Count));
}
}
probabilityRoomByClass.Add(category, probabilityRoom);
}
}
private RDFSelectQuery BuildSelectAllQuery(RDFFilter filter = null)
{
var query = new RDFSelectQuery();
var x = new RDFVariable("x");
var y = new RDFVariable("y");
var z = new RDFVariable("z");
var patternGroup = new RDFPatternGroup("PatternGroup1").AddPattern(new RDFPattern(x, y, z));
if (filter != null)
{
patternGroup.AddFilter(filter);
}
query.AddPatternGroup(patternGroup)
.AddProjectionVariable(x)
.AddProjectionVariable(y)
.AddProjectionVariable(z);
return(query);
}
public void CreateRDFVariable()
{
RDFVariable actor = new RDFVariable("actor");
}
/// <summary>
/// WORKING WITH SPARQL QUERIES
/// </summary>
private void WorkingWithQueries(RDFGraph graph, RDFResource donaldduck)
{
RDFSelectQuery selectQuery = new RDFSelectQuery();
// CREATE VARIABLE
var x = new RDFVariable("x"); // ?X
var y = new RDFVariable("y"); // ?Y
var n = new RDFVariable("n"); // ?N
var c = new RDFVariable("c"); // ?C
// CREATE PATTERNS
var dogOf = new RDFResource(RDFVocabulary.DC.BASE_URI + "dogOf");
var y_dogOf_x = new RDFPattern(y, dogOf, x); // TRIPLE PATTERN
var c_y_dogOf_x = new RDFPattern(c, y, dogOf, x); // QUADRUPLE PATTERN
// CREATE EMPTY PATTERN GROUP
var pg1 = new RDFPatternGroup("PG1");
// CREATE PATTERN GROUP FROM A LIST OF PATTERNS
var patterns = new List <RDFPattern>()
{
y_dogOf_x
};
var pg2 = new RDFPatternGroup("PG2", patterns);
// ADD PATTERNS TO PATTERN GROUP
pg1.AddPattern(y_dogOf_x);
pg1.AddPattern(c_y_dogOf_x);
// ADD PATTERN GROUPS TO QUERY
selectQuery.AddPatternGroup(pg1);
selectQuery.AddPatternGroup(pg2);
// ADD FILTERS TO PATTERN GROUP
pg1.AddFilter(new RDFSameTermFilter(new RDFVariable("character"), donaldduck));
pg1.AddFilter(new RDFLangMatchesFilter(n, "it-IT"));
// ADD MODIFIERS TO QUERY
selectQuery.AddModifier(new RDFOrderByModifier(n, RDFQueryEnums.RDFOrderByFlavors.ASC));
selectQuery.AddModifier(new RDFDistinctModifier());
selectQuery.AddModifier(new RDFGroupByModifier(new List <RDFVariable> {
x
}));
selectQuery.AddModifier(new RDFLimitModifier(100));
selectQuery.AddModifier(new RDFOffsetModifier(25));
// INITIALIZE PROPERTY PATH (VARIABLE TERMS)
var variablePropPath = new RDFPropertyPath(new RDFVariable("START"), new RDFVariable("END"));
// INITIALIZE PROPERTY PATH (MIXED TERMS)
var mixedPropPath = new RDFPropertyPath(new RDFResource("http://res.org/"), new RDFVariable("END"));
//ADD SEQUENCE STEPS TO PROPERTY PATH
variablePropPath.AddSequenceStep(new
RDFPropertyPathStep(new RDFResource("rdf:P1")));
variablePropPath.AddSequenceStep(new
RDFPropertyPathStep(new RDFResource("rdf:P2")));
//ADD ALTERNATIVE STEPS TO PROPERTY PATH
var altSteps = new List <RDFPropertyPathStep>();
altSteps.Add(new RDFPropertyPathStep(new
RDFResource("rdf:P3")));
altSteps.Add(new RDFPropertyPathStep(new
RDFResource("rdf:P7")));
variablePropPath.AddAlternativeSteps(altSteps);
// ADD INVERSE SEQUENCE STEP TO PROPERTY PATH: ?START ^rdf:INVP ?END
variablePropPath.AddSequenceStep(new RDFPropertyPathStep(new RDFResource("rdf:INVP")).Inverse());
//ADD ALTERNATIVE STEPS (ONE INVERSE) TO PROPERTY PATH: ?START (rdf:P3|^rdf:INVP3) ?END
var altSteps2 = new List <RDFPropertyPathStep>();
altSteps2.Add(new RDFPropertyPathStep(new RDFResource("rdf:P3")));
altSteps2.Add(new RDFPropertyPathStep(new RDFResource("rdf:INVP3")).Inverse());
variablePropPath.AddAlternativeSteps(altSteps2);
// ADD SUBQUERY TO QUERY
RDFSelectQuery mySubQuery = new RDFSelectQuery();
selectQuery.AddSubQuery(mySubQuery);
// ADD AGGREGATORS TO GROUPBY MODIFIER
RDFGroupByModifier gm = new RDFGroupByModifier(new List <RDFVariable> {
x
});
gm.AddAggregator(new RDFAvgAggregator(new RDFVariable("age"), new RDFVariable("avg_age")));
gm.AddAggregator(new RDFCountAggregator(new RDFVariable("dept"), new RDFVariable("count_dept")));
gm.AddAggregator(new RDFGroupConcatAggregator(new RDFVariable("name"), new RDFVariable("gc_name"), "-"));
gm.AddAggregator(new RDFSampleAggregator(new RDFVariable("name"), new RDFVariable("sample_name")));
gm.AddAggregator(new RDFSumAggregator(new RDFVariable("salary"), new RDFVariable("sum_salary")));
gm.AddAggregator(new RDFMinAggregator(new RDFVariable("age"), new RDFVariable("min_age"),
RDFQueryEnums.RDFMinMaxAggregatorFlavors.Numeric)); //?age is expected to have numeric typedliterals
gm.AddAggregator(new RDFMinAggregator(new RDFVariable("city"), new RDFVariable("min_city"),
RDFQueryEnums.RDFMinMaxAggregatorFlavors.String));
gm.AddAggregator(new RDFMaxAggregator(new RDFVariable("salary"), new RDFVariable("max_salary"),
RDFQueryEnums.RDFMinMaxAggregatorFlavors.Numeric)); //?salary is expected to have numeric typedliterals
gm.AddAggregator(new RDFMaxAggregator(new RDFVariable("city"), new RDFVariable("min_city"),
RDFQueryEnums.RDFMinMaxAggregatorFlavors.String));
// It is possible to filter a group - by partitioned set of SPARQL results by applying the SetHavingClause operator on desired aggregators:
// ADD AGGREGATORS TO GROUPBY MODIFIER
RDFModelEnums.RDFDatatypes xsdDbl = RDFModelEnums.RDFDatatypes.XSD_DOUBLE;
RDFModelEnums.RDFDatatypes xsdInt = RDFModelEnums.RDFDatatypes.XSD_INT;
gm.AddAggregator(new RDFAvgAggregator(new RDFVariable("age"), new RDFVariable("avg_age"))
.SetHavingClause(RDFQueryEnums.RDFComparisonFlavors.GreaterThan, new RDFTypedLiteral("25.5", xsdDbl))
);
gm.AddAggregator(new RDFCountAggregator(new RDFVariable("dept"), new RDFVariable("count_dept"))
.SetHavingClause(RDFQueryEnums.RDFComparisonFlavors.EqualTo, new RDFTypedLiteral("4", xsdInt))
);
//Declare the following SPARQL values:
/*
* VALUES (?a ?b ?c) {
* ("1" "2" "3")
* ("2" "4" "6")
* ("3" "6" UNDEF)
* }
*/
RDFValues myValues = new RDFValues()
.AddColumn(new RDFVariable("a"),
new List <RDFPatternMember>()
{
new RDFPlainLiteral("1"),
new RDFPlainLiteral("2"),
new RDFPlainLiteral("3")
})
.AddColumn(new RDFVariable("b"),
new List <RDFPatternMember>()
{
new RDFPlainLiteral("2"),
new RDFPlainLiteral("4"),
new RDFPlainLiteral("6")
})
.AddColumn(new RDFVariable("c"),
new List <RDFPatternMember>()
{
new RDFPlainLiteral("3"),
new RDFPlainLiteral("6"),
null //UNDEF
});
// ADD PROPERTY PATH TO PATTERN GROUP
pg1.AddValues(myValues);
// CREATING AND EXECUTING SELECT QUERIES
// APPLY SELECT QUERY TO GRAPH
RDFSelectQueryResult selectQueryResult = selectQuery.ApplyToGraph(graph);
// APPLY SELECT QUERY TO STORE
//RDFSelectQueryResult selectQueryResult = selectQuery.ApplyToStore(store);
// APPLY SELECT QUERY TO FEDERATION
//RDFSelectQueryResult selectQueryResult = selectQuery.ApplyToFederation(federation);
// EXPORT SELECT QUERY RESULTS TO SPARQL XML FORMAT (FILE)
selectQueryResult.ToSparqlXmlResult(@"C:\TMP\select_results.srq");
// EXPORT SELECT QUERY RESULTS TO SPARQL XML FORMAT (STREAM)
//selectQueryResult.ToSparqlXmlResult(myStream);
// IMPORT SELECT QUERY RESULTS FROM SPARQL XML FORMAT (FILE)
selectQueryResult = RDFSelectQueryResult.FromSparqlXmlResult(@"C:\TMP\select_results.srq");
// IMPORT SELECT QUERY RESULTS FROM SPARQL XML FORMAT (STREAM)
//selectQueryResult = RDFSelectQueryResult.FromSparqlXmlResult(myStream);
}
public void SelectDogsOrCats_UnionWithNext_Test()
{
// CREATE SELECT QUERY
RDFSelectQuery selectQuery = new RDFSelectQuery();
selectQuery.AddPrefix(RDFNamespaceRegister.GetByPrefix("dc"));
selectQuery.AddPrefix(RDFNamespaceRegister.GetByPrefix("foaf"));
var x = new RDFVariable("x");
var y = new RDFVariable("y");
RDFPatternMember dogOfPredicate = GraphBuilder2.dogOf;
RDFPatternMember catOfPredicate = GraphBuilder2.catOf;
var x_dogOf_y = new RDFPattern(x, dogOfPredicate, y);
var x_catOf_y = new RDFPattern(x, catOfPredicate, y);
//var orFilter = new RDFBooleanOrFilter(x_dogOf_y, x_catOf_y);
// CREATE PATTERN GROUP FROM A LIST OF PATTERNS
var pg1 = new RDFPatternGroup("PG1");
pg1.AddPattern(x_dogOf_y.UnionWithNext());
pg1.AddPattern(x_catOf_y);
selectQuery.AddPatternGroup(pg1);
selectQuery.AddProjectionVariable(x);
selectQuery.AddProjectionVariable(y);
selectQuery.AddModifier(new RDFOrderByModifier(x, RDFQueryEnums.RDFOrderByFlavors.ASC));
var sparqlCommand = selectQuery.ToString();
/*
* Generates this sparql command
*
* PREFIX dc: <http://purl.org/dc/elements/1.1/>
* PREFIX foaf: <http://xmlns.com/foaf/0.1/>
*
* SELECT ?X ?Y
* WHERE {
* {
* { ?X dc:dogOf ?Y }
* UNION
* { ?X dc:catOf ?Y }
* }
* }
* ORDER BY ASC(?X)
*/
// APPLY SELECT QUERY TO GRAPH
RDFSelectQueryResult selectQueryResult = selectQuery.ApplyToGraph(graph);
// EXPORT SELECT QUERY RESULTS TO SPARQL XML FORMAT (FILE)
selectQueryResult.ToSparqlXmlResult(@"C:\TEMP\select_results.srq");
Assert.Equal(2, selectQueryResult.SelectResultsCount);
//DataRow row = selectQueryResult.SelectResults.Rows[0];
//var dog = row[0].ToString();
//var person = row[1].ToString();
//Assert.Equal(pluto.URI.ToString(), dog);
//Assert.Equal(mickeyMouse.URI.ToString(), person);
/*
* Generates this file content
*
* <?xml version="1.0" encoding="utf-8"?>
* <sparql xmlns="http://www.w3.org/2005/sparql-results#">
* <head>
* <variable name="?X" />
* <variable name="?Y" />
* </head>
* <results>
* <result>
* <binding name="?X">
* <uri>https://en.wikipedia.org/wiki/Figaro_(Disney)</uri>
* </binding>
* <binding name="?Y">
* <uri>https://en.wikipedia.org/wiki/Minnie_Mouse</uri>
* </binding>
* </result>
* <result>
* <binding name="?X">
* <uri>https://en.wikipedia.org/wiki/Pluto_(Disney)</uri>
* </binding>
* <binding name="?Y">
* <uri>https://en.wikipedia.org/wiki/Mickey_Mouse</uri>
* </binding>
* </result>
* </results>
* </sparql>
*/
}
public void SelectDogs()
{
// CREATE SELECT QUERY
RDFSelectQuery selectQuery = new RDFSelectQuery();
selectQuery.AddPrefix(RDFNamespaceRegister.GetByPrefix("dc"));
selectQuery.AddPrefix(RDFNamespaceRegister.GetByPrefix("foaf"));
var x = new RDFVariable("x");
var y = new RDFVariable("y");
RDFPatternMember predicate = GraphBuilder2.dogOf;
var x_dogOf_y = new RDFPattern(x, predicate, y);
// CREATE PATTERN GROUP FROM A LIST OF PATTERNS
var patterns = new List <RDFPattern>()
{
x_dogOf_y
};
var pg1 = new RDFPatternGroup("PG1", patterns);
// ADD PATTERN GROUPS TO QUERY
selectQuery.AddPatternGroup(pg1);
selectQuery.AddProjectionVariable(x);
selectQuery.AddProjectionVariable(y);
// APPLY SELECT QUERY TO GRAPH
var sparqlCommand = selectQuery.ToString();
/*
* Generates this sparql command
*
* PREFIX dc: <http://purl.org/dc/elements/1.1/>
* PREFIX foaf: <http://xmlns.com/foaf/0.1/>
*
* SELECT ?X ?Y
* WHERE {
* {
* ?X dc:dogOf ?Y .
* }
* }
*/
RDFSelectQueryResult selectQueryResult = selectQuery.ApplyToGraph(graph);
// EXPORT SELECT QUERY RESULTS TO SPARQL XML FORMAT (FILE)
selectQueryResult.ToSparqlXmlResult(@"C:\TEMP\select_results.srq");
Assert.Equal(1, selectQueryResult.SelectResultsCount);
DataRow row = selectQueryResult.SelectResults.Rows[0];
var dog = row[0].ToString();
var person = row[1].ToString();
Assert.Equal(pluto.URI.ToString(), dog);
Assert.Equal(mickeyMouse.URI.ToString(), person);
/*
* Generates this file content
*
* <?xml version="1.0" encoding="utf-8"?>
* <sparql xmlns="http://www.w3.org/2005/sparql-results#">
* <head>
* <variable name="?X" />
* <variable name="?Y" />
* </head>
* <results>
* <result>
* <binding name="?X">
* <uri>https://en.wikipedia.org/wiki/Pluto_(Disney)</uri>
* </binding>
* <binding name="?Y">
* <uri>https://en.wikipedia.org/wiki/Mickey_Mouse</uri>
* </binding>
* </result>
* </results>
* </sparql>
*/
}
public void Test2()
{
string filePath = GetPath(@"Files\Test1.ttl");
RDFGraph graph = RDFGraph.FromFile(RDFModelEnums.RDFFormats.Turtle, filePath);
RDFSelectQuery selectQuery = new RDFSelectQuery();
selectQuery.AddPrefix(RDFNamespaceRegister.GetByPrefix("foaf"));
var name = new RDFVariable("name");
var friend = new RDFVariable("friend");
var count = new RDFVariable("count");
var person = new RDFVariable("person");
// ?person foaf:name ?name .
var person_foaf_name_name = new RDFPattern(person, RDFVocabulary.FOAF.NAME, name);
// ?person foaf:knows ?friend .
var person_foaf_knows_friend = new RDFPattern(person, RDFVocabulary.FOAF.KNOWS, friend);
var pg1 = new RDFPatternGroup("PG1");
pg1.AddPattern(person_foaf_name_name);
pg1.AddPattern(person_foaf_knows_friend);
selectQuery.AddPatternGroup(pg1);
selectQuery.AddProjectionVariable(name);
//selectQuery.AddProjectionVariable(count);
// GROUP BY ?PERSON ?NAME
// var gm = new RDFGroupByModifier(new List<RDFVariable>() { person, name });
// GROUP BY ?NAME
var gm = new RDFGroupByModifier(new List <RDFVariable>()
{
name
});
// (COUNT(?friend) AS ?count)
gm.AddAggregator(new RDFCountAggregator(friend, count));
selectQuery.AddModifier(gm);
var sparqlCommand = selectQuery.ToString();
#region Target query in the SPARQL 1.1 documentation
/*
* Target query in the document
*
* PREFIX foaf: <http://xmlns.com/foaf/0.1/>
* SELECT ?name (COUNT(?friend) AS ?count)
* WHERE {
* ?person foaf:name ?name .
* ?person foaf:knows ?friend .
* } GROUP BY ?person ?name
*/
#endregion
#region Managed to build this command
/*
* PREFIX foaf: <http://xmlns.com/foaf/0.1/>
*
* SELECT ?NAME (COUNT(?FRIEND) AS ?COUNT)
* WHERE {
* {
* ?PERSON foaf:name ?NAME .
* ?PERSON foaf:knows ?FRIEND .
* }
* }
* GROUP BY ?NAME
*/
#endregion
#region Managed to build this command
/*
* Managed to build this command
*
* PREFIX foaf: <http://xmlns.com/foaf/0.1/>
*
* SELECT ?PERSON ?NAME (COUNT(?FRIEND) AS ?COUNT)
* WHERE {
* {
* ?PERSON foaf:name ?NAME .
* ?PERSON foaf:knows ?FRIEND .
* }
* }
* GROUP BY ?PERSON ?NAME
*/
#endregion
// APPLY SELECT QUERY TO GRAPH
RDFSelectQueryResult selectQueryResult = selectQuery.ApplyToGraph(graph);
// EXPORT SELECT QUERY RESULTS TO SPARQL XML FORMAT (FILE)
//selectQueryResult.ToSparqlXmlResult(@"C:\TEMP\Test2.srq");
#region Got result
/*
* Got result
*
* <?xml version="1.0" encoding="utf-8"?>
* <sparql xmlns="http://www.w3.org/2005/sparql-results#">
* <head>
* <variable name="?NAME" />
* <variable name="?COUNT" />
* </head>
* <results>
* <result>
* <binding name="?NAME">
* <literal>Alice</literal>
* </binding>
* <binding name="?COUNT">
* <literal datatype="http://www.w3.org/2001/XMLSchema#decimal">3</literal>
* </binding>
* </result>
* <result>
* <binding name="?NAME">
* <literal>Bob</literal>
* </binding>
* <binding name="?COUNT">
* <literal datatype="http://www.w3.org/2001/XMLSchema#decimal">1</literal>
* </binding>
* </result>
* <result>
* <binding name="?NAME">
* <literal>Charlie</literal>
* </binding>
* <binding name="?COUNT">
* <literal datatype="http://www.w3.org/2001/XMLSchema#decimal">1</literal>
* </binding>
* </result>
* </results>
* </sparql>
*
*/
#endregion
#region Got result
/*
*
*
* <?xml version="1.0" encoding="utf-8"?>
* <sparql xmlns="http://www.w3.org/2005/sparql-results#">
* <head>
* <variable name="?PERSON" />
* <variable name="?NAME" />
* <variable name="?COUNT" />
* </head>
* <results>
* <result>
* <binding name="?PERSON">
* <uri>http://example.org/alice#me</uri>
* </binding>
* <binding name="?NAME">
* <literal>Alice</literal>
* </binding>
* <binding name="?COUNT">
* <literal datatype="http://www.w3.org/2001/XMLSchema#decimal">3</literal>
* </binding>
* </result>
* <result>
* <binding name="?PERSON">
* <uri>http://example.org/bob#me</uri>
* </binding>
* <binding name="?NAME">
* <literal>Bob</literal>
* </binding>
* <binding name="?COUNT">
* <literal datatype="http://www.w3.org/2001/XMLSchema#decimal">1</literal>
* </binding>
* </result>
* <result>
* <binding name="?PERSON">
* <uri>http://example.org/charlie#me</uri>
* </binding>
* <binding name="?NAME">
* <literal>Charlie</literal>
* </binding>
* <binding name="?COUNT">
* <literal datatype="http://www.w3.org/2001/XMLSchema#decimal">1</literal>
* </binding>
* </result>
* </results>
* </sparql>
*
*/
#endregion
#region Target result from SPARQL 1.1 documentation
/*
* Target result
* 3 Different query results formats supported by SPARQL 1.1 (XML, JSON, CSV, TSV)
*
* <?xml version="1.0"?>
* <sparql xmlns="http://www.w3.org/2005/sparql-results#">
* <head>
* <variable name="name"/>
* <variable name="count"/>
* </head>
* <results>
* <result>
* <binding name="name">
* <literal>Alice</literal>
* </binding>
* <binding name="count">
* <literal datatype="http://www.w3.org/2001/XMLSchema#integer">3</literal>
* </binding>
* </result>
* <result>
* <binding name="name">
* <literal>Bob</literal>
* </binding>
* <binding name="count">
* <literal datatype="http://www.w3.org/2001/XMLSchema#integer">1</literal>
* </binding>
* </result>
* <result>
* <binding name="name">
* <literal>Charlie</literal>
* </binding>
* <binding name="count">
* <literal datatype="http://www.w3.org/2001/XMLSchema#integer">1</literal>
* </binding>
* </result>
* </results>
* </sparql>
*/
#endregion
Assert.Equal(3, selectQueryResult.SelectResultsCount);
}
public void Test1()
{
string filePath = GetPath(@"Files\Test1.ttl");
RDFGraph graph = RDFGraph.FromFile(RDFModelEnums.RDFFormats.Turtle, filePath);
RDFSelectQuery selectQuery = new RDFSelectQuery();
// PREFIX foaf: <http://xmlns.com/foaf/0.1/>
selectQuery.AddPrefix(RDFNamespaceRegister.GetByPrefix("foaf"));
// ?NAME
var name = new RDFVariable("name");
// ?FRIEND
var friend = new RDFVariable("friend");
// ?PERSON
var person = new RDFVariable("person");
// ?PERSON foaf:name ?NAME .
var person_foaf_name_name = new RDFPattern(person, RDFVocabulary.FOAF.NAME, name);
// ?PERSON foaf:knows ?FRIEND .
var person_foaf_knows_friend = new RDFPattern(person, RDFVocabulary.FOAF.KNOWS, friend);
// WHERE {
// {
// ?PERSON foaf:name? NAME .
// ?PERSON foaf:knows? FRIEND .
// }
// }
var pg1 = new RDFPatternGroup("PG1");
pg1.AddPattern(person_foaf_name_name);
pg1.AddPattern(person_foaf_knows_friend);
selectQuery.AddPatternGroup(pg1);
// SELECT ?PERSON ?NAME ?FRIEND
selectQuery.AddProjectionVariable(person);
selectQuery.AddProjectionVariable(name);
selectQuery.AddProjectionVariable(friend);
var sparqlCommand = selectQuery.ToString();
#region Generated SPARQL command
/*
* Generates this sparql command
*
* PREFIX foaf: <http://xmlns.com/foaf/0.1/>
*
* SELECT ?PERSON ?NAME ?FRIEND
* WHERE {
* {
* ?PERSON foaf:name ?NAME .
* ?PERSON foaf:knows ?FRIEND .
* }
* }
*
*/
#endregion
// APPLY SELECT QUERY TO GRAPH
RDFSelectQueryResult selectQueryResult = selectQuery.ApplyToGraph(graph);
// EXPORT SELECT QUERY RESULTS TO SPARQL XML FORMAT (FILE)
//selectQueryResult.ToSparqlXmlResult(@"C:\TEMP\Test1.srq");
#region Generated result file
/*
* <?xml version="1.0" encoding="utf-8"?>
* <sparql xmlns="http://www.w3.org/2005/sparql-results#">
* <head>
* <variable name="?PERSON" />
* <variable name="?NAME" />
* <variable name="?FRIEND" />
* </head>
* <results>
* <result>
* <binding name="?PERSON">
* <uri>http://example.org/alice#me</uri>
* </binding>
* <binding name="?NAME">
* <literal>Alice</literal>
* </binding>
* <binding name="?FRIEND">
* <uri>http://example.org/bob#me</uri>
* </binding>
* </result>
* <result>
* <binding name="?PERSON">
* <uri>http://example.org/alice#me</uri>
* </binding>
* <binding name="?NAME">
* <literal>Alice</literal>
* </binding>
* <binding name="?FRIEND">
* <uri>http://example.org/charlie#me</uri>
* </binding>
* </result>
* <result>
* <binding name="?PERSON">
* <uri>http://example.org/alice#me</uri>
* </binding>
* <binding name="?NAME">
* <literal>Alice</literal>
* </binding>
* <binding name="?FRIEND">
* <uri>http://example.org/snoopy</uri>
* </binding>
* </result>
* <result>
* <binding name="?PERSON">
* <uri>http://example.org/bob#me</uri>
* </binding>
* <binding name="?NAME">
* <literal>Bob</literal>
* </binding>
* <binding name="?FRIEND">
* <uri>http://example.org/alice#me</uri>
* </binding>
* </result>
* <result>
* <binding name="?PERSON">
* <uri>http://example.org/charlie#me</uri>
* </binding>
* <binding name="?NAME">
* <literal>Charlie</literal>
* </binding>
* <binding name="?FRIEND">
* <uri>http://example.org/alice#me</uri>
* </binding>
* </result>
* </results>
* </sparql>
*/
#endregion
Assert.Equal(5, selectQueryResult.SelectResultsCount);
}
