/** Obsolete since constraints violation are expressed in rdf first * Creates an RDF representation (instances of spin:ConstraintViolation) from a * collection of ConstraintViolation Java objects. * @param cvs the violation objects * @param result the Model to add the results to * @param createSource true to also create the spin:violationSource */ public static void addConstraintViolationsRDF(List <ConstraintViolation> cvs, IGraph result, bool createSource) { foreach (ConstraintViolation cv in cvs) { INode r = SPIN.ConstraintViolation; String message = cv.getMessage(); if (message != null && message.Length > 0) { result.Assert(r, RDFS.label, RDFUtil.CreateLiteralNode(message)); } if (cv.getRoot() != null) { result.Assert(r, SPIN.violationRoot, cv.getRoot()); } foreach (SimplePropertyPath path in cv.getPaths()) { if (path is ObjectPropertyPath) { result.Assert(r, SPIN.violationPath, path.getPredicate()); } else { INode p = RDFUtil.nodeFactory.CreateBlankNode(Guid.NewGuid().ToString()); result.Assert(p, RDF.type, SP.ReversePath); result.Assert(p, SP.path, path.getPredicate()); result.Assert(r, SPIN.violationPath, p); } } if (createSource && cv.getSource() != null) { result.Assert(r, SPIN.violationSource, cv.getSource()); } } }
/** * Creates a new Variable as a blank node in a given Model. * @param model the Model * @param varName the name of the variable * @return the Variable */ public static IVariable createVariable(SpinProcessor model, String varName) { IVariable variable = (IVariable)model.CreateResource(SP.ClassVariable).As(typeof(VariableImpl)); variable.AddProperty(SP.PropertyVarName, RDFUtil.CreateLiteralNode(varName)); return(variable); }
/* * * Creates a new spl:Attribute as a blank node in a given Model. * @param model the Model to create the attribute in * @param argProperty the predicate or null * @param argType the value type or null * @param minCount the minimum cardinality or null * @param maxCount the maximum cardinality or null * @return a new Attribute */ public static IAttribute createAttribute(SpinProcessor model, INode argProperty, INode argType, int minCount, int maxCount) { IAttribute a = (IAttribute)model.CreateResource(SPL.ClassAttribute).As(typeof(AttributeImpl)); if (argProperty != null) { a.AddProperty(SPL.PropertyPredicate, argProperty); } if (argType != null) { a.AddProperty(SPL.PropertyValueType, argType); } a.AddProperty(SPL.PropertyMinCount, RDFUtil.CreateLiteralNode(minCount.ToString(), XSD.DatatypeInt.Uri)); a.AddProperty(SPL.PropertyMaxCount, RDFUtil.CreateLiteralNode(maxCount.ToString(), XSD.DatatypeInt.Uri)); return(a); }
// TODO Should not be needed since we would rely on the underlying storage capabilities /** * Creates a new Values element. * @param model the Model to create the Values in * @param data the Table providing the actual data * @return a new Values */ public static IValues createValues(SpinProcessor model, SparqlResultSet data, bool untyped) { IResource blank = untyped ? model.CreateResource() : model.CreateResource(SP.ClassValues); IValues values = (IValues)blank.As(typeof(ValuesImpl)); List <IResource> vars = new List <IResource>(); foreach (String varName in data.Variables) { vars.Add(Resource.Get(RDFUtil.CreateLiteralNode(varName), model)); } IResource varList = model.CreateList(vars.GetEnumerator()); values.AddProperty(SP.PropertyVarNames, varList); IEnumerator <SparqlResult> bindings = data.Results.GetEnumerator(); if (bindings.MoveNext()) { List <IResource> lists = new List <IResource>(); while (bindings.MoveNext()) { List <IResource> nodes = new List <IResource>(); SparqlResult binding = bindings.Current; foreach (String varName in data.Variables) { INode value = binding.Value(varName); if (value == null) { nodes.Add(Resource.Get(SP.ClassPropertyUndef, model)); } else { nodes.Add(Resource.Get(value, model)); } } lists.Add(model.CreateList(nodes.GetEnumerator())); } values.AddProperty(SP.PropertyBindings, model.CreateList(lists.GetEnumerator())); } return(values); }
private static SparqlParameterizedString convertAskToConstruct(SparqlParameterizedString ask, IQuery spinQuery, String label) { if (label == null) { label = spinQuery.getComment(); } StringBuilder sb = new StringBuilder(); sb.Append("\nCONSTRUCT {\n"); sb.Append("\t_:bnode a <" + SPIN.ConstraintViolation.Uri.ToString() + "> . \n"); sb.Append("\t_:bnode <" + SPIN.violationRoot.Uri.ToString() + "> ?" + SPIN.THIS_VAR_NAME + " . \n"); if (label != null) { // TODO handle literal escaping sb.Append("\t_:bnode <" + RDFS.label.Uri.ToString() + "> \"\"\"" + RDFUtil.CreateLiteralNode(label).ToString() + "\"\"\" . \n"); } sb.Append("}\n"); /* * SparqlQuery construct = SparqlUtil._sparqlParser.ParseFromString(ask); * //construct.setQueryConstructType(); * * List<TriplePattern> list = new List<TriplePattern>(); * INode subject = RDFUtil.nodeFactory.CreateBlankNode(); * list.Add(new TriplePattern(construct., RDF.type, SPIN.ConstraintViolation)); * list.Add(new Triple(subject, SPIN.violationRoot, RDFUtil.CreateLiteralNode(SPIN.THIS_VAR_NAME))); * * Bgp bgp = new Bgp(list); * construct.ConstructTemplate = new GraphPattern(); * construct.ConstructTemplate. * //com.hp.hpl.jena.sparql.syntax.Template template = new com.hp.hpl.jena.sparql.syntax.Template(bgp); * // * //Element where = construct.getQueryPattern(); * //construct.RootGraphPattern(where); * */ return(new SparqlParameterizedString(ask.CommandText.Replace("ASK", sb.ToString()))); }