Performance issues with large data sets

For our use case, we send a few thousand objects to the client. We're currently using a normal JSON API, but are considering using GraphQL instead. However, when returning a few thousand objects, the overhead of resolving values makes it impractical to use. For instance, the example below returns 10000 objects with an ID field, and that takes around ten seconds to run.

Is there a recommended way to improve the performance? The approach I've used successfully so far is to use the existing parser to parse the query, and then generate the response by creating dictionaries directly, which avoids the overhead of resolving/completing on every single value.

``` python
import graphene

class UserQuery(graphene.ObjectType):
id = graphene.Int()

class Query(graphene.ObjectType):
users = graphene.Field(UserQuery.List())

def resolve_users(self, args, info):
return users

class User(object):
def __init__(self, id):
self.id = id

users = [User(index) for index in range(0, 10000)]

schema = graphene.Schema(query=Query)

print(schema.execute('{ users { id } }').data)
```

Run the issue's 10,000-object benchmark using the shown UserQuery, Query, resolve_users, and schema.execute entry points. Read the execution and value-resolution path involved in that query, then establish a measured improvement target and regression coverage; the issue does not specify a concrete acceptance threshold.

Do mô hình lập chỉ mục viết ra từ nội dung của issue.