tinybase 1.3.3 → 2.0.0-beta.0

package/lib/debug/queries.js

@@ -0,0 +1,883 @@
+const arrayEvery = (array, cb) => array.every(cb);
+const arrayIsEqual = (array1, array2) =>
+  arrayLength(array1) === arrayLength(array2) &&
+  arrayEvery(array1, (value1, index) => array2[index] === value1);
+const arraySort = (array, sorter) => array.sort(sorter);
+const arrayForEach = (array, cb) => array.forEach(cb);
+const arrayMap = (array, cb) => array.map(cb);
+const arraySum = (array) => arrayReduce(array, (i, j) => i + j, 0);
+const arrayLength = (array) => array.length;
+const arrayIsEmpty = (array) => arrayLength(array) == 0;
+const arrayReduce = (array, cb, initial) => array.reduce(cb, initial);
+const arraySlice = (array, start, end) => array.slice(start, end);
+const arrayPush = (array, ...values) => array.push(...values);
+
+const getTypeOf = (thing) => typeof thing;
+const EMPTY_STRING = '';
+const STRING = getTypeOf(EMPTY_STRING);
+const BOOLEAN = getTypeOf(true);
+const NUMBER = getTypeOf(0);
+const FUNCTION = getTypeOf(getTypeOf);
+const SUM = 'sum';
+const AVG = 'avg';
+const MIN = 'min';
+const MAX = 'max';
+
+const mathMax = Math.max;
+const mathMin = Math.min;
+const isFiniteNumber = isFinite;
+const isUndefined = (thing) => thing == void 0;
+const ifNotUndefined = (value, then, otherwise) =>
+  isUndefined(value) ? otherwise?.() : then(value);
+const isTypeStringOrBoolean = (type) => type == STRING || type == BOOLEAN;
+const isFunction = (thing) => getTypeOf(thing) == FUNCTION;
+const getUndefined = () => void 0;
+
+const collSize = (coll) => coll.size;
+const collHas = (coll, keyOrValue) => coll?.has(keyOrValue) ?? false;
+const collIsEmpty = (coll) => isUndefined(coll) || collSize(coll) == 0;
+const collValues = (coll) => [...(coll?.values() ?? [])];
+const collClear = (coll) => coll.clear();
+const collForEach = (coll, cb) => coll?.forEach(cb);
+const collDel = (coll, keyOrValue) => coll?.delete(keyOrValue);
+
+const mapNew = (entries) => new Map(entries);
+const mapKeys = (map) => [...(map?.keys() ?? [])];
+const mapGet = (map, key) => map?.get(key);
+const mapForEach = (map, cb) =>
+  collForEach(map, (value, key) => cb(key, value));
+const mapSet = (map, key, value) =>
+  isUndefined(value) ? (collDel(map, key), map) : map?.set(key, value);
+const mapEnsure = (map, key, getDefaultValue) => {
+  if (!collHas(map, key)) {
+    map.set(key, getDefaultValue());
+  }
+  return mapGet(map, key);
+};
+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);
+
+const numericAggregators = mapNew([
+  [
+    AVG,
+    [
+      (numbers, length) => arraySum(numbers) / length,
+      (metric, add, length) => metric + (add - metric) / (length + 1),
+      (metric, remove, length) => metric + (metric - remove) / (length - 1),
+      (metric, add, remove, length) => metric + (add - remove) / length,
+    ],
+  ],
+  [
+    MAX,
+    [
+      (numbers) => mathMax(...numbers),
+      (metric, add) => mathMax(add, metric),
+      (metric, remove) => (remove == metric ? void 0 : metric),
+      (metric, add, remove) =>
+        remove == metric ? void 0 : mathMax(add, metric),
+    ],
+  ],
+  [
+    MIN,
+    [
+      (numbers) => mathMin(...numbers),
+      (metric, add) => mathMin(add, metric),
+      (metric, remove) => (remove == metric ? void 0 : metric),
+      (metric, add, remove) =>
+        remove == metric ? void 0 : mathMin(add, metric),
+    ],
+  ],
+  [
+    SUM,
+    [
+      (numbers) => arraySum(numbers),
+      (metric, add) => metric + add,
+      (metric, remove) => metric - remove,
+      (metric, add, remove) => metric - remove + add,
+    ],
+  ],
+]);
+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 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 getDefinableFunctions = (store, getDefaultThing, validateRowValue) => {
+  const hasRow = store.hasRow;
+  const tableIds = mapNew();
+  const things = mapNew();
+  const allRowValues = mapNew();
+  const allSortKeys = mapNew();
+  const storeListenerIds = mapNew();
+  const getStore = () => store;
+  const getThingIds = () => mapKeys(tableIds);
+  const forEachThing = (cb) => mapForEach(things, cb);
+  const hasThing = (id) => collHas(things, id);
+  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 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) => {
+    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) => {
+      const getCell = (cellId) => store.getCell(tableId, rowId, cellId);
+      const oldRowValue = mapGet(rowValues, rowId);
+      const newRowValue = hasRow(tableId, rowId)
+        ? validateRowValue(getRowValue(getCell, rowId))
+        : void 0;
+      if (oldRowValue != newRowValue) {
+        mapSet(changedRowValues, rowId, [oldRowValue, newRowValue]);
+      }
+      if (!isUndefined(getSortKey)) {
+        const oldSortKey = mapGet(sortKeys, rowId);
+        const newSortKey = hasRow(tableId, rowId)
+          ? getSortKey(getCell, rowId)
+          : void 0;
+        if (oldSortKey != newSortKey) {
+          mapSet(changedSortKeys, rowId, newSortKey);
+        }
+      }
+    };
+    const processTable = (force) => {
+      onChanged(
+        () => {
+          collForEach(changedRowValues, ([, newRowValue], rowId) =>
+            mapSet(rowValues, rowId, newRowValue),
+          );
+          collForEach(changedSortKeys, (newSortKey, rowId) =>
+            mapSet(sortKeys, rowId, newSortKey),
+          );
+        },
+        changedRowValues,
+        changedSortKeys,
+        rowValues,
+        sortKeys,
+        force,
+      );
+      collClear(changedRowValues);
+      collClear(changedSortKeys);
+    };
+    mapForEach(rowValues, processRow);
+    if (store.hasTable(tableId)) {
+      arrayForEach(store.getRowIds(tableId), (rowId) => {
+        if (!collHas(rowValues, rowId)) {
+          processRow(rowId);
+        }
+      });
+    }
+    processTable(true);
+    delStoreListeners(id);
+    addStoreListeners(
+      id,
+      0,
+      store.addRowListener(tableId, null, (_store, _tableId, rowId) =>
+        processRow(rowId),
+      ),
+      store.addTableListener(tableId, () => processTable()),
+    );
+  };
+  const delDefinition = (id) => {
+    mapSet(tableIds, id);
+    mapSet(things, id);
+    mapSet(allRowValues, id);
+    mapSet(allSortKeys, id);
+    delStoreListeners(id);
+  };
+  const destroy = () => mapForEach(storeListenerIds, delDefinition);
+  return [
+    getStore,
+    getThingIds,
+    forEachThing,
+    hasThing,
+    getTableId,
+    getThing,
+    setThing,
+    setDefinition,
+    setDefinitionAndListen,
+    delDefinition,
+    destroy,
+    addStoreListeners,
+    delStoreListeners,
+  ];
+};
+const getCreateFunction = (getFunction) => {
+  const getFunctionsByStore = /* @__PURE__ */ new WeakMap();
+  return (store) => {
+    if (!getFunctionsByStore.has(store)) {
+      getFunctionsByStore.set(store, getFunction(store));
+    }
+    return getFunctionsByStore.get(store);
+  };
+};
+
+const object = Object;
+const objIds = object.keys;
+const objFreeze = object.freeze;
+
+const defaultSorter = (sortKey1, sortKey2) => (sortKey1 < sortKey2 ? -1 : 1);
+
+const createQueries = getCreateFunction((store) => {
+  const [
+    getStore,
+    getQueryIds,
+    forEachQuery,
+    hasQuery,
+    getTableId,
+    ,
+    ,
+    setDefinition,
+    ,
+    delDefinition,
+    destroy,
+    addStoreListeners,
+    delStoreListeners,
+  ] = getDefinableFunctions(store, () => true, getUndefined);
+  const preStore1 = store.createStore();
+  const preStore2 = store.createStore();
+  const resultStore = store.createStore();
+  const preStoreListenerIds = mapNew();
+  const addPreStoreListener = (preStore, queryId, ...listenerIds) =>
+    arrayForEach(listenerIds, (listenerId) =>
+      setAdd(
+        mapEnsure(
+          mapEnsure(preStoreListenerIds, queryId, mapNew),
+          preStore,
+          setNew,
+        ),
+        listenerId,
+      ),
+    );
+  const synchronizeTransactions = (queryId, fromStore, toStore) =>
+    addStoreListeners(
+      queryId,
+      0,
+      fromStore.addWillFinishTransactionListener(toStore.startTransaction),
+      fromStore.addDidFinishTransactionListener(() =>
+        toStore.finishTransaction(),
+      ),
+    );
+  const setQueryDefinition = (queryId, tableId, build) => {
+    setDefinition(queryId, tableId);
+    preStore1.delTable(queryId);
+    preStore2.delTable(queryId);
+    resultStore.delTable(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),
+      ),
+    );
+    delDefinition(queryId);
+    return queries;
+  };
+  const getResultTable = (queryId) => resultStore.getTable(queryId);
+  const getResultRowIds = (queryId) => resultStore.getRowIds(queryId);
+  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 addResultRowListener = (queryId, rowId, listener) =>
+    resultStore.addRowListener(queryId, rowId, (_store, ...args) =>
+      listener(queries, ...args),
+    );
+  const addResultCellIdsListener = (queryId, rowId, listener, trackReorder) =>
+    resultStore.addCellIdsListener(
+      queryId,
+      rowId,
+      (_store, ...args) => listener(queries, ...args),
+      trackReorder,
+    );
+  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,
+    getResultRow,
+    getResultCellIds,
+    getResultCell,
+    hasResultTable,
+    hasResultRow,
+    hasResultCell,
+    forEachResultTable,
+    forEachResultRow,
+    forEachResultCell,
+    addResultTableListener,
+    addResultRowIdsListener,
+    addResultRowListener,
+    addResultCellIdsListener,
+    addResultCellListener,
+    delListener,
+    destroy,
+    getListenerStats,
+  };
+  return objFreeze(queries);
+});
+
+export {createQueries};