autosql/dist/db/database.d.ts

An auto-parser of JSON into SQL.

import { QueryInput, DatabaseConfig, DialectConfig, AlterTableChanges, MetadataHeader, QueryResult, InsertInput } from '../config/types';
import { AutoSQLHandler } from "./autosql";
export declare abstract class Database {
    protected connection: any | null;
    protected config: DatabaseConfig;
    autoSQLHandler: AutoSQLHandler;
    startDate: Date;
    protected abstract getPermanentErrors(): Promise<string[]>;
    constructor(config: DatabaseConfig);
    getConfig(): DatabaseConfig;
    updateTableMetadata(table: string, metaData: MetadataHeader, type?: "metaData" | "existingMetaData"): void;
    updateSchema(schema: string): void;
    static create(config: DatabaseConfig): Database;
    getDialect(): import("../config/types").supportedDialects;
    abstract getDialectConfig(): DialectConfig;
    abstract establishDatabaseConnection(): Promise<void>;
    abstract testQuery(queryOrParams: QueryInput): Promise<any>;
    protected abstract executeQuery(queryOrParams: QueryInput): Promise<any>;
    establishConnection(): Promise<void>;
    testConnection(): Promise<boolean>;
    checkSchemaExists(schemaName: string | string[]): Promise<Record<string, boolean>>;
    createSchema(schemaName: string): Promise<Record<string, boolean>>;
    createTableQuery(table: string, headers: MetadataHeader): QueryInput[];
    alterTableQuery(table: string, oldHeaders: MetadataHeader, newHeaders: MetadataHeader): Promise<QueryInput[]>;
    dropTableQuery(table: string): QueryInput;
    startTransaction(): Promise<void>;
    commit(): Promise<void>;
    rollback(): Promise<void>;
    closeConnection(): Promise<{
        success: boolean;
        error?: string;
    }>;
    runQuery(queryOrParams: QueryInput): Promise<QueryResult>;
    runTransaction(queriesOrStrings: QueryInput[]): Promise<QueryResult>;
    runTransactionsWithConcurrency(queryGroups: QueryInput[][]): Promise<QueryResult[]>;
    getTableMetaData(schema: string, table: string): Promise<MetadataHeader | null>;
    abstract getCreateSchemaQuery(schemaName: string): QueryInput;
    abstract getCheckSchemaQuery(schemaName: string | string[]): QueryInput;
    abstract getCreateTableQuery(table: string, headers: MetadataHeader): QueryInput[];
    abstract getAlterTableQuery(table: string, alterTableChangesOrOldHeaders: AlterTableChanges | MetadataHeader, newHeaders?: MetadataHeader): Promise<QueryInput[]>;
    abstract getDropTableQuery(table: string): QueryInput;
    abstract getPrimaryKeysQuery(table: string): QueryInput;
    abstract getForeignKeyConstraintsQuery(table: string): QueryInput;
    abstract getViewDependenciesQuery(table: string): QueryInput;
    abstract getDropPrimaryKeyQuery(table: string): QueryInput;
    abstract getDropUniqueConstraintQuery(table: string, indexName: string): QueryInput;
    abstract getAddPrimaryKeyQuery(table: string, primaryKeys: string[]): QueryInput;
    abstract getUniqueIndexesQuery(table: string, column_name?: string): QueryInput;
    abstract getTableExistsQuery(schema: string, table: string): QueryInput;
    abstract getTableMetaDataQuery(schema: string, table: string): QueryInput;
    abstract getSplitTablesQuery(table: string): QueryInput;
    abstract getInsertStatementQuery(tableOrInput: string | InsertInput, data?: Record<string, any>[], metaData?: MetadataHeader, insertType?: "UPDATE" | "INSERT"): QueryInput;
    abstract getInsertFromStagingQuery(tableOrInput: string | InsertInput, metaData?: MetadataHeader, insertType?: "UPDATE" | "INSERT"): QueryInput;
    abstract getInsertChangedRowsToHistoryQuery(tableOrInput: string | InsertInput, metaData?: MetadataHeader): QueryInput;
    abstract getCreateTempTableQuery(table: string): QueryInput;
    abstract getConstraintConflictQuery(table: string, structure: {
        uniques: Record<string, string[]>;
        primary: string[];
    }): QueryInput;
    abstract getMaxConnections(): number;
    get autoSQL(): (table: string, data: Record<string, any>[], schema?: string, primaryKey?: string[]) => Promise<QueryResult>;
    get autoCreateTable(): (table: string, newMetaData: MetadataHeader, tableExists?: boolean, runQuery?: boolean) => Promise<QueryResult | QueryInput[]>;
    get autoAlterTable(): (table: string, tableChanges: AlterTableChanges, tableExists?: boolean, runQuery?: boolean) => Promise<QueryResult | QueryInput[]>;
    get fetchTableMetadata(): (table: string) => Promise<{
        currentMetaData: MetadataHeader | null;
        tableExists: boolean;
    }>;
    get splitTableData(): (table: string, data: Record<string, any>[], metaData: MetadataHeader) => Promise<{
        table: string;
        data: Record<string, any>[];
        metaData: MetadataHeader;
        previousMetaData: MetadataHeader;
        mergedMetaData: {
            changes: AlterTableChanges;
            updatedMetaData: MetadataHeader;
        };
    }[]>;
    get autoInsertData(): (inputOrTable: InsertInput | string, inputData?: Record<string, any>[], inputMetaData?: MetadataHeader, inputPreviousMetaData?: AlterTableChanges | MetadataHeader | null, inputComparedMetaData?: {
        changes: AlterTableChanges;
        updatedMetaData: MetadataHeader;
    }, inputRunQuery?: boolean, inputInsertType?: "UPDATE" | "INSERT") => Promise<QueryInput[] | QueryResult>;
    get handleMetadata(): (table: string, data: Record<string, any>[], primaryKey?: string[]) => Promise<{
        currentMetaData: MetadataHeader | null;
        mergedMetaData: MetadataHeader;
        initialComparedMetaData: {
            changes: AlterTableChanges;
            updatedMetaData: MetadataHeader;
        } | undefined;
        changes: AlterTableChanges | null;
        newMetaData: MetadataHeader;
    }>;
    get autoConfigureTable(): (inputOrTable: string | InsertInput, inputData?: Record<string, any>[] | null, inputCurrentMetaData?: MetadataHeader | AlterTableChanges | null, inputNewMetaData?: MetadataHeader | null, inputRunQuery?: boolean) => Promise<QueryResult | QueryInput[]>;
}
import { MySQLDatabase } from "./mysql";
import { PostgresDatabase } from "./pgsql";
export { MySQLDatabase, PostgresDatabase };
//# sourceMappingURL=database.d.ts.map