queryEqual fails

[marcusx2]

Operating System

macOS

Browser Version

Safari 16.5.2

Firebase SDK Version

10.5.0

Firebase SDK Product:

Firestore

Describe your project's tooling

index.html with source tag. Just javascript.

Describe the problem

The queryEqual method doesn't seem to work for all cases. It is my understanding that it should return true if both queries return the same set of documents. I will give you an example where it returns false even though the document set is the same.

Steps and code to reproduce issue

Use the example data.

var q3 = query(collection(db, "cities"), or(where("capital", "==", true), where("capital", "==", false)));
var q4 = collection(db, "cities");

const querySnapshot = await getDocs(q3);
querySnapshot.forEach(doc => console.log(doc.id, " => ", doc.data()));

const querySnapshot2 = await getDocs(q3);
querySnapshot.forEach(doc => console.log(doc.id, " => ", doc.data()));

console.log(queryEqual(q3, q4));

Both queries return the same document set, and it's guaranteed that q3 will always return the same set as q4, yet queryEqual returns false.

Even something much more simple and obvious returns false

var q3 = query(collection(db, "cities"), or(where("capital", "==", true), where("capital", "==", false)));
var q4 = query(collection(db, "cities"), or(where("capital", "==", false), where("capital", "==", true)));

console.log(queryEqual(q3, q4));

From further tests, it seems that queryEqual only returns true if both queries are written exactly the same way, not if the result would turn out the same. Is this by design? In that case, what is the use case of queryEqual? It seems pointless to me.

[dconeybe]

Hi @marcusx2. What you have discovered is intended behavior. Although the queryEqual() function does some rudimentary normalization when comparing queries for equality, that normalization is, indeed, quite basic. In particular, we do not guarantee that queryEqual() returns true if, and only if, the two queries are guaranteed to have the same result set. In fact, the documentation specifically says "Returns true if the provided queries point to the same collection and apply the same constraints.". So, basically, queryEqual() returns true if the two queries were created identically. It would, for sure, be useful to provide deep normalization but that is not an operation that is provided by the SDK. I've logged an internal ticket, b/312455217, to maybe revisit this some day. I'm sorry that I don't have a more satisfying answer.

If interested, here are some links that show how queryEqual() is implemented.

firebase-js-sdk/packages/firestore/src/lite-api/reference.ts

Lines 633 to 657 in 00235ba

	/**
	* Returns true if the provided queries point to the same collection and apply
	* the same constraints.
	*
	* @param left - A `Query` to compare.
	* @param right - A `Query` to compare.
	* @returns true if the references point to the same location in the same
	* Firestore database.
	*/
	export function queryEqual<AppModelType, DbModelType extends DocumentData>(
	left: Query<AppModelType, DbModelType>,
	right: Query<AppModelType, DbModelType>
	): boolean {
	left = getModularInstance(left);
	right = getModularInstance(right);
	if (left instanceof Query && right instanceof Query) {
	return (
	left.firestore === right.firestore &&
	queryEquals(left._query, right._query) &&
	left.converter === right.converter
	);
	}
	return false;
	}

firebase-js-sdk/packages/firestore/src/core/query.ts

Lines 429 to 434 in 00235ba

	export function queryEquals(left: Query, right: Query): boolean {
	return (
	targetEquals(queryToTarget(left), queryToTarget(right)) &&
	left.limitType === right.limitType
	);
	}

firebase-js-sdk/packages/firestore/src/core/target.ts

Lines 178 to 216 in 00235ba

	export function targetEquals(left: Target, right: Target): boolean {
	if (left.limit !== right.limit) {
	return false;
	}
	if (left.orderBy.length !== right.orderBy.length) {
	return false;
	}
	for (let i = 0; i < left.orderBy.length; i++) {
	if (!orderByEquals(left.orderBy[i], right.orderBy[i])) {
	return false;
	}
	}
	if (left.filters.length !== right.filters.length) {
	return false;
	}
	for (let i = 0; i < left.filters.length; i++) {
	if (!filterEquals(left.filters[i], right.filters[i])) {
	return false;
	}
	}
	if (left.collectionGroup !== right.collectionGroup) {
	return false;
	}
	if (!left.path.isEqual(right.path)) {
	return false;
	}
	if (!boundEquals(left.startAt, right.startAt)) {
	return false;
	}
	return boundEquals(left.endAt, right.endAt);
	}

[marcusx2]

Hi @dconeybe , thank you for the clarification. What is the use case of queryEqual then? Can you provide an example?

[dconeybe]

I don't have an example offhand and I honestly can't think of a strong use case. It's probably something we could have omitted from the public API. However, conventionally, we have xxxEqual() functions for many types, so at least it's there for consistency with the API of other types.