relational-database - 解析相关对象的惯用且高效的方法是什么？

Question

如何在 GraphQL 中编写针对关系数据库表现良好的查询解析器？

使用 this tutorial 中的示例架构，假设我有一个包含users 和stories 的简单数据库。用户可以创作多个故事，但故事只有一个用户作为作者(为了简单起见)。

在查询用户时，人们可能还想获取该用户创作的所有故事的列表。一种可能的定义是 GraphQL 查询来处理该问题(从上面链接的教程中窃取):

const Query = new GraphQLObjectType({
  name: 'Query',
  fields: () => ({
    user: {
      type: User,
      args: {
        id: {
          type: new GraphQLNonNull(GraphQLID)
        }
      },
      resolve(parent, {id}, {db}) {
        return db.get(`
          SELECT * FROM User WHERE id = $id
          `, {$id: id});
      }
    },
  })
});

const User = new GraphQLObjectType({
  name: 'User',
  fields: () => ({
    id: {
      type: GraphQLID
    },
    name: {
      type: GraphQLString
    },
    stories: {
      type: new GraphQLList(Story),
      resolve(parent, args, {db}) {
        return db.all(`
          SELECT * FROM Story WHERE author = $user
        `, {$user: parent.id});
      }
    }
  })
});

这将按预期工作；如果我查询特定用户，如果需要，我也能够获取该用户的故事。然而，这并不理想。它需要两次访问数据库，而使用 JOIN 的单个查询就足够了。如果我查询多个用户，问题就会放大——每个额外的用户都会导致额外的数据库查询。我越深入地遍历我的对象关系，问题就会呈指数级恶化。

这个问题解决了吗？有没有一种方法可以编写不会导致生成低效 SQL 查询的查询解析器？

Answer 1

解决此类问题有两种方法。

Facebook 使用的一种方法是将一次性发生的请求排入队列，并在发送前将它们组合在一起。通过这种方式，您可以执行一个请求来检索有关多个用户的信息，而不是为每个用户执行一个请求。 Dan Schafer 写了一个good comment explaining this approach 。 Facebook发布Dataloader ，这是该技术的一个示例实现。

// Pass this to graphql-js context
const storyLoader = new DataLoader((authorIds) => {
  return db.all(
    `SELECT * FROM Story WHERE author IN (${authorIds.join(',')})`
  ).then((rows) => {
    // Order rows so they match orde of authorIds
    const result = {};
    for (const row of rows) {
      const existing = result[row.author] || [];
      existing.push(row);
      result[row.author] = existing;
    }
    const array = [];
    for (const author of authorIds) {
      array.push(result[author] || []);
    }
    return array;
  });
});

// Then use dataloader in your type
const User = new GraphQLObjectType({
  name: 'User',
  fields: () => ({
    id: {
      type: GraphQLID
    },
    name: {
      type: GraphQLString
    },
    stories: {
      type: new GraphQLList(Story),
      resolve(parent, args, {rootValue: {storyLoader}}) {
        return storyLoader.load(parent.id);
      }
    }
  })
});

虽然这不能解决高效的 SQL，但它对于许多用例来说仍然足够好，并且会让东西运行得更快。对于不允许 JOIN 的非关系数据库来说，这也是一个好方法。

另一种方法是在解析函数中使用有关请求字段的信息，以便在相关时使用 JOIN。解析上下文有 fieldASTs 字段，它解析了当前解析的查询部分的 AST。通过查看该 AST(选择集)的子项，我们可以预测是否需要连接。一个非常简单且笨重的示例:

const User = new GraphQLObjectType({
  name: 'User',
  fields: () => ({
    id: {
      type: GraphQLID
    },
    name: {
      type: GraphQLString
    },
    stories: {
      type: new GraphQLList(Story),
      resolve(parent, args, {rootValue: {storyLoader}}) {
        // if stories were pre-fetched use that
        if (parent.stories) {
          return parent.stories;
        } else {
          // otherwise request them normally
          return db.all(`
            SELECT * FROM Story WHERE author = $user
         `, {$user: parent.id});
        }
      }
    }
  })
});

const Query = new GraphQLObjectType({
  name: 'Query',
  fields: () => ({
    user: {
      type: User,
      args: {
        id: {
          type: new GraphQLNonNull(GraphQLID)
        }
      },
      resolve(parent, {id}, {rootValue: {db}, fieldASTs}) {
        // find names of all child fields
        const childFields = fieldASTs[0].selectionSet.selections.map(
          (set) => set.name.value
        );
        if (childFields.includes('stories')) {
          // use join to optimize
          return db.all(`
            SELECT * FROM User INNER JOIN Story ON User.id = Story.author WHERE User.id = $id
          `, {$id: id}).then((rows) => {
            if (rows.length > 0) {
              return {
                id: rows[0].author,
                name: rows[0].name,
                stories: rows
              };
            } else {
              return db.get(`
                SELECT * FROM User WHERE id = $id
                `, {$id: id}
              );
            }
          });
        } else {
          return db.get(`
            SELECT * FROM User WHERE id = $id
            `, {$id: id}
          );
        }
      }
    },
  })
});

请注意，这可能会出现问题，例如片段。然而，人们也可以处理它们，这只是更详细地检查选择集的问题。

目前有一个 PR在 graphql-js 存储库中，通过在上下文中提供“解决计划”，它将允许编写更复杂的逻辑来进行查询优化。