Fix _x_count and optional filter creating duplicate GlobalOperationsStart (kensho-technologies#253)

* Fix bug

* Fix merge conflict

* Fix lint

* Fix indentation

Author: bojanserafimov

graphql_compiler/compiler/ir_lowering_match/__init__.py

@@ -1,7 +1,7 @@
 # Copyright 2018-present Kensho Technologies, LLC.
 import six
 
-from ..blocks import Filter, GlobalOperationsStart
+from ..blocks import Filter
 from ..ir_lowering_common import (extract_optional_location_root_info,
                                   extract_simple_optional_location_info,
                                   lower_context_field_existence, merge_consecutive_filter_clauses,
@@ -82,7 +82,8 @@ def lower_ir(ir_blocks, query_metadata_table, type_equivalence_hints=None):
     if len(simple_optional_root_info) > 0:
         where_filter_predicate = construct_where_filter_predicate(
             query_metadata_table, simple_optional_root_info)
-        ir_blocks.insert(-1, GlobalOperationsStart())
+        # The GlobalOperationsStart block should already exist at this point. It is inserted
+        # in the compiler_frontend, and this function asserts that at the beginning.
         ir_blocks.insert(-1, Filter(where_filter_predicate))
 
     # These lowering / optimization passes work on IR blocks.

graphql_compiler/tests/test_compiler.py

@@ -660,6 +660,45 @@ def test_filter_in_optional_block(self):
 
         check_test_data(self, test_data, expected_match, expected_gremlin, expected_sql)
 
+    def test_filter_in_optional_and_count(self):
+        test_data = test_input_data.filter_in_optional_and_count()
+
+        expected_match = '''
+            SELECT
+                Species___1.name AS `species_name`
+            FROM (
+                MATCH {{
+                    class: Species,
+                    as: Species___1
+                }}.in('Animal_OfSpecies') {{
+                   where: ((name = {animal_name})),
+                   optional: true,
+                   as: Species__in_Animal_OfSpecies___1
+                }}
+                RETURN $matches
+            )
+            LET $Species___1___in_Species_Eats = Species___1.in("Species_Eats").asList()
+            WHERE (
+                (
+                    $Species___1___in_Species_Eats.size() >= {predators}
+                ) AND (
+                    (
+                        (
+                            Species___1.in_Animal_OfSpecies IS null
+                        ) OR (
+                            Species___1.in_Animal_OfSpecies.size() = 0
+                        )
+                    ) OR (
+                        Species__in_Animal_OfSpecies___1 IS NOT null
+                    )
+                )
+            )
+        '''
+        expected_gremlin = NotImplementedError
+        expected_sql = NotImplementedError
+
+        check_test_data(self, test_data, expected_match, expected_gremlin, expected_sql)
+
     def test_between_filter_on_simple_scalar(self):
         # The "between" filter emits different output depending on what the compared types are.
         # This test checks for correct code generation when the type is a simple scalar (a String).

graphql_compiler/tests/test_input_data.py

@@ -314,6 +314,34 @@ def filter_in_optional_block():
         type_equivalence_hints=None)
 
 
+def filter_in_optional_and_count():
+    graphql_input = '''{
+        Species {
+            name @output(out_name: "species_name")
+
+            in_Animal_OfSpecies @optional {
+                name @filter(op_name: "=", value: ["$animal_name"])
+            }
+
+            in_Species_Eats @fold {
+                _x_count @filter(op_name: ">=", value: ["$predators"])
+            }
+        }
+    }'''
+    expected_output_metadata = {
+        'species_name': OutputMetadata(type=GraphQLString, optional=False),
+    }
+    expected_input_metadata = {
+        'animal_name': GraphQLString,
+        'predators': GraphQLInt,
+    }
+    return CommonTestData(
+        graphql_input=graphql_input,
+        expected_output_metadata=expected_output_metadata,
+        expected_input_metadata=expected_input_metadata,
+        type_equivalence_hints=None)
+
+
 def between_filter_on_simple_scalar():
     # The "between" filter emits different output depending on what the compared types are.
     # This test checks for correct code generation when the type is a simple scalar (a String).

graphql_compiler/tests/test_ir_generation.py

@@ -702,6 +702,57 @@ def test_filter_in_optional_block(self):
 
         check_test_data(self, test_data, expected_blocks, expected_location_types)
 
+    def test_filter_in_optional_and_count(self):
+        test_data = test_input_data.filter_in_optional_and_count()
+
+        base_location = helpers.Location(('Species',))
+        animal_location = base_location.navigate_to_subpath('in_Animal_OfSpecies')
+        base_revisit_1 = base_location.revisit()
+        fold_location = base_revisit_1.navigate_to_fold('in_Species_Eats')
+
+        expected_blocks = [
+            blocks.QueryRoot({'Species'}),
+            blocks.MarkLocation(base_location),
+            blocks.Traverse('in', 'Animal_OfSpecies', optional=True),
+            blocks.Filter(
+                expressions.BinaryComposition(
+                    u'=',
+                    expressions.LocalField('name'),
+                    expressions.Variable('$animal_name', GraphQLString)
+                )
+            ),
+            blocks.MarkLocation(animal_location),
+            blocks.EndOptional(),
+            blocks.Backtrack(base_location, optional=True),
+            blocks.MarkLocation(base_revisit_1),
+            blocks.Fold(fold_location),
+            blocks.MarkLocation(fold_location),
+            blocks.Unfold(),
+            blocks.GlobalOperationsStart(),
+            blocks.Filter(expressions.BinaryComposition(
+                u'>=',
+                expressions.FoldedContextField(
+                    fold_location.navigate_to_field(COUNT_META_FIELD_NAME),
+                    GraphQLInt
+                ),
+                expressions.Variable('$predators', GraphQLInt),
+            )),
+            blocks.ConstructResult({
+                'species_name': expressions.OutputContextField(
+                    base_location.navigate_to_field('name'), GraphQLString
+                ),
+            }),
+
+        ]
+        expected_location_types = {
+            base_location: 'Species',
+            animal_location: 'Animal',
+            base_revisit_1: 'Species',
+            fold_location: 'Species',
+        }
+
+        check_test_data(self, test_data, expected_blocks, expected_location_types)
+
     def test_between_filter_on_simple_scalar(self):
         test_data = test_input_data.between_filter_on_simple_scalar()