图数据库笔记：NebulaGraph的基础查询

查询图数据库方式

使用官方提供的python client

测试用数据

上文提到的简单的网络拓扑结构数据

基本思想为，编写一个python类，传入参数后，返回指定参数、场景下的全部边和点数据，供前端使用

一、定义一个连接函数

    def session(self):
        self.connection_pool = ConnectionPool()
        Graph_Config = Config()
        Graph_Config.max_connection_pool_size = 3
        try:
            self.connection_pool.init([(config.NEBULA_HOST, config.NEBULA_PORT)], Graph_Config)
        except Exception as e:
            app.logger.error(e)

        self.client = None
        try:
            self.client = self.connection_pool.get_session(config.NEBULA_USER, config.NEBULA_PASS)
            self.client.execute("USE {}".format(config.NEBULA_SPACE))
        except:
            if self.client is not None:
                self.client.release()

• 官方给出的示例模板为使用了ConnectionPool，当链接数控制在一个时，可以直接实例Connection对象

二、定义一个执行函数，输出查询数据库后的结果

    def execute(self, sql=None):
        sql = sql if sql else self.NgSQL
        result = self.client.execute(sql)
        return result

三、根据不同的应用场景，列举不同的查询

# 获取节点的vid信息，vid为节点数据存储在数据库中的唯一主键
self.NgSQL ="""MATCH (v: node{ip_str: "%s"}) RETURN id(v) as id""" % self.end_ip

# 查询一个节点的上层节点
self.NgSQL = """MATCH p=(v: node{ip_str:"%s"})<-[e:next]-(v2) RETURN v2, relationships(p)""" % self.ip

# 查询一个节点的下层节点
self.NgSQL = """MATCH p=(v: node{ip_str:'%s'})-[e:next]->(v2) RETURN v2 , relationships(p)""" % self.ip

# 查询俩个节点之间的链路
self.NgSQL = """FIND SHORTEST PATH FROM {0} TO {1} OVER * UPTO 50 STEPS""".format(start_vid, target_vid)

# 根据任务条件查询(上文声明了任务数据单独设置为一种节点，在建联任务与节点完成节点绑定任务数据。因此根据任务条件查询为任务下所有的建联节点)
self.NgSQL = """MATCH (v: taskid{task_id:%s})-->(v2) RETURN v2""" % self.task_id

# 获取节点包含的所有信息
self.NgSQL = """MATCH (v2:node{ip_str: '%s'}) RETURN v2""" % self.ip

# 获取层级数据(可以以任何节点为根节点进行层级数据查询)
self.NgSQL = """GET SUBGRAPH 4 STEPS FROM {} out next""".format(self.get_vid())

四、数据的解析

• 由于返回结果为自定义的ResulrSet类型数据，需要对返回值进行类型解析

解析函数具体为

@staticmethod
def print_resp(col):
    value = ''
    if col.is_empty():
        value = ''
    elif col.is_null():
        value = 'None'
    elif col.is_bool():
        value = col.as_bool()
    elif col.is_int():
        value = col.as_int()
    elif col.is_double():
        value = col.as_double()
    elif col.is_string():
        value = col.as_string()
    elif col.is_time():
        value = col.as_time()
    elif col.is_list():
        value = col.as_list()
    elif col.is_set():
        value = col.as_set()
    elif col.is_map():
        value = col.as_map()
    elif col.is_vertex():
        value = col.as_node()
    elif col.is_edge():
        value = col.as_relationship()
    elif col.is_path():
        value = col.as_path()
    return value

最终根据解析后的数据组合成json类型数据，供前端使用。

具体的解析查询结果返回值示例为

# 解析边类型数据
def __parse_edge(self):
    edge_list = []
    for info in self.edge:
        new_info = info.as_list()
        if new_info:
            for s_info in new_info:
                new_data = s_info.as_relationship()
                start_id = self.print_resp(new_data.start_vertex_id())
                end_id = self.print_resp(new_data.end_vertex_id())

                if start_id == end_id:
                    continue
                edge_obj = new_data.propertys()
                for k, v in edge_obj.items():
                    edge_obj[k] = self.print_resp(v)
                virtual = edge_obj.get('virtual', False)
                if virtual:
                    edge_obj['style'] = GraphStyle.edgeStyle
                edge_obj['source'] = start_id
                edge_obj['target'] = end_id

                del edge_obj['virtual']
                edge_list.append(edge_obj)
    return edge_list