/// <summary> /// Collects the namespaces used by the given triple /// </summary> private void CollectNamespaces(RDFTriple triple) { RDFNamespaceRegister.Instance.Register.ForEach(ns => { String nSpace = ns.ToString(); //Resolve subj Uri String subj = triple.Subject.ToString(); if (subj.Contains(nSpace) || subj.StartsWith(ns.Prefix + ":")) { if (!this.Namespaces.Contains(ns)) { this.Namespaces.Add(ns); } } //Resolve pred Uri String pred = triple.Predicate.ToString(); if (pred.Contains(nSpace) || pred.StartsWith(ns.Prefix + ":")) { if (!this.Namespaces.Contains(ns)) { this.Namespaces.Add(ns); } } //Resolve object Uri if (triple.TripleFlavor == RDFModelEnums.RDFTripleFlavor.SPO) { String obj = triple.Object.ToString(); if (obj.Contains(nSpace) || obj.StartsWith(ns.Prefix + ":")) { if (!this.Namespaces.Contains(ns)) { this.Namespaces.Add(ns); } } } else { //Resolve typed literal Uri if (triple.Object is RDFTypedLiteral) { String tLit = RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)triple.Object).Datatype); if (tLit.Contains(nSpace) || tLit.StartsWith(ns.Prefix + ":")) { if (!this.Namespaces.Contains(ns)) { this.Namespaces.Add(ns); } } } } }); }
/// <summary> /// Enlists the facts/literals which are directly (or indirectly, if inference is requested) members of the lens class /// </summary> public List <(bool, RDFOntologyResource)> Members(bool enableInference) { List <(bool, RDFOntologyResource)> result = new List <(bool, RDFOntologyResource)>(); //First-level enlisting of members (datatype class) if (RDFOntologyHelper.CheckIsLiteralCompatibleClass(this.Ontology.Model.ClassModel, this.OntologyClass)) { IEnumerable <RDFOntologyLiteral> ontlits = this.Ontology.Data.Literals.Values.Where(ol => ol.Value is RDFTypedLiteral); foreach (RDFOntologyLiteral ontlit in ontlits.Where(ol => RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)ol.Value).Datatype).Equals(this.OntologyClass.ToString()))) { if (!result.Any(ol => ol.Equals(ontlit))) { result.Add((false, ontlit)); } } } //First-level enlisting of members (object class) else { foreach (RDFOntologyTaxonomyEntry sf in this.Ontology.Data.Relations.ClassType.SelectEntriesByObject(this.OntologyClass).Where(te => !te.IsInference())) { result.Add((false, sf.TaxonomySubject)); } } //Inference-enabled discovery of members if (enableInference) { RDFOntologyData members = RDFOntologyHelper.GetMembersOf(this.Ontology, this.OntologyClass); foreach (RDFOntologyFact fact in members) { if (!result.Any(f => f.Item2.Equals(fact))) { result.Add((true, fact)); } } foreach (RDFOntologyLiteral literal in members.Literals.Values) { if (!result.Any(f => f.Item2.Equals(literal))) { result.Add((true, literal)); } } } return(result); }
/// <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> /// Applies the filter on the column corresponding to the variable in the given datarow /// </summary> internal override Boolean ApplyFilter(DataRow row, Boolean applyNegation) { Boolean keepRow = true; //Check is performed only if the row contains a column named like the filter's variable if (row.Table.Columns.Contains(this.Variable.ToString())) { String variableValue = row[this.Variable.ToString()].ToString(); //Successfull match if given datatype is found in the variable keepRow = Regex.IsMatch(variableValue, "\\^\\^" + RDFModelUtilities.GetDatatypeFromEnum(this.Datatype) + "$"); //Apply the eventual negation if (applyNegation) { keepRow = !keepRow; } } return(keepRow); }
/// <summary> /// Serializes the given store to the given stream using TriX data format. /// </summary> internal static void Serialize(RDFStore store, Stream outputStream) { try { #region serialize using (XmlTextWriter trixWriter = new XmlTextWriter(outputStream, Encoding.UTF8)) { XmlDocument trixDoc = new XmlDocument(); trixWriter.Formatting = Formatting.Indented; #region xmlDecl XmlDeclaration trixDecl = trixDoc.CreateXmlDeclaration("1.0", "UTF-8", null); trixDoc.AppendChild(trixDecl); #endregion #region trixRoot XmlNode trixRoot = trixDoc.CreateNode(XmlNodeType.Element, "TriX", null); XmlAttribute trixRootNS = trixDoc.CreateAttribute("xmlns"); XmlText trixRootNSText = trixDoc.CreateTextNode("http://www.w3.org/2004/03/trix/trix-1/"); trixRootNS.AppendChild(trixRootNSText); trixRoot.Attributes.Append(trixRootNS); #region graphs foreach (var graph in store.ExtractGraphs()) { XmlNode graphElement = trixDoc.CreateNode(XmlNodeType.Element, "graph", null); XmlNode graphUriElement = trixDoc.CreateNode(XmlNodeType.Element, "uri", null); XmlText graphUriElementT = trixDoc.CreateTextNode(graph.ToString()); graphUriElement.AppendChild(graphUriElementT); graphElement.AppendChild(graphUriElement); #region triple foreach (var t in graph) { XmlNode tripleElement = trixDoc.CreateNode(XmlNodeType.Element, "triple", null); #region subj XmlNode subjElement = (((RDFResource)t.Subject).IsBlank ? trixDoc.CreateNode(XmlNodeType.Element, "id", null) : trixDoc.CreateNode(XmlNodeType.Element, "uri", null)); XmlText subjElementText = trixDoc.CreateTextNode(t.Subject.ToString()); subjElement.AppendChild(subjElementText); tripleElement.AppendChild(subjElement); #endregion #region pred XmlNode uriElementP = trixDoc.CreateNode(XmlNodeType.Element, "uri", null); XmlText uriTextP = trixDoc.CreateTextNode(t.Predicate.ToString()); uriElementP.AppendChild(uriTextP); tripleElement.AppendChild(uriElementP); #endregion #region object if (t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO) { XmlNode objElement = (((RDFResource)t.Object).IsBlank ? trixDoc.CreateNode(XmlNodeType.Element, "id", null) : trixDoc.CreateNode(XmlNodeType.Element, "uri", null)); XmlText objElementText = trixDoc.CreateTextNode(t.Object.ToString()); objElement.AppendChild(objElementText); tripleElement.AppendChild(objElement); } #endregion #region literal else { #region plain literal if (t.Object is RDFPlainLiteral) { XmlNode plainLiteralElement = trixDoc.CreateNode(XmlNodeType.Element, "plainLiteral", null); if (((RDFPlainLiteral)t.Object).Language != String.Empty) { XmlAttribute xmlLang = trixDoc.CreateAttribute(RDFVocabulary.XML.PREFIX + ":lang", RDFVocabulary.XML.BASE_URI); XmlText xmlLangText = trixDoc.CreateTextNode(((RDFPlainLiteral)t.Object).Language); xmlLang.AppendChild(xmlLangText); plainLiteralElement.Attributes.Append(xmlLang); } XmlText plainLiteralText = trixDoc.CreateTextNode(RDFModelUtilities.EscapeControlCharsForXML(HttpUtility.HtmlDecode(((RDFLiteral)t.Object).Value))); plainLiteralElement.AppendChild(plainLiteralText); tripleElement.AppendChild(plainLiteralElement); } #endregion #region typed literal else { XmlNode typedLiteralElement = trixDoc.CreateNode(XmlNodeType.Element, "typedLiteral", null); XmlAttribute datatype = trixDoc.CreateAttribute("datatype"); XmlText datatypeText = trixDoc.CreateTextNode(RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)t.Object).Datatype)); datatype.AppendChild(datatypeText); typedLiteralElement.Attributes.Append(datatype); XmlText typedLiteralText = trixDoc.CreateTextNode(RDFModelUtilities.EscapeControlCharsForXML(HttpUtility.HtmlDecode(((RDFLiteral)t.Object).Value))); typedLiteralElement.AppendChild(typedLiteralText); tripleElement.AppendChild(typedLiteralElement); } #endregion } #endregion graphElement.AppendChild(tripleElement); } #endregion trixRoot.AppendChild(graphElement); } #endregion trixDoc.AppendChild(trixRoot); #endregion trixDoc.Save(trixWriter); } #endregion } catch (Exception ex) { throw new RDFStoreException("Cannot serialize TriX because: " + ex.Message, ex); } }
/// <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> /// Serializes the given graph to the given stream using N-Triples data format. /// </summary> internal static void Serialize(RDFGraph graph, Stream outputStream) { try { #region serialize using (StreamWriter sw = new StreamWriter(outputStream, Encoding.ASCII)) { String tripleTemplate = String.Empty; foreach (var t in graph) { #region template if (t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO) { tripleTemplate = "<{SUBJ}> <{PRED}> <{OBJ}> ."; } else { if (t.Object is RDFPlainLiteral) { tripleTemplate = "<{SUBJ}> <{PRED}> \"{VAL}\"@{LANG} ."; } else { tripleTemplate = "<{SUBJ}> <{PRED}> \"{VAL}\"^^<{DTYPE}> ."; } } #endregion #region subj if (((RDFResource)t.Subject).IsBlank) { tripleTemplate = tripleTemplate.Replace("<{SUBJ}>", RDFModelUtilities.Unicode_To_ASCII(t.Subject.ToString()).Replace("bnode:", "_:")); } else { tripleTemplate = tripleTemplate.Replace("{SUBJ}", RDFModelUtilities.Unicode_To_ASCII(t.Subject.ToString())); } #endregion #region pred tripleTemplate = tripleTemplate.Replace("{PRED}", RDFModelUtilities.Unicode_To_ASCII(t.Predicate.ToString())); #endregion #region object if (t.TripleFlavor == RDFModelEnums.RDFTripleFlavors.SPO) { if (((RDFResource)t.Object).IsBlank) { tripleTemplate = tripleTemplate.Replace("<{OBJ}>", RDFModelUtilities.Unicode_To_ASCII(t.Object.ToString())).Replace("bnode:", "_:"); } else { tripleTemplate = tripleTemplate.Replace("{OBJ}", RDFModelUtilities.Unicode_To_ASCII(t.Object.ToString())); } } #endregion #region literal else { tripleTemplate = tripleTemplate.Replace("{VAL}", RDFModelUtilities.EscapeControlCharsForXML(RDFModelUtilities.Unicode_To_ASCII(((RDFLiteral)t.Object).Value.Replace("\\", "\\\\").Replace("\"", "\\\"")))); tripleTemplate = tripleTemplate.Replace("\n", "\\n") .Replace("\t", "\\t") .Replace("\r", "\\r"); #region plain literal if (t.Object is RDFPlainLiteral) { if (((RDFPlainLiteral)t.Object).Language != String.Empty) { tripleTemplate = tripleTemplate.Replace("{LANG}", ((RDFPlainLiteral)t.Object).Language); } else { tripleTemplate = tripleTemplate.Replace("@{LANG}", String.Empty); } } #endregion #region typed literal else { tripleTemplate = tripleTemplate.Replace("{DTYPE}", RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)t.Object).Datatype)); } #endregion } #endregion sw.WriteLine(tripleTemplate); } } #endregion } catch (Exception ex) { throw new RDFModelException("Cannot serialize N-Triples 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> /// Gets a graph representation of this constraint /// </summary> internal override RDFGraph ToRDFGraph(RDFShape shape) { RDFGraph result = new RDFGraph(); if (shape != null) { //sh:datatype result.AddTriple(new RDFTriple(shape, RDFVocabulary.SHACL.DATATYPE, new RDFResource(RDFModelUtilities.GetDatatypeFromEnum(this.Datatype)))); } return(result); }
internal override String ToString(List <RDFNamespace> prefixes) { return("FILTER ( DATATYPE(" + this.Variable + ") = " + RDFQueryUtilities.PrintRDFPatternMember(RDFQueryUtilities.ParseRDFPatternMember(RDFModelUtilities.GetDatatypeFromEnum(this.Datatype)), prefixes) + " )"); }
/// <summary> /// Gives the string representation of the typed literal /// </summary> public override string ToString() => string.Concat(base.ToString(), "^^", RDFModelUtilities.GetDatatypeFromEnum(this.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> /// Gives the string representation of the typed literal /// </summary> public override String ToString() { return(base.ToString() + "^^" + RDFModelUtilities.GetDatatypeFromEnum(this.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; 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> /// Serializes the given graph to the given stream using XML data format. /// </summary> internal static void Serialize(RDFGraph graph, Stream outputStream) { try { #region serialize using (XmlTextWriter rdfxmlWriter = new XmlTextWriter(outputStream, Encoding.UTF8)) { XmlDocument rdfDoc = new XmlDocument(); rdfxmlWriter.Formatting = Formatting.Indented; #region xmlDecl XmlDeclaration xmlDecl = rdfDoc.CreateXmlDeclaration("1.0", "UTF-8", null); rdfDoc.AppendChild(xmlDecl); #endregion #region rdfRoot XmlNode rdfRoot = rdfDoc.CreateNode(XmlNodeType.Element, RDFVocabulary.RDF.PREFIX + ":RDF", RDFVocabulary.RDF.BASE_URI); XmlAttribute rdfRootNS = rdfDoc.CreateAttribute("xmlns:" + RDFVocabulary.RDF.PREFIX); XmlText rdfRootNSText = rdfDoc.CreateTextNode(RDFVocabulary.RDF.BASE_URI); rdfRootNS.AppendChild(rdfRootNSText); rdfRoot.Attributes.Append(rdfRootNS); #region prefixes //Write the graph's prefixes (except for "rdf", which has already been written) graph.GraphMetadata.Namespaces.ForEach(p => { if (!p.Prefix.Equals(RDFVocabulary.RDF.PREFIX, StringComparison.Ordinal) && !p.Prefix.Equals("base", StringComparison.Ordinal)) { XmlAttribute pfRootNS = rdfDoc.CreateAttribute("xmlns:" + p.Prefix); XmlText pfRootNSText = rdfDoc.CreateTextNode(p.ToString()); pfRootNS.AppendChild(pfRootNSText); rdfRoot.Attributes.Append(pfRootNS); } }); //Write the graph's base uri to resolve eventual relative #IDs XmlAttribute pfBaseNS = rdfDoc.CreateAttribute(RDFVocabulary.XML.PREFIX + ":base"); XmlText pfBaseNSText = rdfDoc.CreateTextNode(graph.Context.ToString()); pfBaseNS.AppendChild(pfBaseNSText); rdfRoot.Attributes.Append(pfBaseNS); #endregion #region linq //Group the graph's triples by subj var groupedList = (from triple in graph orderby triple.Subject.ToString() group triple by new { subj = triple.Subject.ToString() }); #endregion #region graph //Iterate over the calculated groups Dictionary <RDFResource, XmlNode> containers = new Dictionary <RDFResource, XmlNode>(); //Floating containers have reification subject which is never object of any graph's triple Boolean floatingContainers = graph.GraphMetadata.Containers.Keys.Any(k => graph.Triples.Values.Count(v => v.Object.Equals(k)) == 0); //Floating collections have reification subject which is never object of any graph's triple Boolean floatingCollections = graph.GraphMetadata.Collections.Keys.Any(k => graph.Triples.Values.Count(v => v.Object.Equals(k)) == 0); foreach (var group in groupedList) { #region subj //Check if the current subj is a container or a collection subj: if so it must be //serialized in the canonical RDF/XML way instead of the "rdf:Description" way XmlNode subjNode = null; String subj = group.Key.subj; //It is a container subj, so add it to the containers pool if (graph.GraphMetadata.Containers.Keys.Any(k => k.ToString().Equals(subj, StringComparison.Ordinal)) && !floatingContainers) { switch (graph.GraphMetadata.Containers.Single(c => c.Key.ToString().Equals(subj, StringComparison.Ordinal)).Value) { case RDFModelEnums.RDFContainerType.Bag: subjNode = rdfDoc.CreateNode(XmlNodeType.Element, RDFVocabulary.RDF.PREFIX + ":Bag", RDFVocabulary.RDF.BASE_URI); containers.Add(new RDFResource(subj), subjNode); break; case RDFModelEnums.RDFContainerType.Seq: subjNode = rdfDoc.CreateNode(XmlNodeType.Element, RDFVocabulary.RDF.PREFIX + ":Seq", RDFVocabulary.RDF.BASE_URI); containers.Add(new RDFResource(subj), subjNode); break; case RDFModelEnums.RDFContainerType.Alt: subjNode = rdfDoc.CreateNode(XmlNodeType.Element, RDFVocabulary.RDF.PREFIX + ":Alt", RDFVocabulary.RDF.BASE_URI); containers.Add(new RDFResource(subj), subjNode); break; } } //It is a subj of a collection of resources, so do not append triples having it as a subject //because we will reconstruct the collection and append it as a whole else if (graph.GraphMetadata.Collections.Keys.Any(k => k.ToString().Equals(subj, StringComparison.Ordinal)) && graph.GraphMetadata.Collections.Single(c => c.Key.ToString().Equals(subj, StringComparison.Ordinal)).Value.ItemType == RDFModelEnums.RDFItemType.Resource && !floatingCollections) { continue; } //It is neither a container or a collection subj else { subjNode = rdfDoc.CreateNode(XmlNodeType.Element, RDFVocabulary.RDF.PREFIX + ":Description", RDFVocabulary.RDF.BASE_URI); //<rdf:Description rdf:nodeID="blankID"> XmlAttribute subjNodeDesc = null; XmlText subjNodeDescText = rdfDoc.CreateTextNode(group.Key.subj); if (group.Key.subj.StartsWith("bnode:")) { subjNodeDescText.InnerText = subjNodeDescText.InnerText.Replace("bnode:", String.Empty); subjNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":nodeID", RDFVocabulary.RDF.BASE_URI); } //<rdf:Description rdf:about="subjURI"> else { subjNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":about", RDFVocabulary.RDF.BASE_URI); } subjNodeDesc.AppendChild(subjNodeDescText); subjNode.Attributes.Append(subjNodeDesc); } #endregion #region predObjList //Iterate over the triples of the current group foreach (var triple in group) { //Do not append the triple if it is "SUBJECT rdf:type rdf:[Bag|Seq|Alt]" if (!(triple.Predicate.Equals(RDFVocabulary.RDF.TYPE) && (subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Bag", StringComparison.Ordinal) || subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Seq", StringComparison.Ordinal) || subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Alt", StringComparison.Ordinal)))) { #region pred String predString = triple.Predicate.ToString(); //"<predPREF:predURI" RDFNamespace predNS = (RDFNamespaceRegister.GetByNamespace(predString) ?? RDFModelUtilities.GenerateNamespace(predString, false)); //Refine the pred with eventually necessary sanitizations String predUri = predString.Replace(predNS.ToString(), predNS.Prefix + ":") .Replace(":#", ":") .TrimEnd(new Char[] { ':', '/' }); //Sanitize eventually detected automatic namespace if (predUri.StartsWith("autoNS:")) { predUri = predUri.Replace("autoNS:", string.Empty); } //Do not write "xmlns" attribute if the predUri is the context of the graph XmlNode predNode = null; if (predNS.ToString().Equals(graph.Context.ToString(), StringComparison.Ordinal)) { predNode = rdfDoc.CreateNode(XmlNodeType.Element, predUri, null); } else { predNode = rdfDoc.CreateNode(XmlNodeType.Element, predUri, predNS.ToString()); } #endregion #region object if (triple.TripleFlavor == RDFModelEnums.RDFTripleFlavor.SPO) { //If the object is a container subj, we must append its entire node saved in the containers dictionary if (containers.Keys.Any(k => k.Equals(triple.Object)) && !floatingContainers) { predNode.AppendChild(containers.Single(c => c.Key.Equals(triple.Object)).Value); } //Else, if the object is a subject of a collection of resources, we must append the "rdf:parseType=Collection" attribute to the predicate node else if (graph.GraphMetadata.Collections.Keys.Any(k => k.Equals(triple.Object)) && graph.GraphMetadata.Collections.Single(c => c.Key.Equals(triple.Object)).Value.ItemType == RDFModelEnums.RDFItemType.Resource && !floatingCollections) { XmlAttribute rdfParseType = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":parseType", RDFVocabulary.RDF.BASE_URI); XmlText rdfParseTypeText = rdfDoc.CreateTextNode("Collection"); rdfParseType.AppendChild(rdfParseTypeText); predNode.Attributes.Append(rdfParseType); //Then we append sequentially the collection elements List <XmlNode> collElements = ReconstructCollection(graph.GraphMetadata, (RDFResource)triple.Object, rdfDoc); collElements.ForEach(c => predNode.AppendChild(c)); } //Else, threat it as a traditional object node else { String objString = triple.Object.ToString(); XmlAttribute predNodeDesc = null; XmlText predNodeDescText = rdfDoc.CreateTextNode(objString); // rdf:nodeID="blankID"> if (objString.StartsWith("bnode:")) { predNodeDescText.InnerText = predNodeDescText.InnerText.Replace("bnode:", String.Empty); predNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":nodeID", RDFVocabulary.RDF.BASE_URI); } // rdf:resource="objURI"> else { predNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":resource", RDFVocabulary.RDF.BASE_URI); } predNodeDesc.AppendChild(predNodeDescText); predNode.Attributes.Append(predNodeDesc); } } #endregion #region literal else { #region plain literal if (triple.Object is RDFPlainLiteral) { RDFPlainLiteral pLit = (RDFPlainLiteral)triple.Object; // xml:lang="plitLANG"> if (pLit.Language != String.Empty) { XmlAttribute plainLiteralLangNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.XML.PREFIX + ":lang", RDFVocabulary.XML.BASE_URI); XmlText plainLiteralLangNodeDescText = rdfDoc.CreateTextNode(pLit.Language); plainLiteralLangNodeDesc.AppendChild(plainLiteralLangNodeDescText); predNode.Attributes.Append(plainLiteralLangNodeDesc); } } #endregion #region typed literal // rdf:datatype="tlitURI"> else { RDFTypedLiteral tLit = (RDFTypedLiteral)triple.Object; XmlAttribute typedLiteralNodeDesc = rdfDoc.CreateAttribute(RDFVocabulary.RDF.PREFIX + ":datatype", RDFVocabulary.RDF.BASE_URI); XmlText typedLiteralNodeDescText = rdfDoc.CreateTextNode(RDFModelUtilities.GetDatatypeFromEnum(tLit.Datatype)); typedLiteralNodeDesc.AppendChild(typedLiteralNodeDescText); predNode.Attributes.Append(typedLiteralNodeDesc); } #endregion //litVALUE</predPREF:predURI>" XmlText litNodeDescText = rdfDoc.CreateTextNode(((RDFLiteral)triple.Object).Value); predNode.AppendChild(litNodeDescText); } #endregion subjNode.AppendChild(predNode); } } //Raw containers must not be written as-is, instead they have to be saved //and attached when their subj is found later as object of a triple if (!subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Bag", StringComparison.Ordinal) && !subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Seq", StringComparison.Ordinal) && !subjNode.Name.Equals(RDFVocabulary.RDF.PREFIX + ":Alt", StringComparison.Ordinal)) { rdfRoot.AppendChild(subjNode); } #endregion } #endregion rdfDoc.AppendChild(rdfRoot); #endregion rdfDoc.Save(rdfxmlWriter); } #endregion } catch (Exception ex) { throw new RDFModelException("Cannot serialize Xml because: " + ex.Message, ex); } }
/// <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> /// Serializes the given store to the given filepath using N-Quads data format. /// </summary> internal static void Serialize(RDFStore store, Stream outputStream) { try { #region serialize using (StreamWriter sw = new StreamWriter(outputStream, Encoding.ASCII)) { String quadrupleTemplate = String.Empty; foreach (var q in store.SelectAllQuadruples()) { #region template if (q.TripleFlavor == RDFModelEnums.RDFTripleFlavor.SPO) { quadrupleTemplate = "<{SUBJ}> <{PRED}> <{OBJ}> <{CTX}> ."; } else { if (q.Object is RDFPlainLiteral) { quadrupleTemplate = "<{SUBJ}> <{PRED}> \"{VAL}\"@{LANG} <{CTX}> ."; } else { quadrupleTemplate = "<{SUBJ}> <{PRED}> \"{VAL}\"^^<{DTYPE}> <{CTX}> ."; } } #endregion #region subj if (((RDFResource)q.Subject).IsBlank) { quadrupleTemplate = quadrupleTemplate.Replace("<{SUBJ}>", RDFModelUtilities.Unicode_To_ASCII(q.Subject.ToString()).Replace("bnode:", "_:")); } else { quadrupleTemplate = quadrupleTemplate.Replace("{SUBJ}", RDFModelUtilities.Unicode_To_ASCII(q.Subject.ToString())); } #endregion #region pred quadrupleTemplate = quadrupleTemplate.Replace("{PRED}", RDFModelUtilities.Unicode_To_ASCII(q.Predicate.ToString())); #endregion #region object if (q.TripleFlavor == RDFModelEnums.RDFTripleFlavor.SPO) { if (((RDFResource)q.Object).IsBlank) { quadrupleTemplate = quadrupleTemplate.Replace("<{OBJ}>", RDFModelUtilities.Unicode_To_ASCII(q.Object.ToString())).Replace("bnode:", "_:"); } else { quadrupleTemplate = quadrupleTemplate.Replace("{OBJ}", RDFModelUtilities.Unicode_To_ASCII(q.Object.ToString())); } } #endregion #region literal else { quadrupleTemplate = quadrupleTemplate.Replace("{VAL}", RDFModelUtilities.Unicode_To_ASCII(((RDFLiteral)q.Object).Value.Replace("\"", "\\\""))); quadrupleTemplate = quadrupleTemplate.Replace("\n", "\\n") .Replace("\t", "\\t") .Replace("\r", "\\r"); #region plain literal if (q.Object is RDFPlainLiteral) { if (((RDFPlainLiteral)q.Object).Language != String.Empty) { quadrupleTemplate = quadrupleTemplate.Replace("{LANG}", ((RDFPlainLiteral)q.Object).Language); } else { quadrupleTemplate = quadrupleTemplate.Replace("@{LANG}", String.Empty); } } #endregion #region typed literal else { quadrupleTemplate = quadrupleTemplate.Replace("{DTYPE}", RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)q.Object).Datatype)); } #endregion } #endregion #region context quadrupleTemplate = quadrupleTemplate.Replace("{CTX}", RDFModelUtilities.Unicode_To_ASCII(q.Context.ToString())); #endregion sw.WriteLine(quadrupleTemplate); } } #endregion } catch (Exception ex) { throw new RDFStoreException("Cannot serialize N-Quads because: " + ex.Message, ex); } }
/// <summary> /// Serializes the given graph to the given stream using Turtle data format. /// </summary> internal static void Serialize(RDFGraph graph, Stream outputStream) { try { #region serialize using (StreamWriter sw = new StreamWriter(outputStream, Encoding.UTF8)) { #region prefixes //Write the namespaces collected by the graph foreach (var ns in graph.GraphMetadata.Namespaces.OrderBy(n => n.Prefix)) { sw.WriteLine("@prefix " + ns.Prefix + ": <" + ns.Namespace + ">."); } sw.WriteLine("@base <" + graph.Context + ">.\n"); #endregion #region linq //Group the graph's triples by subj and pred var groupedList = (from triple in graph orderby triple.Subject.ToString(), triple.Predicate.ToString() group triple by new { subj = triple.Subject.ToString(), pred = triple.Predicate.ToString() }); var groupedListLast = groupedList.Last(); #endregion #region triples String actualSubj = String.Empty; String abbreviatedSubj = String.Empty; String actualPred = String.Empty; String abbreviatedPred = String.Empty; const String spaceConst = " "; StringBuilder result = new StringBuilder(); //Iterate over the calculated groups foreach (var group in groupedList) { var groupLast = group.Last(); //Reset the flag of subj printing for the new iteration Boolean subjPrint = false; #region subj //New subj found: write the finished Turtle token to the file, then start collecting the new one if (!actualSubj.Equals(group.Key.subj, StringComparison.Ordinal)) { if (result.Length > 0) { result.Replace(";", ".", result.Length - 4, 1); sw.Write(result.ToString()); result.Remove(0, result.Length - 1); } actualSubj = group.Key.subj; actualPred = String.Empty; if (!actualSubj.StartsWith("_:")) { abbreviatedSubj = RDFModelUtilities.AbbreviateNamespace(actualSubj); } else { abbreviatedSubj = actualSubj; } result.Append(abbreviatedSubj + " "); subjPrint = true; } #endregion #region predObjList //Iterate over the triples of the current group foreach (var triple in group) { #region pred //New pred found: collect it to the actual Turtle token. if (!actualPred.Equals(triple.Predicate.ToString(), StringComparison.Ordinal)) { if (!subjPrint) { result.Append(spaceConst.PadRight(abbreviatedSubj.Length + 1)); //pretty-printing spaces to align the predList } actualPred = triple.Predicate.ToString(); abbreviatedPred = RDFModelUtilities.AbbreviateNamespace(actualPred); //Turtle goody for "rdf:type" shortcutting to "a" if (abbreviatedPred == RDFVocabulary.RDF.PREFIX + ":type") { abbreviatedPred = "a"; } result.Append(abbreviatedPred + " "); } #endregion #region object //Collect the object or the literal to the Turtle token if (triple.TripleFlavor == RDFModelEnums.RDFTripleFlavor.SPO) { String obj = triple.Object.ToString(); if (!obj.StartsWith("_:")) { result.Append(RDFModelUtilities.AbbreviateNamespace(obj)); } else { result.Append(obj); } } #endregion #region literal else { //Detect presence of long-literals var litValDelim = "\""; if (regexTTL.Match(triple.Object.ToString()).Success) { litValDelim = "\"\"\""; } if (triple.Object is RDFTypedLiteral) { String tLit = litValDelim + ((RDFTypedLiteral)triple.Object).Value.Replace("\"", "\\\"") + litValDelim + "^^" + RDFModelUtilities.GetDatatypeFromEnum(((RDFTypedLiteral)triple.Object).Datatype); result.Append(RDFModelUtilities.AbbreviateNamespace(tLit)); } else { String pLit = litValDelim + ((RDFPlainLiteral)triple.Object).Value.Replace("\"", "\\\"") + litValDelim; if (((RDFPlainLiteral)triple.Object).Language != String.Empty) { pLit = pLit + "@" + ((RDFPlainLiteral)triple.Object).Language; } result.Append(pLit); } } #endregion #region continuation goody //Then append the appropriated Turtle continuation goody ("," or ";") if (!triple.Equals(groupLast)) { result.Append(", "); } else { result.AppendLine("; "); } #endregion } #endregion #region last group //This is only for the last group, which is not written into the cycle as the others if (group.Key.Equals(groupedListLast.Key)) { result.Replace(";", ".", result.Length - 4, 1); sw.Write(result.ToString()); } #endregion } #endregion } #endregion } catch (Exception ex) { throw new RDFModelException("Cannot serialize Turtle because: " + ex.Message, ex); } }
/// <summary> /// Gives the string representation of the filter /// </summary> public override String ToString() { return("FILTER ( DATATYPE(" + this.Variable + ") = <" + RDFModelUtilities.GetDatatypeFromEnum(this.Datatype) + "> )"); }
internal override string ToString(List <RDFNamespace> prefixes) => string.Concat( "FILTER ( DATATYPE(", this.Variable, ") = ", RDFQueryPrinter.PrintPatternMember(RDFQueryUtilities.ParseRDFPatternMember(RDFModelUtilities.GetDatatypeFromEnum(this.Datatype)), prefixes), " )");