tinybase 8.2.0 → 8.3.0-beta.1

package/queries/with-schemas/index.js

@@ -36,6 +36,7 @@ const isFiniteNumber = isFinite;
 const isNullish = (thing) => thing == null;
 const isUndefined = (thing) => thing === void 0;
 const isNull = (thing) => thing === null;
+const isTrue = (thing) => thing === true;
 const ifNotNullish = getIfNotFunction(isNullish);
 const ifNotUndefined = getIfNotFunction(isUndefined);
 const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
@@ -49,10 +50,6 @@ const arrayEvery = (array, cb) => array.every(cb);
 const arrayIsEqual = (array1, array2) =>
   size(array1) === size(array2) &&
   arrayEvery(array1, (value1, index) => array2[index] === value1);
-const arrayOrValueEqual = (value1, value2) =>
-  isArray(value1) && isArray(value2)
-    ? arrayIsEqual(value1, value2)
-    : value1 === value2;
 const arrayForEach = (array, cb) => array.forEach(cb);
 const arrayMap = (array, cb) => array.map(cb);
 const arraySum = (array) => arrayReduce(array, (i, j) => i + j, 0);
@@ -60,11 +57,7 @@ const arrayIsEmpty = (array) => size(array) == 0;
 const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
 const arrayPush = (array, ...values) => array.push(...values);
 
-const collSizeN = (collSizer) => (coll) =>
-  arrayReduce(collValues(coll), (total, coll2) => total + collSizer(coll2), 0);
 const collSize = (coll) => coll?.size ?? 0;
-const collSize2 = collSizeN(collSize);
-const collSize3 = collSizeN(collSize2);
 const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
 const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
 const collValues = (coll) => [...(coll?.values() ?? [])];
@@ -90,32 +83,12 @@ const objIds = object.keys;
 const objFreeze = object.freeze;
 const objNew = (entries = []) => object.fromEntries(entries);
 const objGet = (obj, id) => ifNotUndefined(obj, (obj2) => obj2[id]);
-const objToMap = (obj) => new Map(objEntries(obj));
 const objToArray = (obj, cb) =>
   arrayMap(objEntries(obj), ([id, value]) => cb(value, id));
 const objMap = (obj, cb) =>
   objNew(objToArray(obj, (value, id) => [id, cb(value, id)]));
 const objSize = (obj) => size(objIds(obj));
-
-/* istanbul ignore next */
-const objIsEqual = (
-  obj1,
-  obj2,
-  isEqual = (value1, value2) => value1 === value2,
-) => {
-  const entries1 = objEntries(obj1);
-  return (
-    size(entries1) === objSize(obj2) &&
-    arrayEvery(entries1, ([index, value1]) =>
-      isObject(value1)
-        ? /* istanbul ignore next */
-          isObject(obj2[index])
-          ? objIsEqual(obj2[index], value1, isEqual)
-          : false
-        : isEqual(value1, obj2[index]),
-    )
-  );
-};
+const objIsEmpty = (obj) => isObject(obj) && objSize(obj) == 0;
 
 const map = Map;
 const mapNew = (entries) => new map(entries);
@@ -133,18 +106,6 @@ const mapEnsure = (map2, key, getDefaultValue, hadExistingValue) => {
   }
   return mapGet(map2, key);
 };
-const mapToObj = (map2, valueMapper, excludeMapValue, excludeObjValue) => {
-  const obj = {};
-  collForEach(map2, (mapValue, id) => {
-    {
-      const objValue = mapValue;
-      {
-        obj[id] = objValue;
-      }
-    }
-  });
-  return obj;
-};
 const visitTree = (node, path, ensureLeaf, pruneLeaf, p = 0) =>
   ifNotUndefined(
     (ensureLeaf ? mapEnsure : mapGet)(
@@ -282,27 +243,17 @@ const getDefinableFunctions = (
   const getTableId = (id) => mapGet(tableIds, id);
   const getThing = (id) => mapGet(things, id);
   const setThing = (id, thing) => mapSet(things, id, thing);
-  const addStoreListeners = (id, andCall, ...listenerIds) => {
+  const addStoreListeners = (id, ...listenerIds) => {
     const set = mapEnsure(storeListenerIds, id, setNew);
-    arrayForEach(
-      listenerIds,
-      (listenerId) =>
-        setAdd(set, listenerId) && andCall && store.callListener(listenerId),
-    );
-    return listenerIds;
+    arrayForEach(listenerIds, (listenerId) => setAdd(set, listenerId));
   };
-  const delStoreListeners = (id, ...listenerIds) =>
+  const delStoreListeners = (id) =>
     ifNotUndefined(mapGet(storeListenerIds, id), (allListenerIds) => {
-      arrayForEach(
-        arrayIsEmpty(listenerIds) ? collValues(allListenerIds) : listenerIds,
-        (listenerId) => {
-          store.delListener(listenerId);
-          collDel(allListenerIds, listenerId);
-        },
-      );
-      if (collIsEmpty(allListenerIds)) {
-        mapSet(storeListenerIds, id);
-      }
+      arrayForEach(collValues(allListenerIds), (listenerId) => {
+        store.delListener(listenerId);
+        collDel(allListenerIds, listenerId);
+      });
+      mapSet(storeListenerIds, id);
     });
   const setDefinition = (id, tableId) => {
     mapSet(tableIds, id, tableId);
@@ -382,7 +333,6 @@ const getDefinableFunctions = (
     delStoreListeners(id);
     addStoreListeners(
       id,
-      0,
       store.addRowListener(tableId, null, (_store, _tableId, rowId) =>
         processRow(rowId),
       ),
@@ -413,8 +363,6 @@ const getDefinableFunctions = (
     delDefinition,
     addThingIdsListener,
     destroy,
-    addStoreListeners,
-    delStoreListeners,
   ];
 };
 const getCreateFunction = (getFunction, initFunction) => {
@@ -428,13 +376,29 @@ const getCreateFunction = (getFunction, initFunction) => {
   };
 };
 
+const PARAMS_TABLE = '_';
+const PARAM_LISTENER_PREFIX = 'p';
 const createQueries = getCreateFunction((store) => {
   const createStore = store._[0];
   const preStore = createStore();
+  const paramStore = createStore();
   const resultStore = createStore();
+  const resultStores = mapNew();
+  const redefiningQueryIds = setNew();
+  const routedResultListeners = mapNew();
+  const routedResultListenerIds = mapNew();
+  const resultListenerStats = {
+    table: 0,
+    tableCellIds: 0,
+    rowCount: 0,
+    rowIds: 0,
+    sortedRowIds: 0,
+    row: 0,
+    cellIds: 0,
+    cell: 0,
+  };
   const preStoreListenerIds = mapNew();
-  const paramValuesListeners = mapNew();
-  const paramValueListeners = mapNew();
+  const sourceStoreListenerIds = mapNew();
   const {
     _: [, addListener, callListeners],
     delListener: delListenerImpl,
@@ -451,9 +415,7 @@ const createQueries = getCreateFunction((store) => {
     ,
     delDefinition,
     addQueryIdsListenerImpl,
-    destroy,
-    addStoreListeners,
-    delStoreListeners,
+    destroyImpl,
   ] = getDefinableFunctions(
     store,
     () => [],
@@ -461,6 +423,8 @@ const createQueries = getCreateFunction((store) => {
     addListener,
     callListeners,
   );
+  const getResultStore = (queryId) =>
+    mapEnsure(resultStores, queryId, createStore);
   const addPreStoreListener = (preStore2, queryId, ...listenerIds) =>
     arrayForEach(listenerIds, (listenerId) =>
       setAdd(
@@ -484,8 +448,49 @@ const createQueries = getCreateFunction((store) => {
         collClear(queryPreStoreListenerIds);
       },
     );
-    arrayForEach([resultStore, preStore], (store2) => store2.delTable(queryId));
+    arrayForEach([getResultStore(queryId), preStore], (store2) =>
+      store2.delTable(queryId),
+    );
   };
+  const addSourceStoreListeners = (
+    sourceStore,
+    queryId,
+    andCall,
+    ...listenerIds
+  ) => {
+    const listenerIdSet = mapEnsure(
+      mapEnsure(sourceStoreListenerIds, queryId, mapNew),
+      sourceStore,
+      setNew,
+    );
+    arrayForEach(listenerIds, (listenerId) => {
+      setAdd(listenerIdSet, listenerId);
+      if (andCall) {
+        sourceStore.callListener(listenerId);
+      }
+    });
+    return listenerIds;
+  };
+  const delSourceStoreListeners = (queryId, sourceStore, listenerId) =>
+    ifNotUndefined(
+      mapGet(mapGet(sourceStoreListenerIds, queryId), sourceStore),
+      (allListenerIds) => {
+        sourceStore.delListener(listenerId);
+        collDel(allListenerIds, listenerId);
+        if (collIsEmpty(allListenerIds)) {
+          mapSet(mapGet(sourceStoreListenerIds, queryId), sourceStore);
+        }
+      },
+    );
+  const resetSourceStores = (queryId) =>
+    ifNotUndefined(mapGet(sourceStoreListenerIds, queryId), (queryStoreIds) => {
+      mapForEach(queryStoreIds, (sourceStore, listenerIds) =>
+        collForEach(listenerIds, (listenerId) =>
+          sourceStore.delListener(listenerId),
+        ),
+      );
+      collClear(queryStoreIds);
+    });
   const synchronizeTransactions = (queryId, fromStore, toStore) =>
     addPreStoreListener(
       fromStore,
@@ -495,424 +500,549 @@ const createQueries = getCreateFunction((store) => {
         toStore.finishTransaction(),
       ),
     );
-  const setQueryDefinition = (queryId, tableId, build, paramValues = {}) => {
-    const oldParamValues = getParamValues(queryId);
-    setDefinition(queryId, tableId);
-    setQueryArgs(queryId, [build, objToMap(paramValues)]);
-    callParamListeners(queryId, oldParamValues, paramValues);
-    resetPreStores(queryId);
-    const [, paramsMap] = getQueryArgs(queryId);
-    const selectEntries = [];
-    const joinEntries = [[void 0, [tableId, void 0, void 0, [], mapNew()]]];
-    const wheres = [];
-    const groupEntries = [];
-    const havings = [];
-    const param = (paramId) => mapGet(paramsMap, paramId);
-    const select = (arg1, arg2) => {
-      const selectEntry = isFunction(arg1)
-        ? [size(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) ? void 0 : 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,
-      );
-    build({select, join, where, group, having, param});
-    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 setOrDelParamValues = (queryId, paramValues) =>
+    (objIsEmpty(paramValues) ? paramStore.delRow : paramStore.setRow)(
+      PARAMS_TABLE,
+      queryId,
+      {...paramValues},
     );
-    const groups = mapNew(groupEntries);
-    let selectJoinWhereStore = preStore;
-    if (collIsEmpty(groups) && arrayIsEmpty(havings)) {
-      selectJoinWhereStore = resultStore;
-    } else {
-      synchronizeTransactions(queryId, selectJoinWhereStore, resultStore);
-      const groupedSelectedCellIds = mapNew();
-      mapForEach(groups, (groupedCellId, [selectedCellId, aggregators]) =>
-        setAdd(mapEnsure(groupedSelectedCellIds, selectedCellId, setNew), [
-          groupedCellId,
-          aggregators,
-        ]),
+  const addRoutedResultListener = (stat, queryId, addStoreListener) => {
+    const listenerId = addListener(getUndefined, routedResultListenerIds);
+    const storeListenerIds = mapNew();
+    const syncStoreListeners = () => {
+      const queryIds = queryId == null ? getQueryIds() : [queryId];
+      arrayForEach(queryIds, (queryId2) =>
+        collHas(storeListenerIds, queryId2)
+          ? 0
+          : mapSet(storeListenerIds, queryId2, [
+              getResultStore(queryId2),
+              addStoreListener(getResultStore(queryId2), queryId2),
+            ]),
       );
-      const groupBySelectedCellIds = setNew();
-      mapForEach(selects, (selectedCellId) =>
-        collHas(groupedSelectedCellIds, selectedCellId)
+      mapForEach(storeListenerIds, (storeQueryId, [store2, storeListenerId]) =>
+        (queryId == null && hasQuery(storeQueryId)) || storeQueryId == queryId
           ? 0
-          : setAdd(groupBySelectedCellIds, selectedCellId),
+          : (() => {
+              store2.delListener(storeListenerId);
+              mapSet(storeListenerIds, storeQueryId);
+            })(),
       );
-      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,
+    };
+    syncStoreListeners();
+    mapSet(routedResultListeners, listenerId, [
+      stat,
+      storeListenerIds,
+      queryId == null ? addQueryIdsListenerImpl(syncStoreListeners) : void 0,
+    ]);
+    resultListenerStats[stat]++;
+    return listenerId;
+  };
+  const setQueryDefinition = (
+    queryId,
+    tableIdOrAsQuery,
+    tableIdOrBuild,
+    buildOrParamValues,
+    paramValuesIfSourceIsQuery = {},
+  ) => {
+    const [tableId, build, sourceIsQuery, paramValues] = isTrue(
+      tableIdOrAsQuery,
+    )
+      ? [tableIdOrBuild, buildOrParamValues, 1, paramValuesIfSourceIsQuery]
+      : [tableIdOrAsQuery, tableIdOrBuild, 0, buildOrParamValues ?? {}];
+    ifNotUndefined(getQueryArgs(queryId), ([, listenerId]) =>
+      paramStore.delListener(listenerId),
+    );
+    setDefinition(queryId, tableId);
+    setQueryArgs(queryId, [
+      build,
+      paramStore.addRowListener(PARAMS_TABLE, queryId, () =>
+        setQueryDefinitionImpl(queryId),
+      ),
+      sourceIsQuery,
+    ]);
+    setOrDelParamValues(queryId, paramValues);
+    setQueryDefinitionImpl(queryId);
+    return queries;
+  };
+  const setQueryDefinitionImpl = (queryId) =>
+    getResultStore(queryId).transaction(() =>
+      ifNotUndefined(getQueryArgs(queryId), ([build, , sourceIsQuery]) => {
+        const tableId = getTableId(queryId);
+        const rootStore = sourceIsQuery ? getResultStore(tableId) : store;
+        const resultStore2 = getResultStore(queryId);
+        const paramValues = getParamValues(queryId);
+        setAdd(redefiningQueryIds, queryId);
+        resetPreStores(queryId);
+        resetSourceStores(queryId);
+        const selectEntries = [];
+        const joinEntries = [
+          [void 0, [tableId, void 0, void 0, [], mapNew(), rootStore]],
+        ];
+        const wheres = [];
+        const groupEntries = [];
+        const havings = [];
+        const param = (paramId) => objGet(paramValues, paramId);
+        const select = (arg1, arg2, arg3) => {
+          const joinedTableId = isTrue(arg1) ? arg2 : arg1;
+          const joinedCellId = isTrue(arg1) ? arg3 : arg2;
+          const selectEntry = isFunction(arg1)
+            ? [size(selectEntries) + EMPTY_STRING, arg1]
+            : isUndefined(joinedCellId)
+              ? [arg1, (getTableCell) => getTableCell(arg1)]
+              : [
+                  joinedCellId,
+                  (getTableCell) =>
+                    isTrue(arg1)
+                      ? getTableCell(true, joinedTableId, joinedCellId)
+                      : getTableCell(joinedTableId, joinedCellId),
+                ];
+          arrayPush(selectEntries, selectEntry);
+          return {
+            as: (selectedCellId) => (selectEntry[0] = selectedCellId),
+          };
+        };
+        const join = (arg1, arg2, arg3, arg4) => {
+          const joinedTableId = isTrue(arg1) ? arg2 : arg1;
+          const [fromJoinAlias, onArg] = isTrue(arg1)
+            ? isUndefined(arg4) || isFunction(arg3)
+              ? [void 0, arg3]
+              : [arg3, arg4]
+            : isUndefined(arg3) || isFunction(arg2)
+              ? [void 0, arg2]
+              : [arg2, arg3];
+          const joinEntry = [
+            joinedTableId,
+            [
+              joinedTableId,
+              fromJoinAlias,
+              isFunction(onArg) ? onArg : (getCell) => getCell(onArg),
+              [],
+              mapNew(),
+              isTrue(arg1) ? getResultStore(joinedTableId) : store,
+            ],
+          ];
+          arrayPush(joinEntries, joinEntry);
+          return {as: (joinedTableId2) => (joinEntry[0] = joinedTableId2)};
+        };
+        const where = (arg1, arg2, arg3, arg4) =>
+          arrayPush(
+            wheres,
+            isFunction(arg1)
+              ? arg1
+              : isTrue(arg1)
+                ? (getTableCell) => getTableCell(true, arg2, arg3) === arg4
+                : 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,
+          );
+        build({select, join, where, group, having, param});
+        const selects = mapNew(selectEntries);
+        if (collIsEmpty(selects)) {
+          collDel(redefiningQueryIds, queryId);
+          return queries;
+        }
+        const joins = mapNew(joinEntries);
+        mapForEach(joins, (joinAlias, [, fromJoinAlias]) =>
+          ifNotUndefined(mapGet(joins, fromJoinAlias), ({3: toJoinAliases2}) =>
+            isUndefined(joinAlias) ? 0 : arrayPush(toJoinAliases2, joinAlias),
+          ),
+        );
+        const groups = mapNew(groupEntries);
+        let selectJoinWhereStore = preStore;
+        if (collIsEmpty(groups) && arrayIsEmpty(havings)) {
+          selectJoinWhereStore = resultStore2;
+        } else {
+          synchronizeTransactions(queryId, selectJoinWhereStore, resultStore2);
+          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(
+                            getCellOrValueType(aggregateValue),
+                          )
+                            ? void 0
+                            : aggregateValue;
+                        },
                       );
-                      groupRow[groupedCellId] = isUndefined(
-                        getCellOrValueType(aggregateValue),
-                      )
-                        ? void 0
-                        : aggregateValue;
-                    },
-                  );
+                    }
+                  },
+                );
+                if (
+                  collIsEmpty(selectedRowIds) ||
+                  !arrayEvery(havings, (having2) =>
+                    having2((cellId) => groupRow[cellId]),
+                  )
+                ) {
+                  resultStore2.delRow(queryId, groupRowId);
+                } else if (isUndefined(groupRowId)) {
+                  leaf[2] = resultStore2.addRow(queryId, groupRow);
+                } else {
+                  resultStore2.setRow(queryId, groupRowId, groupRow);
                 }
               },
             );
-            if (
-              collIsEmpty(selectedRowIds) ||
-              !arrayEvery(havings, (having2) =>
-                having2((cellId) => groupRow[cellId]),
-              )
-            ) {
-              resultStore.delRow(queryId, groupRowId);
-            } else if (isUndefined(groupRowId)) {
-              leaf[2] = resultStore.addRow(queryId, groupRow);
-            } else {
-              resultStore.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(
+          addPreStoreListener(
+            selectJoinWhereStore,
+            queryId,
+            selectJoinWhereStore.addRowListener(
               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]) => {
-                  collDel(selectedRowIds, selectedRowId);
-                  return collIsEmpty(selectedRowIds);
-                }),
-                changedGroupedSelectedCells,
-                selectedRowId,
-                1,
-              );
+              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]) => {
+                      collDel(selectedRowIds, selectedRowId);
+                      return collIsEmpty(selectedRowIds);
+                    }),
+                    changedGroupedSelectedCells,
+                    selectedRowId,
+                    1,
+                  );
+                }
+                if (rowExists) {
+                  writeGroupRow(
+                    visitTree(
+                      tree,
+                      newPath,
+                      () => {
+                        const groupRow = {};
+                        collForEach(
+                          groupBySelectedCellIds,
+                          (selectedCellId) =>
+                            (groupRow[selectedCellId] =
+                              selectJoinWhereStore.getCell(
+                                queryId,
+                                selectedRowId,
+                                selectedCellId,
+                              )),
+                        );
+                        return [mapNew(), setNew(), void 0, groupRow];
+                      },
+                      ([, selectedRowIds]) => {
+                        setAdd(selectedRowIds, selectedRowId);
+                      },
+                    ),
+                    changedGroupedSelectedCells,
+                    selectedRowId,
+                  );
+                }
+              },
+            ),
+          );
+        }
+        synchronizeTransactions(queryId, rootStore, selectJoinWhereStore);
+        const writeSelectRow = (rootRowId) => {
+          const getJoinCell = (arg1, arg2, arg3) => {
+            const joinedTableId = isTrue(arg1) ? arg2 : arg1;
+            const joinedCellId = isTrue(arg1) ? arg3 : arg2;
+            if (isUndefined(joinedCellId)) {
+              return rootStore.getCell(tableId, rootRowId, arg1);
             }
-            if (rowExists) {
-              writeGroupRow(
-                visitTree(
-                  tree,
-                  newPath,
-                  () => {
-                    const groupRow = {};
-                    collForEach(
-                      groupBySelectedCellIds,
-                      (selectedCellId) =>
-                        (groupRow[selectedCellId] =
-                          selectJoinWhereStore.getCell(
-                            queryId,
-                            selectedRowId,
-                            selectedCellId,
-                          )),
-                    );
-                    return [mapNew(), setNew(), void 0, groupRow];
-                  },
-                  ([, selectedRowIds]) => {
-                    setAdd(selectedRowIds, selectedRowId);
-                  },
-                ),
-                changedGroupedSelectedCells,
-                selectedRowId,
-              );
+            if (joinedTableId === tableId && !isTrue(arg1)) {
+              return rootStore.getCell(tableId, rootRowId, joinedCellId);
             }
-          },
-        ),
-      );
-    }
-    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) =>
-              selectJoinWhereStore._[5](
-                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, remoteIdPairs] =
-          mapGet(joins, remoteAsTableId);
-        const remoteRowId = on?.(getCell, rootRowId);
-        const [previousRemoteRowId, previousRemoteListenerId] =
-          mapGet(remoteIdPairs, rootRowId) ?? [];
-        if (remoteRowId != previousRemoteRowId) {
-          if (!isUndefined(previousRemoteListenerId)) {
-            delStoreListeners(queryId, previousRemoteListenerId);
-          }
-          mapSet(
-            remoteIdPairs,
-            rootRowId,
-            isUndefined(remoteRowId)
+            const join2 = mapGet(joins, joinedTableId);
+            return isUndefined(join2)
               ? void 0
-              : [
-                  remoteRowId,
-                  ...addStoreListeners(
+              : join2[5].getCell(
+                  join2[0],
+                  mapGet(join2[4], rootRowId)?.[0],
+                  joinedCellId,
+                );
+          };
+          selectJoinWhereStore.transaction(() =>
+            arrayEvery(wheres, (where2) => where2(getJoinCell))
+              ? mapForEach(selects, (asCellId, tableCellGetter) =>
+                  selectJoinWhereStore._[5](
                     queryId,
-                    1,
-                    store.addRowListener(realJoinedTableId, remoteRowId, () =>
-                      listenToTable(
-                        rootRowId,
-                        realJoinedTableId,
-                        remoteRowId,
-                        nextJoinedTableIds,
-                      ),
-                    ),
+                    rootRowId,
+                    asCellId,
+                    tableCellGetter(getJoinCell, rootRowId),
                   ),
-                ],
+                )
+              : selectJoinWhereStore.delRow(queryId, rootRowId),
           );
-        }
-      });
-      writeSelectRow(rootRowId);
-    };
-    const {3: joinedTableIds} = mapGet(joins, void 0);
-    selectJoinWhereStore.transaction(() =>
-      addStoreListeners(
-        queryId,
-        1,
-        store.addRowListener(tableId, null, (_store, _tableId, rootRowId) => {
-          if (store.hasRow(tableId, rootRowId)) {
-            listenToTable(rootRowId, tableId, rootRowId, joinedTableIds);
+        };
+        const listenToTable = (
+          rootRowId,
+          sourceStore,
+          tableId2,
+          rowId,
+          toJoinAliases2,
+        ) => {
+          const getCell = (cellId) =>
+            sourceStore.getCell(tableId2, rowId, cellId);
+          arrayForEach(toJoinAliases2, (joinAlias) => {
+            const [
+              realJoinedTableId,
+              ,
+              on,
+              nextJoinAliases,
+              remoteIdPairs,
+              remoteSourceStore,
+            ] = mapGet(joins, joinAlias);
+            const remoteRowId = on?.(getCell, rootRowId);
+            const previousRemote = mapGet(remoteIdPairs, rootRowId);
+            const previousRemoteRowId = previousRemote?.[0];
+            if (remoteRowId != previousRemoteRowId) {
+              ifNotUndefined(
+                previousRemote,
+                ([, previousRemoteSourceStore, previousRemoteListenerId]) =>
+                  delSourceStoreListeners(
+                    queryId,
+                    previousRemoteSourceStore,
+                    previousRemoteListenerId,
+                  ),
+              );
+              mapSet(
+                remoteIdPairs,
+                rootRowId,
+                isUndefined(remoteRowId)
+                  ? void 0
+                  : [
+                      remoteRowId,
+                      remoteSourceStore,
+                      ...addSourceStoreListeners(
+                        remoteSourceStore,
+                        queryId,
+                        1,
+                        remoteSourceStore.addRowListener(
+                          realJoinedTableId,
+                          remoteRowId,
+                          () =>
+                            listenToTable(
+                              rootRowId,
+                              remoteSourceStore,
+                              realJoinedTableId,
+                              remoteRowId,
+                              nextJoinAliases,
+                            ),
+                        ),
+                      ),
+                    ],
+              );
+            }
+          });
+          writeSelectRow(rootRowId);
+        };
+        const {3: toJoinAliases} = mapGet(joins, void 0);
+        const rootRowChanged = (sourceStore, _tableId, rootRowId) => {
+          if (rootStore.hasRow(tableId, rootRowId)) {
+            listenToTable(
+              rootRowId,
+              rootStore,
+              tableId,
+              rootRowId,
+              toJoinAliases,
+            );
           } else {
             selectJoinWhereStore.delRow(queryId, rootRowId);
             collForEach(joins, ({4: idsByRootRowId}) =>
               ifNotUndefined(
                 mapGet(idsByRootRowId, rootRowId),
-                ([, listenerId]) => {
-                  delStoreListeners(queryId, listenerId);
+                ([, sourceStore2, listenerId]) => {
+                  delSourceStoreListeners(queryId, sourceStore2, listenerId);
                   mapSet(idsByRootRowId, rootRowId);
                 },
               ),
             );
           }
-        }),
-      ),
+        };
+        selectJoinWhereStore.transaction(() => {
+          arrayForEach(rootStore.getRowIds(tableId), (rootRowId) =>
+            rootRowChanged(rootStore, tableId, rootRowId),
+          );
+          addSourceStoreListeners(
+            rootStore,
+            queryId,
+            0,
+            rootStore.addRowListener(tableId, null, rootRowChanged),
+          );
+        });
+        collDel(redefiningQueryIds, queryId);
+        return queries;
+      }),
     );
-    return queries;
-  };
-  const callParamListeners = (queryId, oldParamValues, newParamValues) => {
-    const allParamIds = setNew([
-      ...objIds(oldParamValues),
-      ...objIds(newParamValues),
-    ]);
-    let changed = 0;
-    collForEach(allParamIds, (paramId) => {
-      const newParamValue = objGet(newParamValues, paramId);
-      if (!arrayOrValueEqual(objGet(oldParamValues, paramId), newParamValue)) {
-        changed = 1;
-        callListeners(paramValueListeners, [queryId, paramId], newParamValue);
-      }
-    });
-    if (changed) {
-      callListeners(paramValuesListeners, [queryId], newParamValues);
-    }
-  };
   const delQueryDefinition = (queryId) => {
-    const oldParamValues = getParamValues(queryId);
+    ifNotUndefined(getQueryArgs(queryId), ([, listenerId]) =>
+      paramStore.delListener(listenerId),
+    );
+    paramStore.delRow(PARAMS_TABLE, queryId);
     resetPreStores(queryId);
+    resetSourceStores(queryId);
     delDefinition(queryId);
-    callParamListeners(queryId, oldParamValues, {});
     return queries;
   };
-  const setParamValues = (queryId, paramValues, force = 0) => {
-    ifNotUndefined(getQueryArgs(queryId), ([definition, oldParamValues]) => {
-      if (
-        force ||
-        !objIsEqual(mapToObj(oldParamValues), paramValues, arrayOrValueEqual)
-      ) {
-        resultStore.transaction(() =>
-          setQueryDefinition(
-            queryId,
-            getTableId(queryId),
-            definition,
-            paramValues,
-          ),
-        );
-      }
-    });
+  const setParamValues = (queryId, paramValues) => {
+    if (hasQuery(queryId)) {
+      setOrDelParamValues(queryId, paramValues);
+    }
     return queries;
   };
   const setParamValue = (queryId, paramId, value) => {
-    if (!arrayOrValueEqual(getParamValue(queryId, paramId), value)) {
-      setParamValues(
-        queryId,
-        {...getParamValues(queryId), [paramId]: value},
-        1,
-      );
+    if (hasQuery(queryId)) {
+      paramStore.setCell(PARAMS_TABLE, queryId, paramId, value);
     }
     return queries;
   };
-  const getParamValues = (queryId) => mapToObj(getQueryArgs(queryId)?.[1]);
+  const getParamValues = (queryId) => paramStore.getRow(PARAMS_TABLE, queryId);
   const getParamValue = (queryId, paramId) =>
-    mapGet(getQueryArgs(queryId)?.[1], paramId);
+    paramStore.getCell(PARAMS_TABLE, queryId, paramId);
   const addQueryIdsListener = (listener) =>
     addQueryIdsListenerImpl(() => listener(queries));
+  const forEachResultTable = (tableCallback) =>
+    forEachQuery((queryId) =>
+      getResultStore(queryId).hasTable(queryId)
+        ? tableCallback(queryId, (rowCallback) =>
+            queries.forEachResultRow(queryId, rowCallback),
+          )
+        : 0,
+    );
   const addParamValuesListener = (queryId, listener) =>
-    addListener(
-      (_, queryId2, paramValues) => listener(queries, queryId2, paramValues),
-      paramValuesListeners,
-      [queryId],
+    PARAM_LISTENER_PREFIX +
+    paramStore.addRowListener(
+      PARAMS_TABLE,
+      queryId,
+      (_store, _tableId, queryId2) =>
+        listener(queries, queryId2, getParamValues(queryId2)),
     );
   const addParamValueListener = (queryId, paramId, listener) =>
-    addListener(
-      (_, queryId2, paramId2, paramValue) =>
+    PARAM_LISTENER_PREFIX +
+    paramStore.addCellListener(
+      PARAMS_TABLE,
+      queryId,
+      paramId,
+      (_store, _tableId, queryId2, paramId2, paramValue) =>
         listener(queries, queryId2, paramId2, paramValue),
-      paramValueListeners,
-      [queryId, paramId],
     );
   const delListener = (listenerId) => {
-    delListenerImpl(listenerId);
+    const routedResultListener = mapGet(routedResultListeners, listenerId);
+    if (listenerId[0] == PARAM_LISTENER_PREFIX) {
+      paramStore.delListener(slice(listenerId, 1));
+    } else if (!isUndefined(routedResultListener)) {
+      const [stat, storeListenerIds, queryIdsListenerId] = routedResultListener;
+      mapForEach(storeListenerIds, (_queryId, [store2, storeListenerId]) =>
+        store2.delListener(storeListenerId),
+      );
+      ifNotUndefined(queryIdsListenerId, delListenerImpl);
+      mapSet(routedResultListeners, listenerId);
+      delListenerImpl(listenerId);
+      resultListenerStats[stat]--;
+    } else {
+      delListenerImpl(listenerId);
+    }
     return queries;
   };
-  const getListenerStats = () => {
-    const {
-      tables: _1,
-      tableIds: _2,
-      transaction: _3,
-      ...stats
-    } = resultStore.getListenerStats();
-    return {
-      ...stats,
-      paramValues: collSize2(paramValuesListeners),
-      paramValue: collSize3(paramValueListeners),
-    };
+  const getListenerStats = () => ({
+    ...resultListenerStats,
+    paramValues: paramStore.getListenerStats().row - size(getQueryIds()),
+    paramValue: paramStore.getListenerStats().cell,
+  });
+  const destroy = () => {
+    arrayForEach(getQueryIds(), delQueryDefinition);
+    destroyImpl();
   };
   const queries = {
     setQueryDefinition,
@@ -926,6 +1056,7 @@ const createQueries = getCreateFunction((store) => {
     forEachQuery,
     hasQuery,
     getTableId,
+    forEachResultTable,
     addQueryIdsListener,
     addParamValuesListener,
     addParamValueListener,
@@ -933,30 +1064,41 @@ const createQueries = getCreateFunction((store) => {
     destroy,
     getListenerStats,
   };
+  const getListenerArgs = (args, argumentCount) =>
+    argumentCount == 5
+      ? [args[0], args[1] ?? void 0, args[2], args[3], args[4]]
+      : slice(args, 0, argumentCount);
+  const getResultListenerStat = (gettable) =>
+    gettable[0].toLowerCase() + slice(gettable, 1);
   objMap(
     {
-      [TABLE]: [1, 1],
-      [TABLE + CELL_IDS]: [0, 1],
-      [ROW_COUNT]: [0, 1],
-      [ROW_IDS]: [0, 1],
-      [SORTED_ROW_IDS]: [0, 5],
-      [ROW]: [1, 2],
-      [CELL_IDS]: [0, 2],
-      [CELL]: [1, 3],
+      [TABLE]: [2, 1],
+      [TABLE + CELL_IDS]: [1, 1],
+      [ROW_COUNT]: [1, 1],
+      [ROW_IDS]: [1, 1],
+      [SORTED_ROW_IDS]: [1, 5],
+      [ROW]: [3, 2],
+      [CELL_IDS]: [1, 2],
+      [CELL]: [3, 3],
     },
-    ([hasAndForEach, argumentCount], gettable) => {
+    ([prefixCount, argumentCount], gettable) => {
       arrayForEach(
-        hasAndForEach ? [GET, 'has', 'forEach'] : [GET],
+        slice([GET, 'has', 'forEach'], 0, prefixCount),
         (prefix) =>
           (queries[prefix + RESULT + gettable] = (...args) =>
-            resultStore[prefix + gettable](...args)),
+            getResultStore(args[0])[prefix + gettable](...args)),
       );
       queries[ADD + RESULT + gettable + LISTENER] = (...args) =>
-        resultStore[ADD + gettable + LISTENER](
-          ...slice(args, 0, argumentCount),
-          (_store, ...listenerArgs) =>
-            args[argumentCount](queries, ...listenerArgs),
-          true,
+        addRoutedResultListener(
+          getResultListenerStat(gettable),
+          args[0],
+          (store2) =>
+            store2[ADD + gettable + LISTENER](
+              ...getListenerArgs(args, argumentCount),
+              (_store, ...listenerArgs) =>
+                args[argumentCount](queries, ...listenerArgs),
+              true,
+            ),
         );
     },
   );