ydb-embedded-ui 4.21.1 → 4.23.0

package/dist/containers/Tenant/Query/QueryEditor/QueryEditor.js

@@ -6,7 +6,6 @@ import _ from 'lodash';
 import MonacoEditor from 'react-monaco-editor';
 
 import SplitPane from '../../../../components/SplitPane';
-import {QueryResultTable} from '../../../../components/QueryResultTable';
 
 import {
     sendExecuteQuery,
@@ -26,6 +25,7 @@ import {
     SAVED_QUERIES_KEY,
     ENABLE_ADDITIONAL_QUERY_MODES,
     LAST_USED_QUERY_ACTION_KEY,
+    QUERY_USE_MULTI_SCHEMA_KEY,
 } from '../../../../utils/constants';
 import {useSetting, useQueryModes} from '../../../../utils/hooks';
 import {QUERY_ACTIONS, QUERY_MODES, isNewQueryMode} from '../../../../utils/query';
@@ -40,14 +40,8 @@ import {ExecuteResult} from '../ExecuteResult/ExecuteResult';
 import {ExplainResult} from '../ExplainResult/ExplainResult';
 import {QueryEditorControls} from '../QueryEditorControls/QueryEditorControls';
 
-import {getPreparedResult} from '../utils/getPreparedResult';
-
 import './QueryEditor.scss';
 
-const TABLE_SETTINGS = {
-    sortable: false,
-};
-
 const EDITOR_OPTIONS = {
     automaticLayout: true,
     selectOnLineNumbers: true,
@@ -92,6 +86,7 @@ function QueryEditor(props) {
     const [isResultLoaded, setIsResultLoaded] = useState(false);
     const [queryMode, setQueryMode] = useQueryModes();
     const [enableAdditionalQueryModes] = useSetting(ENABLE_ADDITIONAL_QUERY_MODES);
+    const [useMultiSchema] = useSetting(QUERY_USE_MULTI_SCHEMA_KEY);
     const [lastUsedQueryAction, setLastUsedQueryAction] = useSetting(LAST_USED_QUERY_ACTION_KEY);
 
     useEffect(() => {
@@ -256,9 +251,16 @@ function QueryEditor(props) {
             setShowPreview,
         } = props;
 
+        const schema = useMultiSchema ? 'multi' : 'modern';
+
         setLastUsedQueryAction(QUERY_ACTIONS.execute);
         setResultType(RESULT_TYPES.EXECUTE);
-        sendExecuteQuery({query: input, database: path, mode});
+        sendExecuteQuery({
+            query: input,
+            database: path,
+            mode,
+            schema,
+        });
         setIsResultLoaded(true);
         setShowPreview(false);
 
@@ -314,26 +316,11 @@ function QueryEditor(props) {
             executeQuery: {data, error, stats},
         } = props;
 
-        let content;
-        if (data) {
-            content = (
-                <QueryResultTable
-                    data={data.result}
-                    columns={data.columns}
-                    settings={TABLE_SETTINGS}
-                />
-            );
-        }
-        const textResults = getPreparedResult(data);
-        const disabled = !textResults.length || resultType !== RESULT_TYPES.EXECUTE;
-
         return data || error ? (
             <ExecuteResult
-                result={content}
+                data={data}
                 stats={stats}
                 error={error}
-                textResults={textResults}
-                copyDisabled={disabled}
                 isResultsCollapsed={resultVisibilityState.collapsed}
                 onExpandResults={onExpandResultHandler}
                 onCollapseResults={onCollapseResultHandler}

package/dist/containers/Tenant/Query/utils/getPreparedResult.ts

@@ -1,16 +1,15 @@
 import type {KeyValueRow} from '../../../../types/api/query';
-import type {IQueryResult} from '../../../../types/store/query';
 
-export const getPreparedResult = (data: IQueryResult) => {
+export const getPreparedResult = (data: KeyValueRow[] | undefined) => {
     const columnDivider = '\t';
     const rowDivider = '\n';
 
-    if (!data?.result?.length) {
+    if (!data?.length) {
         return '';
     }
 
-    const columnHeaders = Object.keys(data.result[0]);
-    const rows = Array<string[] | KeyValueRow[]>(columnHeaders).concat(data.result);
+    const columnHeaders = Object.keys(data[0]);
+    const rows = Array<string[] | KeyValueRow[]>(columnHeaders).concat(data);
 
     return rows
         .map((item) => {

package/dist/containers/Tenant/Schema/SchemaViewer/SchemaViewer.tsx

@@ -1,3 +1,4 @@
+import {useMemo} from 'react';
 import cn from 'bem-cn-lite';
 
 import DataTable, {Column} from '@gravity-ui/react-data-table';
@@ -28,6 +29,16 @@ interface SchemaViewerProps {
 }
 
 export const SchemaViewer = ({keyColumnIds = [], columns = [], type}: SchemaViewerProps) => {
+    // Keys should be displayd by their order in keyColumnIds (Primary Key)
+    const keyColumnsOrderValues = useMemo(() => {
+        return keyColumnIds.reduce<Record<number, number>>((result, keyColumnId, index) => {
+            // Put columns with negative values, so they will be the first with ascending sort
+            // Minus keyColumnIds.length for the first key, -1 for the last
+            result[keyColumnId] = index - keyColumnIds.length;
+            return result;
+        }, {});
+    }, [keyColumnIds]);
+
     let dataTableColumns: Column<TColumnDescription>[] = [
         {
             name: SchemaViewerColumns.id,
@@ -36,8 +47,11 @@ export const SchemaViewer = ({keyColumnIds = [], columns = [], type}: SchemaView
         {
             name: SchemaViewerColumns.key,
             width: 40,
+            // Table should start with key columns on sort click
+            defaultOrder: DataTable.ASCENDING,
             sortAccessor: (row) => {
-                return row.Id && keyColumnIds.includes(row.Id) ? 1 : 0;
+                // Values in keyColumnsOrderValues are always negative, so it will be 1 for not key columns
+                return (row.Id && keyColumnsOrderValues[row.Id]) || 1;
             },
             render: ({row}) => {
                 return row.Id && keyColumnIds.includes(row.Id) ? (
@@ -58,6 +72,8 @@ export const SchemaViewer = ({keyColumnIds = [], columns = [], type}: SchemaView
         {
             name: SchemaViewerColumns.notNull,
             width: 100,
+            // Table should start with notNull columns on sort click
+            defaultOrder: DataTable.DESCENDING,
             render: ({row}) => {
                 if (row.NotNull) {
                     return '\u2713';
@@ -75,22 +91,14 @@ export const SchemaViewer = ({keyColumnIds = [], columns = [], type}: SchemaView
         );
     }
 
-    // Display key columns first
-    const tableData = columns.sort((column) => {
-        if (column.Id && keyColumnIds.includes(column.Id)) {
-            return 1;
-        }
-        return -1;
-    });
-
     return (
         <div className={b()}>
             <DataTable
                 theme="yandex-cloud"
-                data={tableData}
+                data={columns}
                 columns={dataTableColumns}
                 settings={DEFAULT_TABLE_SETTINGS}
-                initialSortOrder={{columnId: SchemaViewerColumns.key, order: DataTable.DESCENDING}}
+                initialSortOrder={{columnId: SchemaViewerColumns.key, order: DataTable.ASCENDING}}
             />
         </div>
     );

package/dist/containers/UserSettings/i18n/en.json

@@ -25,6 +25,9 @@
   "settings.enableAdditionalQueryModes.title": "Enable additional query modes",
   "settings.enableAdditionalQueryModes.popover": "Adds 'Data', 'YQL - QueryService' and 'PostgreSQL' modes. May not work on some versions",
 
+  "settings.queryUseMultiSchema.title": "Allow queries with multiple result sets",
+  "settings.queryUseMultiSchema.popover": "Use 'multi' schema for queries that enables queries with multiple result sets. Returns nothing on versions 23-3 and older",
+
   "settings.tenantDiagnostics.title": "Display metrics cards for database diagnostics",
   "settings.tenantDiagnostics.popover": "Adds indicators of database resources usage. Incomplete data may be displayed for some databases"
 }

package/dist/containers/UserSettings/i18n/ru.json

@@ -25,6 +25,9 @@
   "settings.enableAdditionalQueryModes.title": "Включить дополнительные режимы выполнения запросов",
   "settings.enableAdditionalQueryModes.popover": "Добавляет режимы 'Data', 'YQL - QueryService' и 'PostgreSQL'. Может работать некорректно на некоторых версиях",
 
+  "settings.queryUseMultiSchema.title": "Разрешить запросы с несколькими результатами",
+  "settings.queryUseMultiSchema.popover": "Использовать для запросов схему 'multi', которая позволяет выполнять запросы с несколькими результатами. На версиях 23-3 и старше результат не возвращается вообще",
+
   "settings.tenantDiagnostics.title": "Показывать карточки с метриками в диагностике базы данных",
   "settings.tenantDiagnostics.popover": "Добавляет индикаторы использования ресурсов базы данных. Для некоторых баз могут отображаться неполные данные"
 }

package/dist/containers/UserSettings/settings.ts

@@ -11,6 +11,7 @@ import {
     THEME_KEY,
     USE_BACKEND_PARAMS_FOR_TABLES_KEY,
     USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY,
+    QUERY_USE_MULTI_SCHEMA_KEY,
 } from '../../utils/constants';
 import {Lang, defaultLang} from '../../utils/i18n';
 
@@ -95,6 +96,11 @@ export const enableQueryModesForExplainSetting: SettingProps = {
     title: i18n('settings.enableAdditionalQueryModes.title'),
     helpPopoverContent: i18n('settings.enableAdditionalQueryModes.popover'),
 };
+export const queryUseMultiSchemaSetting: SettingProps = {
+    settingKey: QUERY_USE_MULTI_SCHEMA_KEY,
+    title: i18n('settings.queryUseMultiSchema.title'),
+    helpPopoverContent: i18n('settings.queryUseMultiSchema.popover'),
+};
 export const enableNewTenantDiagnosticsDesign: SettingProps = {
     settingKey: DISPLAY_METRICS_CARDS_FOR_TENANT_DIAGNOSTICS,
     title: i18n('settings.tenantDiagnostics.title'),
@@ -113,6 +119,7 @@ export const experimentsSection: SettingsSection = {
         useNodesEndpointSetting,
         useBackendParamsForTables,
         enableQueryModesForExplainSetting,
+        queryUseMultiSchemaSetting,
         enableNewTenantDiagnosticsDesign,
     ],
 };

package/dist/store/reducers/cluster/__test__/parseGroupsStatsQueryResponse.test.ts

@@ -0,0 +1,121 @@
+import {parseGroupsStatsQueryResponse} from '../utils';
+
+describe('parseGroupsStatsQueryResponse', () => {
+    const columns = [
+        {
+            name: 'PDiskFilter',
+            type: 'Utf8?',
+        },
+        {
+            name: 'ErasureSpecies',
+            type: 'Utf8?',
+        },
+        {
+            name: 'CurrentAvailableSize',
+            type: 'Uint64?',
+        },
+        {
+            name: 'CurrentAllocatedSize',
+            type: 'Uint64?',
+        },
+        {
+            name: 'CurrentGroupsCreated',
+            type: 'Uint32?',
+        },
+        {
+            name: 'AvailableGroupsToCreate',
+            type: 'Uint32?',
+        },
+    ];
+
+    // 2 disk types and 2 erasure types
+    const dataSet1 = {
+        columns,
+        result: [
+            ['Type:SSD', 'block-4-2', '1000', '2000', 100, 50],
+            ['Type:ROT', 'block-4-2', '2000', '1000', 50, 0],
+            ['Type:ROT', 'mirror-3of4', '1000', '0', 15, 0],
+            ['Type:SSD', 'mirror-3of4', '1000', '0', 5, 50],
+            ['Type:ROT', 'mirror-3-dc', null, null, null, 0],
+            ['Type:SSD', 'mirror-3-dc', null, null, null, 0],
+        ],
+    };
+
+    // 2 disk types and 1 erasure types, but with additional disks params
+    const dataSet2 = {
+        columns,
+        result: [
+            ['Type:ROT,SharedWithOs:0,ReadCentric:0,Kind:0', 'mirror-3-dc', '1000', '500', 16, 16],
+            ['Type:ROT,SharedWithOs:1,ReadCentric:0,Kind:0', 'mirror-3-dc', '2000', '1000', 8, 24],
+            ['Type:SSD', 'mirror-3-dc', '3000', '400', 2, 10],
+            ['Type:ROT', 'mirror-3-dc', null, null, null, 32],
+            ['Type:ROT', 'block-4-2', null, null, null, 20],
+            ['Type:SSD', 'block-4-2', null, null, null, 0],
+        ],
+    };
+    const parsedDataSet1 = {
+        SSD: {
+            'block-4-2': {
+                diskType: 'SSD',
+                erasure: 'block-4-2',
+                createdGroups: 100,
+                totalGroups: 150,
+                allocatedSize: 2000,
+                availableSize: 1000,
+            },
+            'mirror-3of4': {
+                diskType: 'SSD',
+                erasure: 'mirror-3of4',
+                createdGroups: 5,
+                totalGroups: 55,
+                allocatedSize: 0,
+                availableSize: 1000,
+            },
+        },
+        HDD: {
+            'block-4-2': {
+                diskType: 'HDD',
+                erasure: 'block-4-2',
+                createdGroups: 50,
+                totalGroups: 50,
+                allocatedSize: 1000,
+                availableSize: 2000,
+            },
+            'mirror-3of4': {
+                diskType: 'HDD',
+                erasure: 'mirror-3of4',
+                createdGroups: 15,
+                totalGroups: 15,
+                allocatedSize: 0,
+                availableSize: 1000,
+            },
+        },
+    };
+
+    const parsedDataSet2 = {
+        HDD: {
+            'mirror-3-dc': {
+                diskType: 'HDD',
+                erasure: 'mirror-3-dc',
+                createdGroups: 24,
+                totalGroups: 64,
+                allocatedSize: 1500,
+                availableSize: 3000,
+            },
+        },
+        SSD: {
+            'mirror-3-dc': {
+                diskType: 'SSD',
+                erasure: 'mirror-3-dc',
+                createdGroups: 2,
+                totalGroups: 12,
+                allocatedSize: 400,
+                availableSize: 3000,
+            },
+        },
+    };
+    it('should correctly parse data', () => {
+        expect(parseGroupsStatsQueryResponse(dataSet1)).toEqual(parsedDataSet1);
+        expect(parseGroupsStatsQueryResponse(dataSet2)).toEqual(parsedDataSet2);
+    });
+});

package/dist/store/reducers/cluster/cluster.ts

@@ -3,6 +3,7 @@ import type {Reducer} from 'redux';
 import '../../../services/api';
 import {createRequestActionTypes, createApiRequest} from '../../utils';
 import type {ClusterAction, ClusterState} from './types';
+import {createSelectClusterGroupsQuery, parseGroupsStatsQueryResponse} from './utils';
 
 export const FETCH_CLUSTER = createRequestActionTypes('cluster', 'FETCH_CLUSTER');
 
@@ -17,9 +18,12 @@ const cluster: Reducer<ClusterState, ClusterAction> = (state = initialState, act
             };
         }
         case FETCH_CLUSTER.SUCCESS: {
+            const {clusterData, groupsStats} = action.data;
+
             return {
                 ...state,
-                data: action.data,
+                data: clusterData,
+                groupsStats,
                 loading: false,
                 wasLoaded: true,
                 error: undefined,
@@ -42,8 +46,48 @@ const cluster: Reducer<ClusterState, ClusterAction> = (state = initialState, act
 };
 
 export function getClusterInfo(clusterName?: string) {
+    async function requestClusterData() {
+        // Error here is handled by createApiRequest
+        const clusterData = await window.api.getClusterInfo(clusterName);
+
+        try {
+            const clusterRoot = clusterData.Domain;
+
+            // Without domain we cannot get stats from system tables
+            if (!clusterRoot) {
+                return {
+                    clusterData,
+                };
+            }
+
+            const query = createSelectClusterGroupsQuery(clusterRoot);
+
+            // Normally query request should be fulfilled within 300-400ms even on very big clusters
+            // Table with stats is supposed to be very small (less than 10 rows)
+            // So we batch this request with cluster request to prevent possible layout shifts, if data is missing
+            const groupsStatsResponse = await window.api.sendQuery({
+                schema: 'modern',
+                query: query,
+                database: clusterRoot,
+                action: 'execute-scan',
+            });
+
+            return {
+                clusterData,
+                groupsStats: parseGroupsStatsQueryResponse(groupsStatsResponse),
+            };
+        } catch {
+            // Doesn't return groups stats on error
+            // It could happen if user doesn't have access rights
+            // Or there are no system tables in cluster root
+            return {
+                clusterData,
+            };
+        }
+    }
+
     return createApiRequest({
-        request: window.api.getClusterInfo(clusterName),
+        request: requestClusterData(),
         actions: FETCH_CLUSTER,
     });
 }

package/dist/store/reducers/cluster/types.ts

@@ -1,14 +1,39 @@
-import {FETCH_CLUSTER} from './cluster';
-
 import type {TClusterInfo} from '../../../types/api/cluster';
-import type {ApiRequestAction} from '../../utils';
 import type {IResponseError} from '../../../types/api/error';
+import type {ApiRequestAction} from '../../utils';
+
+import {FETCH_CLUSTER} from './cluster';
+
+export interface DiskErasureGroupsStats {
+    diskType: string;
+    erasure: string;
+    createdGroups: number;
+    totalGroups: number;
+    allocatedSize: number;
+    availableSize: number;
+}
+
+/** Keys - erasure types */
+export type DiskGroupsStats = Record<string, DiskErasureGroupsStats>;
+
+/** Keys - PDisks types */
+export type ClusterGroupsStats = Record<string, DiskGroupsStats>;
 
 export interface ClusterState {
     loading: boolean;
     wasLoaded: boolean;
     data?: TClusterInfo;
     error?: IResponseError;
+    groupsStats?: ClusterGroupsStats;
+}
+
+export interface HandledClusterResponse {
+    clusterData: TClusterInfo;
+    groupsStats: ClusterGroupsStats;
 }
 
-export type ClusterAction = ApiRequestAction<typeof FETCH_CLUSTER, TClusterInfo, IResponseError>;
+export type ClusterAction = ApiRequestAction<
+    typeof FETCH_CLUSTER,
+    HandledClusterResponse,
+    IResponseError
+>;

package/dist/store/reducers/cluster/utils.ts

@@ -0,0 +1,88 @@
+import type {ExecuteQueryResponse} from '../../../types/api/query';
+import {parseQueryAPIExecuteResponse} from '../../../utils/query';
+
+import type {ClusterGroupsStats} from './types';
+
+export const createSelectClusterGroupsQuery = (clusterRoot: string) => {
+    return `
+SELECT 
+    PDiskFilter,
+    ErasureSpecies,
+    CurrentAvailableSize,
+    CurrentAllocatedSize,
+    CurrentGroupsCreated,
+    AvailableGroupsToCreate
+    FROM \`${clusterRoot}/.sys/ds_storage_stats\`
+    ORDER BY CurrentGroupsCreated DESC;
+`;
+};
+
+const getDiskType = (rawTypeString: string) => {
+    // Check if value math regexp and put disk type in type group
+    const diskTypeRe = /^Type:(?<type>[A-Za-z]+)/;
+
+    const diskType = rawTypeString.match(diskTypeRe)?.groups?.['type'];
+
+    if (diskType === 'ROT') {
+        // Display ROT as HDD
+        return 'HDD';
+    }
+
+    return diskType;
+};
+
+export const parseGroupsStatsQueryResponse = (
+    data: ExecuteQueryResponse<'modern'>,
+): ClusterGroupsStats => {
+    const parsedData = parseQueryAPIExecuteResponse(data).result;
+    const result: ClusterGroupsStats = {};
+
+    parsedData?.forEach((stats) => {
+        const {
+            PDiskFilter,
+            ErasureSpecies: erasure,
+            CurrentAvailableSize,
+            CurrentAllocatedSize,
+            CurrentGroupsCreated,
+            AvailableGroupsToCreate,
+        } = stats;
+
+        const createdGroups = Number(CurrentGroupsCreated) || 0;
+        const availableGroupsToCreate = Number(AvailableGroupsToCreate) || 0;
+        const totalGroups = createdGroups + availableGroupsToCreate;
+        const allocatedSize = Number(CurrentAllocatedSize) || 0;
+        const availableSize = Number(CurrentAvailableSize) || 0;
+        const diskType = PDiskFilter && typeof PDiskFilter === 'string' && getDiskType(PDiskFilter);
+
+        if (diskType && erasure && typeof erasure === 'string' && createdGroups) {
+            const preparedStats = {
+                diskType,
+                erasure,
+                createdGroups,
+                totalGroups,
+                allocatedSize,
+                availableSize,
+            };
+
+            if (result[diskType]) {
+                if (result[diskType][erasure]) {
+                    const currentValue = {...result[diskType][erasure]};
+                    result[diskType][erasure] = {
+                        diskType,
+                        erasure,
+                        createdGroups: currentValue.createdGroups + createdGroups,
+                        totalGroups: currentValue.totalGroups + totalGroups,
+                        allocatedSize: currentValue.allocatedSize + allocatedSize,
+                        availableSize: currentValue.availableSize + availableSize,
+                    };
+                } else {
+                    result[diskType][erasure] = preparedStats;
+                }
+            } else {
+                result[diskType] = {[erasure]: preparedStats};
+            }
+        }
+    });
+
+    return result;
+};

package/dist/store/reducers/executeQuery.ts

@@ -1,6 +1,6 @@
 import type {Reducer} from 'redux';
 
-import type {ExecuteActions} from '../../types/api/query';
+import type {ExecuteActions, Schemas} from '../../types/api/query';
 import type {
     ExecuteQueryAction,
     ExecuteQueryState,
@@ -154,9 +154,10 @@ const executeQuery: Reducer<ExecuteQueryState, ExecuteQueryAction> = (
 
 interface SendQueryParams extends QueryRequestParams {
     mode?: QueryMode;
+    schema?: Schemas;
 }
 
-export const sendExecuteQuery = ({query, database, mode}: SendQueryParams) => {
+export const sendExecuteQuery = ({query, database, mode, schema = 'modern'}: SendQueryParams) => {
     let action: ExecuteActions = 'execute';
     let syntax: QuerySyntax = QUERY_SYNTAX.yql;
 
@@ -169,7 +170,7 @@ export const sendExecuteQuery = ({query, database, mode}: SendQueryParams) => {
 
     return createApiRequest({
         request: window.api.sendQuery({
-            schema: 'modern',
+            schema,
             query,
             database,
             action,

package/dist/store/reducers/nodes/types.ts

@@ -30,15 +30,25 @@ export interface NodesPreparedEntity {
     DataCenter?: string;
     Rack?: string;
     Version?: string;
+    TenantName?: string;
+
     StartTime?: string;
     Uptime: string;
+    DisconnectTime?: string;
+
     MemoryUsed?: string;
+    MemoryUsedInAlloc?: string;
     MemoryLimit?: string;
+
+    SharedCacheUsed?: string;
+    SharedCacheLimit?: string | number;
+
     PoolStats?: TPoolStats[];
     LoadAverage?: number[];
     Tablets?: TFullTabletStateInfo[] | TComputeTabletStateInfo[];
-    TenantName?: string;
     Endpoints?: TEndpoint[];
+
+    TotalSessions?: number;
 }
 
 export interface NodesState {

package/dist/store/reducers/nodes/utils.ts

@@ -50,12 +50,18 @@ export const prepareNodesData = (data: TNodesInfo): NodesHandledResponse => {
     const rawNodes = data.Nodes || [];
 
     const preparedNodes = rawNodes.map((node) => {
+        // 0 limit means that limit is not set, so it should be undefined
+        const sharedCacheLimit = Number(node.SystemState.SharedCacheStats?.LimitBytes) || undefined;
+
         return {
             ...node.SystemState,
             Tablets: node.Tablets,
             NodeId: node.NodeId,
             Uptime: calcUptime(node.SystemState?.StartTime),
             TenantName: node.SystemState?.Tenants?.[0],
+
+            SharedCacheUsed: node.SystemState.SharedCacheStats?.UsedBytes,
+            SharedCacheLimit: sharedCacheLimit,
         };
     });
 

package/dist/store/reducers/settings/settings.ts

@@ -16,6 +16,7 @@ import {
     USE_BACKEND_PARAMS_FOR_TABLES_KEY,
     LANGUAGE_KEY,
     DISPLAY_METRICS_CARDS_FOR_TENANT_DIAGNOSTICS,
+    QUERY_USE_MULTI_SCHEMA_KEY,
 } from '../../../utils/constants';
 import '../../../services/api';
 import {parseJson} from '../../../utils/utils';
@@ -56,6 +57,7 @@ export const initialState = {
             ENABLE_ADDITIONAL_QUERY_MODES,
             'true',
         ),
+        [QUERY_USE_MULTI_SCHEMA_KEY]: readSavedSettingsValue(QUERY_USE_MULTI_SCHEMA_KEY, 'false'),
         [DISPLAY_METRICS_CARDS_FOR_TENANT_DIAGNOSTICS]: readSavedSettingsValue(
             DISPLAY_METRICS_CARDS_FOR_TENANT_DIAGNOSTICS,
             'true',

package/dist/types/api/cluster.ts

@@ -32,6 +32,9 @@ export interface TClusterInfo {
     /** uint64 */
     Tablets?: string;
 
+    /** Cluster root database */
+    Domain?: string;
+
     Balancer?: string; // additional
     Solomon?: string; // additional
 }

package/dist/types/api/netInfo.ts

@@ -27,7 +27,7 @@ interface TNetNodeInfo {
     Port: number;
 }
 
-interface TNetNodePeerInfo {
+export interface TNetNodePeerInfo {
     NodeId: number;
     PeerName: string;
     Connected: boolean;