树型文件系统设计

1
2
3
4
5
class Node(models.Model):
    name = models.TextField(null=True, blank=True)
    update_time = models.DateTimeField(null=False, blank=False, default=datetime.utcnow)
    create_time = models.DateTimeField(null=False, blank=False, default=datetime.utcnow)
    parent = models.ForeignKey("self", on_delete=models.CASCADE, null=True, related_name="sons")

1
2
3
def get_sons(self, root):
    return {'name': root.name, 'update_time': root.update_time.timestamp(),
            'sons': [self.get_sons(x) for x in Node.objects.filter(parent=root)]}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class TreeTest(TestCase):
    def setUp(self) -> None:
        super(TreeTest, self).setUp()
        self.root_node = Node.objects.create(name='root')
        for i in range(3):
            parent = self.root_node
            for j in range(3):
                parent = Node.objects.create(name='sons_{}_{}'.format(i, j), parent=parent)

    @override_settings(DEBUG=True)
    def test_scan(self):
        self.get_sons(self.root_node)
        for item in connection.queries:
            print(item)

1
2
3
4
5
6
7
8
9
10
11
12
13
def get_sons(self, root):
    index, node_list = 0, [root]
    while index < len(node_list):
        temp_len = len(node_list)
        for node in Node.objects.filter(parent_id__in=[x.id for x in node_list[index:]]):
            node_list.append(node)
        index = temp_len
    node_dict = {x.id: {'name': x.name, 'parent_id': x.parent_id, 'sons': []}
                 for x in node_list}
    for node in node_dict.values():
        if node['parent_id']:
            node_dict[node['parent_id']]['sons'].append(node)
    return node_dict[root.id]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Node(models.Model):
    name = models.TextField(null=True, blank=True)
    update_time = models.DateTimeField(null=False, blank=False, default=datetime.utcnow)
    create_time = models.DateTimeField(null=False, blank=False, default=datetime.utcnow)

    objects = NodeManager()


class NodeRelation(models.Model):
    ancestor = models.ForeignKey(Node, on_delete=models.CASCADE, related_name='ancestor')
    descendant = models.ForeignKey(Node, on_delete=models.CASCADE, related_name='descendant')
    level = models.IntegerField(null=False, blank=False, db_index=True, default=0)

    class Meta:
        constraints = [
            models.UniqueConstraint(fields=['ancestor', 'descendant'], name='unique_relation')
        ]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class NodeManager(models.Manager):

    def create_with_relation(self, parent_id=None, **kwargs):
        node = self.create(**kwargs)
        relations = [] if parent_id is None else [NodeRelation(
            ancestor_id=x.ancestor_id, descendant=node, level=x.level + 1
        ) for x in NodeRelation.objects.filter(descendant=parent_id)]
        relations.append(NodeRelation(ancestor=node, descendant=node, level=0))
        NodeRelation.objects.bulk_create(relations)
        return node

    def delete_with_relation(self, node_id):
        node_ids = [x['descendant_id'] for x in NodeRelation.objects.filter(
            ancestor_id=node_id).values('descendant_id')]
        self.filter(id__in=node_ids).delete()

1
2
3
4
5
6
7
8
9
class NodeManager(models.Manager):

    def get_tree(self, node_id):
        node_dict = defaultdict(lambda: {'name': '', 'sons': []})
        for node in Node.objects.filter(descendant__ancestor_id=node_id):
            node_dict[node.id]['name'] = node.name
        for relation in NodeRelation.objects.filter(level=1, descendant_id__in=node_dict.keys()):
            node_dict[relation.ancestor_id]['sons'].append(node_dict[relation.descendant_id])
        return node_dict[node_id]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class NodeManager(models.Manager):

    def move_with_relation(self, node_id, parent_id):
        ancestor_query = ~models.Q(ancestor_id=node_id) & models.Q(ancestor_id__in=Subquery(
            NodeRelation.objects.filter(descendant_id=node_id).values('ancestor_id')))
        descendant_query = models.Q(descendant_id__in=Subquery(
            NodeRelation.objects.filter(ancestor_id=node_id).values('descendant_id')))
        NodeRelation.objects.filter(ancestor_query & descendant_query).delete()

        ancestor_list = list(NodeRelation.objects.filter(descendant_id=parent_id))
        descendant_list = list(NodeRelation.objects.filter(ancestor_id=node_id))
        new_relations = [NodeRelation(
            ancestor_id=x.ancestor_id, descendant_id=y.descendant_id, level=x.level + y.level + 1
        ) for x in ancestor_list for y in descendant_list]
        NodeRelation.objects.bulk_create(new_relations)

1
2
3
4
5
6
7
class FileCallback(ABC, metaclass=CallbackMeta):
    file_type = None

    @classmethod
    @abstractmethod
    def create(cls, file: File, *args, **kwargs) -> Tuple[Dict, Any]:
        pass

1
2
3
4
5
6
7
8
9
10
11
12
13
class CallbackMeta(ABCMeta):
    def __new__(mcs, what, bases=None, attrs=None):
        new_class = super().__new__(mcs, what, bases, attrs)
        if what != "FileCallback":
            file_type = new_class.file_type
            for callback_type in ("create", "update", "delete", "dump", "load"):
                CallbackRepository.register(
                    file_type,
                    callback_type,
                    getattr(new_class, callback_type),
                    getattr(new_class, "batch_{}".format(callback_type)),
                )
        return new_class

1
2
3
@classmethod
def _call(cls, callback_type, file_type, *args, **kwargs):
    return getattr(CallbackRepository, callback_type)[file_type](*args, **kwargs)