internal static INode ToSpinRdf(this ISparqlOrderBy ordering, IGraph g, SpinVariableTable varTable) { INode o = g.CreateBlankNode(); INode rdfFirst = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfListFirst)); INode rdfRest = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfListRest)); INode rdfNil = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfListNil)); INode expr = g.CreateUriNode(new Uri(SpinPropertyExpression)); INode item = null; do { if (item == null) { item = g.CreateBlankNode(); } else { INode temp = g.CreateBlankNode(); g.Assert(o, rdfRest, temp); item = temp; ordering = ordering.Child; } g.Assert(o, rdfFirst, item); //TODO: Convert Expression //g.Assert(o, expr, ordering.E } while (ordering.Child != null); return(o); }
internal static INode ToSpinRdf(this ISparqlOrderBy ordering, IGraph g, SpinVariableTable varTable) { INode o = g.CreateBlankNode(); INode item = null; do { if (item == null) { item = g.CreateBlankNode(); } else { INode temp = g.CreateBlankNode(); g.Assert(o, RDF.PropertyRest, temp); item = temp; ordering = ordering.Child; } g.Assert(o, RDF.PropertyFirst, item); //TODO: Convert Expression //g.Assert(o, SP.expression, ordering.E } while (ordering.Child != null); return(o); }
internal static INode ToSpinRdf(this PatternItem item, IGraph g, SpinVariableTable varTable) { INode i; if (item is NodeMatchPattern) { i = ((NodeMatchPattern)item).Node; } else if (item is VariablePattern) { //i = g.CreateUriNode(new Uri(SPIN.NS_URI + "_" + item.VariableName)); i = varTable[item.VariableName]; g.Assert(i, SP.PropertyVarName, g.CreateLiteralNode(item.VariableName, XSD.string_.Uri)); } else if (item is BlankNodePattern) { throw new NotImplementedException(); } else if (item is FixedBlankNodePattern) { throw new SpinException("Skolem Blank INode syntax extension is not representable in SPIN RDF Syntax"); } else { throw new SpinException("Unknown Pattern Items are not representable in SPIN RDF Syntax"); } return(i.CopyNode(g)); }
internal static INode ToSpinRdf(this PatternItem item, IGraph g, SpinVariableTable varTable) { INode i; IUriNode varName = g.CreateUriNode(new Uri(SpinPropertyVariableName)); if (item is NodeMatchPattern) { i = ((NodeMatchPattern)item).Node; } else if (item is VariablePattern) { //i = g.CreateUriNode(new Uri(SpinNamespace + "_" + item.VariableName)); i = varTable[item.VariableName]; g.Assert(i, varName, g.CreateLiteralNode(item.VariableName, new Uri(XmlSpecsHelper.XmlSchemaDataTypeString))); } else if (item is BlankNodePattern) { throw new NotImplementedException(); } else if (item is FixedBlankNodePattern) { throw new SpinException("Skolem Blank Node syntax extension is not representable in SPIN RDF Syntax"); } else { throw new SpinException("Unknown Pattern Items are not representable in SPIN RDF Syntax"); } return(i.CopyNode(g)); }
internal static INode ToSpinRdf(this IToken t, IGraph g, SpinVariableTable varTable) { switch (t.TokenType) { case Token.QNAME: case Token.URI: return(ParserHelper.TryResolveUri(g, t)); case Token.VARIABLE: return(varTable[t.Value]); default: throw new SpinException("Unable to convert a Graph/Service Specifier which is not a QName/URI/Variable to SPIN RDF Syntax"); } }
internal static INode ToSpinRdf(this ITriplePattern pattern, IGraph g, SpinVariableTable varTable) { INode p = g.CreateBlankNode(); INode rdfType = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)); if (pattern is TriplePattern) { TriplePattern tp = (TriplePattern)pattern; //g.Assert(p, rdfType, g.CreateUriNode(new Uri(SpinClassTriplePattern))); g.Assert(p, g.CreateUriNode(new Uri(SpinPropertySubject)), tp.Subject.ToSpinRdf(g, varTable)); g.Assert(p, g.CreateUriNode(new Uri(SpinPropertyPredicate)), tp.Predicate.ToSpinRdf(g, varTable)); g.Assert(p, g.CreateUriNode(new Uri(SpinPropertyObject)), tp.Object.ToSpinRdf(g, varTable)); } else if (pattern is SubQueryPattern) { g.Assert(p, rdfType, g.CreateUriNode(new Uri(SpinClassSubQuery))); g.Assert(p, g.CreateUriNode(new Uri(SpinPropertyQuery)), ((SubQueryPattern)pattern).SubQuery.ToSpinRdf(g)); } else if (pattern is FilterPattern) { g.Assert(p, rdfType, g.CreateUriNode(new Uri(SpinClassFilter))); g.Assert(p, g.CreateUriNode(new Uri(SpinPropertyExpression)), ((FilterPattern)pattern).Filter.Expression.ToSpinRdf(g, varTable)); } else if (pattern is PropertyPathPattern) { PropertyPathPattern pp = (PropertyPathPattern)pattern; g.Assert(p, rdfType, g.CreateUriNode(new Uri(SpinClassTriplePath))); g.Assert(p, g.CreateUriNode(new Uri(SpinPropertySubject)), pp.Subject.ToSpinRdf(g, varTable)); g.Assert(p, g.CreateUriNode(new Uri(SpinPropertyPath)), pp.Path.ToSpinRdf(g, varTable)); g.Assert(p, g.CreateUriNode(new Uri(SpinPropertyObject)), pp.Object.ToSpinRdf(g, varTable)); } else if (pattern is LetPattern) { g.Assert(p, rdfType, g.CreateUriNode(new Uri(SpinClassLet))); INode var = g.CreateBlankNode(); g.Assert(p, g.CreateUriNode(new Uri(SpinPropertyVariable)), var); g.Assert(var, g.CreateUriNode(new Uri(SpinPropertyVariableName)), g.CreateLiteralNode(((LetPattern)pattern).VariableName, new Uri(XmlSpecsHelper.XmlSchemaDataTypeString))); g.Assert(p, g.CreateUriNode(new Uri(SpinPropertyExpression)), ((LetPattern)pattern).AssignExpression.ToSpinRdf(g, varTable)); } else if (pattern is BindPattern) { throw new SpinException("SPARQL 1.1 BINDs are not representable in SPIN RDF Syntax"); } return(p); }
internal static INode ToSpinRdf(this ITriplePattern pattern, IGraph g, SpinVariableTable varTable) { INode p = g.CreateBlankNode(); if (pattern is TriplePattern) { TriplePattern tp = (TriplePattern)pattern; g.Assert(p, RDF.PropertyType, SP.ClassTriplePattern); g.Assert(p, SP.PropertySubject, tp.Subject.ToSpinRdf(g, varTable)); g.Assert(p, SP.PropertyPredicate, tp.Predicate.ToSpinRdf(g, varTable)); g.Assert(p, SP.PropertyObject, tp.Object.ToSpinRdf(g, varTable)); } else if (pattern is SubQueryPattern) { g.Assert(p, RDF.PropertyType, SP.ClassSubQuery); g.Assert(p, SP.PropertyQuery, ((SubQueryPattern)pattern).SubQuery.ToSpinRdf(g)); } else if (pattern is FilterPattern) { g.Assert(p, RDF.PropertyType, SP.ClassFilter); g.Assert(p, SP.PropertyExpression, ((FilterPattern)pattern).Filter.Expression.ToSpinRdf(g, varTable)); } else if (pattern is PropertyPathPattern) { PropertyPathPattern pp = (PropertyPathPattern)pattern; g.Assert(p, RDF.PropertyType, SP.ClassTriplePath); g.Assert(p, SP.PropertySubject, pp.Subject.ToSpinRdf(g, varTable)); g.Assert(p, SP.PropertyPath, pp.Path.ToSpinRdf(g, varTable)); g.Assert(p, SP.PropertyObject, pp.Object.ToSpinRdf(g, varTable)); } else if (pattern is LetPattern) { g.Assert(p, RDF.PropertyType, SP.ClassLet); INode var = g.CreateBlankNode(); g.Assert(p, SP.PropertyVariable, var); g.Assert(var, SP.PropertyVarName, g.CreateLiteralNode(((LetPattern)pattern).VariableName, XSD.string_.Uri)); g.Assert(p, SP.PropertyExpression, ((LetPattern)pattern).AssignExpression.ToSpinRdf(g, varTable)); } else if (pattern is BindPattern) { throw new SpinException("SPARQL 1.1 BINDs are not representable in SPIN RDF Syntax"); } return(p); }
internal static INode ToSpinRdf(this ISparqlAggregate aggregate, IGraph g, SpinVariableTable varTable) { INode a = g.CreateBlankNode(); INode rdfType = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)); if (aggregate is AverageAggregate) { g.Assert(a, rdfType, g.CreateUriNode(new Uri(SpinClassAvg))); } else if (aggregate is CountAggregate) { g.Assert(a, rdfType, g.CreateUriNode(new Uri(SpinClassCount))); } else if (aggregate is MaxAggregate) { g.Assert(a, rdfType, g.CreateUriNode(new Uri(SpinClassMax))); } else if (aggregate is MinAggregate) { g.Assert(a, rdfType, g.CreateUriNode(new Uri(SpinClassMin))); } else if (aggregate is SumAggregate) { g.Assert(a, rdfType, g.CreateUriNode(new Uri(SpinClassSum))); } else if (aggregate is GroupConcatAggregate) { throw new SpinException("GROUP_CONCAT aggregates are not yet representable in SPIN RDF Syntax"); } else if (aggregate is SampleAggregate) { throw new SpinException("SAMPLE aggregates are not yet representable in SPIN RDF Syntax"); } g.Assert(a, g.CreateUriNode(new Uri(SpinPropertyExpression)), aggregate.Expression.ToSpinRdf(g, varTable)); return(a); }
internal static INode ToSpinRdf(this ISparqlPath path, IGraph g, SpinVariableTable varTable) { INode p = g.CreateBlankNode(); return(p); }
internal static INode ToSpinRdf(this SparqlQuery query, IGraph g) { INode root = g.CreateBlankNode(); SpinVariableTable varTable = new SpinVariableTable(g); //Ensure the Query is optimised so that all the elements are placed in Graph Patterns //so we can serialized them OK query.Optimise(); switch (query.QueryType) { case SparqlQueryType.Ask: g.Assert(root, RDF.PropertyType, SP.ClassAsk); break; case SparqlQueryType.Construct: g.Assert(root, RDF.PropertyType, SP.ClassConstruct); break; case SparqlQueryType.Describe: case SparqlQueryType.DescribeAll: throw new SpinException("DESCRIBE queries cannot be represented in SPIN RDF Syntax"); case SparqlQueryType.Select: case SparqlQueryType.SelectAll: case SparqlQueryType.SelectAllDistinct: case SparqlQueryType.SelectAllReduced: case SparqlQueryType.SelectDistinct: case SparqlQueryType.SelectReduced: g.Assert(root, RDF.PropertyType, SP.ClassSelect); break; case SparqlQueryType.Unknown: throw new SpinException("Unknown query types cannot be represented in SPIN RDF Syntax"); } //Process the WHERE clause g.Assert(root, SP.PropertyWhere, query.RootGraphPattern.ToSpinRdf(g, varTable)); //Add Variables for a SELECT query if (SparqlSpecsHelper.IsSelectQuery(query.QueryType)) { switch (query.QueryType) { case SparqlQueryType.Select: case SparqlQueryType.SelectDistinct: case SparqlQueryType.SelectReduced: //Only Add Variables for SELECTs with explicit variable lists INode vars = g.CreateBlankNode(); g.Assert(root, SP.PropertyResultVariables, vars); //Get the Variables and generate the Nodes we'll use to help represent them List <SparqlVariable> vs = query.Variables.Where(v => v.IsResultVariable).ToList(); for (int i = 0; i < vs.Count; i++) { SparqlVariable v = vs[i]; INode var = varTable[v.Name]; g.Assert(vars, RDF.PropertyFirst, var); if (i < vs.Count - 1) { INode temp = g.CreateBlankNode(); g.Assert(vars, RDF.PropertyRest, temp); vars = temp; } // TODO check that was commented before modifications //g.Assert(var, RDF.type, SP.Variable); if (v.IsAggregate) { g.Assert(var, SP.PropertyAs, g.CreateLiteralNode(v.Name, XSD.string_.Uri)); g.Assert(var, SP.PropertyExpression, v.Aggregate.ToSpinRdf(g, varTable)); } else if (v.IsProjection) { g.Assert(var, SP.PropertyAs, g.CreateLiteralNode(v.Name, XSD.string_.Uri)); //TODO check for this //g.Assert(var, SP.expression, v.Projection.ToSpinRdf(query.RootGraphPattern, g, varTable)); } else { g.Assert(var, SP.PropertyVarName, g.CreateLiteralNode(v.Name, XSD.string_.Uri)); } } g.Assert(vars, RDF.PropertyRest, RDF.Nil); break; } } //Add DISTINCT/REDUCED modifiers if appropriate if (query.HasDistinctModifier) { switch (query.QueryType) { case SparqlQueryType.SelectAllDistinct: case SparqlQueryType.SelectDistinct: g.Assert(root, SP.PropertyDistinct, RDFUtil.TRUE); break; case SparqlQueryType.SelectAllReduced: case SparqlQueryType.SelectReduced: g.Assert(root, SP.PropertyReduced, RDFUtil.TRUE); break; } } //Add LIMIT and/or OFFSET if appropriate if (query.Limit > -1) { g.Assert(root, SP.PropertyLimit, query.Limit.ToLiteral(g)); } if (query.Offset > 0) { g.Assert(root, SP.PropertyOffset, query.Offset.ToLiteral(g)); } //Add ORDER BY if appropriate if (query.OrderBy != null) { g.Assert(root, SP.PropertyOrderBy, query.OrderBy.ToSpinRdf(g, varTable)); } //Add GROUP BY and HAVING if (query.GroupBy != null) { throw new SpinException("GROUP BY clauses are not yet representable in SPIN RDF Syntax"); } if (query.Having != null) { throw new SpinException("HAVING clauses are not yet representable in SPIN RDF Syntax"); } return(root); }
internal static INode ToSpinRdf(this ISparqlExpression expr, IGraph g, SpinVariableTable varTable) { INode e = g.CreateBlankNode(); return(e); }
internal static INode ToSpinRdf(this GraphPattern pattern, IGraph g, SpinVariableTable varTable) { INode p = g.CreateBlankNode(); INode ps = p; if (pattern.IsExists) { g.Assert(p, RDF.PropertyType, SP.ClassExists); ps = g.CreateBlankNode(); g.Assert(p, SP.PropertyElements, ps); } else if (pattern.IsGraph) { g.Assert(p, RDF.PropertyType, SP.ClassNamedGraph); INode gSpec = pattern.GraphSpecifier.ToSpinRdf(g, varTable); //g.Assert(p, SP.named, gSpec); // TODO check which is right g.Assert(p, SP.PropertyGraphNameNode, gSpec); // TODO check which is right if (gSpec is IBlankNode) { g.Assert(gSpec, SP.PropertyVarName, pattern.GraphSpecifier.Value.Substring(1).ToLiteral(g)); } ps = g.CreateBlankNode(); g.Assert(p, SP.PropertyElements, ps); } else if (pattern.IsMinus) { g.Assert(p, RDF.PropertyType, SP.ClassMinus); ps = g.CreateBlankNode(); g.Assert(p, SP.PropertyElements, ps); } else if (pattern.IsNotExists) { g.Assert(p, RDF.PropertyType, SP.ClassNotExists); ps = g.CreateBlankNode(); g.Assert(p, SP.PropertyElements, ps); } else if (pattern.IsOptional) { g.Assert(p, RDF.PropertyType, SP.ClassOptional); ps = g.CreateBlankNode(); g.Assert(p, SP.PropertyElements, ps); } else if (pattern.IsService) { g.Assert(p, RDF.PropertyType, SP.ClassService); g.Assert(p, SP.PropertyServiceURI, pattern.GraphSpecifier.ToSpinRdf(g, varTable)); ps = g.CreateBlankNode(); g.Assert(p, SP.PropertyElements, ps); } else if (pattern.IsSubQuery) { g.Assert(p, RDF.PropertyType, SP.ClassSubQuery); ps = g.CreateBlankNode(); g.Assert(p, SP.PropertyQuery, ps); } else if (pattern.IsUnion) { g.Assert(p, RDF.PropertyType, SP.ClassUnion); ps = g.CreateBlankNode(); g.Assert(p, SP.PropertyElements, ps); } if (!pattern.IsEmpty) { //First output Triple Patterns for (int i = 0; i < pattern.TriplePatterns.Count; i++) { INode current = pattern.TriplePatterns[i].ToSpinRdf(g, varTable); if (i == 0) { g.Assert(ps, RDF.PropertyFirst, current); } else { INode temp = g.CreateBlankNode(); g.Assert(ps, RDF.PropertyRest, temp); g.Assert(temp, RDF.PropertyFirst, current); ps = temp; } } if (!pattern.HasChildGraphPatterns) { g.Assert(ps, RDF.PropertyRest, RDF.Nil); } } //Then output Graph Patterns if (pattern.HasChildGraphPatterns) { for (int i = 0; i < pattern.ChildGraphPatterns.Count; i++) { INode current = pattern.ChildGraphPatterns[i].ToSpinRdf(g, varTable); if (pattern.TriplePatterns.Count == 0 && i == 0) { g.Assert(ps, RDF.PropertyFirst, current); } else { INode temp = g.CreateBlankNode(); g.Assert(ps, RDF.PropertyRest, temp); g.Assert(temp, RDF.PropertyFirst, current); ps = temp; } } g.Assert(ps, RDF.PropertyRest, RDF.Nil); } return(p); }
// TODO handle the defaultGraph case internal static INode ToSpinRdf(this SparqlUpdateCommand query, IGraph g) { INode root = g.CreateBlankNode(); SpinVariableTable varTable = new SpinVariableTable(g); switch (query.CommandType) { case SparqlUpdateCommandType.Add: g.Assert(root, RDF.PropertyType, SP.ClassAdd); AddCommand add = (AddCommand)query; if (add.SourceUri == null) { g.Assert(root, SP.PropertyGraphIRI, SP.PropertyDefault); } else { g.Assert(root, SP.PropertyGraphIRI, RDFUtil.CreateUriNode(add.SourceUri)); } if (add.DestinationUri == null) { g.Assert(root, SP.PropertyInto, SP.PropertyDefault); } else { g.Assert(root, SP.PropertyInto, RDFUtil.CreateUriNode(add.DestinationUri)); } break; case SparqlUpdateCommandType.Clear: g.Assert(root, RDF.PropertyType, SP.ClassClear); if (((ClearCommand)query).TargetUri == null) { g.Assert(root, SP.PropertyGraphIRI, SP.PropertyDefault); } else { g.Assert(root, SP.PropertyGraphIRI, RDFUtil.CreateUriNode(((ClearCommand)query).TargetUri)); } break; case SparqlUpdateCommandType.Copy: g.Assert(root, RDF.PropertyType, SP.ClassCopy); CopyCommand copy = (CopyCommand)query; if (copy.SourceUri == null) { g.Assert(root, SP.PropertyGraphIRI, SP.PropertyDefault); } else { g.Assert(root, SP.PropertyGraphIRI, RDFUtil.CreateUriNode(copy.SourceUri)); } if (copy.DestinationUri == null) { g.Assert(root, SP.PropertyInto, SP.PropertyDefault); } else { g.Assert(root, SP.PropertyInto, RDFUtil.CreateUriNode(copy.DestinationUri)); } break; case SparqlUpdateCommandType.Create: g.Assert(root, RDF.PropertyType, SP.ClassCreate); CreateCommand create = (CreateCommand)query; if (create.TargetUri == null) { g.Assert(root, SP.PropertyGraphIRI, SP.PropertyDefault); } else { g.Assert(root, SP.PropertyGraphIRI, RDFUtil.CreateUriNode(create.TargetUri)); } break; case SparqlUpdateCommandType.Delete: g.Assert(root, RDF.PropertyType, SP.ClassModify); DeleteCommand delete = (DeleteCommand)query; if (delete.GraphUri != null) { g.Assert(root, SP.PropertyWith, RDFUtil.CreateUriNode(delete.GraphUri)); } // TODO handle the usings g.Assert(root, SP.PropertyDeletePattern, delete.DeletePattern.ToSpinRdf(g, varTable)); g.Assert(root, SP.PropertyWhere, delete.WherePattern.ToSpinRdf(g, varTable)); break; case SparqlUpdateCommandType.DeleteData: g.Assert(root, RDF.PropertyType, SP.ClassDeleteData); g.Assert(root, SP.PropertyData, ((DeleteDataCommand)query).DataPattern.ToSpinRdf(g, varTable)); break; case SparqlUpdateCommandType.Drop: g.Assert(root, RDF.PropertyType, SP.ClassDrop); DropCommand drop = (DropCommand)query; if (drop.TargetUri == null) { g.Assert(root, SP.PropertyGraphIRI, SP.PropertyDefault); } else { g.Assert(root, SP.PropertyGraphIRI, RDFUtil.CreateUriNode(drop.TargetUri)); } g.Assert(root, SP.PropertyGraphIRI, RDFUtil.CreateUriNode(((DropCommand)query).TargetUri)); break; case SparqlUpdateCommandType.Insert: g.Assert(root, RDF.PropertyType, SP.ClassModify); InsertCommand insert = (InsertCommand)query; if (insert.GraphUri != null) { g.Assert(root, SP.PropertyWith, RDFUtil.CreateUriNode(insert.GraphUri)); } g.Assert(root, SP.PropertyInsertPattern, insert.InsertPattern.ToSpinRdf(g, varTable)); g.Assert(root, SP.PropertyWhere, insert.WherePattern.ToSpinRdf(g, varTable)); break; case SparqlUpdateCommandType.InsertData: g.Assert(root, RDF.PropertyType, SP.ClassInsertData); g.Assert(root, SP.PropertyData, ((InsertDataCommand)query).DataPattern.ToSpinRdf(g, varTable)); break; case SparqlUpdateCommandType.Load: g.Assert(root, RDF.PropertyType, SP.ClassLoad); LoadCommand load = (LoadCommand)query; if (load.SourceUri == null) { g.Assert(root, SP.PropertyGraphIRI, SP.PropertyDefault); } else { g.Assert(root, SP.PropertyGraphIRI, RDFUtil.CreateUriNode(load.SourceUri)); } if (load.TargetUri == null) { g.Assert(root, SP.PropertyInto, SP.PropertyDefault); } else { g.Assert(root, SP.PropertyInto, RDFUtil.CreateUriNode(load.TargetUri)); } break; case SparqlUpdateCommandType.Modify: g.Assert(root, RDF.PropertyType, SP.ClassModify); ModifyCommand modify = (ModifyCommand)query; if (modify.GraphUri != null) { g.Assert(root, SP.PropertyWith, RDFUtil.CreateUriNode(modify.GraphUri)); } if (modify.DeletePattern != null) { g.Assert(root, SP.PropertyDeletePattern, modify.DeletePattern.ToSpinRdf(g, varTable)); } if (modify.InsertPattern != null) { g.Assert(root, SP.PropertyInsertPattern, modify.InsertPattern.ToSpinRdf(g, varTable)); } g.Assert(root, SP.PropertyWhere, modify.WherePattern.ToSpinRdf(g, varTable)); break; case SparqlUpdateCommandType.Move: g.Assert(root, RDF.PropertyType, SP.ClassMove); MoveCommand move = (MoveCommand)query; if (move.SourceUri == null) { g.Assert(root, SP.PropertyGraphIRI, SP.PropertyDefault); } else { g.Assert(root, SP.PropertyGraphIRI, RDFUtil.CreateUriNode(move.SourceUri)); } if (move.DestinationUri == null) { g.Assert(root, SP.PropertyInto, SP.PropertyDefault); } else { g.Assert(root, SP.PropertyInto, RDFUtil.CreateUriNode(move.DestinationUri)); } break; case SparqlUpdateCommandType.Unknown: throw new NotSupportedException("Unkown SPARQL update query encountered " + query.ToString()); } return(root); }
internal static INode ToSpinRdf(this GraphPattern pattern, IGraph g, SpinVariableTable varTable) { INode p = g.CreateBlankNode(); INode ps = p; if (pattern.IsExists) { g.Assert(new Triple(p, g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)), g.CreateUriNode(new Uri(SpinClassExists)))); ps = g.CreateBlankNode(); g.Assert(new Triple(p, g.CreateUriNode(new Uri(SpinPropertyElements)), ps)); } else if (pattern.IsGraph) { g.Assert(new Triple(p, g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)), g.CreateUriNode(new Uri(SpinClassNamedGraph)))); INode gSpec = pattern.GraphSpecifier.ToSpinRdf(g, varTable); g.Assert(new Triple(p, g.CreateUriNode(new Uri(SpinPropertyGraphNameNode)), gSpec)); if (gSpec is IBlankNode) { g.Assert(new Triple(gSpec, g.CreateUriNode(new Uri(SpinPropertyVariableName)), pattern.GraphSpecifier.Value.Substring(1).ToLiteral(g))); } ps = g.CreateBlankNode(); g.Assert(new Triple(p, g.CreateUriNode(new Uri(SpinPropertyElements)), ps)); } else if (pattern.IsMinus) { g.Assert(new Triple(p, g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)), g.CreateUriNode(new Uri(SpinClassMinus)))); ps = g.CreateBlankNode(); g.Assert(new Triple(p, g.CreateUriNode(new Uri(SpinPropertyElements)), ps)); } else if (pattern.IsNotExists) { g.Assert(new Triple(p, g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)), g.CreateUriNode(new Uri(SpinClassNotExists)))); ps = g.CreateBlankNode(); g.Assert(new Triple(p, g.CreateUriNode(new Uri(SpinPropertyElements)), ps)); } else if (pattern.IsOptional) { g.Assert(new Triple(p, g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)), g.CreateUriNode(new Uri(SpinClassOptional)))); ps = g.CreateBlankNode(); g.Assert(new Triple(p, g.CreateUriNode(new Uri(SpinPropertyElements)), ps)); } else if (pattern.IsService) { g.Assert(new Triple(p, g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)), g.CreateUriNode(new Uri(SpinClassService)))); g.Assert(new Triple(p, g.CreateUriNode(new Uri(SpinPropertyServiceUri)), pattern.GraphSpecifier.ToSpinRdf(g, varTable))); ps = g.CreateBlankNode(); g.Assert(new Triple(p, g.CreateUriNode(new Uri(SpinPropertyElements)), ps)); } else if (pattern.IsSubQuery) { g.Assert(new Triple(p, g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)), g.CreateUriNode(new Uri(SpinClassSubQuery)))); ps = g.CreateBlankNode(); g.Assert(new Triple(p, g.CreateUriNode(new Uri(SpinPropertyQuery)), ps)); } else if (pattern.IsUnion) { g.Assert(new Triple(p, g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType)), g.CreateUriNode(new Uri(SpinClassUnion)))); ps = g.CreateBlankNode(); g.Assert(new Triple(p, g.CreateUriNode(new Uri(SpinPropertyElements)), ps)); } INode rdfFirst = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfListFirst)); INode rdfRest = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfListRest)); INode rdfNil = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfListNil)); if (!pattern.IsEmpty) { //First output Triple Patterns for (int i = 0; i < pattern.TriplePatterns.Count; i++) { INode current = pattern.TriplePatterns[i].ToSpinRdf(g, varTable); if (i == 0) { g.Assert(ps, rdfFirst, current); } else { INode temp = g.CreateBlankNode(); g.Assert(ps, rdfRest, temp); g.Assert(temp, rdfFirst, current); ps = temp; } } if (!pattern.HasChildGraphPatterns) { g.Assert(ps, rdfRest, rdfNil); } } //Then output Graph Patterns if (pattern.HasChildGraphPatterns) { for (int i = 0; i < pattern.ChildGraphPatterns.Count; i++) { INode current = pattern.ChildGraphPatterns[i].ToSpinRdf(g, varTable); if (pattern.TriplePatterns.Count == 0 && i == 0) { g.Assert(ps, rdfFirst, current); } else { INode temp = g.CreateBlankNode(); g.Assert(ps, rdfRest, temp); g.Assert(temp, rdfFirst, current); ps = temp; } } g.Assert(ps, rdfRest, rdfNil); } return(p); }