@depup/pg-mem 3.0.14-depup.0

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

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

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

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

package/types/execution/schema-amends/create-function.d.ts

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

package/types/execution/schema-amends/create-index.d.ts

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

package/types/execution/schema-amends/create-materialized-view.d.ts

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

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

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

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

@@ -0,0 +1,21 @@
+import { _ISchema, _Transaction, _IStatementExecutor } from '../../interfaces-private';
+import { CreateSequenceStatement } from 'pgsql-ast-parser';
+import { ExecHelper } from '../exec-utils';
+export declare class ExecuteCreateSequence extends ExecHelper implements _IStatementExecutor {
+    private p;
+    private acceptTempSequences;
+    schema: _ISchema;
+    constructor(inSchema: _ISchema, p: CreateSequenceStatement, acceptTempSequences: boolean);
+    execute(t: _Transaction): {
+        result: {
+            command: string;
+            fields: never[];
+            rowCount: number;
+            rows: never[];
+            location: import("pgsql-ast-parser").NodeLocation;
+        };
+        state: _Transaction;
+    };
+    createSeq(t: _Transaction): null;
+}
+//# sourceMappingURL=create-sequence.d.ts.map

package/types/execution/schema-amends/create-table.d.ts

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

package/types/execution/schema-amends/create-view.d.ts

@@ -0,0 +1,22 @@
+import { _Transaction, _IStatement, _IStatementExecutor, _IView } from '../../interfaces-private';
+import { CreateViewStatement } from 'pgsql-ast-parser';
+import { ExecHelper } from '../exec-utils';
+import { View } from '../../schema/view';
+export declare class CreateView extends ExecHelper implements _IStatementExecutor {
+    private schema;
+    private drop;
+    existing: _IView | null;
+    toRegister: View;
+    constructor(st: _IStatement, p: CreateViewStatement);
+    execute(t: _Transaction): {
+        result: {
+            command: string;
+            fields: never[];
+            rowCount: number;
+            rows: never[];
+            location: import("pgsql-ast-parser").NodeLocation;
+        };
+        state: _Transaction;
+    };
+}
+//# sourceMappingURL=create-view.d.ts.map

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

@@ -0,0 +1,9 @@
+import { _IStatementExecutor, _Transaction, StatementResult, _IStatement } from '../../interfaces-private';
+import { DoStatement } from 'pgsql-ast-parser';
+import { ExecHelper } from '../../execution/exec-utils';
+export declare class DoStatementExec extends ExecHelper implements _IStatementExecutor {
+    private compiled;
+    constructor({ schema }: _IStatement, st: DoStatement);
+    execute(t: _Transaction): StatementResult;
+}
+//# sourceMappingURL=do.d.ts.map

package/types/execution/schema-amends/drop-index.d.ts

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

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

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

package/types/execution/schema-amends/drop-table.d.ts

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

package/types/execution/schema-amends/drop-type.d.ts

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

package/types/execution/select.d.ts

@@ -0,0 +1,15 @@
+import { _IStatementExecutor, _Transaction, StatementResult, _IStatement, _ISelection, _ISchema } from '../interfaces-private';
+import { WithStatementBinding, SelectStatement, WithStatement, ValuesStatement } from 'pgsql-ast-parser';
+export declare function buildValues(p: ValuesStatement, acceptDefault?: boolean): _ISelection;
+export declare function buildSelect(p: SelectStatement): _ISelection;
+export declare function buildWith(p: WithStatement, topLevel: boolean): _ISelection;
+export declare class SelectExec implements _IStatementExecutor {
+    private statement;
+    private p;
+    readonly selection: _ISelection;
+    constructor(statement: _IStatement, p: WithStatementBinding);
+    get schema(): _ISchema;
+    execute(t: _Transaction): StatementResult;
+}
+export declare const TYPE_SYMBOL: unique symbol;
+//# sourceMappingURL=select.d.ts.map

package/types/execution/set.d.ts

@@ -0,0 +1,9 @@
+import { _IStatementExecutor, _Transaction, StatementResult } from '../interfaces-private';
+import { SetGlobalStatement, SetTimezone, SetNames } from 'pgsql-ast-parser';
+import { ExecHelper } from './exec-utils';
+export declare class SetExecutor extends ExecHelper implements _IStatementExecutor {
+    private p;
+    constructor(p: SetGlobalStatement | SetTimezone | SetNames);
+    execute(t: _Transaction): StatementResult;
+}
+//# sourceMappingURL=set.d.ts.map

package/types/execution/show.d.ts

@@ -0,0 +1,8 @@
+import { _IStatementExecutor, _Transaction, StatementResult } from '../interfaces-private';
+import { ShowStatement } from 'pgsql-ast-parser';
+export declare class ShowExecutor implements _IStatementExecutor {
+    private statement;
+    constructor(statement: ShowStatement);
+    execute(t: _Transaction): StatementResult;
+}
+//# sourceMappingURL=show.d.ts.map

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

@@ -0,0 +1,26 @@
+import { _ISchema, _Transaction, _IStatement, nil, OnStatementExecuted, _IStatementExecutor, StatementResult, Parameter } from '../interfaces-private';
+import { Statement } from 'pgsql-ast-parser';
+import { ExecHelper } from './exec-utils';
+export declare class SimpleExecutor extends ExecHelper implements _IStatementExecutor {
+    private exec;
+    private opName?;
+    constructor(st: Statement, exec: (t: _Transaction) => void, opName?: string | undefined);
+    execute(t: _Transaction): StatementResult;
+}
+export declare class StatementExec implements _IStatement {
+    readonly schema: _ISchema;
+    private statement;
+    private pAsSql;
+    private parameters?;
+    private onExecutedCallbacks;
+    private executor?;
+    private checkAstCoverage?;
+    constructor(schema: _ISchema, statement: Statement, pAsSql: string | nil, parameters?: Parameter[] | undefined);
+    onExecuted(callback: OnStatementExecuted): void;
+    private get db();
+    private _getExecutor;
+    compile(): _IStatementExecutor;
+    executeStatement(t: _Transaction, parametersValues: any[]): StatementResult;
+    private niceErrors;
+}
+//# sourceMappingURL=statement-exec.d.ts.map

package/types/execution/transaction-statements.d.ts

@@ -0,0 +1,16 @@
+import { _IStatementExecutor, _Transaction, StatementResult } from '../interfaces-private';
+import { ExecHelper } from './exec-utils';
+import { CommitStatement, RollbackStatement, StartTransactionStatement, BeginStatement } from 'pgsql-ast-parser';
+export declare class CommitExecutor extends ExecHelper implements _IStatementExecutor {
+    constructor(statement: CommitStatement);
+    execute(t: _Transaction): StatementResult;
+}
+export declare class RollbackExecutor extends ExecHelper implements _IStatementExecutor {
+    constructor(statement: RollbackStatement);
+    execute(t: _Transaction): StatementResult;
+}
+export declare class BeginStatementExec extends ExecHelper implements _IStatementExecutor {
+    constructor(statement: BeginStatement | StartTransactionStatement);
+    execute(t: _Transaction): StatementResult;
+}
+//# sourceMappingURL=transaction-statements.d.ts.map

package/types/functions/date.d.ts

@@ -0,0 +1,3 @@
+import { FunctionDefinition } from '../interfaces';
+export declare const dateFunctions: FunctionDefinition[];
+//# sourceMappingURL=date.d.ts.map

package/types/functions/index.d.ts

@@ -0,0 +1,2 @@
+export declare const allFunctions: import("..").FunctionDefinition[];
+//# sourceMappingURL=index.d.ts.map

package/types/functions/numbers.d.ts

@@ -0,0 +1,3 @@
+import { FunctionDefinition } from "../interfaces";
+export declare const numberFunctions: FunctionDefinition[];
+//# sourceMappingURL=numbers.d.ts.map

package/types/functions/sequence-fns.d.ts

@@ -0,0 +1,3 @@
+import { FunctionDefinition } from '../interfaces';
+export declare const sequenceFunctions: FunctionDefinition[];
+//# sourceMappingURL=sequence-fns.d.ts.map

package/types/functions/string.d.ts

@@ -0,0 +1,3 @@
+import { FunctionDefinition } from '../interfaces-private';
+export declare const stringFunctions: FunctionDefinition[];
+//# sourceMappingURL=string.d.ts.map

package/types/functions/subquery.d.ts

@@ -0,0 +1,3 @@
+import { FunctionDefinition } from '../interfaces';
+export declare const subqueryFunctions: FunctionDefinition[];
+//# sourceMappingURL=subquery.d.ts.map

package/types/functions/system.d.ts

@@ -0,0 +1,3 @@
+import { FunctionDefinition } from '../interfaces';
+export declare const systemFunctions: FunctionDefinition[];
+//# sourceMappingURL=system.d.ts.map

package/types/index.d.ts

@@ -0,0 +1,5 @@
+export { newDb } from './db';
+export { enableStatementLocationTracking } from './parser/parse-cache';
+export { replaceQueryArgs$ } from './adapters';
+export * from './interfaces';
+//# sourceMappingURL=index.d.ts.map