/// <summary>
/// Default-ctor to build a filter on the given variable for the given datatype
/// </summary>
public RDFDatatypeFilter(RDFVariable variable, RDFModelEnums.RDFDatatypes datatype)
{
if (variable != null)
{
this.Variable = variable;
this.Datatype = datatype;
}
else
{
throw new RDFQueryException("Cannot create RDFDatatypeFilter because given \"variable\" parameter is null.");
}
}
/// <summary>
/// Default-ctor to build a typed literal with given value and given datatype.
/// Semantic validation of given value against given datatype is performed.
/// </summary>
public RDFTypedLiteral(String value, RDFModelEnums.RDFDatatypes datatype)
{
this.Value = (value ?? String.Empty);
this.Datatype = datatype;
if (RDFModelUtilities.ValidateTypedLiteral(this))
{
this.PatternMemberID = RDFModelUtilities.CreateHash(this.ToString());
}
else
{
throw new RDFModelException("Cannot create RDFTypedLiteral because given \"value\" parameter (" + value + ") is not well-formed against given \"datatype\" parameter (" + RDFModelUtilities.GetDatatypeFromEnum(datatype) + ")");
}
}
/// <summary>
/// Default-ctor to build a typed literal with given value and given datatype.
/// Semantic validation of given value against given datatype is performed.
/// </summary>
public RDFTypedLiteral(string value, RDFModelEnums.RDFDatatypes datatype)
{
this.Value = value ?? string.Empty;
this.Datatype = datatype;
//Validation against semantic of given datatype
if (RDFModelUtilities.ValidateTypedLiteral(this))
{
this.SetLazyPatternMemberID();
}
else
{
throw new RDFModelException("Cannot create RDFTypedLiteral because given \"value\" parameter (" + value + ") is not well-formed against given \"datatype\" parameter (" + RDFModelUtilities.GetDatatypeFromEnum(datatype) + ")");
}
}
/// <summary>
/// Parses the current quadruple of the data reader
/// </summary>
internal static RDFQuadruple ParseQuadruple(IDataReader fetchedQuadruples)
{
if (fetchedQuadruples != null)
{
RDFContext qContext = new RDFContext(fetchedQuadruples["Context"].ToString());
RDFResource qSubject = new RDFResource(fetchedQuadruples["Subject"].ToString());
RDFResource qPredicate = new RDFResource(fetchedQuadruples["Predicate"].ToString());
//SPO-flavour quadruple
if (fetchedQuadruples["TripleFlavor"].ToString().Equals("1"))
{
RDFResource qObject = new RDFResource(fetchedQuadruples["Object"].ToString());
return(new RDFQuadruple(qContext, qSubject, qPredicate, qObject));
}
//SPL-flavour quadruple
string literal = fetchedQuadruples["Object"].ToString();
//PlainLiteral
int lastIndexOfDatatype = literal.LastIndexOf("^^", StringComparison.OrdinalIgnoreCase);
int lastIndexOfLanguage = literal.LastIndexOf("@", StringComparison.OrdinalIgnoreCase);
if (!literal.Contains("^^") ||
literal.EndsWith("^^") ||
RDFModelUtilities.GetUriFromString(literal.Substring(lastIndexOfDatatype + 2)) == null)
{
RDFPlainLiteral pLit = null;
if (RDFNTriples.regexLPL.Match(literal).Success)
{
string pLitValue = literal.Substring(0, lastIndexOfLanguage);
string pLitLang = literal.Substring(lastIndexOfLanguage + 1);
pLit = new RDFPlainLiteral(pLitValue, pLitLang);
}
else
{
pLit = new RDFPlainLiteral(literal);
}
return(new RDFQuadruple(qContext, qSubject, qPredicate, pLit));
}
//TypedLiteral
string tLitValue = literal.Substring(0, lastIndexOfDatatype);
string tLitDatatype = literal.Substring(lastIndexOfDatatype + 2);
RDFModelEnums.RDFDatatypes dt = RDFModelUtilities.GetDatatypeFromString(tLitDatatype);
RDFTypedLiteral tLit = new RDFTypedLiteral(tLitValue, dt);
return(new RDFQuadruple(qContext, qSubject, qPredicate, tLit));
}
throw new RDFStoreException("Cannot parse quadruple because given \"fetchedQuadruples\" parameter is null.");
}
/// <summary>
/// Parses the given string to return an instance of pattern member
/// </summary>
internal static RDFPatternMember ParseRDFPatternMember(string pMember)
{
if (pMember == null)
{
throw new RDFQueryException("Cannot parse pattern member because given \"pMember\" parameter is null.");
}
#region Uri
if (Uri.TryCreate(pMember, UriKind.Absolute, out _))
{
return(new RDFResource(pMember));
}
#endregion
#region Plain Literal
int lastIndexOfDatatype = pMember.LastIndexOf("^^", StringComparison.OrdinalIgnoreCase);
int lastIndexOfLanguage = pMember.LastIndexOf("@", StringComparison.OrdinalIgnoreCase);
if (!pMember.Contains("^^") ||
pMember.EndsWith("^^") ||
RDFModelUtilities.GetUriFromString(pMember.Substring(lastIndexOfDatatype + 2)) == null)
{
RDFPlainLiteral pLit = null;
if (RDFNTriples.regexLPL.Match(pMember).Success)
{
string pLitVal = pMember.Substring(0, lastIndexOfLanguage);
string pLitLng = pMember.Substring(lastIndexOfLanguage + 1);
pLit = new RDFPlainLiteral(pLitVal, pLitLng);
}
else
{
pLit = new RDFPlainLiteral(pMember);
}
return(pLit);
}
#endregion
#region Typed Literal
string tLitValue = pMember.Substring(0, lastIndexOfDatatype);
string tLitDatatype = pMember.Substring(lastIndexOfDatatype + 2);
RDFModelEnums.RDFDatatypes dt = RDFModelUtilities.GetDatatypeFromString(tLitDatatype);
RDFTypedLiteral tLit = new RDFTypedLiteral(tLitValue, dt);
return(tLit);
#endregion
}
/// <summary>
/// Deserializes the given N-Quads stream to a memory store.
/// </summary>
internal static RDFMemoryStore Deserialize(Stream inputStream)
{
long nquadIndex = 0;
try
{
#region deserialize
using (StreamReader sr = new StreamReader(inputStream, Encoding.ASCII))
{
RDFMemoryStore result = new RDFMemoryStore();
string nquad = string.Empty;
string[] tokens = new string[4];
RDFResource S = null;
RDFResource P = null;
RDFResource O = null;
RDFLiteral L = null;
RDFContext C = new RDFContext();
while ((nquad = sr.ReadLine()) != null)
{
nquadIndex++;
#region sanitize & tokenize
//Cleanup previous data
S = null;
tokens[0] = string.Empty;
P = null;
tokens[1] = string.Empty;
O = null;
L = null;
tokens[2] = string.Empty;
C = new RDFContext();
tokens[3] = string.Empty;
//Preliminary sanitizations: clean trailing space-like chars
nquad = nquad.Trim(new char[] { ' ', '\t', '\r', '\n' });
//Skip empty or comment lines
if (nquad == string.Empty || nquad.StartsWith("#"))
{
continue;
}
//Tokenizes the sanitized quad
tokens = TokenizeNQuad(nquad);
#endregion
#region subj
string subj = tokens[0].TrimStart(new char[] { '<' })
.TrimEnd(new char[] { '>' })
.Replace("_:", "bnode:");
S = new RDFResource(RDFModelUtilities.ASCII_To_Unicode(subj));
#endregion
#region pred
string pred = tokens[1].TrimStart(new char[] { '<' })
.TrimEnd(new char[] { '>' });
P = new RDFResource(RDFModelUtilities.ASCII_To_Unicode(pred));
#endregion
#region object
if (tokens[2].StartsWith("<") ||
tokens[2].StartsWith("bnode:") ||
tokens[2].StartsWith("_:"))
{
string obj = tokens[2].TrimStart(new char[] { '<' })
.TrimEnd(new char[] { '>' })
.Replace("_:", "bnode:")
.Trim(new char[] { ' ', '\n', '\t', '\r' });
O = new RDFResource(RDFModelUtilities.ASCII_To_Unicode(obj));
}
#endregion
#region literal
else
{
#region sanitize
tokens[2] = RDFNTriples.regexSqt.Replace(tokens[2], string.Empty);
tokens[2] = RDFNTriples.regexEqt.Replace(tokens[2], string.Empty);
tokens[2] = tokens[2].Replace("\\\\", "\\")
.Replace("\\\"", "\"")
.Replace("\\n", "\n")
.Replace("\\t", "\t")
.Replace("\\r", "\r");
tokens[2] = RDFModelUtilities.ASCII_To_Unicode(tokens[2]);
#endregion
#region plain literal
if (!tokens[2].Contains("^^") ||
tokens[2].EndsWith("^^") ||
tokens[2].Substring(tokens[2].LastIndexOf("^^", StringComparison.Ordinal) + 2, 1) != "<")
{
if (RDFNTriples.regexLPL.Match(tokens[2]).Success)
{
tokens[2] = tokens[2].Replace("\"@", "@");
int lastIndexOfLanguage = tokens[2].LastIndexOf("@", StringComparison.OrdinalIgnoreCase);
string pLitValue = tokens[2].Substring(0, lastIndexOfLanguage);
string pLitLang = tokens[2].Substring(lastIndexOfLanguage + 1);
L = new RDFPlainLiteral(HttpUtility.HtmlDecode(pLitValue), pLitLang);
}
else
{
L = new RDFPlainLiteral(HttpUtility.HtmlDecode(tokens[2]));
}
}
#endregion
#region typed literal
else
{
tokens[2] = tokens[2].Replace("\"^^", "^^");
int lastIndexOfDatatype = tokens[2].LastIndexOf("^^", StringComparison.OrdinalIgnoreCase);
string tLitValue = tokens[2].Substring(0, lastIndexOfDatatype);
string tLitDatatype = tokens[2].Substring(lastIndexOfDatatype + 2)
.TrimStart(new char[] { '<' })
.TrimEnd(new char[] { '>' });
RDFModelEnums.RDFDatatypes dt = RDFModelUtilities.GetDatatypeFromString(tLitDatatype);
L = new RDFTypedLiteral(HttpUtility.HtmlDecode(tLitValue), dt);
}
#endregion
}
#endregion
#region context
if (!string.IsNullOrEmpty(tokens[3]))
{
string ctx = tokens[3].TrimStart(new char[] { '<' })
.TrimEnd(new char[] { '>' });
Uri ctxUri = null;
if (Uri.TryCreate(ctx, UriKind.Absolute, out ctxUri))
{
C = new RDFContext(RDFModelUtilities.ASCII_To_Unicode(ctxUri.ToString()));
}
else
{
throw new RDFModelException("found context '" + ctx + "' which is not a well-formed absolute Uri");
}
}
#endregion
#region addquadruple
if (O != null)
{
result.AddQuadruple(new RDFQuadruple(C, S, P, O));
}
else
{
result.AddQuadruple(new RDFQuadruple(C, S, P, L));
}
#endregion
}
return(result);
}
#endregion
}
catch (Exception ex)
{
throw new RDFModelException("Cannot deserialize N-Quads (line " + nquadIndex + ") because: " + ex.Message, ex);
}
}
/// <summary>
/// Deserializes the given N-Triples stream to a graph.
/// </summary>
internal static RDFGraph Deserialize(Stream inputStream)
{
Int64 ntripleIndex = 0;
try
{
#region deserialize
using (StreamReader sr = new StreamReader(inputStream, Encoding.ASCII))
{
RDFGraph result = new RDFGraph();
String ntriple = String.Empty;
String[] tokens = new String[3];
RDFResource S = null;
RDFResource P = null;
RDFResource O = null;
RDFLiteral L = null;
while ((ntriple = sr.ReadLine()) != null)
{
ntripleIndex++;
#region sanitize & tokenize
//Cleanup previous data
S = null;
tokens[0] = String.Empty;
P = null;
tokens[1] = String.Empty;
O = null;
L = null;
tokens[2] = String.Empty;
//Preliminary sanitizations: clean trailing space-like chars
ntriple = ntriple.Trim(new Char[] { ' ', '\t', '\r', '\n' });
//Skip empty or comment lines
if (ntriple == String.Empty || ntriple.StartsWith("#"))
{
continue;
}
//Tokenizes the sanitized triple
tokens = TokenizeNTriple(ntriple);
#endregion
#region subj
String subj = tokens[0].TrimStart(new Char[] { '<' })
.TrimEnd(new Char[] { '>' })
.Replace("_:", "bnode:");
S = new RDFResource(RDFModelUtilities.ASCII_To_Unicode(subj));
#endregion
#region pred
String pred = tokens[1].TrimStart(new Char[] { '<' })
.TrimEnd(new Char[] { '>' });
P = new RDFResource(RDFModelUtilities.ASCII_To_Unicode(pred));
#endregion
#region object
if (tokens[2].StartsWith("<") ||
tokens[2].StartsWith("bnode:") ||
tokens[2].StartsWith("_:"))
{
String obj = tokens[2].TrimStart(new Char[] { '<' })
.TrimEnd(new Char[] { '>' })
.Replace("_:", "bnode:")
.Trim(new Char[] { ' ', '\n', '\t', '\r' });
O = new RDFResource(RDFModelUtilities.ASCII_To_Unicode(obj));
}
#endregion
#region literal
else
{
#region sanitize
tokens[2] = regexSqt.Replace(tokens[2], String.Empty);
tokens[2] = regexEqt.Replace(tokens[2], String.Empty);
tokens[2] = tokens[2].Replace("\\\\", "\\")
.Replace("\\\"", "\"")
.Replace("\\n", "\n")
.Replace("\\t", "\t")
.Replace("\\r", "\r");
tokens[2] = RDFModelUtilities.ASCII_To_Unicode(tokens[2]);
#endregion
#region plain literal
if (!tokens[2].Contains("^^") ||
tokens[2].EndsWith("^^") ||
tokens[2].Substring(tokens[2].LastIndexOf("^^", StringComparison.Ordinal) + 2, 1) != "<")
{
if (regexLPL.Match(tokens[2]).Success)
{
tokens[2] = tokens[2].Replace("\"@", "@");
String pLitValue = tokens[2].Substring(0, tokens[2].LastIndexOf("@", StringComparison.Ordinal));
String pLitLang = tokens[2].Substring(tokens[2].LastIndexOf("@", StringComparison.Ordinal) + 1);
L = new RDFPlainLiteral(HttpUtility.HtmlDecode(pLitValue), pLitLang);
}
else
{
L = new RDFPlainLiteral(HttpUtility.HtmlDecode(tokens[2]));
}
}
#endregion
#region typed literal
else
{
tokens[2] = tokens[2].Replace("\"^^", "^^");
String tLitValue = tokens[2].Substring(0, tokens[2].LastIndexOf("^^", StringComparison.Ordinal));
String tLitDatatype = tokens[2].Substring(tokens[2].LastIndexOf("^^", StringComparison.Ordinal) + 2)
.TrimStart(new Char[] { '<' })
.TrimEnd(new Char[] { '>' });
RDFModelEnums.RDFDatatypes dt = RDFModelUtilities.GetDatatypeFromString(tLitDatatype);
L = new RDFTypedLiteral(HttpUtility.HtmlDecode(tLitValue), dt);
}
#endregion
}
#endregion
#region addtriple
if (O != null)
{
result.AddTriple(new RDFTriple(S, P, O));
}
else
{
result.AddTriple(new RDFTriple(S, P, L));
}
#endregion
}
return(result);
}
#endregion
}
catch (Exception ex)
{
throw new RDFModelException("Cannot deserialize N-Triples (line " + ntripleIndex + ") because: " + ex.Message, ex);
}
}
/// <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);
}
/// <summary>
/// Default-ctor to build a datatype constraint with the given datatype
/// </summary>
public RDFDatatypeConstraint(RDFModelEnums.RDFDatatypes datatype) : base()
{
this.Datatype = datatype;
}
