/// <summary>
/// Apply the filters of the given pattern group to its result table
/// </summary>
internal static void ApplyFilters(RDFSelectQuery query, RDFPatternGroup patternGroup)
{
if (patternGroup.Patterns.Any() && patternGroup.Filters.Any())
{
DataTable filteredTable = query.PatternGroupResultTables[patternGroup].Clone();
IEnumerator rowsEnum = query.PatternGroupResultTables[patternGroup].Rows.GetEnumerator();
//Iterate the rows of the pattern group's result table
Boolean keepRow = false;
while (rowsEnum.MoveNext())
{
//Apply the pattern group's filters on the row
keepRow = true;
IEnumerator <RDFFilter> filtersEnum = patternGroup.Filters.GetEnumerator();
while (keepRow && filtersEnum.MoveNext())
{
keepRow = filtersEnum.Current.ApplyFilter((DataRow)rowsEnum.Current, false);
}
//If the row has passed all the filters, keep it in the filtered result table
if (keepRow)
{
DataRow newRow = filteredTable.NewRow();
newRow.ItemArray = ((DataRow)rowsEnum.Current).ItemArray;
filteredTable.Rows.Add(newRow);
}
}
//Save results datatable
query.PatternGroupResultTables[patternGroup] = filteredTable;
}
}
/// <summary>
/// Apply the filters of the given pattern group to its result table
/// </summary>
internal static void ApplyFilters(RDFSelectQuery query, RDFPatternGroup patternGroup) {
if (patternGroup.Patterns.Any() && patternGroup.Filters.Any()) {
DataTable filteredTable = query.PatternGroupResultTables[patternGroup].Clone();
IEnumerator rowsEnum = query.PatternGroupResultTables[patternGroup].Rows.GetEnumerator();
//Iterate the rows of the pattern group's result table
Boolean keepRow = false;
while (rowsEnum.MoveNext()) {
//Apply the pattern group's filters on the row
keepRow = true;
IEnumerator<RDFFilter> filtersEnum = patternGroup.Filters.GetEnumerator();
while (keepRow && filtersEnum.MoveNext()) {
keepRow = filtersEnum.Current.ApplyFilter((DataRow)rowsEnum.Current, false);
}
//If the row has passed all the filters, keep it in the filtered result table
if (keepRow) {
DataRow newRow = filteredTable.NewRow();
newRow.ItemArray = ((DataRow)rowsEnum.Current).ItemArray;
filteredTable.Rows.Add(newRow);
}
}
//Save results datatable
query.PatternGroupResultTables[patternGroup] = filteredTable;
}
}
/// <summary>
/// Get the result table of the given pattern group
/// </summary>
internal static void CombinePatterns(RDFSelectQuery query, RDFPatternGroup patternGroup)
{
if (patternGroup.Patterns.Any())
{
//Populate pattern group result table
DataTable patternGroupResultTable = RDFQueryEngine.CombineTables(query.PatternResultTables[patternGroup], false);
//Add it to the list of pattern group result tables
query.PatternGroupResultTables.Add(patternGroup, patternGroupResultTable);
//Populate its metadata
query.PatternGroupResultTables[patternGroup].TableName = patternGroup.ToString();
if (!query.PatternGroupResultTables[patternGroup].ExtendedProperties.ContainsKey("IsOptional"))
{
query.PatternGroupResultTables[patternGroup].ExtendedProperties.Add("IsOptional", patternGroup.IsOptional);
}
else
{
query.PatternGroupResultTables[patternGroup].ExtendedProperties["IsOptional"] = patternGroup.IsOptional;
}
if (!query.PatternGroupResultTables[patternGroup].ExtendedProperties.ContainsKey("JoinAsUnion"))
{
query.PatternGroupResultTables[patternGroup].ExtendedProperties.Add("JoinAsUnion", patternGroup.JoinAsUnion);
}
else
{
query.PatternGroupResultTables[patternGroup].ExtendedProperties["JoinAsUnion"] = patternGroup.JoinAsUnion;
}
}
}
/// <summary>
/// Adds the given subquery to the query
/// </summary>
public RDFDescribeQuery AddSubQuery(RDFSelectQuery subQuery)
{
if (subQuery != null)
{
if (!this.GetSubQueries().Any(q => q.Equals(subQuery)))
{
this.QueryMembers.Add(subQuery.SubQuery());
}
}
return(this);
}
/// <summary>
/// Apply the query modifiers to the query result table
/// </summary>
internal static DataTable ApplyModifiers(RDFSelectQuery query, DataTable table)
{
String tblnmBak = table.TableName;
//Apply the ORDERBY modifiers
table = query.Modifiers.Where(m => m is RDFOrderByModifier)
.Aggregate(table, (current, modifier) => modifier.ApplyModifier(current));
table = table.DefaultView.ToTable();
//Apply the PROJECTION operator
List <String> nonProjCols = new List <String>();
query.PatternGroups.ForEach(pg =>
pg.Variables.ForEach(v => {
if (!query.IsStar && !v.IsResult)
{
if (!nonProjCols.Exists(npc => npc.Equals(v.VariableName, StringComparison.Ordinal)))
{
nonProjCols.Add(v.VariableName);
}
}
})
);
nonProjCols.ForEach(c => {
if (table.Columns.Contains(c))
{
table.Columns.Remove(c);
}
});
//Apply the DISTINCT modifier
table = query.Modifiers.Where(m => m is RDFDistinctModifier)
.Aggregate(table, (current, modifier) => modifier.ApplyModifier(current));
//Apply the OFFSET modifier
table = query.Modifiers.Where(m => m is RDFOffsetModifier)
.Aggregate(table, (current, modifier) => modifier.ApplyModifier(current));
//Apply the LIMIT modifier
table = query.Modifiers.Where(m => m is RDFLimitModifier)
.Aggregate(table, (current, modifier) => modifier.ApplyModifier(current));
table.TableName = tblnmBak;
return(table);
}
/// <summary>
/// Get the intermediate result tables of the given pattern group
/// </summary>
internal static void EvaluatePatterns(RDFSelectQuery query, RDFPatternGroup patternGroup, Object graphOrStore) {
query.PatternResultTables[patternGroup] = new List<DataTable>();
//Iterate over the patterns of the pattern group
foreach (RDFPattern pattern in patternGroup.Patterns) {
//Apply the pattern to the graph/store
DataTable patternResultsTable = graphOrStore is RDFGraph ? RDFQueryEngine.ApplyPattern(pattern, (RDFGraph)graphOrStore)
: RDFQueryEngine.ApplyPattern(pattern, (RDFStore)graphOrStore);
//Set the name and the optionality metadata of the result datatable
patternResultsTable.TableName = pattern.ToString();
patternResultsTable.ExtendedProperties.Add("IsOptional", pattern.IsOptional);
patternResultsTable.ExtendedProperties.Add("JoinAsUnion", pattern.JoinAsUnion);
//Save results datatable
query.PatternResultTables[patternGroup].Add(patternResultsTable);
}
}
/// <summary>
/// Get the intermediate result tables of the given pattern group
/// </summary>
internal static void EvaluatePatterns(RDFSelectQuery query, RDFPatternGroup patternGroup, Object graphOrStore)
{
query.PatternResultTables[patternGroup] = new List <DataTable>();
//Iterate over the patterns of the pattern group
foreach (RDFPattern pattern in patternGroup.Patterns)
{
//Apply the pattern to the graph/store
DataTable patternResultsTable = graphOrStore is RDFGraph?RDFQueryEngine.ApplyPattern(pattern, (RDFGraph)graphOrStore)
: RDFQueryEngine.ApplyPattern(pattern, (RDFStore)graphOrStore);
//Set the name and the optionality metadata of the result datatable
patternResultsTable.TableName = pattern.ToString();
patternResultsTable.ExtendedProperties.Add("IsOptional", pattern.IsOptional);
patternResultsTable.ExtendedProperties.Add("JoinAsUnion", pattern.JoinAsUnion);
//Save results datatable
query.PatternResultTables[patternGroup].Add(patternResultsTable);
}
}
/// <summary>
/// Prints the string representation of a SPARQL SELECT query
/// </summary>
internal static String PrintSelectQuery(RDFSelectQuery selectQuery, Double indentLevel, Boolean fromUnion)
{
StringBuilder sb = new StringBuilder();
if (selectQuery != null)
{
#region INDENT
Int32 subqueryHeaderSpacesFunc(Double indLevel)
{
return(subqueryBodySpacesFunc(indentLevel) - 2 < 0 ? 0 : subqueryBodySpacesFunc(indentLevel) - 2);
}
Int32 subqueryBodySpacesFunc(Double indLevel)
{
return(Convert.ToInt32(4 * indentLevel));
}
Int32 subqueryUnionSpacesFunc(Boolean union)
{
return(union ? 2 : 0);
}
String subquerySpaces = new String(' ', subqueryHeaderSpacesFunc(indentLevel) + subqueryUnionSpacesFunc(fromUnion));
String subqueryBodySpaces = new String(' ', subqueryBodySpacesFunc(indentLevel) + subqueryUnionSpacesFunc(fromUnion));
#endregion
#region PREFIX
if (!selectQuery.IsSubQuery)
{
if (selectQuery.Prefixes.Any())
{
selectQuery.Prefixes.ForEach(pf =>
{
sb.Append("PREFIX " + pf.NamespacePrefix + ": <" + pf.NamespaceUri + ">\n");
});
sb.Append("\n");
}
}
#endregion
#region HEADER
#region BEGINSELECT
if (selectQuery.IsSubQuery)
{
if (selectQuery.IsOptional && !fromUnion)
{
sb.Append(subquerySpaces + "OPTIONAL {\n");
}
else
{
sb.Append(subquerySpaces + "{\n");
}
}
sb.Append(subqueryBodySpaces + "SELECT");
#endregion
#region DISTINCT
selectQuery.GetModifiers()
.Where(mod => mod is RDFDistinctModifier)
.ToList()
.ForEach(dm => sb.Append(" " + dm));
#endregion
#region VARIABLES
if (selectQuery.ProjectionVars.Any())
{
selectQuery.ProjectionVars.OrderBy(x => x.Value)
.ToList()
.ForEach(v => sb.Append(" " + v.Key));
}
else
{
sb.Append(" *");
}
sb.Append("\n");
#endregion
#endregion
#region BODY
sb.Append(subqueryBodySpaces + "WHERE {\n");
#region MEMBERS
Boolean printingUnion = false;
List <RDFQueryMember> evaluableQueryMembers = selectQuery.GetEvaluableQueryMembers().ToList();
RDFQueryMember lastQueryMbr = evaluableQueryMembers.LastOrDefault();
foreach (var queryMember in evaluableQueryMembers)
{
#region PATTERNGROUPS
if (queryMember is RDFPatternGroup)
{
//Current pattern group is set as UNION with the next one
if (((RDFPatternGroup)queryMember).JoinAsUnion)
{
//Current pattern group IS NOT the last of the query
//(so UNION keyword must be appended at last)
if (!queryMember.Equals(lastQueryMbr))
{
//Begin a new Union block
if (!printingUnion)
{
printingUnion = true;
sb.Append(subqueryBodySpaces + " {\n");
}
sb.Append(PrintPatternGroup((RDFPatternGroup)queryMember, subqueryBodySpaces.Length + 2, true, selectQuery.Prefixes));
sb.Append(subqueryBodySpaces + " UNION\n");
}
//Current pattern group IS the last of the query
//(so UNION keyword must not be appended at last)
else
{
//End the Union block
if (printingUnion)
{
printingUnion = false;
sb.Append(PrintPatternGroup((RDFPatternGroup)queryMember, subqueryBodySpaces.Length + 2, true, selectQuery.Prefixes));
sb.Append(subqueryBodySpaces + " }\n");
}
else
{
sb.Append(PrintPatternGroup((RDFPatternGroup)queryMember, subqueryBodySpaces.Length, false, selectQuery.Prefixes));
}
}
}
//Current pattern group is set as INTERSECT with the next one
else
{
//End the Union block
if (printingUnion)
{
printingUnion = false;
sb.Append(PrintPatternGroup((RDFPatternGroup)queryMember, subqueryBodySpaces.Length + 2, true, selectQuery.Prefixes));
sb.Append(subqueryBodySpaces + " }\n");
}
else
{
sb.Append(PrintPatternGroup((RDFPatternGroup)queryMember, subqueryBodySpaces.Length, false, selectQuery.Prefixes));
}
}
}
#endregion
#region SUBQUERY
else if (queryMember is RDFQuery)
{
//Merge main query prefixes
selectQuery.Prefixes.ForEach(pf1 => {
if (!((RDFSelectQuery)queryMember).Prefixes.Any(pf2 => pf2.Equals(pf1)))
{
((RDFSelectQuery)queryMember).AddPrefix(pf1);
}
});
//Current subquery is set as UNION with the next one
if (((RDFSelectQuery)queryMember).JoinAsUnion)
{
//Current subquery IS NOT the last of the query
//(so UNION keyword must be appended at last)
if (!queryMember.Equals(lastQueryMbr))
{
//Begin a new Union block
if (!printingUnion)
{
printingUnion = true;
sb.Append(subqueryBodySpaces + " {\n");
}
sb.Append(PrintSelectQuery((RDFSelectQuery)queryMember, indentLevel + 1 + (fromUnion ? 0.5 : 0), true));
sb.Append(subqueryBodySpaces + " UNION\n");
}
//Current query IS the last of the query
//(so UNION keyword must not be appended at last)
else
{
//End the Union block
if (printingUnion)
{
printingUnion = false;
sb.Append(PrintSelectQuery((RDFSelectQuery)queryMember, indentLevel + 1 + (fromUnion ? 0.5 : 0), true));
sb.Append(subqueryBodySpaces + " }\n");
}
else
{
sb.Append(PrintSelectQuery((RDFSelectQuery)queryMember, indentLevel + 1 + (fromUnion ? 0.5 : 0), false));
}
}
}
//Current query is set as INTERSECT with the next one
else
{
//End the Union block
if (printingUnion)
{
printingUnion = false;
sb.Append(PrintSelectQuery((RDFSelectQuery)queryMember, indentLevel + 1 + (fromUnion ? 0.5 : 0), true));
sb.Append(subqueryBodySpaces + " }\n");
}
else
{
sb.Append(PrintSelectQuery((RDFSelectQuery)queryMember, indentLevel + 1 + (fromUnion ? 0.5 : 0), false));
}
}
}
#endregion
}
#endregion
sb.Append(subqueryBodySpaces + "}");
#endregion
#region FOOTER
#region MODIFIERS
List <RDFModifier> modifiers = selectQuery.GetModifiers().ToList();
// ORDER BY
if (modifiers.Any(mod => mod is RDFOrderByModifier))
{
sb.Append("\n");
sb.Append(subqueryBodySpaces + "ORDER BY");
modifiers.Where(mod => mod is RDFOrderByModifier)
.ToList()
.ForEach(om => sb.Append(" " + om));
}
// LIMIT/OFFSET
if (modifiers.Any(mod => mod is RDFLimitModifier || mod is RDFOffsetModifier))
{
modifiers.Where(mod => mod is RDFLimitModifier)
.ToList()
.ForEach(lim => { sb.Append("\n"); sb.Append(subqueryBodySpaces + lim); });
modifiers.Where(mod => mod is RDFOffsetModifier)
.ToList()
.ForEach(off => { sb.Append("\n"); sb.Append(subqueryBodySpaces + off); });
}
#endregion
#region ENDSELECT
sb.Append("\n");
if (selectQuery.IsSubQuery)
{
sb.Append(subquerySpaces + "}\n");
}
#endregion
#endregion
}
return(sb.ToString());
}
/// <summary>
/// Apply the query modifiers to the query result table
/// </summary>
internal static DataTable ApplyModifiers(RDFSelectQuery query, DataTable table) {
String tblnmBak = table.TableName;
//Apply the ORDERBY modifiers
table = query.Modifiers.Where(m => m is RDFOrderByModifier)
.Aggregate(table, (current, modifier) => modifier.ApplyModifier(current));
table = table.DefaultView.ToTable();
//Apply the PROJECTION operator
List<String> nonProjCols = new List<String>();
query.PatternGroups.ForEach(pg =>
pg.Variables.ForEach(v => {
if (!query.IsStar && !v.IsResult) {
if (!nonProjCols.Exists(npc => npc.Equals(v.VariableName, StringComparison.Ordinal))) {
nonProjCols.Add(v.VariableName);
}
}
})
);
nonProjCols.ForEach(c => {
if (table.Columns.Contains(c)) {
table.Columns.Remove(c);
}
});
//Apply the DISTINCT modifier
table = query.Modifiers.Where(m => m is RDFDistinctModifier)
.Aggregate(table, (current, modifier) => modifier.ApplyModifier(current));
//Apply the OFFSET modifier
table = query.Modifiers.Where(m => m is RDFOffsetModifier)
.Aggregate(table, (current, modifier) => modifier.ApplyModifier(current));
//Apply the LIMIT modifier
table = query.Modifiers.Where(m => m is RDFLimitModifier)
.Aggregate(table, (current, modifier) => modifier.ApplyModifier(current));
table.TableName = tblnmBak;
return table;
}
/// <summary>
/// Get the result table of the given pattern group
/// </summary>
internal static void CombinePatterns(RDFSelectQuery query, RDFPatternGroup patternGroup) {
if (patternGroup.Patterns.Any()) {
//Populate pattern group result table
DataTable patternGroupResultTable = RDFQueryEngine.CombineTables(query.PatternResultTables[patternGroup], false);
//Add it to the list of pattern group result tables
query.PatternGroupResultTables.Add(patternGroup, patternGroupResultTable);
//Populate its metadata
query.PatternGroupResultTables[patternGroup].TableName = patternGroup.ToString();
if (!query.PatternGroupResultTables[patternGroup].ExtendedProperties.ContainsKey("IsOptional")) {
query.PatternGroupResultTables[patternGroup].ExtendedProperties.Add("IsOptional", patternGroup.IsOptional);
}
else {
query.PatternGroupResultTables[patternGroup].ExtendedProperties["IsOptional"] = patternGroup.IsOptional;
}
if (!query.PatternGroupResultTables[patternGroup].ExtendedProperties.ContainsKey("JoinAsUnion")) {
query.PatternGroupResultTables[patternGroup].ExtendedProperties.Add("JoinAsUnion", patternGroup.JoinAsUnion);
}
else {
query.PatternGroupResultTables[patternGroup].ExtendedProperties["JoinAsUnion"] = patternGroup.JoinAsUnion;
}
}
}
protected void GetRDF()
{
try
{
// First we set some core RDF resources
// agent refers to artist(s)
RDFResource type = RDFVocabulary.RDF.TYPE;
RDFResource name = RDFVocabulary.FOAF.NAME;
RDFResource agent = RDFVocabulary.FOAF.AGENT;
// TGN is a Getty vocabulary for locations
// TGN added to RDFSharp vocabularies manually. TGN ID is stored in TMSThes (or equivalent in TMS 2014+)
RDFResource tgn = new RDFResource(RDFVocabulary.TGN.BASE_URI);
// The predicates below are often part of ULAN (which we don't have)
// unsure if using bio events this way is acceptable...
RDFResource livedIn = new RDFResource("http://purl.org/vocab/bio/0.1/event/livedIn");
RDFResource activeIn = new RDFResource("http://purl.org/vocab/bio/0.1/event/activeIn");
RDFResource educatedIn = new RDFResource("http://purl.org/vocab/bio/0.1/event/educatedIn");
RDFResource bornIn = new RDFResource("http://purl.org/vocab/bio/0.1/event/bornIn");
RDFResource diedIn = new RDFResource("http://purl.org/vocab/bio/0.1/event/diedIn");
RDFResource anUri = new RDFResource("http://example.org/uris#anUri");
// Create variables
RDFVariable x = new RDFVariable("x", true);
RDFVariable y = new RDFVariable("y", true);
RDFVariable n = new RDFVariable("n", true);
RDFVariable h = new RDFVariable("h", true);
RDFVariable p = new RDFVariable("p", true);
string m_select = DropDownList1.Text;
string m_filter = TextBox1.Text;
RDFResource m_sparql_resource = livedIn;
if (m_select == "livedIn")
{
m_sparql_resource = livedIn;
}
if (m_select == "activeIn")
{
m_sparql_resource = activeIn;
}
if (m_select == "educatedIn")
{
m_sparql_resource = educatedIn;
}
if (m_select == "bornIn")
{
m_sparql_resource = bornIn;
}
if (m_select == "diedIn")
{
m_sparql_resource = diedIn;
}
// Create Sparql Select query
RDFSelectQuery q1 = new RDFSelectQuery()
.AddPatternGroup(new RDFPatternGroup("TmsPatternGroup")
.AddPattern(new RDFPattern(y, m_sparql_resource, x))
.AddPattern(new RDFPattern(x, type, tgn))
.AddPattern(new RDFPattern(y, name, h).Optional())
.AddPattern(new RDFPattern(x, name, n).Optional())
.AddFilter(new RDFRegexFilter(n, new Regex(m_filter, RegexOptions.IgnoreCase))))
.AddModifier(new RDFDistinctModifier());
// Apply query
string m_conn = ConfigurationManager.ConnectionStrings["RDFConnectionString"].ConnectionString;
RDFSQLServerStore rdf_mssql = new RDFSQLServerStore(m_conn);
RDFSelectQueryResult res = q1.ApplyToStore(rdf_mssql);
Label1.Text = "RESULTS: " + res.SelectResultsCount + "\n\n" + q1;
GridView1.DataSource = res.SelectResults;
GridView1.DataBind();
}
catch (Exception ex)
{
string m_debug = ex.Message;
}
}
/// <summary>
/// Compacts the reified quadruples by removing their 4 standard statements
/// </summary>
public override void UnreifyQuadruples()
{
//Create SPARQL SELECT query for detecting reified quadruples
var T = new RDFVariable("T");
var C = new RDFVariable("C");
var S = new RDFVariable("S");
var P = new RDFVariable("P");
var O = new RDFVariable("O");
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));
}
}
}
