tinybase 1.3.6 → 2.0.0-beta.2

package/lib/debug/tinybase.js

@@ -15,10 +15,14 @@ const AVG = 'avg';
 const MIN = 'min';
 const MAX = 'max';
 
-const arrayPair = (value) => [value, value];
 const arrayHas = (array, value) => array.includes(value);
+const arrayEvery = (array, cb) => array.every(cb);
+const arrayIsEqual = (array1, array2) =>
+  arrayLength(array1) === arrayLength(array2) &&
+  arrayEvery(array1, (value1, index) => array2[index] === value1);
 const arrayIsSorted = (array, sorter) =>
-  array.every(
+  arrayEvery(
+    array,
     (value, index) => index == 0 || sorter(array[index - 1], value) <= 0,
   );
 const arraySort = (array, sorter) => array.sort(sorter);
@@ -29,9 +33,9 @@ const arrayLength = (array) => array.length;
 const arrayIsEmpty = (array) => arrayLength(array) == 0;
 const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
 const arrayFilter = (array, cb) => array.filter(cb);
-const arrayFromSecond = (ids) => ids.slice(1);
+const arraySlice = (array, start, end) => array.slice(start, end);
 const arrayClear = (array, to) => array.splice(0, to);
-const arrayPush = (array, value) => array.push(value);
+const arrayPush = (array, ...values) => array.push(...values);
 const arrayPop = (array) => array.pop();
 
 const jsonString = (obj) =>
@@ -66,7 +70,6 @@ const collSize = (coll) => coll.size;
 const collSize2 = collSizeN(collSize);
 const collSize3 = collSizeN(collSize2);
 const collSize4 = collSizeN(collSize3);
-const collPairSize = (pair, func = collSize) => func(pair[0]) + func(pair[1]);
 const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
 const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
 const collValues = (coll) => [...(coll?.values() ?? [])];
@@ -75,7 +78,6 @@ const collForEach = (coll, cb) => coll?.forEach(cb);
 const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
 
 const mapNew = (entries) => new Map(entries);
-const mapNewPair = (newFunction = mapNew) => [newFunction(), newFunction()];
 const mapKeys = (map) => [...(map?.keys() ?? [])];
 const mapGet = (map, key) => map?.get(key);
 const mapForEach = (map, cb) =>
@@ -105,6 +107,27 @@ const mapClone = (map, childMapper) => {
   return map2;
 };
 const mapClone2 = (map) => mapClone(map, mapClone);
+const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
+  ifNotUndefined(
+    (ensureLeaf ? mapEnsure : mapGet)(
+      node,
+      path[p],
+      p > arrayLength(path) - 2 ? ensureLeaf : mapNew,
+    ),
+    (nodeOrLeaf) => {
+      if (p > arrayLength(path) - 2) {
+        if (pruneLeaf?.(nodeOrLeaf)) {
+          mapSet(node, path[p]);
+        }
+        return nodeOrLeaf;
+      }
+      const leaf = visitTree(nodeOrLeaf, path, ensureLeaf, pruneLeaf, p + 1);
+      if (collIsEmpty(nodeOrLeaf)) {
+        mapSet(node, path[p]);
+      }
+      return leaf;
+    },
+  );
 
 const setNew = (entries) => new Set(entries);
 const setAdd = (set, value) => set?.add(value);
@@ -123,20 +146,46 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
   const getTableId = (id) => mapGet(tableIds, id);
   const getThing = (id) => mapGet(things, id);
   const setThing = (id, thing) => mapSet(things, id, thing);
-  const removeStoreListeners = (id) =>
-    ifNotUndefined(mapGet(storeListenerIds, id), (listenerIds) => {
-      collForEach(listenerIds, store.delListener);
-      mapSet(storeListenerIds, id);
+  const addStoreListeners = (id, andCall, ...listenerIds) => {
+    const set = mapEnsure(storeListenerIds, id, setNew);
+    arrayForEach(
+      listenerIds,
+      (listenerId) =>
+        setAdd(set, listenerId) && andCall && store.callListener(listenerId),
+    );
+    return listenerIds;
+  };
+  const delStoreListeners = (id, ...listenerIds) =>
+    ifNotUndefined(mapGet(storeListenerIds, id), (allListenerIds) => {
+      arrayForEach(
+        arrayIsEmpty(listenerIds) ? collValues(allListenerIds) : listenerIds,
+        (listenerId) => {
+          store.delListener(listenerId);
+          collDel(allListenerIds, listenerId);
+        },
+      );
+      if (collIsEmpty(allListenerIds)) {
+        mapSet(storeListenerIds, id);
+      }
     });
-  const setDefinition = (id, tableId, onChanged, getRowValue, getSortKey) => {
-    const changedRowValues = mapNew();
-    const changedSortKeys = mapNew();
+  const setDefinition = (id, tableId) => {
     mapSet(tableIds, id, tableId);
     if (!collHas(things, id)) {
       mapSet(things, id, getDefaultThing());
       mapSet(allRowValues, id, mapNew());
       mapSet(allSortKeys, id, mapNew());
     }
+  };
+  const setDefinitionAndListen = (
+    id,
+    tableId,
+    onChanged,
+    getRowValue,
+    getSortKey,
+  ) => {
+    setDefinition(id, tableId);
+    const changedRowValues = mapNew();
+    const changedSortKeys = mapNew();
     const rowValues = mapGet(allRowValues, id);
     const sortKeys = mapGet(allSortKeys, id);
     const processRow = (rowId) => {
@@ -186,16 +235,14 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
       });
     }
     processTable(true);
-    removeStoreListeners(id);
-    mapSet(
-      storeListenerIds,
+    delStoreListeners(id);
+    addStoreListeners(
       id,
-      setNew([
-        store.addRowListener(tableId, null, (_store, _tableId, rowId) =>
-          processRow(rowId),
-        ),
-        store.addTableListener(tableId, () => processTable()),
-      ]),
+      0,
+      store.addRowListener(tableId, null, (_store, _tableId, rowId) =>
+        processRow(rowId),
+      ),
+      store.addTableListener(tableId, () => processTable()),
     );
   };
   const delDefinition = (id) => {
@@ -203,7 +250,7 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
     mapSet(things, id);
     mapSet(allRowValues, id);
     mapSet(allSortKeys, id);
-    removeStoreListeners(id);
+    delStoreListeners(id);
   };
   const destroy = () => mapForEach(storeListenerIds, delDefinition);
   return [
@@ -215,8 +262,11 @@ const getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
     getThing,
     setThing,
     setDefinition,
+    setDefinitionAndListen,
     delDefinition,
     destroy,
+    addStoreListeners,
+    delStoreListeners,
   ];
 };
 const getRowCellFunction = (getRowCell, defaultCellValue) =>
@@ -233,64 +283,51 @@ const getCreateFunction = (getFunction) => {
   };
 };
 
-const addDeepSet = (deepSet, value, ids) =>
-  arrayLength(ids) < 2
-    ? setAdd(
-        arrayIsEmpty(ids) ? deepSet : mapEnsure(deepSet, ids[0], setNew),
-        value,
-      )
-    : addDeepSet(
-        mapEnsure(deepSet, ids[0], mapNew),
-        value,
-        arrayFromSecond(ids),
-      );
-const forDeepSet = (valueDo) => {
-  const deep = (deepIdSet, arg, ...ids) =>
-    ifNotUndefined(deepIdSet, (deepIdSet2) =>
-      arrayIsEmpty(ids)
-        ? valueDo(deepIdSet2, arg)
-        : arrayForEach([ids[0], null], (id) =>
-            deep(mapGet(deepIdSet2, id), arg, ...arrayFromSecond(ids)),
-          ),
-    );
-  return deep;
+const getWildcardedLeaves = (deepIdSet, path = [EMPTY_STRING]) => {
+  const leaves = [];
+  const deep = (node, p) =>
+    p == arrayLength(path)
+      ? arrayPush(leaves, node)
+      : path[p] === null
+      ? collForEach(node, (node2) => deep(node2, p + 1))
+      : arrayForEach([path[p], null], (id) => deep(mapGet(node, id), p + 1));
+  deep(deepIdSet, 0);
+  return leaves;
 };
 const getListenerFunctions = (getThing) => {
   let thing;
   let nextId = 0;
   const listenerPool = [];
   const allListeners = mapNew();
-  const addListener = (listener, deepSet, idOrNulls = []) => {
+  const addListener = (listener, idSetNode, path) => {
     thing ??= getThing();
-    const id = arrayPop(listenerPool) ?? '' + nextId++;
-    mapSet(allListeners, id, [listener, deepSet, idOrNulls]);
-    addDeepSet(deepSet, id, idOrNulls);
+    const id = arrayPop(listenerPool) ?? EMPTY_STRING + nextId++;
+    mapSet(allListeners, id, [listener, idSetNode, path]);
+    setAdd(visitTree(idSetNode, path ?? [EMPTY_STRING], setNew), id);
     return id;
   };
-  const callListeners = (deepSet, ids = [], ...extraArgs) =>
-    forDeepSet(collForEach)(
-      deepSet,
-      (id) =>
-        ifNotUndefined(mapGet(allListeners, id), ([listener]) =>
-          listener(thing, ...ids, ...extraArgs),
-        ),
-      ...ids,
+  const callListeners = (idSetNode, ids, ...extraArgs) =>
+    arrayForEach(getWildcardedLeaves(idSetNode, ids), (set) =>
+      collForEach(set, (id) =>
+        mapGet(allListeners, id)[0](thing, ...(ids ?? []), ...extraArgs),
+      ),
     );
   const delListener = (id) =>
-    ifNotUndefined(
-      mapGet(allListeners, id),
-      ([, deepSet, idOrNulls]) => {
-        forDeepSet(collDel)(deepSet, id, ...idOrNulls);
-        mapSet(allListeners, id);
-        if (arrayLength(listenerPool) < 1e3) {
-          arrayPush(listenerPool, id);
-        }
-        return idOrNulls;
-      },
-      () => [],
-    );
+    ifNotUndefined(mapGet(allListeners, id), ([, idSetNode, idOrNulls]) => {
+      visitTree(idSetNode, idOrNulls ?? [EMPTY_STRING], void 0, (idSet) => {
+        collDel(idSet, id);
+        return collIsEmpty(idSet) ? 1 : 0;
+      });
+      mapSet(allListeners, id);
+      if (arrayLength(listenerPool) < 1e3) {
+        arrayPush(listenerPool, id);
+      }
+      return idOrNulls;
+    });
+  const hasListeners = (idSetNode, ids) =>
+    !arrayEvery(getWildcardedLeaves(idSetNode, ids), isUndefined);
   const callListener = (id, idNullGetters, extraArgsGetter) =>
-    ifNotUndefined(mapGet(allListeners, id), ([listener, , idOrNulls]) => {
+    ifNotUndefined(mapGet(allListeners, id), ([listener, , idOrNulls = []]) => {
       const callWithIds = (...ids) => {
         const index = arrayLength(ids);
         index == arrayLength(idOrNulls)
@@ -303,7 +340,7 @@ const getListenerFunctions = (getThing) => {
       };
       callWithIds();
     });
-  return [addListener, callListeners, delListener, callListener];
+  return [addListener, callListeners, delListener, hasListeners, callListener];
 };
 
 const object = Object;
@@ -319,6 +356,17 @@ const objForEach = (obj, cb) =>
   arrayForEach(object.entries(obj), ([id, value]) => cb(value, id));
 const objIsEmpty = (obj) => arrayIsEmpty(objIds(obj));
 
+const getCellType = (cell) => {
+  const type = getTypeOf(cell);
+  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
+    ? type
+    : void 0;
+};
+const setOrDelCell = (store, tableId, rowId, cellId, cell) =>
+  isUndefined(cell)
+    ? store.delCell(tableId, rowId, cellId, true)
+    : store.setCell(tableId, rowId, cellId, cell);
+
 const createCheckpoints = getCreateFunction((store) => {
   let backwardIdsSize = 100;
   let currentId;
@@ -326,7 +374,7 @@ const createCheckpoints = getCreateFunction((store) => {
   let listening = 1;
   let nextCheckpointId;
   let checkpointsChanged;
-  const checkpointIdsListeners = setNew();
+  const checkpointIdsListeners = mapNew();
   const checkpointListeners = mapNew();
   const [addListener, callListeners, delListenerImpl] = getListenerFunctions(
     () => checkpoints,
@@ -341,9 +389,7 @@ const createCheckpoints = getCreateFunction((store) => {
       collForEach(mapGet(deltas, checkpointId), (table, tableId) =>
         collForEach(table, (row, rowId) =>
           collForEach(row, (oldNew, cellId) =>
-            isUndefined(oldNew[oldOrNew])
-              ? store.delCell(tableId, rowId, cellId, true)
-              : store.setCell(tableId, rowId, cellId, oldNew[oldOrNew]),
+            setOrDelCell(store, tableId, rowId, cellId, oldNew[oldOrNew]),
           ),
         ),
       ),
@@ -393,9 +439,9 @@ const createCheckpoints = getCreateFunction((store) => {
       }
     },
   );
-  const addCheckpointImpl = (label = '') => {
+  const addCheckpointImpl = (label = EMPTY_STRING) => {
     if (isUndefined(currentId)) {
-      currentId = '' + nextCheckpointId++;
+      currentId = EMPTY_STRING + nextCheckpointId++;
       mapSet(deltas, currentId, delta);
       setCheckpoint(currentId, label);
       delta = mapNew();
@@ -493,7 +539,7 @@ const createCheckpoints = getCreateFunction((store) => {
     store.delListener(listenerId);
   };
   const getListenerStats = () => ({
-    checkpointIds: collSize(checkpointIdsListeners),
+    checkpointIds: collSize2(checkpointIdsListeners),
     checkpoint: collSize2(checkpointListeners),
   });
   const checkpoints = {
@@ -532,7 +578,8 @@ const createIndexes = getCreateFunction((store) => {
     getTableId,
     getIndex,
     setIndex,
-    setDefinition,
+    ,
+    setDefinitionAndListen,
     delDefinition,
     destroy,
   ] = getDefinableFunctions(store, mapNew, (value) =>
@@ -553,7 +600,7 @@ const createIndexes = getCreateFunction((store) => {
     const sliceIdArraySorter = isUndefined(sliceIdSorter)
       ? void 0
       : ([id1], [id2]) => sliceIdSorter(id1, id2);
-    setDefinition(
+    setDefinitionAndListen(
       indexId,
       tableId,
       (change, changedSliceIds, changedSortKeys, sliceIds, sortKeys, force) => {
@@ -697,7 +744,7 @@ const createIndexes = getCreateFunction((store) => {
   return objFreeze(indexes);
 });
 
-const aggregators = mapNew([
+const numericAggregators = mapNew([
   [
     AVG,
     [
@@ -737,6 +784,35 @@ const aggregators = mapNew([
     ],
   ],
 ]);
+const getAggregateValue = (
+  aggregateValue,
+  oldLength,
+  newValues,
+  changedValues,
+  aggregators,
+  force = false,
+) => {
+  if (collIsEmpty(newValues)) {
+    return void 0;
+  }
+  const [aggregate, aggregateAdd, aggregateRemove, aggregateReplace] =
+    aggregators;
+  force ||= isUndefined(aggregateValue);
+  collForEach(changedValues, ([oldValue, newValue]) => {
+    if (!force) {
+      aggregateValue = isUndefined(oldValue)
+        ? aggregateAdd?.(aggregateValue, newValue, oldLength++)
+        : isUndefined(newValue)
+        ? aggregateRemove?.(aggregateValue, oldValue, oldLength--)
+        : aggregateReplace?.(aggregateValue, newValue, oldValue, oldLength);
+      force ||= isUndefined(aggregateValue);
+    }
+  });
+  return force
+    ? aggregate(collValues(newValues), collSize(newValues))
+    : aggregateValue;
+};
+
 const createMetrics = getCreateFunction((store) => {
   const metricListeners = mapNew();
   const [
@@ -747,7 +823,8 @@ const createMetrics = getCreateFunction((store) => {
     getTableId,
     getMetric,
     setMetric,
-    setDefinition,
+    ,
+    setDefinitionAndListen,
     delDefinition,
     destroy,
   ] = getDefinableFunctions(store, getUndefined, (value) =>
@@ -771,38 +848,29 @@ const createMetrics = getCreateFunction((store) => {
     aggregateRemove,
     aggregateReplace,
   ) => {
-    const metricAggregators = isFunction(aggregate)
+    const aggregators = isFunction(aggregate)
       ? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]
-      : mapGet(aggregators, aggregate) ?? mapGet(aggregators, SUM);
-    setDefinition(
+      : mapGet(numericAggregators, aggregate) ??
+        mapGet(numericAggregators, SUM);
+    setDefinitionAndListen(
       metricId,
       tableId,
       (change, changedNumbers, _changedSortKeys, numbers, _sortKeys, force) => {
-        let newMetric = getMetric(metricId);
-        let length = collSize(numbers);
-        const [aggregate2, aggregateAdd2, aggregateRemove2, aggregateReplace2] =
-          metricAggregators;
-        force = force || isUndefined(newMetric);
-        collForEach(changedNumbers, ([oldNumber, newNumber]) => {
-          if (!force) {
-            newMetric = isUndefined(oldNumber)
-              ? aggregateAdd2?.(newMetric, newNumber, length++)
-              : isUndefined(newNumber)
-              ? aggregateRemove2?.(newMetric, oldNumber, length--)
-              : aggregateReplace2?.(newMetric, newNumber, oldNumber, length);
-          }
-          force = force || isUndefined(newMetric);
-        });
+        const oldMetric = getMetric(metricId);
+        const oldLength = collSize(numbers);
+        force ||= isUndefined(oldMetric);
         change();
-        if (collIsEmpty(numbers)) {
-          newMetric = void 0;
-        } else if (force) {
-          newMetric = aggregate2(collValues(numbers), collSize(numbers));
-        }
+        let newMetric = getAggregateValue(
+          oldMetric,
+          oldLength,
+          numbers,
+          changedNumbers,
+          aggregators,
+          force,
+        );
         if (!isFiniteNumber(newMetric)) {
           newMetric = void 0;
         }
-        const oldMetric = getMetric(metricId);
         if (newMetric != oldMetric) {
           setMetric(metricId, newMetric);
           callListeners(metricListeners, [metricId], newMetric, oldMetric);
@@ -860,7 +928,7 @@ const createCustomPersister = (
           loads++;
         }
         const body = await getPersisted();
-        if (!isUndefined(body) && body != '') {
+        if (!isUndefined(body) && body != EMPTY_STRING) {
           store.setJson(body);
         } else {
           store.setTables(initialTables);
@@ -1013,6 +1081,591 @@ const createRemotePersister = (
   );
 };
 
+const createQueries = getCreateFunction((store) => {
+  const createStore = store.createStore;
+  const [
+    getStore,
+    getQueryIds,
+    forEachQuery,
+    hasQuery,
+    getTableId,
+    ,
+    ,
+    setDefinition,
+    ,
+    delDefinition,
+    destroy,
+    addStoreListeners,
+    delStoreListeners,
+  ] = getDefinableFunctions(store, () => true, getUndefined);
+  const preStore1 = createStore();
+  const preStore2 = createStore();
+  const resultStore = createStore();
+  const preStoreListenerIds = mapNew();
+  const addPreStoreListener = (preStore, queryId, ...listenerIds) =>
+    arrayForEach(listenerIds, (listenerId) =>
+      setAdd(
+        mapEnsure(
+          mapEnsure(preStoreListenerIds, queryId, mapNew),
+          preStore,
+          setNew,
+        ),
+        listenerId,
+      ),
+    );
+  const cleanPreStores = (queryId) =>
+    arrayForEach([resultStore, preStore2, preStore1], (store2) =>
+      store2.delTable(queryId),
+    );
+  const synchronizeTransactions = (queryId, fromStore, toStore) =>
+    addPreStoreListener(
+      fromStore,
+      queryId,
+      fromStore.addWillFinishTransactionListener(toStore.startTransaction),
+      fromStore.addDidFinishTransactionListener(() =>
+        toStore.finishTransaction(),
+      ),
+    );
+  const setQueryDefinition = (queryId, tableId, build) => {
+    setDefinition(queryId, tableId);
+    cleanPreStores(queryId);
+    let offsetLimit;
+    const selectEntries = [];
+    const joinEntries = [[null, [tableId, null, null, [], mapNew()]]];
+    const wheres = [];
+    const groupEntries = [];
+    const havings = [];
+    const orders = [];
+    const select = (arg1, arg2) => {
+      const selectEntry = isFunction(arg1)
+        ? [arrayLength(selectEntries) + EMPTY_STRING, arg1]
+        : [
+            isUndefined(arg2) ? arg1 : arg2,
+            (getTableCell) => getTableCell(arg1, arg2),
+          ];
+      arrayPush(selectEntries, selectEntry);
+      return {as: (selectedCellId) => (selectEntry[0] = selectedCellId)};
+    };
+    const join = (joinedTableId, arg1, arg2) => {
+      const fromIntermediateJoinedTableId =
+        isUndefined(arg2) || isFunction(arg1) ? null : arg1;
+      const onArg = isUndefined(fromIntermediateJoinedTableId) ? arg1 : arg2;
+      const joinEntry = [
+        joinedTableId,
+        [
+          joinedTableId,
+          fromIntermediateJoinedTableId,
+          isFunction(onArg) ? onArg : (getCell) => getCell(onArg),
+          [],
+          mapNew(),
+        ],
+      ];
+      arrayPush(joinEntries, joinEntry);
+      return {as: (joinedTableId2) => (joinEntry[0] = joinedTableId2)};
+    };
+    const where = (arg1, arg2, arg3) =>
+      arrayPush(
+        wheres,
+        isFunction(arg1)
+          ? arg1
+          : isUndefined(arg3)
+          ? (getTableCell) => getTableCell(arg1) === arg2
+          : (getTableCell) => getTableCell(arg1, arg2) === arg3,
+      );
+    const group = (
+      selectedCellId,
+      aggregate,
+      aggregateAdd,
+      aggregateRemove,
+      aggregateReplace,
+    ) => {
+      const groupEntry = [
+        selectedCellId,
+        [
+          selectedCellId,
+          isFunction(aggregate)
+            ? [aggregate, aggregateAdd, aggregateRemove, aggregateReplace]
+            : mapGet(numericAggregators, aggregate) ?? [
+                (_cells, length) => length,
+              ],
+        ],
+      ];
+      arrayPush(groupEntries, groupEntry);
+      return {as: (groupedCellId) => (groupEntry[0] = groupedCellId)};
+    };
+    const having = (arg1, arg2) =>
+      arrayPush(
+        havings,
+        isFunction(arg1)
+          ? arg1
+          : (getSelectedOrGroupedCell) =>
+              getSelectedOrGroupedCell(arg1) === arg2,
+      );
+    const order = (arg1, descending) =>
+      arrayPush(orders, [
+        isFunction(arg1)
+          ? arg1
+          : (getSelectedOrGroupedCell) => getSelectedOrGroupedCell(arg1) ?? 0,
+        descending,
+      ]);
+    const limit = (arg1, arg2) => {
+      offsetLimit = isUndefined(arg2) ? [0, arg1] : [arg1, arg2];
+    };
+    build({select, join, where, group, having, order, limit});
+    const selects = mapNew(selectEntries);
+    if (collIsEmpty(selects)) {
+      return queries;
+    }
+    const joins = mapNew(joinEntries);
+    mapForEach(joins, (asTableId, [, fromAsTableId]) =>
+      ifNotUndefined(mapGet(joins, fromAsTableId), ({3: toAsTableIds}) =>
+        isUndefined(asTableId) ? 0 : arrayPush(toAsTableIds, asTableId),
+      ),
+    );
+    const groups = mapNew(groupEntries);
+    let selectJoinWhereStore = preStore1;
+    let groupHavingStore = preStore2;
+    if (arrayIsEmpty(orders) && isUndefined(offsetLimit)) {
+      groupHavingStore = resultStore;
+    } else {
+      synchronizeTransactions(queryId, groupHavingStore, resultStore);
+      const groupRowIdSorter = (rowId1, rowId2) => {
+        const sortKeys1 = mapGet(sortKeysByGroupRowId, rowId1) ?? [];
+        const sortKeys2 = mapGet(sortKeysByGroupRowId, rowId2) ?? [];
+        const orderIndex = orders.findIndex(
+          (_order, index) => sortKeys1[index] !== sortKeys2[index],
+        );
+        return orderIndex < 0
+          ? 0
+          : defaultSorter(sortKeys1[orderIndex], sortKeys2[orderIndex]) *
+              (orders[orderIndex][1] ? -1 : 1);
+      };
+      const sortKeysByGroupRowId = mapNew();
+      const sortedGroupRowIds = mapNew();
+      addPreStoreListener(
+        groupHavingStore,
+        queryId,
+        arrayIsEmpty(orders)
+          ? groupHavingStore.addRowIdsListener(queryId, () =>
+              collClear(sortedGroupRowIds),
+            )
+          : groupHavingStore.addRowListener(
+              queryId,
+              null,
+              (_store, _tableId, groupRowId) => {
+                let newSortKeys = null;
+                if (groupHavingStore.hasRow(queryId, groupRowId)) {
+                  const oldSortKeys =
+                    mapGet(sortKeysByGroupRowId, groupRowId) ?? [];
+                  const groupRow = groupHavingStore.getRow(queryId, groupRowId);
+                  const getCell = (getSelectedOrGroupedCell) =>
+                    groupRow[getSelectedOrGroupedCell];
+                  newSortKeys = arrayMap(orders, ([getSortKey]) =>
+                    getSortKey(getCell, groupRowId),
+                  );
+                  if (arrayIsEqual(oldSortKeys, newSortKeys)) {
+                    if (mapGet(sortedGroupRowIds, groupRowId)) {
+                      resultStore.setRow(queryId, groupRowId, groupRow);
+                    }
+                    return;
+                  }
+                }
+                mapSet(sortKeysByGroupRowId, groupRowId, newSortKeys);
+                collClear(sortedGroupRowIds);
+              },
+            ),
+        groupHavingStore.addTableListener(queryId, () => {
+          if (collIsEmpty(sortedGroupRowIds)) {
+            resultStore.delTable(queryId);
+            if (groupHavingStore.hasTable(queryId)) {
+              const groupTable = groupHavingStore.getTable(queryId);
+              arrayForEach(
+                arraySort(objIds(groupTable), groupRowIdSorter),
+                (id) => mapSet(sortedGroupRowIds, id, 0),
+              );
+              arrayForEach(
+                ifNotUndefined(
+                  offsetLimit,
+                  ([offset, limit2]) =>
+                    arraySlice(
+                      mapKeys(sortedGroupRowIds),
+                      offset,
+                      offset + limit2,
+                    ),
+                  () => mapKeys(sortedGroupRowIds),
+                ),
+                (groupRowId) => {
+                  resultStore.setRow(
+                    queryId,
+                    groupRowId,
+                    groupTable[groupRowId],
+                  );
+                  mapSet(sortedGroupRowIds, groupRowId, 1);
+                },
+              );
+            }
+          }
+        }),
+      );
+    }
+    if (collIsEmpty(groups) && arrayIsEmpty(havings)) {
+      selectJoinWhereStore = groupHavingStore;
+    } else {
+      synchronizeTransactions(queryId, selectJoinWhereStore, groupHavingStore);
+      const groupedSelectedCellIds = mapNew();
+      mapForEach(groups, (groupedCellId, [selectedCellId, aggregators]) =>
+        setAdd(mapEnsure(groupedSelectedCellIds, selectedCellId, setNew), [
+          groupedCellId,
+          aggregators,
+        ]),
+      );
+      const groupBySelectedCellIds = setNew();
+      mapForEach(selects, (selectedCellId) =>
+        collHas(groupedSelectedCellIds, selectedCellId)
+          ? 0
+          : setAdd(groupBySelectedCellIds, selectedCellId),
+      );
+      const tree = mapNew();
+      const writeGroupRow = (
+        leaf,
+        changedGroupedSelectedCells,
+        selectedRowId,
+        forceRemove,
+      ) =>
+        ifNotUndefined(
+          leaf,
+          ([selectedCells, selectedRowIds, groupRowId, groupRow]) => {
+            mapForEach(
+              changedGroupedSelectedCells,
+              (selectedCellId, [newCell]) => {
+                const selectedCell = mapEnsure(
+                  selectedCells,
+                  selectedCellId,
+                  mapNew,
+                );
+                const oldLeafCell = mapGet(selectedCell, selectedRowId);
+                const newLeafCell = forceRemove ? void 0 : newCell;
+                if (oldLeafCell !== newLeafCell) {
+                  const oldNewSet = setNew([[oldLeafCell, newLeafCell]]);
+                  const oldLength = collSize(selectedCell);
+                  mapSet(selectedCell, selectedRowId, newLeafCell);
+                  collForEach(
+                    mapGet(groupedSelectedCellIds, selectedCellId),
+                    ([groupedCellId, aggregators]) => {
+                      const aggregateValue = getAggregateValue(
+                        groupRow[groupedCellId],
+                        oldLength,
+                        selectedCell,
+                        oldNewSet,
+                        aggregators,
+                      );
+                      groupRow[groupedCellId] = isUndefined(
+                        getCellType(aggregateValue),
+                      )
+                        ? null
+                        : aggregateValue;
+                    },
+                  );
+                }
+              },
+            );
+            (collIsEmpty(selectedRowIds) ||
+              !arrayEvery(havings, (having2) =>
+                having2((cellId) => groupRow[cellId]),
+              )
+              ? groupHavingStore.delRow
+              : groupHavingStore.setRow)(queryId, groupRowId, groupRow);
+          },
+        );
+      addPreStoreListener(
+        selectJoinWhereStore,
+        queryId,
+        selectJoinWhereStore.addRowListener(
+          queryId,
+          null,
+          (_store, _tableId, selectedRowId, getCellChange) => {
+            const oldPath = [];
+            const newPath = [];
+            const changedGroupedSelectedCells = mapNew();
+            const rowExists = selectJoinWhereStore.hasRow(
+              queryId,
+              selectedRowId,
+            );
+            let changedLeaf = !rowExists;
+            collForEach(groupBySelectedCellIds, (selectedCellId) => {
+              const [changed, oldCell, newCell] = getCellChange(
+                queryId,
+                selectedRowId,
+                selectedCellId,
+              );
+              arrayPush(oldPath, oldCell);
+              arrayPush(newPath, newCell);
+              changedLeaf ||= changed;
+            });
+            mapForEach(groupedSelectedCellIds, (selectedCellId) => {
+              const [changed, , newCell] = getCellChange(
+                queryId,
+                selectedRowId,
+                selectedCellId,
+              );
+              if (changedLeaf || changed) {
+                mapSet(changedGroupedSelectedCells, selectedCellId, [newCell]);
+              }
+            });
+            if (changedLeaf) {
+              writeGroupRow(
+                visitTree(
+                  tree,
+                  oldPath,
+                  void 0,
+                  ([, selectedRowIds, groupRowId]) => {
+                    collDel(selectedRowIds, selectedRowId);
+                    if (collIsEmpty(selectedRowIds)) {
+                      groupHavingStore.delRow(queryId, groupRowId);
+                      return 1;
+                    }
+                  },
+                ),
+                changedGroupedSelectedCells,
+                selectedRowId,
+                1,
+              );
+            }
+            if (rowExists) {
+              writeGroupRow(
+                visitTree(
+                  tree,
+                  newPath,
+                  () => {
+                    const groupRow = {};
+                    collForEach(
+                      groupBySelectedCellIds,
+                      (selectedCellId) =>
+                        (groupRow[selectedCellId] =
+                          selectJoinWhereStore.getCell(
+                            queryId,
+                            selectedRowId,
+                            selectedCellId,
+                          )),
+                    );
+                    return [
+                      mapNew(),
+                      setNew(),
+                      groupHavingStore.addRow(queryId, groupRow, 1),
+                      groupRow,
+                    ];
+                  },
+                  ([, selectedRowIds]) => {
+                    setAdd(selectedRowIds, selectedRowId);
+                  },
+                ),
+                changedGroupedSelectedCells,
+                selectedRowId,
+              );
+            }
+          },
+        ),
+      );
+    }
+    synchronizeTransactions(queryId, store, selectJoinWhereStore);
+    const writeSelectRow = (rootRowId) => {
+      const getTableCell = (arg1, arg2) =>
+        store.getCell(
+          ...(isUndefined(arg2)
+            ? [tableId, rootRowId, arg1]
+            : arg1 === tableId
+            ? [tableId, rootRowId, arg2]
+            : [
+                mapGet(joins, arg1)?.[0],
+                mapGet(mapGet(joins, arg1)?.[4], rootRowId)?.[0],
+                arg2,
+              ]),
+        );
+      selectJoinWhereStore.transaction(() =>
+        arrayEvery(wheres, (where2) => where2(getTableCell))
+          ? mapForEach(selects, (asCellId, tableCellGetter) =>
+              setOrDelCell(
+                selectJoinWhereStore,
+                queryId,
+                rootRowId,
+                asCellId,
+                tableCellGetter(getTableCell, rootRowId),
+              ),
+            )
+          : selectJoinWhereStore.delRow(queryId, rootRowId),
+      );
+    };
+    const listenToTable = (rootRowId, tableId2, rowId, joinedTableIds2) => {
+      const getCell = (cellId) => store.getCell(tableId2, rowId, cellId);
+      arrayForEach(joinedTableIds2, (remoteAsTableId) => {
+        const [realJoinedTableId, , on, nextJoinedTableIds, remoteIdPair] =
+          mapGet(joins, remoteAsTableId);
+        const remoteRowId = on?.(getCell, rootRowId);
+        const [previousRemoteRowId, previousRemoteListenerId] =
+          mapGet(remoteIdPair, rootRowId) ?? [];
+        if (remoteRowId != previousRemoteRowId) {
+          if (!isUndefined(previousRemoteListenerId)) {
+            delStoreListeners(queryId, previousRemoteListenerId);
+          }
+          mapSet(
+            remoteIdPair,
+            rootRowId,
+            isUndefined(remoteRowId)
+              ? null
+              : [
+                  remoteRowId,
+                  ...addStoreListeners(
+                    queryId,
+                    1,
+                    store.addRowListener(realJoinedTableId, remoteRowId, () =>
+                      listenToTable(
+                        rootRowId,
+                        realJoinedTableId,
+                        remoteRowId,
+                        nextJoinedTableIds,
+                      ),
+                    ),
+                  ),
+                ],
+          );
+        }
+      });
+      writeSelectRow(rootRowId);
+    };
+    const {3: joinedTableIds} = mapGet(joins, null);
+    selectJoinWhereStore.transaction(() =>
+      addStoreListeners(
+        queryId,
+        1,
+        store.addRowListener(tableId, null, (_store, _tableId, rootRowId) => {
+          if (store.hasRow(tableId, rootRowId)) {
+            listenToTable(rootRowId, tableId, rootRowId, joinedTableIds);
+          } else {
+            selectJoinWhereStore.delRow(queryId, rootRowId);
+            collForEach(joins, ({4: idsByRootRowId}) =>
+              ifNotUndefined(
+                mapGet(idsByRootRowId, rootRowId),
+                ([, listenerId]) => {
+                  delStoreListeners(queryId, listenerId);
+                  mapSet(idsByRootRowId, rootRowId);
+                },
+              ),
+            );
+          }
+        }),
+      ),
+    );
+    return queries;
+  };
+  const delQueryDefinition = (queryId) => {
+    mapForEach(mapGet(preStoreListenerIds, queryId), (preStore, listenerIds) =>
+      collForEach(listenerIds, (listenerId) =>
+        preStore.delListener(listenerId),
+      ),
+    );
+    cleanPreStores(queryId);
+    delDefinition(queryId);
+    return queries;
+  };
+  const getResultTable = (queryId) => resultStore.getTable(queryId);
+  const getResultRowIds = (queryId) => resultStore.getRowIds(queryId);
+  const getResultSortedRowIds = (queryId, cellId, descending) =>
+    resultStore.getSortedRowIds(queryId, cellId, descending);
+  const getResultRow = (queryId, rowId) => resultStore.getRow(queryId, rowId);
+  const getResultCellIds = (queryId, rowId) =>
+    resultStore.getCellIds(queryId, rowId);
+  const getResultCell = (queryId, rowId, cellId) =>
+    resultStore.getCell(queryId, rowId, cellId);
+  const hasResultTable = (queryId) => resultStore.hasTable(queryId);
+  const hasResultRow = (queryId, rowId) => resultStore.hasRow(queryId, rowId);
+  const hasResultCell = (queryId, rowId, cellId) =>
+    resultStore.hasCell(queryId, rowId, cellId);
+  const forEachResultTable = (tableCallback) =>
+    resultStore.forEachTable(tableCallback);
+  const forEachResultRow = (queryId, rowCallback) =>
+    resultStore.forEachRow(queryId, rowCallback);
+  const forEachResultCell = (queryId, rowId, cellCallback) =>
+    resultStore.forEachCell(queryId, rowId, cellCallback);
+  const addResultTableListener = (queryId, listener) =>
+    resultStore.addTableListener(queryId, (_store, ...args) =>
+      listener(queries, ...args),
+    );
+  const addResultRowIdsListener = (queryId, listener, trackReorder) =>
+    resultStore.addRowIdsListener(
+      queryId,
+      (_store, ...args) => listener(queries, ...args),
+      trackReorder,
+    );
+  const addResultSortedRowIdsListener = (
+    queryId,
+    cellId,
+    descending,
+    listener,
+  ) =>
+    resultStore.addSortedRowIdsListener(
+      queryId,
+      cellId,
+      descending,
+      (_store, ...args) => listener(queries, ...args),
+    );
+  const addResultRowListener = (queryId, rowId, listener) =>
+    resultStore.addRowListener(queryId, rowId, (_store, ...args) =>
+      listener(queries, ...args),
+    );
+  const addResultCellIdsListener = (queryId, rowId, listener) =>
+    resultStore.addCellIdsListener(queryId, rowId, (_store, ...args) =>
+      listener(queries, ...args),
+    );
+  const addResultCellListener = (queryId, rowId, cellId, listener) =>
+    resultStore.addCellListener(queryId, rowId, cellId, (_store, ...args) =>
+      listener(queries, ...args),
+    );
+  const delListener = (listenerId) => {
+    resultStore.delListener(listenerId);
+    return queries;
+  };
+  const getListenerStats = () => {
+    const {
+      tables: _1,
+      tableIds: _2,
+      transaction: _3,
+      ...stats
+    } = resultStore.getListenerStats();
+    return stats;
+  };
+  const queries = {
+    setQueryDefinition,
+    delQueryDefinition,
+    getStore,
+    getQueryIds,
+    forEachQuery,
+    hasQuery,
+    getTableId,
+    getResultTable,
+    getResultRowIds,
+    getResultSortedRowIds,
+    getResultRow,
+    getResultCellIds,
+    getResultCell,
+    hasResultTable,
+    hasResultRow,
+    hasResultCell,
+    forEachResultTable,
+    forEachResultRow,
+    forEachResultCell,
+    addResultTableListener,
+    addResultRowIdsListener,
+    addResultSortedRowIdsListener,
+    addResultRowListener,
+    addResultCellIdsListener,
+    addResultCellListener,
+    delListener,
+    destroy,
+    getListenerStats,
+  };
+  return objFreeze(queries);
+});
+
 const createRelationships = getCreateFunction((store) => {
   const remoteTableIds = mapNew();
   const remoteRowIdListeners = mapNew();
@@ -1026,7 +1679,8 @@ const createRelationships = getCreateFunction((store) => {
     getLocalTableId,
     getRelationship,
     ,
-    setDefinition,
+    ,
+    setDefinitionAndListen,
     delDefinition,
     destroy,
   ] = getDefinableFunctions(
@@ -1073,7 +1727,7 @@ const createRelationships = getCreateFunction((store) => {
     getRemoteRowId2,
   ) => {
     mapSet(remoteTableIds, relationshipId, remoteTableId);
-    setDefinition(
+    setDefinitionAndListen(
       relationshipId,
       localTableId,
       (change, changedRemoteRowIds) => {
@@ -1199,6 +1853,14 @@ const createRelationships = getCreateFunction((store) => {
   return objFreeze(relationships);
 });
 
+const pairNew = (value) => [value, value];
+const pairCollSize2 = (pair, func = collSize2) => func(pair[0]) + func(pair[1]);
+const pairCollIsEmpty = (pair) => pairCollSize2(pair) == 0;
+const pairNewMap = () => [mapNew(), mapNew()];
+const pair2CollSize2 = (pair2, func = collSize2) =>
+  pairCollSize2(pair2[0], func) + pairCollSize2(pair2[1], func);
+const pair2NewMap = () => [pairNewMap(), pairNewMap()];
+
 const transformMap = (map, toBeLikeObject, setId, delId = mapSet) => {
   const idsToDelete = arrayFilter(
     mapKeys(map),
@@ -1210,12 +1872,6 @@ const transformMap = (map, toBeLikeObject, setId, delId = mapSet) => {
   arrayForEach(idsToDelete, (id2) => delId(map, id2));
   return map;
 };
-const getCellType = (cell) => {
-  const type = getTypeOf(cell);
-  return isTypeStringOrBoolean(type) || (type == NUMBER && isFiniteNumber(cell))
-    ? type
-    : void 0;
-};
 const validate = (obj, validateChild, onInvalidObj) => {
   if (isUndefined(obj) || !isObject(obj) || objIsEmpty(obj) || objFrozen(obj)) {
     onInvalidObj?.();
@@ -1228,8 +1884,8 @@ const validate = (obj, validateChild, onInvalidObj) => {
   });
   return !objIsEmpty(obj);
 };
-const idsChanged = (ids, id2, added) =>
-  mapSet(ids, id2, mapGet(ids, id2) == -added ? void 0 : added);
+const idsChanged = (changedIds, id2, added) =>
+  mapSet(changedIds, id2, mapGet(changedIds, id2) == -added ? void 0 : added);
 const createStore = () => {
   let hasSchema;
   let cellsTouched;
@@ -1243,17 +1899,23 @@ const createStore = () => {
   const schemaMap = mapNew();
   const schemaRowCache = mapNew();
   const tablesMap = mapNew();
-  const tablesListeners = mapNewPair(setNew);
-  const tableIdsListeners = mapNewPair(setNew);
-  const tableListeners = mapNewPair();
-  const rowIdsListeners = mapNewPair();
-  const rowListeners = mapNewPair();
-  const cellIdsListeners = mapNewPair();
-  const cellListeners = mapNewPair();
-  const invalidCellListeners = mapNewPair();
-  const finishTransactionListeners = mapNewPair(setNew);
-  const [addListener, callListeners, delListenerImpl, callListenerImpl] =
-    getListenerFunctions(() => store);
+  const tablesListeners = pairNewMap();
+  const tableIdsListeners = pair2NewMap();
+  const tableListeners = pairNewMap();
+  const rowIdsListeners = pair2NewMap();
+  const sortedRowIdsListeners = pairNewMap();
+  const rowListeners = pairNewMap();
+  const cellIdsListeners = pair2NewMap();
+  const cellListeners = pairNewMap();
+  const invalidCellListeners = pairNewMap();
+  const finishTransactionListeners = pairNewMap();
+  const [
+    addListener,
+    callListeners,
+    delListenerImpl,
+    hasListeners,
+    callListenerImpl,
+  ] = getListenerFunctions(() => store);
   const validateSchema = (schema) =>
     validate(schema, (tableSchema) =>
       validate(tableSchema, (cellSchema) => {
@@ -1435,12 +2097,49 @@ const createStore = () => {
     }
   };
   const tableIdsChanged = (tableId, added) =>
-    idsChanged(changedTableIds, tableId, added);
+    idsChanged(
+      collIsEmpty(changedTableIds)
+        ? mapSet(
+            changedTableIds,
+            null,
+            hasListeners(tableIdsListeners[0][1]) ||
+              hasListeners(tableIdsListeners[1][1])
+              ? getTableIds()
+              : 0,
+          )
+        : changedTableIds,
+      tableId,
+      added,
+    );
   const rowIdsChanged = (tableId, rowId, added) =>
-    idsChanged(mapEnsure(changedRowIds, tableId, mapNew), rowId, added);
+    idsChanged(
+      mapEnsure(changedRowIds, tableId, () =>
+        mapNew([
+          [
+            null,
+            hasListeners(rowIdsListeners[0][1], [tableId]) ||
+            hasListeners(rowIdsListeners[1][1], [tableId])
+              ? getRowIds(tableId)
+              : 0,
+          ],
+        ]),
+      ),
+      rowId,
+      added,
+    );
   const cellIdsChanged = (tableId, rowId, cellId, added) =>
     idsChanged(
-      mapEnsure(mapEnsure(changedCellIds, tableId, mapNew), rowId, mapNew),
+      mapEnsure(mapEnsure(changedCellIds, tableId, mapNew), rowId, () =>
+        mapNew([
+          [
+            null,
+            hasListeners(cellIdsListeners[0][1], [tableId, rowId]) ||
+            hasListeners(cellIdsListeners[1][1], [tableId, rowId])
+              ? getCellIds(tableId, rowId)
+              : 0,
+          ],
+        ]),
+      ),
       cellId,
       added,
     );
@@ -1465,7 +2164,7 @@ const createStore = () => {
     ifNotUndefined(
       mapGet(mapGet(mapGet(changedCells, tableId), rowId), cellId),
       ([oldCell, newCell]) => [true, oldCell, newCell],
-      () => [false, ...arrayPair(getCell(tableId, rowId, cellId))],
+      () => [false, ...pairNew(getCell(tableId, rowId, cellId))],
     );
   const callInvalidCellListeners = (mutator) =>
     !collIsEmpty(invalidCells) && !collIsEmpty(invalidCellListeners[mutator])
@@ -1483,17 +2182,36 @@ const createStore = () => {
             ),
         )
       : 0;
+  const callIdsListenersIfChanged = (listeners, changedIds, getIds, ids) => {
+    if (collSize(changedIds) > 1) {
+      callListeners(listeners[0], ids);
+      callListeners(listeners[1], ids);
+      return 1;
+    }
+    if (
+      !collIsEmpty(changedIds) &&
+      mapGet(changedIds, null) != 0 &&
+      !arrayIsEqual(mapGet(changedIds, null), getIds(...(ids ?? [])))
+    ) {
+      callListeners(listeners[1], ids);
+      return 1;
+    }
+  };
   const callListenersForChanges = (mutator) => {
+    const emptySortedRowIdListeners = collIsEmpty(
+      sortedRowIdsListeners[mutator],
+    );
     const emptyIdListeners =
-      collIsEmpty(cellIdsListeners[mutator]) &&
-      collIsEmpty(rowIdsListeners[mutator]) &&
-      collIsEmpty(tableIdsListeners[mutator]);
+      pairCollIsEmpty(cellIdsListeners[mutator]) &&
+      pairCollIsEmpty(rowIdsListeners[mutator]) &&
+      emptySortedRowIdListeners &&
+      pairCollIsEmpty(tableIdsListeners[mutator]);
     const emptyOtherListeners =
       collIsEmpty(cellListeners[mutator]) &&
       collIsEmpty(rowListeners[mutator]) &&
       collIsEmpty(tableListeners[mutator]) &&
       collIsEmpty(tablesListeners[mutator]);
-    if (!(emptyIdListeners && emptyOtherListeners)) {
+    if (!emptyIdListeners || !emptyOtherListeners) {
       const changes = mutator
         ? [
             mapClone(changedTableIds),
@@ -1504,20 +2222,55 @@ const createStore = () => {
         : [changedTableIds, changedRowIds, changedCellIds, changedCells];
       if (!emptyIdListeners) {
         collForEach(changes[2], (rowCellIds, tableId) =>
-          collForEach(rowCellIds, (changedIds, rowId) => {
-            if (!collIsEmpty(changedIds)) {
-              callListeners(cellIdsListeners[mutator], [tableId, rowId]);
-            }
-          }),
+          collForEach(rowCellIds, (changedIds, rowId) =>
+            callIdsListenersIfChanged(
+              cellIdsListeners[mutator],
+              changedIds,
+              getCellIds,
+              [tableId, rowId],
+            ),
+          ),
         );
+        const calledSortableTableIds = setNew();
         collForEach(changes[1], (changedIds, tableId) => {
-          if (!collIsEmpty(changedIds)) {
-            callListeners(rowIdsListeners[mutator], [tableId]);
+          if (
+            callIdsListenersIfChanged(
+              rowIdsListeners[mutator],
+              changedIds,
+              getRowIds,
+              [tableId],
+            ) &&
+            !emptySortedRowIdListeners
+          ) {
+            callListeners(sortedRowIdsListeners[mutator], [tableId, null]);
+            setAdd(calledSortableTableIds, tableId);
           }
         });
-        if (!collIsEmpty(changes[0])) {
-          callListeners(tableIdsListeners[mutator]);
+        if (!emptySortedRowIdListeners) {
+          collForEach(changes[3], (rows, tableId) => {
+            if (!collHas(calledSortableTableIds, tableId)) {
+              const sortableCellIds = setNew();
+              collForEach(rows, (cells) =>
+                collForEach(cells, ([oldCell, newCell], cellId) =>
+                  newCell !== oldCell
+                    ? setAdd(sortableCellIds, cellId)
+                    : collDel(cells, cellId),
+                ),
+              );
+              collForEach(sortableCellIds, (cellId) =>
+                callListeners(sortedRowIdsListeners[mutator], [
+                  tableId,
+                  cellId,
+                ]),
+              );
+            }
+          });
         }
+        callIdsListenersIfChanged(
+          tableIdsListeners[mutator],
+          changes[0],
+          getTableIds,
+        );
       }
       if (!emptyOtherListeners) {
         let tablesChanged;
@@ -1550,7 +2303,7 @@ const createStore = () => {
           }
         });
         if (tablesChanged) {
-          callListeners(tablesListeners[mutator], [], getCellChange);
+          callListeners(tablesListeners[mutator], void 0, getCellChange);
         }
       }
     }
@@ -1565,6 +2318,23 @@ const createStore = () => {
   const getTable = (tableId) =>
     mapToObj(mapGet(tablesMap, id(tableId)), mapToObj);
   const getRowIds = (tableId) => mapKeys(mapGet(tablesMap, id(tableId)));
+  const getSortedRowIds = (tableId, cellId, descending) => {
+    const cells = [];
+    mapForEach(mapGet(tablesMap, id(tableId)), (rowId, row) =>
+      arrayPush(cells, [
+        isUndefined(cellId) ? rowId : mapGet(row, id(cellId)),
+        rowId,
+      ]),
+    );
+    return arrayMap(
+      arraySort(
+        cells,
+        ([cell1], [cell2]) =>
+          defaultSorter(cell1, cell2) * (descending ? -1 : 1),
+      ),
+      ([, rowId]) => rowId,
+    );
+  };
   const getRow = (tableId, rowId) =>
     mapToObj(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)));
   const getCellIds = (tableId, rowId) =>
@@ -1603,17 +2373,16 @@ const createStore = () => {
       tableId,
       rowId,
     );
-  const addRow = (tableId, row) =>
+  const addRow = (tableId, row, forceId) =>
     transaction(() => {
-      let rowId = void 0;
-      if (validateRow(tableId, rowId, row)) {
-        tableId = id(tableId);
-        setValidRow(
-          tableId,
-          getOrCreateTable(tableId),
-          (rowId = getNewRowId(mapGet(tablesMap, tableId))),
-          row,
-        );
+      tableId = id(tableId);
+      const isValidRow = validateRow(tableId, void 0, row);
+      const rowId =
+        isValidRow || forceId
+          ? getNewRowId(mapGet(tablesMap, tableId))
+          : void 0;
+      if (isValidRow) {
+        setValidRow(tableId, getOrCreateTable(tableId), rowId, row);
       }
       return rowId;
     });
@@ -1762,21 +2531,19 @@ const createStore = () => {
           collForEach(changedCells, (table, tableId) =>
             collForEach(table, (row, rowId) =>
               collForEach(row, ([oldCell], cellId) =>
-                isUndefined(oldCell)
-                  ? delCell(tableId, rowId, cellId, true)
-                  : setCell(tableId, rowId, cellId, oldCell),
+                setOrDelCell(store, tableId, rowId, cellId, oldCell),
               ),
             ),
           );
           transactions = -1;
           cellsTouched = false;
         }
-        callListeners(finishTransactionListeners[0], [], cellsTouched);
+        callListeners(finishTransactionListeners[0], void 0, cellsTouched);
         callInvalidCellListeners(0);
         if (cellsTouched) {
           callListenersForChanges(0);
         }
-        callListeners(finishTransactionListeners[1], [], cellsTouched);
+        callListeners(finishTransactionListeners[1], void 0, cellsTouched);
         transactions = 0;
         arrayForEach(
           [
@@ -1810,16 +2577,53 @@ const createStore = () => {
     mapForEach(mapGet(mapGet(tablesMap, id(tableId)), id(rowId)), cellCallback);
   const addTablesListener = (listener, mutator) =>
     addListener(listener, tablesListeners[mutator ? 1 : 0]);
-  const addTableIdsListener = (listener, mutator) =>
-    addListener(listener, tableIdsListeners[mutator ? 1 : 0]);
+  const addTableIdsListener = (listener, trackReorder, mutator) =>
+    addListener(
+      listener,
+      tableIdsListeners[mutator ? 1 : 0][trackReorder ? 1 : 0],
+    );
   const addTableListener = (tableId, listener, mutator) =>
     addListener(listener, tableListeners[mutator ? 1 : 0], [tableId]);
-  const addRowIdsListener = (tableId, listener, mutator) =>
-    addListener(listener, rowIdsListeners[mutator ? 1 : 0], [tableId]);
+  const addRowIdsListener = (tableId, listener, trackReorder, mutator) =>
+    addListener(
+      listener,
+      rowIdsListeners[mutator ? 1 : 0][trackReorder ? 1 : 0],
+      [tableId],
+    );
+  const addSortedRowIdsListener = (
+    tableId,
+    cellId,
+    descending,
+    listener,
+    mutator,
+  ) => {
+    let sortedRowIds = getSortedRowIds(tableId, cellId, descending);
+    return addListener(
+      () => {
+        const newSortedRowIds = getSortedRowIds(tableId, cellId, descending);
+        if (!arrayIsEqual(newSortedRowIds, sortedRowIds)) {
+          sortedRowIds = newSortedRowIds;
+          listener(store, tableId, cellId, descending, sortedRowIds);
+        }
+      },
+      sortedRowIdsListeners[mutator ? 1 : 0],
+      [tableId, cellId],
+    );
+  };
   const addRowListener = (tableId, rowId, listener, mutator) =>
     addListener(listener, rowListeners[mutator ? 1 : 0], [tableId, rowId]);
-  const addCellIdsListener = (tableId, rowId, listener, mutator) =>
-    addListener(listener, cellIdsListeners[mutator ? 1 : 0], [tableId, rowId]);
+  const addCellIdsListener = (
+    tableId,
+    rowId,
+    listener,
+    trackReorder,
+    mutator,
+  ) =>
+    addListener(
+      listener,
+      cellIdsListeners[mutator ? 1 : 0][trackReorder ? 1 : 0],
+      [tableId, rowId],
+    );
   const addCellListener = (tableId, rowId, cellId, listener, mutator) =>
     addListener(listener, cellListeners[mutator ? 1 : 0], [
       tableId,
@@ -1838,7 +2642,7 @@ const createStore = () => {
     addListener(listener, finishTransactionListeners[1]);
   const callListener = (listenerId) => {
     callListenerImpl(listenerId, [getTableIds, getRowIds, getCellIds], (ids) =>
-      isUndefined(ids[2]) ? [] : arrayPair(getCell(...ids)),
+      isUndefined(ids[2]) ? [] : pairNew(getCell(...ids)),
     );
     return store;
   };
@@ -1847,21 +2651,23 @@ const createStore = () => {
     return store;
   };
   const getListenerStats = () => ({
-    tables: collPairSize(tablesListeners),
-    tableIds: collPairSize(tableIdsListeners),
-    table: collPairSize(tableListeners, collSize2),
-    rowIds: collPairSize(rowIdsListeners, collSize2),
-    row: collPairSize(rowListeners, collSize3),
-    cellIds: collPairSize(cellIdsListeners, collSize3),
-    cell: collPairSize(cellListeners, collSize4),
-    invalidCell: collPairSize(invalidCellListeners, collSize4),
-    transaction: collPairSize(finishTransactionListeners),
+    tables: pairCollSize2(tablesListeners),
+    tableIds: pair2CollSize2(tableIdsListeners),
+    table: pairCollSize2(tableListeners),
+    rowIds: pair2CollSize2(rowIdsListeners),
+    sortedRowIds: pairCollSize2(sortedRowIdsListeners),
+    row: pairCollSize2(rowListeners, collSize3),
+    cellIds: pair2CollSize2(cellIdsListeners, collSize3),
+    cell: pairCollSize2(cellListeners, collSize4),
+    invalidCell: pairCollSize2(invalidCellListeners, collSize4),
+    transaction: pairCollSize2(finishTransactionListeners),
   });
   const store = {
     getTables,
     getTableIds,
     getTable,
     getRowIds,
+    getSortedRowIds,
     getRow,
     getCellIds,
     getCell,
@@ -1894,6 +2700,7 @@ const createStore = () => {
     addTableIdsListener,
     addTableListener,
     addRowIdsListener,
+    addSortedRowIdsListener,
     addRowListener,
     addCellIdsListener,
     addCellListener,
@@ -1903,6 +2710,7 @@ const createStore = () => {
     callListener,
     delListener,
     getListenerStats,
+    createStore,
   };
   return objFreeze(store);
 };
@@ -1914,6 +2722,7 @@ export {
   createIndexes,
   createLocalPersister,
   createMetrics,
+  createQueries,
   createRelationships,
   createRemotePersister,
   createSessionPersister,