pg-mem/types/transforms/transform-base.d.ts

A memory version of postgres

import type { _ISelection, IValue, _IIndex, _ISchema, _IDb, _Transaction, _SelectExplanation, _Explainer, Stats, nil, _IAlias, Row, _IAggregation } from '../interfaces-private';
import type { buildSelection } from './selection';
import type { buildAlias } from './alias';
import type { buildFilter } from './build-filter';
import type { buildGroupBy } from './aggregation';
import type { buildLimit } from './limit';
import type { buildUnion } from './union';
import type { buildOrderBy } from './order-by';
import type { buildDistinct } from './distinct';
import { Expr, SelectedColumn, LimitStatement, OrderByStatement, ExprRef } from 'pgsql-ast-parser';
interface Fns {
    buildSelection: typeof buildSelection;
    buildAlias: typeof buildAlias;
    buildLimit: typeof buildLimit;
    buildUnion: typeof buildUnion;
    buildFilter: typeof buildFilter;
    buildGroupBy: typeof buildGroupBy;
    buildOrderBy: typeof buildOrderBy;
    buildDistinct: typeof buildDistinct;
}
export declare function initialize(init: Fns): void;
export declare abstract class DataSourceBase implements _ISelection {
    readonly ownerSchema: _ISchema;
    abstract enumerate(t: _Transaction): Iterable<Row>;
    abstract entropy(t: _Transaction): number;
    abstract readonly columns: ReadonlyArray<IValue>;
    abstract getColumn(column: string, nullIfNotFound?: boolean): IValue;
    abstract hasItem(value: Row, t: _Transaction): boolean;
    abstract getIndex(forValue: IValue): _IIndex | null | undefined;
    abstract explain(e: _Explainer): _SelectExplanation;
    abstract isOriginOf(a: IValue): boolean;
    abstract stats(t: _Transaction): Stats | null;
    abstract get isExecutionWithNoResult(): boolean;
    isAggregation(): this is _IAggregation;
    get db(): _IDb;
    constructor(ownerSchema: _ISchema);
    listColumns(): Iterable<IValue>;
    listSelectableIdentities(): Iterable<IValue>;
    select(select: (string | SelectedColumn)[] | nil): _ISelection;
    selectAlias(alias: string): _IAlias | nil;
    filter(filter: Expr | undefined | null): _ISelection;
    groupBy(grouping: Expr[] | nil): _ISelection;
    setAlias(alias?: string): _ISelection;
    limit(limit: LimitStatement): _ISelection;
    orderBy(orderBy: OrderByStatement[] | nil): _ISelection;
    distinct(exprs?: Expr[]): _ISelection;
    union(right: _ISelection): _ISelection;
}
export declare abstract class TransformBase extends DataSourceBase {
    readonly base: _ISelection;
    constructor(base: _ISelection);
    get isExecutionWithNoResult(): boolean;
    entropy(t: _Transaction): number;
    isOriginOf(a: IValue): boolean;
}
export declare abstract class FilterBase extends TransformBase {
    isAggregation(): this is _IAggregation;
    constructor(_base: _ISelection);
    get columns(): ReadonlyArray<IValue>;
    selectAlias(alias: string): nil | _IAlias;
    /**
    private _columns: IValue[];
    private _columnMappings: Map<IValue, IValue>;
    get columns(): ReadonlyArray<IValue> {
        this.initCols();
        return this._columns;
        // return this.base.columns;
    }

    private initCols() {
        if (this._columns) {
            return;
        }
        this._columns = [];
        this._columnMappings = new Map();
        for (const c of this.base.columns) {
            const nc = c.setOrigin(this);
            this._columns.push(nc);
            this._columnMappings.set(c, nc);
        }
    }

    getColumn(column: string, nullIfNotFound?: boolean): IValue {
        if (!this.base) { // istanbul ignore next
            throw new Error('Should not call .getColumn() on join');
        }
        if (!('columns' in this.base)) { // istanbul ignore next
            throw new Error('Should not call getColumn() on table');
        }
        this.initCols();
        const col = this.base.getColumn(column, nullIfNotFound);
        return col && this._columnMappings.get(col);
    }
     */
    getColumn(column: string | ExprRef): IValue;
    getColumn(column: string | ExprRef, nullIfNotFound?: boolean): IValue | nil;
    getIndex(...forValue: IValue[]): _IIndex | null | undefined;
}
export {};
//# sourceMappingURL=transform-base.d.ts.map