Merge branch 'main' into crashlytics

Author: tonybaroneee

packages/firestore/src/core/pipeline-util.ts

@@ -81,10 +81,7 @@ export function toPipelineBooleanExpr(f: FilterInternal): BooleanExpression {
           fieldValue.equal(Constant._fromProto(value))
         );
       case Operator.NOT_EQUAL:
-        return and(
-          fieldValue.exists(),
-          fieldValue.notEqual(Constant._fromProto(value))
-        );
+        return fieldValue.notEqual(Constant._fromProto(value));
       case Operator.ARRAY_CONTAINS:
         return and(
           fieldValue.exists(),
@@ -113,11 +110,11 @@ export function toPipelineBooleanExpr(f: FilterInternal): BooleanExpression {
           Constant._fromProto(val)
         );
         if (!values) {
-          return and(fieldValue.exists(), fieldValue.notEqualAny([]));
+          return fieldValue.notEqualAny([]);
         } else if (values.length === 1) {
-          return and(fieldValue.exists(), fieldValue.notEqual(values[0]));
+          return fieldValue.notEqual(values[0]);
         } else {
-          return and(fieldValue.exists(), fieldValue.notEqualAny(values));
+          return fieldValue.notEqualAny(values);
         }
       }
       default:
@@ -169,19 +166,19 @@ export function toPipeline(query: Query, db: Firestore): Pipeline {
 
   // orders
   const orders = queryNormalizedOrderBy(query);
-  const existsConditions = orders.map(order =>
+  const existsConditions = query.explicitOrderBy.map(order =>
     field(order.field.canonicalString()).exists()
   );
-  if (existsConditions.length > 1) {
-    pipeline = pipeline.where(
-      and(
-        existsConditions[0],
-        existsConditions[1],
-        ...existsConditions.slice(2)
-      )
-    );
-  } else {
-    pipeline = pipeline.where(existsConditions[0]);
+  if (existsConditions.length > 0) {
+    const condition =
+      existsConditions.length === 1
+        ? existsConditions[0]
+        : and(
+            existsConditions[0],
+            existsConditions[1],
+            ...existsConditions.slice(2)
+          );
+    pipeline = pipeline.where(condition);
   }
 
   const orderings = orders.map(order =>

packages/firestore/test/integration/api/query_to_pipeline.test.ts

@@ -814,4 +814,71 @@ apiDescribe.skipClassic('Query to Pipeline', persistence => {
       }
     );
   });
+
+  it('not-in removes existence filter', () => {
+    return withTestCollection(
+      PERSISTENCE_MODE_UNSPECIFIED,
+      {
+        doc1: { field: 2 },
+        doc2: { field: 1 },
+        doc3: {}
+      },
+      async (collRef, db) => {
+        const query1 = query(collRef, where('field', 'not-in', [1]));
+        const snapshot = await execute(db.pipeline().createFrom(query1));
+        // doc3 (missing 'field') should be included because 'not-in' (and implicit order by)
+        // should NOT generate an existence filter.
+        verifyResults(snapshot, { field: 2 }, {});
+      }
+    );
+  });
+
+  it('not-equal removes existence filter', () => {
+    return withTestCollection(
+      PERSISTENCE_MODE_UNSPECIFIED,
+      {
+        doc1: { field: 2 },
+        doc2: { field: 1 },
+        doc3: {}
+      },
+      async (collRef, db) => {
+        const query1 = query(collRef, where('field', '!=', 1));
+        const snapshot = await execute(db.pipeline().createFrom(query1));
+        // doc3 (missing 'field') should be included.
+        verifyResults(snapshot, { field: 2 }, {});
+      }
+    );
+  });
+
+  it('inequality maintains existence filter', () => {
+    return withTestCollection(
+      PERSISTENCE_MODE_UNSPECIFIED,
+      {
+        doc1: { field: 0 },
+        doc2: {}
+      },
+      async (collRef, db) => {
+        const query1 = query(collRef, where('field', '<', 1));
+        const snapshot = await execute(db.pipeline().createFrom(query1));
+        // doc2 (missing 'field') should be EXCLUDED by the inequality filter itself.
+        verifyResults(snapshot, { field: 0 });
+      }
+    );
+  });
+
+  it('explicit order maintains existence filter', () => {
+    return withTestCollection(
+      PERSISTENCE_MODE_UNSPECIFIED,
+      {
+        doc1: { field: 1 },
+        doc2: {}
+      },
+      async (collRef, db) => {
+        const query1 = query(collRef, orderBy('field'));
+        const snapshot = await execute(db.pipeline().createFrom(query1));
+        // doc2 (missing 'field') should be EXCLUDED by the explicit orderBy existence filter.
+        verifyResults(snapshot, { field: 1 });
+      }
+    );
+  });
 });