Fix O(N) time & space in QueryCache search when queryKey is present

packages/query-core/src/__tests__/queryCache.test.tsx

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
 import { queryKey, sleep } from '@tanstack/query-test-utils'
-import { QueryCache, QueryClient, QueryObserver } from '..'
+import { Query, QueryCache, QueryClient, QueryObserver } from '..'
 
 describe('queryCache', () => {
   let queryClient: QueryClient
@@ -293,6 +293,82 @@ describe('queryCache', () => {
       expect(queryCache.findAll({ fetchStatus: 'fetching' })).toEqual([])
     })
 
+    test('only visits queries with the given prefix', async () => {
+      const prefix = ['posts']
+      queryClient.prefetchQuery({
+        queryKey: ['other'],
+        queryFn: () => sleep(100).then(() => 'other'),
+      })
+      queryClient.prefetchQuery({
+        queryKey: ['other', {}],
+        queryFn: () => sleep(100).then(() => 'otherObjectSuffix'),
+      })
+      queryClient.prefetchQuery({
+        queryKey: [{}, 'objectPrefix'],
+        queryFn: () => sleep(100).then(() => 'otherObjectPrefix'),
+      })
+
+      queryClient.prefetchQuery({
+        queryKey: prefix,
+        queryFn: () => sleep(100).then(() => 'exactMatch'),
+      })
+      const exactMatchQuery = queryCache.find({ queryKey: prefix })
+
+      queryClient.prefetchQuery({
+        queryKey: [...prefix, 1],
+        queryFn: () => sleep(100).then(() => 'primitiveSuffix'),
+      })
+      const primitiveSuffixQuery = queryCache.find({ queryKey: [...prefix, 1] })
+
+      queryClient.prefetchQuery({
+        queryKey: [...prefix, 2, 'primitiveSuffix'],
+        queryFn: () => sleep(100).then(() => 'primitiveSuffixLength2'),
+      })
+      const primitiveSuffixLength2Query = queryCache.find({
+        queryKey: [...prefix, 2, 'primitiveSuffix'],
+      })
+
+      queryClient.prefetchQuery({
+        queryKey: [...prefix, 3, {}, 'obj'],
+        queryFn: () => sleep(100).then(() => 'matchingObjectSuffix'),
+      })
+      const matchingObjectSuffixQuery = queryCache.find({
+        queryKey: [...prefix, 3, {}, 'obj'],
+      })
+
+      await vi.advanceTimersByTimeAsync(100)
+
+      let predicateCallCount = 0
+      const results = queryCache.findAll({
+        queryKey: prefix,
+        predicate: () => {
+          predicateCallCount++
+          return true
+        },
+      })
+
+      expect(predicateCallCount).toBe(results.length)
+
+      const sortByHash = (a: Query | undefined, b: Query | undefined) => {
+        if (!a && !b) return 0
+        if (!a) return -1
+        if (!b) return 1
+        if (a.queryHash < b.queryHash) return -1
+        if (a.queryHash > b.queryHash) return 1
+        return 0
+      }
+      results.sort(sortByHash)
+
+      expect(results).toEqual(
+        [
+          exactMatchQuery,
+          primitiveSuffixQuery,
+          primitiveSuffixLength2Query,
+          matchingObjectSuffixQuery,
+        ].sort(sortByHash),
+      )
+    })
+
     test('should return all the queries when no filters are defined', async () => {
       const key1 = queryKey()
       const key2 = queryKey()

packages/query-core/src/query.ts

@@ -202,8 +202,23 @@ export class Query<
   setOptions(
     options?: QueryOptions<TQueryFnData, TError, TData, TQueryKey>,
   ): void {
+    const oldOptions = (this.options as typeof this.options | undefined)
+      ? this.options
+      : undefined
+
     this.options = { ...this.#defaultOptions, ...options }
 
+    if (oldOptions) {
+      // Do not do this update when first created.
+      // The QueryCache manages admission / removal itself.
+      // We only need to keep it up-to-date here.
+      const prevHashFn = oldOptions.queryKeyHashFn
+      const newHashFn = this.options.queryKeyHashFn
+      if (prevHashFn !== newHashFn) {
+        this.#cache.onQueryKeyHashFunctionChanged(prevHashFn, newHashFn)
+      }
+    }
+
     this.updateGcTime(this.options.gcTime)
   }