Produits Entr'ouvert » Combo

from .query import TreeManager

class PageManager(TreeManager):

        if not self.parent_id:

            return [self]

        return list(Page.objects.ancestors(self, include_self=False)) + [self]

        return Page.objects.descendants(self, include_self=include_myself)

# Copyright (c) 2018, Feinheit AG and individual contributors.

# All rights reserved.

#

# Redistribution and use in source and binary forms, with or without modification,

# are permitted provided that the following conditions are met:

#

#     1. Redistributions of source code must retain the above copyright notice,

#        this list of conditions and the following disclaimer.

#

#     2. Redistributions in binary form must reproduce the above copyright

#        notice, this list of conditions and the following disclaimer in the

#        documentation and/or other materials provided with the distribution.

#

#     3. Neither the name of Feinheit AG nor the names of its contributors

#        may be used to endorse or promote products derived from this software

#        without specific prior written permission.

#

# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND

# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR

# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON

# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS

# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

from django.db import connections, models

from django.db.models.sql.compiler import SQLCompiler

from django.db.models.sql.query import Query

from django.db.models.sql.where import AND, ExtraWhere

class TreeQuery(Query):

    def get_compiler(self, using=None, connection=None, elide_empty=True):

        # Copied from django/db/models/sql/query.py

        if using is None and connection is None:

            raise ValueError('Need either using or connection')

        if connection is None:

            connection = connections[using]

        return TreeCompiler(self, connection, using)

class TreeExtraWhere(ExtraWhere):

    def relabeled_clone(self, change_map):

        new_sqls = []

        for sql in self.sqls:

            for old_table_name, new_table_name in change_map.items():

                sql = sql.replace(old_table_name, new_table_name)

            new_sqls.append(sql)

        self.sqls = new_sqls

        return self

class TreeCompiler(SQLCompiler):

    CTE = '''

    WITH RECURSIVE __tree (

        "tree_depth",

        "tree_path",

        "tree_ordering",

        "tree_pk"

    ) AS (

        SELECT

            0 AS tree_depth,

            array[T.id] AS tree_path,

            array["order"] AS tree_ordering,

            T.id

        FROM data_page T

        WHERE T.parent_id IS NULL

        UNION ALL

        SELECT

            __tree.tree_depth + 1 AS tree_depth,

            __tree.tree_path || T.id,

            __tree.tree_ordering || "order",

            T.id

        FROM data_page T

        JOIN __tree ON T.parent_id = __tree.tree_pk

    )

    '''

    def as_sql(self, *args, **kwargs):

        if '__tree' not in self.query.extra_tables:

            self.query.add_extra(

                select={

                    'tree_depth': '__tree.tree_depth',

                    'tree_path': '__tree.tree_path',

                    'tree_ordering': '__tree.tree_ordering',

                },

                select_params=None,

                where=None,

                params=None,

                tables=['__tree'],

                order_by=['tree_ordering'],

            )

            table_name = self.query.table_alias('data_page')[0]

            self.query.where.add(TreeExtraWhere(['__tree.tree_pk = %s.id' % table_name], None), AND)

        sql = super().as_sql(*args, **kwargs)

        return (''.join([self.CTE, sql[0]]), sql[1])

class TreeQuerySet(models.QuerySet):

    def with_tree_fields(self):

        self.query.__class__ = TreeQuery

        return self

    def ancestors(self, page, include_self=True):

        if not hasattr(page, 'tree_path'):

            pk = page.pk if not page.snapshot else page.snapshot.page_id

            page = self.with_tree_fields().get(pk=pk)

        ids = page.tree_path if include_self else page.tree_path[:-1]

        return self.with_tree_fields().filter(id__in=ids).order_by('tree_depth')

    def descendants(self, page, include_self=True):

        queryset = self.with_tree_fields().extra(where=['%s = ANY(tree_path)' % page.pk])

        if not include_self:

            return queryset.exclude(pk=page.pk)

        return queryset

TreeManager = models.Manager.from_queryset(TreeQuerySet)

            Page.objects.filter(pk__in=subpages.values('pk')).update(

                exclude_from_navigation=bool(not self.cleaned_data['include_in_navigation'])

            )

    assert len(ctx.captured_queries) == 34

        assert len(ctx.captured_queries) in [308, 309]

    page2.save()

        assert queries_count_third == queries_count_second + 2