dbgate-datalib 5.2.2 → 5.2.4-alpha.1

package/lib/ChangeSet.d.ts

@@ -1,9 +1,11 @@
 import { Command, Condition } from 'dbgate-sqltree';
-import type { NamedObjectInfo, DatabaseInfo } from 'dbgate-types';
+import type { NamedObjectInfo, DatabaseInfo, TableInfo } from 'dbgate-types';
+import { JsonDataObjectUpdateCommand } from 'dbgate-tools';
 export interface ChangeSetItem {
     pureName: string;
     schemaName?: string;
     insertedRowIndex?: number;
+    existingRowIndex?: number;
     document?: any;
     condition?: {
         [column: string]: string;
@@ -12,16 +14,22 @@ export interface ChangeSetItem {
         [column: string]: string;
     };
 }
-export interface ChangeSet {
+export interface ChangeSetItemFields {
     inserts: ChangeSetItem[];
     updates: ChangeSetItem[];
     deletes: ChangeSetItem[];
 }
+export interface ChangeSet extends ChangeSetItemFields {
+    structure?: TableInfo;
+    dataUpdateCommands?: JsonDataObjectUpdateCommand[];
+    setColumnMode?: 'fixed' | 'variable';
+}
 export declare function createChangeSet(): ChangeSet;
 export interface ChangeSetRowDefinition {
     pureName: string;
     schemaName: string;
     insertedRowIndex?: number;
+    existingRowIndex?: number;
     condition?: {
         [column: string]: string;
     };
@@ -30,7 +38,7 @@ export interface ChangeSetFieldDefinition extends ChangeSetRowDefinition {
     uniqueName: string;
     columnName: string;
 }
-export declare function findExistingChangeSetItem(changeSet: ChangeSet, definition: ChangeSetRowDefinition): [keyof ChangeSet, ChangeSetItem];
+export declare function findExistingChangeSetItem(changeSet: ChangeSet, definition: ChangeSetRowDefinition): [keyof ChangeSetItemFields, ChangeSetItem];
 export declare function setChangeSetValue(changeSet: ChangeSet, definition: ChangeSetFieldDefinition, value: string): ChangeSet;
 export declare function setChangeSetRowData(changeSet: ChangeSet, definition: ChangeSetRowDefinition, document: any): ChangeSet;
 export declare function batchUpdateChangeSet(changeSet: ChangeSet, rowDefinitions: ChangeSetRowDefinition[], dataRows: []): ChangeSet;

package/lib/ChangeSet.js

@@ -27,12 +27,14 @@ function findExistingChangeSetItem(changeSet, definition) {
     else {
         const inUpdates = changeSet.updates.find(x => x.pureName == definition.pureName &&
             x.schemaName == definition.schemaName &&
-            lodash_1.default.isEqual(x.condition, definition.condition));
+            ((definition.existingRowIndex != null && x.existingRowIndex == definition.existingRowIndex) ||
+                (definition.existingRowIndex == null && lodash_1.default.isEqual(x.condition, definition.condition))));
         if (inUpdates)
             return ['updates', inUpdates];
         const inDeletes = changeSet.deletes.find(x => x.pureName == definition.pureName &&
             x.schemaName == definition.schemaName &&
-            lodash_1.default.isEqual(x.condition, definition.condition));
+            ((definition.existingRowIndex != null && x.existingRowIndex == definition.existingRowIndex) ||
+                (definition.existingRowIndex == null && lodash_1.default.isEqual(x.condition, definition.condition))));
         if (inDeletes)
             return ['deletes', inDeletes];
         return ['updates', null];
@@ -58,6 +60,7 @@ function setChangeSetValue(changeSet, definition, value) {
                 schemaName: definition.schemaName,
                 condition: definition.condition,
                 insertedRowIndex: definition.insertedRowIndex,
+                existingRowIndex: definition.existingRowIndex,
                 fields: {
                     [definition.uniqueName]: value,
                 },
@@ -84,6 +87,7 @@ function setChangeSetRowData(changeSet, definition, document) {
                 schemaName: definition.schemaName,
                 condition: definition.condition,
                 insertedRowIndex: definition.insertedRowIndex,
+                existingRowIndex: definition.existingRowIndex,
                 document,
             },
         ] });
@@ -292,6 +296,7 @@ function deleteChangeSetRows(changeSet, definition) {
                     pureName: definition.pureName,
                     schemaName: definition.schemaName,
                     condition: definition.condition,
+                    existingRowIndex: definition.existingRowIndex,
                 },
             ] });
     }
@@ -299,11 +304,10 @@ function deleteChangeSetRows(changeSet, definition) {
 exports.deleteChangeSetRows = deleteChangeSetRows;
 function getChangeSetInsertedRows(changeSet, name) {
     var _a;
-    if (!name)
-        return [];
+    // if (!name) return [];
     if (!changeSet)
         return [];
-    const rows = changeSet.inserts.filter(x => x.pureName == name.pureName && x.schemaName == name.schemaName);
+    const rows = changeSet.inserts.filter(x => name == null || (x.pureName == name.pureName && x.schemaName == name.schemaName));
     const maxIndex = (_a = lodash_1.default.maxBy(rows, x => x.insertedRowIndex)) === null || _a === void 0 ? void 0 : _a.insertedRowIndex;
     if (maxIndex == null)
         return [];
@@ -332,8 +336,14 @@ function changeSetInsertDocuments(changeSet, documents, name) {
 }
 exports.changeSetInsertDocuments = changeSetInsertDocuments;
 function changeSetContainsChanges(changeSet) {
+    var _a;
     if (!changeSet)
         return false;
-    return changeSet.deletes.length > 0 || changeSet.updates.length > 0 || changeSet.inserts.length > 0;
+    return (changeSet.deletes.length > 0 ||
+        changeSet.updates.length > 0 ||
+        changeSet.inserts.length > 0 ||
+        !!changeSet.structure ||
+        !!changeSet.setColumnMode ||
+        ((_a = changeSet.dataUpdateCommands) === null || _a === void 0 ? void 0 : _a.length) > 0);
 }
 exports.changeSetContainsChanges = changeSetContainsChanges;

package/lib/DataDuplicator.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="lodash" />
+import { DatabaseInfo, EngineDriver, ForeignKeyInfo, TableInfo } from 'dbgate-types';
+export interface DataDuplicatorItem {
+    openStream: () => Promise<ReadableStream>;
+    name: string;
+    operation: 'copy' | 'lookup' | 'insertMissing';
+    matchColumns: string[];
+}
+export interface DataDuplicatorOptions {
+    rollbackAfterFinish?: boolean;
+    skipRowsWithUnresolvedRefs?: boolean;
+}
+declare class DuplicatorReference {
+    base: DuplicatorItemHolder;
+    ref: DuplicatorItemHolder;
+    isMandatory: boolean;
+    foreignKey: ForeignKeyInfo;
+    constructor(base: DuplicatorItemHolder, ref: DuplicatorItemHolder, isMandatory: boolean, foreignKey: ForeignKeyInfo);
+    get columnName(): string;
+}
+declare class DuplicatorItemHolder {
+    item: DataDuplicatorItem;
+    duplicator: DataDuplicator;
+    references: DuplicatorReference[];
+    backReferences: DuplicatorReference[];
+    table: TableInfo;
+    isPlanned: boolean;
+    idMap: {};
+    autoColumn: string;
+    refByColumn: {
+        [columnName: string]: DuplicatorReference;
+    };
+    isReferenced: boolean;
+    get name(): string;
+    constructor(item: DataDuplicatorItem, duplicator: DataDuplicator);
+    initializeReferences(): void;
+    createInsertObject(chunk: any): import("lodash").Omit<Pick<any, string>, string>;
+    runImport(): Promise<{
+        inserted: number;
+        mapped: number;
+        missing: number;
+        skipped: number;
+    }>;
+}
+export declare class DataDuplicator {
+    pool: any;
+    driver: EngineDriver;
+    db: DatabaseInfo;
+    items: DataDuplicatorItem[];
+    stream: any;
+    copyStream: (input: any, output: any) => Promise<void>;
+    options: DataDuplicatorOptions;
+    itemHolders: DuplicatorItemHolder[];
+    itemPlan: DuplicatorItemHolder[];
+    constructor(pool: any, driver: EngineDriver, db: DatabaseInfo, items: DataDuplicatorItem[], stream: any, copyStream: (input: any, output: any) => Promise<void>, options?: DataDuplicatorOptions);
+    findItemToPlan(): DuplicatorItemHolder;
+    createPlan(): void;
+    run(): Promise<void>;
+}
+export {};

package/lib/DataDuplicator.js

@@ -0,0 +1,233 @@
+"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.DataDuplicator = void 0;
+const dbgate_tools_1 = require("dbgate-tools");
+const pick_1 = __importDefault(require("lodash/pick"));
+const omit_1 = __importDefault(require("lodash/omit"));
+const logger = (0, dbgate_tools_1.getLogger)('dataDuplicator');
+class DuplicatorReference {
+    constructor(base, ref, isMandatory, foreignKey) {
+        this.base = base;
+        this.ref = ref;
+        this.isMandatory = isMandatory;
+        this.foreignKey = foreignKey;
+    }
+    get columnName() {
+        return this.foreignKey.columns[0].columnName;
+    }
+}
+class DuplicatorItemHolder {
+    constructor(item, duplicator) {
+        var _a, _b, _c, _d, _e;
+        this.item = item;
+        this.duplicator = duplicator;
+        this.references = [];
+        this.backReferences = [];
+        this.isPlanned = false;
+        this.idMap = {};
+        this.refByColumn = {};
+        this.table = duplicator.db.tables.find(x => x.pureName.toUpperCase() == item.name.toUpperCase());
+        this.autoColumn = (_a = this.table.columns.find(x => x.autoIncrement)) === null || _a === void 0 ? void 0 : _a.columnName;
+        if (((_c = (_b = this.table.primaryKey) === null || _b === void 0 ? void 0 : _b.columns) === null || _c === void 0 ? void 0 : _c.length) != 1 ||
+            ((_e = (_d = this.table.primaryKey) === null || _d === void 0 ? void 0 : _d.columns) === null || _e === void 0 ? void 0 : _e[0].columnName) != this.autoColumn) {
+            this.autoColumn = null;
+        }
+    }
+    get name() {
+        return this.item.name;
+    }
+    initializeReferences() {
+        var _a, _b;
+        for (const fk of this.table.foreignKeys) {
+            if (((_a = fk.columns) === null || _a === void 0 ? void 0 : _a.length) != 1)
+                continue;
+            const refHolder = this.duplicator.itemHolders.find(y => y.name.toUpperCase() == fk.refTableName.toUpperCase());
+            if (refHolder == null)
+                continue;
+            const isMandatory = (_b = this.table.columns.find(x => { var _a; return x.columnName == ((_a = fk.columns[0]) === null || _a === void 0 ? void 0 : _a.columnName); })) === null || _b === void 0 ? void 0 : _b.notNull;
+            const newref = new DuplicatorReference(this, refHolder, isMandatory, fk);
+            this.references.push(newref);
+            this.refByColumn[newref.columnName] = newref;
+            refHolder.isReferenced = true;
+        }
+    }
+    createInsertObject(chunk) {
+        const res = (0, omit_1.default)((0, pick_1.default)(chunk, this.table.columns.map(x => x.columnName)), [this.autoColumn, ...this.backReferences.map(x => x.columnName)]);
+        for (const key in res) {
+            const ref = this.refByColumn[key];
+            if (ref) {
+                // remap id
+                res[key] = ref.ref.idMap[res[key]];
+                if (ref.isMandatory && res[key] == null) {
+                    // mandatory refertence not matched
+                    if (this.duplicator.options.skipRowsWithUnresolvedRefs) {
+                        return null;
+                    }
+                    throw new Error(`Unresolved reference, base=${ref.base.name}, ref=${ref.ref.name}, ${key}=${chunk[key]}`);
+                }
+            }
+        }
+        return res;
+    }
+    runImport() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const readStream = yield this.item.openStream();
+            const driver = this.duplicator.driver;
+            const pool = this.duplicator.pool;
+            let inserted = 0;
+            let mapped = 0;
+            let missing = 0;
+            let skipped = 0;
+            let lastLogged = new Date();
+            const writeStream = (0, dbgate_tools_1.createAsyncWriteStream)(this.duplicator.stream, {
+                processItem: (chunk) => __awaiter(this, void 0, void 0, function* () {
+                    var _a, _b, _c;
+                    if (chunk.__isStreamHeader) {
+                        return;
+                    }
+                    const doCopy = () => __awaiter(this, void 0, void 0, function* () {
+                        var _d, _e, _f;
+                        // console.log('chunk', this.name, JSON.stringify(chunk));
+                        const insertedObj = this.createInsertObject(chunk);
+                        // console.log('insertedObj', this.name, JSON.stringify(insertedObj));
+                        if (insertedObj == null) {
+                            skipped += 1;
+                            return;
+                        }
+                        let res = yield (0, dbgate_tools_1.runQueryOnDriver)(pool, driver, dmp => {
+                            dmp.put('^insert ^into %f (%,i) ^values (%,v)', this.table, Object.keys(insertedObj), Object.values(insertedObj));
+                            if (this.autoColumn &&
+                                this.isReferenced &&
+                                !this.duplicator.driver.dialect.requireStandaloneSelectForScopeIdentity) {
+                                dmp.selectScopeIdentity(this.table);
+                            }
+                        });
+                        inserted += 1;
+                        if (this.autoColumn && this.isReferenced) {
+                            if (this.duplicator.driver.dialect.requireStandaloneSelectForScopeIdentity) {
+                                res = yield (0, dbgate_tools_1.runQueryOnDriver)(pool, driver, dmp => dmp.selectScopeIdentity(this.table));
+                            }
+                            // console.log('IDRES', JSON.stringify(res));
+                            const resId = (_f = (_e = Object.entries((_d = res === null || res === void 0 ? void 0 : res.rows) === null || _d === void 0 ? void 0 : _d[0])) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f[1];
+                            if (resId != null) {
+                                this.idMap[chunk[this.autoColumn]] = resId;
+                            }
+                        }
+                    });
+                    switch (this.item.operation) {
+                        case 'copy': {
+                            yield doCopy();
+                            break;
+                        }
+                        case 'insertMissing':
+                        case 'lookup': {
+                            const res = yield (0, dbgate_tools_1.runQueryOnDriver)(pool, driver, dmp => dmp.put('^select %i ^from %f ^where %i = %v', this.autoColumn, this.table, this.item.matchColumns[0], chunk[this.item.matchColumns[0]]));
+                            const resId = (_c = (_b = Object.entries((_a = res === null || res === void 0 ? void 0 : res.rows) === null || _a === void 0 ? void 0 : _a[0])) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c[1];
+                            if (resId != null) {
+                                mapped += 1;
+                                this.idMap[chunk[this.autoColumn]] = resId;
+                            }
+                            else if (this.item.operation == 'insertMissing') {
+                                yield doCopy();
+                            }
+                            else {
+                                missing += 1;
+                            }
+                            break;
+                        }
+                    }
+                    if (new Date().getTime() - lastLogged.getTime() > 5000) {
+                        logger.info(`Duplicating ${this.item.name} in progress, inserted ${inserted} rows, mapped ${mapped} rows, missing ${missing} rows, skipped ${skipped} rows`);
+                        lastLogged = new Date();
+                    }
+                    // this.idMap[oldId] = newId;
+                }),
+            });
+            yield this.duplicator.copyStream(readStream, writeStream);
+            // await this.duplicator.driver.writeQueryStream(this.duplicator.pool, {
+            //   mapResultId: (oldId, newId) => {
+            //     this.idMap[oldId] = newId;
+            //   },
+            // });
+            return { inserted, mapped, missing, skipped };
+        });
+    }
+}
+class DataDuplicator {
+    constructor(pool, driver, db, items, stream, copyStream, options = {}) {
+        this.pool = pool;
+        this.driver = driver;
+        this.db = db;
+        this.items = items;
+        this.stream = stream;
+        this.copyStream = copyStream;
+        this.options = options;
+        this.itemPlan = [];
+        this.itemHolders = items.map(x => new DuplicatorItemHolder(x, this));
+        this.itemHolders.forEach(x => x.initializeReferences());
+    }
+    findItemToPlan() {
+        for (const item of this.itemHolders) {
+            if (item.isPlanned)
+                continue;
+            if (item.references.every(x => x.ref.isPlanned)) {
+                return item;
+            }
+        }
+        for (const item of this.itemHolders) {
+            if (item.isPlanned)
+                continue;
+            if (item.references.every(x => x.ref.isPlanned || !x.isMandatory)) {
+                const backReferences = item.references.filter(x => !x.ref.isPlanned);
+                item.backReferences = backReferences;
+                return item;
+            }
+        }
+        throw new Error('Cycle in mandatory references');
+    }
+    createPlan() {
+        while (this.itemPlan.length < this.itemHolders.length) {
+            const item = this.findItemToPlan();
+            item.isPlanned = true;
+            this.itemPlan.push(item);
+        }
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.createPlan();
+            yield (0, dbgate_tools_1.runCommandOnDriver)(this.pool, this.driver, dmp => dmp.beginTransaction());
+            try {
+                for (const item of this.itemPlan) {
+                    const stats = yield item.runImport();
+                    logger.info(`Duplicated ${item.name}, inserted ${stats.inserted} rows, mapped ${stats.mapped} rows, missing ${stats.missing} rows, skipped ${stats.skipped} rows`);
+                }
+            }
+            catch (err) {
+                logger.error({ err }, `Failed duplicator job, rollbacking. ${err.message}`);
+                yield (0, dbgate_tools_1.runCommandOnDriver)(this.pool, this.driver, dmp => dmp.rollbackTransaction());
+                return;
+            }
+            if (this.options.rollbackAfterFinish) {
+                logger.info('Rollbacking transaction, nothing was changed');
+                yield (0, dbgate_tools_1.runCommandOnDriver)(this.pool, this.driver, dmp => dmp.rollbackTransaction());
+            }
+            else {
+                logger.info('Committing duplicator transaction');
+                yield (0, dbgate_tools_1.runCommandOnDriver)(this.pool, this.driver, dmp => dmp.commitTransaction());
+            }
+        });
+    }
+}
+exports.DataDuplicator = DataDuplicator;

package/lib/GridConfig.d.ts

@@ -33,6 +33,7 @@ export interface GridConfig extends GridConfigColumns {
     formViewRecordNumber?: number;
     formFilterColumns: string[];
     formColumnFilterText?: string;
+    multiColumnFilter?: string;
 }
 export interface GridCache {
     refreshTime: number;

package/lib/GridDisplay.d.ts

@@ -48,6 +48,7 @@ export declare abstract class GridDisplay {
     get baseTableOrCollection(): NamedObjectInfo;
     get baseTableOrView(): TableInfo | ViewInfo;
     changeSetKeyFields: string[];
+    editableStructure: TableInfo;
     sortable: boolean;
     groupable: boolean;
     filterable: boolean;
@@ -82,6 +83,7 @@ export declare abstract class GridDisplay {
     toggleExpandedColumn(uniqueName: string, value?: boolean): void;
     getFilter(uniqueName: string): string;
     setFilter(uniqueName: any, value: any): void;
+    setMutliColumnFilter(value: any): void;
     showFilter(uniqueName: any): void;
     removeFilter(uniqueName: any): void;
     setFilters(dct: any): void;
@@ -98,8 +100,8 @@ export declare abstract class GridDisplay {
     clearFilters(): void;
     resetConfig(): void;
     getChangeSetCondition(row: any): Pick<any, string>;
-    getChangeSetField(row: any, uniqueName: any, insertedRowIndex: any): ChangeSetFieldDefinition;
-    getChangeSetRow(row: any, insertedRowIndex: any): ChangeSetRowDefinition;
+    getChangeSetField(row: any, uniqueName: any, insertedRowIndex: any, existingRowIndex?: any, baseNameOmitable?: boolean): ChangeSetFieldDefinition;
+    getChangeSetRow(row: any, insertedRowIndex: any, existingRowIndex: any, baseNameOmitable?: boolean): ChangeSetRowDefinition;
     createSelect(options?: {}): Select;
     processReferences(select: Select, displayedColumnInfo: DisplayedColumnInfo, options: any): void;
     createColumnExpression(col: any, source: any, alias?: any): any;
@@ -115,7 +117,7 @@ export declare abstract class GridDisplay {
     }[];
     resizeColumn(uniqueName: string, computedSize: number, diff: number): void;
     getCountQuery(): Select;
-    compileFilters(): Condition;
+    compileJslFilters(): Condition;
     switchToFormView(rowIndex: any): void;
     switchToJsonView(): void;
     formViewNavigate(command: any, allRowCount: any): void;

package/lib/GridDisplay.js

@@ -21,6 +21,7 @@ class GridDisplay {
         this.serverVersion = serverVersion;
         this.formColumns = [];
         this.changeSetKeyFields = null;
+        this.editableStructure = null;
         this.sortable = false;
         this.groupable = false;
         this.filterable = false;
@@ -133,6 +134,30 @@ class GridDisplay {
                 continue;
             }
         }
+        if (this.baseTableOrView && this.config.multiColumnFilter) {
+            try {
+                const condition = (0, dbgate_filterparser_1.parseFilter)(this.config.multiColumnFilter, 'string');
+                if (condition) {
+                    const orCondition = {
+                        conditionType: 'or',
+                        conditions: [],
+                    };
+                    for (const column of this.baseTableOrView.columns) {
+                        orCondition.conditions.push(lodash_1.default.cloneDeepWith(condition, (expr) => {
+                            if (expr.exprType == 'placeholder') {
+                                return this.createColumnExpression(column, { alias: 'basetbl' });
+                            }
+                        }));
+                    }
+                    if (orCondition.conditions.length > 0) {
+                        conditions.push(orCondition);
+                    }
+                }
+            }
+            catch (err) {
+                console.warn(err.message);
+            }
+        }
         if (conditions.length > 0) {
             select.where = {
                 conditionType: 'and',
@@ -241,6 +266,10 @@ class GridDisplay {
         this.setConfig(cfg => (Object.assign(Object.assign({}, cfg), { filters: Object.assign(Object.assign({}, cfg.filters), { [uniqueName]: value }), formViewRecordNumber: 0 })));
         this.reload();
     }
+    setMutliColumnFilter(value) {
+        this.setConfig(cfg => (Object.assign(Object.assign({}, cfg), { multiColumnFilter: value, formViewRecordNumber: 0 })));
+        this.reload();
+    }
     showFilter(uniqueName) {
         this.setConfig(cfg => {
             if (!cfg.filters.uniqueName)
@@ -319,27 +348,30 @@ class GridDisplay {
             return null;
         return lodash_1.default.pick(row, this.changeSetKeyFields);
     }
-    getChangeSetField(row, uniqueName, insertedRowIndex) {
+    getChangeSetField(row, uniqueName, insertedRowIndex, existingRowIndex = null, baseNameOmitable = false) {
         const col = this.columns.find(x => x.uniqueName == uniqueName);
         if (!col)
             return null;
         const baseObj = this.baseTableOrSimilar;
-        if (!baseObj)
-            return null;
-        if (baseObj.pureName != col.pureName || baseObj.schemaName != col.schemaName) {
-            return null;
+        if (!baseNameOmitable) {
+            if (!baseObj)
+                return null;
+            if (baseObj.pureName != col.pureName || baseObj.schemaName != col.schemaName) {
+                return null;
+            }
         }
-        return Object.assign(Object.assign({}, this.getChangeSetRow(row, insertedRowIndex)), { uniqueName: uniqueName, columnName: col.columnName });
+        return Object.assign(Object.assign({}, this.getChangeSetRow(row, insertedRowIndex, existingRowIndex, baseNameOmitable)), { uniqueName: uniqueName, columnName: col.columnName });
     }
-    getChangeSetRow(row, insertedRowIndex) {
+    getChangeSetRow(row, insertedRowIndex, existingRowIndex, baseNameOmitable = false) {
         const baseObj = this.baseTableOrSimilar;
-        if (!baseObj)
+        if (!baseNameOmitable && !baseObj)
             return null;
         return {
-            pureName: baseObj.pureName,
-            schemaName: baseObj.schemaName,
+            pureName: baseObj === null || baseObj === void 0 ? void 0 : baseObj.pureName,
+            schemaName: baseObj === null || baseObj === void 0 ? void 0 : baseObj.schemaName,
             insertedRowIndex,
-            condition: insertedRowIndex == null ? this.getChangeSetCondition(row) : null,
+            existingRowIndex,
+            condition: insertedRowIndex == null && existingRowIndex == null ? this.getChangeSetCondition(row) : null,
         };
     }
     createSelect(options = {}) {
@@ -357,6 +389,7 @@ class GridDisplay {
         return Object.assign({ exprType: 'column', alias: alias || col.columnName, source }, col);
     }
     createSelectBase(name, columns, options) {
+        var _a;
         if (!columns)
             return null;
         const orderColumnName = columns[0].columnName;
@@ -367,13 +400,15 @@ class GridDisplay {
                 alias: 'basetbl',
             },
             columns: columns.map(col => this.createColumnExpression(col, { alias: 'basetbl' })),
-            orderBy: [
-                {
-                    exprType: 'column',
-                    columnName: orderColumnName,
-                    direction: 'ASC',
-                },
-            ],
+            orderBy: ((_a = this.driver) === null || _a === void 0 ? void 0 : _a.requiresDefaultSortCriteria)
+                ? [
+                    {
+                        exprType: 'column',
+                        columnName: orderColumnName,
+                        direction: 'ASC',
+                    },
+                ]
+                : null,
         };
         const displayedColumnInfo = lodash_1.default.keyBy(this.columns.map(col => (Object.assign(Object.assign({}, col), { sourceAlias: 'basetbl' }))), 'uniqueName');
         this.processReferences(select, displayedColumnInfo, options);
@@ -523,7 +558,7 @@ class GridDisplay {
         // const sql = treeToSql(this.driver, select, dumpSqlSelect);
         // return sql;
     }
-    compileFilters() {
+    compileJslFilters() {
         var _a;
         const filters = this.config && this.config.filters;
         if (!filters)
@@ -549,6 +584,15 @@ class GridDisplay {
                 // filter parse error - ignore filter
             }
         }
+        if (this.config.multiColumnFilter) {
+            const placeholderCondition = (0, dbgate_filterparser_1.parseFilter)(this.config.multiColumnFilter, 'string');
+            if (placeholderCondition) {
+                conditions.push({
+                    conditionType: 'anyColumnPass',
+                    placeholderCondition,
+                });
+            }
+        }
         if (conditions.length == 0)
             return null;
         return {

package/lib/JslGridDisplay.d.ts

@@ -1,5 +1,5 @@
 import { GridDisplay, ChangeCacheFunc, ChangeConfigFunc } from './GridDisplay';
 import { GridConfig, GridCache } from './GridConfig';
 export declare class JslGridDisplay extends GridDisplay {
-    constructor(jslid: any, structure: any, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, rows: any, isDynamicStructure: boolean, supportsReload: boolean);
+    constructor(jslid: any, structure: any, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, rows: any, isDynamicStructure: boolean, supportsReload: boolean, editable?: boolean);
 }

package/lib/JslGridDisplay.js

@@ -8,13 +8,16 @@ const lodash_1 = __importDefault(require("lodash"));
 const GridDisplay_1 = require("./GridDisplay");
 const CollectionGridDisplay_1 = require("./CollectionGridDisplay");
 class JslGridDisplay extends GridDisplay_1.GridDisplay {
-    constructor(jslid, structure, config, setConfig, cache, setCache, rows, isDynamicStructure, supportsReload) {
+    constructor(jslid, structure, config, setConfig, cache, setCache, rows, isDynamicStructure, supportsReload, editable = false) {
         var _a;
         super(config, setConfig, cache, setCache, null);
         this.filterable = true;
+        this.sortable = true;
         this.supportsReload = supportsReload;
         this.isDynamicStructure = isDynamicStructure;
         this.filterTypeOverride = 'eval';
+        this.editable = editable;
+        this.editableStructure = editable ? structure : null;
         if (structure === null || structure === void 0 ? void 0 : structure.columns) {
             this.columns = lodash_1.default.uniqBy((_a = structure.columns
                 .map(col => ({

package/lib/MacroDefinition.d.ts

@@ -8,7 +8,7 @@ export interface MacroDefinition {
     name: string;
     group: string;
     description?: string;
-    type: 'transformValue';
+    type: 'transformValue' | 'transformRow';
     code: string;
     args?: MacroArgument[];
 }

package/lib/PerspectiveConfig.d.ts

@@ -46,6 +46,7 @@ export interface PerspectiveNodeConfig {
     };
     isAutoGenerated?: true | undefined;
     isNodeChecked?: boolean;
+    multiColumnFilter?: string;
     position?: {
         x: number;
         y: number;