/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
try
{
if (context.Data.HasGraph(this._sourceUri))
{
//Get the Source Graph
IGraph source = context.Data.GetModifiableGraph(this._sourceUri);
//Create/Delete/Clear the Destination Graph
IGraph dest;
if (context.Data.HasGraph(this._destUri))
{
if (this._destUri == null)
{
dest = context.Data.GetModifiableGraph(this._destUri);
dest.Clear();
}
else
{
context.Data.RemoveGraph(this._destUri);
dest = new Graph();
dest.BaseUri = this._destUri;
context.Data.AddGraph(dest);
dest = context.Data.GetModifiableGraph(this._destUri);
}
}
else
{
dest = new Graph();
dest.BaseUri = this._destUri;
context.Data.AddGraph(dest);
}
//Move data from the Source into the Destination
dest.Merge(source);
}
else
{
//Only show error if not Silent
if (!this._silent)
{
if (this._sourceUri != null)
{
throw new SparqlUpdateException("Cannot COPY from Graph <" + this._sourceUri.ToString() + "> as it does not exist");
}
else
{
//This would imply a more fundamental issue with the Dataset not understanding that null means default graph
throw new SparqlUpdateException("Cannot COPY from the Default Graph as it does not exist");
}
}
}
}
catch
{
//If not silent throw the exception upwards
if (!this._silent) throw;
}
}
/// <summary>
/// Executes a set of Update Commands against the Triple Store
/// </summary>
/// <param name="updates">SPARQL Update Command Set</param>
public void ExecuteUpdate(SparqlUpdateCommandSet updates)
{
SparqlUpdateEvaluationContext context = new SparqlUpdateEvaluationContext(new InMemoryDataset(this));
for (int i = 0; i < updates.CommandCount; i++)
{
updates[i].Evaluate(context);
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
try
{
if (context.Data.HasGraph(this._sourceUri))
{
//Get the Source Graph
IGraph source = context.Data.GetModifiableGraph(this._sourceUri);
//Get the Destination Graph
IGraph dest;
if (context.Data.HasGraph(this._destUri))
{
dest = context.Data.GetModifiableGraph(this._destUri);
}
else
{
dest = new Graph();
dest.BaseUri = this._destUri;
}
//Move data from the Source into the Destination
dest.Merge(source);
}
else
{
//Only show error if not Silent
if (!this._silent)
{
if (this._sourceUri != null)
{
throw new SparqlUpdateException("Cannot ADD from Graph <" + this._sourceUri.ToString() + "> as it does not exist");
}
else
{
//This would imply a more fundamental issue with the Dataset not understanding that null means default graph
throw new SparqlUpdateException("Cannot ADD from the Default Graph as it does not exist");
}
}
}
}
catch
{
//If not silent throw the exception upwards
if (!this._silent)
{
throw;
}
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Update Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
if (context.Data.HasGraph(this._graphUri))
{
if (!this._silent)
{
throw new SparqlUpdateException("Cannot create a Named Graph with URI '" + this._graphUri.ToString() + "' since a Graph with this URI already exists in the Store");
}
}
else
{
Graph g = new Graph();
g.BaseUri = this._graphUri;
context.Data.AddGraph(g);
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
//Q: Does LOAD into a named Graph require that Graph to be pre-existing?
//if (this._graphUri != null)
//{
// //When adding to specific Graph need to ensure that Graph exists
// //In the case when we're adding to the default graph we'll create it if it doesn't exist
// if (!context.Data.HasGraph(this._graphUri))
// {
// throw new RdfUpdateException("Cannot LOAD into a Graph that does not exist in the Store");
// }
//}
try
{
//Load from the URI
Graph g = new Graph();
#if SILVERLIGHT
throw new PlatformNotSupportedException("The SPARQL LOAD command is not currently supported under Silverlight/Windows Phone 7");
#else
UriLoader.Load(g, this._sourceUri);
#endif
if (context.Data.HasGraph(this._graphUri))
{
//Merge the Data into the existing Graph
context.Data.GetModifiableGraph(this._graphUri).Merge(g);
}
else
{
//Add New Graph to the Dataset
g.BaseUri = this._graphUri;
context.Data.AddGraph(g);
}
}
catch
{
if (!this._silent)
{
throw;
}
}
}
/// <summary>
/// Evaluates the Command in the given Context.
/// </summary>
/// <param name="context">Evaluation Context.</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
try
{
switch (_mode)
{
case ClearMode.Graph:
case ClearMode.Default:
if (context.Data.HasGraph(_graphUri))
{
context.Data.GetModifiableGraph(_graphUri).Clear();
}
break;
case ClearMode.Named:
foreach (Uri u in context.Data.GraphUris)
{
if (u != null)
{
context.Data.GetModifiableGraph(u).Clear();
}
}
break;
case ClearMode.All:
foreach (Uri u in context.Data.GraphUris)
{
context.Data.GetModifiableGraph(u).Clear();
}
break;
}
}
catch
{
if (!_silent)
{
throw;
}
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
// Q: Does LOAD into a named Graph require that Graph to be pre-existing?
// if (this._graphUri != null)
// {
// //When adding to specific Graph need to ensure that Graph exists
// //In the case when we're adding to the default graph we'll create it if it doesn't exist
// if (!context.Data.HasGraph(this._graphUri))
// {
// throw new RdfUpdateException("Cannot LOAD into a Graph that does not exist in the Store");
// }
// }
try
{
// Load from the URI
Graph g = new Graph();
UriLoader.Load(g, _sourceUri);
if (context.Data.HasGraph(_graphUri))
{
// Merge the Data into the existing Graph
context.Data.GetModifiableGraph(_graphUri).Merge(g);
}
else
{
// Add New Graph to the Dataset
g.BaseUri = _graphUri;
context.Data.AddGraph(g);
}
}
catch
{
if (!_silent)
{
throw;
}
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
//Split the Pattern into the set of Graph Patterns
List <GraphPattern> patterns = new List <GraphPattern>();
if (this._pattern.IsGraph)
{
patterns.Add(this._pattern);
}
else if (this._pattern.TriplePatterns.Count > 0 || this._pattern.HasChildGraphPatterns)
{
if (this._pattern.TriplePatterns.Count > 0)
{
patterns.Add(new GraphPattern());
this._pattern.TriplePatterns.ForEach(tp => patterns[0].AddTriplePattern(tp));
}
this._pattern.ChildGraphPatterns.ForEach(gp => patterns.Add(gp));
}
else
{
//If no Triple Patterns and No Child Graph Patterns nothing to do
return;
}
ConstructContext constructContext = new ConstructContext(null, null, false);
foreach (GraphPattern pattern in patterns)
{
if (!this.IsValidDataPattern(pattern, false))
{
throw new SparqlUpdateException("Cannot evaluate a INSERT DATA command where any of the Triple Patterns are not concrete triples (variables are not permitted) or any of the GRAPH clauses have nested Graph Patterns");
}
//Get the Target Graph
IGraph target;
Uri graphUri;
if (pattern.IsGraph)
{
switch (pattern.GraphSpecifier.TokenType)
{
case Token.QNAME:
throw new NotSupportedException("Graph Specifiers as QNames for INSERT DATA Commands are not supported - please specify an absolute URI instead");
case Token.URI:
graphUri = UriFactory.Create(pattern.GraphSpecifier.Value);
break;
default:
throw new SparqlUpdateException("Cannot evaluate an INSERT DATA Command as the Graph Specifier is not a QName/URI");
}
}
else
{
graphUri = null;
}
if (context.Data.HasGraph(graphUri))
{
target = context.Data.GetModifiableGraph(graphUri);
}
else
{
//If the Graph does not exist then it must be created
target = new Graph();
target.BaseUri = graphUri;
context.Data.AddGraph(target);
}
//Insert the actual Triples
foreach (IConstructTriplePattern p in pattern.TriplePatterns.OfType <IConstructTriplePattern>())
{
INode subj = p.Subject.Construct(constructContext);
INode pred = p.Predicate.Construct(constructContext);
INode obj = p.Object.Construct(constructContext);
target.Assert(new Triple(subj, pred, obj, graphUri));
}
}
}
/// <summary>
/// Executes a single Update Command against the Triple Store
/// </summary>
/// <param name="update">SPARQL Update Command</param>
public void ExecuteUpdate(SparqlUpdateCommand update)
{
SparqlUpdateEvaluationContext context = new SparqlUpdateEvaluationContext(new InMemoryDataset(this));
update.Evaluate(context);
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
bool datasetOk = false;
bool defGraphOk = false;
try
{
//First evaluate the WHERE pattern to get the affected bindings
ISparqlAlgebra where = this._wherePattern.ToAlgebra();
//Set Active Graph for the WHERE
//Don't bother if there are USING URIs as these would override any Active Graph we set here
//so we can save ourselves the effort of doing this
if (!this.UsingUris.Any())
{
if (this._graphUri != null)
{
context.Data.SetActiveGraph(this._graphUri);
defGraphOk = true;
}
else
{
context.Data.SetActiveGraph((Uri)null);
defGraphOk = true;
}
}
//We need to make a dummy SparqlQuery object since if the Command has used any
//USING NAMEDs along with GRAPH clauses then the algebra needs to have the
//URIs available to it which it gets from the Query property of the Context
//object
SparqlQuery query = new SparqlQuery();
foreach (Uri u in this.UsingNamedUris)
{
query.AddNamedGraph(u);
}
SparqlEvaluationContext queryContext = new SparqlEvaluationContext(query, context.Data);
if (this.UsingUris.Any())
{
//If there are USING URIs set the Active Graph to be formed of the Graphs with those URIs
context.Data.SetActiveGraph(this._usingUris);
datasetOk = true;
}
BaseMultiset results = where.Evaluate(queryContext);
if (this.UsingUris.Any())
{
//If there are USING URIs reset the Active Graph afterwards
//Also flag the dataset as no longer being OK as this flag is used in the finally
//block to determine whether the Active Graph needs resetting which it may do if the
//evaluation of the
context.Data.ResetActiveGraph();
datasetOk = false;
}
//Reset Active Graph for the WHERE
if (defGraphOk)
{
context.Data.ResetActiveGraph();
defGraphOk = false;
}
//TODO: Need to detect when we create a Graph for Insertion but then fail to insert anything since in this case the Inserted Graph should be removed
//Get the Graph to which we are inserting
//HashSet<Uri> insertedGraphs = new HashSet<Uri>();
IGraph g;
if (context.Data.HasGraph(this._graphUri))
{
g = context.Data.GetModifiableGraph(this._graphUri);
}
else
{
//insertedGraphs.Add(this._graphUri);
g = new Graph();
g.BaseUri = this._graphUri;
context.Data.AddGraph(g);
g = context.Data.GetModifiableGraph(this._graphUri);
}
//Insert the Triples for each Solution
foreach (Set s in queryContext.OutputMultiset.Sets)
{
List<Triple> insertedTriples = new List<Triple>();
//Triples from raw Triple Patterns
try
{
ConstructContext constructContext = new ConstructContext(g, s, true);
foreach (IConstructTriplePattern p in this._insertPattern.TriplePatterns.OfType<IConstructTriplePattern>())
{
try
{
insertedTriples.Add(p.Construct(constructContext));
}
catch (RdfQueryException)
{
//If we throw an error this means we couldn't construct a specific Triple
//so we continue anyway
}
}
g.Assert(insertedTriples);
}
catch (RdfQueryException)
{
//If we throw an error this means we couldn't construct for this solution so the
//solution is ignored for this graph
}
//Triples from GRAPH clauses
foreach (GraphPattern gp in this._insertPattern.ChildGraphPatterns)
{
insertedTriples.Clear();
try
{
String graphUri;
switch (gp.GraphSpecifier.TokenType)
{
case Token.URI:
graphUri = gp.GraphSpecifier.Value;
break;
case Token.VARIABLE:
if (s.ContainsVariable(gp.GraphSpecifier.Value))
{
INode temp = s[gp.GraphSpecifier.Value.Substring(1)];
if (temp == null)
{
//If the Variable is not bound then skip
continue;
}
else if (temp.NodeType == NodeType.Uri)
{
graphUri = temp.ToSafeString();
}
else
{
//If the Variable is not bound to a URI then skip
continue;
}
}
else
{
//If the Variable is not bound for this solution then skip
continue;
}
break;
default:
//Any other Graph Specifier we have to ignore this solution
continue;
}
//Ensure the Graph we're inserting to exists in the dataset creating it if necessary
IGraph h;
Uri destUri = new Uri(graphUri);
if (context.Data.HasGraph(destUri))
{
h = context.Data.GetModifiableGraph(destUri);
}
else
{
//insertedGraphs.Add(destUri);
h = new Graph();
h.BaseUri = destUri;
context.Data.AddGraph(h);
h = context.Data.GetModifiableGraph(destUri);
}
//Do the actual Insertions
ConstructContext constructContext = new ConstructContext(h, s, true);
foreach (IConstructTriplePattern p in gp.TriplePatterns.OfType<IConstructTriplePattern>())
{
try
{
insertedTriples.Add(p.Construct(constructContext));
}
catch (RdfQueryException)
{
//If we throw an error this means we couldn't construct a specific Triple
//so we continue anyway
}
}
h.Assert(insertedTriples);
}
catch (RdfQueryException)
{
//If we throw an error this means we couldn't construct for this solution so the
//solution is ignored for this Graph
}
}
}
}
finally
{
//If the Dataset was set and an error occurred in doing the WHERE clause then
//we'll need to Reset the Active Graph
if (datasetOk) context.Data.ResetActiveGraph();
if (defGraphOk) context.Data.ResetActiveGraph();
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
//Q: Does LOAD into a named Graph require that Graph to be pre-existing?
//if (this._graphUri != null)
//{
// //When adding to specific Graph need to ensure that Graph exists
// //In the case when we're adding to the default graph we'll create it if it doesn't exist
// if (!context.Data.HasGraph(this._graphUri))
// {
// throw new RdfUpdateException("Cannot LOAD into a Graph that does not exist in the Store");
// }
//}
try
{
//Load from the URI
Graph g = new Graph();
UriLoader.Load(g, this._sourceUri);
if (context.Data.HasGraph(this._graphUri))
{
//Merge the Data into the existing Graph
context.Data.GetModifiableGraph(this._graphUri).Merge(g);
}
else
{
//Add New Graph to the Dataset
g.BaseUri = this._graphUri;
context.Data.AddGraph(g);
}
}
catch
{
if (!this._silent) throw;
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
bool datasetOk = false;
bool defGraphOk = false;
try
{
//First evaluate the WHERE pattern to get the affected bindings
ISparqlAlgebra where = this._wherePattern.ToAlgebra();
if (context.Commands != null)
{
where = context.Commands.ApplyAlgebraOptimisers(where);
}
//Set Active Graph for the WHERE
//Don't bother if there are USING URIs as these would override any Active Graph we set here
//so we can save ourselves the effort of doing this
if (!this.UsingUris.Any())
{
if (this._graphUri != null)
{
context.Data.SetActiveGraph(this._graphUri);
defGraphOk = true;
}
else
{
context.Data.SetActiveGraph((Uri)null);
defGraphOk = true;
}
}
//We need to make a dummy SparqlQuery object since if the Command has used any
//USING NAMEDs along with GRAPH clauses then the algebra needs to have the
//URIs available to it which it gets from the Query property of the Context
//object
SparqlQuery query = new SparqlQuery();
foreach (Uri u in this.UsingUris)
{
query.AddDefaultGraph(u);
}
foreach (Uri u in this.UsingNamedUris)
{
query.AddNamedGraph(u);
}
SparqlEvaluationContext queryContext = new SparqlEvaluationContext(query, context.Data, context.QueryProcessor);
if (this.UsingUris.Any())
{
//If there are USING URIs set the Active Graph to be formed of the Graphs with those URIs
context.Data.SetActiveGraph(this._usingUris);
datasetOk = true;
}
BaseMultiset results = queryContext.Evaluate(where);
if (results is IdentityMultiset)
{
queryContext.OutputMultiset = new SingletonMultiset(results.Variables);
}
if (this.UsingUris.Any())
{
//If there are USING URIs reset the Active Graph afterwards
//Also flag the dataset as no longer being OK as this flag is used in the finally
//block to determine whether the Active Graph needs resetting which it may do if the
//evaluation of the query fails for any reason
context.Data.ResetActiveGraph();
datasetOk = false;
}
//Reset Active Graph for the WHERE
if (defGraphOk)
{
context.Data.ResetActiveGraph();
defGraphOk = false;
}
//TODO: Need to detect when we create a Graph for Insertion but then fail to insert anything since in this case the Inserted Graph should be removed
//Get the Graph to which we are inserting Triples with no explicit Graph clause
IGraph g = null;
if (this._insertPattern.TriplePatterns.Count > 0)
{
if (context.Data.HasGraph(this._graphUri))
{
g = context.Data.GetModifiableGraph(this._graphUri);
}
else
{
//insertedGraphs.Add(this._graphUri);
g = new Graph();
g.BaseUri = this._graphUri;
context.Data.AddGraph(g);
g = context.Data.GetModifiableGraph(this._graphUri);
}
}
//Keep a record of graphs to which we insert
MultiDictionary <Uri, IGraph> graphs = new MultiDictionary <Uri, IGraph>(u => (u != null ? u.GetEnhancedHashCode() : 0), true, new UriComparer(), MultiDictionaryMode.AVL);
//Insert the Triples for each Solution
foreach (ISet s in queryContext.OutputMultiset.Sets)
{
List <Triple> insertedTriples = new List <Triple>();
try
{
//Create a new Construct Context for each Solution
ConstructContext constructContext = new ConstructContext(null, s, true);
//Triples from raw Triple Patterns
if (this._insertPattern.TriplePatterns.Count > 0)
{
foreach (IConstructTriplePattern p in this._insertPattern.TriplePatterns.OfType <IConstructTriplePattern>())
{
try
{
insertedTriples.Add(p.Construct(constructContext));
}
catch (RdfQueryException)
{
//If we throw an error this means we couldn't construct a specific Triple
//so we continue anyway
}
}
g.Assert(insertedTriples);
}
//Triples from GRAPH clauses
foreach (GraphPattern gp in this._insertPattern.ChildGraphPatterns)
{
insertedTriples.Clear();
try
{
String graphUri;
switch (gp.GraphSpecifier.TokenType)
{
case Token.URI:
graphUri = gp.GraphSpecifier.Value;
break;
case Token.VARIABLE:
String graphVar = gp.GraphSpecifier.Value.Substring(1);
if (s.ContainsVariable(graphVar))
{
INode temp = s[graphVar];
if (temp == null)
{
//If the Variable is not bound then skip
continue;
}
else if (temp.NodeType == NodeType.Uri)
{
graphUri = temp.ToSafeString();
}
else
{
//If the Variable is not bound to a URI then skip
continue;
}
}
else
{
//If the Variable is not bound for this solution then skip
continue;
}
break;
default:
//Any other Graph Specifier we have to ignore this solution
continue;
}
//Ensure the Graph we're inserting to exists in the dataset creating it if necessary
IGraph h;
Uri destUri = UriFactory.Create(graphUri);
if (graphs.ContainsKey(destUri))
{
h = graphs[destUri];
}
else
{
if (context.Data.HasGraph(destUri))
{
h = context.Data.GetModifiableGraph(destUri);
}
else
{
//insertedGraphs.Add(destUri);
h = new Graph();
h.BaseUri = destUri;
context.Data.AddGraph(h);
h = context.Data.GetModifiableGraph(destUri);
}
graphs.Add(destUri, h);
}
//Do the actual Insertions
foreach (IConstructTriplePattern p in gp.TriplePatterns.OfType <IConstructTriplePattern>())
{
try
{
insertedTriples.Add(p.Construct(constructContext));
}
catch (RdfQueryException)
{
//If we throw an error this means we couldn't construct a specific Triple
//so we continue anyway
}
}
h.Assert(insertedTriples);
}
catch (RdfQueryException)
{
//If we throw an error this means we couldn't construct for this solution so the
//solution is ignored for this Graph
}
}
}
catch (RdfQueryException)
{
//If we throw an error this means we couldn't construct for this solution so the
//solution is ignored for this graph
}
}
}
finally
{
//If the Dataset was set and an error occurred in doing the WHERE clause then
//we'll need to Reset the Active Graph
if (datasetOk)
{
context.Data.ResetActiveGraph();
}
if (defGraphOk)
{
context.Data.ResetActiveGraph();
}
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
try
{
switch (_mode)
{
case ClearMode.Default:
case ClearMode.Graph:
if (!context.Data.HasGraph(_graphUri))
{
if (!_silent)
{
throw new SparqlUpdateException("Cannot remove a Named Graph with URI '" + _graphUri.AbsoluteUri + "' since a Graph with this URI does not exist in the Store");
}
}
else
{
if (_mode == ClearMode.Graph)
{
context.Data.RemoveGraph(_graphUri);
}
else
{
// DROPing the DEFAULT graph only results in clearing it
// This is because removing the default graph may cause errors in later commands/queries
// which rely on it existing
context.Data.GetModifiableGraph(_graphUri).Clear();
}
}
break;
case ClearMode.Named:
foreach (Uri u in context.Data.GraphUris.ToList())
{
if (u != null)
{
context.Data.RemoveGraph(u);
}
}
break;
case ClearMode.All:
foreach (Uri u in context.Data.GraphUris.ToList())
{
if (u != null)
{
context.Data.RemoveGraph(u);
}
else
{
// DROPing the DEFAULT graph only results in clearing it
// This is because removing the default graph may cause errors in later commands/queries
// which rely on it existing
context.Data.GetModifiableGraph(u).Clear();
}
}
break;
}
}
catch
{
if (!_silent)
{
throw;
}
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
try
{
switch (this._mode)
{
case ClearMode.Default:
case ClearMode.Graph:
if (!context.Data.HasGraph(this._graphUri))
{
if (!this._silent) throw new SparqlUpdateException("Cannot remove a Named Graph with URI '" + this._graphUri.ToString() + "' since a Graph with this URI does not exist in the Store");
}
else
{
if (this._mode == ClearMode.Graph)
{
context.Data.RemoveGraph(this._graphUri);
}
else
{
//DROPing the DEFAULT graph only results in clearing it
//This is because removing the default graph may cause errors in later commands/queries
//which rely on it existing
context.Data.GetModifiableGraph(this._graphUri).Clear();
}
}
break;
case ClearMode.Named:
foreach (Uri u in context.Data.GraphUris.ToList())
{
if (u != null)
{
context.Data.RemoveGraph(u);
}
}
break;
case ClearMode.All:
foreach (Uri u in context.Data.GraphUris.ToList())
{
if (u != null)
{
context.Data.RemoveGraph(u);
}
else
{
//DROPing the DEFAULT graph only results in clearing it
//This is because removing the default graph may cause errors in later commands/queries
//which rely on it existing
context.Data.GetModifiableGraph(u).Clear();
}
}
break;
}
}
catch
{
if (!this._silent) throw;
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
bool defGraphOk = false;
bool datasetOk = false;
try
{
//First evaluate the WHERE pattern to get the affected bindings
ISparqlAlgebra where = this._wherePattern.ToAlgebra();
if (context.Commands != null)
{
where = context.Commands.ApplyAlgebraOptimisers(where);
}
//Set Active Graph for the WHERE based upon the WITH clause
//Don't bother if there are USING URIs as these would override any Active Graph we set here
//so we can save ourselves the effort of doing this
if (!this.UsingUris.Any())
{
if (this._graphUri != null)
{
context.Data.SetActiveGraph(this._graphUri);
defGraphOk = true;
}
else
{
context.Data.SetActiveGraph((Uri)null);
defGraphOk = true;
}
}
//We need to make a dummy SparqlQuery object since if the Command has used any
//USING/USING NAMEDs along with GRAPH clauses then the algebra needs to have the
//URIs available to it which it gets from the Query property of the Context
//object
SparqlQuery query = new SparqlQuery();
foreach (Uri u in this.UsingUris)
{
query.AddDefaultGraph(u);
}
foreach (Uri u in this.UsingNamedUris)
{
query.AddNamedGraph(u);
}
SparqlEvaluationContext queryContext = new SparqlEvaluationContext(query, context.Data, context.QueryProcessor);
if (this.UsingUris.Any())
{
//If there are USING URIs set the Active Graph to be formed of the Graphs with those URIs
context.Data.SetActiveGraph(this._usingUris);
datasetOk = true;
}
BaseMultiset results = queryContext.Evaluate(where);
if (results is IdentityMultiset)
{
results = new SingletonMultiset(results.Variables);
}
if (this.UsingUris.Any())
{
//If there are USING URIs reset the Active Graph afterwards
//Also flag the dataset as no longer being OK as this flag is used in the finally
//block to determine whether the Active Graph needs resetting which it may do if the
//evaluation of the
context.Data.ResetActiveGraph();
datasetOk = false;
}
//Reset Active Graph for the WHERE
if (defGraphOk)
{
context.Data.ResetActiveGraph();
defGraphOk = false;
}
//Get the Graph from which we are deleting
IGraph g = context.Data.GetModifiableGraph(this._graphUri);
//Delete the Triples for each Solution
foreach (ISet s in results.Sets)
{
List <Triple> deletedTriples = new List <Triple>();
//Triples from raw Triple Patterns
try
{
ConstructContext constructContext = new ConstructContext(g, s, true);
foreach (IConstructTriplePattern p in this._deletePattern.TriplePatterns.OfType <IConstructTriplePattern>())
{
try
{
deletedTriples.Add(p.Construct(constructContext));
}
catch (RdfQueryException)
{
//If we get an error here then we couldn't construct a specific Triple
//so we continue anyway
}
}
g.Retract(deletedTriples);
}
catch (RdfQueryException)
{
//If we throw an error this means we couldn't construct for this solution so the
//solution is ignored this graph
}
//Triples from GRAPH clauses
foreach (GraphPattern gp in this._deletePattern.ChildGraphPatterns)
{
deletedTriples.Clear();
try
{
String graphUri;
switch (gp.GraphSpecifier.TokenType)
{
case Token.URI:
graphUri = gp.GraphSpecifier.Value;
break;
case Token.VARIABLE:
String graphVar = gp.GraphSpecifier.Value.Substring(1);
if (s.ContainsVariable(graphVar))
{
INode temp = s[graphVar];
if (temp == null)
{
//If the Variable is not bound then skip
continue;
}
else if (temp.NodeType == NodeType.Uri)
{
graphUri = temp.ToSafeString();
}
else
{
//If the Variable is not bound to a URI then skip
continue;
}
}
else
{
//If the Variable is not bound for this solution then skip
continue;
}
break;
default:
//Any other Graph Specifier we have to ignore this solution
continue;
}
//If the Dataset doesn't contain the Graph then no need to do the Deletions
if (!context.Data.HasGraph(UriFactory.Create(graphUri)))
{
continue;
}
//Do the actual Deletions
IGraph h = context.Data.GetModifiableGraph(UriFactory.Create(graphUri));
ConstructContext constructContext = new ConstructContext(h, s, true);
foreach (IConstructTriplePattern p in gp.TriplePatterns.OfType <IConstructTriplePattern>())
{
try
{
deletedTriples.Add(p.Construct(constructContext));
}
catch (RdfQueryException)
{
//If we get an error here then we couldn't construct a specific
//triple so we continue anyway
}
}
h.Retract(deletedTriples);
}
catch (RdfQueryException)
{
//If we get an error here this means we couldn't construct for this solution so the
//solution is ignored for this graph
}
}
}
}
finally
{
//If the Dataset was set and an error occurred in doing the WHERE clause then
//we'll need to Reset the Active Graph
if (datasetOk)
{
context.Data.ResetActiveGraph();
}
if (defGraphOk)
{
context.Data.ResetActiveGraph();
}
}
}
/// <summary>
/// Evaluates the Command in the given Context.
/// </summary>
/// <param name="context">Evaluation Context.</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
try
{
if (context.Data.HasGraph(_sourceUri))
{
// If Source and Destination are same this is a no-op
if (EqualityHelper.AreUrisEqual(_sourceUri, _destUri))
{
return;
}
// Get the Source Graph
IGraph source = context.Data.GetModifiableGraph(_sourceUri);
// Create/Delete/Clear the Destination Graph
IGraph dest;
if (context.Data.HasGraph(_destUri))
{
if (_destUri == null)
{
dest = context.Data.GetModifiableGraph(_destUri);
dest.Clear();
}
else
{
context.Data.RemoveGraph(_destUri);
dest = new Graph();
dest.BaseUri = _destUri;
context.Data.AddGraph(dest);
dest = context.Data.GetModifiableGraph(_destUri);
}
}
else
{
dest = new Graph();
dest.BaseUri = _destUri;
context.Data.AddGraph(dest);
}
// Move data from the Source into the Destination
dest.Merge(source);
}
else
{
// Only show error if not Silent
if (!_silent)
{
if (_sourceUri != null)
{
throw new SparqlUpdateException("Cannot COPY from Graph <" + _sourceUri.AbsoluteUri + "> as it does not exist");
}
else
{
// This would imply a more fundamental issue with the Dataset not understanding that null means default graph
throw new SparqlUpdateException("Cannot COPY from the Default Graph as it does not exist");
}
}
}
}
catch
{
// If not silent throw the exception upwards
if (!_silent)
{
throw;
}
}
}
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
throw new NotImplementedException();
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
//Split the Pattern into the set of Graph Patterns
List<GraphPattern> patterns = new List<GraphPattern>();
if (this._pattern.IsGraph)
{
patterns.Add(this._pattern);
}
else if (this._pattern.TriplePatterns.Count > 0 || this._pattern.HasChildGraphPatterns)
{
if (this._pattern.TriplePatterns.Count > 0)
{
patterns.Add(new GraphPattern());
this._pattern.TriplePatterns.ForEach(tp => patterns[0].AddTriplePattern(tp));
}
this._pattern.ChildGraphPatterns.ForEach(gp => patterns.Add(gp));
}
else
{
//If no Triple Patterns and No Child Graph Patterns nothing to do
return;
}
foreach (GraphPattern pattern in patterns)
{
if (!this.IsValidDataPattern(pattern, false)) throw new SparqlUpdateException("Cannot evaluate a INSERT DATA command where any of the Triple Patterns are not concrete triples (variables are not permitted) or any of the GRAPH clauses have nested Graph Patterns");
//Get the Target Graph
IGraph target;
Uri graphUri;
if (pattern.IsGraph)
{
switch (pattern.GraphSpecifier.TokenType)
{
case Token.QNAME:
throw new NotSupportedException("Graph Specifiers as QNames for INSERT DATA Commands are not supported - please specify an absolute URI instead");
case Token.URI:
graphUri = UriFactory.Create(pattern.GraphSpecifier.Value);
break;
default:
throw new SparqlUpdateException("Cannot evaluate an INSERT DATA Command as the Graph Specifier is not a QName/URI");
}
}
else
{
graphUri = null;
}
if (context.Data.HasGraph(graphUri))
{
target = context.Data.GetModifiableGraph(graphUri);
}
else
{
//If the Graph does not exist then it must be created
target = new Graph();
target.BaseUri = graphUri;
context.Data.AddGraph(target);
}
//Insert the actual Triples
INode subj, pred, obj;
ConstructContext constructContext = new ConstructContext(target, null, true);
foreach (IConstructTriplePattern p in pattern.TriplePatterns.OfType<IConstructTriplePattern>())
{
subj = p.Subject.Construct(constructContext);
pred = p.Predicate.Construct(constructContext);
obj = p.Object.Construct(constructContext);
target.Assert(new Triple(subj, pred, obj));
}
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
try
{
switch (this._mode)
{
case ClearMode.Graph:
case ClearMode.Default:
if (context.Data.HasGraph(this._graphUri))
{
context.Data.GetModifiableGraph(this._graphUri).Clear();
}
break;
case ClearMode.Named:
foreach (Uri u in context.Data.GraphUris)
{
if (u != null)
{
context.Data.GetModifiableGraph(u).Clear();
}
}
break;
case ClearMode.All:
foreach (Uri u in context.Data.GraphUris)
{
context.Data.GetModifiableGraph(u).Clear();
}
break;
}
}
catch
{
if (!this._silent) throw;
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
bool defGraphOk = false;
bool datasetOk = false;
try
{
//First evaluate the WHERE pattern to get the affected bindings
ISparqlAlgebra where = this._wherePattern.ToAlgebra();
if (context.Commands != null)
{
where = context.Commands.ApplyAlgebraOptimisers(where);
}
//Set Active Graph for the WHERE based upon the WITH clause
//Don't bother if there are USING URIs as these would override any Active Graph we set here
//so we can save ourselves the effort of doing this
if (!this.UsingUris.Any())
{
if (this._graphUri != null)
{
context.Data.SetActiveGraph(this._graphUri);
defGraphOk = true;
}
else
{
context.Data.SetActiveGraph((Uri)null);
defGraphOk = true;
}
}
//We need to make a dummy SparqlQuery object since if the Command has used any
//USING/USING NAMEDs along with GRAPH clauses then the algebra needs to have the
//URIs available to it which it gets from the Query property of the Context
//object
SparqlQuery query = new SparqlQuery();
foreach (Uri u in this.UsingUris)
{
query.AddDefaultGraph(u);
}
foreach (Uri u in this.UsingNamedUris)
{
query.AddNamedGraph(u);
}
SparqlEvaluationContext queryContext = new SparqlEvaluationContext(query, context.Data, context.QueryProcessor);
if (this.UsingUris.Any())
{
//If there are USING URIs set the Active Graph to be formed of the Graphs with those URIs
context.Data.SetActiveGraph(this._usingUris);
datasetOk = true;
}
BaseMultiset results = queryContext.Evaluate(where);
if (this.UsingUris.Any())
{
//If there are USING URIs reset the Active Graph afterwards
//Also flag the dataset as no longer being OK as this flag is used in the finally
//block to determine whether the Active Graph needs resetting which it may do if the
//evaluation of the
context.Data.ResetActiveGraph();
datasetOk = false;
}
//Reset Active Graph for the WHERE
if (defGraphOk)
{
context.Data.ResetActiveGraph();
defGraphOk = false;
}
//Get the Graph from which we are deleting
IGraph g = context.Data.GetModifiableGraph(this._graphUri);
//Delete the Triples for each Solution
foreach (ISet s in queryContext.OutputMultiset.Sets)
{
List<Triple> deletedTriples = new List<Triple>();
//Triples from raw Triple Patterns
try
{
ConstructContext constructContext = new ConstructContext(g, s, true);
foreach (IConstructTriplePattern p in this._deletePattern.TriplePatterns.OfType<IConstructTriplePattern>())
{
try
{
deletedTriples.Add(p.Construct(constructContext));
}
catch (RdfQueryException)
{
//If we get an error here then we couldn't construct a specific Triple
//so we continue anyway
}
}
g.Retract(deletedTriples);
}
catch (RdfQueryException)
{
//If we throw an error this means we couldn't construct for this solution so the
//solution is ignored this graph
}
//Triples from GRAPH clauses
foreach (GraphPattern gp in this._deletePattern.ChildGraphPatterns)
{
deletedTriples.Clear();
try
{
String graphUri;
switch (gp.GraphSpecifier.TokenType)
{
case Token.URI:
graphUri = gp.GraphSpecifier.Value;
break;
case Token.VARIABLE:
if (s.ContainsVariable(gp.GraphSpecifier.Value))
{
INode temp = s[gp.GraphSpecifier.Value.Substring(1)];
if (temp == null)
{
//If the Variable is not bound then skip
continue;
}
else if (temp.NodeType == NodeType.Uri)
{
graphUri = temp.ToSafeString();
}
else
{
//If the Variable is not bound to a URI then skip
continue;
}
}
else
{
//If the Variable is not bound for this solution then skip
continue;
}
break;
default:
//Any other Graph Specifier we have to ignore this solution
continue;
}
//If the Dataset doesn't contain the Graph then no need to do the Deletions
if (!context.Data.HasGraph(UriFactory.Create(graphUri))) continue;
//Do the actual Deletions
IGraph h = context.Data.GetModifiableGraph(UriFactory.Create(graphUri));
ConstructContext constructContext = new ConstructContext(h, s, true);
foreach (IConstructTriplePattern p in gp.TriplePatterns.OfType<IConstructTriplePattern>())
{
try
{
deletedTriples.Add(p.Construct(constructContext));
}
catch (RdfQueryException)
{
//If we get an error here then we couldn't construct a specific
//triple so we continue anyway
}
}
h.Retract(deletedTriples);
}
catch (RdfQueryException)
{
//If we get an error here this means we couldn't construct for this solution so the
//solution is ignored for this graph
}
}
}
}
finally
{
//If the Dataset was set and an error occurred in doing the WHERE clause then
//we'll need to Reset the Active Graph
if (datasetOk) context.Data.ResetActiveGraph();
if (defGraphOk) context.Data.ResetActiveGraph();
}
}
/// <summary>
/// Evaluates the Command in the given Context
/// </summary>
/// <param name="context">Update Evaluation Context</param>
public override void Evaluate(SparqlUpdateEvaluationContext context)
{
if (context.Data.HasGraph(this._graphUri))
{
if (!this._silent) throw new SparqlUpdateException("Cannot create a Named Graph with URI '" + this._graphUri.ToString() + "' since a Graph with this URI already exists in the Store");
}
else
{
Graph g = new Graph();
g.BaseUri = this._graphUri;
context.Data.AddGraph(g);
}
}