Skip to main content

Implementing GraphQL with joins

Project description

In some use cases, I’ve found it more natural to generate the requested GraphQL data using SQL joins rather than resolving values individually. This is a proof of concept that provides an alternative way of responding to GraphQL queries.

In the reference GraphQL implementation, resolve functions describe how to fulfil some part of the requested data for each instance of an object. If implemented naively with a SQL backend, this results in the N+1 problem. For instance, given the query:

{
    books(genre: "comedy") {
        title
        author {
            name
        }
    }
}

A naive GraphQL implement would issue one SQL query to get the list of all books in the comedy genre, and then N queries to get the author of each book (where N is the number of books returned by the first query).

There are various solutions proposed to this problem: GraphJoiner suggests that using joins is a natural fit for many use cases. For this specific case, we only need to run two queries: one to find the list of all books in the comedy genre, and one to get the authors of books in the comedy genre.

Example

Let’s say we have some models defined by SQLAlchemy. A book has an ID, a title, a genre and an author ID. An author has an ID and a name.

from sqlalchemy import Column, Integer, Unicode, ForeignKey
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class Author(Base):
    __tablename__ = "author"

    id = Column(Integer, primary_key=True)
    name = Column(Unicode, nullable=False)

class Book(Base):
    __tablename__ = "book"

    id = Column(Integer, primary_key=True)
    title = Column(Unicode, nullable=False)
    genre = Column(Unicode, nullable=False)
    author_id = Column(Integer, ForeignKey(Author.id))

We then define object types for the root, books and authors:

from graphql import GraphQLInt, GraphQLString, GraphQLArgument
from graphjoiner import JoinType, RootJoinType, single, many, field
from sqlalchemy.orm import Query

def create_root():
    def fields():
        return {
            "books": many(
                book_join_type,
                books_query,
                args={"genre": GraphQLArgument(type=GraphQLString)}
            )
        }

    def books_query(request, _):
        query = Query([]).select_from(Book)

        if "genre" in request.args:
            query = query.filter(Book.genre == request.args["genre"])

        return query

    return RootJoinType(name="Root", fields=fields)

root = create_root()

def fetch_immediates_from_database(request, query):
    query = query.with_entities(*(
        selection.field.column_name
        for selection in request.selections
    ))
    keys = tuple(selection.key for selection in request.selections)

    return [
        dict(zip(keys, row))
        for row in query.with_session(request.context.session).all()
    ]

def create_book_join_type():
    def fields():
        return {
            "id": field(column_name="id", type=GraphQLInt),
            "title": field(column_name="title", type=GraphQLString),
            "genre": field(column_name="genre", type=GraphQLString),
            "authorId": field(column_name="author_id", type=GraphQLInt),
            "author": single(author_join_type, author_query, join={"authorId": "id"}),
        }

    def author_query(request, book_query):
        books = book_query.with_entities(Book.author_id).distinct().subquery()
        return Query([]) \
            .select_from(Author) \
            .join(books, books.c.author_id == Author.id)

    return JoinType(
        name="Book",
        fields=fields,
        fetch_immediates=fetch_immediates_from_database,
    )

book_join_type = create_book_join_type()

def create_author_join_type():
    def fields():
        return {
            "id": field(column_name="id", type=GraphQLInt),
            "name": field(column_name="name", type=GraphQLString),
        }

    return JoinType(
        name="Author",
        fields=fields,
        fetch_immediates=fetch_immediates_from_database,
    )
author_join_type = create_author_join_type()

We can execute the query by calling execute:

from graphjoiner import execute

query = """
    {
        books(genre: "comedy") {
            title
            author {
                name
            }
        }
    }
"""

class Context(object):
    def __init__(self, session):
        self.session = session

execute(root, query, context=Context(session))

Which produces:

{
    "books": [
        {
            "title": "Leave It to Psmith",
            "author": {
                "name": "PG Wodehouse"
            }
        },
        {
            "title": "Right Ho, Jeeves",
            "author": {
                "name": "PG Wodehouse"
            }
        },
        {
            "title": "Catch-22",
            "author": {
                "name": "Joseph Heller"
            }
        },
    ]
}

Let’s break things down a little, starting with the definition of the root object:

def create_root():
    def fields():
        return {
            "books": many(
                book_join_type,
                books_query,
                args={"genre": GraphQLArgument(type=GraphQLString)}
            )
        }

    def books_query(request, _):
        query = Query([]).select_from(Book)

        if "genre" in request.args:
            query = query.filter(Book.genre == request.args["genre"])

        return query

    return RootJoinType(name="Root", fields=fields)

root = create_root()

For each object type, we need to define its fields. The root has only one field, books, a one-to-many relationship, which we define using many(). The first argument, book_join_type, is the type we’re defining a relationship to. The second argument to describes how to create a query representing all of those related books: in this case all books, potentially filtered by a genre argument.

This means we need to define book_join_type:

def create_book_join_type():
    def fields():
        return {
            "id": field(column_name="id", type=GraphQLInt),
            "title": field(column_name="title", type=GraphQLString),
            "genre": field(column_name="genre", type=GraphQLString),
            "authorId": field(column_name="author_id", type=GraphQLInt),
            "author": single(author_join_type, author_query, join={"authorId": "id"}),
        }

    def author_query(request, book_query):
        books = book_query.with_entities(Book.author_id).distinct().subquery()
        return Query([]) \
            .select_from(Author) \
            .join(books, books.c.author_id == Author.id)

    return JoinType(
        name="Book",
        fields=fields,
        fetch_immediates=fetch_immediates_from_database,
    )

book_join_type = create_book_join_type()

The author field is defined as a one-to-one mapping from book to author. As before, we define a function that generates a query for the requested authors. We also provide a join argument to single() so that GraphJoiner knows how to join together the results of the author query and the book query: in this case, the authorId field on books corresponds to the id field on authors. (If we leave out the join argument, then GraphJoiner will perform a cross join i.e. a cartesian product. Since there’s always exactly one root instance, this is fine for relationships defined on the root.)

The remaining fields define a mapping from the GraphQL field to the database column. This mapping is handled by fetch_immediates_from_database. The value of request.selections in fetch_immediates() is the selections of fields that aren’t defined as relationships (using single or many) that were either explicitly requested in the original GraphQL query, or are required as part of the join.

def fetch_immediates_from_database(fields, request, query):
    query = query.with_entities(*(
        fields[selection.field_name].column_name
        for selection in request.selections
    ))
    keys = tuple(selection.key for selection in request.selections)

    return [
        dict(zip(keys, row))
        for row in query.with_session(request.context.session).all()
    ]

For completeness, we can tweak the definition of author_join_type so we can request the books by an author:

def create_author_join_type():
    def fields():
        return {
            "id": field(column_name="id", type=GraphQLInt),
            "name": field(column_name="name", type=GraphQLString),
            "author": many(book_join_type, book_query, join={"id": "authorId"}),
        }

    def book_query(request, author_query):
        authors = author_query.with_entities(Author.id).distinct().subquery()
        return Query([]) \
            .select_from(Book) \
            .join(authors, authors.c.id == Book.author_id)

    return JoinType(
        name="Author",
        fields=fields,
        fetch_immediates=fetch_immediates_from_database,
    )

author_join_type = create_author_join_type()

Installation

pip install graphjoiner

Project details


Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Filename, size & hash SHA256 hash help File type Python version Upload date
graphjoiner-0.2.0-py2.py3-none-any.whl (10.9 kB) Copy SHA256 hash SHA256 Wheel 2.7
graphjoiner-0.2.0.tar.gz (7.4 kB) Copy SHA256 hash SHA256 Source None

Supported by

Elastic Elastic Search Pingdom Pingdom Monitoring Google Google BigQuery Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN SignalFx SignalFx Supporter DigiCert DigiCert EV certificate StatusPage StatusPage Status page