/// <summary> /// Updates the properties of a resource in the backing RDF store. /// </summary> /// <param name="resource">Resource that is to be updated in the backing store.</param> /// <param name="transaction">Transaction associated with this action.</param> public virtual void UpdateResource(Resource resource, ITransaction transaction = null) { string updateString; if (resource.IsNew) { updateString = string.Format(@"WITH {0} INSERT {{ {1} }} WHERE {{}}", SparqlSerializer.SerializeUri(Uri), SparqlSerializer.SerializeResource(resource, IgnoreUnmappedProperties)); } else { updateString = string.Format(@"WITH {0} DELETE {{ {1} ?p ?o. }} INSERT {{ {2} }} WHERE {{ OPTIONAL {{ {1} ?p ?o. }} }}", SparqlSerializer.SerializeUri(Uri), SparqlSerializer.SerializeUri(resource.Uri), SparqlSerializer.SerializeResource(resource, IgnoreUnmappedProperties)); } SparqlUpdate update = new SparqlUpdate(updateString) { Resource = resource }; ExecuteUpdate(update, transaction); resource.IsNew = false; resource.IsSynchronized = true; }
/// <summary> /// Updates the properties of a resource in the backing RDF store. /// </summary> /// <param name="resource">Resource that is to be updated in the backing store.</param> /// <param name="transaction">ransaction associated with this action.</param> public void UpdateResource(Resource resource, ITransaction transaction = null) { string updateString; if (resource.IsNew) { updateString = string.Format(@"WITH {0} INSERT {{ {1} }} WHERE {{}}", SparqlSerializer.SerializeUri(Uri), SparqlSerializer.SerializeResource(resource)); } else { updateString = string.Format(@"WITH {0} DELETE {{ {1} ?p ?o. }} INSERT {{ {2} }} WHERE {{ {1} ?p ?o. }} ", SparqlSerializer.SerializeUri(Uri), SparqlSerializer.SerializeUri(resource.Uri), SparqlSerializer.SerializeResource(resource)); } SparqlUpdate update = new SparqlUpdate(updateString); update.Resource = resource; ExecuteUpdate(update, transaction); resource.IsNew = false; }
public override string ToString() { SparqlQuery query = new SparqlQuery(SparqlSerializer.Serialize(_model, _query)); query.Model = _model; return(query.ToString()); }
/// <summary> /// Generate the Dataset for a single model /// </summary> /// <param name="model"></param> /// <returns></returns> public static string GenerateDatasetClause(IModel model) { if (model == null) { return(""); } if (model is IModelGroup) { return(GenerateDatasetClause(model as IModelGroup)); } return("FROM " + SparqlSerializer.SerializeUri(model.Uri) + " "); }
/// <summary> /// Generate a dataset clause for an enumeration of models. /// </summary> /// <param name="models">An enumeration of models.</param> /// <returns></returns> public static string GenerateDatasetClause(IEnumerable <IModel> models) { if (!models.Any()) { return(""); } StringBuilder resultBuilder = new StringBuilder(); foreach (var model in models) { resultBuilder.Append("FROM "); resultBuilder.Append(SparqlSerializer.SerializeUri(model.Uri)); resultBuilder.Append(" "); } return(resultBuilder.ToString()); }
public IEnumerable <T> GetResources <T>(int offset = -1, int limit = -1) where T : Resource { _query.Offset = offset; _query.Limit = limit; if (_inferenceEnabled) { SparqlQuery uriQuery = new SparqlQuery(SparqlSerializer.Serialize(_model, _query, true)); StringBuilder uris = new StringBuilder(); var uriList = FetchUris(uriQuery).ToList(); foreach (Uri u in uriList) { if (u != null) { uris.Append(SparqlSerializer.SerializeUri(u)); } } if (!uriList.Any()) { return(new List <T>()); } SparqlQuery query = new SparqlQuery(string.Format("DESCRIBE {0} {1}", uris, SparqlSerializer.GenerateDatasetClause(_model))); ISparqlQueryResult res = _model.ExecuteQuery(query); if (IsSorted) { return(res.GetResources <T>().OrderBy(o => { return (o != null) ? uriList.IndexOf(o.Uri) : -1; })); } else { return(res.GetResources <T>()); } } else { SparqlQuery query = new SparqlQuery(SparqlSerializer.Serialize(_model, _query)); return(_model.ExecuteQuery(query, _inferenceEnabled).GetResources <T>()); } }
public int Count() { SparqlQuery query = new SparqlQuery(SparqlSerializer.SerializeCount(_model, _query)); ISparqlQueryResult result = _model.ExecuteQuery(query, _inferenceEnabled); IEnumerable <BindingSet> bindings = result.GetBindings(); if (bindings != null) { foreach (BindingSet b in bindings) { if (b.ContainsKey("count")) { return((int)b["count"]); } } } return(-1); }
/// <summary> /// Set the value for a query parameter which is preceeded by '@'. /// </summary> /// <param name="parameter">The parameter name including the '@'.</param> /// <param name="value">The paramter value.</param> public void Bind(string parameter, object value) { if (string.IsNullOrEmpty(parameter)) { throw new ArgumentException("Empty or null value for SPARQL query parameter."); } else if (parameter[0] != '@') { throw new ArgumentException("SPARQL query parameters must start with '@'."); } else if (value == null) { throw new ArgumentNullException("SPARQL query parameter values may not be null."); } else if (ParameterTypes[parameter] == CustomToken.GRAPHPARAMETER) { if (ParameterValues.ContainsKey(parameter)) { string g = ParameterValues[parameter]; DefaultGraphs.Remove(g); } string uri = SparqlSerializer.SerializeValue(value); string url = uri.TrimStart('<').TrimEnd('>'); if (DefaultGraphs.Contains(url)) { throw new ArgumentException("FROM parameter value {0} is already set. Have you previously set the model property of the query?", uri); } DefaultGraphs.Add(url); ParameterValues[parameter] = uri; } else { ParameterValues[parameter] = SparqlSerializer.SerializeValue(value); } }
/// <summary> /// Return the query with all bound variables. /// </summary> /// <param name="outputLevel">Level of the sub graph to be returned (0 := entire query).</param> /// <returns></returns> protected string Serialize(int outputLevel = 0) { StringBuilder outputBuilder = new StringBuilder(); // The current iteration depth. int level = 0; for (int i = 0; i < Tokens.Count; i++) { IToken token = Tokens[i]; if (token.TokenType == Token.LEFTCURLYBRACKET) { level += 1; // Do not output the brackets at the output level. if (level == outputLevel) { continue; } } else if (token.TokenType == Token.RIGHTCURLYBRACKET) { level -= 1; } if (level < outputLevel) { continue; } switch (token.TokenType) { default: { outputBuilder.Append(token.Value); outputBuilder.Append(' '); break; } case Token.URI: { outputBuilder.AppendFormat("<{0}> ", token.Value); break; } case Token.LITERAL: case Token.LONGLITERAL: { IToken next = i < Tokens.Count ? Tokens[i + 1] : null; outputBuilder.Append(SparqlSerializer.SerializeString(token.Value)); if (next.TokenType != Token.LANGSPEC) { outputBuilder.Append(' '); } break; } case Token.LANGSPEC: { outputBuilder.AppendFormat("@{0} ", token.Value); break; } case Token.HATHAT: { outputBuilder.Append(token.Value); break; } case CustomToken.PARAMETER: case CustomToken.GRAPHPARAMETER: { string key = token.Value; if (!ParameterValues.ContainsKey(key)) { string msg = string.Format("No value set for query parameter {0}.", key); throw new KeyNotFoundException(msg); } outputBuilder.Append(ParameterValues[key]); outputBuilder.Append(' '); break; } } } return(outputBuilder.ToString().Trim()); }
public T GetResource <T>(Uri uri, ITransaction transaction = null) where T : Resource { SparqlQuery query = new SparqlQuery(String.Format("DESCRIBE {0} {1}", SparqlSerializer.SerializeUri(uri), DatasetClause)); ISparqlQueryResult result = ExecuteQuery(query, transaction: transaction); IList resources = result.GetResources <T>().ToList(); if (resources.Count > 0) { T res = resources[0] as T; res.IsNew = false; res.IsSynchronized = true; res.IsReadOnly = true; res.SetModel(this); return(res); } else { string msg = "Error: Could not find resource <{0}>."; throw new ArgumentException(string.Format(msg, uri)); } }
public bool ContainsResource(Uri uri, ITransaction transaction = null) { return(ExecuteQuery(new SparqlQuery(string.Format(@"ASK {0} {{ {1} ?p ?o . }}", DatasetClause, SparqlSerializer.SerializeUri(uri))), transaction: transaction).GetAnwser()); }
void UpdateDatasetClause() { _datasetClause = SparqlSerializer.GenerateDatasetClause(_set); }
public override string ToString() { return(SparqlSerializer.Serialize(null, this)); }