def add_node_collection_to_graph(self, db_name, collection_name, label, limit=0): """Adds all nodes in Mongo collection to Neo4j. :param str db_name: name of Mongo database :param str collection_name: name of collection in the MongoDB :param str label: :param int limit: if > 0, only limit records are added to the graph :rtype None: """ c = self.get_collection(db_name, collection_name) cur = c.find(limit=limit) # Create a write batch to add nodes to batch = neo4j.WriteBatch(self) # Iterate over all records in the collection and add corresponding node for i, d in enumerate(cur): anode = self.get_or_add_node_to_batch(d, label_index=label, batch=batch, stub='False') if (i % 100) == 0: batch.submit() batch = neo4j.WriteBatch(self) print 'add_node_collection_to_graph', label, i, self.order batch.submit()
def test_complex_relate(self): alice, bob, carol, dave = self.graph_db.create({"name": "Alice"}, {"name": "Bob"}, {"name": "Carol"}, {"name": "Dave"}) batch = neo4j.WriteBatch(self.graph_db) batch.get_or_create_path(alice, ("IS~MARRIED~TO", { "since": 1996 }), bob) #batch.get_or_create((alice, "DISLIKES", carol, {"reasons": ["youth", "beauty"]})) batch.get_or_create_path(alice, ("DISLIKES!", { "reason": "youth" }), carol) rels1 = batch.submit() self.assertTrue(rels1 is not None) self.assertEqual(2, len(rels1)) batch = neo4j.WriteBatch(self.graph_db) batch.get_or_create_path(bob, ("WORKS WITH", { "since": 2004, "company": "Megacorp" }), carol) #batch.get_or_create((alice, "DISLIKES", carol, {"reasons": ["youth", "beauty"]})) batch.get_or_create_path(alice, ("DISLIKES!", { "reason": "youth" }), carol) batch.get_or_create_path(bob, ("WORKS WITH", { "since": 2009, "company": "Megacorp" }), dave) rels2 = batch.submit() self.assertTrue(rels2 is not None) self.assertEqual(3, len(rels2)) self.assertEqual(rels1[1], rels2[1])
def Test1(self): startTime = datetime.datetime.now() num_nodes = 100000 num_labels = 1000 print "Adding %d labels to %d nodes" % (num_labels, num_nodes) print "(# nodes in label ~ Uniform)" nodes_in_label = map( lambda x: int(round(x)), np.random.uniform(low=0,high=num_nodes,size=num_labels) ) cnt = 0 wbatch = neo4j.WriteBatch(self.gdb) for index, num in enumerate(nodes_in_label): print "--adding label_%d to %d nodes" % (index, num) wbatch.append_cypher(self._getAddLabelCypher('label_%d' % index), {'num': num}) cnt += 1 if cnt == 5: wbatch.submit() cnt = 0 wbatch = neo4j.WriteBatch(self.gdb) endTime = datetime.datetime.now() print "%d labels added to %d nodes" % (num_labels, num_nodes) print endTime - startTime
def test_is_idempotent(graph): alice, = graph.create({"name": "Alice"}) batch = neo4j.WriteBatch(graph) batch.get_or_create_path(alice, "KNOWS", {"name": "Bob"}) results = batch.submit() path = results[0] bob = path.nodes[1] assert path.nodes[0] == alice assert bob["name"] == "Bob" batch = neo4j.WriteBatch(graph) batch.get_or_create_path(alice, "KNOWS", {"name": "Bob"}) results = batch.submit() path = results[0] assert path.nodes[0] == alice assert path.nodes[1] == bob
def test_can_add_labels_to_node_in_same_batch(graph): batch = neo4j.WriteBatch(graph) a = batch.create({"name": "Alice"}) batch.add_labels(a, "human", "female") results = batch.submit() alice = results[batch.find(a)] assert alice.get_labels() == {"human", "female"}
def test_can_set_property_on_preexisting_node(): graph_db = neo4j.GraphDatabaseService() alice, = graph_db.create({"name": "Alice"}) batch = neo4j.WriteBatch(graph_db) batch.set_property(alice, "age", 34) batch.run() assert alice["age"] == 34
def createAnalysis(self, target_uuid=None, target_genid=None, data_link=None, results_uuid=None, description_uuid=None): if (target_uuid is None) == (target_genid is None): raise Exception( "Exactly one of the following parameters must be specified: target_uuid, target_genid " ) if target_genid is not None: target_node = self._getNodeByGenid(label=BIOENTITY, genid=target_genid) else: target_node = self._getNodeByUUID(label=RAW_DATA, uuid=target_uuid) wbatch = neo4j.WriteBatch(self.gdb) params = {} params['uuid'] = self._getNewUUID() if data_link is not None: params['data_link'] = data_link if results_uuid is not None: params['results_uuid'] = results_uuid if description_uuid is not None: params['description_uuid'] = description_uuid analysis_node = wbatch.create(node(params)) wbatch.add_labels(analysis_node, ANALYSIS) wbatch.create(rel(target_node, HAS_ANALYSIS, analysis_node)) wbatch.submit() return params['uuid']
def test_is_not_idempotent(): graph_db = neo4j.GraphDatabaseService() alice, = graph_db.create({"name": "Alice"}) batch = neo4j.WriteBatch(graph_db) batch.create_path(alice, "KNOWS", {"name": "Bob"}) results = batch.submit() path = results[0] bob = path.nodes[1] assert path.nodes[0] == alice assert bob["name"] == "Bob" batch = neo4j.WriteBatch(graph_db) batch.create_path(alice, "KNOWS", {"name": "Bob"}) results = batch.submit() path = results[0] assert path.nodes[0] == alice assert path.nodes[1] != bob
def _update_index(self, props): for cls in self.__class__.mro(): if cls.__name__ == 'StructuredNode' or cls.__name__ == 'ReadOnlyNode': break batch = neo4j.WriteBatch(self.client) for key, value in props.iteritems(): if key in cls.__dict__.keys(): node_property = cls.get_property(key) if node_property.unique_index: try: batch.add_indexed_node_or_fail( cls.index.__index__, key, value, self.__node__) except NotImplementedError: batch.get_or_add_indexed_node( cls.index.__index__, key, value, self.__node__) elif node_property.index: batch.add_indexed_node(cls.index.__index__, key, value, self.__node__) requests = batch.requests try: i = 0 for r in batch._submit(): if r.status == 200: raise UniqueProperty(requests[i], cls.index.name) i = i + 1 except rest.ResourceConflict as r: raise UniqueProperty(requests[r.id], cls.index.name)
def test_can_delete_property_on_preexisting_node(graph): alice, = graph.create({"name": "Alice", "age": 34}) batch = neo4j.WriteBatch(graph) batch.delete_property(alice, "age") batch.run() assert alice["name"] == "Alice" assert alice["age"] is None
def test_can_set_properties_on_preexisting_node(graph): alice, = graph.create({}) batch = neo4j.WriteBatch(graph) batch.set_properties(alice, {"name": "Alice", "age": 34}) batch.run() assert alice["name"] == "Alice" assert alice["age"] == 34
def add_ref(self, source, relationship, dest): """ add relation for two nodes """ batch = neo4j.WriteBatch(self.graph_db) batch.create(rel(source, relationship, dest)) batch.submit()
def test_can_remove_labels_from_preexisting_node(graph): alice, = graph.create({"name": "Alice"}) alice.add_labels("human", "female") batch = neo4j.WriteBatch(graph) batch.remove_label(alice, "human") batch.run() assert alice.get_labels() == {"female"}
def test_can_add_labels_to_preexisting_node(): graph_db = neo4j.GraphDatabaseService() alice, = graph_db.create({"name": "Alice"}) batch = neo4j.WriteBatch(graph_db) batch.add_labels(alice, "human", "female") batch.run() assert alice.get_labels() == {"human", "female"}
def save(self, subj, node=None): """ Save an object to a database node. :param subj: the object to save :param node: the database node to save to (if omitted, will re-save to same node as previous save) """ if node is not None: subj.__node__ = node # naively copy properties from object to node props = {} for key, value in subj.__dict__.items(): if not key.startswith("_"): props[key] = value if hasattr(subj, "__node__"): subj.__node__.set_properties(props) query = neo4j.CypherQuery(self.graph, "START a=node({A}) " "MATCH (a)-[r]->(b) " "DELETE r") query.execute(A=subj.__node__._id) else: subj.__node__, = self.graph.create(props) # write rels if hasattr(subj, "__rel__"): batch = neo4j.WriteBatch(self.graph) for rel_type, rels in subj.__rel__.items(): for rel_props, endpoint in rels: end_node = self._get_node(endpoint) if not neo4j.familiar(end_node, self.graph): raise ValueError(end_node) batch.create((subj.__node__, rel_type, end_node, rel_props)) batch.run() return subj
def test_can_delete_properties_on_preexisting_node(graph): alice, = graph.create({"name": "Alice", "age": 34}) batch = neo4j.WriteBatch(graph) batch.delete_properties(alice) batch.run() props = alice.get_properties() assert props == {}
def test_can_set_property_on_node_in_same_batch(graph): batch = neo4j.WriteBatch(graph) alice = batch.create({"name": "Alice"}) batch.set_property(alice, "age", 34) results = batch.submit() alice = results[batch.find(alice)] assert alice["age"] == 34
def getShortestPaths(): batch = neo4j.WriteBatch(DB) # try and link user data from user->explore to user->trending queryString = """ MATCH (a:FourSqrVenues_explore)<-->(b:FourSqrUsers) MATCH p = allShortestPaths((a)<-->(b)) RETURN p limit 100 """ """ START n = node:points_hk('bbox:[ 22.3, 115.0, 22.271, 114.18 ]') WHERE (n:FourSquareVenues_explore) RETURN n """ """START n=node:points_hk('withinDistance:[ 22.35, 114.2, 15.0 ]') WHERE (n:FourSqrVenues_explore) return n""" queryString = '''MATCH (u:FourSqrVenues_explore) RETURN u.lat, u.lon''' batch.append_cypher(queryString) results = batch.submit() for i in results[0]: lat, lon = i[0], i[1] batch.append_cypher("START n=node:points_hk('withinDistance:[ %s, %s, 0.10 ]') WHERE (n:FourSqrVenues_explore) return n" %(lat, lon)) new_results = batch.submit() for i in new_results: if i: if isinstance(i, list): for new_i in i: print u'%s' %(new_i.values[0]) else: print i._id #print u'{0}'.format(i[0]) '''
def test_can_delete_properties_on_preexisting_node(): graph_db = neo4j.GraphDatabaseService() alice, = graph_db.create({"name": "Alice", "age": 34}) batch = neo4j.WriteBatch(graph_db) batch.delete_properties(alice) batch.run() props = alice.get_properties() assert props == {}
def test_can_delete_properties_on_node_in_same_batch(graph): batch = neo4j.WriteBatch(graph) alice = batch.create({"name": "Alice", "age": 34}) batch.delete_properties(alice) results = batch.submit() alice = results[batch.find(alice)] props = alice.get_properties() assert props == {}
def test_can_delete_property_on_node_in_same_batch(graph): batch = neo4j.WriteBatch(graph) alice = batch.create({"name": "Alice", "age": 34}) batch.delete_property(alice, "age") results = batch.submit() alice = results[batch.find(alice)] assert alice["name"] == "Alice" assert alice["age"] is None
def restoreWG(wgList): labels = ['Social', 'WG'] batch = neo4j.WriteBatch(gdb) for wgName in wgList: wgNode = batch.create(node(identifier=wgName)) batch.add_labels(wgNode, *labels) results = batch.submit() batch.clear()
def setUp(self): self.graph_db = default_graph_db() self.friendships = self.graph_db.get_or_create_index( neo4j.Relationship, "Friendships") self.alice, self.bob = self.graph_db.create({"name": "Alice"}, {"name": "Bob"}) self.batch = neo4j.WriteBatch(self.graph_db) self.recycling = []
def test_can_delete_property_on_preexisting_node(): graph_db = neo4j.GraphDatabaseService() alice, = graph_db.create({"name": "Alice", "age": 34}) batch = neo4j.WriteBatch(graph_db) batch.delete_property(alice, "age") batch.run() assert alice["name"] == "Alice" assert alice["age"] is None
def test_can_create_path_with_new_nodes(graph): batch = neo4j.WriteBatch(graph) batch.create_path({"name": "Alice"}, "KNOWS", {"name": "Bob"}) results = batch.submit() path = results[0] assert len(path) == 1 assert path.nodes[0]["name"] == "Alice" assert path.relationships[0].type == "KNOWS" assert path.nodes[1]["name"] == "Bob"
def test_can_set_properties_on_node_in_same_batch(): graph_db = neo4j.GraphDatabaseService() batch = neo4j.WriteBatch(graph_db) alice = batch.create({}) batch.set_properties(alice, {"name": "Alice", "age": 34}) results = batch.submit() alice = results[batch.find(alice)] assert alice["name"] == "Alice" assert alice["age"] == 34
def test_can_add_labels_to_node_in_same_batch(): graph_db = neo4j.GraphDatabaseService() batch = neo4j.WriteBatch(graph_db) alice = batch.create({"name": "Alice"}) batch.add_labels(alice, "human", "female") batch.remove_label(alice, "female") results = batch.submit() alice = results[batch.find(alice)] assert alice.get_labels() == {"human"}
def test_can_set_labels_on_preexisting_node(graph): if not graph.supports_node_labels: return alice, = graph.create({"name": "Alice"}) alice.add_labels("human", "female") batch = neo4j.WriteBatch(graph) batch.set_labels(alice, "mystery", "badger") batch.run() assert alice.get_labels() == {"mystery", "badger"}
def test_can_create_path_with_existing_nodes(graph): alice, bob = graph.create({"name": "Alice"}, {"name": "Bob"}) batch = neo4j.WriteBatch(graph) batch.create_path(alice, "KNOWS", bob) results = batch.submit() path = results[0] assert len(path) == 1 assert path.nodes[0] == alice assert path.relationships[0].type == "KNOWS" assert path.nodes[1] == bob
def test_can_use_return_values_as_references(): batch = neo4j.WriteBatch(neo4j.GraphDatabaseService()) a = batch.create(node(name="Alice")) b = batch.create(node(name="Bob")) batch.create(rel(a, "KNOWS", b)) results = batch.submit() ab = results[2] assert isinstance(ab, neo4j.Relationship) assert ab.start_node["name"] == "Alice" assert ab.end_node["name"] == "Bob"