dbgate-datalib 5.0.8 → 5.1.1

package/lib/PerspectiveDataProvider.js

@@ -0,0 +1,181 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerspectiveDataProvider = exports.PERSPECTIVE_PAGE_SIZE = void 0;
+const debug_1 = __importDefault(require("debug"));
+exports.PERSPECTIVE_PAGE_SIZE = 100;
+const dbg = (0, debug_1.default)('dbgate:PerspectiveDataProvider');
+class PerspectiveDataProvider {
+    constructor(cache, loader) {
+        this.cache = cache;
+        this.loader = loader;
+    }
+    loadData(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            dbg('load data', props);
+            // console.log('LOAD DATA', props);
+            if (props.bindingColumns) {
+                return this.loadDataNested(props);
+            }
+            else {
+                return this.loadDataFlat(props);
+            }
+        });
+    }
+    loadDataNested(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tableCache = this.cache.getTableCache(props);
+            const uncached = tableCache.getUncachedBindingGroups(props);
+            if (uncached.length > 0) {
+                const counts = yield this.loader.loadGrouping(Object.assign(Object.assign({}, props), { bindingValues: uncached }));
+                // console.log('COUNTS', counts);
+                for (const resetItem of uncached) {
+                    tableCache.storeGroupSize(props, resetItem, 0);
+                }
+                for (const countItem of counts) {
+                    const { _perspective_group_size_ } = countItem, fields = __rest(countItem, ["_perspective_group_size_"]);
+                    tableCache.storeGroupSize(props, props.bindingColumns.map(col => fields[col]), _perspective_group_size_);
+                }
+            }
+            const rows = [];
+            // console.log('CACHE', tableCache.bindingGroups);
+            let groupIndex = 0;
+            let loadCalled = false;
+            let shouldReturn = false;
+            for (; groupIndex < props.bindingValues.length; groupIndex++) {
+                const groupValues = props.bindingValues[groupIndex];
+                const group = tableCache.getBindingGroup(groupValues);
+                if (!group.loadedAll) {
+                    if (loadCalled) {
+                        shouldReturn = true;
+                    }
+                    else {
+                        // we need to load next data
+                        yield this.loadNextGroup(props, groupIndex);
+                        loadCalled = true;
+                    }
+                }
+                // console.log('GRP', groupValues, group);
+                rows.push(...group.loadedRows);
+                if (rows.length >= props.topCount || shouldReturn) {
+                    return {
+                        rows: rows.slice(0, props.topCount),
+                        incomplete: props.topCount < rows.length || !group.loadedAll || groupIndex < props.bindingValues.length - 1,
+                    };
+                }
+            }
+            if (groupIndex >= props.bindingValues.length) {
+                // all groups are fully loaded
+                return { rows, incomplete: false };
+            }
+        });
+    }
+    loadNextGroup(props, groupIndex) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tableCache = this.cache.getTableCache(props);
+            const planLoadingGroupIndexes = [];
+            const planLoadingGroups = [];
+            let planLoadRowCount = 0;
+            const loadPlanned = () => __awaiter(this, void 0, void 0, function* () {
+                // console.log(
+                //   'LOAD PLANNED',
+                //   planLoadingGroupIndexes,
+                //   planLoadingGroupIndexes.map(idx => props.bindingValues[idx])
+                // );
+                const rows = yield this.loader.loadData(Object.assign(Object.assign({}, props), { bindingValues: planLoadingGroupIndexes.map(idx => props.bindingValues[idx]) }));
+                // console.log('LOADED PLANNED', rows);
+                // distribute rows into groups
+                for (const row of rows) {
+                    const group = planLoadingGroups.find(x => x.matchRow(row));
+                    if (group) {
+                        group.loadedRows.push(row);
+                    }
+                }
+                for (const group of planLoadingGroups) {
+                    group.loadedAll = true;
+                }
+            });
+            for (; groupIndex < props.bindingValues.length; groupIndex++) {
+                const groupValues = props.bindingValues[groupIndex];
+                const group = tableCache.getBindingGroup(groupValues);
+                if (!group)
+                    continue;
+                if (group.loadedAll)
+                    continue;
+                if (group.groupSize == 0) {
+                    group.loadedAll = true;
+                    continue;
+                }
+                if (group.groupSize >= exports.PERSPECTIVE_PAGE_SIZE) {
+                    if (planLoadingGroupIndexes.length > 0) {
+                        yield loadPlanned();
+                        return;
+                    }
+                    const nextRows = yield this.loader.loadData(Object.assign(Object.assign({}, props), { topCount: null, range: {
+                            offset: group.loadedRows.length,
+                            limit: exports.PERSPECTIVE_PAGE_SIZE,
+                        }, bindingValues: [group.bindingValues] }));
+                    group.loadedRows = [...group.loadedRows, ...nextRows];
+                    group.loadedAll = nextRows.length < exports.PERSPECTIVE_PAGE_SIZE;
+                    return;
+                }
+                else {
+                    if (planLoadRowCount + group.groupSize > exports.PERSPECTIVE_PAGE_SIZE) {
+                        yield loadPlanned();
+                        return;
+                    }
+                    planLoadingGroupIndexes.push(groupIndex);
+                    planLoadingGroups.push(group);
+                    planLoadRowCount += group.groupSize;
+                }
+            }
+            if (planLoadingGroupIndexes.length > 0) {
+                yield loadPlanned();
+            }
+        });
+    }
+    loadDataFlat(props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tableCache = this.cache.getTableCache(props);
+            if (props.topCount <= tableCache.loadedCount) {
+                return tableCache.getRowsResult(props);
+            }
+            // load missing rows
+            tableCache.dataColumns = props.dataColumns;
+            const nextRows = yield this.loader.loadData(Object.assign(Object.assign({}, props), { topCount: null, range: {
+                    offset: tableCache.loadedCount,
+                    limit: props.topCount - tableCache.loadedCount,
+                } }));
+            if (nextRows.errorMessage) {
+                throw new Error(nextRows.errorMessage);
+            }
+            tableCache.loadedRows = [...tableCache.loadedRows, ...nextRows];
+            tableCache.loadedAll = nextRows.length < props.topCount - tableCache.loadedCount;
+            // const rows=tableCache.getRows(props);
+            return tableCache.getRowsResult(props);
+        });
+    }
+}
+exports.PerspectiveDataProvider = PerspectiveDataProvider;

package/lib/PerspectiveDisplay.d.ts

@@ -0,0 +1,55 @@
+import { PerspectiveTreeNode } from './PerspectiveTreeNode';
+export declare class PerspectiveDisplayColumn {
+    display: PerspectiveDisplay;
+    title: string;
+    dataField: string;
+    parentNodes: PerspectiveTreeNode[];
+    colSpanAtLevel: {};
+    columnIndex: number;
+    dataNode: PerspectiveTreeNode;
+    constructor(display: PerspectiveDisplay);
+    get rowSpan(): number;
+    showParent(level: number): boolean;
+    getColSpan(level: number): any;
+    isVisible(level: number): boolean;
+    get columnLevel(): number;
+    getParentName(level: any): any;
+    getParentNode(level: any): PerspectiveTreeNode;
+    getParentTableDesignerId(level: any): string;
+}
+interface PerspectiveSubRowCollection {
+    rows: CollectedPerspectiveDisplayRow[];
+}
+interface CollectedPerspectiveDisplayRow {
+    columnIndexes: number[];
+    rowData: any[];
+    subRowCollections: PerspectiveSubRowCollection[];
+    incompleteRowsIndicator?: string[];
+}
+export declare class PerspectiveDisplayRow {
+    display: PerspectiveDisplay;
+    constructor(display: PerspectiveDisplay);
+    rowData: any[];
+    rowSpans: number[];
+    rowCellSkips: boolean[];
+    rowJoinIds: number[];
+}
+export declare class PerspectiveDisplay {
+    root: PerspectiveTreeNode;
+    columns: PerspectiveDisplayColumn[];
+    rows: PerspectiveDisplayRow[];
+    readonly columnLevelCount: number;
+    loadIndicatorsCounts: {
+        [designerId: string]: number;
+    };
+    constructor(root: PerspectiveTreeNode, rows: any[]);
+    private getRowAt;
+    fillColumns(children: PerspectiveTreeNode[], parentNodes: PerspectiveTreeNode[]): void;
+    processColumn(node: PerspectiveTreeNode, parentNodes: PerspectiveTreeNode[]): void;
+    findColumnIndexFromNode(node: PerspectiveTreeNode): number;
+    collectRows(sourceRows: any[], nodes: PerspectiveTreeNode[]): CollectedPerspectiveDisplayRow[];
+    fillRowSpans(): void;
+    mergeRows(collectedRows: CollectedPerspectiveDisplayRow[]): void;
+    mergeRow(collectedRow: CollectedPerspectiveDisplayRow, rowIndex: number): number;
+}
+export {};

package/lib/PerspectiveDisplay.js

@@ -0,0 +1,229 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerspectiveDisplay = exports.PerspectiveDisplayRow = exports.PerspectiveDisplayColumn = void 0;
+const max_1 = __importDefault(require("lodash/max"));
+const fill_1 = __importDefault(require("lodash/fill"));
+const findIndex_1 = __importDefault(require("lodash/findIndex"));
+const debug_1 = __importDefault(require("debug"));
+const dbg = (0, debug_1.default)('dbgate:PerspectiveDisplay');
+let lastJoinId = 0;
+function getJoinId() {
+    lastJoinId += 1;
+    return lastJoinId;
+}
+class PerspectiveDisplayColumn {
+    constructor(display) {
+        this.display = display;
+        this.parentNodes = [];
+        this.colSpanAtLevel = {};
+        this.columnIndex = 0;
+        this.dataNode = null;
+    }
+    get rowSpan() {
+        return this.display.columnLevelCount - this.parentNodes.length;
+    }
+    showParent(level) {
+        return !!this.colSpanAtLevel[level];
+    }
+    getColSpan(level) {
+        return this.colSpanAtLevel[level];
+    }
+    isVisible(level) {
+        return level == this.columnLevel;
+    }
+    get columnLevel() {
+        return this.parentNodes.length;
+    }
+    getParentName(level) {
+        var _a;
+        return (_a = this.parentNodes[level]) === null || _a === void 0 ? void 0 : _a.title;
+    }
+    getParentNode(level) {
+        return this.parentNodes[level];
+    }
+    getParentTableDesignerId(level) {
+        var _a, _b;
+        return ((_a = this.parentNodes[level]) === null || _a === void 0 ? void 0 : _a.headerTableAttributes) ? (_b = this.parentNodes[level]) === null || _b === void 0 ? void 0 : _b.designerId : '';
+    }
+}
+exports.PerspectiveDisplayColumn = PerspectiveDisplayColumn;
+class PerspectiveDisplayRow {
+    constructor(display) {
+        this.display = display;
+        this.rowData = [];
+        this.rowSpans = null;
+        this.rowCellSkips = null;
+        this.rowJoinIds = [];
+        this.rowData = (0, fill_1.default)(Array(display.columns.length), undefined);
+        this.rowSpans = (0, fill_1.default)(Array(display.columns.length), 1);
+        this.rowJoinIds = (0, fill_1.default)(Array(display.columns.length), 0);
+        this.rowCellSkips = (0, fill_1.default)(Array(display.columns.length), false);
+    }
+}
+exports.PerspectiveDisplayRow = PerspectiveDisplayRow;
+class PerspectiveDisplay {
+    constructor(root, rows) {
+        this.root = root;
+        this.columns = [];
+        this.rows = [];
+        this.loadIndicatorsCounts = {};
+        // dbg('source rows', rows);
+        this.fillColumns(root.childNodes, [root]);
+        if (this.columns.length > 0) {
+            this.columns[0].colSpanAtLevel[0] = this.columns.length;
+        }
+        this.columnLevelCount = (0, max_1.default)(this.columns.map(x => x.parentNodes.length)) + 1;
+        const collectedRows = this.collectRows(rows, root.childNodes);
+        dbg('collected rows', collectedRows);
+        // console.log('COLLECTED', JSON.stringify(collectedRows, null, 2));
+        // this.mergeRows(collectedRows);
+        this.mergeRows(collectedRows);
+        // dbg('merged rows', this.rows);
+        // console.log(
+        //   'MERGED',
+        //   this.rows.map(r =>
+        //     r.incompleteRowsIndicator
+        //       ? `************************************ ${r.incompleteRowsIndicator.join('|')}`
+        //       : r.rowData.join('|')
+        //   )
+        // );
+    }
+    getRowAt(rowIndex) {
+        while (this.rows.length <= rowIndex) {
+            this.rows.push(new PerspectiveDisplayRow(this));
+        }
+        return this.rows[rowIndex];
+    }
+    fillColumns(children, parentNodes) {
+        for (const child of children) {
+            if (child.isCheckedColumn || child.isCheckedNode) {
+                this.processColumn(child, parentNodes);
+            }
+        }
+    }
+    processColumn(node, parentNodes) {
+        if (node.isCheckedColumn) {
+            const column = new PerspectiveDisplayColumn(this);
+            column.title = node.columnTitle;
+            column.dataField = node.dataField;
+            column.parentNodes = parentNodes;
+            column.display = this;
+            column.columnIndex = this.columns.length;
+            column.dataNode = node;
+            this.columns.push(column);
+        }
+        if (node.isExpandable && node.isCheckedNode) {
+            const countBefore = this.columns.length;
+            this.fillColumns(node.childNodes, [...parentNodes, node]);
+            if (this.columns.length > countBefore) {
+                this.columns[countBefore].colSpanAtLevel[parentNodes.length] = this.columns.length - countBefore;
+            }
+        }
+    }
+    findColumnIndexFromNode(node) {
+        return (0, findIndex_1.default)(this.columns, x => { var _a, _b, _c; return x.dataNode.columnName == node.columnName && ((_b = (_a = x.dataNode) === null || _a === void 0 ? void 0 : _a.parentNode) === null || _b === void 0 ? void 0 : _b.designerId) == ((_c = node === null || node === void 0 ? void 0 : node.parentNode) === null || _c === void 0 ? void 0 : _c.designerId); });
+    }
+    // findColumnIndexFromNode(node: PerspectiveTreeNode) {
+    //   return _findIndex(this.columns, x => x.dataNode.designerId == node.designerId);
+    // }
+    collectRows(sourceRows, nodes) {
+        // console.log('********** COLLECT ROWS', sourceRows);
+        const columnNodes = nodes.filter(x => x.isCheckedColumn);
+        const treeNodes = nodes.filter(x => x.isCheckedNode);
+        // console.log('columnNodes', columnNodes);
+        // console.log('treeNodes', treeNodes);
+        const columnIndexes = columnNodes.map(node => this.findColumnIndexFromNode(node));
+        const res = [];
+        for (const sourceRow of sourceRows) {
+            // console.log('PROCESS SOURCE', sourceRow);
+            // row.startIndex = startIndex;
+            const rowData = columnNodes.map(node => sourceRow[node.codeName]);
+            const subRowCollections = [];
+            for (const node of treeNodes) {
+                if (sourceRow[node.fieldName]) {
+                    const subrows = {
+                        rows: this.collectRows(sourceRow[node.fieldName], node.childNodes),
+                    };
+                    subRowCollections.push(subrows);
+                }
+            }
+            res.push({
+                rowData,
+                columnIndexes,
+                subRowCollections,
+                incompleteRowsIndicator: sourceRow.incompleteRowsIndicator,
+            });
+        }
+        return res;
+    }
+    fillRowSpans() {
+        for (let col = 0; col < this.columns.length; col++) {
+            // let lastFilledJoinId = null;
+            let lastFilledRow = 0;
+            let rowIndex = 0;
+            for (const row of this.rows) {
+                if (row.rowData[col] === undefined &&
+                    row.rowJoinIds[col] == this.rows[lastFilledRow].rowJoinIds[col] &&
+                    row.rowJoinIds[col]) {
+                    row.rowCellSkips[col] = true;
+                    this.rows[lastFilledRow].rowSpans[col] = rowIndex - lastFilledRow + 1;
+                }
+                else {
+                    lastFilledRow = rowIndex;
+                }
+                rowIndex++;
+            }
+        }
+    }
+    mergeRows(collectedRows) {
+        let rowIndex = 0;
+        for (const collectedRow of collectedRows) {
+            const count = this.mergeRow(collectedRow, rowIndex);
+            rowIndex += count;
+        }
+        this.fillRowSpans();
+    }
+    mergeRow(collectedRow, rowIndex) {
+        var _a;
+        if (((_a = collectedRow.incompleteRowsIndicator) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+            for (const indicator of collectedRow.incompleteRowsIndicator) {
+                if (!this.loadIndicatorsCounts[indicator]) {
+                    this.loadIndicatorsCounts[indicator] = rowIndex;
+                }
+                if (rowIndex < this.loadIndicatorsCounts[indicator]) {
+                    this.loadIndicatorsCounts[indicator] = rowIndex;
+                }
+            }
+            return 0;
+        }
+        const mainRow = this.getRowAt(rowIndex);
+        for (let i = 0; i < collectedRow.columnIndexes.length; i++) {
+            mainRow.rowData[collectedRow.columnIndexes[i]] = collectedRow.rowData[i];
+        }
+        let rowCount = 1;
+        for (const subrows of collectedRow.subRowCollections) {
+            let additionalRowCount = 0;
+            let currentRowIndex = rowIndex;
+            for (const subrow of subrows.rows) {
+                const count = this.mergeRow(subrow, currentRowIndex);
+                additionalRowCount += count;
+                currentRowIndex += count;
+            }
+            if (additionalRowCount > rowCount) {
+                rowCount = additionalRowCount;
+            }
+        }
+        const joinId = getJoinId();
+        for (let radd = 0; radd < rowCount; radd++) {
+            const row = this.getRowAt(rowIndex + radd);
+            for (let i = 0; i < collectedRow.columnIndexes.length; i++) {
+                row.rowJoinIds[collectedRow.columnIndexes[i]] = joinId;
+            }
+        }
+        return rowCount;
+    }
+}
+exports.PerspectiveDisplay = PerspectiveDisplay;

package/lib/PerspectiveTreeNode.d.ts

@@ -0,0 +1,174 @@
+import { ColumnInfo, DatabaseInfo, ForeignKeyInfo, NamedObjectInfo, TableInfo, ViewInfo } from 'dbgate-types';
+import { ChangePerspectiveConfigFunc, MultipleDatabaseInfo, PerspectiveConfig, PerspectiveCustomJoinConfig, PerspectiveFilterColumnInfo, PerspectiveNodeConfig, PerspectiveReferenceConfig } from './PerspectiveConfig';
+import { PerspectiveDatabaseConfig, PerspectiveDataLoadProps, PerspectiveDataProvider } from './PerspectiveDataProvider';
+import { FilterType } from 'dbgate-filterparser/lib/types';
+import { Condition } from 'dbgate-sqltree';
+export interface PerspectiveDataLoadPropsWithNode {
+    props: PerspectiveDataLoadProps;
+    node: PerspectiveTreeNode;
+}
+export declare abstract class PerspectiveTreeNode {
+    dbs: MultipleDatabaseInfo;
+    config: PerspectiveConfig;
+    setConfig: ChangePerspectiveConfigFunc;
+    parentNode: PerspectiveTreeNode;
+    dataProvider: PerspectiveDataProvider;
+    databaseConfig: PerspectiveDatabaseConfig;
+    designerId: string;
+    constructor(dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, parentNode: PerspectiveTreeNode, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig, designerId: string);
+    readonly nodeConfig: PerspectiveNodeConfig;
+    readonly parentNodeConfig: PerspectiveNodeConfig;
+    abstract get title(): any;
+    abstract get codeName(): any;
+    abstract get isExpandable(): any;
+    childNodesCache: PerspectiveTreeNode[];
+    get childNodes(): PerspectiveTreeNode[];
+    abstract generateChildNodes(): PerspectiveTreeNode[];
+    abstract get icon(): string;
+    get fieldName(): any;
+    get headerTableAttributes(): any;
+    get dataField(): any;
+    get tableCode(): any;
+    get namedObject(): NamedObjectInfo;
+    abstract getNodeLoadProps(parentRows: any[]): PerspectiveDataLoadProps;
+    get isRoot(): boolean;
+    get rootNode(): PerspectiveTreeNode;
+    get isSortable(): boolean;
+    matchChildRow(parentRow: any, childRow: any): boolean;
+    hasTableCode(code: string): any;
+    get level(): any;
+    get isExpanded(): boolean;
+    get isCheckedColumn(): boolean;
+    get isChecked(): boolean;
+    get isCheckedNode(): boolean;
+    get isSecondaryChecked(): boolean;
+    get secondaryCheckable(): boolean;
+    get columnTitle(): any;
+    get filterType(): FilterType;
+    get columnName(): any;
+    get customJoinConfig(): PerspectiveCustomJoinConfig;
+    get db(): DatabaseInfo;
+    get isCircular(): boolean;
+    hasDesignerIdInIncestors(designerId: string): boolean;
+    getChildMatchColumns(): any[];
+    getParentMatchColumns(): any[];
+    parseFilterCondition(source?: any): any;
+    get hasUncheckedNodeInPath(): any;
+    get childDataColumn(): any;
+    toggleExpanded(value?: boolean): void;
+    toggleChecked(value?: boolean): void;
+    toggleCheckedNode(value?: boolean): void;
+    toggleSecondaryChecked(value?: boolean): void;
+    createReferenceConfigColumns(): PerspectiveReferenceConfig['columns'];
+    ensureNodeConfig(cfg: PerspectiveConfig): [PerspectiveConfig, PerspectiveNodeConfig];
+    includeInNodeSet(field: 'expandedColumns' | 'uncheckedColumns' | 'checkedColumns', isIncluded: boolean): void;
+    getFilter(): string;
+    getDataLoadColumns(): any[];
+    getChildrenCondition(source?: any): Condition;
+    getOrderBy(table: TableInfo | ViewInfo): PerspectiveDataLoadProps['orderBy'];
+    getBaseTables(): any[];
+    getBaseTableFromThis(): any;
+    get filterInfo(): PerspectiveFilterColumnInfo;
+    findChildNodeByUniquePath(uniquePath: string[]): any;
+    findNodeByDesignerId(designerId: string): PerspectiveTreeNode;
+    get supportsParentFilter(): boolean;
+    get isParentFilter(): boolean;
+    buildParentFilterConditions(): Condition[];
+    getParentJoinCondition(alias: string, parentAlias: string): Condition[];
+    get sortOrder(): "ASC" | "DESC";
+    get sortOrderIndex(): number;
+}
+export declare class PerspectiveTableColumnNode extends PerspectiveTreeNode {
+    column: ColumnInfo;
+    table: TableInfo | ViewInfo;
+    foreignKey: ForeignKeyInfo;
+    refTable: TableInfo;
+    isView: boolean;
+    isTable: boolean;
+    constructor(column: ColumnInfo, table: TableInfo | ViewInfo, dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig, parentNode: PerspectiveTreeNode, designerId: string);
+    matchChildRow(parentRow: any, childRow: any): boolean;
+    getChildMatchColumns(): string[];
+    getParentMatchColumns(): string[];
+    getParentJoinCondition(alias: string, parentAlias: string): Condition[];
+    createReferenceConfigColumns(): PerspectiveReferenceConfig['columns'];
+    getNodeLoadProps(parentRows: any[]): PerspectiveDataLoadProps;
+    get icon(): "img circular" | "img autoincrement" | "img foreign-key" | "img column";
+    get codeName(): string;
+    get columnName(): string;
+    get fieldName(): string;
+    get title(): string;
+    get isExpandable(): boolean;
+    get isSortable(): boolean;
+    get filterType(): FilterType;
+    get isCircular(): boolean;
+    get isSecondaryChecked(): boolean;
+    get isChecked(): boolean;
+    get secondaryCheckable(): boolean;
+    toggleChecked(value?: boolean): void;
+    toggleSecondaryChecked(value?: boolean): void;
+    generateChildNodes(): PerspectiveTreeNode[];
+    getBaseTableFromThis(): TableInfo;
+    get filterInfo(): PerspectiveFilterColumnInfo;
+    parseFilterCondition(source?: any): Condition;
+    get headerTableAttributes(): {
+        schemaName: string;
+        pureName: string;
+        conid: string;
+        database: string;
+    };
+    get tableCode(): string;
+    get namedObject(): NamedObjectInfo;
+}
+export declare class PerspectiveTableNode extends PerspectiveTreeNode {
+    table: TableInfo | ViewInfo;
+    dataProvider: PerspectiveDataProvider;
+    constructor(table: TableInfo | ViewInfo, dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig, parentNode: PerspectiveTreeNode, designerId: string);
+    getNodeLoadProps(parentRows: any[]): PerspectiveDataLoadProps;
+    get codeName(): string;
+    get title(): string;
+    get isExpandable(): boolean;
+    generateChildNodes(): PerspectiveTreeNode[];
+    get icon(): string;
+    getBaseTableFromThis(): TableInfo | ViewInfo;
+    get headerTableAttributes(): {
+        schemaName: string;
+        pureName: string;
+        conid: string;
+        database: string;
+    };
+    get tableCode(): string;
+    get namedObject(): NamedObjectInfo;
+}
+export declare class PerspectiveTableReferenceNode extends PerspectiveTableNode {
+    foreignKey: ForeignKeyInfo;
+    dataProvider: PerspectiveDataProvider;
+    isMultiple: boolean;
+    constructor(foreignKey: ForeignKeyInfo, table: TableInfo, dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig, isMultiple: boolean, parentNode: PerspectiveTreeNode, designerId: string);
+    matchChildRow(parentRow: any, childRow: any): boolean;
+    getChildMatchColumns(): string[];
+    getParentMatchColumns(): string[];
+    getNodeLoadProps(parentRows: any[]): PerspectiveDataLoadProps;
+    createReferenceConfigColumns(): PerspectiveReferenceConfig['columns'];
+    get columnTitle(): string;
+    get title(): string;
+    get codeName(): string;
+    get isChecked(): boolean;
+    toggleChecked(value?: boolean): void;
+    getParentJoinCondition(alias: string, parentAlias: string): Condition[];
+}
+export declare class PerspectiveCustomJoinTreeNode extends PerspectiveTableNode {
+    customJoin: PerspectiveCustomJoinConfig;
+    dataProvider: PerspectiveDataProvider;
+    constructor(customJoin: PerspectiveCustomJoinConfig, table: TableInfo | ViewInfo, dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig, parentNode: PerspectiveTreeNode, designerId: string);
+    matchChildRow(parentRow: any, childRow: any): boolean;
+    getChildMatchColumns(): string[];
+    getParentMatchColumns(): string[];
+    getNodeLoadProps(parentRows: any[]): PerspectiveDataLoadProps;
+    get icon(): string;
+    get codeName(): string;
+    get customJoinConfig(): PerspectiveCustomJoinConfig;
+    get isChecked(): boolean;
+    toggleChecked(value?: boolean): void;
+    getParentJoinCondition(alias: string, parentAlias: string): Condition[];
+}
+export declare function getTableChildPerspectiveNodes(table: TableInfo | ViewInfo, dbs: MultipleDatabaseInfo, config: PerspectiveConfig, setConfig: ChangePerspectiveConfigFunc, dataProvider: PerspectiveDataProvider, databaseConfig: PerspectiveDatabaseConfig, parentNode: PerspectiveTreeNode): any[];