ydb-embedded-ui 6.4.0 → 6.6.0

package/dist/src/store/reducers/executeQuery.js

@@ -0,0 +1,145 @@
+import { settingsManager } from '../../services/settings';
+import { QUERIES_HISTORY_KEY } from '../../utils/constants';
+import { QUERY_MODES, QUERY_SYNTAX, isQueryErrorResponse, parseQueryAPIExecuteResponse, } from '../../utils/query';
+import { createRequestActionTypes } from '../utils';
+import { api } from './api';
+const MAXIMUM_QUERIES_IN_HISTORY = 20;
+export const SEND_QUERY = createRequestActionTypes('query', 'SEND_QUERY');
+const CHANGE_USER_INPUT = 'query/CHANGE_USER_INPUT';
+const SAVE_QUERY_TO_HISTORY = 'query/SAVE_QUERY_TO_HISTORY';
+const GO_TO_PREVIOUS_QUERY = 'query/GO_TO_PREVIOUS_QUERY';
+const GO_TO_NEXT_QUERY = 'query/GO_TO_NEXT_QUERY';
+const SET_TENANT_PATH = 'query/SET_TENANT_PATH';
+const queriesHistoryInitial = settingsManager.readUserSettingsValue(QUERIES_HISTORY_KEY, []);
+const sliceLimit = queriesHistoryInitial.length - MAXIMUM_QUERIES_IN_HISTORY;
+const initialState = {
+    loading: false,
+    input: '',
+    history: {
+        queries: queriesHistoryInitial
+            .slice(sliceLimit < 0 ? 0 : sliceLimit)
+            .map(getQueryInHistory),
+        currentIndex: queriesHistoryInitial.length > MAXIMUM_QUERIES_IN_HISTORY
+            ? MAXIMUM_QUERIES_IN_HISTORY - 1
+            : queriesHistoryInitial.length - 1,
+    },
+};
+const executeQuery = (state = initialState, action) => {
+    switch (action.type) {
+        case CHANGE_USER_INPUT: {
+            return Object.assign(Object.assign({}, state), { input: action.data.input });
+        }
+        case SAVE_QUERY_TO_HISTORY: {
+            const queryText = action.data.queryText;
+            // Do not save explicit yql syntax value for easier further support (use yql by default)
+            const syntax = action.data.mode === QUERY_MODES.pg ? QUERY_SYNTAX.pg : undefined;
+            const newQueries = [...state.history.queries, { queryText, syntax }].slice(state.history.queries.length >= MAXIMUM_QUERIES_IN_HISTORY ? 1 : 0);
+            settingsManager.setUserSettingsValue(QUERIES_HISTORY_KEY, newQueries);
+            const currentIndex = newQueries.length - 1;
+            return Object.assign(Object.assign({}, state), { history: {
+                    queries: newQueries,
+                    currentIndex,
+                } });
+        }
+        case GO_TO_PREVIOUS_QUERY: {
+            const currentIndex = state.history.currentIndex;
+            if (currentIndex <= 0) {
+                return state;
+            }
+            const newCurrentIndex = currentIndex - 1;
+            const query = state.history.queries[newCurrentIndex];
+            return Object.assign(Object.assign({}, state), { history: Object.assign(Object.assign({}, state.history), { currentIndex: newCurrentIndex }), input: query.queryText });
+        }
+        case GO_TO_NEXT_QUERY: {
+            const lastIndexInHistory = state.history.queries.length - 1;
+            const currentIndex = state.history.currentIndex;
+            if (currentIndex >= lastIndexInHistory) {
+                return state;
+            }
+            const newCurrentIndex = currentIndex + 1;
+            const query = state.history.queries[newCurrentIndex];
+            return Object.assign(Object.assign({}, state), { history: Object.assign(Object.assign({}, state.history), { currentIndex: newCurrentIndex }), input: query.queryText });
+        }
+        case SET_TENANT_PATH: {
+            return Object.assign(Object.assign({}, state), { tenantPath: action.data });
+        }
+        default:
+            return state;
+    }
+};
+export const executeQueryApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        executeQuery: build.mutation({
+            queryFn: async ({ query, database, mode, schema = 'modern' }) => {
+                let action = 'execute';
+                let syntax = QUERY_SYNTAX.yql;
+                if (mode === 'pg') {
+                    action = 'execute-query';
+                    syntax = QUERY_SYNTAX.pg;
+                }
+                else if (mode) {
+                    action = `execute-${mode}`;
+                }
+                try {
+                    const response = await window.api.sendQuery({
+                        schema,
+                        query,
+                        database,
+                        action,
+                        syntax,
+                        stats: 'full',
+                    });
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
+                    const data = parseQueryAPIExecuteResponse(response);
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+        }),
+    }),
+    overrideExisting: 'throw',
+});
+export const saveQueryToHistory = (queryText, mode) => {
+    return {
+        type: SAVE_QUERY_TO_HISTORY,
+        data: { queryText, mode },
+    };
+};
+export const goToPreviousQuery = () => {
+    return {
+        type: GO_TO_PREVIOUS_QUERY,
+    };
+};
+export const goToNextQuery = () => {
+    return {
+        type: GO_TO_NEXT_QUERY,
+    };
+};
+export const changeUserInput = ({ input }) => {
+    return {
+        type: CHANGE_USER_INPUT,
+        data: { input },
+    };
+};
+export const setTenantPath = (value) => {
+    return {
+        type: SET_TENANT_PATH,
+        data: value,
+    };
+};
+export const selectQueriesHistory = (state) => {
+    return state.executeQuery.history.queries;
+};
+function getQueryInHistory(rawQuery) {
+    if (typeof rawQuery === 'string') {
+        return {
+            queryText: rawQuery,
+        };
+    }
+    return rawQuery;
+}
+export default executeQuery;

package/dist/src/store/reducers/executeTopQueries/executeTopQueries.js

@@ -0,0 +1,68 @@
+import { createSlice } from '@reduxjs/toolkit';
+import { HOUR_IN_SECONDS } from '../../../utils/constants';
+import { isQueryErrorResponse, parseQueryAPIExecuteResponse } from '../../../utils/query';
+import { api } from '../api';
+import { getFiltersConditions } from './utils';
+const initialState = {};
+const slice = createSlice({
+    name: 'executeTopQueries',
+    initialState,
+    reducers: {
+        setTopQueriesFilters: (state, action) => {
+            return Object.assign(Object.assign({}, state), action.payload);
+        },
+    },
+});
+export const { setTopQueriesFilters } = slice.actions;
+export default slice.reducer;
+const getQueryText = (path, filters) => {
+    const filterConditions = getFiltersConditions(path, filters);
+    return `
+SELECT
+    CPUTime as CPUTimeUs,
+    QueryText,
+    IntervalEnd,
+    EndTime,
+    ReadRows,
+    ReadBytes,
+    UserSID,
+    Duration
+FROM \`${path}/.sys/top_queries_by_cpu_time_one_hour\`
+WHERE ${filterConditions || 'true'}
+`;
+};
+export const topQueriesApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        getTopQueries: build.query({
+            queryFn: async ({ database, filters }, { signal, dispatch }) => {
+                var _a, _b;
+                try {
+                    const response = await window.api.sendQuery({
+                        schema: 'modern',
+                        query: getQueryText(database, filters),
+                        database,
+                        action: 'execute-scan',
+                    }, { signal });
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
+                    const data = parseQueryAPIExecuteResponse(response);
+                    // FIXME: do we really need this?
+                    if (!(filters === null || filters === void 0 ? void 0 : filters.from) && !(filters === null || filters === void 0 ? void 0 : filters.to)) {
+                        const intervalEnd = (_b = (_a = data === null || data === void 0 ? void 0 : data.result) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.IntervalEnd;
+                        if (intervalEnd) {
+                            const to = new Date(intervalEnd).getTime();
+                            const from = new Date(to - HOUR_IN_SECONDS * 1000).getTime();
+                            dispatch(setTopQueriesFilters({ from, to }));
+                        }
+                    }
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+        }),
+    }),
+    overrideExisting: 'throw',
+});

package/dist/src/store/reducers/explainQuery/explainQuery.d.ts

@@ -0,0 +1,9 @@
+import type { QueryMode, QueryRequestParams } from '../../../types/store/query';
+import type { PreparedExplainResponse } from './types';
+interface ExplainQueryParams extends QueryRequestParams {
+    mode?: QueryMode;
+}
+export declare const explainQueryApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    explainQuery: import("@reduxjs/toolkit/query").MutationDefinition<ExplainQueryParams, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", PreparedExplainResponse, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
+export {};

package/dist/src/store/reducers/explainQuery/explainQuery.js

@@ -0,0 +1,32 @@
+import { QUERY_SYNTAX, isQueryErrorResponse } from '../../../utils/query';
+import { api } from '../api';
+import { prepareExplainResponse } from './utils';
+export const explainQueryApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        explainQuery: build.mutation({
+            queryFn: async ({ query, database, mode }) => {
+                let action = 'explain';
+                let syntax = QUERY_SYNTAX.yql;
+                if (mode === 'pg') {
+                    action = 'explain-query';
+                    syntax = QUERY_SYNTAX.pg;
+                }
+                else if (mode) {
+                    action = `explain-${mode}`;
+                }
+                try {
+                    const response = await window.api.getExplainQuery(query, database, action, syntax);
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
+                    const data = prepareExplainResponse(response);
+                    return { data };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+        }),
+    }),
+    overrideExisting: 'throw',
+});

package/dist/src/store/reducers/explainQuery/types.d.ts

@@ -0,0 +1,12 @@
+import type { ExplainPlanNodeData, GraphNode, Link } from '@gravity-ui/paranoid';
+import type { PlanTable, QueryPlan, ScriptPlan } from '../../../types/api/query';
+export interface PreparedExplainResponse {
+    plan?: {
+        links?: Link[];
+        nodes?: GraphNode<ExplainPlanNodeData>[];
+        tables?: PlanTable[];
+        version?: string;
+        pristine?: QueryPlan | ScriptPlan;
+    };
+    ast?: string;
+}

package/dist/src/store/reducers/explainQuery/utils.d.ts

@@ -0,0 +1,6 @@
+import type { ExplainQueryResponse, ExplainScriptResponse } from '../../../types/api/query';
+import type { PreparedExplainResponse } from './types';
+export declare const explainVersions: {
+    v2: string;
+};
+export declare const prepareExplainResponse: (response: ExplainScriptResponse | ExplainQueryResponse) => PreparedExplainResponse;

package/dist/src/store/reducers/explainQuery/utils.js

@@ -0,0 +1,40 @@
+import { preparePlan } from '../../../utils/prepareQueryExplain';
+import { parseQueryAPIExplainResponse, parseQueryExplainPlan } from '../../../utils/query';
+export const explainVersions = {
+    v2: '0.2',
+};
+const supportedExplainQueryVersions = Object.values(explainVersions);
+export const prepareExplainResponse = (response) => {
+    const { plan: rawPlan, ast } = parseQueryAPIExplainResponse(response);
+    if (!rawPlan) {
+        return { ast };
+    }
+    const { tables, meta, Plan } = parseQueryExplainPlan(rawPlan);
+    if (supportedExplainQueryVersions.indexOf(meta.version) === -1) {
+        // Do not prepare plan for not supported versions
+        return {
+            plan: {
+                pristine: rawPlan,
+                version: meta.version,
+            },
+            ast,
+        };
+    }
+    let links = [];
+    let nodes = [];
+    if (Plan) {
+        const preparedPlan = preparePlan(Plan);
+        links = preparedPlan.links;
+        nodes = preparedPlan.nodes;
+    }
+    return {
+        plan: {
+            links,
+            nodes,
+            tables,
+            version: meta.version,
+            pristine: rawPlan,
+        },
+        ast,
+    };
+};