Class: SPARQL::Algebra::Operator::Delete

Inherits:
Operator::Unary
  • Object
show all
Includes:
Update
Defined in:
lib/sparql/algebra/operator/delete.rb

Overview

The SPARQL UPDATE delete operator.

The DELETE operation is a form of the DELETE/INSERT operation having no INSERT section

[42] DeleteClause ::= 'DELETE' QuadPattern

Examples:

SPARQL Grammar

PREFIX     : <http://example.org/> 
PREFIX foaf: <http://xmlns.com/foaf/0.1/> 

DELETE { ?s ?p ?o }
WHERE  { :a foaf:knows ?s . ?s ?p ?o }

SSE

(prefix ((: <http://example.org/>)
         (foaf: <http://xmlns.com/foaf/0.1/>))
 (update
  (modify
   (bgp
    (triple :a foaf:knows ?s)
    (triple ?s ?p ?o))
   (delete ((triple ?s ?p ?o))))))

See Also:

Constant Summary collapse

NAME = 
[:delete]

Instance Method Summary collapse

Methods included from Update

#empty?, #graph_name=, #unshift, #variables

Instance Method Details

#execute(queryable, solutions: nil, **options) ⇒ RDF::Queryable

Executes this upate on the given writable graph or repository.

Parameters:

  • queryable (RDF::Queryable) —

    the graph or repository to write

  • solutions (RDF::Query::Solutions) (defaults to: nil) —

    Solutions to map to patterns for this operation

  • options (Hash{Symbol => Object}) —

    any additional keyword options

Options Hash (**options):

  • debug (Boolean) —

    Query execution debugging

Returns:

Raises:

  • (IOError) —

    If from does not exist, unless the silent operator is present

See Also:



50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/sparql/algebra/operator/delete.rb', line 50

def execute(queryable, solutions: nil, **options)
  debug(options) {"Delete: #{solutions} against #{operands.to_sse}"}
  # Only binds the first solution
  solution = solutions.is_a?(RDF::Query::Solutions) ? solutions.first : solutions
  # Operands are an array of patterns and Queries (when named).
  # Create a new query made up all patterns
  patterns = operand.inject([]) do |memo, op|
    if op.respond_to?(:statements)
      memo += op.statements.to_a
    else
      memo << op
    end
    memo
  end
  patterns.each do |pattern|
    pattern = pattern.dup.bind(solution)
    debug(options) {"Delete pattern #{pattern.to_sse}"}
    queryable.delete(RDF::Statement.from(pattern)) if pattern.bound? || pattern.constant?
  end
  queryable
end

#to_sparql(**options) ⇒ String

Returns a partial SPARQL grammar for this term.

Returns:

  • (String) 


77
78
79
80
81
 
# File 'lib/sparql/algebra/operator/delete.rb', line 77

def to_sparql(**options)
  "DELETE {\n" +
    operands.first.to_sparql(delimiter: " .\n", **options) +
    "\n}"
end