def remove_from_index(self, cls, index, key=None, value=None, entity=None): """ Remove any nodes or relationships from an index that match a particular set of criteria. Allowed parameter combinations are: `key`, `value`, `entity` remove a specific node or relationship indexed under a given key-value pair `key`, `entity` remove a specific node or relationship indexed against a given key and with any value `entity` remove all occurrences of a specific node or relationship regardless of key or value :param cls: the type of indexed entity :param index: index or index name :param key: index entry key :param value: index entry value :param entity: node or relationship to remove from the index :return: :class:`.Job` """ index = self._index(cls, index) if key and value and entity: uri = self._uri_for(index, key, value, remote(entity)._id) elif key and entity: uri = self._uri_for(index, key, remote(entity)._id) elif entity: uri = self._uri_for(index, remote(entity)._id) else: raise TypeError("Illegal parameter combination for index removal") return self.append_delete(uri)
def test_can_pull_path(self): alice = Node(name="Alice") bob = Node(name="Bob") carol = Node(name="Carol") dave = Node(name="Dave") path = Path(alice, "LOVES", bob, Relationship(carol, "HATES", bob), carol, "KNOWS", dave) self.graph.create(path) assert path[0]["amount"] is None assert path[1]["amount"] is None assert path[2]["since"] is None statement = ( "MATCH ()-[ab]->() WHERE id(ab)={ab} " "MATCH ()-[bc]->() WHERE id(bc)={bc} " "MATCH ()-[cd]->() WHERE id(cd)={cd} " "SET ab.amount = 'lots', bc.amount = 'some', cd.since = 1999") id_0 = remote(path[0])._id id_1 = remote(path[1])._id id_2 = remote(path[2])._id parameters = {"ab": id_0, "bc": id_1, "cd": id_2} self.graph.run(statement, parameters) self.graph.pull(path) assert path[0]["amount"] == "lots" assert path[1]["amount"] == "some" assert path[2]["since"] == 1999
def test_can_push_path(self): alice = Node(name="Alice") bob = Node(name="Bob") carol = Node(name="Carol") dave = Node(name="Dave") path = Path(alice, "LOVES", bob, Relationship(carol, "HATES", bob), carol, "KNOWS", dave) self.graph.create(path) statement = ("MATCH ()-[ab]->() WHERE id(ab)={ab} " "MATCH ()-[bc]->() WHERE id(bc)={bc} " "MATCH ()-[cd]->() WHERE id(cd)={cd} " "RETURN ab.amount, bc.amount, cd.since") parameters = { "ab": remote(path[0])._id, "bc": remote(path[1])._id, "cd": remote(path[2])._id } path[0]["amount"] = "lots" path[1]["amount"] = "some" path[2]["since"] = 1999 ab_amount, bc_amount, cd_since = self.graph.run(statement, parameters).next() assert ab_amount is None assert bc_amount is None assert cd_since is None self.graph.push(path) ab_amount, bc_amount, cd_since = self.graph.run(statement, parameters).next() assert ab_amount == "lots" assert bc_amount == "some" assert cd_since == 1999
def remove_from_index(self, cls, index, key=None, value=None, entity=None): """ Remove any nodes or relationships from an index that match a particular set of criteria. Allowed parameter combinations are: `key`, `value`, `entity` remove a specific node or relationship indexed under a given key-value pair `key`, `entity` remove a specific node or relationship indexed against a given key and with any value `entity` remove all occurrences of a specific node or relationship regardless of key or value :param cls: the type of indexed entity :param index: index or index name :param key: index entry key :param value: index entry value :param entity: node or relationship to remove from the index :return: :class:`.Job` """ index = self._index(cls, index) if key and value and entity: uri = self._uri_for(index, key, value, remote(entity)._id) elif key and entity: uri = self._uri_for(index, key, remote(entity)._id) elif entity: uri = self._uri_for(index, remote(entity)._id) else: raise TypeError("Illegal parameter combination for index removal") return self.append_delete(uri)
def __init__(self, graph, path): self.graph = graph self.remote = Resource(remote(self.graph.dbms).uri.resolve(path)) try: self.remote.get() except GraphError: raise NotImplementedError("No extension found at path %r on " "graph <%s>" % (path, remote(self.graph).uri))
def __init__(self, graph, path): self.graph = graph self.remote = Resource(remote(self.graph.dbms).uri.resolve(path)) try: self.remote.get() except GraphError: raise NotImplementedError("No extension found at path %r on " "graph <%s>" % (path, remote(self.graph).uri))
def test_can_create_relationship(self): a = Node("Person", name="Alice") b = Node("Person", name="Bob") r = Relationship(a, "KNOWS", b, since=1999) self.graph.create(r) assert remote(a) assert remote(b) assert remote(r) assert r.start_node() == a assert r.end_node() == b
def __eq__(self, other): if not isinstance(other, GraphObject): return False remote_self = remote(self.__ogm__.node) remote_other = remote(other.__ogm__.node) if remote_self and remote_other: return remote_self == remote_other else: return self.__primarylabel__ == other.__primarylabel__ and \ self.__primarykey__ == other.__primarykey__ and \ self.__primaryvalue__ == other.__primaryvalue__
def __eq__(self, other): if not isinstance(other, GraphObject): return False remote_self = remote(self.__ogm__.node) remote_other = remote(other.__ogm__.node) if remote_self and remote_other: return remote_self == remote_other else: return self.__primarylabel__ == other.__primarylabel__ and \ self.__primarykey__ == other.__primarykey__ and \ self.__primaryvalue__ == other.__primaryvalue__
def _index_manager(self, content_type): """ Fetch the index management resource for the given `content_type`. :param content_type: :return: """ if content_type is Node: uri = remote(self.graph).metadata["node_index"] elif content_type is Relationship: uri = remote(self.graph).metadata["relationship_index"] else: raise TypeError("Indexes can manage either Nodes or Relationships") return Resource(uri)
def _index_manager(self, content_type): """ Fetch the index management resource for the given `content_type`. :param content_type: :return: """ if content_type is Node: uri = remote(self.graph).metadata["node_index"] elif content_type is Relationship: uri = remote(self.graph).metadata["relationship_index"] else: raise TypeError("Indexes can manage either Nodes or Relationships") return Resource(uri)
def test_unique_path_not_unique_raises_cypher_error(self): graph = self.graph record = graph.run("CREATE (a), (b) RETURN a, b").next() parameters = { "A": remote(record["a"])._id, "B": remote(record["b"])._id } statement = ("MATCH (a) WHERE id(a)={A} MATCH (b) WHERE id(b)={B}" "CREATE (a)-[:KNOWS]->(b)") graph.run(statement, parameters) graph.run(statement, parameters) statement = ("MATCH (a) WHERE id(a)={A} MATCH (b) WHERE id(b)={B}" "CREATE UNIQUE (a)-[:KNOWS]->(b)") with self.assertRaises(ConstraintError): graph.run(statement, parameters)
def delete_index(self, content_type, index_name): """ Delete the entire index identified by the type and name supplied. :param content_type: either :class:`.Node` or :class:`.Relationship` :param index_name: the name of the index to delete :raise LookupError: if the specified index does not exist """ if index_name not in self._indexes[content_type]: self.get_indexes(content_type) if index_name in self._indexes[content_type]: index = self._indexes[content_type][index_name] remote(index).delete() del self._indexes[content_type][index_name] else: raise LookupError("Index not found")
def _related_objects(self): if self.__related_objects is None: self.__related_objects = [] remote_node = remote(self.node) if remote_node: self.__db_pull__(remote_node.graph) return self.__related_objects
def __db_delete__(self, tx): ogm = self.__ogm__ remote_node = remote(ogm.node) if remote_node: tx.run("MATCH (a) WHERE id(a) = {x} OPTIONAL MATCH (a)-[r]->() DELETE r DELETE a", x=remote_node._id) for related_objects in ogm.related.values(): related_objects.clear()
def _related_objects(self): if self.__related_objects is None: self.__related_objects = [] remote_node = remote(self.node) if remote_node: self.__db_pull__(remote_node.graph) return self.__related_objects
def __db_delete__(self, tx): ogm = self.__ogm__ remote_node = remote(ogm.node) if remote_node: tx.run("MATCH (a) WHERE id(a) = {x} OPTIONAL MATCH (a)-[r]->() DELETE r DELETE a", x=remote_node._id) for related_objects in ogm.related.values(): related_objects.clear()
def delete_index(self, content_type, index_name): """ Delete the entire index identified by the type and name supplied. :param content_type: either :class:`.Node` or :class:`.Relationship` :param index_name: the name of the index to delete :raise LookupError: if the specified index does not exist """ if index_name not in self._indexes[content_type]: self.get_indexes(content_type) if index_name in self._indexes[content_type]: index = self._indexes[content_type][index_name] remote(index).delete() del self._indexes[content_type][index_name] else: raise LookupError("Index not found")
def __db_push__(self, graph): related_objects = self._related_objects tx = graph.begin() # 1. merge all nodes (create ones that don't) for related_object, _ in related_objects: tx.merge(related_object) tx.process() # 2a. remove any relationships not in list of nodes subject_id = remote(self.node)._id tx.run("MATCH %s WHERE id(a) = {x} AND NOT id(b) IN {y} DELETE _" % self.__relationship_pattern, x=subject_id, y=[remote(obj.__ogm__.node)._id for obj, _ in related_objects]) # 2b. merge all relationships for related_object, properties in related_objects: tx.run("MATCH (a) WHERE id(a) = {x} MATCH (b) WHERE id(b) = {y} " "MERGE %s SET _ = {z}" % self.__relationship_pattern, x=subject_id, y=remote(related_object.__ogm__.node)._id, z=properties) tx.commit()
def test_query_can_return_collection(self): node = Node() self.graph.create(node) statement = "MATCH (a) WHERE id(a)={N} RETURN collect(a) AS a_collection" params = {"N": remote(node)._id} cursor = self.graph.run(statement, params) record = cursor.next() assert record["a_collection"] == [node]
def test_param_used_once(self): node = Node() self.graph.create(node) statement = "MATCH (a) WHERE id(a)={X} RETURN a" params = {"X": remote(node)._id} cursor = self.graph.run(statement, params) record = cursor.next() assert record["a"] == node
def test_can_push_relationship(self): a = Node() b = Node() ab = Relationship(a, "KNOWS", b) self.graph.create(ab) value = self.graph.evaluate( "MATCH ()-[ab:KNOWS]->() WHERE id(ab)={i} " "RETURN ab.since", i=remote(ab)._id) assert value is None ab["since"] = 1999 self.graph.push(ab) value = self.graph.evaluate( "MATCH ()-[ab:KNOWS]->() WHERE id(ab)={i} " "RETURN ab.since", i=remote(ab)._id) assert value == 1999
def add(self, key, value, entity): """ Add an entity to this index under the `key`:`value` pair supplied. Note that while Neo4j indexes allow multiple entities to be added under a particular key:value, the same entity may only be represented once; this method is therefore idempotent. :param key: :param value: :param entity: """ remote(self).post({ "key": key, "value": value, "uri": remote(entity).uri.string, }) return entity
def add(self, key, value, entity): """ Add an entity to this index under the `key`:`value` pair supplied. Note that while Neo4j indexes allow multiple entities to be added under a particular key:value, the same entity may only be represented once; this method is therefore idempotent. :param key: :param value: :param entity: """ remote(self).post({ "key": key, "value": value, "uri": remote(entity).uri.string, }) return entity
def test_param_used_twice(self): node = Node() self.graph.create(node) statement = "MATCH (a) WHERE id(a)={X} MATCH (b) WHERE id(b)={X} RETURN a, b" params = {"X": remote(node)._id} record = self.graph.run(statement, params).next() assert record["a"] == node assert record["b"] == node
def __db_push__(self, graph): related_objects = self._related_objects tx = graph.begin() # 1. merge all nodes (create ones that don't) for related_object, _ in related_objects: tx.merge(related_object) tx.process() # 2a. remove any relationships not in list of nodes subject_id = remote(self.node)._id tx.run("MATCH %s WHERE id(a) = {x} AND NOT id(b) IN {y} DELETE _" % self.__relationship_pattern, x=subject_id, y=[remote(obj.__ogm__.node)._id for obj, _ in related_objects]) # 2b. merge all relationships for related_object, properties in related_objects: tx.run("MATCH (a) WHERE id(a) = {x} MATCH (b) WHERE id(b) = {y} " "MERGE %s SET _ = {z}" % self.__relationship_pattern, x=subject_id, y=remote(related_object.__ogm__.node)._id, z=properties) tx.commit()
def __primaryvalue__(self): node = self.__ogm__.node primary_key = self.__primarykey__ if primary_key == "__id__": remote_node = remote(node) return remote_node._id if remote_node else None else: return node[primary_key]
def __primaryvalue__(self): node = self.__ogm__.node primary_key = self.__primarykey__ if primary_key == "__id__": remote_node = remote(node) return remote_node._id if remote_node else None else: return node[primary_key]
def __init__(self, graph, name): self.graph = graph self.name = name remote_graph = remote(self.graph) extensions = remote_graph.metadata["extensions"] try: self.resources = {key: Resource(value) for key, value in extensions[self.name].items()} except KeyError: raise LookupError("No plugin named %r found on graph <%s>" % (self.name, remote_graph.uri))
def __db_pull__(self, graph): ogm = self.__ogm__ if not remote(ogm.node): selector = GraphObjectSelector(self.__class__, graph) selector._selection_class = NodeSelection ogm.node = selector.select(self.__primaryvalue__).first() graph.pull(ogm.node) for related_objects in ogm.related.values(): related_objects.__db_pull__(graph)
def test_query(self): a, b, ab = self.alice_and_bob statement = ("MATCH (a) WHERE id(a)={A} " "MATCH (b) WHERE id(b)={B} " "MATCH (a)-[ab:KNOWS]->(b) " "RETURN a, b, ab, a.name AS a_name, b.name AS b_name") records = list( self.graph.run(statement, { "A": remote(a)._id, "B": remote(b)._id })) assert len(records) == 1 for record in records: assert isinstance(record["a"], Node) assert isinstance(record["b"], Node) assert isinstance(record["ab"], Relationship) assert record["a_name"] == "Alice" assert record["b_name"] == "Bob"
def __db_pull__(self, graph): ogm = self.__ogm__ if not remote(ogm.node): selector = GraphObjectSelector(self.__class__, graph) selector._selection_class = NodeSelection ogm.node = selector.select(self.__primaryvalue__).first() graph.pull(ogm.node) for related_objects in ogm.related.values(): related_objects.__db_pull__(graph)
def test_query_can_return_path(self): a, b, ab = self.alice_and_bob statement = ("MATCH (a) WHERE id(a)={A} " "MATCH (b) WHERE id(b)={B} " "MATCH p=((a)-[ab:KNOWS]->(b)) " "RETURN p") records = list( self.graph.run(statement, { "A": remote(a)._id, "B": remote(b)._id })) assert len(records) == 1 for record in records: assert isinstance(record["p"], Path) nodes = record["p"].nodes() assert len(nodes) == 2 assert nodes[0] == a assert nodes[1] == b assert record["p"][0].type() == "KNOWS"
def test_can_graph_pull_node(self): alice_1 = Node() alice_2 = Node("Person", name="Alice") self.graph.create(alice_2) assert set(alice_1.labels()) == set() assert dict(alice_1) == {} alice_1.__remote__ = RemoteEntity(remote(alice_2).uri) self.graph.pull(alice_1) assert set(alice_1.labels()) == set(alice_2.labels()) assert dict(alice_1) == dict(alice_2)
def test_param_reused_once_after_with_statement(self): a, b, ab = self.alice_and_bob query = ("MATCH (a) WHERE id(a)={A} " "MATCH (a)-[:KNOWS]->(b) " "WHERE a.age > {min_age} " "WITH a " "MATCH (a)-[:KNOWS]->(b) " "WHERE b.age > {min_age} " "RETURN b") params = {"A": remote(a)._id, "min_age": 50} record = self.graph.run(query, params).next() assert record["b"] == b
def __init__(self, graph, name): self.graph = graph self.name = name remote_graph = remote(self.graph) extensions = remote_graph.metadata["extensions"] try: self.resources = { key: Resource(value) for key, value in extensions[self.name].items() } except KeyError: raise LookupError("No plugin named %r found on graph <%s>" % (self.name, remote_graph.uri))
def test_param_used_thrice(self): node = Node() self.graph.create(node) statement = "MATCH (a) WHERE id(a)={X} " \ "MATCH (b) WHERE id(b)={X} " \ "MATCH (c) WHERE id(c)={X} " \ "RETURN a, b, c" params = {"X": remote(node)._id} cursor = self.graph.run(statement, params) record = cursor.next() assert record["a"] == node assert record["b"] == node assert record["c"] == node
def __db_push__(self, graph): ogm = self.__ogm__ node = ogm.node if remote(node): graph.push(node) else: primary_key = getattr(node, "__primarykey__", "__id__") if primary_key == "__id__": graph.create(node) else: graph.merge(node) for related_objects in ogm.related.values(): related_objects.__db_push__(graph)
def correct_name(graph): tmps1 = time.time() statement = 'MATCH (labels:Label) '\ 'RETURN labels' tx = graph.begin() cursor = tx.run(statement) for record in cursor: name = str(dict(record[0])["name"]) (user_defined_name, modified) = correctPersonName(name) if modified is True: statement = 'MATCH (clus_lab:Label) '\ 'WHERE ID(clus_lab)=' + str(remote(record[0])._id) + \ ' MATCH (algo:Algo {name:"' + 'user_defined' + '"}) '\ 'MATCH (clus:Cluster)-[:LABEL]->(clus_lab) '\ 'MERGE (user_lab:Label {name:"' + user_defined_name + '"}) '\ 'MERGE (user_lab)-[:IDENTIFY_BY]->(algo) '\ 'CREATE (user_clus:User_Defined_Cluster) '\ 'CREATE (user_clus)-[:LABEL]->(user_lab) '\ 'CREATE (user_clus)-[:CLUSTERED]->(clus) '\ 'CREATE (user_clus)-[:GENERATED_BY]->(algo) '\ 'RETURN user_clus,clus ' cursor2 = tx.run(statement) for record2 in cursor2: statement = 'MATCH (clus:Cluster) '\ 'WHERE ID(clus)=' + str(remote(record2[1])._id) + \ ' MATCH (clus)-[:CLUSTERED]->(tracks:Track) '\ 'RETURN tracks' cursor3 = tx.run(statement) for track in cursor3: statement = 'MATCH (user_clus:User_Defined_Cluster) '\ 'WHERE ID(user_clus)=' + str(remote(record2[0])._id) + \ ' MATCH (track:Track) '\ 'WHERE ID(track) =' + str(remote(track[0])._id) + \ ' CREATE (user_clus)-[:CLUSTERED]->(track)' tx.run(statement) tx.commit() tmps2 = time.time() - tmps1 print "Done in " + str(int(tmps2)) + " second(s)."
def __db_push__(self, graph): ogm = self.__ogm__ node = ogm.node if remote(node): graph.push(node) else: primary_key = getattr(node, "__primarykey__", "__id__") if primary_key == "__id__": graph.create(node) else: graph.merge(node) for related_objects in ogm.related.values(): related_objects.__db_push__(graph)
def load_texture(graph,cluster): tx = graph.begin() image_str = "" statement = 'MATCH (n:Cluster) '\ 'WHERE Not (n)-[:CLUSTERED]-() '\ 'MATCH (n)-[r]->() '\ 'DELETE r ' graph.run(statement) statement = 'MATCH (n:Cluster) '\ 'WHERE Not (n)-[:CLUSTERED]-() '\ 'DELETE n ' graph.run(statement) if type(cluster) is str : sentence = cluster else: print cluster sentence = str(remote(cluster)._id) print sentence statement = 'MATCH (clus) '\ 'WHERE ID(clus)=' + sentence + \ ' MATCH (clus)-[:CLUSTERED]->(track:Track) '\ 'WITH track LIMIT 1 '\ 'MATCH (track)<-[:TRACK]-()<-[:COMPOSED_OF]-(:Jt)-[:BROADCAST_ON]->(day:Day)<-[:DAY]-(month:Month)<-[:MONTH]-(year:Year) '\ 'RETURN track.num_shot,track.num_track,day.name,month.name,year.name LIMIT 1' cursor = tx.run(statement) for record in cursor: print record year = str(record[4]) month = str(record[3]) day = str(record[2]) num_shot = str(record[0]) num_track = str(record[1]) if len(day) == 1: day = "0" + day if len(month) == 1: month = "0" + month f = open(texture_path_local + "image_track_" + str(year) +".json") json_texture_year = json.load(f) f.close() image_str = str(json_texture_year[month + "_" + day][num_shot + "_" + num_track]) statement = 'MATCH (clus) '\ 'WHERE ID(clus)=' + sentence +\ ' SET clus.texture ="' + image_str + '" '\ 'RETURN clus.texture ' record = graph.run(statement) tx.commit return image_str
def append_node(i, node): remote_node = remote(node) if node is None: path.append("(n{0})".format(i)) values.append("n{0}".format(i)) elif remote_node: path.append("(n{0})".format(i)) initial_match_clause.append("MATCH (n{0}) WHERE id(n{0})={{i{0}}}".format(i)) params["i{0}".format(i)] = remote_node._id values.append("n{0}".format(i)) else: path.append("(n{0} {{p{0}}})".format(i)) params["p{0}".format(i)] = dict(node) values.append("n{0}".format(i))
def cursor2json(cursor): # Same pseudo-random sequence for each exec: allows stable layout on the UI random.seed(0) g = {"nodes": [], "edges": []} done = set() for res in cursor: for node in res.nodes(): ref = remote(node).ref if ref not in done: labels = list(node.labels()) g["nodes"].append(node2json(ref, labels, dict(node))) done.add(ref) for edge in res.relationships(): ref = remote(edge).ref if ref not in done: from_ref = remote(edge.start_node()).ref to_ref = remote(edge.end_node()).ref g["edges"].append(edge2json(ref, from_ref, to_ref, [edge.type()], dict(edge))) done.add(ref) return g
def _uri_for(self, resource, *segments, **kwargs): """ Return a relative URI in string format for the entity specified plus extra path segments. """ if isinstance(resource, int): uri = "{{{0}}}".format(resource) elif isinstance(resource, NodePointer): uri = "{{{0}}}".format(resource.address) elif isinstance(resource, Job): uri = "{{{0}}}".format(self.find(resource)) else: remote_resource = remote(resource) remote_graph = remote(remote_resource.graph) graph_uri = remote_graph.uri.string entity_uri = remote_resource.uri.string uri = entity_uri[len(graph_uri):] if segments: if not uri.endswith("/"): uri += "/" uri += "/".join(map(percent_encode, segments)) query = kwargs.get("query") if query is not None: uri += "?" + query return uri
def _uri_for(self, resource, *segments, **kwargs): """ Return a relative URI in string format for the entity specified plus extra path segments. """ if isinstance(resource, int): uri = "{{{0}}}".format(resource) elif isinstance(resource, NodePointer): uri = "{{{0}}}".format(resource.address) elif isinstance(resource, Job): uri = "{{{0}}}".format(self.find(resource)) else: remote_resource = remote(resource) remote_graph = remote(remote_resource.graph) graph_uri = remote_graph.uri.string entity_uri = remote_resource.uri.string uri = entity_uri[len(graph_uri):] if segments: if not uri.endswith("/"): uri += "/" uri += "/".join(map(percent_encode, segments)) query = kwargs.get("query") if query is not None: uri += "?" + query return uri
def add_if_none(self, key, value, entity): """ Add an entity to this index under the `key`:`value` pair supplied if no entry already exists at that point. If added, this method returns the entity, otherwise :py:const:`None` is returned. """ rs = self._get_or_create.post({ "key": key, "value": value, "uri": remote(entity).uri.string, }) if rs.status_code == CREATED: return entity else: return None
def __init__(self, content_type, uri, name=None): self._content_type = content_type key_value_pos = uri.find("/{key}/{value}") if key_value_pos >= 0: self._searcher = ResourceTemplate(uri) self.__remote__ = Resource(uri[:key_value_pos]) else: self.__remote__ = Resource(uri) self._searcher = ResourceTemplate(uri.string + "/{key}/{value}") uri = remote(self).uri self._create_or_fail = Resource(uri.resolve("?uniqueness=create_or_fail")) self._get_or_create = Resource(uri.resolve("?uniqueness=get_or_create")) self._query_template = ResourceTemplate(uri.string + "{?query,order}") self._name = name or uri.path.segments[-1] self.__searcher_stem_cache = {} self.graph = Graph(uri.resolve("/db/data/").string)
def __db_merge__(self, tx, primary_label=None, primary_key=None): # TODO make atomic graph = tx.graph ogm = self.__ogm__ node = ogm.node if primary_label is None: primary_label = getattr(node, "__primarylabel__", None) if primary_key is None: primary_key = getattr(node, "__primarykey__", "__id__") if not remote(node): if primary_key == "__id__": node.add_label(primary_label) graph.create(node) else: graph.merge(node, primary_label, primary_key) for related_objects in ogm.related.values(): related_objects.__db_push__(graph)
def uri_string(self): """ The fully resolved URI string for this target. :rtype: string """ if isinstance(self.entity, int): uri_string = "{%d}" % self.entity elif isinstance(self.entity, NodePointer): uri_string = "{%d}" % self.entity.address else: remote_entity = remote(self.entity) if remote_entity: uri_string = remote_entity.ref else: uri_string = ustr(self.entity) if self.segments: if not uri_string.endswith("/"): uri_string += "/" uri_string += "/".join(map(percent_encode, self.segments)) return uri_string
def remove(self, key=None, value=None, entity=None): """ Remove any entries from the index which match the parameters supplied. The allowed parameter combinations are: `key`, `value`, `entity` remove a specific entity indexed under a given key-value pair `key`, `value` remove all entities indexed under a given key-value pair `key`, `entity` remove a specific entity indexed against a given key but with any value `entity` remove all occurrences of a specific entity regardless of key and value """ if key and value and entity: t = ResourceTemplate(remote(self).uri.string + "/{key}/{value}/{entity}") t.expand(key=key, value=value, entity=remote(entity)._id).delete() elif key and value: uris = [ URI(remote(entity).metadata["indexed"]) for entity in self.get(key, value) ] batch = ManualIndexWriteBatch(self.graph) for uri in uris: batch.append_delete(uri) batch.run() elif key and entity: t = ResourceTemplate(remote(self).uri.string + "/{key}/{entity}") t.expand(key=key, entity=remote(entity)._id).delete() elif entity: t = ResourceTemplate(remote(self).uri.string + "/{entity}") t.expand(entity=remote(entity)._id).delete() else: raise TypeError("Illegal parameter combination for index removal")
def __init__(self, graph): self.graph = graph self.runner = BatchRunner(remote(self.graph).metadata["batch"]) self.jobs = []
def _get_ref(elt, cls, props): return remote(elt).ref if isinstance(elt, cls) else props.pop("_ref")
def _get_ref(elt, props): if isinstance(elt, Node): return int(remote(elt).ref.split('/', 1)[-1]) else: return elt["metadata"]["id"]
def __repr__(self): return "{0}({1}, {2})".format( self.__class__.__name__, self._content_type.__name__, repr(remote(self).uri.string) )