def showAllDB(): db = GraphDatabase(workingdb) query = """START n=node(*) MATCH (n) - [r] -> (m) RETURN n.name, r, m.name""" print db.query(query) db.shutdown()
def showAllRelations(qname): db = GraphDatabase(workingdb) query = """START n=node(*) MATCH (n) - [r] -> (m) WHERE HAS(n.name) AND n.name = {name} RETURN n.name, r, m.name""" print db.query(query, name=qname) db.shutdown()
def showAllNodes(): # open the db db = GraphDatabase(workingdb) number_of_nodes = len(db.nodes) query = "START n=node(*) RETURN n" print "This db has " + str(number_of_nodes) +"nodes" if(number_of_nodes>0): print db.query(query) else: print "no nodes" db.shutdown()
class SocialGraph: def __init__(self, neo4j_url="graph.db"): self.db = GraphDatabase(neo4j_url) self.nodes = {} self.rels = [] def file_to_db(self, data_path): data = json_io.read_json(data_path) with self.db.transaction: for source_name, targets in data.iteritems(): if source_name in self.nodes: source = self.nodes[source_name] else: source = self.db.node(name=source_name) self.nodes[source_name] = source for target_name in targets: if target_name in self.nodes: target = self.nodes[target_name] else: target = self.db.node(name=target_name) self.nodes[target_name] = target #for attr, val in targets[target_name].iteritems(): self.rels.append(source.knows(target)) return self.nodes def load_pattern(self, dir_file, clip_file): self.dir_patterns = json_io.read_json(dir_file) self.clip_patterns = json_io.read_json(clip_file) def has_relationship(self, source_name, target_name): source = self.nodes[source_name] target = self.nodes[target_name] query = '''start source=node({s_id}) \ match (source)-[r]->(target) \ where target.name = {t_name} return r''' number_rel = self.db.query(query, s_id=source.id, t_name=target_name)['r'] if len(number_rel) > 1: return True else: return False def pattern_matching(self, source_name, target_name, keyword): source = self.nodes[source_name] target = self.nodes[target_name] result = self.dir_query(source, target_name) if result == keyword: return True elif result: return result elif result == False: return False result = self.dir_query(target, source_name) if result == keyword: return True elif result: return result elif result == False: return False result = self.clip_query(source, target_name) if result == keyword: return True elif result: return result elif result == False: return False return True def dir_query(self, source, target_name): dir_query = '''START source=node({s_id}) \ MATCH (source)-[r1]->(middleman)-[r2]->(target) \ WHERE target.name = {t_name} RETURN r1, r2''' results = self.db.query(dir_query, s_id=source.id, t_name=target_name) for result in results: if 'rel' in result['r1'].keys() and \ 'rel' in result['r2'].keys(): relationship1 = result['r1']['rel'] relationship2 = result['r2']['rel'] if relationship2 in self.dir_patterns[relationship1]: predict_rel = self.dir_patterns[relationship1][relationship2] else: return False return predict_rel return None def clip_query(self, source, target_name): dir_query = '''START source=node({s_id}) \ MATCH (source)-[r1]->(middleman)<-[r2]-(target) \ WHERE target.name = {t_name} RETURN r1, r2''' results = self.db.query(dir_query, s_id=source.id, t_name=target_name) for result in results: if 'rel' in result['r1'].keys() and 'rel' in result['r2'].keys(): relationship1 = result['r1']['rel'] relationship2 = result['r2']['rel'] if relationship2 in self.clip_patterns[relationship1]: predict_rel = self.clip_patterns[relationship1][relationship2] else: return False return predict_rel return None def relationship_tagging(self, source_name, target_name, keyword, confidence): source = self.nodes[source_name] target = self.nodes[target_name] with self.db.transaction: relationship = source.knows(target, rel=keyword) if confidence <= 2: print source_name + ' <-- ' + keyword + ' <-- ' + target_name relationship = target.knows(source, rel=keyword) def clear(self): with self.db.transaction: for rel in self.db.relationships: rel.delete() for node in self.db.nodes: node.delete() def shutdown(self): self.db.shutdown()
class Memory(object): def __init__(self,mind,dbpath="data"): self.mind = mind self.dbpath = dbpath self.mind.log("Starting Graph Database at "+dbpath) self.db = GraphDatabase(dbpath) self.root = None memorySize = len(self.db.nodes) self.log("starting with "+str(memorySize)+" nodes in memory") self.vars = {} self.initialGraph(memorySize<=1) def __del__(self): self.shutdown() def shutdown(self): self.log("shutting down Graph Database...") self.db.shutdown() def log(self,something): self.mind.log(something) def error(self,errorType,command): self.mind.error(errorType,command) def initialTime(self,create=False): if create: self.log("create time graph...") with self.db.transaction: self.timeIndex = self.db.node.indexes.create('abstractTime') self.eventIndex = self.db.node.indexes.create('events') self.vars["timeroot"] = self.createNode("TIME_ROOT") self.vars["root"].TIMERELATION(self.vars["timeroot"]) self.vars["timeroot"].TIMERELATION(self.createNode("JALALI_CALENDAR"),cal_type="J") self.vars["timeroot"].TIMERELATION(self.createNode("HIJRI_CALENDAR"),cal_type="H") self.vars["timeroot"].TIMERELATION(self.createNode("GREGORY_CALENDAR"),cal_type="G") else: self.log("initial time...") with self.db.transaction: self.vars["timeroot"] = self.vars["root"].TIMERELATION.single.end self.timeIndex = self.db.node.indexes.get('abstractTime') self.eventIndex = self.db.nodes.indexes.get('events') def initialPlace(self,create=False): if create: self.log("create place graph ...") with self.db.transaction: self.placeIndex = self.db.node.indexes.create('abstractPlace') self.vars["placeroot"] = self.createNode(name="PLACE_ROOT") self.vars["root"].PLACERELATION(self.vars["placeroot"]) else: self.log("initial place ...") with self.db.transaction: self.vars["placeroot"] = self.vars["root"].PLACERELATION.single.end self.placeIndex = self.db.node.indexes.get('abstractPlace') def initialObjects(self,create=False): if create: with self.db.transaction: self.vars["objectroot"] = self.createNode("OBJECT_ROOT") self.vars["root"].OBJECTRELATION(self.vars["objectroot"]) self.vars["actionroot"] = self.createNode("ACTION_ROOT") self.vars["objectroot"].ACTIONRELATION(self.vars["actionroot"]) self.vars["eventroot"] = self.createNode("EVENT_ROOT") self.vars["objectroot"].EVENTRELATION(self.vars["eventroot"]) self.vars["me"] = self.createNode('me') self.vars["me"].ISA(self.vars["objectroot"],type="me") self.vars["master"] = self.createNode('master') self.vars["master"].ISA(self.vars["objectroot"],type="master") else: self.vars["objectroot"] = self.vars["root"].OBJECTRELATION.single.end self.vars["actionroot"] = self.vars["objectroot"].ACTIONRELATION.single.end self.vars["eventroot"] = self.vars["objectroot"].EVENTRELATION.single.end self.vars["me"] = [rel for rel in self.vars["objectroot"].ISA.incoming if rel["type"]=="me" ][0].start self.vars["master"] = [rel for rel in self.vars["objectroot"].ISA.incoming if rel["type"]=="master" ][0].start def initialGraph(self,create=False): if create: self.log("create Graph ...") with self.db.transaction: self.vars["root"] = self.db.node[0] self.vars["root"]['name'] = 'ROOT' self.nameIndex = self.db.node.indexes.create('name') self.indexName(self.vars["root"]) self.messageIndex = self.db.node.indexes.create('message',type='fulltext') else: self.log("initial graph...") with self.db.transaction: self.vars["root"] = self.db.node[0] self.nameIndex = self.db.node.indexes.get('name') self.messageIndex = self.db.node.indexes.get('message') self.initialTime(create) self.initialPlace(create) self.initialObjects(create) def getNodes(self,str): if str.startswith("`") and str.endswith("`"): result = [] for id in str[1:-1].split(","): result.append(self.db.node[int(id)]) if len(result)==1: return result[0] if len(result)>1: return result return str def cypher(self,query): return self.db.query(query) def findNodeById(self,id): return self.db.nodes[id] def indexName(self,obj): try: del self.nameIndex['name'][obj['name']][obj] except: pass self.nameIndex['name'][obj['name']] = obj def createNode(self,name=None): with self.db.transaction: if name == None: node = self.db.node() else: node = self.db.node(name=name) self.indexName(node) return node def createNodeOFType(self, typename=None, prop={}): with self.mind.memory.db.transaction: name = None if "name" in prop.keys(): name = prop["name"] node = self.createNode(name) self.setNodeProperties(node,prop) if typename is not None: typevar = self.objectType(typename) node.IS(typevar) return node def setNodeProperties(self,node,prop): with self.db.transaction: for k,v in prop.items(): node[k] = v if k=="name": self.indexName(node) def setRelationProperties(self,rel,prop): with self.db.transaction: for k,v in prop.items(): rel[k] = v def createRelation(self,type,prop,src,target): with self.db.transaction: rel = src.relationships.create(type,target) self.setRelationProperties(rel, prop) def isTypeOf(self,node,type): return node is not None and node.hasProperty("type") and node["type"]==type def getProperty(self,node,name,default=None): if node is None or not node.hasProperty(name): return default else: return node[name] def typeOfObject(self,node): if node is None: return [] result = [] for v in node.IS.outgoing: if v.end.id != self.vars["objectroot"].id: result.append(v.end) return result def objectType(self,typename): with self.db.transaction: if typename==None: return self.vars["objectroot"] else: resultVarname = self.mind.workingMemory.getTmpVarname() query = """CYPHER 1.9 start root=node(0),t=node:name(name='%s') MATCH (root)-[:OBJECTRELATION]->()<-[:IS]-(t) RETURN t"""%(typename) self.mind.memoryWindow.cypher(resultVarname,query) resultVar = self.mind.workingMemory.getVar(resultVarname) if len(resultVar)==0 or resultVar[0] is None: typevar = self.createNode(typename) typevar.IS(self.mind.workingMemory.getVar("objectroot")[0]) else: typevar = resultVar[0] return typevar def actionType(self,subject,actionname): with self.db.transaction: resultVarname = self.mind.workingMemory.getTmpVarname() if len(subject)==0: query = """CYPHER 1.9 start root=node(0),t=node:name(name='%s') MATCH (root)-[:OBJECTRELATION]->()-[:ACTIONRELATION]->()<-[r:IS]-(t) WHERE has(r.type) and r.type="objective" RETURN t"""%(actionname) self.mind.memoryWindow.cypher(resultVarname,query) resultvar = self.mind.workingMemory.getVar(resultVarname) if resultvar is None or len(resultvar)==0 or resultvar[0] is None: actionvar = self.createNode(actionname) actionvar.IS(self.vars["actionroot"],type="objective") else: actionvar = resultvar[0] return [actionvar] else: for sbj in subject: sbjtype = self.typeOfObject(sbj) print sbjtype if len(sbjtype) == 0: sbjtype = [sbj] actionvars = [] for st in sbjtype: query = """CYPHER 1.9 start root=node(0),t=node:name(name='%s') MATCH (root)-[:OBJECTRELATION]->()-[:ACTIONRELATION]->()<-[r:IS]-(w)-[:WHO]->(t) WHERE has(r.type) and r.type="subjective" RETURN w"""%(self.getProperty(st, "name", "---")) self.mind.memoryWindow.cypher(resultVarname,query) resultvar = self.mind.workingMemory.getVar(resultVarname) if resultvar is None or len(resultvar)==0 or resultvar[0] is None: actionvar = self.createNode(self.getProperty(st, "name", "---")) actionvar.IS(self.vars["actionroot"],type="subjective") actionvar.WHO(st) else: actionvar = resultvar[0] created = False for ins in actionvar.IS.incoming: if self.getProperty(ins, "name") == actionname: created = True actionvars.append(ins) if not created: ins = self.createNode(actionname) ins.IS(actionvar) actionvars.append(ins) return actionvars
import os,jpype,time,random, cPickle os.environ['NEO4J_PYTHON_JVMARGS'] = '-Xms4G -Xmx8G -XX:MaxPermSize=1G' os.environ['JAVA_HOME']='/usr/lib/jvm/jdk1.7.0/' from neo4j import GraphDatabase db = GraphDatabase('data') print 'deleting' with db.transaction: db.query('start r=relationship(*) delete r'); db.query('start n=node(*) delete n;') print 'reading' friends = cPickle.load(open('friends.pickle')) print 'nodes' nodes = {} with db.transaction: for a,data in friends.items(): n = db.node(noscenda_name='person%s'%a) nodes[a]=n if a%1000==0: print 'n ',a i= 0 print 'relations' with db.transaction: for a,targets in friends.items(): for b in targets: i+=1 getattr(nodes[a],'friend')(nodes[b]) if i%1000==0:
return user #根据用户名获得用户节点 def get_user(name): return user_idx['name'][name].single #建立节点 for name in ['user1', 'user2','user3','user4']: create_user(name) #为节点间添加关注关系(FOLLOWS) with db.transaction: get_user('user2').FOLLOWS(get_user('user1')) get_user('user3').FOLLOWS(get_user('user1')) get_user('user4').FOLLOWS(get_user('user3')) # 获得用户1的粉丝 for relationship in get_user('user1').FOLLOWS.incoming: u = relationship.start print u['name'] #输出结果:user2,user3 #为用户4推荐好友,即该用户关注的用户所关注的用户 nid = get_user('user4').id #设置查询语句 query = "START n=node({id}) MATCH n-[:FOLLOWS]->m-[:FOLLOWS]->fof RETURN n,m,fof" for row in db.query(query,id=nid): node = row['fof'] print node['name'] #输出结果:user1
#script for excecuting a cypher query with embedded python from neo4j import GraphDatabase import traceback import time import redis r = redis.StrictRedis(host='46.137.39.99', port=6379, db=0) cypherRedisKey = r.get("cypherQueries") db = GraphDatabase("/mnt/neo4py_store/data/graph.db") try: cypher_query = "" while cypher_query is not None: print "query found" cypher_query = r.rpop(cypherRedisKey) if cypher_query is not None: db.query(cypher_query) print "sleeping..." time.sleep(10) except Exception, e: logfile = open('./pythonError.log', 'a') logfile.write("\n"+e.message()) logfile.close() db.shutdown()