mirror of
https://github.com/apache/superset.git
synced 2026-04-20 00:24:38 +00:00
chore(frontend): migrate SqlLab and explore JS/JSX files to TypeScript (#36760)
Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>
This commit is contained in:
Evan Rusackas
836
superset-frontend/src/SqlLab/reducers/sqlLab.ts
Normal file
836
superset-frontend/src/SqlLab/reducers/sqlLab.ts
Normal file
@@ -0,0 +1,836 @@
|
||||
/**
|
||||
* Licensed to the Apache Software Foundation (ASF) under one
|
||||
* or more contributor license agreements. See the NOTICE file
|
||||
* distributed with this work for additional information
|
||||
* regarding copyright ownership. The ASF licenses this file
|
||||
* to you under the Apache License, Version 2.0 (the
|
||||
* "License"); you may not use this file except in compliance
|
||||
* with the License. You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing,
|
||||
* software distributed under the License is distributed on an
|
||||
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
||||
* KIND, either express or implied. See the License for the
|
||||
* specific language governing permissions and limitations
|
||||
* under the License.
|
||||
*/
|
||||
import { normalizeTimestamp, QueryState, t } from '@superset-ui/core';
|
||||
import { isEqual, omit } from 'lodash';
|
||||
import { shallowEqual } from 'react-redux';
|
||||
import { now } from '@superset-ui/core/utils/dates';
|
||||
import type { SqlLabRootState, QueryEditor, Table } from '../types';
|
||||
import * as actions from '../actions/sqlLab';
|
||||
import type { SqlLabAction } from '../actions/sqlLab';
|
||||
import {
|
||||
addToObject,
|
||||
alterInObject,
|
||||
alterInArr,
|
||||
removeFromArr,
|
||||
getFromArr,
|
||||
addToArr,
|
||||
extendArr,
|
||||
} from '../../reduxUtils';
|
||||
|
||||
type SqlLabState = SqlLabRootState['sqlLab'];
|
||||
|
||||
function alterUnsavedQueryEditorState(
|
||||
state: SqlLabState,
|
||||
updatedState: Partial<QueryEditor>,
|
||||
id: string,
|
||||
silent = false,
|
||||
): Partial<SqlLabState> {
|
||||
if (state.tabHistory[state.tabHistory.length - 1] !== id) {
|
||||
const { queryEditors } = alterInArr(
|
||||
state,
|
||||
'queryEditors',
|
||||
{ id },
|
||||
updatedState,
|
||||
);
|
||||
return {
|
||||
queryEditors,
|
||||
};
|
||||
}
|
||||
return {
|
||||
unsavedQueryEditor: {
|
||||
...(state.unsavedQueryEditor.id === id && state.unsavedQueryEditor),
|
||||
...(id ? { id, ...updatedState } : state.unsavedQueryEditor),
|
||||
...(!silent && { updatedAt: new Date().getTime() }),
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
export default function sqlLabReducer(
|
||||
state: SqlLabState = {} as SqlLabState,
|
||||
action: SqlLabAction,
|
||||
): SqlLabState {
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
const actionHandlers: Record<string, () => any> = {
|
||||
[actions.ADD_QUERY_EDITOR]() {
|
||||
const mergeUnsavedState = alterInArr(
|
||||
state,
|
||||
'queryEditors',
|
||||
state.unsavedQueryEditor,
|
||||
{
|
||||
...state.unsavedQueryEditor,
|
||||
},
|
||||
);
|
||||
const newState = {
|
||||
...mergeUnsavedState,
|
||||
tabHistory: [...state.tabHistory, action.queryEditor!.id],
|
||||
};
|
||||
return addToArr(newState, 'queryEditors', {
|
||||
...action.queryEditor!,
|
||||
updatedAt: new Date().getTime(),
|
||||
});
|
||||
},
|
||||
[actions.QUERY_EDITOR_SAVED]() {
|
||||
const { query, result, clientId } = action;
|
||||
const existing = state.queryEditors.find(qe => qe.id === clientId);
|
||||
return alterInArr(
|
||||
state,
|
||||
'queryEditors',
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
existing as any,
|
||||
{
|
||||
remoteId: result!.remoteId,
|
||||
name: (query as { name: string }).name,
|
||||
},
|
||||
'id',
|
||||
);
|
||||
},
|
||||
[actions.UPDATE_QUERY_EDITOR]() {
|
||||
const id = action.alterations!.remoteId;
|
||||
const existing = state.queryEditors.find(qe => qe.remoteId === id);
|
||||
if (existing == null) return state;
|
||||
return alterInArr(
|
||||
state,
|
||||
'queryEditors',
|
||||
existing,
|
||||
action.alterations!,
|
||||
'remoteId',
|
||||
);
|
||||
},
|
||||
[actions.CLONE_QUERY_TO_NEW_TAB]() {
|
||||
const queryEditor = state.queryEditors.find(
|
||||
qe => qe.id === state.tabHistory[state.tabHistory.length - 1],
|
||||
);
|
||||
const progenitor = {
|
||||
...queryEditor,
|
||||
...(state.unsavedQueryEditor.id === queryEditor?.id &&
|
||||
state.unsavedQueryEditor),
|
||||
};
|
||||
const qe = {
|
||||
remoteId: progenitor.remoteId,
|
||||
name: t('Copy of %s', progenitor.name),
|
||||
dbId: action.query!.dbId ? action.query!.dbId : null,
|
||||
catalog: action.query!.catalog ? action.query!.catalog : null,
|
||||
schema: action.query!.schema ? action.query!.schema : null,
|
||||
autorun: true,
|
||||
sql: action.query!.sql,
|
||||
queryLimit: action.query!.queryLimit,
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
maxRow: (action.query as any)?.maxRow,
|
||||
};
|
||||
const stateWithoutUnsavedState = {
|
||||
...state,
|
||||
unsavedQueryEditor: {},
|
||||
};
|
||||
return sqlLabReducer(
|
||||
stateWithoutUnsavedState,
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
actions.addQueryEditor(qe as any),
|
||||
);
|
||||
},
|
||||
[actions.REMOVE_QUERY_EDITOR]() {
|
||||
const queryEditor = {
|
||||
...action.queryEditor!,
|
||||
...(action.queryEditor!.id === state.unsavedQueryEditor.id &&
|
||||
state.unsavedQueryEditor),
|
||||
};
|
||||
let newState = removeFromArr(state, 'queryEditors', queryEditor);
|
||||
// List of remaining queryEditor ids
|
||||
const qeIds = newState.queryEditors.map(
|
||||
(qe: QueryEditor) => qe.tabViewId ?? qe.id,
|
||||
);
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
const queries: any = {};
|
||||
Object.keys(state.queries).forEach(k => {
|
||||
const query = state.queries[k];
|
||||
if (qeIds.indexOf(query.sqlEditorId) > -1) {
|
||||
queries[k] = query;
|
||||
}
|
||||
});
|
||||
|
||||
let tabHistory = state.tabHistory.slice();
|
||||
tabHistory = tabHistory.filter(id => qeIds.indexOf(id) > -1);
|
||||
|
||||
// Remove associated table schemas
|
||||
const tables = state.tables.filter(
|
||||
table =>
|
||||
table.queryEditorId !== (queryEditor.tabViewId ?? queryEditor.id),
|
||||
);
|
||||
|
||||
newState = {
|
||||
...newState,
|
||||
tabHistory:
|
||||
tabHistory.length === 0 && newState.queryEditors.length > 0
|
||||
? newState.queryEditors.slice(-1).map((qe: QueryEditor) => qe.id)
|
||||
: tabHistory,
|
||||
tables,
|
||||
queries,
|
||||
unsavedQueryEditor: {
|
||||
...(action.queryEditor!.id !== state.unsavedQueryEditor.id &&
|
||||
state.unsavedQueryEditor),
|
||||
},
|
||||
destroyedQueryEditors: {
|
||||
...newState.destroyedQueryEditors,
|
||||
...(!queryEditor.inLocalStorage && {
|
||||
[(queryEditor.tabViewId ?? queryEditor.id)!]: Date.now(),
|
||||
}),
|
||||
},
|
||||
};
|
||||
return newState;
|
||||
},
|
||||
[actions.CLEAR_DESTROYED_QUERY_EDITOR]() {
|
||||
const destroyedQueryEditors = { ...state.destroyedQueryEditors };
|
||||
delete destroyedQueryEditors[action.queryEditorId!];
|
||||
return { ...state, destroyedQueryEditors };
|
||||
},
|
||||
[actions.REMOVE_QUERY]() {
|
||||
const newQueries = { ...state.queries };
|
||||
delete newQueries[action.query!.id!];
|
||||
return { ...state, queries: newQueries };
|
||||
},
|
||||
[actions.RESET_STATE]() {
|
||||
return { ...action.sqlLabInitialState };
|
||||
},
|
||||
[actions.MERGE_TABLE]() {
|
||||
const at = { ...action.table } as Table;
|
||||
const existingTableIndex = state.tables.findIndex(
|
||||
xt =>
|
||||
xt.dbId === at.dbId &&
|
||||
xt.queryEditorId === at.queryEditorId &&
|
||||
xt.catalog === at.catalog &&
|
||||
xt.schema === at.schema &&
|
||||
xt.name === at.name,
|
||||
);
|
||||
if (existingTableIndex >= 0) {
|
||||
if (action.query) {
|
||||
at.dataPreviewQueryId = action.query!.id;
|
||||
}
|
||||
return {
|
||||
...state,
|
||||
tables: [
|
||||
...state.tables.slice(0, existingTableIndex),
|
||||
{
|
||||
...state.tables[existingTableIndex],
|
||||
...at,
|
||||
...(state.tables[existingTableIndex].initialized && {
|
||||
id: state.tables[existingTableIndex].id,
|
||||
}),
|
||||
},
|
||||
...state.tables.slice(existingTableIndex + 1),
|
||||
],
|
||||
...(at.expanded && {
|
||||
activeSouthPaneTab: at.id,
|
||||
}),
|
||||
};
|
||||
}
|
||||
// for new table, associate Id of query for data preview
|
||||
at.dataPreviewQueryId = null;
|
||||
let newState = {
|
||||
...addToArr(state, 'tables', at, Boolean(action.prepend)),
|
||||
...(at.expanded && { activeSouthPaneTab: at.id }),
|
||||
};
|
||||
if (action.query) {
|
||||
newState = alterInArr(newState, 'tables', at, {
|
||||
dataPreviewQueryId: action.query!.id,
|
||||
});
|
||||
}
|
||||
return newState;
|
||||
},
|
||||
[actions.EXPAND_TABLE]() {
|
||||
return alterInArr(state, 'tables', action.table!, { expanded: true });
|
||||
},
|
||||
[actions.REMOVE_DATA_PREVIEW]() {
|
||||
const queries = { ...state.queries };
|
||||
delete queries[action.table!.dataPreviewQueryId!];
|
||||
const newState = alterInArr(state, 'tables', action.table!, {
|
||||
dataPreviewQueryId: null,
|
||||
});
|
||||
return { ...newState, queries };
|
||||
},
|
||||
[actions.CHANGE_DATA_PREVIEW_ID]() {
|
||||
const queries = { ...state.queries };
|
||||
delete queries[action.oldQueryId!];
|
||||
|
||||
const newTables: Table[] = [];
|
||||
state.tables.forEach(xt => {
|
||||
if (xt.dataPreviewQueryId === action.oldQueryId) {
|
||||
newTables.push({ ...xt, dataPreviewQueryId: action.newQuery!.id });
|
||||
} else {
|
||||
newTables.push(xt);
|
||||
}
|
||||
});
|
||||
return {
|
||||
...state,
|
||||
queries,
|
||||
tables: newTables,
|
||||
};
|
||||
},
|
||||
[actions.COLLAPSE_TABLE]() {
|
||||
return alterInArr(state, 'tables', action.table!, { expanded: false });
|
||||
},
|
||||
[actions.REMOVE_TABLES]() {
|
||||
const tableIds = action.tables!.map((table: Table) => table.id);
|
||||
const tables = state.tables.filter(table => !tableIds.includes(table.id));
|
||||
|
||||
return {
|
||||
...state,
|
||||
tables,
|
||||
...(tableIds.includes(state.activeSouthPaneTab as string) && {
|
||||
activeSouthPaneTab:
|
||||
tables.find(
|
||||
({ queryEditorId }) =>
|
||||
queryEditorId === action.tables![0].queryEditorId,
|
||||
)?.id ?? 'Results',
|
||||
}),
|
||||
};
|
||||
},
|
||||
[actions.COST_ESTIMATE_STARTED]() {
|
||||
return {
|
||||
...state,
|
||||
queryCostEstimates: {
|
||||
...state.queryCostEstimates,
|
||||
[action.query!.id!]: {
|
||||
completed: false,
|
||||
cost: null,
|
||||
error: null,
|
||||
},
|
||||
},
|
||||
};
|
||||
},
|
||||
[actions.COST_ESTIMATE_RETURNED]() {
|
||||
return {
|
||||
...state,
|
||||
queryCostEstimates: {
|
||||
...state.queryCostEstimates,
|
||||
[action.query!.id!]: {
|
||||
completed: true,
|
||||
cost: action.json!.result,
|
||||
error: null,
|
||||
},
|
||||
},
|
||||
};
|
||||
},
|
||||
[actions.COST_ESTIMATE_FAILED]() {
|
||||
return {
|
||||
...state,
|
||||
queryCostEstimates: {
|
||||
...state.queryCostEstimates,
|
||||
[action.query!.id!]: {
|
||||
completed: false,
|
||||
cost: null,
|
||||
error: action.error,
|
||||
},
|
||||
},
|
||||
};
|
||||
},
|
||||
[actions.START_QUERY]() {
|
||||
let newState = { ...state };
|
||||
let sqlEditorId;
|
||||
if (action.query!.sqlEditorId) {
|
||||
const queryEditorByTabId = getFromArr(
|
||||
state.queryEditors,
|
||||
action.query!.sqlEditorId,
|
||||
'tabViewId',
|
||||
);
|
||||
sqlEditorId =
|
||||
(queryEditorByTabId as QueryEditor | undefined)?.id ??
|
||||
action.query!.sqlEditorId;
|
||||
const foundQueryEditor = getFromArr(state.queryEditors, sqlEditorId);
|
||||
const baseQe = foundQueryEditor || {};
|
||||
const qe = {
|
||||
...baseQe,
|
||||
...(sqlEditorId === state.unsavedQueryEditor.id &&
|
||||
state.unsavedQueryEditor),
|
||||
};
|
||||
if (qe.latestQueryId && state.queries[qe.latestQueryId]) {
|
||||
const newResults = {
|
||||
...state.queries[qe.latestQueryId].results,
|
||||
data: [],
|
||||
query: null,
|
||||
};
|
||||
const q = { ...state.queries[qe.latestQueryId], results: newResults };
|
||||
const queries = {
|
||||
...state.queries,
|
||||
[q.id]: q,
|
||||
} as SqlLabState['queries'];
|
||||
newState = { ...state, queries };
|
||||
}
|
||||
}
|
||||
newState = addToObject(newState, 'queries', action.query!) as SqlLabState;
|
||||
|
||||
return {
|
||||
...newState,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
latestQueryId: action.query!.id,
|
||||
},
|
||||
sqlEditorId!,
|
||||
action.query!.isDataPreview,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.STOP_QUERY]() {
|
||||
return alterInObject(state, 'queries', action.query!, {
|
||||
state: QueryState.Stopped,
|
||||
results: [],
|
||||
});
|
||||
},
|
||||
[actions.CLEAR_QUERY_RESULTS]() {
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
const newResults = { ...(action.query as any).results };
|
||||
newResults.data = [];
|
||||
return alterInObject(state, 'queries', action.query!, {
|
||||
results: newResults,
|
||||
cached: true,
|
||||
});
|
||||
},
|
||||
[actions.REQUEST_QUERY_RESULTS]() {
|
||||
return alterInObject(state, 'queries', action.query!, {
|
||||
state: QueryState.Fetching,
|
||||
});
|
||||
},
|
||||
[actions.QUERY_SUCCESS]() {
|
||||
// prevent race condition where query succeeds shortly after being canceled
|
||||
// or the final result was unsuccessful
|
||||
if (
|
||||
action.query!.state === QueryState.Stopped ||
|
||||
(action.results as { status?: string })?.status !== QueryState.Success
|
||||
) {
|
||||
return state;
|
||||
}
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
const alts: any = {
|
||||
endDttm: now(),
|
||||
progress: 100,
|
||||
results: action.results,
|
||||
rows: action?.results?.query?.rows || 0,
|
||||
state: QueryState.Success,
|
||||
executedSql: action?.results?.query?.executedSql,
|
||||
limitingFactor: action?.results?.query?.limitingFactor,
|
||||
tempSchema: action?.results?.query?.tempSchema,
|
||||
tempTable: action?.results?.query?.tempTable,
|
||||
errorMessage: null,
|
||||
cached: false,
|
||||
};
|
||||
|
||||
const resultsKey = action?.results?.query?.resultsKey;
|
||||
if (resultsKey) {
|
||||
alts.resultsKey = resultsKey;
|
||||
}
|
||||
|
||||
return alterInObject(state, 'queries', action.query!, alts);
|
||||
},
|
||||
[actions.QUERY_FAILED]() {
|
||||
if (action.query!.state === QueryState.Stopped) {
|
||||
return state;
|
||||
}
|
||||
const alts = {
|
||||
state: QueryState.Failed,
|
||||
errors: action.errors,
|
||||
errorMessage: action.msg,
|
||||
endDttm: now(),
|
||||
link: action.link,
|
||||
};
|
||||
return alterInObject(state, 'queries', action.query!, alts);
|
||||
},
|
||||
[actions.SET_ACTIVE_QUERY_EDITOR]() {
|
||||
const qeIds = state.queryEditors.map(qe => qe.id);
|
||||
if (
|
||||
qeIds.indexOf(action.queryEditor!.id!) > -1 &&
|
||||
state.tabHistory[state.tabHistory.length - 1] !== action.queryEditor!.id
|
||||
) {
|
||||
const mergeUnsavedState = {
|
||||
...alterInArr(state, 'queryEditors', state.unsavedQueryEditor, {
|
||||
...state.unsavedQueryEditor,
|
||||
}),
|
||||
unsavedQueryEditor: {},
|
||||
};
|
||||
return {
|
||||
...(action.queryEditor!.id === state.unsavedQueryEditor.id
|
||||
? alterInArr(
|
||||
mergeUnsavedState,
|
||||
'queryEditors',
|
||||
action.queryEditor!,
|
||||
{
|
||||
...action.queryEditor!,
|
||||
...state.unsavedQueryEditor,
|
||||
},
|
||||
)
|
||||
: mergeUnsavedState),
|
||||
tabHistory: [...state.tabHistory, action.queryEditor!.id],
|
||||
};
|
||||
}
|
||||
return state;
|
||||
},
|
||||
[actions.LOAD_QUERY_EDITOR]() {
|
||||
const mergeUnsavedState = alterInArr(
|
||||
state,
|
||||
'queryEditors',
|
||||
state.unsavedQueryEditor,
|
||||
{
|
||||
...state.unsavedQueryEditor,
|
||||
},
|
||||
);
|
||||
return alterInArr(
|
||||
mergeUnsavedState,
|
||||
'queryEditors',
|
||||
action.queryEditor!,
|
||||
{
|
||||
...action.queryEditor!,
|
||||
},
|
||||
);
|
||||
},
|
||||
[actions.SET_TABLES]() {
|
||||
return extendArr(state, 'tables', action.tables!);
|
||||
},
|
||||
[actions.SET_ACTIVE_SOUTHPANE_TAB]() {
|
||||
return { ...state, activeSouthPaneTab: action.tabId };
|
||||
},
|
||||
[actions.MIGRATE_QUERY_EDITOR]() {
|
||||
try {
|
||||
// remove migrated query editor from localStorage
|
||||
const { sqlLab } = JSON.parse(localStorage.getItem('redux') || '{}');
|
||||
sqlLab.queryEditors = sqlLab.queryEditors.filter(
|
||||
(qe: QueryEditor) => qe.id !== action.oldQueryEditor!.id,
|
||||
);
|
||||
localStorage.setItem('redux', JSON.stringify({ sqlLab }));
|
||||
} catch (error) {
|
||||
// continue regardless of error
|
||||
}
|
||||
// replace localStorage query editor with the server backed one
|
||||
return alterInArr(
|
||||
state,
|
||||
'queryEditors',
|
||||
action.oldQueryEditor!,
|
||||
action.newQueryEditor!,
|
||||
);
|
||||
},
|
||||
[actions.MIGRATE_TABLE]() {
|
||||
try {
|
||||
// remove migrated table from localStorage
|
||||
const { sqlLab } = JSON.parse(localStorage.getItem('redux') || '{}');
|
||||
sqlLab.tables = sqlLab.tables.filter(
|
||||
(table: Table) => table.id !== action.oldTable!.id,
|
||||
);
|
||||
localStorage.setItem('redux', JSON.stringify({ sqlLab }));
|
||||
} catch (error) {
|
||||
// continue regardless of error
|
||||
}
|
||||
|
||||
// replace localStorage table with the server backed one
|
||||
return addToArr(
|
||||
removeFromArr(state, 'tables', action.oldTable!),
|
||||
'tables',
|
||||
action.newTable!,
|
||||
);
|
||||
},
|
||||
[actions.MIGRATE_QUERY]() {
|
||||
const query = {
|
||||
...state.queries[action.queryId!],
|
||||
// point query to migrated query editor
|
||||
sqlEditorId: action.queryEditorId,
|
||||
};
|
||||
const queries = { ...state.queries, [query.id]: query };
|
||||
return { ...state, queries };
|
||||
},
|
||||
[actions.QUERY_EDITOR_SETDB]() {
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
dbId: action.dbId,
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.QUERY_EDITOR_SET_CATALOG]() {
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
catalog: action.catalog,
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.QUERY_EDITOR_SET_SCHEMA]() {
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
schema: action.schema ?? undefined,
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.QUERY_EDITOR_SET_TITLE]() {
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
name: action.name,
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.QUERY_EDITOR_SET_SQL]() {
|
||||
const { unsavedQueryEditor } = state;
|
||||
if (
|
||||
unsavedQueryEditor?.id === action.queryEditor!.id &&
|
||||
unsavedQueryEditor.sql === action.sql
|
||||
) {
|
||||
return state;
|
||||
}
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
sql: action.sql ?? undefined,
|
||||
...(action.queryId && { latestQueryId: action.queryId }),
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.QUERY_EDITOR_SET_CURSOR_POSITION]() {
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
cursorPosition: action.position,
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.QUERY_EDITOR_SET_QUERY_LIMIT]() {
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
queryLimit: action.queryLimit,
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.QUERY_EDITOR_SET_TEMPLATE_PARAMS]() {
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
templateParams: action.templateParams,
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.QUERY_EDITOR_SET_SELECTED_TEXT]() {
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
selectedText: action.sql ?? undefined,
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
true,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.QUERY_EDITOR_SET_AUTORUN]() {
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
autorun: action.autorun,
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.QUERY_EDITOR_PERSIST_HEIGHT]() {
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
northPercent: action.northPercent,
|
||||
southPercent: action.southPercent,
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.QUERY_EDITOR_TOGGLE_LEFT_BAR]() {
|
||||
return {
|
||||
...state,
|
||||
...alterUnsavedQueryEditorState(
|
||||
state,
|
||||
{
|
||||
hideLeftBar: action.hideLeftBar,
|
||||
},
|
||||
action.queryEditor!.id!,
|
||||
),
|
||||
};
|
||||
},
|
||||
[actions.SET_DATABASES]() {
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
const databases: any = {};
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
(action.databases as any[])!.forEach((db: any) => {
|
||||
databases[db.id] = {
|
||||
...db,
|
||||
extra_json: JSON.parse(db.extra || ''),
|
||||
};
|
||||
});
|
||||
return { ...state, databases };
|
||||
},
|
||||
[actions.REFRESH_QUERIES]() {
|
||||
let newQueries = { ...state.queries };
|
||||
// Fetch the updates to the queries present in the store.
|
||||
let change = false;
|
||||
let { queriesLastUpdate } = state;
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
Object.entries(action.alteredQueries!).forEach(
|
||||
([id, changedQuery]: [string, any]) => {
|
||||
if (
|
||||
!state.queries.hasOwnProperty(id) ||
|
||||
(state.queries[id].state !== QueryState.Stopped &&
|
||||
state.queries[id].state !== QueryState.Failed)
|
||||
) {
|
||||
const changedOn = normalizeTimestamp(changedQuery.changed_on);
|
||||
const timestamp = Date.parse(changedOn);
|
||||
if (timestamp > queriesLastUpdate) {
|
||||
queriesLastUpdate = timestamp;
|
||||
}
|
||||
const prevState = state.queries[id]?.state;
|
||||
const currentState = changedQuery.state;
|
||||
newQueries[id] = {
|
||||
...state.queries[id],
|
||||
...changedQuery,
|
||||
...(changedQuery.startDttm && {
|
||||
startDttm: Number(changedQuery.startDttm),
|
||||
}),
|
||||
...(changedQuery.endDttm && {
|
||||
endDttm: Number(changedQuery.endDttm),
|
||||
}),
|
||||
// race condition:
|
||||
// because of async behavior, sql lab may still poll a couple of seconds
|
||||
// when it started fetching or finished rendering results
|
||||
state:
|
||||
currentState === QueryState.Success &&
|
||||
[
|
||||
QueryState.Fetching,
|
||||
QueryState.Success,
|
||||
QueryState.Running,
|
||||
].includes(prevState)
|
||||
? prevState
|
||||
: currentState,
|
||||
};
|
||||
if (
|
||||
shallowEqual(
|
||||
omit(newQueries[id], ['extra']),
|
||||
omit(state.queries[id], ['extra']),
|
||||
) &&
|
||||
isEqual(newQueries[id].extra, state.queries[id].extra)
|
||||
) {
|
||||
newQueries[id] = state.queries[id];
|
||||
} else {
|
||||
change = true;
|
||||
}
|
||||
}
|
||||
},
|
||||
);
|
||||
if (!change) {
|
||||
newQueries = state.queries;
|
||||
}
|
||||
return { ...state, queries: newQueries, queriesLastUpdate };
|
||||
},
|
||||
[actions.CLEAR_INACTIVE_QUERIES]() {
|
||||
const { queries } = state;
|
||||
const cleanedQueries = Object.fromEntries(
|
||||
Object.entries(queries)
|
||||
.filter(([, query]) => {
|
||||
if (
|
||||
['running', 'pending'].includes(query.state) &&
|
||||
Date.now() - query.startDttm > action.interval! &&
|
||||
query.progress === 0
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
})
|
||||
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
||||
.map(([id, query]: [string, any]) => [
|
||||
id,
|
||||
{
|
||||
...query,
|
||||
state:
|
||||
query.resultsKey && query.results?.status
|
||||
? query.results.status
|
||||
: query.state,
|
||||
},
|
||||
]),
|
||||
);
|
||||
return { ...state, queries: cleanedQueries };
|
||||
},
|
||||
[actions.SET_USER_OFFLINE]() {
|
||||
return { ...state, offline: action.offline };
|
||||
},
|
||||
[actions.CREATE_DATASOURCE_STARTED]() {
|
||||
return { ...state, isDatasourceLoading: true, errorMessage: null };
|
||||
},
|
||||
[actions.CREATE_DATASOURCE_SUCCESS]() {
|
||||
return {
|
||||
...state,
|
||||
isDatasourceLoading: false,
|
||||
errorMessage: null,
|
||||
datasource: action.datasource,
|
||||
};
|
||||
},
|
||||
[actions.CREATE_DATASOURCE_FAILED]() {
|
||||
return { ...state, isDatasourceLoading: false, errorMessage: action.err };
|
||||
},
|
||||
[actions.SET_EDITOR_TAB_LAST_UPDATE]() {
|
||||
return { ...state, editorTabLastUpdatedAt: action.timestamp };
|
||||
},
|
||||
[actions.SET_LAST_UPDATED_ACTIVE_TAB]() {
|
||||
return { ...state, lastUpdatedActiveTab: action.queryEditorId };
|
||||
},
|
||||
};
|
||||
if (action.type in actionHandlers) {
|
||||
return actionHandlers[action.type]();
|
||||
}
|
||||
return state;
|
||||
}
|
||||
Reference in New Issue
Block a user