Zum Inhalt springen

GraphQL und MySQL: Das Join-Problem lösen

Eine einfache Illustration einer Datenbank mit einem Reißverschluss und einem Schloss, die eine sichere oder verschlüsselte Datenspeicherung symbolisieren.

GraphQL setzt sich immer mehr durch. Entsprechend müssen Entwicklungsteams GraphQL APIs für immer grössere Unternehmen und Datenmengen bauen. Je grösser das Projekt, desto sorgfältiger muss die Datenbank gewählt werden. Dokumentdatenbanken wie MongoDB sind die natürlichen Partner von GraphQL, für relationale Daten sind aber SQL-Datenbanken der Standard.

Gute Nachrichten! Es ist zwar kniffliger, aber GraphQL und relationale Datenbanken lassen sich mit sehr zufriedenstellenden Ergebnissen kombinieren. Leider gibt es kaum Dokumentation dazu, wie das geht. Genau das wollen wir hier ändern.

Dieser Artikel setzt voraus, dass du mit GraphQL, Apollo Server, MongoDB und MySQL vertraut bist. Er ist Teil einer Serie von smartive über GraphQL auf Enterprise-Niveau.

Beispiel-Datenstruktur: Ein Blog

Alle Beispiele bauen auf einer einfachen Datenstruktur auf: User können Posts erstellen, Posts können Kommentare haben.

Diagramm, das die Beziehungen zeigt: „Benutzer“ stellt eine Verbindung zu „Beitrag“ und „Kommentar“ her, wobei „Kommentar“ auch zurück zu „Beitrag“ führt.

So sieht das in einem GraphQL-Schema aus. Achte auf die To-One- und To-Many-Beziehungen, die wir unterschiedlich auflösen müssen.

type Post {
    id: ID
    title: String
    content: String
    user: User! # to-one
    comments: [Comment] # to-many
  }
  type Comment {
    id: ID
    content: String
    post: Post! # to-one
    user: User! # to-one
  }
  type User {
    id: ID
    name: String
  }

  query {
    post(id: ID): Post
  }

Einfache Queries

Starten wir mit dem Resolver, der eine einfache Query ohne Joins beantwortet:

query {
    post(id: "xyz") {
      id
      title
      content
    }
  }

Für die MySQL-Queries verwenden wir die Node-Library knex:

import Knex from "knex";

const client = Knex({ client: "mysql", connection: { host: "127.0.0.1" } });
const resolvers = {
  Query: {
    post: (_, { id }) => client.from("Posts").where({ id }).first()
  }
};

Verknüpfte Queries

So weit, so gut. Bisher machen wir nichts anderes, als wir es auch mit einer NoSQL-Datenbank wie MongoDB tun würden. Aber was, wenn wir verknüpfte Daten abfragen wollen?

query {
    post(id: "xyz") {
      title
      content
      user {
        name
      }
      comments {
        content
        user {
          name
        }
      }
    }
  }

Schauen wir uns ein paar Ansätze und ihre Vor- und Nachteile an.

Strukturierte Daten

Mit MongoDB könnten wir das ganze Dokument (den Post, seine Autorin, seine Kommentare usw.) als einen einzigen Eintrag speichern. Damit wären wir fertig: keine weiteren Resolver nötig.

post: (_, { id }) => client.collection("posts").findOne(id)

Dieser Ansatz hat aber ein paar Nachteile:

  1. Er funktioniert nicht für beliebige Zugriffsmuster. Was, wenn ich die Posts aller Kommentierenden will? Plötzlich brauchen wir doch mehr Resolver.
  2. Die Daten werden redundant bzw. denormalisiert gespeichert, was Updates kompliziert macht.

Und schliesslich funktioniert dieser Ansatz nicht mit relationalen Datenbanken. Wir brauchen also etwas anderes.

Der naive Ansatz

Der naheliegendste Weg, verknüpfte Queries aufzulösen: jeden Eintrag einzeln laden und Apollo alles zusammenfügen lassen:

Post: {
      user: ({ userId }) => client.from("Users").where({ id: userId }).first(),
      comments: ({ id }) => client.from("Comments").where({ postId: id })
    },
    Comment: {
      user: ({ userId }) => client.from("Users").where({ id: userId }).first()
    }

Genau so wollen Apollo-Resolver eigentlich verwendet werden. Aber auch dieser Ansatz hat Nachteile:

  1. Er führt zu «N+1» Queries an die Datenbank (immer noch besser, als «N+1» Queries vom Client an den Server zu schicken)
  2. Daten in der Node-Runtime zu joinen ist langsamer als in der Datenbank

Schauen wir uns die MySQL-Queries an, die diese Resolver für die obige Query erzeugen:

SELECT * FROM Posts WHERE id = "xyz";
SELECT * FROM Users WHERE id = <post.userId>;
SELECT * FROM Comments WHERE postId = "xyz";
/* For every comment */
SELECT * FROM Users WHERE id = <comment.userId>;

Anzahl Queries = 3 + Anzahl Kommentare. Wir wissen, dass das besser geht:

SELECT
  Posts.title AS title,
  Posts.content AS content,
  user.name AS user__name
FROM Posts
LEFT JOIN Users AS user ON Posts.userId = user.id
WHERE Posts.id === "xyz";

SELECT
  Comments.content as content,
  user.name AS user__name,
FROM Comments
LEFT JOIN Users AS user ON Comments.userId = user.id
WHERE Comments.postId === "xyz";

Anzahl Queries = 2. Die Frage ist: Wie bauen wir Resolver, die solche optimierten Queries erzeugen?

Der Ansatz für «Apollo-Profis»

Wenn klassische Apollo-Resolver die Stützräder sind, dann schrauben wir sie jetzt definitiv ab. Wir nehmen das Auflösen von Queries komplett selbst in die Hand. Dafür brauchen wir einen Almighty Root Resolver (ARR), also einen Resolver, der die ganze Query (rekursiv) auflöst, ohne etwas an untergeordnete Resolver abzugeben.

Um einen ARR zu bauen (und ein paar andere raffinierte Dinge zu tun), musst du einige zentrale Interna von Apollo verstehen, nämlich wie es das GraphQL-Schema und die Queries darstellt (Tipp: als AST-Objekte). Lies am besten zuerst unseren Artikel Lerne den AST lieben!, bevor du weitermachst.

To-One-Queries lösen

Schauen wir uns die Beziehung post→ user an. Das ist eine To-One-Beziehung: Zu jedem Post gibt es genau einen User. Mit Blick auf die MySQL-Resultate sind To-One-Beziehungen praktisch, weil sich das Resultat immer in einer einzigen Zeile darstellen lässt. Das heisst, wir können beliebig viele To-One-Beziehungen mit einer einzigen Query (mit Left Joins) lösen. Hier ist ein post-Resolver, der so eine Query baut:

post: async (_, { id }, _ctx, info: GraphQLResolveInfo) => {
        const query = info.fieldNodes.find(field => field.name.value === info.fieldName);

        const sql = client.from("Posts").where({ id }).first();

        for (const field of query.selectionSet.selections.filter(isFieldNode)
          .filter(f => f.name.value !== "post")
        ) {
          sql.select(field.name.value);
        }

        for (const field of query.selectionSet.selections.filter(isFieldNode)
          .filter(f => f.name.value === "post")
        ) {
          sql.leftJoin(`Users as user`, `Posts.userId`, `user.id`);
          for (const userField of field.selectionSet.selections.filter(isFieldNode)) {
            sql.select(
              `user.${userField.name.value} as user__${userField.name.value}`
            );
          }
        }

        return unflatten(await sql);
      }

Was passiert in diesem Code-Snippet? Zuerst fragen wir einen post und seine einfachen Felder ab, dann joinen wir die Tabelle User per Left Join, um die relevanten User-Informationen zu bekommen. unflatten ist eine Funktion, die die flache MySQL-Resultatzeile in ein sauber strukturiertes Dokument umwandelt. Die Implementierung überlassen wir dir als Übung.

Natürlich löst diese Query nur eine einzige, hartcodierte Beziehung. Aber wir kommen der Sache langsam näher.

Übrigens: Falls du dich fragst, was dieses info-Objekt ist und was du damit anstellen kannst (Spoiler: eine Menge), lies nochmals Lerne den AST lieben!. Dort schauen wir es uns im Detail an.

To-Many-Queries lösen

Für To-Many-Beziehungen wie post→ comments brauchen wir eine separate Query für die verknüpfte Entität. So machen wir das:

post: async (_, { id }, _ctx, info: GraphQLResolveInfo) => {
        const query = info.fieldNodes.find(field => field.name.value === info.fieldName);

        const post = await client.from("Posts").where({ id }).first();

        for (const field of query.selectionSet.selections.filter(isFieldNode)
          .filter(f => f.name.value === "comments")
        ) {
          post.comments = await client.from("Comments").where({ postId: id });
        }

        return post;
      }

Der Resolver lädt zuerst den Post, dann mit einer separaten MySQL-Query die Kommentare und hängt sie anschliessend an den Post an.

Der generische Fall mit Directives

Schauen wir uns jetzt an, wie wir einen ARR aufbauen, der alle nötigen Joins (für To-One- und To-Many-Beziehungen) generisch ausführt. Zuerst müssen wir das Schema mit speziellen Directives annotieren:

type Post {
    id: ID
    title: String
    content: String
    user: User @toOne
    comments: [Comment] @toMany(key: "userId")
  }
  type Comment {
    id: ID
    content: String
    post: Post @toOne
    user: User @toOne
  }

Im Resolver können wir dann den Schema-AST untersuchen und entscheiden, wann und wie gejoint wird:

post: async (_, { id }, _ctx, info: GraphQLResolveInfo) => {
        const query = info.fieldNodes.find(field => field.name.value === info.fieldName);
        const type = info.schema.getType('Post').astNode as ObjectTypeDefinitionNode;

        const sql = client.from("Posts").where({ id }).first();

        for (const field of query.selectionSet.selections.filter(isFieldNode)
          .filter(field => !getDirective(type, field, 'toOne') && !getDirective(type, field, 'toMany'))
        ) {
          sql.select(field.name.value);
        }

        for (const field of query.selectionSet.selections.filter(isFieldNode)
          .filter(field => getDirective(type, field, 'toOne'))
        ) {
          // left join...
        }

        const post = unflatten(await sql);

        for (const field of query.selectionSet.selections.filter(isFieldNode)
          .filter(field => getDirective(type, field, 'toMany'))
        ) {
          // sub query...
        }

        return post;
      }

Um den ARR fertigzustellen, müssen wir diese Funktion so erweitern, dass sie Sub-Joins rekursiv berechnet. Dafür untersuchen wir den Query-AST weiter und leiten nach demselben Grundprinzip die Queries ab, die ausgeführt werden müssen. Hier hören wir aber auf, denn das würde den Rahmen dieses Artikels sprengen.

Erst der Anfang

GraphQL-Queries in effiziente MySQL-Queries zu übersetzen ist nicht einfach, lohnt sich aber. Sobald wir das für unseren grössten Kunden geschafft hatten, konnten wir unserem GraphQL-Schema generisch immer mehr mächtige Features hinzufügen, und die Schnittstelle zu MySQL blieb dabei immer optimiert. Beispiele:

  • Filter und Sortierung (z. B. posts(where: { title: "xyz" }, orderBy: [{created: ASC}], first: 10, skip: 0) { ... })
  • Aggregationen (z. B. posts { commentsAggregations { COUNT AVG { rating } } })
  • Aggregationsfilter (z. B. posts(where: { comments: {GTE: { COUNT: 6 } } }) { ... })
  • Sortierung nach Aggregationen (z. B. posts(orderBy: [{ comments: { COUNT: DESC }]) { ... })
  • Distinct-Aggregationen (z. B. posts { commentsAggregations { distinctUsers { COUNT user { username } } } })
  • Polymorphismus und Joins auf Untertabellen mit nicht gemeinsamen Feldern (z. B. users { name ...on Student { school } })
  • Umgang mit externen Feldern (also solchen, die nicht aus der Datenbank kommen), externen Filtern, Schreib- und Zugriffsrechten, Sanitization-Regeln … alles mit Schema Directives
  • Schema-Generierung auf Basis einer strengeren (TypeScript-)Darstellung des Modells

Alles in allem konnten wir dank unserer Entscheidung, den AST zu nutzen und eigene ARRs zu bauen, eine sehr mächtige modellgetriebene API entwickeln. Wir sind selbst immer wieder überrascht, welche Use Cases sie bereits abdeckt.

GraphQL-Applikationen auf Enterprise-Niveau bauen

Du willst GraphQL-Profi werden? Folge uns und lies unsere ganze Serie über GraphQL-Applikationen auf Enterprise-Niveau.

Teil 1: Enterprise-taugliche APIs mit GraphQL, MySQL und Node.js bauen

Teil 2: GraphQL-Patterns für Fortgeschrittene: Der allmächtige Root Resolver

Teil 3: GraphQL-Patterns für Fortgeschrittene: Lerne den AST lieben!

Teil 4: GraphQL und MySQL: Das Join-Problem lösen

Teil 5: GraphQL und Elasticsearch: Ein Liebesbrief 💌

Teil 6: Die beliebtesten GraphQL-Server und -Clients für Node.js

Du brauchst ein Expert*innen-Team für deine anspruchsvolle Webapplikation? Schau dir unser Portfolio an.

Ein Mann mit Brille, Bart und kurzen Haaren in einem marineblauen Button-Down-Hemd und khakifarbenen Hosen steht lächelnd vor einem blauen Hintergrund.

Geschrieben von
Nicola Marcacci Rossi

Technology|Dezember 2019

Ähnliche Challenge auf dem Tisch? Lass uns drüber reden.

Weitere Artikel

© 2026 smartive AG