@depup/pg-mem 3.0.14-depup.0

package/types/transforms/transform-base.d.ts

@@ -0,0 +1,100 @@
+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

package/types/transforms/union.d.ts

@@ -0,0 +1,32 @@
+import { IValue, _ISelection, _Transaction, _Explainer, _SelectExplanation, Stats, _IIndex, _IType, _IAggregation, Row } from '../interfaces-private';
+import { DataSourceBase } from './transform-base';
+import { nil } from '../interfaces';
+import { ExprRef } from 'pgsql-ast-parser';
+export declare function buildUnion(left: _ISelection, right: _ISelection): Union;
+interface UCol {
+    name: string;
+    type: _IType;
+    lval: IValue;
+    rval: IValue;
+}
+declare class Union extends DataSourceBase {
+    private cols;
+    private left;
+    private right;
+    get isExecutionWithNoResult(): boolean;
+    isAggregation(): this is _IAggregation;
+    readonly columns: ReadonlyArray<IValue>;
+    private readonly colsByName;
+    entropy(t: _Transaction): number;
+    hasItem(raw: Row, t: _Transaction): boolean;
+    constructor(cols: UCol[], left: _ISelection, right: _ISelection);
+    stats(t: _Transaction): Stats | null;
+    enumerate(t: _Transaction): Iterable<Row>;
+    explain(e: _Explainer): _SelectExplanation;
+    getColumn(column: string | ExprRef): IValue;
+    getColumn(column: string | ExprRef, nullIfNotFound?: boolean): IValue | nil;
+    getIndex(...forValue: IValue[]): _IIndex | null | undefined;
+    isOriginOf(a: IValue): boolean;
+}
+export {};
+//# sourceMappingURL=union.d.ts.map

package/types/utils.d.ts

@@ -0,0 +1,86 @@
+import moment from 'moment';
+import { IValue, RegClass, _ISchema, _ISelection, _IType, _Transaction } from './interfaces-private';
+import { DataTypeDef, Expr, ExprRef, Interval, nil, QName } from 'pgsql-ast-parser';
+import { ISubscription, IType } from './interfaces';
+export declare const doRequire: any;
+export interface Ctor<T> extends Function {
+    new (...params: any[]): T;
+    prototype: T;
+}
+export type Optional<T> = {
+    [key in keyof T]?: T[key];
+};
+export type SRecord<T> = Record<string, T>;
+export declare function trimNullish<T>(value: T, depth?: number): T;
+export declare function watchUse<T>(rootValue: T): {
+    checked: T;
+    check?: () => string | null;
+};
+export declare function deepEqual<T>(a: T, b: T, strict?: boolean, depth?: number, numberDelta?: number): boolean;
+export declare function deepCompare<T>(a: T, b: T, strict?: boolean, depth?: number, numberDelta?: number): number;
+type Json = {
+    [key: string]: Json;
+} | Json[] | string | number | null;
+export declare function queryJson(a: Json, b: Json): boolean;
+export declare function buildLikeMatcher(likeCondition: string, caseSensitive?: boolean): (stringToMatch: string | number) => boolean | null;
+export declare function nullIsh(v: any): v is nil;
+export declare function hasNullish(...vals: any[]): boolean;
+export declare function sum(v: number[]): number;
+export declare function deepCloneSimple<T>(v: T, noSymbols?: boolean): T;
+export declare function isSelectAllArgList(select: Expr[]): boolean;
+export declare function ignore(...val: any[]): void;
+export declare function combineSubs(...vals: ISubscription[]): ISubscription;
+export interface ExecCtx {
+    readonly schema: _ISchema;
+    readonly transaction: _Transaction;
+    readonly parametersValues?: any[];
+}
+export declare function executionCtx(): ExecCtx;
+export declare function hasExecutionCtx(): boolean;
+export declare function isTopLevelExecutionContext(): boolean;
+export declare function pushExecutionCtx<T>(ctx: ExecCtx, act: () => T): T;
+export declare function indexHash(this: void, vals: (IValue | string)[]): string;
+export declare function randomString(length?: number, chars?: string): string;
+export declare function schemaOf(t: DataTypeDef): string | nil;
+export declare function isType(t: any): t is (_IType | IType);
+export declare namespace isType {
+    var TAG: symbol;
+}
+export declare function suggestColumnName(expr: Expr | nil): string | null;
+export declare function findTemplate<T>(this: void, selection: _ISelection, t: _Transaction, template?: T, columns?: (keyof T)[]): Iterable<T>;
+export declare function compareVersions(_a: string, _b: string): number;
+export declare function intervalToSec(v: Interval): number;
+export declare function parseRegClass(_reg: RegClass): QName | number;
+export declare function parseTime(str: string): moment.Moment;
+export declare function colByName<T>(refs: Map<string, T>, ref: string | ExprRef, nullIfNotFound: boolean | nil): T | nil;
+export declare function colToStr(col: string | ExprRef): string;
+export declare function qnameToStr(col: string | QName): string;
+export declare function asSingleName(col: string | ExprRef): string | nil;
+export declare function asSingleQName(col: string | QName, allowedSchema?: string): string | nil;
+export declare function errorMessage(error: unknown): string;
+export declare function it<T>(iterable: Iterable<T>): IteratorHelper<T>;
+export declare class IteratorHelper<T> implements Iterable<T> {
+    private underlying;
+    constructor(underlying: () => Iterable<T>);
+    [Symbol.iterator](): Iterator<T, any, undefined>;
+    flatten(): T extends Iterable<infer X> ? IteratorHelper<X> : never;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number) => U, initialValue: U): U;
+}
+export declare function fromEntries<K, V>(iterable: readonly (readonly [K, V])[]): Map<K, V>;
+export declare function notNil<T>(value: (T | nil)[] | nil): Exclude<T, null>[];
+/** Modify an array if necessary */
+export declare function modifyIfNecessary<T>(values: T[], mapper: (input: T) => T | nil): T[];
+export type LazySync<T> = (() => T) & {
+    invalidate: () => void;
+};
+export declare function lazySync<T>(ctor: () => T): LazySync<T>;
+export declare function timeoutOrImmediate(fn: () => void, time: number): any;
+export declare const delay: (time: number | undefined) => Promise<void>;
+export declare class AsyncQueue {
+    private queue;
+    private processing;
+    enqueue(task: () => Promise<any>): void;
+    private processQueue;
+}
+export {};
+//# sourceMappingURL=utils.d.ts.map