1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
import { _ISelection, _IIndex, _ITable, _Transaction, _Explainer, _SelectExplanation, Stats, nil } from '../interfaces-private.ts';import { FilterBase } from './transform-base.ts';import { SeqScanFilter } from './seq-scan.ts';


export class AndFilter<T = any> extends FilterBase<T> {
    get index(): _IIndex<T> | nil {        return null;    }
    private prevEntropy?: { t: _Transaction; ret: number };
    entropy(t: _Transaction) {        // just a bit of caching        if (t === this.prevEntropy?.t) {            return this.prevEntropy.ret;        }        const { best } = this.plan(t);        const ret = best.entropy(t);        this.prevEntropy = {            ret,            t,        };        return ret;    }
    hasItem(value: T, t: _Transaction): boolean {        return this.filters.every(x => x.hasItem(value, t));    }
    constructor(private filters: _ISelection<T>[]) {        super(filters.find(x => !(x instanceof SeqScanFilter)) ?? filters[0]);        if (filters.some(f => f.columns !== this.base.columns)) {            throw new Error('Column set mismatch');        }    }
    private plan(t: _Transaction) {        const sorted = [...this.filters]            .sort((a, b) => a.entropy(t) > b.entropy(t) ? 1 : -1);        const [best] = sorted.splice(0, 1);        return { best, sorted };    }

    stats(t: _Transaction): Stats | null {        return null;    }
    *enumerate(t: _Transaction): Iterable<T> {        // sort them so the most restrictive filter is first        const { best, sorted } = this.plan(t)        for (const item of best.enumerate(t)) {            if (!sorted.every(x => x.hasItem(item, t))) {                continue;            }            yield item;        }    }
    explain(e: _Explainer): _SelectExplanation {        const { best, sorted } = this.plan(e.transaction);        return {            id: e.idFor(this),            _: 'and',            enumerate: best.explain(e),            andCheck: sorted.map(x => x.explain(e)),        };    }
}