Techniques for enhancing Django query performance

Hi folks!

I was curious as to how one would go about increasing query performance, when one is using DjangoObjectTypes directly connected to a model. One example of an optimization that I think would be easy is the following:

if 'arg x' is a field that is asked for:
    make sure that "something_set" is included in "select_related"

Any one willing to share ideas? Also, how would one go about creating a LRU cache?

[jameswyse]

I’ve extracted some code and simplified it a bit (our implementation is a bit more complex) but hopefully you find it useful. One day I’ll find the time to release this as a reusable package (or perhaps directly in to graphene-django)

helpers.py

from graphql.utils.ast_to_dict import ast_to_dict
from django.utils.six import iteritems


def collect_fields(node, fragments, variables):
    field = {}
    selection_set = node.get('selection_set') if node else None
    selections = selection_set.get('selections', None) if selection_set else None

    if selections is not None:
        for leaf in selections:
            leaf_kind = leaf.get('kind')
            leaf_name = leaf.get('name', {}).get('value')
            leaf_directives = leaf.get('directives')

            # Check if leaf should be skipped
            # - If name is '__typename'
            # - if @skip directive is used and evaluates to True
            # - if @include directive is used and evaluates to False (not yet implemented!)
            should_skip = False
            for directive in leaf_directives:
                if directive.get('name', {}).get('value') == 'skip':
                    for arg in directive.get('arguments', []):
                        arg_value = arg.get('value', {})
                        if arg.get('name', {}).get('value') == 'if':
                            if arg_value.get('kind') == 'Variable':
                                var_name = arg_value.get('name', {}).get('value')
                                should_skip = variables.get(var_name, should_skip)
                            elif arg_value.get('kind') == 'BooleanValue':
                                should_skip = arg_value.get('value')

            if leaf_name != '__typename' and not should_skip:
                if leaf_kind == 'Field':
                    field.update({leaf_name: collect_fields(leaf, fragments, variables)})
                elif leaf_kind == 'FragmentSpread':
                    field.update(collect_fields(fragments[leaf_name], fragments, variables))
    return field


def get_fields(info):
    """Return a nested dict of the fields requested by a graphene resolver"""
    fragments = {}
    node = ast_to_dict(info.field_asts[0])

    for name, value in iteritems(info.fragments):
        fragments[name] = ast_to_dict(value)

    fields = collect_fields(node, fragments, info.variable_values)

    return fields

Example usage

from django.db.models import Prefetch

def resolve_posts(self, args, context, info):
    qs = Post.objects.all()
    fields = get_fields(info)

    # posts { author }
    if fields.get('author', {}):
        qs = qs.select_related('author')

    # posts { comments }    
    if fields.get('comments', {}):
        all_comments = Comment.objects.all()

        # posts { comments { author } }
        if fields.get('comments', {}).get('author', {}):
            all_comments = all_comments.select_related('author')

        qs = qs.prefetch_related(Prefetch('comments', queryset=all_comments))

    return qs

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.