dbgate-datalib 5.0.7 → 5.1.0

package/lib/FreeTableGridDisplay.d.ts

@@ -14,8 +14,8 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         uniquePath: string[];
         pairingId?: string;
         columnName: string;
-        notNull: boolean;
-        autoIncrement: boolean;
+        notNull?: boolean;
+        autoIncrement?: boolean;
         dataType: string;
         precision?: number;
         scale?: number;
@@ -28,6 +28,8 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         columnComment?: string;
         isUnsigned?: boolean;
         isZerofill?: boolean;
+        contentHash?: string;
+        engine?: string;
     }[];
     getDisplayColumn(col: ColumnInfo): {
         pureName: string;
@@ -37,8 +39,8 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         uniquePath: string[];
         pairingId?: string;
         columnName: string;
-        notNull: boolean;
-        autoIncrement: boolean;
+        notNull?: boolean;
+        autoIncrement?: boolean;
         dataType: string;
         precision?: number;
         scale?: number;
@@ -51,5 +53,7 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         columnComment?: string;
         isUnsigned?: boolean;
         isZerofill?: boolean;
+        contentHash?: string;
+        engine?: string;
     };
 }

package/lib/GridDisplay.d.ts

@@ -9,7 +9,7 @@ export interface DisplayColumn {
     headerText: string;
     uniqueName: string;
     uniquePath: string[];
-    notNull: boolean;
+    notNull?: boolean;
     autoIncrement?: boolean;
     isPrimaryKey?: boolean;
     foreignKey?: ForeignKeyInfo;

package/lib/PerspectiveCache.d.ts

@@ -0,0 +1,39 @@
+import { PerspectiveDataLoadProps } from './PerspectiveDataProvider';
+export declare class PerspectiveBindingGroup {
+    table: PerspectiveCacheTable;
+    constructor(table: PerspectiveCacheTable);
+    groupSize?: number;
+    loadedAll: boolean;
+    loadedRows: any[];
+    bindingValues: any[];
+    matchRow(row: any): boolean;
+}
+export declare class PerspectiveCacheTable {
+    cache: PerspectiveCache;
+    constructor(props: PerspectiveDataLoadProps, cache: PerspectiveCache);
+    schemaName: string;
+    pureName: string;
+    bindingColumns?: string[];
+    dataColumns: string[];
+    loadedAll: boolean;
+    loadedRows: any[];
+    bindingGroups: {
+        [bindingKey: string]: PerspectiveBindingGroup;
+    };
+    get loadedCount(): number;
+    getRowsResult(props: PerspectiveDataLoadProps): {
+        rows: any[];
+        incomplete: boolean;
+    };
+    getBindingGroup(groupValues: any[]): PerspectiveBindingGroup;
+    getUncachedBindingGroups(props: PerspectiveDataLoadProps): any[][];
+    storeGroupSize(props: PerspectiveDataLoadProps, bindingValues: any[], count: number): void;
+}
+export declare class PerspectiveCache {
+    constructor();
+    tables: {
+        [tableKey: string]: PerspectiveCacheTable;
+    };
+    getTableCache(props: PerspectiveDataLoadProps): PerspectiveCacheTable;
+    clear(): void;
+}

package/lib/PerspectiveCache.js

@@ -0,0 +1,99 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerspectiveCache = exports.PerspectiveCacheTable = exports.PerspectiveBindingGroup = void 0;
+const pick_1 = __importDefault(require("lodash/pick"));
+const zip_1 = __importDefault(require("lodash/zip"));
+const difference_1 = __importDefault(require("lodash/difference"));
+const debug_1 = __importDefault(require("debug"));
+const json_stable_stringify_1 = __importDefault(require("json-stable-stringify"));
+const dbg = (0, debug_1.default)('dbgate:PerspectiveCache');
+class PerspectiveBindingGroup {
+    constructor(table) {
+        this.table = table;
+        this.loadedRows = [];
+    }
+    matchRow(row) {
+        return this.table.bindingColumns.every((column, index) => row[column] == this.bindingValues[index]);
+    }
+}
+exports.PerspectiveBindingGroup = PerspectiveBindingGroup;
+class PerspectiveCacheTable {
+    constructor(props, cache) {
+        this.cache = cache;
+        this.loadedRows = [];
+        this.bindingGroups = {};
+        this.schemaName = props.schemaName;
+        this.pureName = props.pureName;
+        this.bindingColumns = props.bindingColumns;
+        this.dataColumns = props.dataColumns;
+        this.loadedAll = false;
+    }
+    get loadedCount() {
+        return this.loadedRows.length;
+    }
+    getRowsResult(props) {
+        return {
+            rows: this.loadedRows.slice(0, props.topCount),
+            incomplete: props.topCount < this.loadedCount || !this.loadedAll,
+        };
+    }
+    getBindingGroup(groupValues) {
+        const key = (0, json_stable_stringify_1.default)(groupValues);
+        return this.bindingGroups[key];
+    }
+    getUncachedBindingGroups(props) {
+        const uncached = [];
+        for (const group of props.bindingValues) {
+            const key = (0, json_stable_stringify_1.default)(group);
+            const item = this.bindingGroups[key];
+            if (!item) {
+                uncached.push(group);
+            }
+        }
+        return uncached;
+    }
+    storeGroupSize(props, bindingValues, count) {
+        const originalBindingValue = props.bindingValues.find(v => (0, zip_1.default)(v, bindingValues).every(([x, y]) => x == y));
+        if (originalBindingValue) {
+            const key = (0, json_stable_stringify_1.default)(originalBindingValue);
+            // console.log('SET SIZE', originalBindingValue, bindingValues, key, count);
+            const group = new PerspectiveBindingGroup(this);
+            group.bindingValues = bindingValues;
+            group.groupSize = count;
+            this.bindingGroups[key] = group;
+        }
+        else {
+            dbg('Group not found', bindingValues);
+        }
+    }
+}
+exports.PerspectiveCacheTable = PerspectiveCacheTable;
+class PerspectiveCache {
+    constructor() {
+        this.tables = {};
+    }
+    getTableCache(props) {
+        const tableKey = (0, json_stable_stringify_1.default)((0, pick_1.default)(props, ['schemaName', 'pureName', 'bindingColumns', 'databaseConfig', 'orderBy', 'condition']));
+        let res = this.tables[tableKey];
+        if (res && (0, difference_1.default)(props.dataColumns, res.dataColumns).length > 0) {
+            dbg('Delete cache because incomplete columns', props.pureName, res.dataColumns);
+            // we have incomplete cache
+            delete this.tables[tableKey];
+            res = null;
+        }
+        if (!res) {
+            res = new PerspectiveCacheTable(props, this);
+            this.tables[tableKey] = res;
+            return res;
+        }
+        // cache could be used
+        return res;
+    }
+    clear() {
+        this.tables = {};
+    }
+}
+exports.PerspectiveCache = PerspectiveCache;

package/lib/PerspectiveConfig.d.ts

@@ -0,0 +1,63 @@
+import { DatabaseInfo, ForeignKeyInfo } from 'dbgate-types';
+export interface PerspectiveConfigColumns {
+    expandedColumns: string[];
+    checkedColumns: string[];
+    uncheckedColumns: string[];
+}
+export interface PerspectiveCustomJoinConfig {
+    joinid: string;
+    joinName: string;
+    baseUniqueName: string;
+    conid?: string;
+    database?: string;
+    refSchemaName?: string;
+    refTableName: string;
+    columns: {
+        baseColumnName: string;
+        refColumnName: string;
+    }[];
+}
+export interface PerspectiveFilterColumnInfo {
+    columnName: string;
+    filterType: string;
+    pureName: string;
+    schemaName: string;
+    foreignKey: ForeignKeyInfo;
+}
+export interface PerspectiveParentFilterConfig {
+    uniqueName: string;
+}
+export interface PerspectiveConfig extends PerspectiveConfigColumns {
+    rootObject: {
+        schemaName?: string;
+        pureName: string;
+    };
+    filters: {
+        [uniqueName: string]: string;
+    };
+    sort: {
+        [parentUniqueName: string]: {
+            uniqueName: string;
+            order: 'ASC' | 'DESC';
+        }[];
+    };
+    customJoins: PerspectiveCustomJoinConfig[];
+    parentFilters: PerspectiveParentFilterConfig[];
+}
+export declare function createPerspectiveConfig(rootObject: {
+    schemaName?: string;
+    pureName: string;
+}): PerspectiveConfig;
+export declare type ChangePerspectiveConfigFunc = (changeFunc: (config: PerspectiveConfig) => PerspectiveConfig, reload?: boolean) => void;
+export declare function extractPerspectiveDatabases({ conid, database }: {
+    conid: any;
+    database: any;
+}, cfg: PerspectiveConfig): {
+    conid: string;
+    database: string;
+}[];
+export interface MultipleDatabaseInfo {
+    [conid: string]: {
+        [database: string]: DatabaseInfo;
+    };
+}

package/lib/PerspectiveConfig.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPerspectiveDatabases = exports.createPerspectiveConfig = void 0;
+function createPerspectiveConfig(rootObject) {
+    return {
+        expandedColumns: [],
+        checkedColumns: [],
+        uncheckedColumns: [],
+        customJoins: [],
+        filters: {},
+        sort: {},
+        rootObject,
+        parentFilters: [],
+    };
+}
+exports.createPerspectiveConfig = createPerspectiveConfig;
+function extractPerspectiveDatabases({ conid, database }, cfg) {
+    const res = [];
+    res.push({ conid, database });
+    function add(conid, database) {
+        if (res.find(x => x.conid == conid && x.database == database))
+            return;
+        res.push({ conid, database });
+    }
+    for (const custom of cfg.customJoins) {
+        add(custom.conid || conid, custom.database || database);
+    }
+    return res;
+}
+exports.extractPerspectiveDatabases = extractPerspectiveDatabases;

package/lib/PerspectiveDataLoader.d.ts

@@ -0,0 +1,9 @@
+import { Condition } from 'dbgate-sqltree';
+import { PerspectiveDataLoadProps } from './PerspectiveDataProvider';
+export declare class PerspectiveDataLoader {
+    apiCall: any;
+    constructor(apiCall: any);
+    buildCondition(props: PerspectiveDataLoadProps): Condition;
+    loadGrouping(props: PerspectiveDataLoadProps): Promise<any>;
+    loadData(props: PerspectiveDataLoadProps): Promise<any>;
+}

package/lib/PerspectiveDataLoader.js

@@ -0,0 +1,136 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PerspectiveDataLoader = void 0;
+const debug_1 = __importDefault(require("debug"));
+const dbg = (0, debug_1.default)('dbgate:PerspectiveDataLoader');
+class PerspectiveDataLoader {
+    constructor(apiCall) {
+        this.apiCall = apiCall;
+    }
+    buildCondition(props) {
+        const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, condition } = props;
+        const conditions = [];
+        if (condition) {
+            conditions.push(condition);
+        }
+        if ((bindingColumns === null || bindingColumns === void 0 ? void 0 : bindingColumns.length) == 1) {
+            conditions.push({
+                conditionType: 'in',
+                expr: {
+                    exprType: 'column',
+                    columnName: bindingColumns[0],
+                    source: {
+                        name: { schemaName, pureName },
+                    },
+                },
+                values: bindingValues.map(x => x[0]),
+            });
+        }
+        return conditions.length > 0
+            ? {
+                conditionType: 'and',
+                conditions,
+            }
+            : null;
+    }
+    loadGrouping(props) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { schemaName, pureName, bindingColumns, bindingValues, dataColumns } = props;
+            const bindingColumnExpressions = bindingColumns.map(columnName => ({
+                exprType: 'column',
+                columnName,
+                source: {
+                    name: { schemaName, pureName },
+                },
+            }));
+            const select = {
+                commandType: 'select',
+                from: {
+                    name: { schemaName, pureName },
+                },
+                columns: [
+                    {
+                        exprType: 'call',
+                        func: 'COUNT',
+                        args: [
+                            {
+                                exprType: 'raw',
+                                sql: '*',
+                            },
+                        ],
+                        alias: '_perspective_group_size_',
+                    },
+                    ...bindingColumnExpressions,
+                ],
+                where: this.buildCondition(props),
+            };
+            select.groupBy = bindingColumnExpressions;
+            if (dbg === null || dbg === void 0 ? void 0 : dbg.enabled) {
+                dbg(`LOAD COUNTS, table=${props.pureName}, columns=${(_a = props.dataColumns) === null || _a === void 0 ? void 0 : _a.join(',')}`);
+            }
+            const response = yield this.apiCall('database-connections/sql-select', {
+                conid: props.databaseConfig.conid,
+                database: props.databaseConfig.database,
+                select,
+            });
+            if (response.errorMessage)
+                return response;
+            return response.rows.map(row => (Object.assign(Object.assign({}, row), { _perspective_group_size_: parseInt(row._perspective_group_size_) })));
+        });
+    }
+    loadData(props) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function* () {
+            const { schemaName, pureName, bindingColumns, bindingValues, dataColumns, orderBy, condition } = props;
+            const select = {
+                commandType: 'select',
+                from: {
+                    name: { schemaName, pureName },
+                },
+                columns: dataColumns === null || dataColumns === void 0 ? void 0 : dataColumns.map(columnName => ({
+                    exprType: 'column',
+                    columnName,
+                    source: {
+                        name: { schemaName, pureName },
+                    },
+                })),
+                selectAll: !dataColumns,
+                orderBy: orderBy === null || orderBy === void 0 ? void 0 : orderBy.map(({ columnName, order }) => ({
+                    exprType: 'column',
+                    columnName,
+                    direction: order,
+                    source: {
+                        name: { schemaName, pureName },
+                    },
+                })),
+                range: props.range,
+                where: this.buildCondition(props),
+            };
+            if (dbg === null || dbg === void 0 ? void 0 : dbg.enabled) {
+                dbg(`LOAD DATA, table=${props.pureName}, columns=${(_a = props.dataColumns) === null || _a === void 0 ? void 0 : _a.join(',')}, range=${(_b = props.range) === null || _b === void 0 ? void 0 : _b.offset},${(_c = props.range) === null || _c === void 0 ? void 0 : _c.limit}`);
+            }
+            const response = yield this.apiCall('database-connections/sql-select', {
+                conid: props.databaseConfig.conid,
+                database: props.databaseConfig.database,
+                select,
+            });
+            if (response.errorMessage)
+                return response;
+            return response.rows;
+        });
+    }
+}
+exports.PerspectiveDataLoader = PerspectiveDataLoader;

package/lib/PerspectiveDataProvider.d.ts

@@ -0,0 +1,42 @@
+import { Condition } from 'dbgate-sqltree';
+import { RangeDefinition } from 'dbgate-types';
+import { PerspectiveCache } from './PerspectiveCache';
+import { PerspectiveDataLoader } from './PerspectiveDataLoader';
+export declare const PERSPECTIVE_PAGE_SIZE = 100;
+export interface PerspectiveDatabaseConfig {
+    conid: string;
+    database: string;
+}
+export interface PerspectiveDataLoadProps {
+    databaseConfig: PerspectiveDatabaseConfig;
+    schemaName: string;
+    pureName: string;
+    dataColumns: string[];
+    orderBy: {
+        columnName: string;
+        order: 'ASC' | 'DESC';
+    }[];
+    bindingColumns?: string[];
+    bindingValues?: any[][];
+    range?: RangeDefinition;
+    topCount?: number;
+    condition?: Condition;
+}
+export declare class PerspectiveDataProvider {
+    cache: PerspectiveCache;
+    loader: PerspectiveDataLoader;
+    constructor(cache: PerspectiveCache, loader: PerspectiveDataLoader);
+    loadData(props: PerspectiveDataLoadProps): Promise<{
+        rows: any[];
+        incomplete: boolean;
+    }>;
+    loadDataNested(props: PerspectiveDataLoadProps): Promise<{
+        rows: any[];
+        incomplete: boolean;
+    }>;
+    loadNextGroup(props: PerspectiveDataLoadProps, groupIndex: number): Promise<void>;
+    loadDataFlat(props: PerspectiveDataLoadProps): Promise<{
+        rows: any[];
+        incomplete: boolean;
+    }>;
+}

package/lib/PerspectiveDataProvider.js

@@ -0,0 +1,179 @@
+"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.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;