def create_node_or_node_rel(node_key1, node1_id, node1_index_name, rel,
node_key2, node2_id, node2_index_name):
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node1_index_name)
group_index = Index.get_index(Node, node2_index_name)
print node_index
print group_index
tx = graph.begin()
node1 = node_index.get(node_key1, node1_id)[0]
node2 = group_index.get(node_key2, node2_id)[0]
if not (node1 and node2):
print "node does not exist"
return '1'
c_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s') MATCH (start_node)-[r:%s]->(end_node) RETURN r" % (
node1_index_name, 'pname', node1_id, node2_index_name, 'pname',
node2_id, rel)
print c_string
result = graph.run(c_string)
print result
rel_list = []
for item in result:
rel_list.append(item)
print rel_list
if not rel_list:
rel = Relationship(node1, rel, node2)
graph.create(rel)
print "create success"
else:
print "The current two nodes already have a relationship"
return '0'
return '2'
def create_node_or_node_rel(node_key1, node1_id, node1_index_name, rel,
node_key2, node2_id, node2_index_name):
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node1_index_name)
group_index = Index.get_index(Node, node2_index_name)
print node_index
print group_index
tx = graph.begin()
node1 = node_index.get(node_key1, node1_id)[0]
node2 = group_index.get(node_key2, node2_id)[0]
if not (node1 and node2):
print "node does not exist"
return 'does not exist'
c_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s') MATCH (start_node)-[r:%s]->(end_node) RETURN r" % (
node1_index_name, node_key1, node1_id, node2_index_name, node_key2,
node2_id, rel)
# return c_string
result = graph.run(c_string)
# print result
# rel_list = []
for item in result:
rel_list.append(item)
# print rel_list
if rel in rel_list:
return 'has relation already'
rel = Relationship(node1, rel, node2)
graph.create(rel)
print "create success"
return True
def create_rel_from_uid2_location():
Index = ManualIndexManager(graph) # manage index
node_index = Index.get_index(Node, node_index_name)
location_index = Index.get_index(Node, location_index_name)
tx = graph.begin()
count = 0
ts = time.time()
f = open("user_portrait.txt", "rb")
for line in f:
user_dict = json.loads(line)
uid = user_dict["uid"]
location = user_dict["location"]
if not location:
continue
user_node = node_index.get("uid", uid)[0]
location_node = location_index.get("location", location)[0]
rel = Relationship(user_node, "location", location_node)
tx.create(rel)
count += 1
if count % 1000 == 0:
tx.commit()
print count
te = time.time()
print te - ts
ts = te
tx = graph.begin()
tx.commit()
def create_rel_from_uid2_topic():
Index = ManualIndexManager(graph) # manage index
topic_name = "topic_index"
node_index = Index.get_index(Node, "node_index")
topic_index = Index.get_index(Node, topic_name)
tx = graph.begin()
count = 0
ts = time.time()
f = open("user_portrait.txt", "rb")
for line in f:
user_dict = json.loads(line)
uid = user_dict["uid"]
topic_string = user_dict["topic_string"]
user_node = node_index.get("uid", uid)[0]
topic_list = topic_string.split("&")
for iter_topic in topic_list:
topic_node = topic_index.get("topic", iter_topic)[0]
rel = Relationship(user_node, "topic", topic_node)
tx.create(rel)
count += 1
if count % 1000 == 0:
tx.commit()
print count
te = time.time()
print te - ts
ts = te
tx = graph.begin()
tx.commit()
def create_rel(node_key1, node1_list, node1_index_name, rel, node_key2, node2_id, node2_index_name, submit_user):
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node1_index_name)
group_index = Index.get_index(Node, node2_index_name)
tx = graph.begin()
for node1_id in node1_list:
# print node2_id
# print node1_id,'-----'
# node1 = node_index.get(node_key1, node1_id)
try:
node1 = node_index.get(node_key1, node1_id)[0]
# print node1, node1_id,'node1 hey2222!!'
except:
continue
# print node1, node1_id,'node1 hey!!'
return 'uid1 not exist'
node2 = group_index.get(node_key2, node2_id)[0]
if not (node1 and node2):
print "node does not exist"
return 'node does not exist'
c_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s') MATCH (start_node)-[r:%s]->(end_node) RETURN r" % (
node1_index_name, node_key1, node1_id, node2_index_name, node_key2, node2_id, rel)
result = graph.run(c_string)
rel_list = []
for item in result:
print item,'00000000000'
rel_list.append(item)
if rel not in rel_list:
rel2 = Relationship(node1, rel, node2)
graph.create(rel2)
print "create success"
else:
return 'has relation'
return '1'
def show_relation(node_key1, node1_id, node1_index_name, node_key2, node2_id,
node2_index_name):
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node1_index_name)
group_index = Index.get_index(Node, node2_index_name)
print node_index
print group_index
tx = graph.begin()
node1 = node_index.get(node_key1, node1_id)[0]
node2 = group_index.get(node_key2, node2_id)[0]
if not (node1 and node2):
print "node does not exist"
return 'does not exist'
c_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s') MATCH (start_node)-[r]-(end_node) RETURN r" % (
node1_index_name, node_key1, node1_id, node2_index_name, node_key2,
node2_id)
# return c_string
print c_string
result = graph.run(c_string)
# print result
rel_list = []
for item in result:
relation = dict(item)['r'].type()
relation_ch = relation_dict[relation]
if relation in [other_rel, event_other, organization_tag, user_tag]:
relation_name = dict(item)['r']['name']
relaiton_name_list = relation_name.split(',')
for i_name in relaiton_name_list:
relation_ch2 = relation_ch + '-' + i_name
relation = relation + '&' + relation_name
rel_list.append(relation_ch2)
else:
rel_list.append(relation_ch)
return rel_list
def create_node_location():
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node_index_name)
location_index = Index.get_or_create_index(Node, location_index_name)
f = open("user_portrait.txt", "rb")
count = 0
update_node = []
index_list = []
in_set = set()
tx = graph.begin()
for item in f:
user_dict = json.loads(item)
each_location = user_dict["location"]
exist = location_index.get("location", each_location)
if not exist and each_location not in in_set:
node = Node("Location", location=each_location)
tx.create(node)
index_list.append([each_location, node])
count += 1
in_set.add(each_location)
if count % 10 == 0:
print count
tx.commit()
tx = graph.begin()
for item in index_list:
location_index.add("location", item[0], item[1])
index_list = []
tx.commit()
if index_list:
for item in index_list:
location_index.add("location", item[0], item[1])
print "all done"
f.close()
def create_user2user_rel(uid_list, rel_type):
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node_index_name)
tx = graph.begin()
count = 0
"""
f = open("user_portrait.txt", "rb")
uid_list = []
for line in f:
user_dict = json.loads(line)
uid = user_dict["uid"]
uid_list.append(uid)
"""
for i in range(len(uid_list) - 1):
for j in range(i + 1, len(uid_list)):
user1 = uid_list[i]
user2 = uid_list[j]
user_node1 = node_index.get("uid", user1)[0]
user_node2 = node_index.get("uid", user2)[0]
prob = random.random()
if prob <= 0.03:
rel = Relationship(user_node1, rel_type, user_node2)
tx.create(rel)
count += 1
if count % 100 == 0:
tx.commit()
print count
tx = graph.begin()
tx.commit()
print "finish"
def create_relationship(st_node,
ed_node,
rel_type,
st_type="node_index",
ed_type="node_index",
st_index="uid",
ed_index="uid"):
Index = ManualIndexManager(graph) # manage index
start_index = Index.get_index(Node, st_type)
start_node = start_index.get(st_index, st_node)
if start_node:
start_node = start_node[0]
else:
print "start_node no exists"
sys.exit(0)
end_index = Index.get_index(Node, ed_type)
end_node = end_index.get(ed_index, ed_node)
if end_node:
end_node = end_node[0]
else:
print "end_node no exists"
sys.exit(0)
c_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s') MATCH (start_node)-[r:%s]->(end_node) RETURN r" % (
st_type, st_index, st_node, ed_type, ed_index, ed_node, rel_type)
result = graph.run(c_string)
rel_list = []
for item in result:
rel_list.append(item)
if not rel_list:
rel = Relationship(start_node, rel_type, end_node)
graph.create(rel)
print "create"
def put_in_node():
Index = ManualIndexManager(graph) # manage index
tx = graph.begin()
count = 0
index_list = [] # temporal put in
filter_set = set()
ts = time.time()
#domain_name = "domain_index"
domain_name = "topic_index"
domain_index = Index.get_or_create_index(Node, domain_name)
Batch_index = ManualIndexWriteBatch(graph)
#for item in domain_list:
for item in topic_list:
#st_node = Index.get_or_create_indexed_node(node_name, "uid", start_node, {"uid":start_node})
#ed_node = Index.get_or_create_indexed_node(node_name, "uid", end_node, {"uid":end_node})
#exist = Index.get_indexed_node(domain_name, "domain", item)
exist = Index.get_indexed_node(domain_name, "topic", item)
if not exist:
#node = Node("Domain", domain=item)
node = Node("Topic", topic=item)
tx.create(node)
index_list.append([item, node])
tx.commit()
for item in index_list:
#domain_index.add('domain', item[0], item[1])
domain_index.add('topic', item[0], item[1])
print domain_index
print domain_index.get("topic", '科技类')
def delete_rel(node_key1, node1_id, node1_index_name, rel, node_key2, node2_id,
node2_index_name):
list = []
Index = ManualIndexManager(graph)
node1_index = Index.get_index(Node, node1_index_name)
node2_index = Index.get_index(Node, node2_index_name)
if not (node1_index or node2_index):
print "node_index does not exist"
return None
node1 = node1_index.get(node_key1, node1_id)[0]
node2 = node2_index.get(node_key2, node2_id)[0]
if not (node1 or node2):
print("node does not exist")
c_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s') MATCH (start_node)-[r:%s]-(end_node) RETURN r" % (
node1_index_name, node_key1, node1_id, node2_index_name, node_key2,
node2_id, rel)
result = graph.run(c_string)
for item in result:
list.append(item)
if not list:
print "Deleted rel does not exist"
return None
c_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s') MATCH (start_node)-[r:%s]-(end_node) DELETE r" % (
node1_index_name, node_key1, node1_id, node2_index_name, node_key2,
node2_id, rel)
print c_string
graph.run(c_string)
print "delete success"
return True
def create_rel(node_key1, node1_list, node1_index_name, rel, node_key2,
node2_id, node2_index_name, submit_user):
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node1_index_name)
group_index = Index.get_index(Node, node2_index_name)
tx = graph.begin()
print node1_list, '00990909000000000000'
for node1_id in node1_list:
print node1_id, '----==！！！==----'
node1 = node_index.get(node_key1, node1_id)
node1 = node_index.get(node_key1, node1_id)[0]
node2 = group_index.get(node_key2, node2_id)[0]
if not (node1 and node2):
print "node does not exist"
return 'node does not exist'
c_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s') MATCH (start_node)-[r:%s]->(end_node) RETURN r" % (
node1_index_name, node_key1, node1_id, node2_index_name, node_key2,
node2_id, rel)
result = graph.run(c_string)
rel_list = []
for item in result:
rel_list.append(item)
if rel not in rel_list:
rel2 = Relationship(node1, rel, node2)
graph.create(rel2)
print "create success"
return 'success'
def create_person(node_type, node_key, node_id, node_name_index):
Index = ManualIndexManager(graph)
node_name = Index.get_or_create_index(Node, node_name_index)
if node_name:
exist = node_name.get(node_key, node_id)
if exist:
return 'Node Exist' #节点已存在
else:
if node_key == "uid":
person_node = Node(node_type, uid=node_id)
elif node_key == "org_id":
person_node = Node(node_type, org_id=node_id)
elif node_key == "event_id":
person_node = Node(node_type, event_id=node_id)
elif node_key == "event":
person_node = Node(node_type, event=node_id)
elif node_key == "group":
person_node = Node(node_type, group=node_id)
else:
return 'Node Type Wrong' #节点类型错误
graph.create(person_node)
node_name.add(node_key, node_id, person_node)
return 'Node Success' #创建节点成功
else:
return 'Node Wrong' #创建节点失败
def create_node_or_node_rel(node_key1, node1_id, node1_index_name, rel,
node_key2, node2_id, node2_index_name):
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node1_index_name)
group_index = Index.get_index(Node, node2_index_name)
tx = graph.begin()
if len(node_index.get(node_key1, node1_id)) == 0:
return 'Node1 does not exist'
if len(group_index.get(node_key2, node2_id)) == 0:
return "Node2 does not exist"
node1 = node_index.get(node_key1, node1_id)[0]
node2 = group_index.get(node_key2, node2_id)[0]
if not (node1 and node2):
return "Node1 and Node2 do not exist"
c_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s') MATCH (start_node)-[r:%s]->(end_node) RETURN r" \
% (node1_index_name, node_key1, node1_id, node2_index_name, node_key2, node2_id, rel)
result = graph.run(c_string)
# print result
rel_list = []
for item in result:
rel_list.append(item)
if not rel_list:
rel = Relationship(node1, rel, node2)
graph.create(rel)
return "Create success"
else:
return "The current two nodes already have a relationship"
def create_rel_from_uid2_domain():
Index = ManualIndexManager(graph) # manage index
domain_name = "domain_index"
node_index = Index.get_index(Node, "node_index")
domain_index = Index.get_index(Node, domain_name)
domain_node = domain_index.get("domain", "媒体")
tx = graph.begin()
count = 0
ts = time.time()
f = open("user_portrait.txt", "rb")
for line in f:
user_dict = json.loads(line)
uid = user_dict["uid"]
print uid
print count
domain = user_dict["domain"]
user_node = node_index.get("uid", uid)[0]
domain_node = domain_index.get("domain", domain)[0]
rel = Relationship(user_node, "domain", domain_node)
tx.create(rel)
count += 1
if count % 1000 == 0:
tx.commit()
print count
te = time.time()
print te - ts
ts = te
tx = graph.begin()
tx.commit()
def create_relationship(st_node, ed_node, rel_type):
Index = ManualIndexManager(graph) # manage index
node_name = "node_index"
node_index = Index.get_index(Node, node_name)
start_node = node_index.get("uid", st_node)
end_node = node_index.get("uid", ed_node)
c_string = "START start_node=node:node_index(uid='%s'),end_node=node:node_index(uid='%s') MATCH (start_node)-[r:'%s']->(end_node) RETURN r" % (
st_node, ed_node, rel_type)
result = graph.run(c_string)
for item in result:
print item
def get_user_attribute_by_index(uid):
ts = time.time()
Index = ManualIndexManager(graph) # manage index
node_name = "node_index"
node_index = Index.get_index(Node, node_name)
user_node = node_index.get("uid", uid)
print user_node
te = time.time()
print te - ts
return user_node
def update_node(key_id, uid, node_name, attribute_dict):
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node_name)
node = node_index.get(key_id, uid)[0]
if not node:
return "No such node"
for k, v in attribute_dict.iteritems():
node[k] = v
graph.push(node)
return "Update success"
def create_node_or_node_rel(node_key1, node1_id, node1_index_name, rel_union,
node_key2, node2_id, node2_index_name):
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node1_index_name)
group_index = Index.get_index(Node, node2_index_name)
print node_index
print group_index
tx = graph.begin()
node1 = node_index.get(node_key1, node1_id)[0]
node2 = group_index.get(node_key2, node2_id)[0]
if not (node1 and node2):
print "node does not exist"
return 'does not exist'
# c_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s') MATCH (start_node)-[r:%s]->(end_node) RETURN r" % (
# node1_index_name,node_key1, node1_id, node2_index_name, node_key2, node2_id, rel)
# # return c_string
# result = graph.run(c_string)
# # print result
# rel_list = []
# for item in result:
# rel_list.append(item)
# # print rel_list
# if rel in rel_list:
# return 'has relation already'
rel = rel_union.split(',')[0]
if rel in [other_rel, event_other, organization_tag, user_tag]:
rel_name = rel_union.split(',')[1]
c_string = "START start_node=node:%s(%s='%s'), end_node=node:%s(%s='%s') \
MATCH (start_node)-[r:%s]->(end_node) RETURN type(r), r.name" % (node1_index_name,\
node_key1, node1_id, node2_index_name, node_key2, node2_id, rel)
result = graph.run(c_string)
exist_relation = []
for i in result:
dict_i = dict(i)
exist_relation = dict_i['r.name'].split(',')
if exist_relation:
del_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s') \
MATCH (start_node)-[r:%s]->(end_node) delete r" % (node1_index_name,\
node_key1, node1_id, node2_index_name, node_key2, node2_id, rel)
result = graph.run(del_string)
exist_relation.append(rel_name)
exist_relation = [i for i in set(exist_relation)]
add_relation_string = ','.join(exist_relation)
c_string = "START start_node=node:%s(%s='%s'),end_node=node:%s(%s='%s')\
create (start_node)-[r:%s {name:'%s'} ]->(end_node) " %(node1_index_name,\
node_key1, node1_id, node2_index_name, node_key2, node2_id, rel, add_relation_string)
result = graph.run(c_string)
else:
rel = Relationship(node1, rel, node2)
graph.create(rel)
print "create success"
return True
def create_rel_from_event_special(event, special_event):
Index = ManualIndexManager(graph) # manage index
event_index = Index.get_index(Node, event_index_name)
special_event_index = Index.get_index(Node, special_event_index_name)
node1 = event_index.get("event", event)[0]
node2 = special_event_index.get("event", special_event)[0]
rel = Relationship(node1, event_special, node2)
tx = graph.begin()
tx.create(rel)
tx.commit()
def delete_user(uid):
Index = ManualIndexManager(graph) # manage index
node_name = "node_index"
node_index = Index.get_index(Node, node_name)
user_node = node_index.get("uid", uid)
print user_node
if not user_node:
print "no user exists"
return None
#c_string = "MATCH (n {uid: '%s'})-[rel]->(fof) DELETE n,rel" %uid
c_string = "START start_node=node:node_index(uid='%s') MATCH (start_node)-[rel]->(fof) DELETE start_node, rel" % uid
result = graph.run(c_string)
print result
def create_node_and_rel(node_key1, node1_list, node1_index_name, rel, node_key2, \
node2_id, node2_index_name, submit_user, k_label, node2_name):
Index = ManualIndexManager(graph) # manage index
group_index = Index.get_or_create_index(Node, node2_index_name)
p_node2_id = p.get_pinyin(node2_id)
p_node2_id = p_node2_id.lower()
c_string = "START end_node=node:%s(%s='%s') RETURN end_node"\
% (node2_index_name, node_key2, p_node2_id)
print c_string
try:
result = graph.run(c_string)
except:
result = []
node_l = []
for i in result:
node_l.append(i[0])
if len(node_l) > 0: #判断对否有该节点存在
return 'group already exist'
else:
group_dict = {}
group_dict['group_name'] = node2_name
group_dict['people'] = '&'.join(node1_list)
group_dict['people_count'] = len(node1_list)
group_dict['create_ts'] = int(time.time())
group_dict['user'] = submit_user
group_dict['k_label'] = '&'.join(k_label.split(','))
group_id = p.get_pinyin(node2_id)
group_id = group_id.lower()
labels = get_special_labels(node1_list)
group_dict['label'] = labels
wiki_link = getUrlByKeyWordList(labels)
group_dict['wiki_link'] = json.dumps(wiki_link)
# es_group.delete(index=group_name, doc_type=group_type, id='*****@*****.**')
es_group.index(index=group_name,
doc_type=group_type,
id=group_id,
body=group_dict)
new_group = Node(group_node, group=group_id)
graph.create(new_group)
group_index.add("group", group_id, new_group)
# return 'succeed'
user_org = search_user_type(node1_list)
user_id = user_org[0]
org_id = user_org[1]
flag = create_rel(node_key1, user_id, node1_index_name, rel, node_key2,
group_id, node2_index_name, submit_user)
node_key11 = org_primary
node11_index_name = org_index_name
info = create_rel(node_key1, org_id, node1_index_name, rel, node_key2,
group_id, node2_index_name, submit_user)
return info
def put_in_special_event(event_name):
Index = ManualIndexManager(graph)
special_event_index = Index.get_or_create_index(Node,
special_event_index_name)
exist = special_event_index.get("event", event_name)
if not exist:
node = Node("SpecialEvent", event=event_name)
tx = graph.begin()
tx.create(node)
tx.commit()
special_event_index.add("event", event_name, node)
return 1
return 0
def query_db():
Index = ManualIndexManager(graph) # manage index
#node_1 = Index.get_indexed_node("uid_index", "uid", "3293303045")
node_1 = Index.get_indexed_node("uid_index", "uid", "2139111593")
c_string = "MATCH (node_1)-[:retweet]->(fof) RETURN fof.uid"
result = graph.run(c_string)
uid_set = []
count = 0
for item in graph.run(c_string):
uid_set.append(item['fof.uid'])
count += 1
print count
print len(uid_set)
print sorted(uid_set)[:20]
def update_node(key_id, uid, node_index_name, attribute_dict):
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node_index_name)
node = node_index.get(key_id, uid)[0]
print node
if not node:
print "no such node"
sys.exit(0)
for k, v in attribute_dict.iteritems():
node[k] = v
graph.push(node)
print "update success"
return True
def select_rels(node_key, node_id, node_name_index):
list = []
Index = ManualIndexManager(graph)
node_name = Index.get_index(Node, node_name_index)
if not node_name:
return "Node_index does not exist "
node = node_name.get(node_key, node_id)[0]
if not node:
return "Node does not exist"
c_string = "START start_node=node:%s(%s='%s') MATCH (start_node)-[r]-() return r" % (
node_name_index, node_key, node_id)
print c_string
result = graph.run(c_string)
for item in result:
list.append(item)
return list
def create_node_and_rel(node_key1, node1_list, node1_index_name, rel, node_key2, \
node2_id, node2_index_name, submit_user, k_label, node2_name):
Index = ManualIndexManager(graph) # manage index
theme_index = Index.get_or_create_index(Node, node2_index_name)
p_node2_id = p.get_pinyin(node2_id)
p_node2_id = p_node2_id.lower()
c_string = "START end_node=node:%s(%s='%s') RETURN end_node"\
% (node2_index_name, node_key2, p_node2_id)
print c_string
try:
result = graph.run(c_string)
except:
result = []
node_l = []
for i in result:
# node1_l
node_l.append(i[0])
if len(node_l) > 0: #判断对否有该节点存在
return 'theme already exist'
else:
theme_dict = {}
theme_dict['topic_name'] = node2_name
theme_dict['event'] = '&'.join(node1_list)
theme_dict['event_count'] = len(node1_list)
theme_dict['create_ts'] = int(time.time())
theme_dict['user'] = submit_user
if k_label:
k_label = '&'.join(k_label.split(','))
theme_dict['k_label'] = k_label
topic_id = p.get_pinyin(node2_id)
topic_id = topic_id.lower()
labels = get_special_labels(node1_list)
theme_dict['label'] = labels
wiki_link = getUrlByKeyWordList(labels)
theme_dict['wiki_link'] = json.dumps(wiki_link)
# es_event.delete(index=special_event_name, doc_type=special_event_type, id='*****@*****.**')
es_event.index(index=special_event_name,
doc_type=special_event_type,
id=topic_id,
body=theme_dict)
new_theme = Node(special_event_node, event=topic_id)
graph.create(new_theme)
theme_index.add("event", topic_id, new_theme)
# return 'succeed'
info = create_rel(node_key1, node1_list, node1_index_name, rel, node_key2,
topic_id, node2_index_name, submit_user)
return info
def update_attribute(uid, attribute_dict):
ts = time.time()
Index = ManualIndexManager(graph) # manage index
ts = time.time()
node_name = "node_index"
node_index = Index.get_index(Node, node_name)
user_node = node_index.get("uid", uid)[0] # return with a list
print user_node
# update attribute-value
for k, v in attribute_dict.iteritems():
user_node[k] = v
# push to neo4j-db
graph.push(user_node)
te = time.time()
print te - ts
def create_user(user, attribute_dict=dict()):
Index = ManualIndexManager(graph) # manage index
node_name = "node_index"
node_index = Index.get_index(Node, node_name)
exist = node_index.get("uid", user)
if exist:
user_node = exist[0]
for k, v in attribute_dict.iteritems():
user_node[k] = v
graph.push(user_node)
else:
user_node = Node("User", uid=user)
for k, v in attribute_dict.iteritems():
user_node[k] = v
graph.create(user_node)
node_index.add("uid", user, user_node)
return True
def delete_node(node_key, node_id, node_index_name):
Index = ManualIndexManager(graph)
node_index = Index.get_index(Node, node_index_name)
if not node_index:
print "node_index does not exist"
return None
node = node_index.get(node_key, node_id)[0]
if not node:
print "The node does not exist"
return None
c_string = "START start_node=node:%s(%s='%s') MATCH (start_node)-[r]-() DELETE r" % (
node_index_name, node_key, node_id)
graph.run(c_string)
print "delete rel success"
c_string = "START start_node=node:%s(%s='%s') delete start_node" % (
node_index_name, node_key, node_id)
graph.run(c_string)
print "delete node success"
return True
