Revert "graph, graphql, store: Fix ParentLink entries"

This reverts commit 906f5e6.

Author: lutter

graph/src/components/store/mod.rs

@@ -461,7 +461,7 @@ pub enum ParentLink {
     /// The parent stores the id of one child. The ith entry in the
     /// vector contains the id of the child of the parent with id
     /// `EntityWindow.ids[i]`
-    Scalar(Vec<Option<String>>),
+    Scalar(Vec<String>),
 }
 
 /// How many children a parent can have when the child stores

graphql/src/store/prefetch.rs

@@ -296,12 +296,10 @@ impl<'a> JoinCond<'a> {
                         // those and the parent ids
                         let (ids, child_ids): (Vec<_>, Vec<_>) = parents_by_id
                             .into_iter()
-                            .map(|(id, node)| {
-                                (
-                                    id,
-                                    node.get(child_field)
-                                        .and_then(|value| value.as_str().map(|s| s.to_string())),
-                                )
+                            .filter_map(|(id, node)| {
+                                node.get(child_field)
+                                    .and_then(|value| value.as_str())
+                                    .map(|child_id| (id, child_id.to_owned()))
                             })
                             .unzip();
 
@@ -313,28 +311,25 @@ impl<'a> JoinCond<'a> {
                         // parent ids
                         let (ids, child_ids): (Vec<_>, Vec<_>) = parents_by_id
                             .into_iter()
-                            .map(|(id, node)| {
-                                (
-                                    id,
-                                    node.get(child_field)
-                                        .and_then(|value| match value {
-                                            r::Value::List(values) => {
-                                                let values: Vec<_> = values
-                                                    .iter()
-                                                    .filter_map(|value| {
-                                                        value.as_str().map(|value| value.to_owned())
-                                                    })
-                                                    .collect();
-                                                if values.is_empty() {
-                                                    None
-                                                } else {
-                                                    Some(values)
-                                                }
+                            .filter_map(|(id, node)| {
+                                node.get(child_field)
+                                    .and_then(|value| match value {
+                                        r::Value::List(values) => {
+                                            let values: Vec<_> = values
+                                                .iter()
+                                                .filter_map(|value| {
+                                                    value.as_str().map(|value| value.to_owned())
+                                                })
+                                                .collect();
+                                            if values.is_empty() {
+                                                None
+                                            } else {
+                                                Some(values)
                                             }
-                                            _ => None,
-                                        })
-                                        .unwrap_or(Vec::new()),
-                                )
+                                        }
+                                        _ => None,
+                                    })
+                                    .map(|child_ids| (id, child_ids))
                             })
                             .unzip();
                         (ids, ParentLink::List(child_ids))

store/postgres/src/relational_queries.rs

@@ -2103,13 +2103,7 @@ enum ParentIds {
 impl ParentIds {
     fn new(link: ParentLink) -> Self {
         match link {
-            ParentLink::Scalar(child_ids) => {
-                // Remove `None` child ids; query generation doesn't require
-                // that parent and child ids are in strict 1:1
-                // correspondence
-                let child_ids = child_ids.into_iter().filter_map(|c| c).collect();
-                ParentIds::Scalar(child_ids)
-            }
+            ParentLink::Scalar(child_ids) => ParentIds::Scalar(child_ids),
             ParentLink::List(child_ids) => {
                 // Postgres will only accept child_ids, which is a Vec<Vec<String>>
                 // if all Vec<String> are the same length. We therefore pad

store/test-store/tests/postgres/relational_bytes.rs

@@ -555,7 +555,7 @@ fn query() {
             ids: vec![CHILD1.to_owned(), CHILD2.to_owned()],
             link: EntityLink::Parent(
                 THING.clone(),
-                ParentLink::Scalar(vec![Some(ROOT.to_owned()), Some(ROOT.to_owned())]),
+                ParentLink::Scalar(vec![ROOT.to_owned(), ROOT.to_owned()]),
             ),
             column_names: AttributeNames::All,
         }]);