Go整合Neo4j——结果集记录的拆分

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/CSDN_FlyYoung/article/details/88573764

使用Go官方驱动查询Neo4j会得到一个CYPHER记录的结果集, 类似于JDBC查询数据库的结果集
CYPHER查询的一个记录就是一个节点和关系构成的子网, 该子网包含相应的节点和关系
如果是查询所有的节点和关系, 需要使用Neo4j的内部id来进行查询, 并在查询之后做id的去重处理

func (this *NetworkNode) GetNetwork(CYPHER string) ([]*NetworkNode, []*NetworkNodeEdge,  error) {

	// 创建neo4j驱动, 切记关闭驱动
	driver, driverErr := neo4j.NewDriver(conf.NEO4J_URL, neo4j.BasicAuth(conf.NEO4J_USERNAME, conf.NEO4J_PASSWORD, ""))
	if driverErr != nil {
		panic(driverErr.Error())
	}
	defer driver.Close()

	// 获取neo4j session, 切记关闭session
	session, sessionErr := driver.Session(neo4j.AccessModeRead)
	if sessionErr != nil {
		panic(sessionErr.Error())
	}
	defer session.Close()

	// 执行neo4j的读事务
	var nodesCh = make(chan []*NetworkNode)
	var nodeEdgesCh = make(chan []*NetworkNodeEdge)
	_, err := session.ReadTransaction(func(tx neo4j.Transaction) (interface{}, error) {
		result, resErr := tx.Run(CYPHER, nil)

		recordNum := 0
		var nodeMap = make(map[int]neo4j.Node)
		var relMap = make(map[int]neo4j.Relationship)
		for result.Next() {
			// 记录
			recordNum++
			recordValues := result.Record().Values()[0]

			// 节点
			nodes := recordValues.(neo4j.Path).Nodes()
			for _,v := range nodes {
				nodeMap[int(v.Id())] = v
			}

			// 关系
			relationships := recordValues.(neo4j.Path).Relationships()
			for _,v := range relationships {
				relMap[int(v.Id())] = v
			}
		}
		fmt.Println("nodeMapLen:", len(nodeMap))
		fmt.Println("relMapLen:", len(relMap))
		fmt.Println("recordLen:", recordNum)

		// 构造nodes
		go func() {
			nodes := ConstructNodes(nodeMap)
			nodesCh <- nodes
		}()

		// 构造RelationShip
		go func() {
			nodeEdges := ConstructRelships(relMap)
			nodeEdgesCh <- nodeEdges
		}()

		if resErr != nil {
			panic(resErr.Error())
		}

		return result, resErr
	})

	if err != nil {
		panic(err.Error())
	}

	return <- nodesCh, <- nodeEdgesCh, err
}

// 构造Node
func ConstructNodes(nodeMap map[int]neo4j.Node) (nodes []*NetworkNode) {
	for _, v := range nodeMap {
		nodeProps := v.Props()

		// 节点属性
		var networkProperty NetworkNodeProperty
		insertDate := nodeProps["insert_date"]
		if insertDate != nil {
			networkProperty.InsertDate = insertDate.(time.Time)
		}

		updateDate := nodeProps["update_date"]
		if updateDate != nil {
			networkProperty.UpdateDate = updateDate.(time.Time)
		}

		blkFlag1 := nodeProps["blk_flag1"]
		if blkFlag1 != nil {
			networkProperty.BlkFlg1 = blkFlag1.(string)
		}

		value := nodeProps["value"]
		if value != nil {
			networkProperty.Value = value.(string)
		}

		createDate := nodeProps["create_date"]
		if createDate != nil {
			networkProperty.CreateDate = createDate.(time.Time)
		}

		title := nodeProps["title"]
		if title != nil {
			networkProperty.Title = title.(string)
		}

		loadTimes := nodeProps["loan_times"]
		if loadTimes != nil {
			networkProperty.LoanTimes = int(loadTimes.(int64))
		}

		isReject := nodeProps["is_reject"]
		if isReject != nil {
			networkProperty.IsReject = isReject.(bool)
		}

		isNew := nodeProps["is_new"]
		if isNew != nil {
			networkProperty.IsNew = isNew.(bool)
		}

		isFraud := nodeProps["is_fraud"]
		if isFraud != nil {
			networkProperty.IsFraud = isFraud.(bool)
		}

		overdueDay := nodeProps["overdue_day"]
		if overdueDay != nil {
			networkProperty.OverdueDay = int(overdueDay.(int64))
		}

		myType := nodeProps["type"]
		if myType != nil {
			networkProperty.Type = myType.(string)
		}

		// 节点
		var node NetworkNode
		node.Id = int(v.Id())								// 节点id
		labels := v.Labels()								// 节点labels
		if labels != nil {
			node.Labels = labels
		}
		node.NetworkNodeProperties = networkProperty		// 节点属性

		// 添加node
		nodes = append(nodes, &node)
	}

	return
}

// 构造RelationShip
func ConstructRelships(relMap map[int]neo4j.Relationship) (nodeEdges []*NetworkNodeEdge) {
	for _, v := range relMap {
		// 关系属性
		var nodeEdgeProperty NetworkNodeEdgeProperty
		nodeEdgeProps := v.Props()
		nodeEdgeProperty.InsertDate = nodeEdgeProps["insert_date"].(time.Time)
		nodeEdgeProperty.UpdateDate = nodeEdgeProps["update_date"].(time.Time)

		// 关系
		var nodeEdge NetworkNodeEdge
		nodeEdge.Id = int(v.Id())							// 关系id
		nodeEdge.Type = v.Type()							// 关系类型
		nodeEdge.Source = int(v.StartId())					// 关系起点
		nodeEdge.Target = int(v.EndId())					// 关系终点
		nodeEdge.NodeEdgeProperty = nodeEdgeProperty		// 关系属性

		// 添加关系
		nodeEdges = append(nodeEdges, &nodeEdge)
	}

	return
}