@depup/pg-mem 3.0.14-depup.0

package/types/transaction.d.ts

@@ -0,0 +1,26 @@
+import { _Transaction } from './interfaces-private';
+import { Map as ImMap, Set as ImSet } from 'immutable';
+export declare class Transaction implements _Transaction {
+    private parent;
+    private data;
+    private origData;
+    private transientData;
+    static root(): Transaction;
+    get isChild(): boolean;
+    private constructor();
+    clone(): Transaction;
+    fork(): _Transaction;
+    commit(): _Transaction;
+    fullCommit(): _Transaction;
+    rollback(): Transaction;
+    delete(identity: symbol): void;
+    set<T>(identity: symbol, data: T): T;
+    get<T>(identity: symbol): T;
+    getMap<T extends ImMap<any, any>>(identity: symbol): T;
+    getSet<T>(identity: symbol): ImSet<T>;
+    setTransient<T>(identity: symbol, data: T): T;
+    /** Set transient data, which will only exist within the scope of the current statement */
+    getTransient<T>(identity: symbol): T;
+    clearTransientData(): void;
+}
+//# sourceMappingURL=transaction.d.ts.map

package/types/transforms/aggregation.d.ts

@@ -0,0 +1,41 @@
+import { TransformBase } from './transform-base';
+import { _ISelection, _Transaction, IValue, _IIndex, _Explainer, _SelectExplanation, Stats, _IAggregation, Row } from '../interfaces-private';
+import { Expr, ExprRef, ExprCall } from 'pgsql-ast-parser';
+import { nil } from '../interfaces';
+export declare const aggregationFunctions: Set<string>;
+export declare function buildGroupBy(on: _ISelection, groupBy: Expr[]): Aggregation;
+export declare function getAggregator(): _IAggregation | null;
+export declare class Aggregation extends TransformBase implements _ISelection, _IAggregation {
+    columns: readonly IValue[];
+    /**
+     * Group-by values
+     * - key: column in source hash
+     * - value: column in this, evaluated against temporary entity.
+     **/
+    private readonly symbol;
+    private readonly aggId;
+    private readonly groupIndex?;
+    private aggregations;
+    /** How to get grouping values on the base table raw items (not on "this.enumerate()" raw items)  */
+    private groupingValuesOnbase;
+    /** How to get the grouped values on "this.enumerate()" raw items output */
+    private groupByMapping;
+    isAggregation(): this is _IAggregation;
+    constructor(on: _ISelection, _groupedBy: Expr[]);
+    getColumn(column: string | ExprRef): IValue;
+    getColumn(column: string | ExprRef, nullIfNotFound?: boolean): IValue | nil;
+    checkIfIsKey(got: IValue): IValue;
+    entropy(t: _Transaction): number;
+    stats(): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    private _enumerateAggregationKeys;
+    private iterateFromIndex;
+    private seqScan;
+    private computeDirect;
+    getAggregation(name: string, call: ExprCall): IValue;
+    private _getAggregation;
+    hasItem(value: Row, t: _Transaction): boolean;
+    getIndex(forValue: IValue): _IIndex | nil;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=aggregation.d.ts.map

package/types/transforms/aggregations/array_agg.d.ts

@@ -0,0 +1,11 @@
+import { AggregationComputer, AggregationGroupComputer, IValue, _ISelection, _IType, _Transaction } from '../../interfaces-private';
+import { ExprCall } from 'pgsql-ast-parser';
+declare class ArrayAggExpr implements AggregationComputer<any[]> {
+    private exp;
+    constructor(exp: IValue);
+    get type(): _IType<any>;
+    createGroup(t: _Transaction): AggregationGroupComputer<any[]>;
+}
+export declare function buildArrayAgg(this: void, base: _ISelection, call: ExprCall): ArrayAggExpr;
+export {};
+//# sourceMappingURL=array_agg.d.ts.map

package/types/transforms/aggregations/avg.d.ts

@@ -0,0 +1,11 @@
+import { AggregationComputer, AggregationGroupComputer, IValue, _ISelection, _IType, _Transaction } from '../../interfaces-private';
+import { ExprCall } from 'pgsql-ast-parser';
+declare class AvgExpr implements AggregationComputer<number> {
+    private exp;
+    constructor(exp: IValue);
+    get type(): _IType<any>;
+    createGroup(t: _Transaction): AggregationGroupComputer<number>;
+}
+export declare function buildAvg(this: void, base: _ISelection, call: ExprCall): AvgExpr;
+export {};
+//# sourceMappingURL=avg.d.ts.map

package/types/transforms/aggregations/bool-aggregs.d.ts

@@ -0,0 +1,12 @@
+import { _ISelection, AggregationComputer, IValue, _IType, _Transaction, AggregationGroupComputer } from '../../interfaces-private';
+import { ExprCall } from 'pgsql-ast-parser';
+declare class BoolAgg implements AggregationComputer<boolean> {
+    private exp;
+    private isOr;
+    constructor(exp: IValue, isOr: boolean);
+    get type(): _IType<any>;
+    createGroup(t: _Transaction): AggregationGroupComputer<boolean>;
+}
+export declare function buildBoolAgg(this: void, base: _ISelection, call: ExprCall, fn: 'bool_and' | 'bool_or'): BoolAgg;
+export {};
+//# sourceMappingURL=bool-aggregs.d.ts.map

package/types/transforms/aggregations/count.d.ts

@@ -0,0 +1,19 @@
+import { AggregationComputer, AggregationGroupComputer, IndexKey, IValue, _IIndex, _ISelection, _IType, _Transaction } from '../../interfaces-private';
+import { ExprCall } from 'pgsql-ast-parser';
+export declare function buildCount(this: void, base: _ISelection, call: ExprCall): CountStar | CountExpr;
+declare class CountStar implements AggregationComputer<number> {
+    private on;
+    constructor(on: _ISelection);
+    get type(): _IType<any>;
+    computeFromIndex(key: IndexKey, index: _IIndex, t: _Transaction): number | undefined;
+    computeNoGroup(t: _Transaction): number | undefined;
+    createGroup(): AggregationGroupComputer<number>;
+}
+declare class CountExpr implements AggregationComputer<number> {
+    private exp;
+    constructor(exp: IValue);
+    get type(): _IType<any>;
+    createGroup(t: _Transaction): AggregationGroupComputer<number>;
+}
+export {};
+//# sourceMappingURL=count.d.ts.map

package/types/transforms/aggregations/json_aggs.d.ts

@@ -0,0 +1,11 @@
+import { _ISelection, AggregationComputer, IValue, _IType, _Transaction, AggregationGroupComputer } from '../../interfaces-private';
+import { ExprCall } from 'pgsql-ast-parser';
+declare class JsonAggExpr implements AggregationComputer<any[]> {
+    private exp;
+    readonly type: _IType;
+    constructor(exp: IValue, type: _IType);
+    createGroup(t: _Transaction): AggregationGroupComputer<any[]>;
+}
+export declare function buildJsonAgg(this: void, base: _ISelection, call: ExprCall, fn: 'json_agg' | 'jsonb_agg'): JsonAggExpr;
+export {};
+//# sourceMappingURL=json_aggs.d.ts.map

package/types/transforms/aggregations/max-min.d.ts

@@ -0,0 +1,12 @@
+import { AggregationComputer, AggregationGroupComputer, IValue, _ISelection, _IType, _Transaction } from '../../interfaces-private';
+import { Expr } from 'pgsql-ast-parser';
+declare class MinMax implements AggregationComputer<number> {
+    private exp;
+    private isMax;
+    constructor(exp: IValue, isMax: boolean);
+    get type(): _IType<any>;
+    createGroup(t: _Transaction): AggregationGroupComputer<number>;
+}
+export declare function buildMinMax(this: void, base: _ISelection, args: Expr[], op: 'max' | 'min'): MinMax;
+export {};
+//# sourceMappingURL=max-min.d.ts.map

package/types/transforms/aggregations/sum.d.ts

@@ -0,0 +1,11 @@
+import { AggregationComputer, AggregationGroupComputer, IValue, _ISelection, _IType, _Transaction } from '../../interfaces-private';
+import { ExprCall } from 'pgsql-ast-parser';
+declare class SumExpr implements AggregationComputer<number> {
+    private exp;
+    constructor(exp: IValue);
+    get type(): _IType<any>;
+    createGroup(t: _Transaction): AggregationGroupComputer<number>;
+}
+export declare function buildSum(this: void, base: _ISelection, call: ExprCall): SumExpr;
+export {};
+//# sourceMappingURL=sum.d.ts.map

package/types/transforms/alias.d.ts

@@ -0,0 +1,29 @@
+import { TransformBase } from './transform-base';
+import { _Transaction, IValue, _Explainer, _ISelection, _SelectExplanation, Stats, nil, _IAlias, Row } from '../interfaces-private';
+import { ExprRef } from 'pgsql-ast-parser';
+export declare function buildAlias(on: _ISelection, alias?: string): _ISelection;
+export declare class Alias extends TransformBase implements _IAlias {
+    name: string;
+    private oldToThis;
+    private thisToOld;
+    private _columns;
+    private asRecord;
+    get isExecutionWithNoResult(): boolean;
+    constructor(sel: _ISelection, name: string);
+    listSelectableIdentities(): Iterable<IValue>;
+    rebuild(): void;
+    selectAlias(alias: string): _IAlias | nil;
+    listColumns(): Iterable<IValue>;
+    get debugId(): string | undefined;
+    get columns(): ReadonlyArray<IValue>;
+    init(): void;
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    hasItem(value: Row, t: _Transaction): boolean;
+    getColumn(column: string | ExprRef): IValue;
+    getColumn(column: string | ExprRef, nullIfNotFound?: boolean): IValue | nil;
+    private _getColumn;
+    explain(e: _Explainer): _SelectExplanation;
+    getIndex(...forValue: IValue[]): nil | import("../interfaces-private")._IIndex;
+}
+//# sourceMappingURL=alias.d.ts.map

package/types/transforms/and-filter.d.ts

@@ -0,0 +1,15 @@
+import { _ISelection, _IIndex, _Transaction, _Explainer, _SelectExplanation, Stats, nil, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+export declare class AndFilter extends FilterBase {
+    private filters;
+    get index(): _IIndex | nil;
+    private prevEntropy?;
+    entropy(t: _Transaction): number;
+    hasItem(value: Row, t: _Transaction): boolean;
+    constructor(filters: _ISelection[]);
+    private plan;
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=and-filter.d.ts.map

package/types/transforms/array-filter.d.ts

@@ -0,0 +1,14 @@
+import { FilterBase } from './transform-base';
+import { _ISelection, _Explainer, _SelectExplanation, _Transaction, Stats, Row } from '../interfaces-private';
+export declare class ArrayFilter extends FilterBase {
+    rows: Row[];
+    get index(): null;
+    entropy(): number;
+    hasItem(raw: Row): boolean;
+    getIndex(): null;
+    constructor(fromTable: _ISelection, rows: Row[]);
+    enumerate(): Iterable<Row>;
+    stats(t: _Transaction): Stats | null;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=array-filter.d.ts.map

package/types/transforms/between-filter.d.ts

@@ -0,0 +1,16 @@
+import { IValue, _Transaction, _Explainer, _SelectExplanation, Stats, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+export declare class BetweenFilter extends FilterBase {
+    private onValue;
+    private lo;
+    private hi;
+    private op;
+    private opDef;
+    entropy(t: _Transaction): number;
+    constructor(onValue: IValue, lo: any, hi: any, op: 'inside' | 'outside');
+    hasItem(value: Row, t: _Transaction): boolean;
+    enumerate(t: _Transaction): Iterable<Row>;
+    stats(t: _Transaction): Stats | null;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=between-filter.d.ts.map

package/types/transforms/build-filter.d.ts

@@ -0,0 +1,4 @@
+import { _ISelection } from '../interfaces-private';
+import { Expr } from 'pgsql-ast-parser';
+export declare function buildFilter(this: void, on: _ISelection, filter: Expr, parentName: string): _ISelection;
+//# sourceMappingURL=build-filter.d.ts.map

package/types/transforms/distinct.d.ts

@@ -0,0 +1,16 @@
+import { Expr } from 'pgsql-ast-parser';
+import { IValue, Row, Stats, _Explainer, _ISelection, _SelectExplanation, _Transaction } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+export declare function buildDistinct(on: _ISelection, exprs?: Expr[]): Distinct;
+declare class Distinct extends FilterBase {
+    private exprs;
+    get index(): null;
+    entropy(t: _Transaction): number;
+    hasItem(raw: Row, t: _Transaction): boolean;
+    constructor(selection: _ISelection, exprs: ReadonlyArray<IValue>);
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+}
+export {};
+//# sourceMappingURL=distinct.d.ts.map

package/types/transforms/eq-filter.d.ts

@@ -0,0 +1,17 @@
+import { IValue, _Transaction, _Explainer, _SelectExplanation, Stats, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+export declare class EqFilter extends FilterBase {
+    private onValue;
+    private equalsCst;
+    private op;
+    private matchNull;
+    private index;
+    private opDef;
+    entropy(t: _Transaction): number;
+    stats(t: _Transaction): Stats | null;
+    hasItem(item: Row, t: _Transaction): boolean;
+    constructor(onValue: IValue, equalsCst: any, op: 'eq' | 'neq', matchNull: boolean);
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=eq-filter.d.ts.map

package/types/transforms/false-filter.d.ts

@@ -0,0 +1,11 @@
+import { _Explainer, _SelectExplanation, _Transaction, Stats, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+export declare class FalseFilter extends FilterBase {
+    get index(): null;
+    entropy(): number;
+    hasItem(): boolean;
+    enumerate(): Iterable<Row>;
+    stats(t: _Transaction): Stats | null;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=false-filter.d.ts.map

package/types/transforms/in-filter.d.ts

@@ -0,0 +1,14 @@
+import { IValue, _Transaction, _Explainer, _SelectExplanation, Stats, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+export declare class InFilter extends FilterBase {
+    private onValue;
+    private elts;
+    private index;
+    entropy(t: _Transaction): number;
+    hasItem(item: Row, t: _Transaction): boolean;
+    constructor(onValue: IValue, elts: any[]);
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=in-filter.d.ts.map

package/types/transforms/ineq-filter.d.ts

@@ -0,0 +1,16 @@
+import { IValue, _Transaction, _Explainer, _SelectExplanation, Stats, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+export declare class IneqFilter extends FilterBase {
+    private onValue;
+    private op;
+    private than;
+    private index;
+    private opDef;
+    entropy(t: _Transaction): number;
+    hasItem(item: Row, t: _Transaction): boolean;
+    constructor(onValue: IValue, op: 'gt' | 'ge' | 'lt' | 'le', than: any);
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=ineq-filter.d.ts.map

package/types/transforms/join.d.ts

@@ -0,0 +1,74 @@
+import { _ISelection, IValue, _IIndex, _Transaction, _SelectExplanation, _Explainer, IndexExpression, IndexOp, IndexKey, _IndexExplanation, Stats, _IAlias, Row } from '../interfaces-private';
+import { nil } from '../interfaces';
+import { DataSourceBase } from './transform-base';
+import { ExprRef, JoinClause } from 'pgsql-ast-parser';
+import { SELECT_ALL } from '../execution/clean-results';
+interface JoinRaw {
+    '>restrictive': Row;
+    '>joined': Row;
+}
+interface JoinStrategy {
+    iterate: _ISelection;
+    iterateSide: 'joined' | 'restrictive';
+    joinIndex: _IIndex;
+    onValue: IValue;
+    othersPredicate?: IValue;
+}
+export declare class JoinSelection extends DataSourceBase {
+    readonly restrictive: _ISelection;
+    readonly joined: _ISelection;
+    readonly innerJoin: boolean;
+    get isExecutionWithNoResult(): boolean;
+    private _columns;
+    private seqScanExpression;
+    private joinId;
+    private columnsMappingParentToThis;
+    private indexOnRestrictingTableByValue;
+    private indexCache;
+    strategies: JoinStrategy[];
+    private building;
+    private ignoreDupes?;
+    private mergeSelect?;
+    isOriginOf(a: IValue): boolean;
+    get columns(): IValue[];
+    entropy(t: _Transaction): number;
+    constructor(restrictive: _ISelection, joined: _ISelection, on: JoinClause, innerJoin: boolean);
+    private wrap;
+    listSelectableIdentities(): Iterable<IValue>;
+    private fetchOnStrategies;
+    private fetchUsingStrategies;
+    private fetchAndStrategies;
+    private fetchEqStrategyOn;
+    getColumn(column: string | ExprRef): IValue;
+    getColumn(column: string | ExprRef, nullIfNotFound?: boolean): IValue | nil;
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<any>;
+    selectAlias(alias: string): _IAlias | nil;
+    iterateCatastrophicItem(item: any, others: any[], side: 'joined' | 'restrictive', t: _Transaction): Generator<any, void, unknown>;
+    private builder;
+    iterateStrategyItem(item: any, strategy: JoinStrategy, t: _Transaction): Generator<any, void, unknown>;
+    buildItem(l: Row, r: Row): {
+        '>joined': any;
+        '>restrictive': any;
+        [SELECT_ALL]: () => any;
+    };
+    private merge;
+    hasItem(value: JoinRaw): boolean;
+    getIndex(forValue: IValue): _IIndex | nil;
+    explain(e: _Explainer): _SelectExplanation;
+}
+export declare class JoinIndex implements _IIndex {
+    readonly owner: JoinSelection;
+    private base;
+    constructor(owner: JoinSelection, base: _IIndex);
+    get expressions(): IndexExpression[];
+    stats(t: _Transaction, key?: IndexKey): Stats | null;
+    iterateKeys(): null;
+    entropy(op: IndexOp): number;
+    eqFirst(rawKey: IndexKey, t: _Transaction): Row | null;
+    private chooseStrategy;
+    enumerate(op: IndexOp): Iterable<Row>;
+    explain(e: _Explainer): _IndexExplanation;
+}
+export {};
+//# sourceMappingURL=join.d.ts.map

package/types/transforms/limit.d.ts

@@ -0,0 +1,18 @@
+import { IValue, _ISelection, _Transaction, _Explainer, _SelectExplanation, Stats, nil, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+import { LimitStatement } from 'pgsql-ast-parser';
+export declare function buildLimit(on: _ISelection, limit: LimitStatement): LimitFilter;
+declare class LimitFilter extends FilterBase {
+    private selection;
+    private take;
+    private skip;
+    get index(): null;
+    entropy(t: _Transaction): number;
+    hasItem(raw: Row, t: _Transaction): boolean;
+    constructor(selection: _ISelection, take: IValue | nil, skip: IValue | nil);
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+}
+export {};
+//# sourceMappingURL=limit.d.ts.map

package/types/transforms/not-in-filter.d.ts

@@ -0,0 +1,15 @@
+import { IValue, _Transaction, _Explainer, _SelectExplanation, Stats, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+export declare class NotInFilter extends FilterBase {
+    private onValue;
+    private elts;
+    private index;
+    private keys;
+    entropy(t: _Transaction): number;
+    hasItem(item: Row, t: _Transaction): boolean;
+    constructor(onValue: IValue, elts: any[]);
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=not-in-filter.d.ts.map

package/types/transforms/or-filter.d.ts

@@ -0,0 +1,13 @@
+import { _ISelection, _Transaction, _Explainer, _SelectExplanation, Stats, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+export declare class OrFilter extends FilterBase {
+    private left;
+    private right;
+    entropy(t: _Transaction): number;
+    hasItem(value: Row, t: _Transaction): boolean;
+    constructor(left: _ISelection, right: _ISelection);
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=or-filter.d.ts.map

package/types/transforms/order-by.d.ts

@@ -0,0 +1,26 @@
+import { IValue, _ISelection, _Transaction, _Explainer, _SelectExplanation, Stats, _IAggregation, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+import { OrderByStatement, ExprCall } from 'pgsql-ast-parser';
+export declare function buildOrderBy(on: _ISelection, order: OrderByStatement[]): OrderBy;
+declare class OrderBy extends FilterBase implements _IAggregation {
+    private selection;
+    order: {
+        by: IValue;
+        order: 'ASC' | 'DESC';
+        nullsLast: boolean;
+    }[];
+    get index(): null;
+    isAggregation(): this is _IAggregation;
+    getAggregation(name: string, call: ExprCall): IValue;
+    checkIfIsKey(got: IValue): IValue;
+    private get asAggreg();
+    entropy(t: _Transaction): number;
+    hasItem(raw: Row, t: _Transaction): boolean;
+    constructor(selection: _ISelection, order: OrderByStatement[]);
+    stats(t: _Transaction): Stats | null;
+    getIndex(...forValue: IValue[]): import("../interfaces").nil | import("../interfaces-private")._IIndex;
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+}
+export {};
+//# sourceMappingURL=order-by.d.ts.map

package/types/transforms/restrictive-index.d.ts

@@ -0,0 +1,15 @@
+import { _IIndex, IndexExpression, _Transaction, IndexKey, _Explainer, _IndexExplanation, IndexOp, _ISelection, Stats, Row } from '../interfaces-private';
+export declare class RestrictiveIndex implements _IIndex {
+    private base;
+    readonly filter: _ISelection;
+    constructor(base: _IIndex, filter: _ISelection);
+    private match;
+    get expressions(): IndexExpression[];
+    stats(t: _Transaction, key?: IndexKey): Stats | null;
+    iterateKeys(): null;
+    eqFirst(rawKey: IndexKey, t: _Transaction): any;
+    entropy(t: IndexOp): number;
+    enumerate(op: IndexOp): Iterable<Row>;
+    explain(e: _Explainer): _IndexExplanation;
+}
+//# sourceMappingURL=restrictive-index.d.ts.map

package/types/transforms/selection.d.ts

@@ -0,0 +1,45 @@
+import { _ISelection, _IIndex, IValue, _IType, _Transaction, _Explainer, _SelectExplanation, IndexKey, _IndexExplanation, IndexExpression, IndexOp, Stats, _IAggregation, Row } from '../interfaces-private';
+import { nil } from '../interfaces';
+import { Evaluator, EvaluatorOptions } from '../evaluator';
+import { TransformBase } from './transform-base';
+import { SelectedColumn, Expr, ExprRef } from 'pgsql-ast-parser';
+export declare function buildSelection(on: _ISelection, select: SelectedColumn[] | nil): _ISelection | Selection;
+export declare function columnEvaluator(this: void, on: _ISelection, id: string, type: _IType, opts?: EvaluatorOptions): Evaluator<any>;
+export interface CustomAlias {
+    val: IValue;
+    as?: string;
+    expr?: Expr;
+}
+export declare class Selection extends TransformBase implements _ISelection {
+    private columnIds;
+    private columnsOrigin;
+    private columnMapping;
+    private indexCache;
+    private columnsById;
+    private symbol;
+    readonly columns: IValue[];
+    isAggregation(): this is _IAggregation;
+    constructor(base: _ISelection, _columns: (SelectedColumn | CustomAlias)[]);
+    private refColumn;
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    build(item: any, t: _Transaction): Row;
+    hasItem(value: Row, t: _Transaction): boolean;
+    getColumn(column: string | ExprRef): IValue;
+    getColumn(column: string | ExprRef, nullIfNotFound?: boolean): IValue | nil;
+    getIndex(val: IValue): _IIndex | nil;
+    explain(e: _Explainer): _SelectExplanation;
+}
+export declare class SelectionIndex implements _IIndex {
+    readonly owner: Selection;
+    private base;
+    constructor(owner: Selection, base: _IIndex);
+    stats(t: _Transaction, key?: IndexKey): Stats | null;
+    iterateKeys(t: _Transaction): Iterable<IndexKey> | null;
+    get expressions(): IndexExpression[];
+    entropy(op: IndexOp): number;
+    eqFirst(rawKey: IndexKey, t: _Transaction): any;
+    enumerate(op: IndexOp): Iterable<Row>;
+    explain(e: _Explainer): _IndexExplanation;
+}
+//# sourceMappingURL=selection.d.ts.map

package/types/transforms/seq-scan.d.ts

@@ -0,0 +1,14 @@
+import { IValue, _ISelection, _Transaction, _Explainer, _SelectExplanation, Stats, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+export declare class SeqScanFilter extends FilterBase {
+    private selection;
+    private getter;
+    get index(): null;
+    entropy(t: _Transaction): number;
+    hasItem(raw: Row, t: _Transaction): boolean;
+    constructor(selection: _ISelection, getter: IValue);
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=seq-scan.d.ts.map

package/types/transforms/startswith-filter.d.ts

@@ -0,0 +1,14 @@
+import { IValue, _Transaction, _Explainer, _SelectExplanation, Stats, Row } from '../interfaces-private';
+import { FilterBase } from './transform-base';
+export declare class StartsWithFilter extends FilterBase {
+    private onValue;
+    private startWith;
+    get index(): null;
+    entropy(t: _Transaction): number;
+    hasItem(item: Row, t: _Transaction): boolean;
+    constructor(onValue: IValue, startWith: string);
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+}
+//# sourceMappingURL=startswith-filter.d.ts.map