/// <summary>
/// Tries to abbreviate the string representation of the given pattern member by searching for it in the given list of namespaces
/// </summary>
internal static (Boolean, String) AbbreviateRDFPatternMember(RDFPatternMember patternMember, List <RDFNamespace> Prefixes)
{
var prefixes = Prefixes;
#region Prefix Search
//Check if the pattern member starts with a known prefix, if so just return it
if (prefixes == null)
{
prefixes = new List <RDFNamespace>();
}
var prefixToSearch = patternMember.ToString().Split(':')[0];
var searchedPrefix = prefixes.Find(pf => pf.NamespacePrefix.Equals(prefixToSearch, StringComparison.OrdinalIgnoreCase));
if (searchedPrefix != null)
{
return(true, patternMember.ToString());
}
#endregion
#region Namespace Search
//Check if the pattern member starts with a known namespace, if so replace it with its prefix
String pmString = patternMember.ToString();
Boolean abbrev = false;
prefixes.ForEach(ns =>
{
if (!abbrev)
{
String nS = ns.ToString();
if (!pmString.Equals(nS, StringComparison.OrdinalIgnoreCase))
{
if (pmString.StartsWith(nS))
{
pmString = pmString.Replace(nS, ns.NamespacePrefix + ":").TrimEnd(new Char[] { '/' });
//Accept the abbreviation only if it has generated a valid XSD QName
try
{
new RDFTypedLiteral(pmString, RDFModelEnums.RDFDatatypes.XSD_QNAME);
abbrev = true;
}
catch
{
pmString = patternMember.ToString();
abbrev = false;
}
}
}
}
});
return(abbrev, pmString);
#endregion
}
/// <summary>
/// Gets the datatable representing the SPARQL values
/// </summary>
internal DataTable GetDataTable()
{
DataTable result = new DataTable();
result.ExtendedProperties.Add("IsOptional", false);
result.ExtendedProperties.Add("JoinAsUnion", false);
//Create the columns of the SPARQL values
this.Bindings.ToList()
.ForEach(b => RDFQueryEngine.AddColumn(result, b.Key));
result.AcceptChanges();
//Create the rows of the SPARQL values
result.BeginLoadData();
for (int i = 0; i < this.MaxBindingsLength; i++)
{
Dictionary <String, String> bindings = new Dictionary <String, String>();
this.Bindings.ToList()
.ForEach(b =>
{
RDFPatternMember bindingValue = b.Value.ElementAtOrDefault(i);
bindings.Add(b.Key, bindingValue?.ToString());
if (bindingValue == null)
{
result.ExtendedProperties["IsOptional"] = true;
}
});
RDFQueryEngine.AddRow(result, bindings);
}
result.EndLoadData();
return(result);
}
/// <summary>
/// Gets the row value for the aggregator as number
/// </summary>
internal Double GetRowValueAsNumber(DataRow tableRow)
{
try
{
if (!tableRow.IsNull(this.AggregatorVariable.VariableName))
{
RDFPatternMember rowAggregatorValue = RDFQueryUtilities.ParseRDFPatternMember(tableRow[this.AggregatorVariable.VariableName].ToString());
//PlainLiteral: accepted only if numeric and non-languaged
if (rowAggregatorValue is RDFPlainLiteral)
{
if (String.IsNullOrEmpty(((RDFPlainLiteral)rowAggregatorValue).Language))
{
if (Double.TryParse(rowAggregatorValue.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out Double doubleValue))
{
return(doubleValue);
}
}
}
//TypedLiteral: accepted only if numeric
else if (rowAggregatorValue is RDFTypedLiteral)
{
if (((RDFTypedLiteral)rowAggregatorValue).HasDecimalDatatype())
{
return(Double.Parse(((RDFTypedLiteral)rowAggregatorValue).Value, NumberStyles.Float, CultureInfo.InvariantCulture));
}
}
}
return(Double.NaN);
}
catch (Exception ex)
{
RDFQueryEvents.RaiseSELECTQueryEvaluation(String.Format("Exception intercepted during evaluation of RDFAggregator '{0}' in method GetRowValueAsNumber: '{1}'", this, ex.Message));
return(Double.NaN);
}
}
/// <summary>
/// Gives a formatted string representation of the given pattern member
/// </summary>
internal static String PrintRDFPatternMember(RDFPatternMember patternMember)
{
if (patternMember != null)
{
#region Variable
if (patternMember is RDFVariable)
{
return(patternMember.ToString());
}
#endregion
#region Non-Variable
#region Resource/Context
if (patternMember is RDFResource || patternMember is RDFContext)
{
if (patternMember is RDFResource && ((RDFResource)patternMember).IsBlank)
{
return(patternMember.ToString());
}
return("<" + patternMember + ">");
}
#endregion
#region Literal
if (patternMember is RDFPlainLiteral)
{
if (((RDFPlainLiteral)patternMember).Language != String.Empty)
{
return("\"" + ((RDFPlainLiteral)patternMember).Value + "\"@" + ((RDFPlainLiteral)patternMember).Language);
}
return("\"" + ((RDFPlainLiteral)patternMember).Value + "\"");
}
return("\"" + ((RDFTypedLiteral)patternMember).Value + "\"^^<" + RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)patternMember).Datatype) + ">");
#endregion
#endregion
}
throw new RDFQueryException("Cannot print pattern member because given \"patternMember\" parameter is null.");
}
/// <summary>
/// Prints the string representation of a pattern member
/// </summary>
internal static String PrintPatternMember(RDFPatternMember patternMember, List <RDFNamespace> prefixes)
{
if (patternMember != null)
{
#region Variable
if (patternMember is RDFVariable)
{
return(patternMember.ToString());
}
#endregion
#region Resource/Context
if (patternMember is RDFResource || patternMember is RDFContext)
{
#region Blank
if (patternMember is RDFResource && ((RDFResource)patternMember).IsBlank)
{
return(patternMember.ToString().Replace("bnode:", "_:"));
}
#endregion
#region NonBlank
var abbreviatedPM = RDFQueryUtilities.AbbreviateRDFPatternMember(patternMember, prefixes);
if (abbreviatedPM.Item1)
{
return(abbreviatedPM.Item2);
}
else
{
return("<" + abbreviatedPM.Item2 + ">");
}
#endregion
}
#endregion
#region Literal
if (patternMember is RDFLiteral)
{
#region PlainLiteral
if (patternMember is RDFPlainLiteral)
{
if (((RDFPlainLiteral)patternMember).Language != String.Empty)
{
return("\"" + ((RDFPlainLiteral)patternMember).Value + "\"@" + ((RDFPlainLiteral)patternMember).Language);
}
return("\"" + ((RDFPlainLiteral)patternMember).Value + "\"");
}
#endregion
#region TypedLiteral
else
{
var abbreviatedPM = RDFQueryUtilities.AbbreviateRDFPatternMember(RDFQueryUtilities.ParseRDFPatternMember(RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)patternMember).Datatype)), prefixes);
if (abbreviatedPM.Item1)
{
return("\"" + ((RDFTypedLiteral)patternMember).Value + "\"^^" + abbreviatedPM.Item2);
}
else
{
return("\"" + ((RDFTypedLiteral)patternMember).Value + "\"^^<" + abbreviatedPM.Item2 + ">");
}
}
#endregion
}
#endregion
}
return(null);
}
/// <summary>
/// Writes the "SPARQL Query Results XML Format" stream corresponding to the SELECT query result
/// </summary>
public void ToSparqlXmlResult(Stream outputStream)
{
try {
#region serialize
using (XmlTextWriter sparqlWriter = new XmlTextWriter(outputStream, Encoding.UTF8)) {
XmlDocument sparqlDoc = new XmlDocument();
sparqlWriter.Formatting = Formatting.Indented;
#region xmlDecl
XmlDeclaration sparqlDecl = sparqlDoc.CreateXmlDeclaration("1.0", "UTF-8", null);
sparqlDoc.AppendChild(sparqlDecl);
#endregion
#region sparqlRoot
XmlNode sparqlRoot = sparqlDoc.CreateNode(XmlNodeType.Element, "sparql", null);
XmlAttribute sparqlRootNS = sparqlDoc.CreateAttribute("xmlns");
XmlText sparqlRootNSText = sparqlDoc.CreateTextNode("http://www.w3.org/2005/sparql-results#");
sparqlRootNS.AppendChild(sparqlRootNSText);
sparqlRoot.Attributes.Append(sparqlRootNS);
#region sparqlHead
XmlNode sparqlHeadElement = sparqlDoc.CreateNode(XmlNodeType.Element, "head", null);
IEnumerator resultColumns = this.SelectResults.Columns.GetEnumerator();
while (resultColumns.MoveNext())
{
XmlNode variableElement = sparqlDoc.CreateNode(XmlNodeType.Element, "variable", null);
XmlAttribute varElName = sparqlDoc.CreateAttribute("name");
XmlText varElNameText = sparqlDoc.CreateTextNode(resultColumns.Current.ToString());
varElName.AppendChild(varElNameText);
variableElement.Attributes.Append(varElName);
sparqlHeadElement.AppendChild(variableElement);
}
sparqlRoot.AppendChild(sparqlHeadElement);
#endregion
#region sparqlResults
XmlNode sparqlResultsElement = sparqlDoc.CreateNode(XmlNodeType.Element, "results", null);
IEnumerator resultRows = this.SelectResults.Rows.GetEnumerator();
while (resultRows.MoveNext())
{
resultColumns.Reset();
XmlNode resultElement = sparqlDoc.CreateNode(XmlNodeType.Element, "result", null);
while (resultColumns.MoveNext())
{
if (!((DataRow)resultRows.Current).IsNull(resultColumns.Current.ToString()))
{
XmlNode bindingElement = sparqlDoc.CreateNode(XmlNodeType.Element, "binding", null);
XmlAttribute bindElName = sparqlDoc.CreateAttribute("name");
XmlText bindElNameText = sparqlDoc.CreateTextNode(resultColumns.Current.ToString());
bindElName.AppendChild(bindElNameText);
bindingElement.Attributes.Append(bindElName);
#region RDFTerm
RDFPatternMember rdfTerm = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)resultRows.Current)[resultColumns.Current.ToString()].ToString());
if (rdfTerm is RDFResource)
{
if (rdfTerm.ToString().StartsWith("bnode:"))
{
XmlNode bnodeElement = sparqlDoc.CreateNode(XmlNodeType.Element, "bnode", null);
XmlText bnodeElText = sparqlDoc.CreateTextNode(rdfTerm.ToString());
bnodeElement.AppendChild(bnodeElText);
bindingElement.AppendChild(bnodeElement);
}
else
{
XmlNode uriElement = sparqlDoc.CreateNode(XmlNodeType.Element, "uri", null);
XmlText uriElText = sparqlDoc.CreateTextNode(rdfTerm.ToString());
uriElement.AppendChild(uriElText);
bindingElement.AppendChild(uriElement);
}
}
else if (rdfTerm is RDFLiteral)
{
XmlNode litElement = sparqlDoc.CreateNode(XmlNodeType.Element, "literal", null);
if (rdfTerm is RDFPlainLiteral)
{
if (((RDFPlainLiteral)rdfTerm).Language != String.Empty)
{
XmlAttribute xmlLang = sparqlDoc.CreateAttribute(RDFVocabulary.XML.PREFIX + ":lang", RDFVocabulary.XML.BASE_URI);
XmlText xmlLangText = sparqlDoc.CreateTextNode(((RDFPlainLiteral)rdfTerm).Language);
xmlLang.AppendChild(xmlLangText);
litElement.Attributes.Append(xmlLang);
}
XmlText plainLiteralText = sparqlDoc.CreateTextNode(RDFModelUtilities.EscapeControlCharsForXML(HttpUtility.HtmlDecode(((RDFLiteral)rdfTerm).Value)));
litElement.AppendChild(plainLiteralText);
}
else
{
XmlAttribute datatype = sparqlDoc.CreateAttribute("datatype");
XmlText datatypeText = sparqlDoc.CreateTextNode(RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)rdfTerm).Datatype));
datatype.AppendChild(datatypeText);
litElement.Attributes.Append(datatype);
XmlText typedLiteralText = sparqlDoc.CreateTextNode(RDFModelUtilities.EscapeControlCharsForXML(HttpUtility.HtmlDecode(((RDFLiteral)rdfTerm).Value)));
litElement.AppendChild(typedLiteralText);
}
bindingElement.AppendChild(litElement);
}
#endregion
resultElement.AppendChild(bindingElement);
}
}
sparqlResultsElement.AppendChild(resultElement);
}
sparqlRoot.AppendChild(sparqlResultsElement);
#endregion
sparqlDoc.AppendChild(sparqlRoot);
#endregion
sparqlDoc.Save(sparqlWriter);
}
#endregion
}
catch (Exception ex) {
throw new RDFQueryException("Cannot serialize SPARQL XML RESULT because: " + ex.Message, ex);
}
}
/// <summary>
/// Compares the given pattern members, throwing a "Type Error" whenever the comparison operator detects sematically incompatible members;
/// </summary>
internal static Int32 CompareRDFPatternMembers(RDFPatternMember left, RDFPatternMember right)
{
#region CornerCase Comparisons
if (left == null)
{
if (right == null)
{
return(0);
}
return(-1);
}
if (right == null)
{
return(1);
}
#endregion
#region Effective Comparisons
#region RESOURCE/CONTEXT
if (left is RDFResource || left is RDFContext)
{
//RESOURCE/CONTEXT VS RESOURCE/CONTEXT
if (right is RDFResource || right is RDFContext)
{
return(String.Compare(left.ToString(), right.ToString(), StringComparison.Ordinal));
}
//RESOURCE/CONTEXT VS "XSD:ANYURI" TYPED LITERAL
if (right is RDFTypedLiteral && ((RDFTypedLiteral)right).Datatype.Equals(RDFModelEnums.RDFDatatype.XSD_ANYURI))
{
return(String.Compare(left.ToString(), ((RDFTypedLiteral)right).Value, StringComparison.Ordinal));
}
//RESOURCE/CONTEXT VS LITERAL
return(-1);
}
#endregion
#region PLAINLITERAL
if (left is RDFPlainLiteral)
{
//PLAIN LITERAL VS RESOURCE/CONTEXT
if (right is RDFResource || right is RDFContext)
{
return(1);
}
//PLAIN LITERAL VS PLAIN LITERAL
if (right is RDFPlainLiteral)
{
return(String.Compare(left.ToString(), right.ToString(), StringComparison.Ordinal));
}
//PLAIN LITERAL VS "RDFS:LITERAL" OR "XSD:STRING" TYPED LITERAL
if (((RDFTypedLiteral)right).Datatype.Equals(RDFModelEnums.RDFDatatype.RDFS_LITERAL) ||
((RDFTypedLiteral)right).Datatype.Equals(RDFModelEnums.RDFDatatype.XSD_STRING))
{
return(String.Compare(left.ToString(), ((RDFTypedLiteral)right).Value, StringComparison.Ordinal));
}
//PLAIN LITERAL VS TYPED LITERAL
return(-1);
}
#endregion
#region TYPEDLITERAL
//TYPED LITERAL VS RESOURCE/CONTEXT
if (right is RDFResource || right is RDFContext)
{
//"XSD:ANYURI" TYPED LITERAL VS RESOURCE/CONTEXT
if (left is RDFTypedLiteral && ((RDFTypedLiteral)left).Datatype.Equals(RDFModelEnums.RDFDatatype.XSD_ANYURI))
{
return(String.Compare(((RDFTypedLiteral)left).Value, right.ToString(), StringComparison.Ordinal));
}
//TYPED LITERAL VS RESOURCE/CONTEXT
return(1);
}
//TYPED LITERAL VS PLAIN LITERAL
if (right is RDFPlainLiteral)
{
//"RDFS:LITERAL" OR "XSD:STRING" TYPED LITERAL VS PLAIN LITERAL
if (((RDFTypedLiteral)left).Datatype.Equals(RDFModelEnums.RDFDatatype.RDFS_LITERAL) ||
((RDFTypedLiteral)left).Datatype.Equals(RDFModelEnums.RDFDatatype.XSD_STRING))
{
return(String.Compare(((RDFTypedLiteral)left).Value, right.ToString(), StringComparison.Ordinal));
}
//TYPED LITERAL VS PLAIN LITERAL
return(1);
}
//TYPED LITERAL VS TYPED LITERAL
//Detect left typed literal's category
RDFModelEnums.RDFDatatype leftDType = ((RDFTypedLiteral)left).Datatype;
Boolean isLeftDTypeBoolean = leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_BOOLEAN);
Boolean isLeftDTypeNumeric = leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_BYTE) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_DECIMAL) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_DOUBLE) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_FLOAT) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_INT) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_INTEGER) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_LONG) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NEGATIVEINTEGER) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NONNEGATIVEINTEGER) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NONPOSITIVEINTEGER) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_POSITIVEINTEGER) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_SHORT) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDBYTE) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDINT) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDLONG) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDSHORT);
Boolean isLeftDTypeDateTime = leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_DATE) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_DATETIME) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_GDAY) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_GMONTH) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_GMONTHDAY) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_GYEAR) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_GYEARMONTH) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_TIME);
Boolean isLeftDTypeTimeSpan = leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_DURATION);
Boolean isLeftDTypeString = leftDType.Equals(RDFModelEnums.RDFDatatype.RDFS_LITERAL) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.RDF_XMLLITERAL) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_ANYURI) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_BASE64BINARY) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_HEXBINARY) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_LANGUAGE) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NAME) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NCNAME) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NMTOKEN) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NORMALIZEDSTRING) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_NOTATION) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_QNAME) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_STRING) ||
leftDType.Equals(RDFModelEnums.RDFDatatype.XSD_TOKEN);
//Detect right typed literal's category
RDFModelEnums.RDFDatatype rightDType = ((RDFTypedLiteral)right).Datatype;
Boolean isRightDTypeBoolean = rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_BOOLEAN);
Boolean isRightDTypeNumeric = rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_BYTE) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_DECIMAL) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_DOUBLE) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_FLOAT) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_INT) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_INTEGER) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_LONG) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NEGATIVEINTEGER) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NONNEGATIVEINTEGER) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NONPOSITIVEINTEGER) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_POSITIVEINTEGER) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_SHORT) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDBYTE) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDINT) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDLONG) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_UNSIGNEDSHORT);
Boolean isRightDTypeDateTime = rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_DATE) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_DATETIME) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_GDAY) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_GMONTH) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_GMONTHDAY) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_GYEAR) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_GYEARMONTH) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_TIME);
Boolean isRightDTypeTimeSpan = rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_DURATION);
Boolean isRightDTypeString = rightDType.Equals(RDFModelEnums.RDFDatatype.RDFS_LITERAL) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.RDF_XMLLITERAL) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_ANYURI) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_BASE64BINARY) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_HEXBINARY) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_LANGUAGE) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NAME) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NCNAME) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NMTOKEN) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NORMALIZEDSTRING) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_NOTATION) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_QNAME) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_STRING) ||
rightDType.Equals(RDFModelEnums.RDFDatatype.XSD_TOKEN);
//Compare typed literals, only if categories are semantically compatible
if (isLeftDTypeBoolean && isRightDTypeBoolean)
{
Boolean leftValueBoolean = Boolean.Parse(((RDFTypedLiteral)left).Value);
Boolean rightValueBoolean = Boolean.Parse(((RDFTypedLiteral)right).Value);
return(leftValueBoolean.CompareTo(rightValueBoolean));
}
else if (isLeftDTypeDateTime && isRightDTypeDateTime)
{
DateTime leftValueDateTime = DateTime.Parse(((RDFTypedLiteral)left).Value, CultureInfo.InvariantCulture);
DateTime rightValueDateTime = DateTime.Parse(((RDFTypedLiteral)right).Value, CultureInfo.InvariantCulture);
return(leftValueDateTime.CompareTo(rightValueDateTime));
}
else if (isLeftDTypeNumeric && isRightDTypeNumeric)
{
Decimal leftValueDecimal = Decimal.Parse(((RDFTypedLiteral)left).Value, CultureInfo.InvariantCulture);
Decimal rightValueDecimal = Decimal.Parse(((RDFTypedLiteral)right).Value, CultureInfo.InvariantCulture);
return(leftValueDecimal.CompareTo(rightValueDecimal));
}
else if (isLeftDTypeString && isRightDTypeString)
{
String leftValueString = ((RDFTypedLiteral)left).Value;
String rightValueString = ((RDFTypedLiteral)right).Value;
return(leftValueString.CompareTo(rightValueString));
}
else if (isLeftDTypeTimeSpan && isRightDTypeTimeSpan)
{
TimeSpan leftValueDuration = XmlConvert.ToTimeSpan(((RDFTypedLiteral)left).Value);
TimeSpan rightValueDuration = XmlConvert.ToTimeSpan(((RDFTypedLiteral)right).Value);
return(leftValueDuration.CompareTo(rightValueDuration));
}
else
{
throw new RDFQueryException("Type Error: Typed Literal of datatype (" + RDFModelUtilities.GetDatatypeFromEnum(leftDType) + ") cannot be compared to Typed Literal of datatype (" + RDFModelUtilities.GetDatatypeFromEnum(rightDType) + ")");
}
#endregion
#endregion
}
/// <summary>
/// Fills the templates of the given query with data from the given result table
/// </summary>
internal static DataTable FillTemplates(RDFConstructQuery constructQuery, DataTable resultTable)
{
//Create the structure of the result datatable
DataTable result = new DataTable("CONSTRUCT_RESULTS");
result.Columns.Add("SUBJECT", Type.GetType("System.String"));
result.Columns.Add("PREDICATE", Type.GetType("System.String"));
result.Columns.Add("OBJECT", Type.GetType("System.String"));
result.AcceptChanges();
//Initialize working variables
Dictionary <String, String> constructRow = new Dictionary <String, String>();
constructRow.Add("SUBJECT", null);
constructRow.Add("PREDICATE", null);
constructRow.Add("OBJECT", null);
//Iterate on the templates
foreach (RDFPattern tp in constructQuery.Templates.Where(tp => tp.Variables.Count == 0 ||
tp.Variables.TrueForAll(v => resultTable.Columns.Contains(v.ToString()))))
{
#region GROUND TEMPLATE
//Check if the template is ground, so represents an explicit triple to be added as-is
if (tp.Variables.Count == 0)
{
constructRow["SUBJECT"] = tp.Subject.ToString();
constructRow["PREDICATE"] = tp.Predicate.ToString();
constructRow["OBJECT"] = tp.Object.ToString();
RDFQueryUtilities.AddRow(result, constructRow);
continue;
}
#endregion
#region NON-GROUND TEMPLATE
//Iterate the result datatable's rows to construct the triples of the current template
IEnumerator rowsEnum = resultTable.Rows.GetEnumerator();
while (rowsEnum.MoveNext())
{
#region SUBJECT
//Subject of the template is a variable
if (tp.Subject is RDFVariable)
{
//Check if the template must be skipped, in order to not produce illegal triples
//Row contains an unbound value in position of the variable corresponding to the template subject
if (((DataRow)rowsEnum.Current).IsNull(tp.Subject.ToString()))
{
continue;
}
RDFPatternMember subj = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)rowsEnum.Current)[tp.Subject.ToString()].ToString());
//Row contains a literal in position of the variable corresponding to the template subject
if (subj is RDFLiteral)
{
continue;
}
//Row contains a resource in position of the variable corresponding to the template subject
constructRow["SUBJECT"] = subj.ToString();
}
//Subject of the template is a resource
else
{
constructRow["SUBJECT"] = tp.Subject.ToString();
}
#endregion
#region PREDICATE
//Predicate of the template is a variable
if (tp.Predicate is RDFVariable)
{
//Check if the template must be skipped, in order to not produce illegal triples
//Row contains an unbound value in position of the variable corresponding to the template predicate
if (((DataRow)rowsEnum.Current).IsNull(tp.Predicate.ToString()))
{
continue;
}
RDFPatternMember pred = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)rowsEnum.Current)[tp.Predicate.ToString()].ToString());
//Row contains a blank resource or a literal in position of the variable corresponding to the template predicate
if ((pred is RDFResource && ((RDFResource)pred).IsBlank) || pred is RDFLiteral)
{
continue;
}
//Row contains a non-blank resource in position of the variable corresponding to the template predicate
constructRow["PREDICATE"] = pred.ToString();
}
//Predicate of the template is a resource
else
{
constructRow["PREDICATE"] = tp.Predicate.ToString();
}
#endregion
#region OBJECT
//Object of the template is a variable
if (tp.Object is RDFVariable)
{
//Check if the template must be skipped, in order to not produce illegal triples
//Row contains an unbound value in position of the variable corresponding to the template object
if (((DataRow)rowsEnum.Current).IsNull(tp.Object.ToString()))
{
continue;
}
RDFPatternMember obj = RDFQueryUtilities.ParseRDFPatternMember(((DataRow)rowsEnum.Current)[tp.Object.ToString()].ToString());
//Row contains a resource or a literal in position of the variable corresponding to the template object
constructRow["OBJECT"] = obj.ToString();
}
//Object of the template is a resource or a literal
else
{
constructRow["OBJECT"] = tp.Object.ToString();
}
#endregion
//Insert the triple into the final table
RDFQueryUtilities.AddRow(result, constructRow);
}
#endregion
}
return(result);
}
/// <summary>
/// Compares the given pattern members, throwing a "Type Error" whenever the comparison operator detects sematically incompatible members;
/// </summary>
internal static Int32 CompareRDFPatternMembers(RDFPatternMember left, RDFPatternMember right)
{
#region NULLS
if (left == null)
{
if (right == null)
{
return(0);
}
return(-1);
}
if (right == null)
{
return(1);
}
#endregion
#region RESOURCE/CONTEXT
if (left is RDFResource || left is RDFContext)
{
//RESOURCE/CONTEXT VS RESOURCE/CONTEXT/PLAINLITERAL
if (right is RDFResource || right is RDFContext || right is RDFPlainLiteral)
{
return(String.Compare(left.ToString(), right.ToString(), StringComparison.Ordinal));
}
//RESOURCE/CONTEXT VS TYPEDLITERAL
else
{
if (((RDFTypedLiteral)right).HasStringDatatype())
{
return(String.Compare(left.ToString(), ((RDFTypedLiteral)right).Value, StringComparison.Ordinal));
}
return(-99); //Type Error
}
}
#endregion
#region PLAINLITERAL
else if (left is RDFPlainLiteral)
{
//PLAINLITERAL VS RESOURCE/CONTEXT/PLAINLITERAL
if (right is RDFResource || right is RDFContext || right is RDFPlainLiteral)
{
return(String.Compare(left.ToString(), right.ToString(), StringComparison.Ordinal));
}
//PLAINLITERAL VS TYPEDLITERAL
else
{
if (((RDFTypedLiteral)right).HasStringDatatype())
{
return(String.Compare(left.ToString(), ((RDFTypedLiteral)right).Value, StringComparison.Ordinal));
}
return(-99); //Type Error
}
}
#endregion
#region TYPEDLITERAL
else
{
//TYPEDLITERAL VS RESOURCE/CONTEXT/PLAINLITERAL
if (right is RDFResource || right is RDFContext || right is RDFPlainLiteral)
{
if (((RDFTypedLiteral)left).HasStringDatatype())
{
return(String.Compare(((RDFTypedLiteral)left).Value, right.ToString(), StringComparison.Ordinal));
}
return(-99); //Type Error
}
//TYPEDLITERAL VS TYPEDLITERAL
else
{
if (((RDFTypedLiteral)left).HasBooleanDatatype() && ((RDFTypedLiteral)right).HasBooleanDatatype())
{
Boolean leftValueBoolean = Boolean.Parse(((RDFTypedLiteral)left).Value);
Boolean rightValueBoolean = Boolean.Parse(((RDFTypedLiteral)right).Value);
return(leftValueBoolean.CompareTo(rightValueBoolean));
}
else if (((RDFTypedLiteral)left).HasDatetimeDatatype() && ((RDFTypedLiteral)right).HasDatetimeDatatype())
{
DateTime leftValueDateTime = DateTime.Parse(((RDFTypedLiteral)left).Value, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal);
DateTime rightValueDateTime = DateTime.Parse(((RDFTypedLiteral)right).Value, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal);
return(leftValueDateTime.CompareTo(rightValueDateTime));
}
else if (((RDFTypedLiteral)left).HasDecimalDatatype() && ((RDFTypedLiteral)right).HasDecimalDatatype())
{
Decimal leftValueDecimal = Decimal.Parse(((RDFTypedLiteral)left).Value, CultureInfo.InvariantCulture);
Decimal rightValueDecimal = Decimal.Parse(((RDFTypedLiteral)right).Value, CultureInfo.InvariantCulture);
return(leftValueDecimal.CompareTo(rightValueDecimal));
}
else if (((RDFTypedLiteral)left).HasStringDatatype() && ((RDFTypedLiteral)right).HasStringDatatype())
{
String leftValueString = ((RDFTypedLiteral)left).Value;
String rightValueString = ((RDFTypedLiteral)right).Value;
return(leftValueString.CompareTo(rightValueString));
}
else if (((RDFTypedLiteral)left).HasTimespanDatatype() && ((RDFTypedLiteral)right).HasTimespanDatatype())
{
TimeSpan leftValueDuration = XmlConvert.ToTimeSpan(((RDFTypedLiteral)left).Value);
TimeSpan rightValueDuration = XmlConvert.ToTimeSpan(((RDFTypedLiteral)right).Value);
return(leftValueDuration.CompareTo(rightValueDuration));
}
else
{
return(-99); //Type Error
}
}
}
#endregion
}
