Best practices for queries? Should I delete all inactive query definitions?

[willhoney7]

Should I delQueryDefinition for any query not actively being used? Do the queries run behind-the-scenes based on being defined or based on having listeners?

[jamesgpearce]

Yes, the queries re reactive so are being updated when underlying data changes (per transaction). That could add processing effort if it's large and complex and not being used. But measure it and see.

I'm curious to know how you are using queries in a way that might make this a concern. Eg would it help if they were parametrizable?

[willhoney7]

Okay, thank you! This is good to know. I will make sure I'm deleting my query definitions when unused then.

Parameterized queries is my biggest "want" for tinybase, for sure. I've ended up creating my own custom query class that takes in an array of variables and will "define" a query using the variables, (e.g, queryId = "${baseQueryId}:${variables.join(':')}".... And those variables change as you navigate to view different resources. If I don't delete the query definition I'll end up with a lot after using the app for a while.

I've seen different discussions on these parameters. I think it would be acceptable if the parameters HAD to be from the value store, but I would most like if the parameters could be passed in when calling getResultTable or useResultTable. I know that changes a bit of how queries work (since it sounds like they're calculated on data change, not on listen.)

[willhoney7]

Here's a edited snippet of my query class:

import { createQueries, ResultTable } from 'tinybase/with-schemas';

// example query

export const totalSpend = new CustomQuery({
    queryId: 'totalSpend',
    tableId: 'sometable',
    definition:
        (startDate: string, endDate: string) =>
        (keywords) => {
            keywords.select('amount');
            keywords.where((getCell) => {
                const date = getCell('date');
                const isInBetweenDates = date != null && date >= startDate && date <= endDate;
                return isInBetweenDates;
            });
            keywords.group('amount', 'sum');
        },
});

const result = totalSpend.getResultTable(store, '2025-01-01', '2025-01-31');
// then I also have a hook for using in react (not included here)
const result = useCustomQuery(totalSpend, ['2025-01-01', '2025-01-31']);


// query class (lightly edited)
export class CustomQuery<
    TableId extends TableName,
    Dependencies extends Array<Primitive>,
> {
    private readonly baseQueryId: QueryDefinition<TableId>[0];
    public readonly tableId: QueryDefinition<TableId>[1];
    private readonly definition: (...dependencies: Dependencies) => QueryDefinition<TableId>[2];

    // this is a little repetitive, but I think it's worth using the object syntax for the constructor
    public constructor({
        definition,
        queryId,
        tableId,
    }: {
        definition: (...dependencies: Dependencies) => QueryDefinition<TableId>[2];
        queryId: QueryDefinition<TableId>[0];
        tableId: QueryDefinition<TableId>[1];
    }) {
        this.baseQueryId = queryId;
        this.tableId = tableId;
        this.definition = definition;
    }

    public defineQuery = (
        store: MyTinybaseStore,
        queries: ReturnType<typeof getQueries>,
        ...dependencies: Dependencies
    ) => {
        const queryId = this.getQueryId(dependencies);
        if (!queries.hasQuery(queryId)) {
            // since we are defining all variables within the dependencies, we don't need to redefine the query if it's already defined
            queries.setQueryDefinition(
                this.getQueryId(dependencies),
                this.tableId,
                this.definition(...dependencies),
            );
        }
        return queryId;
    };

    // queryId is the base query id + plus all the dependencies (so we get unique ids based on the dependencies)
    public getQueryId = (dependencies: Dependencies) => {
        return `${this.baseQueryId}:${dependencies.join(':')}`;
    };

    // maybe pass in a schema instead?
    public getResultTable = <Result = ResultTable>(
        store: MyTinybaseStore,
        ...dependencies: Dependencies
    ) => {
        const queries = getQueries(store)
        const queryId = this.defineQuery(store, queries, ...dependencies);
        return queries.getResultTable(queryId) as Result;
    };

    public removeQuery = (store: MyTinybaseStore, ...dependencies: Dependencies) => {
        const queryId = this.getQueryId(dependencies);
        const queries = getQueries(store)
        queries.delQueryDefinition(queryId);
    };
}

// type stuff
type TableName = 'sometable' | 'myothertable';
type MyTinybaseStore = MergeableStore<...>;
const _queries = getQueries(store);
export type QueryDefinition<TableId extends TableName> = Parameters<
    // TODO can I do this with just the types? I don't know how to pass in a generic to the function on the Queries interface.
    typeof _queries.setQueryDefinition<TableId>
>;

function getQueries(store: MyTinybaseStore) {
    const queries = createQueries(store);
    return queries;
}