django 实现：闭包表—树状结构-Toy模板网

这篇具有很好参考价值的文章主要介绍了django 实现：闭包表—树状结构。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

闭包表—树状结构数据的数据库表设计

闭包表模型

闭包表（Closure Table）是一种通过空间换时间的模型，它是用一个专门的关系表（其实这也是我们推荐的归一化方式）来记录树上节点之间的层级关系以及距离。

场景

我们基于 django orm实现一个文件树，文件夹直接可以实现无限嵌套
django 实现：闭包表—树状结构,django,数据库,sqlite

models

#  文件详情表（主要用于记录文件名）
class DmFileDetail(models.Model):
    file_name = models.CharField("文件名（文件夹名）", max_length=50)
    is_file = models.BooleanField("是否是文件", default=False)
    user_id = models.IntegerField("用户id", default=0)
    create_time = models.IntegerField("创建时间", default=0)
    update_time = models.IntegerField("创建时间", default=0)
    is_del = models.BooleanField("是否删除", default=False)

    class Meta:
        db_table = 'inchat_dm_file_detail'
        verbose_name = verbose_name_plural = u'数字人文件详情表'

    def __str__(self):
        return self.file_name

#  文件关系表（主要用户记录文件之间的关联，即路径）
class DmFileRelation(models.Model):
    ancestor_id = models.IntegerField("祖先节点ID")
    descendant_id = models.IntegerField("子孙节点ID")
    depth = models.IntegerField("深度（层级）", db_index=True)
    user_id = models.IntegerField("用户id", default=0, db_index=True)
    is_del = models.BooleanField("是否删除", default=False)

    class Meta:
        db_table = 'inchat_dm_file_relation'
        index_together = ('ancestor_id', 'descendant_id')
        verbose_name = verbose_name_plural = u'数字人文件关系表'

id	file_name
1	AAA
2	aaa.pdf

id	ancestor_id	descendant_id	depth
1	1	1	0
2	2	2	0
3	1	2	1

增删改查

class DmRelationNode:
    """
    关系节点
    """
    NAME = "DmRelationNode"
    RELATION_CLIENT = DmFileRelation

    @classmethod
    def insert_relation_node(cls, node_id, user_id, parent_id):
        """
        插入新的关系节点
        """
        # 自身
        insert_self = cls.RELATION_CLIENT(
            ancestor_id=parent_id,
            descendant_id=node_id,
            user_id=user_id,
            depth=1
        )
        insert_list = []
        # 获取父节点所有祖先
        parent_relation = cls.RELATION_CLIENT.objects.filter(descendant_id=parent_id) \
            .values_list('ancestor_id', 'depth')
        for ancestor_id, depth in parent_relation:
            insert_data = cls.RELATION_CLIENT(
                ancestor_id=ancestor_id,
                descendant_id=node_id,
                depth=depth + 1,
                user_id=user_id
            )
            insert_list.append(insert_data)
        # 插入自身
        insert_list.append(insert_self)
        logger.info('%s insert_relation_node.node_id:%s,parent_id:%s,insert_list:%s', cls.NAME, node_id, parent_id,
                    insert_list)
        ret = cls.RELATION_CLIENT.objects.bulk_create(insert_list)
        logger.info('%s insert_relation_node.node_id:%s,parent_id:%s,ret_list:%s', cls.NAME, node_id, parent_id, ret)
        return ret

    @classmethod
    def get_ancestor_relation(cls, node_id):
        """
        获取某个节点的所有祖先节点
        """
        arges = ['ancestor_id', 'descendant_id', 'depth']
        ancestor_relation_list = cls.RELATION_CLIENT.objects.filter(descendant_id=node_id, is_del=False).values(*arges)
        relation_map = dict()
        relation_dict = relation_map
        for ancestor in ancestor_relation_list:
            relation_dict['id'] = ancestor['ancestor_id']
            if ancestor['ancestor_id'] != node_id:
                relation_dict['children'] = {}
                relation_dict = relation_dict['children']
        return ancestor_relation_list

    @classmethod
    def get_descendant_relation(cls, node_id):
        """
        获取所有的子节点
        """
        arges = ['ancestor_id', 'descendant_id', 'depth']
        descendant_relation_list = cls.RELATION_CLIENT.objects.filter(ancestor_id=node_id, is_del=False).values(*arges)

        return descendant_relation_list

    @classmethod
    def get_direct_relation(cls, user_id):
        """
        获取所有直系
        """
        arges = ['ancestor_id', 'descendant_id', 'depth']
        direct_relation = cls.RELATION_CLIENT.objects.filter(depth=1, user_id=user_id, is_del=False).values(*arges)
        return direct_relation

    @classmethod
    def get_children_node(cls, node_id):
        """
        获取某节点的子节点
        """
        children_node = cls.RELATION_CLIENT.objects.filter(depth=1, ancestor_id=node_id, is_del=False) \
            .values_list('descendant_id', flat=True)
        return children_node

    @classmethod
    def remove_node(cls, node_id):
				"""
        删除节点
        """
        logger.info('%s remove_node. node_id:%s', cls.NAME, node_id)
        query = Q(ancestor_id=node_id, is_del=False) | Q(descendant_id=node_id, is_del=False)
        res = cls.RELATION_CLIENT.objects.filter(query).update(is_del=True)
        logger.info('%s remove_node. node_id:%s,count:%s', cls.NAME, node_id, res)
        return res

以下是一些常规的操作

class DmFileTree:
    """
    DM文件树
    """
    NAME = "DmFileTree"
    DETAIL_CLIENT = DmFileDetail
    RELATION_NODE_CLIENT = DmRelationNode
    FILE_SAVE_DIR = 'media/dm/'

    @classmethod
    def get_file_map(cls, user_id):
        """
        获取用户所有文件文件名
        """
        file_detail = cls.DETAIL_CLIENT.objects.filter(user_id=user_id).values('id', 'file_name', 'path', 'is_file')
        file_map = dict()
        for file in file_detail:
            file_dict = dict(
                id=file['id'],
                name=file['file_name'],
                is_file=file['is_file'],
                filePath=cls.FILE_SAVE_DIR + file['path'] + file['file_name']
            )
            file_map[file['id']] = file_dict
        return file_map

    @classmethod
    def add_file(cls, user_id, file_name, parent_id, path='', is_file=False):
        """
         新建文件（夹）
        """
        kwargs = dict(
            file_name=file_name,
            path=path,
            is_file=is_file,
            user_id=user_id,
            create_time=get_cur_timestamp()
        )
        file_obj = cls.DETAIL_CLIENT.objects.create(**kwargs)
        if not file_obj:
            logger.error('%s add_file failed. kwargs:%s', cls.NAME, kwargs)
            return False

        res = cls.RELATION_NODE_CLIENT.insert_relation_node(node_id=file_obj.id, user_id=user_id, parent_id=parent_id)
        if not res:
            return False

        return dict(id=file_obj.id, name=file_name)

    @classmethod
    def get_file_path(cls, file_id):
        """
        获取文件路径
        """
        ancestor_query = cls.RELATION_NODE_CLIENT.get_ancestor_relation(file_id)
        ancestor = map(lambda x: x['ancestor_id'], ancestor_query)
        # 过滤0
        ancestor = list(filter(lambda x: x > 0, ancestor))
        # 排序
        ancestor.sort()
        path = '/'.join(map(str, ancestor))
        return '/' + path + '/' if path else '/'

    @classmethod
    def get_all_files(cls, user_id):
        # 获取所有文件名字典
        file_map = cls.get_file_map(user_id)
        # 查询所有子目录及文件
        files_relation_list = cls.RELATION_NODE_CLIENT.get_direct_relation(user_id)
        file_info = {a['descendant_id']: file_map.get(a['descendant_id']) or {} for a in files_relation_list}
        tree = cls.list_to_tree(files_relation_list, file_info)
        return tree

    @classmethod
    def get_child_files(cls, user_id, parent_id):
        """
        获取下级文件
        """
        # 获取所有文件名字典
        file_map = cls.get_file_map(user_id)
        file_list = cls.RELATION_NODE_CLIENT.get_children_node(node_id=parent_id)

        files = map(lambda x: dict(id=x, name=file_map.get(x) or ''), file_list)
        return files

    @staticmethod
    def list_to_tree(data, node_dict):
        """
        将节点列表转换成树形结构字典
        :param data: 带有 id 和 parent_id 属性的节点列表
        :param node_dict: 单节点的数据结构字典
        :return: 树形结构字典
        """

        tree = []

        # 遍历每一个节点，将其添加到父节点的字典或根节点列表中
        for item in data:
            id = item['descendant_id']
            parent_id = item['ancestor_id']

            # 如果父节点为 None，则将当前节点添加到根节点列表中
            if not parent_id:
                tree.append(node_dict[id])
            # 如果父节点存在，则将当前节点添加到父节点的 children 属性中
            else:
                parent = node_dict[parent_id]
                if 'children' not in parent:
                    parent['children'] = []
                parent['children'].append(node_dict[id])

        return tree

    @classmethod
    def delete_file(cls, file_id):
        """
         文件删除
        """
        res1 = cls.DETAIL_CLIENT.objects.filter(id=file_id).update(is_del=True)
        logger.info('%s delete_file. file_id:%s, count:%s', cls.NAME, file_id, res1)
        res2 = cls.RELATION_NODE_CLIENT.remove_node(file_id)

        return res1, res2

    @classmethod
    def search_file(cls, file_name):
        """
        搜索文件
        """
        query_set = cls.DETAIL_CLIENT.objects.filter(file_name__icontains=file_name) \
            .values('id', 'file_name', 'path', 'is_file')
        file_list = []
        for file in query_set:
            file_dict = dict(
                id=file['id'],
                name=file['file_name'],
                is_file=file['is_file'],
                filePath='media/dm_upload' + file['path']
            )
            file_list.append(file_dict)
        return file_list

    @classmethod
    def get_file_url(cls, file_id, file_obj=None):
        """
        获取文件下载链接
        """
        file_url = ''
        if not file_obj:
            file_obj = cls.DETAIL_CLIENT.objects.filter(id=file_id).first()
        if file_obj:
            file_url = 'http://127.0.0.1:8000/' + cls.FILE_SAVE_DIR + file_obj.path + file_obj.file_name
        return file_url