/// <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 }