@depup/pg-mem 3.0.14-depup.0

package/types/datatypes/datatype-base.d.ts

@@ -0,0 +1,66 @@
+import { Evaluator } from '../evaluator';
+import { DataType, IValue, nil, Reg, _IType, _RelationBase, _Transaction } from '../interfaces-private';
+export declare function regGen(typeId: number | null): Reg;
+export declare abstract class TypeBase<TRaw = any> implements _IType<TRaw>, _RelationBase {
+    readonly reg: Reg;
+    get type(): 'type';
+    /**
+     * select a.oid, a.typname, b.typcategory  from  pg_catalog.pg_type a
+        left join pg_catalog.pg_type b on b.oid = a.typelem
+     */
+    constructor(typeId: number | null);
+    private _asArray?;
+    private _asList?;
+    abstract primary: DataType;
+    get name(): string;
+    get primaryName(): string;
+    /** Compute a custom unicty hash for a non null value */
+    doGetHash?(value: TRaw): string | number;
+    /** Can be casted to */
+    doCanCast?(to: _IType<TRaw>): boolean | nil;
+    /** Can be built to from (inverse of doCanCast()) */
+    doCanBuildFrom?(from: _IType): boolean | nil;
+    /**
+     * @see this.prefer() doc
+      */
+    doPrefer?(type: _IType<TRaw>): _IType | null;
+    /**
+     * @see this.canConvertImplicit() doc
+     */
+    doCanConvertImplicit?(to: _IType<TRaw>): boolean;
+    /** Perform conversion from this type to given type */
+    doCast?(value: Evaluator<TRaw>, to: _IType<TRaw>): Evaluator<any> | nil;
+    /** Perform conversion  given type to this type (inverse of doCast()) */
+    doBuildFrom?(value: Evaluator, from: _IType): Evaluator<TRaw> | nil;
+    doEquals(a: TRaw, b: TRaw): boolean;
+    doGt(a: TRaw, b: TRaw): boolean;
+    doLt(a: TRaw, b: TRaw): boolean;
+    toString(): string;
+    equals(a: TRaw, b: TRaw): boolean | null;
+    gt(a: TRaw, b: TRaw): boolean | null;
+    lt(a: TRaw, b: TRaw): boolean | null;
+    ge(a: TRaw, b: TRaw): boolean | null;
+    le(a: TRaw, b: TRaw): boolean | null;
+    /**
+     * When performing 'a+b', will be given 'b' type,
+     * this returns the prefered resulting type, or null if they are not compatible
+      */
+    prefer(to: _IType<TRaw>): _IType | nil;
+    /**
+     * Can constant literals be converted implicitely
+     * (without a cast... i.e. you can use both values as different values of a case expression, for instance)
+     **/
+    canConvertImplicit(to: _IType<TRaw>): boolean | nil;
+    /** Can be explicitely casted to */
+    canCast(to: _IType<TRaw>): boolean | nil;
+    /** Perform cast */
+    cast(_a: IValue<TRaw>, _to: _IType<any>): IValue;
+    /** Perform implicit conversion */
+    convertImplicit(_a: IValue<TRaw>, _to: _IType<any>): IValue;
+    private _convert;
+    asArray(): _IType<TRaw[]>;
+    asList(): _IType<TRaw[]>;
+    hash(value: any): string | number | null;
+    drop(t: _Transaction): void;
+}
+//# sourceMappingURL=datatype-base.d.ts.map

package/types/datatypes/datatypes-geometric.d.ts

@@ -0,0 +1,59 @@
+import { DataType } from '../interfaces';
+import { _IType } from '../interfaces-private';
+import { Box, Circle, Line, Path, Point, Polygon, Segment } from 'pgsql-ast-parser';
+import { Evaluator } from '../evaluator';
+import { TypeBase } from './datatype-base';
+export declare function pointToStr(p: Point): string;
+export declare function pointEq(a: Point, b: Point): boolean;
+export declare class PointType extends TypeBase<Point> {
+    get primary(): DataType;
+    get name(): string;
+    doCanCast(t: _IType): boolean;
+    doCast(value: Evaluator<Point>, to: _IType): Evaluator<Point>;
+    doEquals(a: Point, b: Point): boolean;
+    doGt(a: Point, b: Point): boolean;
+    doLt(a: Point, b: Point): boolean;
+}
+export declare class LineType extends TypeBase<Line> {
+    get primary(): DataType;
+    get name(): string;
+    doCanCast(t: _IType): boolean;
+    doCast(value: Evaluator<Line>, to: _IType): Evaluator<Line>;
+    doEquals(a: Line, b: Line): boolean;
+}
+export declare class LsegType extends TypeBase<Segment> {
+    get primary(): DataType;
+    get name(): string;
+    doCanCast(t: _IType): boolean;
+    doCast(value: Evaluator<Segment>, to: _IType): Evaluator<Segment>;
+    doEquals([as, ae]: Segment, [bs, be]: Segment): boolean;
+}
+export declare class BoxType extends TypeBase<Box> {
+    get primary(): DataType;
+    get name(): string;
+    doCanCast(t: _IType): boolean;
+    doCast(value: Evaluator<Box>, to: _IType): Evaluator<Box>;
+    doEquals([as, ae]: Box, [bs, be]: Box): boolean;
+}
+export declare class PathType extends TypeBase<Path> {
+    get primary(): DataType;
+    get name(): string;
+    doCanCast(t: _IType): boolean;
+    doCast(value: Evaluator<Path>, to: _IType): Evaluator<Path>;
+    doEquals(a: Path, b: Path): boolean;
+}
+export declare class PolygonType extends TypeBase<Polygon> {
+    get primary(): DataType;
+    get name(): string;
+    doCanCast(t: _IType): boolean;
+    doCast(value: Evaluator<Polygon>, to: _IType): Evaluator<Polygon>;
+    doEquals(a: Polygon, b: Polygon): boolean;
+}
+export declare class CircleType extends TypeBase<Circle> {
+    get primary(): DataType;
+    get name(): string;
+    doCanCast(t: _IType): boolean;
+    doCast(value: Evaluator<Circle>, to: _IType): Evaluator<Circle>;
+    doEquals(a: Circle, b: Circle): boolean;
+}
+//# sourceMappingURL=datatypes-geometric.d.ts.map

package/types/datatypes/datatypes-geometric.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=datatypes-geometric.spec.d.ts.map

package/types/datatypes/datatypes.d.ts

@@ -0,0 +1,101 @@
+import { IValue, _IType } from '../interfaces-private';
+import { DataType, IType, nil } from '../interfaces';
+import { Evaluator } from '../evaluator';
+import { TypeBase } from './datatype-base';
+declare class NullType extends TypeBase<null> {
+    get primary(): DataType;
+    doCast(value: Evaluator<any>, to: _IType): Evaluator<any>;
+    doCanCast(to: _IType): boolean;
+    doCanConvertImplicit(): boolean;
+    doEquals(a: any, b: any): boolean;
+    doGt(a: any, b: any): boolean;
+    doLt(a: any, b: any): boolean;
+    doPrefer(type: _IType): _IType<any>;
+}
+export declare class DefaultType extends NullType {
+}
+export declare const integers: ReadonlySet<DataType>;
+export declare const floats: ReadonlySet<DataType>;
+export declare const numbers: ReadonlySet<DataType>;
+export declare const numberPriorities: Record<DataType, number>;
+export declare function isNumeric(t: DataType | IType): boolean;
+export declare function isInteger(t: DataType | IType): boolean;
+declare class TextType extends TypeBase<string> {
+    readonly len: number | null;
+    private citext?;
+    get name(): string;
+    get primary(): DataType;
+    constructor(len: number | null, citext?: boolean | undefined);
+    doPrefer(to: _IType, stricterType?: boolean): _IType<any> | TextType | null;
+    doCanConvertImplicit(to: _IType): boolean;
+    doCanCast(to: _IType): boolean | nil;
+    doCast(value: Evaluator<string>, to: _IType): Evaluator<string> | undefined;
+    doEquals(a: string, b: string): boolean;
+}
+export declare class ArrayType extends TypeBase<any[]> {
+    readonly of: _IType;
+    private list;
+    static matches(type: IType): type is ArrayType;
+    get primary(): DataType;
+    get name(): string;
+    constructor(of: _IType, list: boolean);
+    doCanCast(to: _IType): boolean | nil;
+    doCast(value: Evaluator, _to: _IType): Evaluator<any>;
+    toText(to: _IType, value: Evaluator): Evaluator<any>;
+    toSingleColumn(to: _IType, value: Evaluator): Evaluator<any>;
+    doEquals(a: any[], b: any[]): boolean;
+    doGt(a: any[], b: any[]): boolean;
+    doLt(a: any[], b: any[]): boolean;
+    convertLiteral(elts: any): any[] | undefined;
+}
+export interface RecordCol {
+    readonly name: string;
+    readonly type: _IType;
+}
+/** Basic types */
+export declare const Types: {
+    record: (columns: RecordCol[]) => _IType;
+    bool: _IType;
+    text: (len?: number | nil) => _IType;
+    citext: TextType;
+    timestamp: (len?: number | nil) => _IType;
+    timestamptz: (len?: number | nil) => _IType;
+    uuid: _IType;
+    date: _IType;
+    interval: _IType;
+    time: _IType;
+    timetz: _IType;
+    jsonb: _IType;
+    regtype: _IType;
+    regclass: _IType;
+    json: _IType;
+    null: _IType;
+    float: _IType;
+    integer: _IType;
+    bigint: _IType;
+    bytea: _IType;
+    point: _IType;
+    line: _IType;
+    lseg: _IType;
+    box: _IType;
+    inet: _IType;
+    path: _IType;
+    polygon: _IType;
+    circle: _IType;
+    default: _IType;
+};
+export declare const dateTypes: ReadonlySet<DataType>;
+export declare function isDateType(_type: _IType | DataType): boolean;
+export declare function isGeometric(dt: DataType): boolean;
+export declare const typeSynonyms: {
+    [key: string]: DataType | {
+        type: DataType;
+        ignoreConfig: boolean;
+    };
+};
+/** Finds a common type by implicit conversion */
+export declare function reconciliateTypes(values: IValue[], nullIfNoMatch?: false, stricterType?: boolean): _IType;
+export declare function reconciliateTypes(values: IValue[], nullIfNoMatch: true, stricterType?: boolean): _IType | nil;
+export declare function reconciliateTypes(values: IValue[], nullIfNoMatch?: boolean, stricterType?: boolean): _IType | nil;
+export {};
+//# sourceMappingURL=datatypes.d.ts.map

package/types/datatypes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './datatypes';
+//# sourceMappingURL=index.d.ts.map

package/types/datatypes/t-custom-enum.d.ts

@@ -0,0 +1,21 @@
+import { Evaluator } from '../evaluator';
+import { TypeBase } from './datatype-base';
+import { DataType, nil } from '../interfaces';
+import { _IRelation, _ISchema, _IType, _Transaction } from '../interfaces-private';
+export declare function asEnum(o: _IRelation | null): CustomEnumType;
+export declare class CustomEnumType extends TypeBase<string> {
+    readonly schema: _ISchema;
+    private readonly _name;
+    readonly values: string[];
+    get primary(): DataType;
+    get name(): string;
+    constructor(schema: _ISchema, _name: string, values: string[]);
+    install(): void;
+    doCanCast(to: _IType): boolean;
+    doCast(value: Evaluator<string>, to: _IType<string>): Evaluator<any> | nil;
+    prefer(type: _IType<any>): _IType | nil;
+    doCanBuildFrom(from: _IType): boolean | nil;
+    doBuildFrom(value: Evaluator<string>, from: _IType<string>): Evaluator<string> | nil;
+    drop(t: _Transaction): void;
+}
+//# sourceMappingURL=t-custom-enum.d.ts.map

package/types/datatypes/t-equivalent.d.ts

@@ -0,0 +1,18 @@
+import { Evaluator } from '../evaluator';
+import { TypeBase } from './datatype-base';
+import { DataType, IEquivalentType, nil } from '../interfaces';
+import { _IType } from '../interfaces-private';
+export declare class EquivalentType extends TypeBase<string> {
+    private def;
+    private equiv;
+    constructor(def: IEquivalentType);
+    get primary(): DataType;
+    get primaryName(): string;
+    get name(): string;
+    doCanCast(to: _IType): boolean;
+    doCast(value: Evaluator<string>, to: _IType<string>): Evaluator<any> | nil;
+    prefer(type: _IType<any>): _IType | nil;
+    doCanBuildFrom(from: _IType): boolean | nil;
+    doBuildFrom(value: Evaluator<string>, from: _IType<string>): Evaluator<string> | nil;
+}
+//# sourceMappingURL=t-equivalent.d.ts.map

package/types/datatypes/t-inet.d.ts

@@ -0,0 +1,13 @@
+import { Evaluator } from '../evaluator';
+import { TypeBase } from './datatype-base';
+import { DataType, nil } from '../interfaces';
+import { _IType } from '../interfaces-private';
+export declare class INetType extends TypeBase<string> {
+    get primary(): DataType;
+    doCanCast(to: _IType): boolean;
+    doCast(value: Evaluator<string>, to: _IType<string>): Evaluator<any> | nil;
+    prefer(type: _IType<any>): _IType | nil;
+    doCanBuildFrom(from: _IType): boolean | nil;
+    doBuildFrom(value: Evaluator<string>, from: _IType<string>): Evaluator<string> | nil;
+}
+//# sourceMappingURL=t-inet.d.ts.map

package/types/datatypes/t-interval.d.ts

@@ -0,0 +1,13 @@
+import { DataType, nil, _IType } from '../interfaces-private';
+import { Interval } from 'pgsql-ast-parser';
+import { TypeBase } from './datatype-base';
+import { Evaluator } from '../evaluator';
+export declare class IntervalType extends TypeBase<Interval> {
+    get primary(): DataType;
+    doCanBuildFrom(from: _IType): boolean;
+    doBuildFrom(value: Evaluator, from: _IType): Evaluator<Interval> | nil;
+    doEquals(a: Interval, b: Interval): boolean;
+    doGt(a: Interval, b: Interval): boolean;
+    doLt(a: Interval, b: Interval): boolean;
+}
+//# sourceMappingURL=t-interval.d.ts.map

package/types/datatypes/t-jsonb.d.ts

@@ -0,0 +1,16 @@
+import { DataType, nil, _IType } from '../interfaces-private';
+import { TypeBase } from './datatype-base';
+import { Evaluator } from '../evaluator';
+export declare class JSONBType extends TypeBase<any> {
+    readonly primary: DataType;
+    constructor(primary: DataType, dataType: number);
+    doCanCast(_to: _IType): boolean | nil;
+    doCast(a: Evaluator, to: _IType): Evaluator;
+    doCanBuildFrom(from: _IType): boolean;
+    doBuildFrom(value: Evaluator, from: _IType): Evaluator<Date> | nil;
+    doEquals(a: any, b: any): boolean;
+    doGt(a: any, b: any): boolean;
+    doLt(a: any, b: any): boolean;
+    toResult(result: any): any;
+}
+//# sourceMappingURL=t-jsonb.d.ts.map

package/types/datatypes/t-record.d.ts

@@ -0,0 +1,17 @@
+import { DataType, nil, _IType, _ISelection, _Transaction } from '../interfaces-private';
+import { TypeBase } from './datatype-base';
+import { RecordCol } from './datatypes';
+import { Evaluator } from '../evaluator';
+export declare class RecordType extends TypeBase<any> {
+    readonly columns: readonly RecordCol[];
+    static matches(type: _IType): type is RecordType;
+    constructor(columns: readonly RecordCol[]);
+    get primary(): DataType;
+    doEquals(a: any, b: any): boolean;
+    static from(selection: _ISelection): RecordType;
+    /** Build a function that will transform a record of this type to a record of the target type  */
+    transformItemFrom(source: _ISelection): ((raw: any, t: _Transaction, execId: string) => any) | null;
+    doCanCast(to: _IType): boolean | nil;
+    doCast(value: Evaluator<any>, to: _IType): Evaluator<any> | nil;
+}
+//# sourceMappingURL=t-record.d.ts.map

package/types/datatypes/t-regclass.d.ts

@@ -0,0 +1,11 @@
+import { DataType, nil, RegClass, _IType } from '../interfaces-private';
+import { TypeBase } from './datatype-base';
+import { Evaluator } from '../evaluator';
+export declare class RegClassImpl extends TypeBase<RegClass> {
+    get primary(): DataType;
+    doCanCast(_to: _IType): boolean | nil;
+    doCast(a: Evaluator, to: _IType): Evaluator;
+    doCanBuildFrom(from: _IType): boolean;
+    doBuildFrom(value: Evaluator, from: _IType): Evaluator<RegClass> | nil;
+}
+//# sourceMappingURL=t-regclass.d.ts.map

package/types/datatypes/t-regtype.d.ts

@@ -0,0 +1,11 @@
+import { DataType, nil, RegClass, RegType, _IType } from '../interfaces-private';
+import { TypeBase } from './datatype-base';
+import { Evaluator } from '../evaluator';
+export declare class RegTypeImpl extends TypeBase<RegType> {
+    get primary(): DataType;
+    doCanCast(_to: _IType): boolean | nil;
+    doCast(a: Evaluator<RegType>, to: _IType): Evaluator;
+    doCanBuildFrom(from: _IType): boolean;
+    doBuildFrom(value: Evaluator, from: _IType): Evaluator<RegClass> | nil;
+}
+//# sourceMappingURL=t-regtype.d.ts.map

package/types/datatypes/t-time.d.ts

@@ -0,0 +1,14 @@
+import { DataType, nil, _IType } from '../interfaces-private';
+import { TypeBase } from './datatype-base';
+import { Evaluator } from '../evaluator';
+export declare class TimeType extends TypeBase<string> {
+    readonly primary: DataType.time | DataType.timetz;
+    constructor(primary: DataType.time | DataType.timetz);
+    get name(): string;
+    doCanCast(to: _IType): true | null;
+    doCanConvertImplicit(to: _IType): boolean;
+    doCast(value: Evaluator, to: _IType): Evaluator<any>;
+    doCanBuildFrom(from: _IType): boolean;
+    doBuildFrom(value: Evaluator, from: _IType): Evaluator<string> | nil;
+}
+//# sourceMappingURL=t-time.d.ts.map

package/types/datatypes/t-timestamp.d.ts

@@ -0,0 +1,18 @@
+import { DataType, nil, _IType } from '../interfaces-private';
+import { TypeBase } from './datatype-base';
+import { Evaluator } from '../evaluator';
+export declare class TimestampType extends TypeBase<Date> {
+    readonly primary: DataType;
+    readonly precision: number | null;
+    constructor(primary: DataType, typeId: number | null, precision?: number | null);
+    get name(): string;
+    doCanCast(to: _IType): boolean | null;
+    doCanConvertImplicit(to: _IType): boolean;
+    doCast(value: Evaluator, to: _IType): Evaluator<any>;
+    doCanBuildFrom(from: _IType): boolean;
+    doBuildFrom(value: Evaluator, from: _IType): Evaluator<Date> | nil;
+    doEquals(a: any, b: any): boolean;
+    doGt(a: any, b: any): boolean;
+    doLt(a: any, b: any): boolean;
+}
+//# sourceMappingURL=t-timestamp.d.ts.map

package/types/db.d.ts

@@ -0,0 +1,3 @@
+import { IMemoryDb, MemoryDbOptions } from './interfaces';
+export declare function newDb(opts?: MemoryDbOptions): IMemoryDb;
+//# sourceMappingURL=db.d.ts.map

package/types/evaluator.d.ts

@@ -0,0 +1,61 @@
+import { IValue, _IIndex, _ISelection, _IType, _Transaction, _Explainer, _ExprExplanation, Parameter } from './interfaces-private';
+import { nil, ArgDefDetails } from './interfaces';
+import { QName } from 'pgsql-ast-parser';
+export interface EvaluatorOptions {
+    isAny?: boolean;
+    isColumnOf?: _ISelection;
+    /** its type will act as if it is a constant literal (for parameters type resolution) */
+    actAsConstantLiteral?: boolean;
+    forceNotConstant?: boolean;
+    onCast?: (to: _IType) => void;
+    unpure?: boolean;
+}
+export declare class Evaluator<T = any> implements IValue<T> {
+    readonly type: _IType<T>;
+    readonly id: string | nil;
+    readonly hash: string;
+    val: nil | Object | number | string | Date | ((raw: any, transaction: _Transaction | nil) => any);
+    private opts?;
+    readonly isConstantLiteral: boolean;
+    readonly usedColumns: Set<IValue<any>>;
+    readonly forceNotConstant?: boolean;
+    get index(): _IIndex | nil;
+    get isConstant(): boolean;
+    get isConstantReal(): boolean;
+    origin: _ISelection | nil;
+    get isAny(): boolean;
+    constructor(type: _IType<T>, id: string | nil, hash: string, dependencies: IValue | IValue[] | nil, val: nil | Object | number | string | Date | ((raw: any, transaction: _Transaction | nil) => any), opts?: EvaluatorOptions | undefined);
+    setType(type: _IType): Evaluator<T>;
+    setConversion(converter: (val: T, t: _Transaction | nil) => any, hashConv: (hash: string) => any): Evaluator<T>;
+    setOrigin(origin: _ISelection): IValue;
+    clone(): Evaluator<T>;
+    map<TNew>(mapper: (val: T) => TNew, newType?: _IType<TNew>): IValue<TNew>;
+    setWrapper<TNew>(newOrigin: _ISelection, unwrap: (val: T) => TNew, newType?: _IType<TNew>): IValue<TNew>;
+    setId(newId: string): IValue;
+    get(): T;
+    get(raw: any, t: _Transaction | nil): T;
+    canCast(to: _IType<T>): boolean;
+    cast<T = any>(to: _IType<T>): IValue;
+    convertImplicit<T = any>(to: _IType<T>): IValue;
+    explain(e: _Explainer): _ExprExplanation;
+}
+export declare const Value: {
+    readonly null: (ofType?: _IType) => IValue;
+    readonly text: (value: string, length?: number | nil) => IValue;
+    readonly number: (value: number, type?: _IType<any>) => IValue;
+    readonly function: (value: string | QName, args: IValue[]) => IValue;
+    readonly bool: (value: boolean) => IValue;
+    /** @deprecated Use with care */
+    readonly constant: (_type: _IType, value: any) => IValue;
+    /** @deprecated Use with care */
+    readonly converter: (type: _IType, to: _IType) => (val: any, t: _Transaction | nil) => any;
+    readonly in: (value: IValue, array: IValue, inclusive: boolean) => IValue;
+    readonly isNull: (leftValue: IValue, expectNull: boolean) => IValue;
+    readonly isTrue: (leftValue: IValue, expectTrue: boolean) => IValue;
+    readonly isFalse: (leftValue: IValue, expectFalse: boolean) => IValue;
+    readonly negate: (value: IValue) => IValue;
+    readonly array: (values: IValue[]) => IValue;
+    readonly list: (values: IValue[]) => IValue;
+};
+export declare function buildParameterList(statementName: string | null, args: ArgDefDetails[]): Parameter[];
+//# sourceMappingURL=evaluator.d.ts.map

package/types/execution/clean-results.d.ts

@@ -0,0 +1,5 @@
+export declare const JSON_NIL: unique symbol;
+export declare const IS_PARTIAL_INDEXING: unique symbol;
+export declare const SELECT_ALL: unique symbol;
+export declare function cleanResults<T>(results: T): T;
+//# sourceMappingURL=clean-results.d.ts.map

package/types/execution/exec-utils.d.ts

@@ -0,0 +1,19 @@
+import { QName, Statement, NodeLocation } from 'pgsql-ast-parser';
+import { _ISchema, _Transaction } from '../interfaces-private';
+export declare function checkExistence(schema: _ISchema, name: QName, ifNotExists: boolean | undefined, act: () => void): boolean;
+export declare function locOf(p: Statement): NodeLocation;
+export declare abstract class ExecHelper {
+    private statement;
+    constructor(statement: Statement);
+    protected noData(t: _Transaction, name?: string): {
+        result: {
+            command: string;
+            fields: never[];
+            rowCount: number;
+            rows: never[];
+            location: NodeLocation;
+        };
+        state: _Transaction;
+    };
+}
+//# sourceMappingURL=exec-utils.d.ts.map

package/types/execution/records-mutations/deletion.d.ts

@@ -0,0 +1,8 @@
+import { _Transaction } from '../../interfaces-private';
+import { DeleteStatement } from 'pgsql-ast-parser';
+import { MutationDataSourceBase } from './mutation-base';
+export declare class Deletion extends MutationDataSourceBase {
+    constructor(ast: DeleteStatement);
+    protected performMutation(t: _Transaction): any[];
+}
+//# sourceMappingURL=deletion.d.ts.map

package/types/execution/records-mutations/insert.d.ts

@@ -0,0 +1,13 @@
+import { _Transaction } from '../../interfaces-private';
+import { InsertStatement } from 'pgsql-ast-parser';
+import { MutationDataSourceBase } from './mutation-base';
+export declare class Insert extends MutationDataSourceBase {
+    private valueRawSource;
+    private insertColumns;
+    private valueConvertedSource;
+    private opts;
+    constructor(ast: InsertStatement);
+    private visit;
+    protected performMutation(t: _Transaction): any[];
+}
+//# sourceMappingURL=insert.d.ts.map

package/types/execution/records-mutations/mutation-base.d.ts

@@ -0,0 +1,31 @@
+import { DataSourceBase } from '../../transforms/transform-base';
+import { _ISelection, _ITable, _Transaction, IValue, _IIndex, _Explainer, _IAggregation, Row } from '../../interfaces-private';
+import { InsertStatement, UpdateStatement, DeleteStatement, SetStatement, ExprRef } from 'pgsql-ast-parser';
+type MutationStatement = InsertStatement | UpdateStatement | DeleteStatement;
+export declare abstract class MutationDataSourceBase extends DataSourceBase {
+    protected table: _ITable;
+    protected mutatedSel: _ISelection;
+    static readonly affectedRows: unique symbol;
+    /** Perform the mutation, and returns the affected elements */
+    protected abstract performMutation(t: _Transaction): Row[];
+    private returningRows?;
+    private returning?;
+    private mutationResult;
+    get isExecutionWithNoResult(): boolean;
+    isAggregation(): this is _IAggregation;
+    get columns(): readonly IValue<any>[];
+    constructor(table: _ITable, mutatedSel: _ISelection, p: MutationStatement);
+    private _doExecuteOnce;
+    enumerate(t: _Transaction): Iterable<any>;
+    entropy(t: _Transaction): number;
+    getColumn(column: string | ExprRef, nullIfNotFound?: boolean | undefined): IValue;
+    hasItem(value: any, t: _Transaction): boolean;
+    getIndex(forValue: IValue): _IIndex | null | undefined;
+    explain(e: _Explainer): never;
+    isOriginOf(a: IValue): boolean;
+    stats(t: _Transaction): null;
+}
+export type Setter = (t: _Transaction, target: any, source: any) => void;
+export declare function createSetter(this: void, setTable: _ITable, setSelection: _ISelection, _sets: SetStatement[]): Setter;
+export {};
+//# sourceMappingURL=mutation-base.d.ts.map

package/types/execution/records-mutations/truncate-table.d.ts

@@ -0,0 +1,10 @@
+import { _Transaction, _IStatementExecutor, StatementResult } from '../../interfaces-private';
+import { TruncateTableStatement } from 'pgsql-ast-parser';
+import { ExecHelper } from '../exec-utils';
+export declare class TruncateTable extends ExecHelper implements _IStatementExecutor {
+    private table;
+    private opts;
+    constructor(statement: TruncateTableStatement);
+    execute(t: _Transaction): StatementResult;
+}
+//# sourceMappingURL=truncate-table.d.ts.map

package/types/execution/records-mutations/update.d.ts

@@ -0,0 +1,10 @@
+import { _Transaction } from '../../interfaces-private';
+import { UpdateStatement } from 'pgsql-ast-parser';
+import { MutationDataSourceBase } from './mutation-base';
+export declare class Update extends MutationDataSourceBase {
+    private setter;
+    private fetchObjectToUpdate?;
+    constructor(ast: UpdateStatement);
+    protected performMutation(t: _Transaction): any[];
+}
+//# sourceMappingURL=update.d.ts.map

package/types/execution/schema-amends/alter-enum.d.ts

@@ -0,0 +1,20 @@
+import { _Transaction, _IStatementExecutor, _IStatement } from '../../interfaces-private';
+import { AlterEnumType } from 'pgsql-ast-parser';
+import { ExecHelper } from '../exec-utils';
+export declare class AlterEnum extends ExecHelper implements _IStatementExecutor {
+    private p;
+    private onSchema;
+    private originalEnum;
+    constructor({ schema }: _IStatement, p: AlterEnumType);
+    execute(t: _Transaction): {
+        result: {
+            command: string;
+            fields: never[];
+            rowCount: number;
+            rows: never[];
+            location: import("pgsql-ast-parser").NodeLocation;
+        };
+        state: _Transaction;
+    };
+}
+//# sourceMappingURL=alter-enum.d.ts.map

package/types/execution/schema-amends/alter-sequence.d.ts

@@ -0,0 +1,19 @@
+import { _Transaction, _IStatementExecutor, _IStatement } from '../../interfaces-private';
+import { AlterSequenceStatement } from 'pgsql-ast-parser';
+import { ExecHelper } from '../exec-utils';
+export declare class AlterSequence extends ExecHelper implements _IStatementExecutor {
+    private p;
+    private seq;
+    constructor({ schema }: _IStatement, p: AlterSequenceStatement);
+    execute(t: _Transaction): {
+        result: {
+            command: string;
+            fields: never[];
+            rowCount: number;
+            rows: never[];
+            location: import("pgsql-ast-parser").NodeLocation;
+        };
+        state: _Transaction;
+    };
+}
+//# sourceMappingURL=alter-sequence.d.ts.map

package/types/execution/schema-amends/alter.d.ts

@@ -0,0 +1,19 @@
+import { _Transaction, _IStatementExecutor, _IStatement } from '../../interfaces-private';
+import { AlterTableStatement } from 'pgsql-ast-parser';
+import { ExecHelper } from '../exec-utils';
+export declare class Alter extends ExecHelper implements _IStatementExecutor {
+    private p;
+    private table;
+    constructor({ schema }: _IStatement, p: AlterTableStatement);
+    execute(t: _Transaction): {
+        result: {
+            command: string;
+            fields: never[];
+            rowCount: number;
+            rows: never[];
+            location: import("pgsql-ast-parser").NodeLocation;
+        };
+        state: _Transaction;
+    };
+}
+//# sourceMappingURL=alter.d.ts.map