add pipeline canonify and eq

Author: wu-hui

packages/firestore/src/api/pipeline.ts

@@ -144,4 +144,12 @@ export class Pipeline<
 
     return () => {};
   }
+
+  /**
+   * @internal
+   * @private
+   */
+  _stages(): Stage[] {
+    return this.stages;
+  }
 }

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

@@ -18,10 +18,16 @@ import {
   Expr,
   Field,
   FilterCondition,
+  FirestoreFunction,
   not,
-  or
+  or,
+  Ordering
 } from '../lite-api/expressions';
-import { isNanValue, isNullValue } from '../model/values';
+import {
+  isNanValue,
+  isNullValue,
+  VECTOR_MAP_VECTORS_KEY
+} from '../model/values';
 import {
   ArrayValue as ProtoArrayValue,
   Function as ProtoFunction,
@@ -41,6 +47,23 @@ import {
   Filter as FilterInternal,
   Operator
 } from './filter';
+import { Pipeline } from '../lite-api/pipeline';
+import {
+  AddFields,
+  Aggregate,
+  CollectionGroupSource,
+  CollectionSource,
+  DatabaseSource,
+  Distinct,
+  DocumentsSource,
+  FindNearest,
+  Limit,
+  Offset,
+  Select,
+  Sort,
+  Stage,
+  Where
+} from '../lite-api/stage';
 
 /* eslint @typescript-eslint/no-explicit-any: 0 */
 
@@ -247,3 +270,98 @@ export function toPipelineFilterCondition(
 
   throw new Error(`Failed to convert filter to pipeline conditions: ${f}`);
 }
+
+function canonifyExpr(expr: Expr): string {
+  if (expr instanceof Field) {
+    return `fld(${expr.fieldName()})`;
+  }
+  if (expr instanceof Constant) {
+    return `cst(${expr.value})`;
+  }
+  if (expr instanceof FirestoreFunction) {
+    return `fn(${expr.name},[${expr.params.map(canonifyExpr).join(',')}])`;
+  }
+  throw new Error(`Unrecognized expr ${expr}`);
+}
+
+function canonifySortOrderings(orders: Ordering[]): string {
+  return orders.map(o => `${canonifyExpr(o.expr)} ${o.direction}`).join(',');
+}
+
+function canonifyStage(stage: Stage): string {
+  if (stage instanceof AddFields) {
+    return `${stage.name}(${canonifyExprMap(stage.fields)})`;
+  }
+  if (stage instanceof Aggregate) {
+    let result = `${stage.name}(${canonifyExprMap(
+      stage.accumulators as unknown as Map<string, Expr>
+    )})`;
+    if (stage.groups.size > 0) {
+      result = result + `grouping(${canonifyExprMap(stage.groups)})`;
+    }
+    return result;
+  }
+  if (stage instanceof Distinct) {
+    return `${stage.name}(${canonifyExprMap(stage.groups)})`;
+  }
+  if (stage instanceof CollectionSource) {
+    return `${stage.name}(${stage.collectionPath})`;
+  }
+  if (stage instanceof CollectionGroupSource) {
+    return `${stage.name}(${stage.collectionId})`;
+  }
+  if (stage instanceof DatabaseSource) {
+    return `${stage.name}()`;
+  }
+  if (stage instanceof DocumentsSource) {
+    return `${stage.name}(${stage.docPaths.sort()})`;
+  }
+  if (stage instanceof Where) {
+    return `${stage.name}(${canonifyExpr(stage.condition)})`;
+  }
+  if (stage instanceof FindNearest) {
+    const vector = stage._vectorValue.value.mapValue.fields![
+      VECTOR_MAP_VECTORS_KEY
+    ].arrayValue?.values?.map(value => value.doubleValue);
+    let result = `${stage.name}(${canonifyExpr(stage._field)},${
+      stage._distanceMeasure
+    },[${vector}]`;
+    if (!!stage._limit) {
+      result = result + `,${stage._limit}`;
+    }
+    if (!!stage._distanceField) {
+      result = result + `,${stage._distanceField}`;
+    }
+    return result + ')';
+  }
+  if (stage instanceof Limit) {
+    return `${stage.name}(${stage.limit})`;
+  }
+  if (stage instanceof Offset) {
+    return `${stage.name}(${stage.offset})`;
+  }
+  if (stage instanceof Select) {
+    return `${stage.name}(${canonifyExprMap(stage.projections)})`;
+  }
+  if (stage instanceof Sort) {
+    return `${stage.name}(${canonifySortOrderings(stage.orders)})`;
+  }
+
+  throw new Error(`Unrecognized stage ${stage.name}`);
+}
+
+function canonifyExprMap(map: Map<string, Expr>): string {
+  const sortedEntries = Array.from(map.entries()).sort();
+  return `${sortedEntries
+    .map(([key, val]) => `${key}=${canonifyExpr(val)}`)
+    .join(',')}`;
+}
+
+export function canonifyPipeline(p: Pipeline): string {
+  return p.stages.map(s => canonifyStage(s)).join('|');
+}
+
+// TODO(pipeline): do a proper implementation for eq.
+export function pipelineEq(left: Pipeline, right: Pipeline): boolean {
+  return canonifyPipeline(left) === canonifyPipeline(right);
+}

packages/firestore/src/lite-api/expressions.ts

@@ -2009,7 +2009,7 @@ export class Constant extends Expr {
 
   private _protoValue?: ProtoValue;
 
-  private constructor(private value: any) {
+  private constructor(readonly value: any) {
     super();
   }
 
@@ -2191,7 +2191,7 @@ export class Constant extends Expr {
  */
 export class FirestoreFunction extends Expr {
   exprType: ExprType = 'Function';
-  constructor(private name: string, private params: Expr[]) {
+  constructor(readonly name: string, readonly params: Expr[]) {
     super();
   }
 
@@ -6706,8 +6706,8 @@ export function descending(expr: Expr): Ordering {
  */
 export class Ordering {
   constructor(
-    private expr: Expr,
-    private direction: 'ascending' | 'descending'
+    readonly expr: Expr,
+    readonly direction: 'ascending' | 'descending'
   ) {}
 
   /**

packages/firestore/src/lite-api/pipeline.ts

@@ -144,7 +144,7 @@ export class Pipeline<AppModelType = DocumentData>
      * @private
      */
     protected documentReferenceFactory: (id: DocumentKey) => DocumentReference,
-    protected stages: Stage[],
+    readonly stages: Stage[],
     // TODO(pipeline) support converter
     //private converter:  FirestorePipelineConverter<AppModelType> = defaultPipelineConverter()
     protected converter: unknown = {}

packages/firestore/src/lite-api/stage.ts

@@ -48,7 +48,7 @@ export interface Stage extends ProtoSerializable<ProtoStage> {
 export class AddFields implements Stage {
   name = 'add_fields';
 
-  constructor(private fields: Map<string, Expr>) {}
+  constructor(readonly fields: Map<string, Expr>) {}
 
   /**
    * @internal
@@ -69,8 +69,8 @@ export class Aggregate implements Stage {
   name = 'aggregate';
 
   constructor(
-    private accumulators: Map<string, Accumulator>,
-    private groups: Map<string, Expr>
+    readonly accumulators: Map<string, Accumulator>,
+    readonly groups: Map<string, Expr>
   ) {}
 
   /**
@@ -94,7 +94,7 @@ export class Aggregate implements Stage {
 export class Distinct implements Stage {
   name = 'distinct';
 
-  constructor(private groups: Map<string, Expr>) {}
+  constructor(readonly groups: Map<string, Expr>) {}
 
   /**
    * @internal
@@ -114,7 +114,7 @@ export class Distinct implements Stage {
 export class CollectionSource implements Stage {
   name = 'collection';
 
-  constructor(private collectionPath: string) {
+  constructor(readonly collectionPath: string) {
     if (!this.collectionPath.startsWith('/')) {
       this.collectionPath = '/' + this.collectionPath;
     }
@@ -138,7 +138,7 @@ export class CollectionSource implements Stage {
 export class CollectionGroupSource implements Stage {
   name = 'collection_group';
 
-  constructor(private collectionId: string) {}
+  constructor(readonly collectionId: string) {}
 
   /**
    * @internal
@@ -175,7 +175,7 @@ export class DatabaseSource implements Stage {
 export class DocumentsSource implements Stage {
   name = 'documents';
 
-  constructor(private docPaths: string[]) {}
+  constructor(readonly docPaths: string[]) {}
 
   static of(refs: DocumentReference[]): DocumentsSource {
     return new DocumentsSource(refs.map(ref => '/' + ref.path));
@@ -201,7 +201,7 @@ export class DocumentsSource implements Stage {
 export class Where implements Stage {
   name = 'where';
 
-  constructor(private condition: FilterCondition & Expr) {}
+  constructor(readonly condition: FilterCondition & Expr) {}
 
   /**
    * @internal
@@ -243,11 +243,11 @@ export class FindNearest implements Stage {
    * @param _distanceField
    */
   constructor(
-    private _field: Field,
-    private _vectorValue: ObjectValue,
-    private _distanceMeasure: 'euclidean' | 'cosine' | 'dot_product',
-    private _limit?: number,
-    private _distanceField?: string
+    readonly _field: Field,
+    readonly _vectorValue: ObjectValue,
+    readonly _distanceMeasure: 'euclidean' | 'cosine' | 'dot_product',
+    readonly _limit?: number,
+    readonly _distanceField?: string
   ) {}
 
   /**
@@ -286,7 +286,7 @@ export class FindNearest implements Stage {
 export class Limit implements Stage {
   name = 'limit';
 
-  constructor(private limit: number) {}
+  constructor(readonly limit: number) {}
 
   /**
    * @internal
@@ -306,7 +306,7 @@ export class Limit implements Stage {
 export class Offset implements Stage {
   name = 'offset';
 
-  constructor(private offset: number) {}
+  constructor(readonly offset: number) {}
 
   /**
    * @internal
@@ -326,7 +326,7 @@ export class Offset implements Stage {
 export class Select implements Stage {
   name = 'select';
 
-  constructor(private projections: Map<string, Expr>) {}
+  constructor(readonly projections: Map<string, Expr>) {}
 
   /**
    * @internal
@@ -346,7 +346,7 @@ export class Select implements Stage {
 export class Sort implements Stage {
   name = 'sort';
 
-  constructor(private orders: Ordering[]) {}
+  constructor(readonly orders: Ordering[]) {}
 
   /**
    * @internal