rdflib.Graph.ConjunctiveGraph

Package rdflib :: Module Graph :: Class ConjunctiveGraph

[show private | hide private]

Type ConjunctiveGraph

object --+        
         |        
      Node --+    
             |    
         Graph --+
                 |
                ConjunctiveGraph

Known Subclasses:: BackwardCompatGraph, ReadOnlyGraphAggregate, TextIndex

Method Summary
	`__init__(self, store, identifier)`
	`__len__(self)` Number of triples in the entire conjunctive graph
	`__reduce__(self)`
	`__str__(self)`
	`add(self, (s, p, o))` Add the triple to the default context
	`addN(self, quads)` Add a sequence of triple with context
	`context_id(self, uri, context_id)` URI#context
	`contexts(self, triple)` Iterate over all contexts in the graph
	`parse(self, source, publicID, format, **args)` Parse source into Graph into it's own context (sub graph)
	`quads(self, (s, p, o))` Iterate over all the quads in the entire conjunctive graph
	`remove(self, (s, p, o))` Removes from all its contexts
	`remove_context(self, context)` Removes the given context from the graph
	`triples(self, (s, p, o))` Iterate over all the triples in the entire conjunctive graph
	`triples_choices(self, (s, p, o))` Iterate over all the triples in the entire conjunctive graph
Inherited from Graph
	`__add__(self, other)` Set theoretical union
	`__cmp__(self, other)`
	`__contains__(self, triple)` Support for 'triple in graph' syntax
	`__hash__(self)`
	`__iadd__(self, other)` Add all triples in Graph other to Graph
	`__isub__(self, other)` Subtract all triples in Graph other from Graph
	`__iter__(self)` Iterates over all triples in the store
	`__mul__(self, other)` Set theoretical intersection
	`__repr__(self)`
	`__sub__(self, other)` Set theoretical difference
	`absolutize(self, uri, defrag)` Turn uri into an absolute URI if it's not one already
	`all_nodes(self)`
	`bind(self, prefix, namespace, override)` Bind prefix to namespace
	`close(self, commit_pending_transaction)` Close the graph store
	`comment(self, subject, default)` Query for the RDFS.comment of the subject
	`commit(self)` Commits active transactions
	`compute_qname(self, uri)`
	`connected(self)` Check if the Graph is connected
	`destroy(self, configuration)` Destroy the store identified by `configuration` if supported
	`isomorphic(self, other)`
	`items(self, list)` Generator over all items in the resource specified by list
	`label(self, subject, default)` Query for the RDFS.label of the subject
	`load(self, source, publicID, format)`
	`md5_term_hash(self)`
	`n3(self)` return an n3 identifier for the Graph
	`namespaces(self)` Generator over all the prefix, namespace tuples
	`objects(self, subject, predicate)` A generator of objects with the given subject and predicate
	`open(self, configuration, create)` Open the graph store
	`predicate_objects(self, subject)` A generator of (predicate, object) tuples for the given subject
	`predicates(self, subject, object)` A generator of predicates with the given subject and object
	`prepare_input_source(self, source, publicID)`
	`qname(self, uri)`
	`query(self, strOrQuery, initBindings, initNs, DEBUG, processor)` Executes a SPARQL query (eventually will support Versa queries with same method) against this Graph strOrQuery - Is either a string consisting of the SPARQL query or an instance of rdflib.sparql.bison.Query.Query initBindings - A mapping from a Variable to an RDFLib term (used as initial bindings for SPARQL query) initNS - A mapping from a namespace prefix to an instance of rdflib.Namespace (used for SPARQL query) DEBUG - A boolean flag passed on to the SPARQL parser and evaluation engine processor - The kind of RDF query (must be 'sparql' until Versa is ported)
	`rollback(self)` Rollback active transactions
	`seq(self, subject)` Check if subject is an rdf:Seq
	`serialize(self, destination, format, base, encoding, **args)` Serialize the Graph to destination
	`set(self, (subject, predicate, object))` Convenience method to update the value of object
	`subject_objects(self, predicate)` A generator of (subject, object) tuples for the given predicate
	`subject_predicates(self, object)` A generator of (subject, predicate) tuples for the given object
	`subjects(self, predicate, object)` A generator of subjects with the given predicate and object
	`transitive_objects(self, subject, property, remember)` Transitively generate objects for the `property` relationship
	`transitive_subjects(self, predicate, object, remember)` Transitively generate objects for the `property` relationship
	`value(self, subject, predicate, object, default, any)` Get a value for a pair of two criteria Exactly one of subject, predicate, object must be None.
	`_get_namespace_manager(self)`
	`_set_namespace_manager(self, nm)`
Inherited from object
	`__delattr__(...)` x.__delattr__('name') <==> del x.name
	`__getattribute__(...)` x.__getattribute__('name') <==> x.name
	`__new__(T, S, ...)` T.__new__(S, ...) -> a new object with type S, a subtype of T
	`__reduce_ex__(...)` helper for pickle
	`__setattr__(...)` x.__setattr__('name', value) <==> x.name = value

Property Summary
Inherited from Graph
	`identifier`
	`namespace_manager`
	`store`

Class Variable Summary
Inherited from Node
`Implements`	`__implemented__` = `<implementedBy rdflib.Node.Node>`
`ClassProvides`	`__providedBy__` = `<zope.interface.declarations.ClassProvi...`
`ClassProvides`	`__provides__` = `<zope.interface.declarations.ClassProvide...`
`tuple`	`__slots__` = `()`

Method Details

len(self)
(Length operator)

Number of triples in the entire conjunctive graph

Overrides:: rdflib.Graph.Graph.__len__

add(self, (s, p, o))

Add the triple to the default context

Overrides:: rdflib.Graph.Graph.add

addN(self, quads)

Add a sequence of triple with context

Overrides:: rdflib.Graph.Graph.addN

context_id(self, uri, context_id=None)

URI#context

contexts(self, triple=None)

Iterate over all contexts in the graph

If triple is specified, iterate over all contexts the triple is in.

parse(self, source, publicID=None, format='xml', **args)

Parse source into Graph into it's own context (sub graph)

Format defaults to xml (AKA rdf/xml). The publicID argument is for specifying the logical URI for the case that it's different from the physical source URI. Returns the context into which the source was parsed. In the case of n3 it returns the root context.