@signaldb/svelte 2.0.0-beta.13 → 2.0.0-beta.14

package/dist/base/core/src/WorkerDataAdapter.js

@@ -6,10 +6,37 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const queryId_1 = __importDefault(require("./utils/queryId"));
 const randomId_1 = __importDefault(require("./utils/randomId"));
 const batchOnNextTick_1 = __importDefault(require("./utils/batchOnNextTick"));
-const applyQueryOptions_1 = __importDefault(require("./utils/applyQueryOptions"));
+const incrementalQueryUpdate_1 = require("./utils/incrementalQueryUpdate");
+const queryDelta_1 = require("./utils/queryDelta");
 const match_1 = __importDefault(require("./utils/match"));
 const modify_1 = __importDefault(require("./utils/modify"));
 const deepClone_1 = __importDefault(require("./utils/deepClone"));
+// The ids a selector names outright, or `null` when it asks something the ids alone cannot answer.
+// Deliberately strict: one key, `id`, holding a primitive or a lone `$in`. Anything else — another
+// field alongside it, an operator, a nested condition — falls back to matching, because guessing
+// wrong here would silently drop a row from a write.
+/**
+ * Extracts the ids a selector names outright.
+ * @param selector - The selector to inspect.
+ * @returns The named ids, or `null` when the selector asks more than ids can answer.
+ */
+function selectorIds(selector) {
+    if (selector == null || typeof selector !== 'object')
+        return null;
+    const keys = Object.keys(selector);
+    if (keys.length !== 1 || keys[0] !== 'id')
+        return null;
+    const value = selector.id;
+    if (value == null)
+        return null;
+    if (typeof value !== 'object')
+        return [value];
+    const valueKeys = Object.keys(value);
+    if (valueKeys.length !== 1 || valueKeys[0] !== '$in')
+        return null;
+    const inValues = value.$in;
+    return Array.isArray(inValues) ? inValues : null;
+}
 class WorkerDataAdapter {
     worker;
     options;
@@ -20,6 +47,10 @@ class WorkerDataAdapter {
     collectionReady = new Map();
     batchExecutionHelpers = new Map();
     queries = {};
+    // Resolvers for `exec` calls that are still waiting for their response, keyed by message id.
+    // Together with the query registry above this is everything the shared dispatcher needs to route
+    // a message, which is why there is no longer a listener per request or per query.
+    pendingRequests = new Map();
     // Writes that have been issued but not yet confirmed by the worker. Their
     // effect is layered on top of each active query's last authoritative result
     // in `getQueryResult`, so a cursor reflects a write immediately instead of
@@ -33,6 +64,13 @@ class WorkerDataAdapter {
     // rollback.
     pendingWrites = new Map();
     pendingWriteSeq = 0;
+    // Bumped whenever a collection's pending writes change, in either direction. Anything derived
+    // from them is stale from that moment on.
+    pendingWriteVersions = new Map();
+    bumpPendingWriteVersion(collectionName) {
+        const current = this.pendingWriteVersions.get(collectionName) ?? 0;
+        this.pendingWriteVersions.set(collectionName, current + 1);
+    }
     constructor(worker, options) {
         this.worker = worker;
         this.options = options;
@@ -43,18 +81,115 @@ class WorkerDataAdapter {
             const timeoutId = setTimeout(() => {
                 reject(new Error('WorkerDataAdapter initialization timed out'));
             }, 5000);
-            const handleMessage = (event) => {
-                const { type, workerId } = event.data;
-                if (workerId !== this.id)
-                    return;
-                if (type === 'ready') {
-                    resolve();
-                    clearTimeout(timeoutId);
-                    this.worker.removeEventListener('message', handleMessage);
-                }
+            this.resolveWorkerReady = () => {
+                clearTimeout(timeoutId);
+                resolve();
             };
-            this.worker.addEventListener('message', handleMessage);
         });
+        this.worker.addEventListener('message', this.handleWorkerMessage);
+    }
+    resolveWorkerReady = () => { };
+    // The one and only message listener this adapter installs. Every response and every query update
+    // is routed from here by a map lookup. Listening per request and per query instead meant each
+    // incoming message was offered to every listener in turn, and each of them re-serialized its own
+    // selector to decide the message was not for it — turning a write that touches N queries into
+    // N² selector serializations before any of the actual work started.
+    handleWorkerMessage = (event) => {
+        const message = event.data;
+        if (message == null)
+            return;
+        if (message.workerId !== this.id)
+            return;
+        if (message.type === 'ready') {
+            this.resolveWorkerReady();
+            return;
+        }
+        if (message.type === 'response') {
+            if (message.id == null)
+                return;
+            const pending = this.pendingRequests.get(message.id);
+            if (!pending)
+                return;
+            this.pendingRequests.delete(message.id);
+            this.log('response', message.data ?? message.error);
+            if (message.error) {
+                pending.reject(message.error);
+            }
+            else {
+                pending.resolve(message.data);
+            }
+            return;
+        }
+        if (message.type === 'queryUpdate')
+            this.handleQueryUpdate(message.data, message.error ?? null);
+    };
+    handleQueryUpdate(data, error) {
+        if (data == null)
+            return;
+        const { collectionName, qid, selector, options, state, items, delta, } = data;
+        if (collectionName == null)
+            return;
+        const collectionQueries = this.queries[collectionName];
+        if (!collectionQueries)
+            return;
+        // The host names the query outright; deriving the id from the selector is only for messages
+        // that predate that (and for tests that hand-roll one).
+        const id = qid ?? (selector === undefined ? undefined : (0, queryId_1.default)(selector, options));
+        if (id == null)
+            return;
+        const query = collectionQueries.get(id);
+        if (!query)
+            return;
+        this.log('queryUpdate', query.selector, query.options, state, data ?? error);
+        let nextItems = items;
+        let deltaToPublish;
+        if (delta != null) {
+            // A delta only makes sense against the result it was computed from. If this adapter is
+            // holding something else — a message lost, a query re-registered underneath, a host and an
+            // adapter that disagree — applying it anyway would leave a result that silently drifts from
+            // the store. Refusing it keeps the last coherent result instead, and the next full answer
+            // puts things right.
+            if (!(0, queryDelta_1.canApplyQueryDelta)(query.items, delta))
+                return;
+            if ((0, queryDelta_1.isEmptyQueryDelta)(delta))
+                return;
+            const pendingBefore = this.flattenPendingWrites(collectionName);
+            const servedBefore = pendingBefore == null
+                ? null
+                : this.servedResult(collectionName, query);
+            nextItems = (0, queryDelta_1.applyQueryDelta)(query.items, delta);
+            if (servedBefore == null) {
+                // Nothing is layered on top of the stored result, so what the host described is exactly
+                // what a reader of this query will see change.
+                deltaToPublish = delta;
+            }
+            else {
+                // A write is still in flight, and its effect has been shown to readers all along. What
+                // they see change is the difference between the two layered results — which, for the
+                // ordinary case of the host confirming the write that is in flight, is nothing at all.
+                this.updateQuery(collectionName, {
+                    selector: query.selector,
+                    options: query.options,
+                }, { state, error, items: nextItems });
+                const stored = collectionQueries.get(id);
+                if (!stored)
+                    return;
+                const servedDelta = (0, queryDelta_1.diffQueryResults)(servedBefore, this.servedResult(collectionName, stored));
+                if ((0, queryDelta_1.isEmptyQueryDelta)(servedDelta) && state === query.state)
+                    return;
+                stored.stateChangeCallbacks
+                    .forEach(callback => (0, queryDelta_1.callWithDelta)(callback, state, servedDelta));
+                return;
+            }
+        }
+        this.updateQuery(collectionName, {
+            selector: query.selector,
+            options: query.options,
+        }, { state, error, items: nextItems });
+        const updated = collectionQueries.get(id);
+        if (!updated)
+            return;
+        updated.stateChangeCallbacks.forEach(callback => (0, queryDelta_1.callWithDelta)(callback, state, deltaToPublish));
     }
     async exec(method, collectionName, ...args) {
         await this.workerReady;
@@ -69,24 +204,7 @@ class WorkerDataAdapter {
         }
         return new Promise((resolve, reject) => {
             const messageId = (0, randomId_1.default)();
-            const handleMessage = (event) => {
-                const { id, workerId, type, data, error } = event.data;
-                if (workerId !== this.id)
-                    return;
-                if (type !== 'response')
-                    return;
-                if (id !== messageId)
-                    return;
-                this.log(method, 'result', data ?? error);
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve(data);
-                }
-                this.worker.removeEventListener('message', handleMessage);
-            };
-            this.worker.addEventListener('message', handleMessage);
+            this.pendingRequests.set(messageId, { resolve, reject });
             this.worker.postMessage({
                 id: messageId,
                 workerId: this.id,
@@ -95,30 +213,156 @@ class WorkerDataAdapter {
             });
         });
     }
-    // The items an active query currently holds, deduplicated by id — the only
-    // items this adapter knows about, and the set a selector-based write can be
-    // resolved against locally.
-    observableItems(collectionName) {
-        const byId = new Map();
-        this.queries[collectionName]?.forEach((query) => {
-            this.mergePendingWrites(collectionName, query.items).forEach((item) => {
-                byId.set(item.id, item);
-            });
+    /**
+     * Issues a call whose result nobody is waiting for, and makes sure a failure has somewhere to
+     * go. A bare rejection here would surface as an uncaught error — which is what a disposed
+     * collection produced every time a cursor was cleaned up after it.
+     * @param method - The method to call on the worker.
+     * @param collectionName - The collection it applies to.
+     * @param args - The remaining arguments.
+     * @param onError - Called when the call fails, in place of merely logging it.
+     */
+    execInBackground(method, collectionName, args = [], onError) {
+        this.exec(method, collectionName, ...args).catch((error) => {
+            if (onError) {
+                onError(error);
+                return;
+            }
+            this.log(method, 'failed', error);
         });
-        return [...byId.values()];
     }
-    mergePendingWrites(collectionName, items) {
+    queryItemsById(query) {
+        if (!query.itemsById) {
+            query.itemsById = new Map(query.items.map(item => [item.id, item]));
+        }
+        return query.itemsById;
+    }
+    // The pending writes of a collection collapsed into one upsert/delete view, newest write winning.
+    // `null` when there are none, which is the overwhelmingly common case and the one every caller
+    // below short-circuits on. Pending sets are tiny — a write or two in flight — so this is cheap in
+    // a way that touching each query's items is not.
+    flattenPendingWrites(collectionName) {
         const pending = this.pendingWrites.get(collectionName);
         if (!pending || pending.size === 0)
-            return items;
-        const merged = new Map(items.map(item => [item.id, item]));
+            return null;
+        const upserts = new Map();
+        const deletes = new Set();
         [...pending.entries()]
             .sort(([a], [b]) => a - b) // eslint-disable-line unicorn/no-array-sort -- unavailable on Hermes
             .forEach(([, write]) => {
-            write.upserts.forEach((item, id) => merged.set(id, item));
-            write.deletes.forEach(id => merged.delete(id));
+            write.upserts.forEach((item, id) => {
+                upserts.set(id, item);
+                deletes.delete(id);
+            });
+            write.deletes.forEach((id) => {
+                deletes.add(id);
+                upserts.delete(id);
+            });
+        });
+        return { upserts, deletes };
+    }
+    // The items an active query currently holds, deduplicated by id, plus whatever the pending writes
+    // add or remove — the only items this adapter knows about, and the set a selector-based write is
+    // resolved against locally. One pass over the queries rather than a merge per query.
+    // Whether a query's result is the items themselves rather than a projection of them. A write is
+    // resolved locally by applying its modifier to the item this adapter holds, and applying it to an
+    // item that has had fields removed produces something that is not the item — one that a selector
+    // naming a projected-away field no longer matches, so the row would vanish from every other
+    // query until the store answered. An item known only through a projection is therefore treated as
+    // not known at all: the write still happens, it simply is not shown before the store confirms it.
+    static providesFullItems(query) {
+        return query.options?.fields == null;
+    }
+    observableItems(collectionName) {
+        const byId = new Map();
+        this.queries[collectionName]?.forEach((query) => {
+            if (!WorkerDataAdapter.providesFullItems(query))
+                return;
+            query.items.forEach(item => byId.set(item.id, item));
+        });
+        const pending = this.flattenPendingWrites(collectionName);
+        if (pending) {
+            pending.upserts.forEach((item, id) => byId.set(id, item));
+            pending.deletes.forEach(id => byId.delete(id));
+        }
+        return [...byId.values()];
+    }
+    // The same answer as `observableItems` restricted to known ids — for the selector shapes that
+    // name them (`{ id }`, `{ id: { $in } }`), which is what an ordinary `updateOne`/`removeOne`
+    // carries. Costs a handful of map lookups instead of materialising every active query's result
+    // and running the matcher over all of it.
+    observableItemsByIds(collectionName, ids) {
+        const pending = this.flattenPendingWrites(collectionName);
+        const found = new Map();
+        ids.forEach((id) => {
+            if (pending?.deletes.has(id))
+                return;
+            const pendingItem = pending?.upserts.get(id);
+            if (pendingItem) {
+                found.set(id, pendingItem);
+                return;
+            }
+            const queries = this.queries[collectionName];
+            if (!queries)
+                return;
+            for (const query of queries.values()) {
+                if (!WorkerDataAdapter.providesFullItems(query))
+                    continue;
+                const item = this.queryItemsById(query).get(id);
+                if (item) {
+                    found.set(id, item);
+                    return;
+                }
+            }
+        });
+        return [...found.values()];
+    }
+    // Whether any pending write changes what this query would return. Answered against the pending
+    // set (small) and the query's id index, never by walking its items: a query no in-flight write
+    // touches — nearly all of them, nearly always — keeps its own array, so its readers skip both the
+    // merge and the re-filtering that would follow it.
+    // What `getQueryResult` answers: the query's last confirmed result with whatever writes are still
+    // in flight folded into it. Only the items those writes touch are examined — the rest matched
+    // when the store produced them and are carried over untouched, which is both what makes this cost
+    // the size of the pending writes rather than the size of the result, and what keeps a projected
+    // result from being re-matched against fields its projection has already dropped.
+    servedResult(collectionName, query) {
+        const pendingVersion = this.pendingWriteVersions.get(collectionName) ?? 0;
+        if (query.served
+            && query.served.fromItems === query.items
+            && query.served.pendingVersion === pendingVersion) {
+            return query.served.items;
+        }
+        const items = this.computeServedResult(collectionName, query);
+        query.served = { items, fromItems: query.items, pendingVersion };
+        return items;
+    }
+    computeServedResult(collectionName, query) {
+        const pending = this.flattenPendingWrites(collectionName);
+        if (!pending)
+            return query.items;
+        const byId = this.queryItemsById(query);
+        let affected = false;
+        pending.deletes.forEach((id) => {
+            if (byId.has(id))
+                affected = true;
+        });
+        if (!affected) {
+            pending.upserts.forEach((item, id) => {
+                if (affected)
+                    return;
+                if (byId.has(id))
+                    affected = true;
+                else if (query.selector != null && (0, match_1.default)(item, query.selector))
+                    affected = true;
+            });
+        }
+        if (!affected)
+            return query.items;
+        return (0, incrementalQueryUpdate_1.mergeChangesetIntoResult)(query.items, query.selector, query.options, {
+            upserts: [...pending.upserts.values()],
+            deletes: [...pending.deletes],
         });
-        return [...merged.values()];
     }
     /**
      * Registers a write's effect locally and notifies every active query it
@@ -132,6 +376,11 @@ class WorkerDataAdapter {
     applyPendingWrite(collectionName, upserts, deletes) {
         if (upserts.length === 0 && deletes.length === 0)
             return () => { };
+        const affectedIds = new Set([...upserts.map(item => item.id), ...deletes]);
+        const affected = this.affectedQueries(collectionName, upserts, affectedIds);
+        // Captured before the write is registered, so the notification below can say what actually
+        // changed for a reader rather than just that something did.
+        const servedBefore = this.servedResults(collectionName, affected);
         const seq = this.pendingWriteSeq += 1;
         const pending = this.pendingWrites.get(collectionName)
             ?? new Map();
@@ -140,36 +389,70 @@ class WorkerDataAdapter {
             deletes: new Set(deletes),
         });
         this.pendingWrites.set(collectionName, pending);
-        const affectedIds = new Set([...upserts.map(item => item.id), ...deletes]);
-        this.notifyAffectedQueries(collectionName, upserts, affectedIds);
+        this.bumpPendingWriteVersion(collectionName);
+        this.notifyWithDeltas(collectionName, affected, servedBefore);
         return () => {
             const current = this.pendingWrites.get(collectionName);
             if (!current)
                 return;
+            const affectedOnDrop = this.affectedQueries(collectionName, upserts, affectedIds);
+            const beforeDrop = this.servedResults(collectionName, affectedOnDrop);
             current.delete(seq);
             if (current.size === 0)
                 this.pendingWrites.delete(collectionName);
-            this.notifyAffectedQueries(collectionName, upserts, affectedIds);
+            this.bumpPendingWriteVersion(collectionName);
+            // By the time a write settles the host's own answer has usually already landed, so dropping
+            // the optimistic copy changes nothing a reader can see and produces no notification at all.
+            this.notifyWithDeltas(collectionName, affectedOnDrop, beforeDrop);
         };
     }
-    // Re-runs the state-change callbacks of every query whose result the write
-    // can have changed — either because a written item matches its selector, or
-    // because it already held one of the affected items (an update that moves an
-    // item out of a query, or a removal).
-    notifyAffectedQueries(collectionName, upserts, affectedIds) {
+    // The queries whose result the write can have changed — either because a written item matches
+    // their selector, or because they already hold one of the affected items (an update that moves
+    // an item out of a query, or a removal).
+    affectedQueries(collectionName, upserts, affectedIds) {
+        const affected = [];
         this.queries[collectionName]?.forEach((query) => {
-            const wasHolding = query.items.some(item => affectedIds.has(item.id));
+            const byId = this.queryItemsById(query);
+            let wasHolding = false;
+            affectedIds.forEach((id) => {
+                if (byId.has(id))
+                    wasHolding = true;
+            });
             const nowMatches = upserts.some(item => query.selector != null
                 && (0, match_1.default)(item, query.selector));
             if (!wasHolding && !nowMatches)
                 return;
-            query.stateChangeCallbacks.forEach(callback => callback(query.state));
+            affected.push(query);
+        });
+        return affected;
+    }
+    servedResults(collectionName, queries) {
+        return new Map(queries.map(query => [query, this.servedResult(collectionName, query)]));
+    }
+    // Tells each query what changed for someone reading it, and says nothing to a query where the
+    // answer is the same as before. A reader that has to re-run the query to find that out pays for
+    // the whole result to learn nothing.
+    notifyWithDeltas(collectionName, queries, servedBefore) {
+        queries.forEach((query) => {
+            const before = servedBefore.get(query);
+            if (before == null)
+                return;
+            const delta = (0, queryDelta_1.diffQueryResults)(before, this.servedResult(collectionName, query));
+            if ((0, queryDelta_1.isEmptyQueryDelta)(delta))
+                return;
+            query.stateChangeCallbacks.forEach(callback => (0, queryDelta_1.callWithDelta)(callback, query.state, delta));
         });
     }
     matchObservableItems(collectionName, selector, onlyFirst) {
         if (selector == null)
             return [];
-        const matches = this.observableItems(collectionName).filter(item => (0, match_1.default)(item, selector));
+        // `updateOne({ id })` and `removeOne({ id })` are what an application writes most of the time,
+        // and they name exactly the rows they touch — no reason to materialise every active query's
+        // result and run the matcher over all of it to find them.
+        const ids = selectorIds(selector);
+        const matches = ids == null
+            ? this.observableItems(collectionName).filter(item => (0, match_1.default)(item, selector))
+            : this.observableItemsByIds(collectionName, ids);
         return onlyFirst ? matches.slice(0, 1) : matches;
     }
     resolveUpdate(collectionName, selector, modifier, onlyFirst) {
@@ -224,18 +507,22 @@ class WorkerDataAdapter {
             options: query.options,
             state: 'active',
             error: null,
-            items: [],
             stateChangeCallbacks: [],
-            eventHandler: existing?.eventHandler,
             ...existing,
             ...update,
+            // An update that says nothing about the items leaves them alone. A query going back to
+            // `'active'` while it is recomputed is exactly that, and letting it blank the result would
+            // leave every reader of this query with nothing to show until the recomputation lands.
+            ...update.items
+                ? { items: update.items, itemsById: undefined }
+                : { items: existing?.items ?? [] },
         };
         collectionQueries.set(id, newState);
         this.queries[collectionName] = collectionQueries;
     }
     createCollectionBackend(collection, indices) {
         this.queries[collection.name] = new Map();
-        void this.exec('registerCollection', collection.name, indices);
+        this.execInBackground('registerCollection', collection.name, [indices]);
         this.collectionReady.set(collection.name, this.exec('isReady', collection.name));
         this.batchExecutionHelpers.set(collection.name, (0, batchOnNextTick_1.default)(async (method, args) => this.exec(method, collection.name, args)));
         return {
@@ -263,41 +550,24 @@ class WorkerDataAdapter {
             // methods for registering and unregistering queries that will be called from the collection during find/findOne
             registerQuery: (selector, options) => {
                 this.updateQuery(collection.name, { selector, options }, { state: 'active', error: null, items: [] });
-                void this.exec('registerQuery', collection.name, selector, options);
-                const handler = (event) => {
-                    const { type, data, workerId, error } = event.data;
-                    if (type !== 'queryUpdate')
-                        return;
-                    if (data == null)
-                        return;
-                    const { collectionName, selector: responseSelector, options: responseOptions, state, items, } = data;
-                    if (workerId !== this.id)
-                        return;
-                    if (collectionName !== collection.name)
-                        return;
-                    if ((0, queryId_1.default)(responseSelector, responseOptions) !== (0, queryId_1.default)(selector, options))
-                        return;
-                    this.log('queryUpdate', responseSelector, responseOptions, state, data ?? error);
-                    this.updateQuery(collection.name, {
-                        selector: responseSelector,
-                        options: responseOptions,
-                    }, { state, error, items });
+                // A query the worker could not register will never answer. Left as a bare rejection it
+                // would surface as an uncaught error and the cursor would sit on its empty result forever,
+                // indistinguishable from a query with nothing to show; published as an error it reaches
+                // the collection's `query.error` event, which is what that event is for.
+                this.execInBackground('registerQuery', collection.name, [selector, options], (error) => {
                     const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
                     if (!query)
                         return;
-                    query.stateChangeCallbacks.forEach(callback => callback(state));
-                };
-                this.worker.addEventListener('message', handler);
-                this.updateQuery(collection.name, { selector, options }, { eventHandler: handler });
+                    this.updateQuery(collection.name, { selector, options }, { state: 'error', error });
+                    query.stateChangeCallbacks.forEach(callback => callback('error'));
+                });
             },
             unregisterQuery: (selector, options) => {
-                const qid = (0, queryId_1.default)(selector, options);
-                const query = this.queries[collection.name]?.get(qid);
-                if (query?.eventHandler) {
-                    this.worker.removeEventListener('message', query.eventHandler);
-                }
-                this.queries[collection.name]?.delete(qid);
-                void this.exec('unregisterQuery', collection.name, selector, options);
+                this.queries[collection.name]?.delete((0, queryId_1.default)(selector, options));
+                // Nothing holds the query any more, so a failure here has nobody to report to — but it
+                // still must not escape as an uncaught error, which is what a disposed collection would
+                // otherwise produce every time a cursor was cleaned up after it.
+                this.execInBackground('unregisterQuery', collection.name, [selector, options]);
             },
             getQueryState: (selector, options) => {
                 const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
@@ -311,10 +581,7 @@ class WorkerDataAdapter {
                 const query = this.queries[collection.name]?.get((0, queryId_1.default)(selector, options));
                 if (!query)
                     return [];
-                const pending = this.pendingWrites.get(collection.name);
-                if (!pending || pending.size === 0)
-                    return query.items;
-                return (0, applyQueryOptions_1.default)(this.mergePendingWrites(collection.name, query.items), selector, options);
+                return this.servedResult(collection.name, query);
             },
             onQueryStateChange: (selector, options, callback) => {
                 this.updateQuery(collection.name, { selector, options }, {

package/dist/base/core/src/WorkerDataAdapterHost.d.ts

@@ -44,6 +44,8 @@ export default class WorkerDataAdapterHost<T extends BaseItem<I>, I = any> {
     private queryItems;
     private executeQuery;
     private ensureQuery;
+    private setQueryItems;
+    private queryItemIds;
     private emitQueryUpdate;
     private ensureStorageAdapter;
     private checkQueryUpdates;