validation.validate slowness

Small scratch script demonstrating validation.validate slowness.

You can run by installing graphql-core in a venv, then running scratch.py. Personally,
I then run it through gprof2dot for visualisation

Author: alexchamberlain

benchmark/data.json

@@ -0,0 +1,44 @@
+[
+  {
+    "cities": [
+      {
+        "name": "London"
+      },
+      {
+        "name": "Cambridge"
+      }
+    ],
+    "iso_code": "gb",
+    "name": "United Kingdom"
+  },
+  {
+    "cities": [
+      {
+        "name": "Paris"
+      }
+    ],
+    "iso_code": "fr",
+    "name": "France"
+  },
+  {
+    "cities": [
+      {
+        "name": "Berlin"
+      }
+    ],
+    "iso_code": "de",
+    "name": "Germany"
+  },
+  {
+    "cities": [
+      {
+        "name": "Madrid"
+      },
+      {
+        "name": "Barcelona"
+      }
+    ],
+    "iso_code": "es",
+    "name": "Spain"
+  }
+]

benchmark/schema.graphql

@@ -0,0 +1,17 @@
+type City {
+    name: String!
+}
+
+type Country {
+    name: String!
+    iso_code: String!
+    cities: [City!]!
+}
+
+type Query {
+    country(iso_code: String!): Country
+}
+
+schema {
+    query: Query
+}

benchmark/scratch.py

@@ -0,0 +1,74 @@
+#!/opt/bb/bin/python3.7
+import asyncio
+import json
+import os
+import cProfile
+
+from graphql import graphql_sync
+from graphql import build_schema as graphql_build_schema
+from graphql.type.schema import GraphQLSchema
+
+dir_path = os.path.dirname(os.path.realpath(__file__))
+
+
+with open(os.path.join(dir_path, "schema.graphql"), "r") as fo:
+    schema = fo.read()
+
+with open(os.path.join(dir_path, "data.json"), "r") as fo:
+    data = json.load(fo)
+
+iso_to_country = {c["iso_code"]: c for c in data}
+
+
+def build_schema(schema_definition: str) -> GraphQLSchema:
+    schema = graphql_build_schema(schema_definition)
+
+    schema.query_type.fields["country"].resolve = country_resolver
+
+    return schema
+
+
+def country_resolver(parent, resolve_info, *, iso_code):
+    return iso_to_country
+
+
+schema = build_schema(schema)
+
+
+loop = asyncio.get_event_loop()
+
+
+with cProfile.Profile() as pr:
+    graphql_sync(
+        schema,
+        """
+            {
+                gb: country(iso_code:"gb")
+                {
+                    name
+                    iso_code
+                    cities { name }
+                }
+                fr: country(iso_code:"fr")
+                {
+                    name
+                    iso_code
+                    cities { name }
+                }
+                de: country(iso_code:"de")
+                {
+                    name
+                    iso_code
+                    cities { name }
+                }
+                es: country(iso_code:"es")
+                {
+                    name
+                    iso_code
+                    cities { name }
+                }
+            }
+        """,
+    )
+
+pr.dump_stats("scratch.prof")

pyproject.toml

@@ -52,5 +52,5 @@ tox = "^3.19"
 target-version = ['py36', 'py37', 'py38']
 
 [build-system]
-requires = ["poetry>=1,<2"]
+requires = ["poetry>=1,<2", "setuptools"]
 build-backend = "poetry.masonry.api"

src/graphql/language/ast.py

@@ -221,15 +221,17 @@ class Node:
     """AST nodes"""
 
     # allow custom attributes and weak references (not used internally)
-    __slots__ = "__dict__", "__weakref__", "loc"
+    __slots__ = "__dict__", "__weakref__", "loc", "_hash"
 
     loc: Optional[Location]
 
     kind: str = "ast"  # the kind of the node as a snake_case string
     keys = ["loc"]  # the names of the attributes of this node
 
+
     def __init__(self, **kwargs: Any) -> None:
         """Initialize the node with the given keyword arguments."""
+        self._hash = None
         for key in self.keys:
             value = kwargs.get(key)
             if isinstance(value, list) and not isinstance(value, FrozenList):
@@ -250,7 +252,10 @@ def __eq__(self, other: Any) -> bool:
         )
 
     def __hash__(self) -> int:
-        return hash(tuple(getattr(self, key) for key in self.keys))
+        if self._hash is None:
+            self._hash = hash(tuple(getattr(self, key) for key in self.keys))
+
+        return self._hash
 
     def __copy__(self) -> "Node":
         """Create a shallow copy of the node."""

src/graphql/language/visitor.py

@@ -173,6 +173,9 @@ def leave(self, node, key, parent, path, ancestors):
     # Provide special return values as attributes
     BREAK, SKIP, REMOVE, IDLE = BREAK, SKIP, REMOVE, IDLE
 
+    def __init__(self):
+        self._visit_fns = {}
+
     def __init_subclass__(cls) -> None:
         """Verify that all defined handlers are valid."""
         super().__init_subclass__()
@@ -197,10 +200,18 @@ def __init_subclass__(cls) -> None:
 
     def get_visit_fn(self, kind: str, is_leaving: bool = False) -> Callable:
         """Get the visit function for the given node kind and direction."""
+
+        key = (kind, is_leaving)
+        if key in self._visit_fns:
+            return self._visit_fns[key]
+
         method = "leave" if is_leaving else "enter"
         visit_fn = getattr(self, f"{method}_{kind}", None)
         if not visit_fn:
             visit_fn = getattr(self, method, None)
+
+        self._visit_fns[key] = visit_fn
+
         return visit_fn
 
 
@@ -367,14 +378,22 @@ class ParallelVisitor(Visitor):
 
     def __init__(self, visitors: Collection[Visitor]):
         """Create a new visitor from the given list of parallel visitors."""
+        super().__init__()
         self.visitors = visitors
         self.skipping: List[Any] = [None] * len(visitors)
+        self._enter_visit_fns = {}
+        self._leave_visit_fns = {}
 
     def enter(self, node: Node, *args: Any) -> Optional[VisitorAction]:
+        visit_fns = self._enter_visit_fns.get(node.kind)
+        if visit_fns is None:
+            visit_fns = [v.get_visit_fn(node.kind) for v in self.visitors]
+            self._enter_visit_fns[node.kind] = visit_fns
+
         skipping = self.skipping
         for i, visitor in enumerate(self.visitors):
             if not skipping[i]:
-                fn = visitor.get_visit_fn(node.kind)
+                fn = visit_fns[i]
                 if fn:
                     result = fn(node, *args)
                     if result is SKIP or result is False:
@@ -386,10 +405,15 @@ def enter(self, node: Node, *args: Any) -> Optional[VisitorAction]:
         return None
 
     def leave(self, node: Node, *args: Any) -> Optional[VisitorAction]:
+        visit_fns = self._leave_visit_fns.get(node.kind)
+        if visit_fns is None:
+            visit_fns = [v.get_visit_fn(node.kind, is_leaving=True) for v in self.visitors]
+            self._leave_visit_fns[node.kind] = visit_fns
+
         skipping = self.skipping
         for i, visitor in enumerate(self.visitors):
             if not skipping[i]:
-                fn = visitor.get_visit_fn(node.kind, is_leaving=True)
+                fn = visit_fns[i]
                 if fn:
                     result = fn(node, *args)
                     if result is BREAK or result is True:

src/graphql/utilities/type_info.py

@@ -88,6 +88,7 @@ def __init__(
         self._argument: Optional[GraphQLArgument] = None
         self._enum_value: Optional[GraphQLEnumValue] = None
         self._get_field_def = get_field_def_fn or get_field_def
+        self._visit_fns = {}
         if initial_type:
             if is_input_type(initial_type):
                 self._input_type_stack.append(cast(GraphQLInputType, initial_type))
@@ -136,15 +137,25 @@ def get_enum_value(self) -> Optional[GraphQLEnumValue]:
         return self._enum_value
 
     def enter(self, node: Node) -> None:
-        method = getattr(self, "enter_" + node.kind, None)
+        method = self._get_method("enter", node.kind)
         if method:
             method(node)
 
     def leave(self, node: Node) -> None:
-        method = getattr(self, "leave_" + node.kind, None)
+        method = self._get_method("leave", node.kind)
         if method:
             method()
 
+    def _get_method(self, direction: str, kind: str) -> Optional[Callable[[], None]]:
+        key = (direction, kind)
+        if key in self._visit_fns:
+            return self._visit_fns[key]
+
+        fn = getattr(self, f"{direction}_{kind}", None)
+        self._visit_fns[key] = fn
+        return fn
+
+
     # noinspection PyUnusedLocal
     def enter_selection_set(self, node: SelectionSetNode) -> None:
         named_type = get_named_type(self.get_type())
@@ -301,6 +312,7 @@ class TypeInfoVisitor(Visitor):
     """A visitor which maintains a provided TypeInfo."""
 
     def __init__(self, type_info: "TypeInfo", visitor: Visitor):
+        super().__init__()
         self.type_info = type_info
         self.visitor = visitor
 

src/graphql/validation/rules/__init__.py

@@ -17,6 +17,7 @@ class ASTValidationRule(Visitor):
     context: ASTValidationContext
 
     def __init__(self, context: ASTValidationContext):
+        super().__init__()
         self.context = context
 
     def report_error(self, error: GraphQLError) -> None:

src/graphql/validation/rules/lone_schema_definition.py

@@ -17,23 +17,14 @@ def __init__(self, context: SDLValidationContext):
         super().__init__(context)
         old_schema = context.schema
         self.already_defined = old_schema and (
-            old_schema.ast_node
-            or old_schema.query_type
-            or old_schema.mutation_type
-            or old_schema.subscription_type
+            old_schema.ast_node or old_schema.query_type or old_schema.mutation_type or old_schema.subscription_type
         )
         self.schema_definitions_count = 0
 
     def enter_schema_definition(self, node: SchemaDefinitionNode, *_args: Any) -> None:
         if self.already_defined:
-            self.report_error(
-                GraphQLError(
-                    "Cannot define a new schema within a schema extension.", node
-                )
-            )
+            self.report_error(GraphQLError("Cannot define a new schema within a schema extension.", node))
         else:
             if self.schema_definitions_count:
-                self.report_error(
-                    GraphQLError("Must provide only one schema definition.", node)
-                )
+                self.report_error(GraphQLError("Must provide only one schema definition.", node))
             self.schema_definitions_count += 1

src/graphql/validation/rules/no_undefined_variables.py

@@ -21,9 +21,7 @@ def __init__(self, context: ValidationContext):
     def enter_operation_definition(self, *_args: Any) -> None:
         self.defined_variable_names.clear()
 
-    def leave_operation_definition(
-        self, operation: OperationDefinitionNode, *_args: Any
-    ) -> None:
+    def leave_operation_definition(self, operation: OperationDefinitionNode, *_args: Any) -> None:
         usages = self.context.get_recursive_variable_usages(operation)
         defined_variables = self.defined_variable_names
         for usage in usages:
@@ -32,15 +30,12 @@ def leave_operation_definition(
             if var_name not in defined_variables:
                 self.report_error(
                     GraphQLError(
-                        f"Variable '${var_name}' is not defined"
-                        f" by operation '{operation.name.value}'."
+                        f"Variable '${var_name}' is not defined" f" by operation '{operation.name.value}'."
                         if operation.name
                         else f"Variable '${var_name}' is not defined.",
                         [node, operation],
                     )
                 )
 
-    def enter_variable_definition(
-        self, node: VariableDefinitionNode, *_args: Any
-    ) -> None:
+    def enter_variable_definition(self, node: VariableDefinitionNode, *_args: Any) -> None:
         self.defined_variable_names.add(node.variable.name.value)