Don't clone selection sets during execution

mhallin · mhallin · commit 13903d7628b5 · 2016-12-28T11:28:48.000+01:00
diff --git a/src/executor.rs b/src/executor.rs
@@ -37,7 +37,7 @@ pub enum FieldPath<'a> {
 pub struct Executor<'a, CtxT> where CtxT: 'a {
     fragments: &'a HashMap<&'a str, &'a Fragment>,
     variables: &'a HashMap<String, InputValue>,
-    current_selection_set: Option<Vec<Selection>>,
+    current_selection_set: Option<&'a [Selection]>,
     schema: &'a SchemaType,
     context: &'a CtxT,
     errors: &'a RwLock<Vec<ExecutionError>>,
@@ -151,12 +151,7 @@ impl<'a, CtxT> Executor<'a, CtxT> {
 
     /// Resolve a single arbitrary value into an `ExecutionResult`
     pub fn resolve<T: GraphQLType<Context=CtxT>>(&self, value: &T) -> ExecutionResult {
-        Ok(value.resolve(
-            match self.current_selection_set {
-                Some(ref sel) => Some(sel.clone()),
-                None => None,
-            },
-            self))
+        Ok(value.resolve(self.current_selection_set, self))
     }
 
     /// Resolve a single arbitrary value into a return value
@@ -194,7 +189,7 @@ impl<'a, CtxT> Executor<'a, CtxT> {
         &self,
         field_name: Option<String>,
         location: SourcePosition,
-        selection_set: Option<Vec<Selection>>,
+        selection_set: Option<&'a [Selection]>,
     )
         -> Executor<CtxT>
     {
@@ -339,7 +334,7 @@ pub fn execute_validated_query<'a, QueryT, MutationT, CtxT>(
         let executor = Executor {
             fragments: &fragments.iter().map(|f| (f.item.name.item.as_str(), &f.item)).collect(),
             variables: variables,
-            current_selection_set: Some(op.item.selection_set),
+            current_selection_set: Some(&op.item.selection_set[..]),
             schema: &root_node.schema,
             context: context,
             errors: &errors,
diff --git a/src/macros/enums.rs b/src/macros/enums.rs
@@ -83,7 +83,7 @@ macro_rules! graphql_enum {
                     .into_meta()
             }
 
-            fn resolve(&self, _: Option<Vec<$crate::Selection>>, _: &$crate::Executor<Self::Context>) -> $crate::Value {
+            fn resolve(&self, _: Option<&[$crate::Selection]>, _: &$crate::Executor<Self::Context>) -> $crate::Value {
                 match self {
                     $(
                         &graphql_enum!(@as_pattern, $eval) =>
diff --git a/src/macros/interface.rs b/src/macros/interface.rs
@@ -268,7 +268,7 @@ macro_rules! graphql_interface {
             fn resolve_into_type(
                 &$mainself,
                 type_name: &str,
-                _: Option<Vec<$crate::Selection>>,
+                _: Option<&[$crate::Selection]>,
                 executor: &$crate::Executor<Self::Context>,
             )
                 -> $crate::ExecutionResult
diff --git a/src/macros/scalar.rs b/src/macros/scalar.rs
@@ -77,7 +77,7 @@ macro_rules! graphql_scalar {
 
             fn resolve(
                 &$resolve_selfvar,
-                _: Option<Vec<$crate::Selection>>,
+                _: Option<&[$crate::Selection]>,
                 _: &$crate::Executor<Self::Context>) -> $crate::Value {
                 $resolve_body
             }
diff --git a/src/macros/union.rs b/src/macros/union.rs
@@ -137,7 +137,7 @@ macro_rules! graphql_union {
             fn resolve_into_type(
                 &$mainself,
                 type_name: &str,
-                _: Option<Vec<$crate::Selection>>,
+                _: Option<&[$crate::Selection]>,
                 executor: &$crate::Executor<Self::Context>,
             )
                 -> $crate::ExecutionResult
diff --git a/src/types/base.rs b/src/types/base.rs
@@ -248,7 +248,7 @@ pub trait GraphQLType: Sized {
     ///
     /// The default implementation panics.
     #[allow(unused_variables)]
-    fn resolve_into_type(&self, type_name: &str, selection_set: Option<Vec<Selection>>, executor: &Executor<Self::Context>) -> ExecutionResult {
+    fn resolve_into_type(&self, type_name: &str, selection_set: Option<&[Selection]>, executor: &Executor<Self::Context>) -> ExecutionResult {
         if Self::name().unwrap() == type_name {
             Ok(self.resolve(selection_set, executor))
         } else {
@@ -274,7 +274,7 @@ pub trait GraphQLType: Sized {
     /// The default implementation uses `resolve_field` to resolve all fields,
     /// including those through fragment expansion, for object types. For
     /// non-object types, this method panics.
-    fn resolve(&self, selection_set: Option<Vec<Selection>>, executor: &Executor<Self::Context>) -> Value {
+    fn resolve(&self, selection_set: Option<&[Selection]>, executor: &Executor<Self::Context>) -> Value {
         if let Some(selection_set) = selection_set {
             let mut result = HashMap::new();
             resolve_selection_set_into(self, selection_set, executor, &mut result);
@@ -288,7 +288,7 @@ pub trait GraphQLType: Sized {
 
 fn resolve_selection_set_into<T, CtxT>(
     instance: &T,
-    selection_set: Vec<Selection>,
+    selection_set: &[Selection],
     executor: &Executor<CtxT>,
     result: &mut HashMap<String, Value>)
     where T: GraphQLType<Context=CtxT>
@@ -299,11 +299,11 @@ fn resolve_selection_set_into<T, CtxT>(
 
     for selection in selection_set {
         match selection {
-            Selection::Field(Spanning { item: f, start: start_pos, .. }) => {
+            &Selection::Field(Spanning { item: ref f, start: ref start_pos, .. }) => {
                 if is_excluded(
-                        &match f.directives {
-                            Some(sel) => Some(sel.iter().cloned().map(|s| s.item).collect()),
-                            None => None,
+                        &match &f.directives {
+                            &Some(ref sel) => Some(sel.iter().cloned().map(|s| s.item).collect()),
+                            &None => None,
                         },
                         executor.variables()) {
                     continue;
@@ -327,30 +327,30 @@ fn resolve_selection_set_into<T, CtxT>(
                 let mut sub_exec = executor.sub_executor(
                     Some(response_name.clone()),
                     start_pos.clone(),
-                    f.selection_set);
+                    f.selection_set.as_ref().map(|v| &v[..]));
 
                 let field_result = instance.resolve_field(
                     &f.name.item,
                     &Arguments::new(
-                        f.arguments.map(|m|
-                            m.item.into_iter().map(|(k, v)|
+                        f.arguments.as_ref().map(|m|
+                            m.item.iter().cloned().map(|(k, v)|
                                 (k.item, v.item.into_const(exec_vars))).collect()),
                         &meta_field.arguments),
                     &mut sub_exec);
 
                 match field_result {
                     Ok(v) => merge_key_into(result, response_name.clone(), v),
                     Err(e) => {
-                        sub_exec.push_error(e, start_pos);
+                        sub_exec.push_error(e, start_pos.clone());
                         result.insert(response_name.clone(), Value::null());
                     }
                 }
             },
-            Selection::FragmentSpread(Spanning { item: spread, .. }) => {
+            &Selection::FragmentSpread(Spanning { item: ref spread, .. }) => {
                 if is_excluded(
-                        &match spread.directives {
-                            Some(sel) => Some(sel.iter().cloned().map(|s| s.item).collect()),
-                            None => None,
+                        &match &spread.directives {
+                            &Some(ref sel) => Some(sel.iter().cloned().map(|s| s.item).collect()),
+                            &None => None,
                         },
                         executor.variables()) {
                     continue;
@@ -360,13 +360,13 @@ fn resolve_selection_set_into<T, CtxT>(
                     .expect("Fragment could not be found");
 
                 resolve_selection_set_into(
-                    instance, fragment.selection_set.clone(), executor, result);
+                    instance, &fragment.selection_set[..], executor, result);
             },
-            Selection::InlineFragment(Spanning { item: fragment, start: start_pos, .. }) => {
+            &Selection::InlineFragment(Spanning { item: ref fragment, start: ref start_pos, .. }) => {
                 if is_excluded(
-                        &match fragment.directives {
-                            Some(sel) => Some(sel.iter().cloned().map(|s| s.item).collect()),
-                            None => None
+                        &match &fragment.directives {
+                            &Some(ref sel) => Some(sel.iter().cloned().map(|s| s.item).collect()),
+                            &None => None
                         },
                         executor.variables()) {
                     continue;
@@ -375,12 +375,12 @@ fn resolve_selection_set_into<T, CtxT>(
                 let mut sub_exec = executor.sub_executor(
                     None,
                     start_pos.clone(),
-                    Some(fragment.selection_set.clone()));
+                    Some(&fragment.selection_set[..]));
 
-                if let Some(type_condition) = fragment.type_condition {
+                if let &Some(ref type_condition) = &fragment.type_condition {
                     let sub_result = instance.resolve_into_type(
                         &type_condition.item,
-                        Some(fragment.selection_set.clone()),
+                        Some(&fragment.selection_set[..]),
                         &mut sub_exec);
 
                     if let Ok(Value::Object(mut hash_map)) = sub_result {
@@ -389,13 +389,13 @@ fn resolve_selection_set_into<T, CtxT>(
                         }
                     }
                     else if let Err(e) = sub_result {
-                         sub_exec.push_error(e, start_pos);
+                         sub_exec.push_error(e, start_pos.clone());
                     }
                 }
                 else {
                     resolve_selection_set_into(
                         instance,
-                        fragment.selection_set.clone(),
+                        &fragment.selection_set[..],
                         &mut sub_exec,
                         result);
                 }
diff --git a/src/types/containers.rs b/src/types/containers.rs
@@ -16,7 +16,7 @@ impl<T, CtxT> GraphQLType for Option<T> where T: GraphQLType<Context=CtxT> {
         registry.build_nullable_type::<T>().into_meta()
     }
 
-    fn resolve(&self, _: Option<Vec<Selection>>, executor: &Executor<CtxT>) -> Value {
+    fn resolve(&self, _: Option<&[Selection]>, executor: &Executor<CtxT>) -> Value {
         match *self {
             Some(ref obj) => executor.resolve_into_value(obj),
             None => Value::null(),
@@ -56,7 +56,7 @@ impl<T, CtxT> GraphQLType for Vec<T> where T: GraphQLType<Context=CtxT> {
         registry.build_list_type::<T>().into_meta()
     }
 
-    fn resolve(&self, _: Option<Vec<Selection>>, executor: &Executor<CtxT>) -> Value {
+    fn resolve(&self, _: Option<&[Selection]>, executor: &Executor<CtxT>) -> Value {
         Value::list(
             self.iter().map(|e| executor.resolve_into_value(e)).collect()
         )
@@ -103,7 +103,7 @@ impl<'a, T, CtxT> GraphQLType for &'a [T] where T: GraphQLType<Context=CtxT> {
         registry.build_list_type::<T>().into_meta()
     }
 
-    fn resolve(&self, _: Option<Vec<Selection>>, executor: &Executor<CtxT>) -> Value {
+    fn resolve(&self, _: Option<&[Selection]>, executor: &Executor<CtxT>) -> Value {
         Value::list(
             self.iter().map(|e| executor.resolve_into_value(e)).collect()
         )
diff --git a/src/types/pointers.rs b/src/types/pointers.rs
@@ -16,7 +16,7 @@ impl<T, CtxT> GraphQLType for Box<T> where T: GraphQLType<Context=CtxT> {
         T::meta(registry)
     }
 
-    fn resolve_into_type(&self, name: &str, selection_set: Option<Vec<Selection>>, executor: &Executor<CtxT>) -> ExecutionResult {
+    fn resolve_into_type(&self, name: &str, selection_set: Option<&[Selection]>, executor: &Executor<CtxT>) -> ExecutionResult {
         (**self).resolve_into_type(name, selection_set, executor)
     }
 
@@ -25,7 +25,7 @@ impl<T, CtxT> GraphQLType for Box<T> where T: GraphQLType<Context=CtxT> {
         (**self).resolve_field(field, args, executor)
     }
 
-    fn resolve(&self, selection_set: Option<Vec<Selection>>, executor: &Executor<CtxT>) -> Value {
+    fn resolve(&self, selection_set: Option<&[Selection]>, executor: &Executor<CtxT>) -> Value {
         (**self).resolve(selection_set, executor)
     }
 }
@@ -56,7 +56,7 @@ impl<'a, T, CtxT> GraphQLType for &'a T where T: GraphQLType<Context=CtxT> {
         T::meta(registry)
     }
 
-    fn resolve_into_type(&self, name: &str, selection_set: Option<Vec<Selection>>, executor: &Executor<CtxT>) -> ExecutionResult {
+    fn resolve_into_type(&self, name: &str, selection_set: Option<&[Selection]>, executor: &Executor<CtxT>) -> ExecutionResult {
         (**self).resolve_into_type(name, selection_set, executor)
     }
 
@@ -65,7 +65,7 @@ impl<'a, T, CtxT> GraphQLType for &'a T where T: GraphQLType<Context=CtxT> {
         (**self).resolve_field(field, args, executor)
     }
 
-    fn resolve(&self, selection_set: Option<Vec<Selection>>, executor: &Executor<CtxT>) -> Value {
+    fn resolve(&self, selection_set: Option<&[Selection]>, executor: &Executor<CtxT>) -> Value {
         (**self).resolve(selection_set, executor)
     }
 }
diff --git a/src/types/scalars.rs b/src/types/scalars.rs
@@ -53,7 +53,7 @@ impl<'a> GraphQLType for &'a str {
         registry.build_scalar_type::<String>().into_meta()
     }
 
-    fn resolve(&self, _: Option<Vec<Selection>>, _: &Executor<Self::Context>) -> Value {
+    fn resolve(&self, _: Option<&[Selection]>, _: &Executor<Self::Context>) -> Value {
         Value::string(self)
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -83,7 +83,7 @@ macro_rules! graphql_enum {`
`83`	`83`	`.into_meta()`
`84`	`84`	`}`
`85`	`85`
`86`		`- fn resolve(&self, _: Option<Vec<$crate::Selection>>, _: &$crate::Executor<Self::Context>) -> $crate::Value {`
	`86`	`+ fn resolve(&self, _: Option<&[$crate::Selection]>, _: &$crate::Executor<Self::Context>) -> $crate::Value {`
`87`	`87`	`match self {`
`88`	`88`	`$(`
`89`	`89`	`&graphql_enum!(@as_pattern, $eval) =>`
Original file line number	Diff line number	Diff line change
`@@ -268,7 +268,7 @@ macro_rules! graphql_interface {`
`268`	`268`	`fn resolve_into_type(`
`269`	`269`	`&$mainself,`
`270`	`270`	`type_name: &str,`
`271`		`- _: Option<Vec<$crate::Selection>>,`
	`271`	`+ _: Option<&[$crate::Selection]>,`
`272`	`272`	`executor: &$crate::Executor<Self::Context>,`
`273`	`273`	`)`
`274`	`274`	`-> $crate::ExecutionResult`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ macro_rules! graphql_scalar {`
`77`	`77`
`78`	`78`	`fn resolve(`
`79`	`79`	`&$resolve_selfvar,`
`80`		`- _: Option<Vec<$crate::Selection>>,`
	`80`	`+ _: Option<&[$crate::Selection]>,`
`81`	`81`	`_: &$crate::Executor<Self::Context>) -> $crate::Value {`
`82`	`82`	`$resolve_body`
`83`	`83`	`}`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ macro_rules! graphql_union {`
`137`	`137`	`fn resolve_into_type(`
`138`	`138`	`&$mainself,`
`139`	`139`	`type_name: &str,`
`140`		`- _: Option<Vec<$crate::Selection>>,`
	`140`	`+ _: Option<&[$crate::Selection]>,`
`141`	`141`	`executor: &$crate::Executor<Self::Context>,`
`142`	`142`	`)`
`143`	`143`	`-> $crate::ExecutionResult`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ impl<T, CtxT> GraphQLType for Option<T> where T: GraphQLType<Context=CtxT> {`
`16`	`16`	`registry.build_nullable_type::<T>().into_meta()`
`17`	`17`	`}`
`18`	`18`
`19`		`- fn resolve(&self, _: Option<Vec<Selection>>, executor: &Executor<CtxT>) -> Value {`
	`19`	`+ fn resolve(&self, _: Option<&[Selection]>, executor: &Executor<CtxT>) -> Value {`
`20`	`20`	`match *self {`
`21`	`21`	`Some(ref obj) => executor.resolve_into_value(obj),`
`22`	`22`	`None => Value::null(),`
`@@ -56,7 +56,7 @@ impl<T, CtxT> GraphQLType for Vec<T> where T: GraphQLType<Context=CtxT> {`
`56`	`56`	`registry.build_list_type::<T>().into_meta()`
`57`	`57`	`}`
`58`	`58`
`59`		`- fn resolve(&self, _: Option<Vec<Selection>>, executor: &Executor<CtxT>) -> Value {`
	`59`	`+ fn resolve(&self, _: Option<&[Selection]>, executor: &Executor<CtxT>) -> Value {`
`60`	`60`	`Value::list(`
`61`	`61`	`self.iter().map(\|e\| executor.resolve_into_value(e)).collect()`
`62`	`62`	`)`
`@@ -103,7 +103,7 @@ impl<'a, T, CtxT> GraphQLType for &'a [T] where T: GraphQLType<Context=CtxT> {`
`103`	`103`	`registry.build_list_type::<T>().into_meta()`
`104`	`104`	`}`
`105`	`105`
`106`		`- fn resolve(&self, _: Option<Vec<Selection>>, executor: &Executor<CtxT>) -> Value {`
	`106`	`+ fn resolve(&self, _: Option<&[Selection]>, executor: &Executor<CtxT>) -> Value {`
`107`	`107`	`Value::list(`
`108`	`108`	`self.iter().map(\|e\| executor.resolve_into_value(e)).collect()`
`109`	`109`	`)`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ impl<'a> GraphQLType for &'a str {`
`53`	`53`	`registry.build_scalar_type::<String>().into_meta()`
`54`	`54`	`}`
`55`	`55`
`56`		`- fn resolve(&self, _: Option<Vec<Selection>>, _: &Executor<Self::Context>) -> Value {`
	`56`	`+ fn resolve(&self, _: Option<&[Selection]>, _: &Executor<Self::Context>) -> Value {`
`57`	`57`	`Value::string(self)`
`58`	`58`	`}`
`59`	`59`	`}`