@peerbit/indexer-tests 1.1.3 → 1.1.4

package/dist/src/benchmarks.js

@@ -8,10 +8,9 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { field, vec } from "@dao-xyz/borsh";
-import { BoolQuery, StringMatch, getIdProperty, id, } from "@peerbit/indexer-interface";
-import B from "benchmark";
+import { And, BoolQuery, Compare, IntegerCompare, Or, Query, Sort, StringMatch, getIdProperty, id, } from "@peerbit/indexer-interface";
 import sodium from "libsodium-wrappers";
-import pDefer from "p-defer";
+import * as B from "tinybench";
 import { v4 as uuid } from "uuid";
 const setup = async (properties, createIndicies, type = "transient") => {
     await sodium.ready;
@@ -29,7 +28,7 @@ const setup = async (properties, createIndicies, type = "transient") => {
     return { indices, store, directory };
 };
 let preFillCount = 2e4;
-const strinbBenchmark = async (createIndicies, type = "transient") => {
+const stringBenchmark = async (createIndicies, type = "transient") => {
     class StringDocument {
         id;
         string;
@@ -54,74 +53,41 @@ const strinbBenchmark = async (createIndicies, type = "transient") => {
         await stringIndexPreFilled.store.put(new StringDocument(uuid(), i % 100 === 0 ? fixed : uuid()));
     }
     const stringIndexEmpty = await setup({ schema: StringDocument }, createIndicies, type);
-    let done = pDefer();
-    const suite = new B.Suite({ delay: 100 });
-    suite
-        .add("string put - " + type, {
-        fn: async (deferred) => {
-            await stringIndexEmpty.store.put(new StringDocument(uuid(), uuid()));
-            deferred.resolve();
-        },
-        defer: true,
-        maxTime: 5,
+    const suite = new B.Bench({ warmupIterations: 1000 });
+    await suite
+        .add("string put - " + type, async () => {
+        await stringIndexEmpty.store.put(new StringDocument(uuid(), uuid()));
     })
-        .add("string query matching - " + type, {
-        fn: async (deferred) => {
-            const iterator = stringIndexPreFilled.store.iterate({
-                query: new StringMatch({ key: "string", value: fixed }),
-            });
-            await iterator.next(10);
-            await iterator.close();
-            deferred.resolve();
-        },
-        defer: true,
-        maxTime: 5,
+        .add("string query matching - " + type, async () => {
+        const iterator = stringIndexPreFilled.store.iterate({
+            query: new StringMatch({ key: "string", value: fixed }),
+        });
+        await iterator.next(10);
+        await iterator.close();
     })
-        .add("string count matching - " + type, {
-        fn: async (deferred) => {
-            await stringIndexPreFilled.store.count({
-                query: new StringMatch({ key: "string", value: fixed }),
-            });
-            deferred.resolve();
-        },
-        defer: true,
-        maxTime: 5,
+        .add("string count matching - " + type, async () => {
+        await stringIndexPreFilled.store.count({
+            query: new StringMatch({ key: "string", value: fixed }),
+        });
     })
-        .add("string count no-matches - " + type, {
-        fn: async (deferred) => {
-            const out = Math.random() > 0.5 ? true : false;
-            await stringIndexPreFilled.store.count({
-                query: new StringMatch({ key: "string", value: uuid() }),
-            });
-            deferred.resolve();
-        },
-        defer: true,
-        maxTime: 5,
-    })
-        .on("cycle", async (event) => {
-        // eslint-disable-next-line no-console
-        console.log(String(event.target));
-    })
-        .on("error", (err) => {
-        throw err;
-    })
-        .on("complete", async () => {
-        await stringIndexEmpty.indices.stop();
-        stringIndexEmpty.directory &&
-            fs.rmSync(stringIndexEmpty.directory, { recursive: true, force: true });
-        await stringIndexPreFilled.indices.stop();
-        stringIndexPreFilled.directory &&
-            fs.rmSync(stringIndexPreFilled.directory, {
-                recursive: true,
-                force: true,
-            });
-        done.resolve();
-    })
-        .on("error", (e) => {
-        done.reject(e);
+        .add("string count no-matches - " + type, async () => {
+        const out = Math.random() > 0.5 ? true : false;
+        await stringIndexPreFilled.store.count({
+            query: new StringMatch({ key: "string", value: uuid() }),
+        });
     })
         .run();
-    return done.promise;
+    await stringIndexEmpty.indices.stop();
+    stringIndexEmpty.directory &&
+        fs.rmSync(stringIndexEmpty.directory, { recursive: true, force: true });
+    await stringIndexPreFilled.indices.stop();
+    stringIndexPreFilled.directory &&
+        fs.rmSync(stringIndexPreFilled.directory, {
+            recursive: true,
+            force: true,
+        });
+    /* eslint-disable no-console */
+    console.table(suite.table());
 };
 const boolQueryBenchmark = async (createIndicies, type = "transient") => {
     class BoolQueryDocument {
@@ -147,54 +113,160 @@ const boolQueryBenchmark = async (createIndicies, type = "transient") => {
         await boolIndexPrefilled.store.put(new BoolQueryDocument(uuid(), Math.random() > 0.5 ? true : false));
     }
     const boolIndexEmpty = await setup({ schema: BoolQueryDocument }, createIndicies, type);
-    let done = pDefer();
-    const suite = new B.Suite({ delay: 100 });
-    suite
-        .add("bool query - " + type, {
-        fn: async (deferred) => {
-            const out = Math.random() > 0.5 ? true : false;
-            const iterator = await boolIndexPrefilled.store.iterate({
-                query: new BoolQuery({ key: "bool", value: out }),
-            });
-            await iterator.next(10);
-            await iterator.close();
-            deferred.resolve();
-        },
-        defer: true,
-        maxTime: 5,
+    const suite = new B.Bench({ warmupIterations: 1000 });
+    let fetch = 10;
+    await suite
+        .add(`bool query fetch ${fetch} - ${type}`, async () => {
+        const out = Math.random() > 0.5 ? true : false;
+        const iterator = await boolIndexPrefilled.store.iterate({
+            query: new BoolQuery({ key: "bool", value: out }),
+        });
+        await iterator.next(10);
+        await iterator.close();
     })
-        .add("bool put - " + type, {
-        fn: async (deferred) => {
-            await boolIndexEmpty.store.put(new BoolQueryDocument(uuid(), Math.random() > 0.5 ? true : false));
-            deferred.resolve();
-        },
-        defer: true,
-        maxTime: 5,
+        .add(`non bool query fetch ${fetch} - ${type}`, async () => {
+        const iterator = await boolIndexPrefilled.store.iterate();
+        await iterator.next(10);
+        await iterator.close();
     })
-        .on("cycle", async (event) => {
-        // eslint-disable-next-line no-console
-        console.log(String(event.target));
+        .add(`non bool query fetch with sort ${fetch} - ${type}`, async () => {
+        const iterator = boolIndexPrefilled.store.iterate({
+            sort: [new Sort({ key: "id" })],
+        });
+        await iterator.next(10);
+        await iterator.close();
     })
-        .on("error", (err) => {
-        throw err;
+        .add(`bool put - ${type}`, async () => {
+        await boolIndexEmpty.store.put(new BoolQueryDocument(uuid(), Math.random() > 0.5 ? true : false));
     })
-        .on("complete", async () => {
-        await boolIndexEmpty.indices.stop();
-        boolIndexEmpty.directory &&
-            fs.rmSync(boolIndexEmpty.directory, { recursive: true, force: true });
-        await boolIndexPrefilled.indices.stop();
-        boolIndexPrefilled.directory &&
-            fs.rmSync(boolIndexPrefilled.directory, {
-                recursive: true,
-                force: true,
-            });
-        done.resolve();
+        .run();
+    await boolIndexEmpty.indices.stop();
+    boolIndexEmpty.directory &&
+        fs.rmSync(boolIndexEmpty.directory, { recursive: true, force: true });
+    await boolIndexPrefilled.indices.stop();
+    boolIndexPrefilled.directory &&
+        fs.rmSync(boolIndexPrefilled.directory, {
+            recursive: true,
+            force: true,
+        });
+    /* eslint-disable no-console */
+    console.table(suite.table());
+};
+const inequalityBenchmark = async (createIndicies, type = "transient") => {
+    class NumberQueryDocument {
+        id;
+        number;
+        constructor(id, number) {
+            this.id = id;
+            this.number = number;
+        }
+    }
+    __decorate([
+        id({ type: "string" }),
+        __metadata("design:type", String)
+    ], NumberQueryDocument.prototype, "id", void 0);
+    __decorate([
+        field({ type: "u32" }),
+        __metadata("design:type", Number)
+    ], NumberQueryDocument.prototype, "number", void 0);
+    const fs = await import("fs");
+    const numberIndexPrefilled = await setup({ schema: NumberQueryDocument }, createIndicies, type);
+    let docCount = 10e4;
+    for (let i = 0; i < docCount; i++) {
+        await numberIndexPrefilled.store.put(new NumberQueryDocument(uuid(), i));
+    }
+    const boolIndexEmpty = await setup({ schema: NumberQueryDocument }, createIndicies, type);
+    // warmup
+    for (let i = 0; i < 1000; i++) {
+        const iterator = numberIndexPrefilled.store.iterate({
+            query: new IntegerCompare({
+                key: "number",
+                compare: Compare.Less,
+                value: 11,
+            }),
+        });
+        await iterator.next(10);
+        await iterator.close();
+    }
+    const suite = new B.Bench({ warmupIterations: 1000 });
+    let fetch = 10;
+    await suite
+        .add(`number query fetch ${fetch} - ${type}`, async () => {
+        const iterator = numberIndexPrefilled.store.iterate({
+            query: new IntegerCompare({
+                key: "number",
+                compare: Compare.Less,
+                value: 11,
+            }),
+        });
+        await iterator.next(10);
+        await iterator.close();
+    })
+        .add(`non number query fetch ${fetch} - ${type}`, async () => {
+        const iterator = numberIndexPrefilled.store.iterate();
+        await iterator.next(10);
+        await iterator.close();
     })
-        .on("error", (e) => {
-        done.reject(e);
+        .add(`number put - ${type}`, async () => {
+        await boolIndexEmpty.store.put(new NumberQueryDocument(uuid(), Math.round(Math.random() * 0xffffffff)));
     })
         .run();
-    return done.promise;
+    await boolIndexEmpty.indices.stop();
+    boolIndexEmpty.directory &&
+        fs.rmSync(boolIndexEmpty.directory, { recursive: true, force: true });
+    await numberIndexPrefilled.indices.stop();
+    numberIndexPrefilled.directory &&
+        fs.rmSync(numberIndexPrefilled.directory, {
+            recursive: true,
+            force: true,
+        });
+    /* eslint-disable no-console */
+    console.table(suite.table());
+};
+const getBenchmark = async (createIndicies, type = "transient") => {
+    class BoolQueryDocument {
+        id;
+        bool;
+        constructor(id, bool) {
+            this.id = id;
+            this.bool = bool;
+        }
+    }
+    __decorate([
+        id({ type: "string" }),
+        __metadata("design:type", String)
+    ], BoolQueryDocument.prototype, "id", void 0);
+    __decorate([
+        field({ type: "bool" }),
+        __metadata("design:type", Boolean)
+    ], BoolQueryDocument.prototype, "bool", void 0);
+    const fs = await import("fs");
+    const boolIndexPrefilled = await setup({ schema: BoolQueryDocument }, createIndicies, type);
+    let docCount = preFillCount;
+    let ids = [];
+    for (let i = 0; i < docCount; i++) {
+        let id = uuid();
+        ids.push(id);
+        await boolIndexPrefilled.store.put(new BoolQueryDocument(id, Math.random() > 0.5 ? true : false));
+    }
+    const boolIndexEmpty = await setup({ schema: BoolQueryDocument }, createIndicies, type);
+    const suite = new B.Bench({ warmupIterations: 1000 });
+    await suite
+        .add("get by id - " + type, async () => {
+        await boolIndexPrefilled.store.get(ids[Math.floor(Math.random() * ids.length)]);
+    })
+        .run();
+    await boolIndexEmpty.indices.stop();
+    boolIndexEmpty.directory &&
+        fs.rmSync(boolIndexEmpty.directory, { recursive: true, force: true });
+    await boolIndexPrefilled.indices.stop();
+    boolIndexPrefilled.directory &&
+        fs.rmSync(boolIndexPrefilled.directory, {
+            recursive: true,
+            force: true,
+        });
+    /* eslint-disable no-console */
+    console.table(suite.table());
 };
 const nestedBoolQueryBenchmark = async (createIndicies, type = "transient") => {
     class Nested {
@@ -230,53 +302,31 @@ const nestedBoolQueryBenchmark = async (createIndicies, type = "transient") => {
         await boolIndexPrefilled.store.put(new NestedBoolQueryDocument(uuid(), i % 2 === 0 ? true : false));
     }
     const boolIndexEmpty = await setup({ schema: NestedBoolQueryDocument }, createIndicies, type);
-    let done = pDefer();
-    const suite = new B.Suite({ delay: 100 });
-    suite
-        .add("nested bool query - " + type, {
-        fn: async (deferred) => {
-            const out = Math.random() > 0.5 ? true : false;
-            const iterator = await boolIndexPrefilled.store.iterate({
-                query: new BoolQuery({ key: ["nested", "bool"], value: out }),
-            });
-            await iterator.next(10);
-            await iterator.close();
-            deferred.resolve();
-        },
-        defer: true,
-        maxTime: 5,
-        async: true,
-    })
-        .add("nested bool put - " + type, {
-        fn: async (deferred) => {
-            await boolIndexEmpty.store.put(new NestedBoolQueryDocument(uuid(), Math.random() > 0.5 ? true : false));
-            deferred.resolve();
-        },
-        defer: true,
-        maxTime: 5,
-        async: true,
-    })
-        .on("cycle", async (event) => {
-        // eslint-disable-next-line no-console
-        console.log(String(event.target));
+    const suite = new B.Bench({ warmupIterations: 1000 });
+    await suite
+        .add("nested bool query - " + type, async () => {
+        const out = Math.random() > 0.5 ? true : false;
+        const iterator = await boolIndexPrefilled.store.iterate({
+            query: new BoolQuery({ key: ["nested", "bool"], value: out }),
+        });
+        await iterator.next(10);
+        await iterator.close();
     })
-        .on("error", (err) => {
-        done.reject(err);
-    })
-        .on("complete", async () => {
-        await boolIndexEmpty.indices.stop();
-        boolIndexEmpty.directory &&
-            fs.rmSync(boolIndexEmpty.directory, { recursive: true, force: true });
-        await boolIndexPrefilled.indices.stop();
-        boolIndexPrefilled.directory &&
-            fs.rmSync(boolIndexPrefilled.directory, {
-                recursive: true,
-                force: true,
-            });
-        done.resolve();
+        .add("nested bool put - " + type, async () => {
+        await boolIndexEmpty.store.put(new NestedBoolQueryDocument(uuid(), Math.random() > 0.5 ? true : false));
     })
         .run();
-    return done.promise;
+    await boolIndexEmpty.indices.stop();
+    boolIndexEmpty.directory &&
+        fs.rmSync(boolIndexEmpty.directory, { recursive: true, force: true });
+    await boolIndexPrefilled.indices.stop();
+    boolIndexPrefilled.directory &&
+        fs.rmSync(boolIndexPrefilled.directory, {
+            recursive: true,
+            force: true,
+        });
+    /* eslint-disable no-console */
+    console.table(suite.table());
 };
 const shapedQueryBenchmark = async (createIndicies, type = "transient") => {
     class Nested {
@@ -313,66 +363,244 @@ const shapedQueryBenchmark = async (createIndicies, type = "transient") => {
             new Nested(i % 2 === 0 ? true : false),
         ]));
     }
-    let done = pDefer();
-    const suite = new B.Suite({ delay: 100 });
+    const suite = new B.Bench({ warmupIterations: 1000 });
     let fetch = 10;
-    suite
-        .add("unshaped nested query - " + type, {
-        fn: async (deferred) => {
-            const out = Math.random() > 0.5 ? true : false;
-            let iterator = await boolIndexPrefilled.store.iterate({
-                query: new BoolQuery({ key: ["nested", "bool"], value: out }),
-            });
-            const results = await iterator.next(fetch);
-            await iterator.close();
-            if (results.length !== fetch) {
-                throw new Error("Missing results");
-            }
-            deferred.resolve();
-        },
-        defer: true,
-        maxTime: 5,
-        async: true,
+    await suite
+        .add("unshaped nested array query - " + type, async () => {
+        const out = Math.random() > 0.5 ? true : false;
+        let iterator = await boolIndexPrefilled.store.iterate({
+            query: new BoolQuery({ key: ["nested", "bool"], value: out }),
+        });
+        const results = await iterator.next(fetch);
+        await iterator.close();
+        if (results.length !== fetch) {
+            throw new Error("Missing results");
+        }
+    })
+        .add("shaped nested array query - " + type, async () => {
+        const out = Math.random() > 0.5 ? true : false;
+        const iterator = boolIndexPrefilled.store.iterate({
+            query: new BoolQuery({ key: ["nested", "bool"], value: out }),
+        }, { shape: { id: true } });
+        const results = await iterator.next(fetch);
+        await iterator.close();
+        if (results.length !== fetch) {
+            throw new Error("Missing results");
+        }
+    })
+        .add("nested fetch without query - " + type, async () => {
+        const iterator = boolIndexPrefilled.store.iterate({}, { shape: { id: true } });
+        const results = await iterator.next(fetch);
+        await iterator.close();
+        if (results.length !== fetch) {
+            throw new Error("Missing results");
+        }
     })
-        .add("shaped nested query - " + type, {
-        fn: async (deferred) => {
-            const out = Math.random() > 0.5 ? true : false;
-            const iterator = await boolIndexPrefilled.store.iterate({
-                query: new BoolQuery({ key: ["nested", "bool"], value: out }),
-            }, { shape: { id: true } });
+        .run();
+    await boolIndexPrefilled.indices.stop();
+    boolIndexPrefilled.directory &&
+        fs.rmSync(boolIndexPrefilled.directory, {
+            recursive: true,
+            force: true,
+        });
+    /* eslint-disable no-console */
+    console.table(suite.table());
+};
+const multiFieldQueryBenchmark = async (createIndicies, type = "transient") => {
+    class ReplicationRangeIndexableU32 {
+        id;
+        hash;
+        timestamp;
+        start1;
+        end1;
+        start2;
+        end2;
+        width;
+        mode;
+        constructor(properties) {
+            this.id = properties.id || uuid();
+            this.hash = properties.hash;
+            this.timestamp = properties.timestamp;
+            this.start1 = properties.start1;
+            this.end1 = properties.end1;
+            this.start2 = properties.start2;
+            this.end2 = properties.end2;
+            this.width = properties.width;
+            this.mode = properties.mode;
+        }
+    }
+    __decorate([
+        id({ type: "string" }),
+        __metadata("design:type", String)
+    ], ReplicationRangeIndexableU32.prototype, "id", void 0);
+    __decorate([
+        field({ type: "string" }),
+        __metadata("design:type", String)
+    ], ReplicationRangeIndexableU32.prototype, "hash", void 0);
+    __decorate([
+        field({ type: "u64" }),
+        __metadata("design:type", BigInt)
+    ], ReplicationRangeIndexableU32.prototype, "timestamp", void 0);
+    __decorate([
+        field({ type: "u32" }),
+        __metadata("design:type", Number)
+    ], ReplicationRangeIndexableU32.prototype, "start1", void 0);
+    __decorate([
+        field({ type: "u32" }),
+        __metadata("design:type", Number)
+    ], ReplicationRangeIndexableU32.prototype, "end1", void 0);
+    __decorate([
+        field({ type: "u32" }),
+        __metadata("design:type", Number)
+    ], ReplicationRangeIndexableU32.prototype, "start2", void 0);
+    __decorate([
+        field({ type: "u32" }),
+        __metadata("design:type", Number)
+    ], ReplicationRangeIndexableU32.prototype, "end2", void 0);
+    __decorate([
+        field({ type: "u32" }),
+        __metadata("design:type", Number)
+    ], ReplicationRangeIndexableU32.prototype, "width", void 0);
+    __decorate([
+        field({ type: "u8" }),
+        __metadata("design:type", Number)
+    ], ReplicationRangeIndexableU32.prototype, "mode", void 0);
+    const indexPrefilled = await setup({ schema: ReplicationRangeIndexableU32 }, createIndicies, type);
+    let docCount = 10e4; // This is very small, so we expect that the ops will be very fast (i.e a few amount to join)
+    for (let i = 0; i < docCount; i++) {
+        await indexPrefilled.store.put(new ReplicationRangeIndexableU32({
+            hash: uuid(),
+            timestamp: BigInt(i),
+            start1: i,
+            end1: i + 1,
+            start2: i + 2,
+            end2: i + 3,
+            width: i + 4,
+            mode: i % 3,
+        }));
+    }
+    const suite = new B.Bench({ warmupIterations: 500 });
+    let fetch = 10;
+    const fs = await import("fs");
+    const ors = [];
+    for (const point of [10, docCount - 4]) {
+        ors.push(new And([
+            new IntegerCompare({
+                key: "start1",
+                compare: Compare.LessOrEqual,
+                value: point,
+            }),
+            new IntegerCompare({
+                key: "end1",
+                compare: Compare.Greater,
+                value: point,
+            }),
+        ]));
+        ors.push(new And([
+            new IntegerCompare({
+                key: "start2",
+                compare: Compare.LessOrEqual,
+                value: point,
+            }),
+            new IntegerCompare({
+                key: "end2",
+                compare: Compare.Greater,
+                value: point,
+            }),
+        ]));
+    }
+    let complicatedQuery = [
+        new Or(ors) /* ,
+        new IntegerCompare({
+            key: "timestamp",
+            compare: Compare.Less,
+            value: 100
+        }) */,
+    ];
+    const suites = [
+        /* {
+            query: [
+                new IntegerCompare({
+                    key: "start1",
+                    compare: Compare.LessOrEqual,
+                    value: 5,
+                }),
+                new IntegerCompare({
+                    key: "end1",
+                    compare: Compare.Greater,
+                    value: 5,
+                })
+            ], name: "2-fields query"
+        },
+        {
+            query: [
+
+                new IntegerCompare({
+                    key: "start1",
+                    compare: Compare.LessOrEqual,
+                    value: 5,
+                }),
+                new IntegerCompare({
+                    key: "end1",
+                    compare: Compare.Greater,
+                    value: 5,
+                }),
+                new IntegerCompare({
+                    key: "timestamp",
+                    compare: Compare.Less,
+                    value: 10,
+                }),
+            ], name: "3-fields query"
+        }, */
+        { query: complicatedQuery, name: "3-fields or query" },
+    ];
+    suites.forEach(({ query, name }) => {
+        suite.add(`m-field ${name} query small fetch - ${type}`, async () => {
+            const iterator = await indexPrefilled.store.iterate({
+                query,
+            });
             const results = await iterator.next(fetch);
             await iterator.close();
-            if (results.length !== fetch) {
-                throw new Error("Missing results");
+            if (results.length === 0) {
+                throw new Error("No results");
             }
-            deferred.resolve();
-        },
-        defer: true,
-        maxTime: 5,
-        async: true,
-    })
-        .on("cycle", async (event) => {
-        // eslint-disable-next-line no-console
-        console.log(String(event.target));
-    })
-        .on("error", (err) => {
-        done.reject(err);
-    })
-        .on("complete", async () => {
-        await boolIndexPrefilled.indices.stop();
-        boolIndexPrefilled.directory &&
-            fs.rmSync(boolIndexPrefilled.directory, {
-                recursive: true,
-                force: true,
+        });
+        /* .add(`m-field ${name} query all fetch - ${type}`, async () => {
+            const iterator = indexPrefilled.store.iterate({
+                query,
             });
-        done.resolve();
-    })
-        .run();
-    return done.promise;
+            const results = await iterator.all();
+
+            if (results.length === 0) {
+                throw new Error("No results");
+            }
+        }) */
+    });
+    /* suite.add("m-field no query small fetch - " + type, async () => {
+        const iterator = await indexPrefilled.store.iterate();
+        const results = await iterator.next(fetch);
+        await iterator.close();
+
+        if (results.length === 0) {
+            throw new Error("No results");
+        }
+    }) */
+    await suite.run();
+    await indexPrefilled.indices.stop();
+    indexPrefilled.directory &&
+        fs.rmSync(indexPrefilled.directory, {
+            recursive: true,
+            force: true,
+        });
+    /* eslint-disable no-console */
+    console.table(suite.table());
 };
 export const benchmarks = async (createIndicies, type = "transient") => {
-    await strinbBenchmark(createIndicies, type);
+    await inequalityBenchmark(createIndicies, type);
+    await multiFieldQueryBenchmark(createIndicies, type);
+    await stringBenchmark(createIndicies, type);
     await shapedQueryBenchmark(createIndicies, type);
+    await getBenchmark(createIndicies, type);
     await boolQueryBenchmark(createIndicies, type);
     await nestedBoolQueryBenchmark(createIndicies, type);
 };