querysub 0.402.0 → 0.404.0

package/src/0-path-value-core/hackedPackedPathParentFiltering.ts

@@ -0,0 +1,97 @@
+import { measureWrap } from "socket-function/src/profiling/measure";
+import { getPathDepth, getPathIndexAssert, hack_getPackedPathSuffix, hack_setPackedPathSuffix, hack_stripPackedPath } from "../path";
+import { PathRouter } from "./PathRouter";
+import { cache } from "socket-function/src/caching";
+import { authorityLookup } from "./AuthorityLookup";
+
+// NOTE: This code has been moved into PathRouter
+// /** Returns a number between 0 (inclusive) and 1 (exclusive)
+//  *      - See matchesParentRangeFilter, matchesParentRangeFilterPart, and filterChildPaths.
+//  */
+// export function __getRoutingHash(key: string): number {
+//     // Using fastHash is about twice as fast as sha256 (although that might be due to the buffer allocation?)
+//     let hash = fastHash(key);
+//     return hash % (1000 * 1000 * 1000) / (1000 * 1000 * 1000);
+//     // let hash = sha256(key);
+//     // return getBufferFraction(Buffer.from(hash, "hex"));
+// }
+
+let isPrefix = cache((path: string) => {
+    let spec = authorityLookup.getOurSpec();
+    if (!spec) return false;
+    for (let prefix of spec.prefixes) {
+        if (path.startsWith(prefix.prefix)) return true;
+    }
+    return false;
+});
+
+// NOTE: Assumes fullPath is already a child of parentPath, and only checks for hash
+export function matchesParentRangeFilter(config: {
+    parentPath: string;
+    fullPath: string;
+    packedPath: string;
+}) {
+    if (config.packedPath === config.packedPath) return true;
+    let filter = decodeParentFilter(config.packedPath);
+    if (!filter) return true;
+    if (filter.useFullPathHash) {
+        let route = PathRouter.getSingleKeyRoute(config.fullPath);
+        return filter.start <= route && route < filter.end;
+    }
+    let route = PathRouter.getRouteChildKey(config.fullPath);
+    return filter.start <= route && route < filter.end;
+}
+// export function matchesParentRangeFilterPart(config: {
+//     part: string;
+//     start: number;
+//     end: number;
+// }) {
+//     if (config.start === 0 && config.end === 1) return true;
+//     let hash = __getRoutingHash(config.part);
+//     return config.start <= hash && hash < config.end;
+// }
+
+export const filterChildPathsBase = measureWrap(
+    function filterChildPathsBase(parentPath: string, packedSuffix: string, paths: Set<string>): Set<string> {
+        let [startFractionStr, endFractionStr, useFullPathHash] = packedSuffix.split("|");
+        let startFraction = Number(startFractionStr);
+        let endFraction = Number(endFractionStr);
+
+        let depth = getPathDepth(parentPath);
+
+        let filtered = new Set<string>();
+        for (let path of paths) {
+            if (useFullPathHash) {
+                let route = PathRouter.getSingleKeyRoute(path);
+                if (startFraction <= route && route < endFraction) {
+                    filtered.add(path);
+                }
+            } else {
+                let key = getPathIndexAssert(path, depth);
+                let hash = PathRouter.getSingleKeyRoute(key);
+                if (startFraction <= hash && hash < endFraction) {
+                    filtered.add(path);
+                }
+            }
+        }
+        //console.log(`Filtered ${paths.size} paths to ${filtered.size} paths`);
+        return filtered;
+    }
+);
+
+export function encodeParentFilter(config: {
+    path: string;
+    startFraction: number;
+    endFraction: number;
+    useFullPathHash?: boolean;
+}) {
+    return hack_setPackedPathSuffix(config.path, `${config.startFraction}|${config.endFraction}|${config.useFullPathHash ? "F" : ""}`);
+}
+export function decodeParentFilter(path: string): { path: string; start: number, end: number, useFullPathHash?: boolean } | undefined {
+    let packedSuffix = hack_getPackedPathSuffix(path);
+    if (!packedSuffix) return undefined;
+    let [startStr, endStr, useFullPathHash] = packedSuffix.split("|");
+    let unpackedPath = hack_stripPackedPath(path);
+    return { path: unpackedPath, start: Number(startStr), end: Number(endStr), useFullPathHash: !!useFullPathHash };
+
+}