dbgate-datalib 7.1.13 → 7.2.1

package/lib/ChangeSet.d.ts

@@ -1,6 +1,7 @@
 import { Command, Condition } from 'dbgate-sqltree';
 import type { NamedObjectInfo, DatabaseInfo, TableInfo, SqlDialect } from 'dbgate-types';
 import { JsonDataObjectUpdateCommand } from 'dbgate-tools';
+export type ChangeSetValue = any;
 export interface ChangeSetItem {
     pureName: string;
     schemaName?: string;
@@ -8,13 +9,13 @@ export interface ChangeSetItem {
     existingRowIndex?: number;
     document?: any;
     condition?: {
-        [column: string]: string;
+        [column: string]: ChangeSetValue;
     };
     fields?: {
-        [column: string]: string;
+        [column: string]: ChangeSetValue;
     };
     insertIfNotExistsFields?: {
-        [column: string]: string;
+        [column: string]: ChangeSetValue;
     };
 }
 export interface ChangeSetItemFields {
@@ -34,7 +35,7 @@ export interface ChangeSetRowDefinition {
     insertedRowIndex?: number;
     existingRowIndex?: number;
     condition?: {
-        [column: string]: string;
+        [column: string]: ChangeSetValue;
     };
 }
 export interface ChangeSetFieldDefinition extends ChangeSetRowDefinition {
@@ -63,13 +64,13 @@ export declare function removeSchemaFromChangeSet(changeSet: ChangeSet): {
         existingRowIndex?: number;
         document?: any;
         condition?: {
-            [column: string]: string;
+            [column: string]: any;
         };
         fields?: {
-            [column: string]: string;
+            [column: string]: any;
         };
         insertIfNotExistsFields?: {
-            [column: string]: string;
+            [column: string]: any;
         };
     }[];
     updates: {
@@ -79,13 +80,13 @@ export declare function removeSchemaFromChangeSet(changeSet: ChangeSet): {
         existingRowIndex?: number;
         document?: any;
         condition?: {
-            [column: string]: string;
+            [column: string]: any;
         };
         fields?: {
-            [column: string]: string;
+            [column: string]: any;
         };
         insertIfNotExistsFields?: {
-            [column: string]: string;
+            [column: string]: any;
         };
     }[];
     deletes: {
@@ -95,13 +96,13 @@ export declare function removeSchemaFromChangeSet(changeSet: ChangeSet): {
         existingRowIndex?: number;
         document?: any;
         condition?: {
-            [column: string]: string;
+            [column: string]: any;
         };
         fields?: {
-            [column: string]: string;
+            [column: string]: any;
         };
         insertIfNotExistsFields?: {
-            [column: string]: string;
+            [column: string]: any;
         };
     }[];
     structure?: TableInfo;

package/lib/ChangeSet.js

@@ -13,6 +13,23 @@ function createChangeSet() {
     };
 }
 exports.createChangeSet = createChangeSet;
+function normalizeChangeSetValueForCompare(value) {
+    if ((value === null || value === void 0 ? void 0 : value.$bigint) != null)
+        return value.$bigint;
+    if ((value === null || value === void 0 ? void 0 : value.$decimal) != null)
+        return value.$decimal;
+    if (lodash_1.default.isNumber(value) || lodash_1.default.isBoolean(value))
+        return value.toString();
+    return value;
+}
+function normalizeChangeSetConditionForCompare(condition) {
+    if (condition == null)
+        return condition;
+    return lodash_1.default.mapValues(condition, normalizeChangeSetValueForCompare);
+}
+function isSameChangeSetCondition(left, right) {
+    return lodash_1.default.isEqual(normalizeChangeSetConditionForCompare(left), normalizeChangeSetConditionForCompare(right));
+}
 function findExistingChangeSetItem(changeSet, definition) {
     if (!changeSet || !definition)
         return ['updates', null];
@@ -28,13 +45,13 @@ function findExistingChangeSetItem(changeSet, definition) {
         const inUpdates = changeSet.updates.find(x => x.pureName == definition.pureName &&
             x.schemaName == definition.schemaName &&
             ((definition.existingRowIndex != null && x.existingRowIndex == definition.existingRowIndex) ||
-                (definition.existingRowIndex == null && lodash_1.default.isEqual(x.condition, definition.condition))));
+                (definition.existingRowIndex == null && isSameChangeSetCondition(x.condition, definition.condition))));
         if (inUpdates)
             return ['updates', inUpdates];
         const inDeletes = changeSet.deletes.find(x => x.pureName == definition.pureName &&
             x.schemaName == definition.schemaName &&
             ((definition.existingRowIndex != null && x.existingRowIndex == definition.existingRowIndex) ||
-                (definition.existingRowIndex == null && lodash_1.default.isEqual(x.condition, definition.condition))));
+                (definition.existingRowIndex == null && isSameChangeSetCondition(x.condition, definition.condition))));
         if (inDeletes)
             return ['deletes', inDeletes];
         return ['updates', null];

package/lib/EditableQueryResultDisplay.d.ts

@@ -0,0 +1,37 @@
+import { ChangeSetFieldDefinition, ChangeSetRowDefinition } from './ChangeSet';
+import { DisplayColumn } from './GridDisplay';
+import { DatabaseInfo, QueryResultColumn } from 'dbgate-types';
+export interface QueryResultTableMapping {
+    pureName: string;
+    schemaName?: string;
+    keyColumns: string[];
+    keyDisplayColumns: {
+        displayName: string;
+        sourceColumnName: string;
+    }[];
+}
+export interface QueryResultColumnBaseMapping {
+    pureName: string;
+    schemaName?: string;
+    sourceColumnName: string;
+}
+export declare function getTableKey(schemaName: string, pureName: string): string;
+export declare function createEditableQueryResultMappings(columns: QueryResultColumn[], dbinfo: DatabaseInfo): {
+    editableColumns: Set<string>;
+    tableMappings: {
+        [key: string]: QueryResultTableMapping;
+    };
+    columnBaseMappings: {
+        [columnName: string]: QueryResultColumnBaseMapping;
+    };
+};
+export declare function hasCompleteQueryResultKey(mapping: QueryResultTableMapping, row: any): boolean;
+export declare function isEditableQueryResultColumn(columns: DisplayColumn[], tableMappings: {
+    [key: string]: QueryResultTableMapping;
+}, uniqueName: string, row?: any): boolean;
+export declare function getEditableQueryResultChangeSetField(columns: DisplayColumn[], tableMappings: {
+    [key: string]: QueryResultTableMapping;
+}, row: any, uniqueName: string, insertedRowIndex: any, existingRowIndex?: any): ChangeSetFieldDefinition;
+export declare function getEditableQueryResultChangeSetRowDefinitions(tableMappings: {
+    [key: string]: QueryResultTableMapping;
+}, row: any, insertedRowIndex: any, existingRowIndex: any): ChangeSetRowDefinition[];

package/lib/EditableQueryResultDisplay.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEditableQueryResultChangeSetRowDefinitions = exports.getEditableQueryResultChangeSetField = exports.isEditableQueryResultColumn = exports.hasCompleteQueryResultKey = exports.createEditableQueryResultMappings = exports.getTableKey = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+function getTableKey(schemaName, pureName) {
+    return `${schemaName || ''}\n${pureName}`;
+}
+exports.getTableKey = getTableKey;
+function namesEqual(left, right) {
+    return left != null && right != null && left.toLowerCase() == right.toLowerCase();
+}
+function findTable(dbinfo, schemaName, pureName) {
+    if (!(dbinfo === null || dbinfo === void 0 ? void 0 : dbinfo.tables))
+        return null;
+    if (schemaName) {
+        const schemaTable = dbinfo.tables.find(table => table.schemaName == schemaName && table.pureName == pureName) ||
+            dbinfo.tables.find(table => namesEqual(table.schemaName, schemaName) && namesEqual(table.pureName, pureName));
+        if (schemaTable)
+            return schemaTable;
+        const uniqueNameTables = dbinfo.tables.filter(table => namesEqual(table.pureName, pureName));
+        return uniqueNameTables.length == 1 ? uniqueNameTables[0] : null;
+    }
+    const tables = dbinfo.tables.filter(table => table.pureName == pureName);
+    if (tables.length == 1)
+        return tables[0];
+    const matchingTables = dbinfo.tables.filter(table => namesEqual(table.pureName, pureName));
+    return matchingTables.length == 1 ? matchingTables[0] : null;
+}
+function findColumnName(table, columnName) {
+    var _a, _b;
+    if (!columnName)
+        return columnName;
+    const exactColumn = (_a = table === null || table === void 0 ? void 0 : table.columns) === null || _a === void 0 ? void 0 : _a.find(column => column.columnName == columnName);
+    if (exactColumn)
+        return exactColumn.columnName;
+    const matchingColumns = ((_b = table === null || table === void 0 ? void 0 : table.columns) === null || _b === void 0 ? void 0 : _b.filter(column => namesEqual(column.columnName, columnName))) || [];
+    return matchingColumns.length == 1 ? matchingColumns[0].columnName : columnName;
+}
+function createEditableQueryResultMappings(columns, dbinfo) {
+    var _a, _b;
+    const editableColumns = new Set();
+    const tableMappings = {};
+    const columnBaseMappings = {};
+    const groups = lodash_1.default.groupBy((columns || []).filter(column => column.tableName && column.sourceColumnName), column => getTableKey(column.tableSchema, column.tableName));
+    for (const groupColumns of Object.values(groups)) {
+        const firstColumn = groupColumns[0];
+        const table = findTable(dbinfo, firstColumn.tableSchema, firstColumn.tableName);
+        const tableSchema = table ? table.schemaName : firstColumn.tableSchema;
+        const tableName = (table === null || table === void 0 ? void 0 : table.pureName) || firstColumn.tableName;
+        const normalizedColumns = groupColumns.map(column => (Object.assign(Object.assign({}, column), { sourceColumnName: findColumnName(table, column.sourceColumnName) })));
+        const sourceToDisplay = new Map(normalizedColumns.map(column => [column.sourceColumnName, column.columnName]));
+        const primaryKeyColumns = ((_b = (_a = table === null || table === void 0 ? void 0 : table.primaryKey) === null || _a === void 0 ? void 0 : _a.columns) === null || _b === void 0 ? void 0 : _b.map(column => column.columnName)) ||
+            normalizedColumns.filter(column => column.isPrimaryKey).map(column => column.sourceColumnName);
+        const keyColumns = primaryKeyColumns.length > 0 && primaryKeyColumns.every(columnName => sourceToDisplay.has(columnName))
+            ? primaryKeyColumns
+            : [];
+        if (keyColumns.length == 0)
+            continue;
+        const mapping = {
+            pureName: tableName,
+            schemaName: tableSchema,
+            keyColumns,
+            keyDisplayColumns: keyColumns.map(sourceColumnName => ({
+                sourceColumnName,
+                displayName: sourceToDisplay.get(sourceColumnName),
+            })),
+        };
+        tableMappings[getTableKey(tableSchema, tableName)] = mapping;
+        for (const column of normalizedColumns) {
+            editableColumns.add(column.columnName);
+            columnBaseMappings[column.columnName] = {
+                pureName: tableName,
+                schemaName: tableSchema,
+                sourceColumnName: column.sourceColumnName,
+            };
+        }
+    }
+    return { editableColumns, tableMappings, columnBaseMappings };
+}
+exports.createEditableQueryResultMappings = createEditableQueryResultMappings;
+function hasCompleteQueryResultKey(mapping, row) {
+    return mapping.keyDisplayColumns.every(keyColumn => {
+        const value = row === null || row === void 0 ? void 0 : row[keyColumn.displayName];
+        return value !== null && value !== undefined;
+    });
+}
+exports.hasCompleteQueryResultKey = hasCompleteQueryResultKey;
+function getQueryResultCondition(mapping, row) {
+    const condition = {};
+    for (const keyColumn of mapping.keyDisplayColumns) {
+        condition[keyColumn.sourceColumnName] = row === null || row === void 0 ? void 0 : row[keyColumn.displayName];
+    }
+    return condition;
+}
+function isEditableQueryResultColumn(columns, tableMappings, uniqueName, row) {
+    const col = columns.find(column => column.uniqueName == uniqueName);
+    if (!(col === null || col === void 0 ? void 0 : col.queryResultEditable))
+        return false;
+    const mapping = tableMappings[getTableKey(col.schemaName, col.pureName)];
+    return !!mapping && hasCompleteQueryResultKey(mapping, row);
+}
+exports.isEditableQueryResultColumn = isEditableQueryResultColumn;
+function getEditableQueryResultChangeSetField(columns, tableMappings, row, uniqueName, insertedRowIndex, existingRowIndex = null) {
+    if (insertedRowIndex != null || !isEditableQueryResultColumn(columns, tableMappings, uniqueName, row))
+        return null;
+    const col = columns.find(column => column.uniqueName == uniqueName);
+    if (!col)
+        return null;
+    const mapping = tableMappings[getTableKey(col.schemaName, col.pureName)];
+    if (!mapping)
+        return null;
+    if (!hasCompleteQueryResultKey(mapping, row))
+        return null;
+    const condition = getQueryResultCondition(mapping, row);
+    if (lodash_1.default.isEmpty(condition))
+        return null;
+    return {
+        pureName: mapping.pureName,
+        schemaName: mapping.schemaName,
+        existingRowIndex,
+        condition,
+        uniqueName,
+        columnName: col.sourceColumnName,
+    };
+}
+exports.getEditableQueryResultChangeSetField = getEditableQueryResultChangeSetField;
+function getEditableQueryResultChangeSetRowDefinitions(tableMappings, row, insertedRowIndex, existingRowIndex) {
+    if (insertedRowIndex != null)
+        return [];
+    return Object.values(tableMappings)
+        .filter(mapping => hasCompleteQueryResultKey(mapping, row))
+        .map(mapping => {
+        return {
+            pureName: mapping.pureName,
+            schemaName: mapping.schemaName,
+            existingRowIndex,
+            condition: getQueryResultCondition(mapping, row),
+        };
+    });
+}
+exports.getEditableQueryResultChangeSetRowDefinitions = getEditableQueryResultChangeSetRowDefinitions;

package/lib/FreeTableGridDisplay.d.ts

@@ -27,6 +27,7 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         isPersisted?: boolean;
         isSparse?: boolean;
         defaultValue?: string;
+        onUpdateExpression?: string;
         defaultConstraint?: string;
         columnComment?: string;
         isUnsigned?: boolean;
@@ -57,6 +58,7 @@ export declare class FreeTableGridDisplay extends GridDisplay {
         isPersisted?: boolean;
         isSparse?: boolean;
         defaultValue?: string;
+        onUpdateExpression?: string;
         defaultConstraint?: string;
         columnComment?: string;
         isUnsigned?: boolean;

package/lib/GridDisplay.d.ts

@@ -25,6 +25,8 @@ export interface DisplayColumn {
     dataType?: string;
     filterBehaviour?: FilterBehaviour;
     isStructured?: boolean;
+    sourceColumnName?: string;
+    queryResultEditable?: boolean;
 }
 export interface DisplayedColumnEx extends DisplayColumn {
     sourceAlias: string;
@@ -59,6 +61,10 @@ export declare abstract class GridDisplay {
     groupable: boolean;
     filterable: boolean;
     editable: boolean;
+    allowInsert: boolean;
+    allowDelete: boolean;
+    allowStructureChange: boolean;
+    allowRowDocumentEdit: boolean;
     isLoadedCorrectly: boolean;
     supportsReload: boolean;
     isDynamicStructure: boolean;
@@ -115,8 +121,10 @@ export declare abstract class GridDisplay {
     clearFilters(): void;
     resetConfig(): void;
     getChangeSetCondition(row: any): Pick<any, string>;
+    isColumnEditable(uniqueName: string, row?: any): boolean;
     getChangeSetField(row: any, uniqueName: any, insertedRowIndex: any, existingRowIndex?: any, baseNameOmitable?: boolean): ChangeSetFieldDefinition;
     getChangeSetRow(row: any, insertedRowIndex: any, existingRowIndex: any, baseNameOmitable?: boolean): ChangeSetRowDefinition;
+    getChangeSetRowDefinitions(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, purpose?: 'view' | 'filter'): any;

package/lib/GridDisplay.js

@@ -27,6 +27,10 @@ class GridDisplay {
         this.groupable = false;
         this.filterable = false;
         this.editable = false;
+        this.allowInsert = true;
+        this.allowDelete = true;
+        this.allowStructureChange = true;
+        this.allowRowDocumentEdit = true;
         this.isLoadedCorrectly = true;
         this.supportsReload = false;
         this.isDynamicStructure = false;
@@ -406,6 +410,9 @@ class GridDisplay {
             return null;
         return lodash_1.default.pick(row, this.changeSetKeyFields);
     }
+    isColumnEditable(uniqueName, row) {
+        return this.editable;
+    }
     getChangeSetField(row, uniqueName, insertedRowIndex, existingRowIndex = null, baseNameOmitable = false) {
         const col = this.columns.find(x => x.uniqueName == uniqueName);
         if (!col)
@@ -432,6 +439,9 @@ class GridDisplay {
             condition: insertedRowIndex == null && existingRowIndex == null ? this.getChangeSetCondition(row) : null,
         };
     }
+    getChangeSetRowDefinitions(row, insertedRowIndex, existingRowIndex, baseNameOmitable = false) {
+        return [this.getChangeSetRow(row, insertedRowIndex, existingRowIndex, baseNameOmitable)].filter(Boolean);
+    }
     createSelect(options = {}) {
         return null;
     }

package/lib/JslGridDisplay.d.ts

@@ -1,6 +1,13 @@
 import { GridDisplay, ChangeCacheFunc, ChangeConfigFunc } from './GridDisplay';
 import { GridConfig, GridCache } from './GridConfig';
-import { EngineDriver } from 'dbgate-types';
+import { DatabaseInfo, EngineDriver } from 'dbgate-types';
 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, editable?: boolean, driver?: EngineDriver, currentSettings?: any);
+    queryResultEditing: boolean;
+    private queryResultTableMappings;
+    private queryResultColumnBaseMappings;
+    constructor(jslid: any, structure: any, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, rows: any, isDynamicStructure: boolean, supportsReload: boolean, editable?: boolean, driver?: EngineDriver, currentSettings?: any, queryResultEditing?: boolean, dbinfo?: DatabaseInfo);
+    private getEditableQueryResultColumns;
+    isColumnEditable(uniqueName: string, row?: any): boolean;
+    getChangeSetField(row: any, uniqueName: any, insertedRowIndex: any, existingRowIndex?: any, baseNameOmitable?: boolean): import("./ChangeSet").ChangeSetFieldDefinition;
+    getChangeSetRowDefinitions(row: any, insertedRowIndex: any, existingRowIndex: any, baseNameOmitable?: boolean): import("./ChangeSet").ChangeSetRowDefinition[];
 }

package/lib/JslGridDisplay.js

@@ -8,36 +8,80 @@ const lodash_1 = __importDefault(require("lodash"));
 const GridDisplay_1 = require("./GridDisplay");
 const CollectionGridDisplay_1 = require("./CollectionGridDisplay");
 const dbgate_tools_1 = require("dbgate-tools");
+const EditableQueryResultDisplay_1 = require("./EditableQueryResultDisplay");
 class JslGridDisplay extends GridDisplay_1.GridDisplay {
-    constructor(jslid, structure, config, setConfig, cache, setCache, rows, isDynamicStructure, supportsReload, editable = false, driver = null, currentSettings = null) {
+    constructor(jslid, structure, config, setConfig, cache, setCache, rows, isDynamicStructure, supportsReload, editable = false, driver = null, currentSettings = null, queryResultEditing = false, dbinfo = null) {
         var _a;
-        super(config, setConfig, cache, setCache, driver, undefined, undefined, currentSettings);
+        super(config, setConfig, cache, setCache, driver, dbinfo, undefined, currentSettings);
+        this.queryResultEditing = queryResultEditing;
+        this.queryResultTableMappings = {};
+        this.queryResultColumnBaseMappings = {};
         this.filterable = true;
         this.sortable = true;
         this.supportsReload = supportsReload;
         this.isDynamicStructure = isDynamicStructure;
         this.filterBehaviourOverride = dbgate_tools_1.evalFilterBehaviour;
         this.editable = editable;
-        this.editableStructure = editable ? structure : null;
+        this.editableStructure = editable && !queryResultEditing ? structure : null;
+        if (queryResultEditing) {
+            this.allowInsert = false;
+            this.allowDelete = false;
+            this.allowStructureChange = false;
+            this.allowRowDocumentEdit = false;
+        }
         if (structure === null || structure === void 0 ? void 0 : structure.columns) {
+            const queryResultEditableColumns = queryResultEditing
+                ? this.getEditableQueryResultColumns(structure.columns, dbinfo)
+                : new Set();
             this.columns = lodash_1.default.uniqBy((_a = structure.columns
-                .map(col => ({
-                columnName: col.columnName,
-                headerText: col.columnName,
-                uniqueName: col.columnName,
-                uniquePath: [col.columnName],
-                notNull: col.notNull,
-                autoIncrement: col.autoIncrement,
-                pureName: null,
-                schemaName: null,
-            }))) === null || _a === void 0 ? void 0 : _a.map(col => (Object.assign(Object.assign({}, col), { isChecked: this.isColumnChecked(col) }))), col => col.uniqueName);
+                .map(col => {
+                const columnBaseMapping = this.queryResultColumnBaseMappings[col.columnName];
+                return {
+                    columnName: col.columnName,
+                    headerText: col.columnName,
+                    uniqueName: col.columnName,
+                    uniquePath: [col.columnName],
+                    notNull: col.notNull,
+                    autoIncrement: col.autoIncrement,
+                    pureName: queryResultEditing ? (columnBaseMapping ? columnBaseMapping.pureName : col.tableName) : null,
+                    schemaName: queryResultEditing ? (columnBaseMapping ? columnBaseMapping.schemaName : col.tableSchema) : null,
+                    sourceColumnName: columnBaseMapping ? columnBaseMapping.sourceColumnName : col.sourceColumnName,
+                    queryResultEditable: queryResultEditableColumns.has(col.columnName),
+                };
+            })) === null || _a === void 0 ? void 0 : _a.map(col => (Object.assign(Object.assign({}, col), { isChecked: this.isColumnChecked(col) }))), col => col.uniqueName);
         }
         if (structure === null || structure === void 0 ? void 0 : structure.__isDynamicStructure) {
             this.columns = (0, CollectionGridDisplay_1.analyseCollectionDisplayColumns)(rows, this);
         }
         if (!this.columns)
             this.columns = [];
+        if (queryResultEditing) {
+            this.editable = this.columns.some(col => col.queryResultEditable);
+        }
         this.formColumns = this.columns;
     }
+    getEditableQueryResultColumns(columns, dbinfo) {
+        const { editableColumns, tableMappings, columnBaseMappings } = (0, EditableQueryResultDisplay_1.createEditableQueryResultMappings)(columns, dbinfo);
+        this.queryResultTableMappings = tableMappings;
+        this.queryResultColumnBaseMappings = columnBaseMappings;
+        return editableColumns;
+    }
+    isColumnEditable(uniqueName, row) {
+        if (!this.queryResultEditing)
+            return super.isColumnEditable(uniqueName, row);
+        return (0, EditableQueryResultDisplay_1.isEditableQueryResultColumn)(this.columns, this.queryResultTableMappings, uniqueName, row);
+    }
+    getChangeSetField(row, uniqueName, insertedRowIndex, existingRowIndex = null, baseNameOmitable = false) {
+        if (!this.queryResultEditing) {
+            return super.getChangeSetField(row, uniqueName, insertedRowIndex, existingRowIndex, baseNameOmitable);
+        }
+        return (0, EditableQueryResultDisplay_1.getEditableQueryResultChangeSetField)(this.columns, this.queryResultTableMappings, row, uniqueName, insertedRowIndex, existingRowIndex);
+    }
+    getChangeSetRowDefinitions(row, insertedRowIndex, existingRowIndex, baseNameOmitable = false) {
+        if (!this.queryResultEditing) {
+            return super.getChangeSetRowDefinitions(row, insertedRowIndex, existingRowIndex, baseNameOmitable);
+        }
+        return (0, EditableQueryResultDisplay_1.getEditableQueryResultChangeSetRowDefinitions)(this.queryResultTableMappings, row, insertedRowIndex, existingRowIndex);
+    }
 }
 exports.JslGridDisplay = JslGridDisplay;

package/lib/QueryResultChangeSet.d.ts

@@ -0,0 +1,5 @@
+import type { QueryResultColumn } from 'dbgate-types';
+import { ChangeSet } from './ChangeSet';
+export declare function createQueryResultSaveChangeSet(changeSet: ChangeSet, structure: {
+    columns?: QueryResultColumn[];
+}): ChangeSet;

package/lib/QueryResultChangeSet.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createQueryResultSaveChangeSet = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const ChangeSet_1 = require("./ChangeSet");
+function createQueryResultSaveChangeSet(changeSet, structure) {
+    const res = (0, ChangeSet_1.createChangeSet)();
+    const columnMap = lodash_1.default.keyBy(((structure === null || structure === void 0 ? void 0 : structure.columns) || []).filter(column => column.tableName && column.sourceColumnName), 'columnName');
+    res.updates = ((changeSet === null || changeSet === void 0 ? void 0 : changeSet.updates) || [])
+        .map(update => {
+        const fields = {};
+        for (const fieldName of Object.keys(update.fields || {})) {
+            const column = columnMap[fieldName];
+            if (!column)
+                continue;
+            fields[column.sourceColumnName] = update.fields[fieldName];
+        }
+        if (lodash_1.default.isEmpty(fields))
+            return null;
+        return {
+            pureName: update.pureName,
+            schemaName: update.schemaName,
+            condition: update.condition,
+            fields,
+        };
+    })
+        .filter(Boolean);
+    return res;
+}
+exports.createQueryResultSaveChangeSet = createQueryResultSaveChangeSet;

package/lib/TableGridDisplay.d.ts

@@ -58,6 +58,7 @@ export declare class TableGridDisplay extends GridDisplay {
         isPersisted?: boolean;
         isSparse?: boolean;
         defaultValue?: string;
+        onUpdateExpression?: string;
         defaultConstraint?: string;
         columnComment?: string;
         isUnsigned?: boolean;

package/lib/ViewGridDisplay.d.ts

@@ -1,16 +1,28 @@
 import { GridDisplay, ChangeCacheFunc, ChangeConfigFunc } from './GridDisplay';
-import type { EngineDriver, ViewInfo, ColumnInfo, DatabaseInfo } from 'dbgate-types';
+import type { EngineDriver, ViewInfo, ColumnInfo, DatabaseInfo, QueryResultColumn } from 'dbgate-types';
 import { GridConfig, GridCache } from './GridConfig';
 export declare class ViewGridDisplay extends GridDisplay {
     view: ViewInfo;
-    constructor(view: ViewInfo, driver: EngineDriver, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, dbinfo: DatabaseInfo, serverVersion: any, currentSettings: any);
-    getDisplayColumns(view: ViewInfo): {
+    viewResultInfo: {
+        columns?: QueryResultColumn[];
+    };
+    private queryResultTableMappings;
+    private queryResultColumnBaseMappings;
+    constructor(view: ViewInfo, driver: EngineDriver, config: GridConfig, setConfig: ChangeConfigFunc, cache: GridCache, setCache: ChangeCacheFunc, dbinfo: DatabaseInfo, serverVersion: any, currentSettings: any, viewResultInfo?: {
+        columns?: QueryResultColumn[];
+    }, editableView?: boolean);
+    private getEditableQueryResultColumns;
+    getDisplayColumns(view: ViewInfo, resultColumnMap?: {
+        [columnName: string]: QueryResultColumn;
+    }, queryResultEditableColumns?: Set<string>): {
         isChecked: boolean;
         pureName: string;
         schemaName: string;
         headerText: string;
         uniqueName: string;
         uniquePath: string[];
+        sourceColumnName: string;
+        queryResultEditable: boolean;
         pairingId?: string;
         columnName: string;
         notNull?: boolean;
@@ -24,6 +36,7 @@ export declare class ViewGridDisplay extends GridDisplay {
         isPersisted?: boolean;
         isSparse?: boolean;
         defaultValue?: string;
+        onUpdateExpression?: string;
         defaultConstraint?: string;
         columnComment?: string;
         isUnsigned?: boolean;
@@ -35,12 +48,14 @@ export declare class ViewGridDisplay extends GridDisplay {
         contentHash?: string;
         engine?: string;
     }[];
-    getDisplayColumn(view: ViewInfo, col: ColumnInfo): {
+    getDisplayColumn(view: ViewInfo, col: ColumnInfo, resultColumn?: QueryResultColumn, queryResultEditableColumns?: Set<string>): {
         pureName: string;
         schemaName: string;
         headerText: string;
         uniqueName: string;
         uniquePath: string[];
+        sourceColumnName: string;
+        queryResultEditable: boolean;
         pairingId?: string;
         columnName: string;
         notNull?: boolean;
@@ -54,6 +69,7 @@ export declare class ViewGridDisplay extends GridDisplay {
         isPersisted?: boolean;
         isSparse?: boolean;
         defaultValue?: string;
+        onUpdateExpression?: string;
         defaultConstraint?: string;
         columnComment?: string;
         isUnsigned?: boolean;
@@ -65,5 +81,8 @@ export declare class ViewGridDisplay extends GridDisplay {
         contentHash?: string;
         engine?: string;
     };
+    isColumnEditable(uniqueName: string, row?: any): boolean;
+    getChangeSetField(row: any, uniqueName: any, insertedRowIndex: any, existingRowIndex?: any, baseNameOmitable?: boolean): import("./ChangeSet").ChangeSetFieldDefinition;
+    getChangeSetRowDefinitions(row: any, insertedRowIndex: any, existingRowIndex: any, baseNameOmitable?: boolean): import("./ChangeSet").ChangeSetRowDefinition[];
     createSelect(options?: {}): import("dbgate-sqltree").Select;
 }

package/lib/ViewGridDisplay.js

@@ -1,29 +1,67 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ViewGridDisplay = void 0;
+const lodash_1 = __importDefault(require("lodash"));
 const GridDisplay_1 = require("./GridDisplay");
+const EditableQueryResultDisplay_1 = require("./EditableQueryResultDisplay");
 class ViewGridDisplay extends GridDisplay_1.GridDisplay {
-    constructor(view, driver, config, setConfig, cache, setCache, dbinfo, serverVersion, currentSettings) {
+    constructor(view, driver, config, setConfig, cache, setCache, dbinfo, serverVersion, currentSettings, viewResultInfo = null, editableView = false) {
+        var _a;
         super(config, setConfig, cache, setCache, driver, dbinfo, serverVersion, currentSettings);
         this.view = view;
-        this.columns = this.getDisplayColumns(view);
+        this.viewResultInfo = viewResultInfo;
+        this.queryResultTableMappings = {};
+        this.queryResultColumnBaseMappings = {};
+        const effectiveEditable = editableView && ((_a = driver === null || driver === void 0 ? void 0 : driver.databaseEngineTypes) === null || _a === void 0 ? void 0 : _a.includes('sql')) && (driver === null || driver === void 0 ? void 0 : driver.supportsEditableQueryResults);
+        const queryResultEditableColumns = effectiveEditable
+            ? this.getEditableQueryResultColumns((viewResultInfo === null || viewResultInfo === void 0 ? void 0 : viewResultInfo.columns) || [], dbinfo)
+            : new Set();
+        const resultColumnMap = lodash_1.default.keyBy((viewResultInfo === null || viewResultInfo === void 0 ? void 0 : viewResultInfo.columns) || [], 'columnName');
+        this.columns = this.getDisplayColumns(view, resultColumnMap, queryResultEditableColumns);
         this.formColumns = this.columns;
         this.filterable = true;
         this.sortable = true;
         this.groupable = false;
-        this.editable = false;
+        this.editable = effectiveEditable && this.columns.some(col => col.queryResultEditable);
+        if (effectiveEditable) {
+            this.allowInsert = false;
+            this.allowDelete = false;
+            this.allowStructureChange = false;
+            this.allowRowDocumentEdit = false;
+        }
         this.supportsReload = true;
         this.baseView = view;
     }
-    getDisplayColumns(view) {
+    getEditableQueryResultColumns(columns, dbinfo) {
+        const { editableColumns, tableMappings, columnBaseMappings } = (0, EditableQueryResultDisplay_1.createEditableQueryResultMappings)(columns, dbinfo);
+        this.queryResultTableMappings = tableMappings;
+        this.queryResultColumnBaseMappings = columnBaseMappings;
+        return editableColumns;
+    }
+    getDisplayColumns(view, resultColumnMap = {}, queryResultEditableColumns = new Set()) {
         var _a, _b;
-        return (((_b = (_a = view === null || view === void 0 ? void 0 : view.columns) === null || _a === void 0 ? void 0 : _a.map(col => this.getDisplayColumn(view, col))) === null || _b === void 0 ? void 0 : _b.map(col => (Object.assign(Object.assign({}, col), { isChecked: this.isColumnChecked(col) })))) || []);
+        return (((_b = (_a = view === null || view === void 0 ? void 0 : view.columns) === null || _a === void 0 ? void 0 : _a.map(col => this.getDisplayColumn(view, col, resultColumnMap[col.columnName], queryResultEditableColumns))) === null || _b === void 0 ? void 0 : _b.map(col => (Object.assign(Object.assign({}, col), { isChecked: this.isColumnChecked(col) })))) || []);
     }
-    getDisplayColumn(view, col) {
+    getDisplayColumn(view, col, resultColumn = null, queryResultEditableColumns = new Set()) {
         const uniquePath = [col.columnName];
         const uniqueName = uniquePath.join('.');
-        return Object.assign(Object.assign({}, col), { pureName: view.pureName, schemaName: view.schemaName, headerText: col.columnName, uniqueName,
-            uniquePath });
+        const columnBaseMapping = this.queryResultColumnBaseMappings[col.columnName];
+        return Object.assign(Object.assign({}, col), { pureName: columnBaseMapping ? columnBaseMapping.pureName : (resultColumn === null || resultColumn === void 0 ? void 0 : resultColumn.tableName) || view.pureName, schemaName: columnBaseMapping ? columnBaseMapping.schemaName : (resultColumn === null || resultColumn === void 0 ? void 0 : resultColumn.tableSchema) || view.schemaName, headerText: col.columnName, uniqueName,
+            uniquePath, sourceColumnName: columnBaseMapping ? columnBaseMapping.sourceColumnName : resultColumn === null || resultColumn === void 0 ? void 0 : resultColumn.sourceColumnName, queryResultEditable: queryResultEditableColumns.has(col.columnName) });
+    }
+    isColumnEditable(uniqueName, row) {
+        if (!this.editable)
+            return false;
+        return (0, EditableQueryResultDisplay_1.isEditableQueryResultColumn)(this.columns, this.queryResultTableMappings, uniqueName, row);
+    }
+    getChangeSetField(row, uniqueName, insertedRowIndex, existingRowIndex = null, baseNameOmitable = false) {
+        return (0, EditableQueryResultDisplay_1.getEditableQueryResultChangeSetField)(this.columns, this.queryResultTableMappings, row, uniqueName, insertedRowIndex, existingRowIndex);
+    }
+    getChangeSetRowDefinitions(row, insertedRowIndex, existingRowIndex, baseNameOmitable = false) {
+        return (0, EditableQueryResultDisplay_1.getEditableQueryResultChangeSetRowDefinitions)(this.queryResultTableMappings, row, insertedRowIndex, existingRowIndex);
     }
     createSelect(options = {}) {
         const select = this.createSelectBase(this.view, this.view.columns, options);

package/lib/index.d.ts

@@ -5,6 +5,8 @@ export * from './PerspectiveTreeNode';
 export * from './TableGridDisplay';
 export * from './ViewGridDisplay';
 export * from './JslGridDisplay';
+export * from './QueryResultChangeSet';
+export * from './EditableQueryResultDisplay';
 export * from './ChangeSet';
 export * from './MacroDefinition';
 export * from './runMacro';

package/lib/index.js

@@ -21,6 +21,8 @@ __exportStar(require("./PerspectiveTreeNode"), exports);
 __exportStar(require("./TableGridDisplay"), exports);
 __exportStar(require("./ViewGridDisplay"), exports);
 __exportStar(require("./JslGridDisplay"), exports);
+__exportStar(require("./QueryResultChangeSet"), exports);
+__exportStar(require("./EditableQueryResultDisplay"), exports);
 __exportStar(require("./ChangeSet"), exports);
 __exportStar(require("./MacroDefinition"), exports);
 __exportStar(require("./runMacro"), exports);

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "7.1.13",
+  "version": "7.2.1",
   "name": "dbgate-datalib",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -19,14 +19,14 @@
   ],
   "dependencies": {
     "date-fns": "^4.1.0",
-    "dbgate-filterparser": "7.1.13",
-    "dbgate-sqltree": "7.1.13",
-    "dbgate-tools": "7.1.13",
+    "dbgate-filterparser": "7.2.1",
+    "dbgate-sqltree": "7.2.1",
+    "dbgate-tools": "7.2.1",
     "uuid": "^3.4.0"
   },
   "devDependencies": {
     "@types/node": "^13.7.0",
-    "dbgate-types": "7.1.13",
+    "dbgate-types": "7.2.1",
     "jest": "^28.1.3",
     "ts-jest": "^28.0.7",
     "typescript": "^4.4.3"