You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@superset.apache.org by el...@apache.org on 2022/06/22 20:20:13 UTC
[superset] branch master updated: chore: Convert QueryAutoRefresh to TypeScript functional React component [sc-48362] (#20179)
This is an automated email from the ASF dual-hosted git repository.
elizabeth pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/superset.git
The following commit(s) were added to refs/heads/master by this push:
new 9f9aae49c9 chore: Convert QueryAutoRefresh to TypeScript functional React component [sc-48362] (#20179)
9f9aae49c9 is described below
commit 9f9aae49c912eefd2793fbeda75806700573f519
Author: Eric Briscoe <er...@gmail.com>
AuthorDate: Wed Jun 22 13:20:02 2022 -0700
chore: Convert QueryAutoRefresh to TypeScript functional React component [sc-48362] (#20179)
* git commit -m 'Convert QueryAutoRefresh to functional component [sc-48362]'
* addressing PR comments [sc-48362]
Removes unneeded props and state tracking of offline, adds finally block to simplify clearing pending request, simplifies value comparison in array by using includes in place of indexOf
* Address PR comment to use enum for QueryState [sc-48362]
Original implementation had string literals used in multiple places representing Query.state value options. This commit creates a formal TypeScript enum for QueryState so we can remove string literals and ensure better consistency
* Address PR comments for object type validation [sc-48362]
This commit resolves an issue why the TypeScript typing for queryList was marked as a Query[] but was actually a Dictionary (associative array) or Queries. A new type QueryDictionary has been added and the QueryAutoRefresh code was adjusted to use QueryDictionary instead of Query[] in appropriate places as well as unit tests. Commit also removes QueryAutoRefreshContainer by making the once component using QueryAutoRefresh (which is already redux connected) pass the needed values on [...]
* Addresses PR comment to add QueryState.SCHEDULED to runningQueryStateList [sc-48362]
In previous implementation 'scheduled' was not included int he list of Query States. Further investigation shows it should be added to as a running state.
* Fix prettier lint error [sc-48362]
* Adjust unit tests for props update hoisting callbacks out of actions wrapper object [sc-48362]
* Update with changes from master [sc-48362]
Merges in updates from master and resolves conflicts from relocation of some of the Query TypeScript definitions into core
* Removes logic setting user offline and relying on results panel error message [sc-48362]
* Fixes bad import after some TypeScript definitions were relocated to core [sc-48362]
* Fixes TypeScript errors [sc-48362]
---
.../superset-ui-core/src/query/types/Query.ts | 42 +++++--
.../src/SqlLab/components/App/index.jsx | 11 +-
.../QueryAutoRefresh/QueryAutoRefresh.test.jsx | 68 -----------
.../QueryAutoRefresh/QueryAutoRefresh.test.tsx | 133 +++++++++++++++++++++
.../SqlLab/components/QueryAutoRefresh/index.jsx | 124 -------------------
.../SqlLab/components/QueryAutoRefresh/index.tsx | 100 ++++++++++++++++
superset-frontend/src/SqlLab/fixtures.ts | 114 ++++++++++++++++--
superset-frontend/src/SqlLab/types.ts | 5 +
superset-frontend/src/SqlLab/utils/useInterval.ts | 47 ++++++++
9 files changed, 431 insertions(+), 213 deletions(-)
diff --git a/superset-frontend/packages/superset-ui-core/src/query/types/Query.ts b/superset-frontend/packages/superset-ui-core/src/query/types/Query.ts
index d622f1ed98..cb90fe6f6c 100644
--- a/superset-frontend/packages/superset-ui-core/src/query/types/Query.ts
+++ b/superset-frontend/packages/superset-ui-core/src/query/types/Query.ts
@@ -254,15 +254,35 @@ export type QueryColumn = {
is_dttm: boolean;
};
-export type QueryState =
- | 'stopped'
- | 'failed'
- | 'pending'
- | 'running'
- | 'scheduled'
- | 'success'
- | 'fetching'
- | 'timed_out';
+// Possible states of a query object for processing on the server
+export enum QueryState {
+ STARTED = 'started',
+ STOPPED = 'stopped',
+ FAILED = 'failed',
+ PENDING = 'pending',
+ RUNNING = 'running',
+ SCHEDULED = 'scheduled',
+ SUCCESS = 'success',
+ FETCHING = 'fetching',
+ TIMED_OUT = 'timed_out',
+}
+
+// Inidcates a Query's state is still processing
+export const runningQueryStateList: QueryState[] = [
+ QueryState.RUNNING,
+ QueryState.STARTED,
+ QueryState.PENDING,
+ QueryState.FETCHING,
+ QueryState.SCHEDULED,
+];
+
+// Indicates a Query's state has completed processing regardless of success / failure
+export const concludedQueryStateList: QueryState[] = [
+ QueryState.STOPPED,
+ QueryState.FAILED,
+ QueryState.SUCCESS,
+ QueryState.TIMED_OUT,
+];
export type Query = {
cached: boolean;
@@ -304,7 +324,7 @@ export type Query = {
executedSql: string;
output: string | Record<string, any>;
actions: Record<string, any>;
- type: DatasourceType.Query;
+ type: DatasourceType;
columns: QueryColumn[];
};
@@ -335,7 +355,7 @@ export const testQuery: Query = {
isDataPreview: false,
progress: 0,
resultsKey: null,
- state: 'success',
+ state: QueryState.SUCCESS,
tempSchema: null,
trackingUrl: null,
templateParams: null,
diff --git a/superset-frontend/src/SqlLab/components/App/index.jsx b/superset-frontend/src/SqlLab/components/App/index.jsx
index 8a0ade9509..3aae12bfb3 100644
--- a/superset-frontend/src/SqlLab/components/App/index.jsx
+++ b/superset-frontend/src/SqlLab/components/App/index.jsx
@@ -94,12 +94,17 @@ class App extends React.PureComponent {
}
render() {
+ const { queries, actions, queriesLastUpdate } = this.props;
if (this.state.hash && this.state.hash === '#search') {
return window.location.replace('/superset/sqllab/history/');
}
return (
<div className="App SqlLab">
- <QueryAutoRefresh />
+ <QueryAutoRefresh
+ queries={queries}
+ refreshQueries={actions?.refreshQueries}
+ queriesLastUpdate={queriesLastUpdate}
+ />
<TabbedSqlEditors />
<ToastContainer />
</div>
@@ -114,10 +119,12 @@ App.propTypes = {
};
function mapStateToProps(state) {
- const { common, localStorageUsageInKilobytes } = state;
+ const { common, localStorageUsageInKilobytes, sqlLab } = state;
return {
common,
localStorageUsageInKilobytes,
+ queries: sqlLab?.queries,
+ queriesLastUpdate: sqlLab?.queriesLastUpdate,
};
}
diff --git a/superset-frontend/src/SqlLab/components/QueryAutoRefresh/QueryAutoRefresh.test.jsx b/superset-frontend/src/SqlLab/components/QueryAutoRefresh/QueryAutoRefresh.test.jsx
deleted file mode 100644
index 06bf187e11..0000000000
--- a/superset-frontend/src/SqlLab/components/QueryAutoRefresh/QueryAutoRefresh.test.jsx
+++ /dev/null
@@ -1,68 +0,0 @@
-/**
- * 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 React from 'react';
-import { shallow } from 'enzyme';
-import sinon from 'sinon';
-import thunk from 'redux-thunk';
-import configureStore from 'redux-mock-store';
-import QueryAutoRefresh from 'src/SqlLab/components/QueryAutoRefresh';
-import { initialState, runningQuery } from 'src/SqlLab/fixtures';
-
-describe('QueryAutoRefresh', () => {
- const middlewares = [thunk];
- const mockStore = configureStore(middlewares);
- const sqlLab = {
- ...initialState.sqlLab,
- queries: {
- ryhMUZCGb: runningQuery,
- },
- };
- const state = {
- ...initialState,
- sqlLab,
- };
- const store = mockStore(state);
- const getWrapper = () =>
- shallow(<QueryAutoRefresh store={store} />)
- .dive()
- .dive();
- let wrapper;
-
- it('shouldCheckForQueries', () => {
- wrapper = getWrapper();
- expect(wrapper.instance().shouldCheckForQueries()).toBe(true);
- });
-
- it('setUserOffline', () => {
- wrapper = getWrapper();
- const spy = sinon.spy(wrapper.instance().props.actions, 'setUserOffline');
-
- // state not changed
- wrapper.setState({
- offline: false,
- });
- expect(spy.called).toBe(false);
-
- // state is changed
- wrapper.setState({
- offline: true,
- });
- expect(spy.callCount).toBe(1);
- });
-});
diff --git a/superset-frontend/src/SqlLab/components/QueryAutoRefresh/QueryAutoRefresh.test.tsx b/superset-frontend/src/SqlLab/components/QueryAutoRefresh/QueryAutoRefresh.test.tsx
new file mode 100644
index 0000000000..32bf401f22
--- /dev/null
+++ b/superset-frontend/src/SqlLab/components/QueryAutoRefresh/QueryAutoRefresh.test.tsx
@@ -0,0 +1,133 @@
+/**
+ * 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 React from 'react';
+import { render } from '@testing-library/react';
+import QueryAutoRefresh, {
+ isQueryRunning,
+ shouldCheckForQueries,
+} from 'src/SqlLab/components/QueryAutoRefresh';
+import { successfulQuery, runningQuery } from 'src/SqlLab/fixtures';
+import { QueryDictionary } from 'src/SqlLab/types';
+
+// NOTE: The uses of @ts-ignore in this file is to enable testing of bad inputs to verify the
+// function / component handles bad data elegantly
+describe('QueryAutoRefresh', () => {
+ const runningQueries: QueryDictionary = {};
+ runningQueries[runningQuery.id] = runningQuery;
+
+ const successfulQueries: QueryDictionary = {};
+ successfulQueries[successfulQuery.id] = successfulQuery;
+
+ const refreshQueries = jest.fn();
+
+ const queriesLastUpdate = Date.now();
+
+ it('isQueryRunning returns true for valid running query', () => {
+ const running = isQueryRunning(runningQuery);
+ expect(running).toBe(true);
+ });
+
+ it('isQueryRunning returns false for valid not-running query', () => {
+ const running = isQueryRunning(successfulQuery);
+ expect(running).toBe(false);
+ });
+
+ it('isQueryRunning returns false for invalid query', () => {
+ // @ts-ignore
+ let running = isQueryRunning(null);
+ expect(running).toBe(false);
+ // @ts-ignore
+ running = isQueryRunning(undefined);
+ expect(running).toBe(false);
+ // @ts-ignore
+ running = isQueryRunning('I Should Be An Object');
+ expect(running).toBe(false);
+ // @ts-ignore
+ running = isQueryRunning({ state: { badFormat: true } });
+ expect(running).toBe(false);
+ });
+
+ it('shouldCheckForQueries is true for valid running query', () => {
+ expect(shouldCheckForQueries(runningQueries)).toBe(true);
+ });
+
+ it('shouldCheckForQueries is false for valid completed query', () => {
+ expect(shouldCheckForQueries(successfulQueries)).toBe(false);
+ });
+
+ it('shouldCheckForQueries is false for invalid inputs', () => {
+ // @ts-ignore
+ expect(shouldCheckForQueries(null)).toBe(false);
+ // @ts-ignore
+ expect(shouldCheckForQueries(undefined)).toBe(false);
+ expect(
+ // @ts-ignore
+ shouldCheckForQueries({
+ // @ts-ignore
+ '1234': null,
+ // @ts-ignore
+ '23425': 'hello world',
+ // @ts-ignore
+ '345': [],
+ // @ts-ignore
+ '57346': undefined,
+ }),
+ ).toBe(false);
+ });
+
+ it('Attempts to refresh when given pending query', () => {
+ render(
+ <QueryAutoRefresh
+ queries={runningQueries}
+ refreshQueries={refreshQueries}
+ queriesLastUpdate={queriesLastUpdate}
+ />,
+ );
+ setTimeout(() => {
+ expect(refreshQueries).toHaveBeenCalled();
+ }, 1000);
+ });
+
+ it('Does not fail and attempts to refresh when given pending query and invlaid query', () => {
+ render(
+ <QueryAutoRefresh
+ // @ts-ignore
+ queries={{ ...runningQueries, g324t: null }}
+ refreshQueries={refreshQueries}
+ queriesLastUpdate={queriesLastUpdate}
+ />,
+ );
+ setTimeout(() => {
+ expect(refreshQueries).toHaveBeenCalled();
+ }, 1000);
+ });
+
+ it('Does NOT Attempt to refresh when given only completed queries', () => {
+ render(
+ <QueryAutoRefresh
+ queries={successfulQueries}
+ refreshQueries={refreshQueries}
+ queriesLastUpdate={queriesLastUpdate}
+ />,
+ );
+ setTimeout(() => {
+ expect(refreshQueries).not.toHaveBeenCalled();
+ }, 1000);
+ });
+});
diff --git a/superset-frontend/src/SqlLab/components/QueryAutoRefresh/index.jsx b/superset-frontend/src/SqlLab/components/QueryAutoRefresh/index.jsx
deleted file mode 100644
index b54936b691..0000000000
--- a/superset-frontend/src/SqlLab/components/QueryAutoRefresh/index.jsx
+++ /dev/null
@@ -1,124 +0,0 @@
-/**
- * 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 React from 'react';
-import PropTypes from 'prop-types';
-import { bindActionCreators } from 'redux';
-import { connect } from 'react-redux';
-import { SupersetClient } from '@superset-ui/core';
-import * as Actions from 'src/SqlLab/actions/sqlLab';
-
-const QUERY_UPDATE_FREQ = 2000;
-const QUERY_UPDATE_BUFFER_MS = 5000;
-const MAX_QUERY_AGE_TO_POLL = 21600000;
-const QUERY_TIMEOUT_LIMIT = 10000;
-
-class QueryAutoRefresh extends React.PureComponent {
- constructor(props) {
- super(props);
- this.state = {
- offline: props.offline,
- };
- }
-
- UNSAFE_componentWillMount() {
- this.startTimer();
- }
-
- componentDidUpdate(prevProps) {
- if (prevProps.offline !== this.state.offline) {
- this.props.actions.setUserOffline(this.state.offline);
- }
- }
-
- componentWillUnmount() {
- this.stopTimer();
- }
-
- shouldCheckForQueries() {
- // if there are started or running queries, this method should return true
- const { queries } = this.props;
- const now = new Date().getTime();
- const isQueryRunning = q =>
- ['running', 'started', 'pending', 'fetching'].indexOf(q.state) >= 0;
-
- return Object.values(queries).some(
- q => isQueryRunning(q) && now - q.startDttm < MAX_QUERY_AGE_TO_POLL,
- );
- }
-
- startTimer() {
- if (!this.timer) {
- this.timer = setInterval(this.stopwatch.bind(this), QUERY_UPDATE_FREQ);
- }
- }
-
- stopTimer() {
- clearInterval(this.timer);
- this.timer = null;
- }
-
- stopwatch() {
- // only poll /superset/queries/ if there are started or running queries
- if (this.shouldCheckForQueries()) {
- SupersetClient.get({
- endpoint: `/superset/queries/${
- this.props.queriesLastUpdate - QUERY_UPDATE_BUFFER_MS
- }`,
- timeout: QUERY_TIMEOUT_LIMIT,
- })
- .then(({ json }) => {
- if (Object.keys(json).length > 0) {
- this.props.actions.refreshQueries(json);
- }
- this.setState({ offline: false });
- })
- .catch(() => {
- this.setState({ offline: true });
- });
- } else {
- this.setState({ offline: false });
- }
- }
-
- render() {
- return null;
- }
-}
-QueryAutoRefresh.propTypes = {
- offline: PropTypes.bool.isRequired,
- queries: PropTypes.object.isRequired,
- actions: PropTypes.object.isRequired,
- queriesLastUpdate: PropTypes.number.isRequired,
-};
-
-function mapStateToProps({ sqlLab }) {
- return {
- offline: sqlLab.offline,
- queries: sqlLab.queries,
- queriesLastUpdate: sqlLab.queriesLastUpdate,
- };
-}
-
-function mapDispatchToProps(dispatch) {
- return {
- actions: bindActionCreators(Actions, dispatch),
- };
-}
-
-export default connect(mapStateToProps, mapDispatchToProps)(QueryAutoRefresh);
diff --git a/superset-frontend/src/SqlLab/components/QueryAutoRefresh/index.tsx b/superset-frontend/src/SqlLab/components/QueryAutoRefresh/index.tsx
new file mode 100644
index 0000000000..eb3e6f4c38
--- /dev/null
+++ b/superset-frontend/src/SqlLab/components/QueryAutoRefresh/index.tsx
@@ -0,0 +1,100 @@
+/**
+ * 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 { useState } from 'react';
+import { isObject } from 'lodash';
+import {
+ SupersetClient,
+ Query,
+ runningQueryStateList,
+} from '@superset-ui/core';
+import { QueryDictionary } from 'src/SqlLab/types';
+import useInterval from 'src/SqlLab/utils/useInterval';
+
+const QUERY_UPDATE_FREQ = 2000;
+const QUERY_UPDATE_BUFFER_MS = 5000;
+const MAX_QUERY_AGE_TO_POLL = 21600000;
+const QUERY_TIMEOUT_LIMIT = 10000;
+
+interface RefreshQueriesFunc {
+ (alteredQueries: any): any;
+}
+
+export interface QueryAutoRefreshProps {
+ queries: QueryDictionary;
+ refreshQueries: RefreshQueriesFunc;
+ queriesLastUpdate: number;
+}
+
+// returns true if the Query.state matches one of the specifc values indicating the query is still processing on server
+export const isQueryRunning = (q: Query): boolean =>
+ runningQueryStateList.includes(q?.state);
+
+// returns true if at least one query is running and within the max age to poll timeframe
+export const shouldCheckForQueries = (queryList: QueryDictionary): boolean => {
+ let shouldCheck = false;
+ const now = Date.now();
+ if (isObject(queryList)) {
+ shouldCheck = Object.values(queryList).some(
+ q => isQueryRunning(q) && now - q?.startDttm < MAX_QUERY_AGE_TO_POLL,
+ );
+ }
+ return shouldCheck;
+};
+
+function QueryAutoRefresh({
+ queries,
+ refreshQueries,
+ queriesLastUpdate,
+}: QueryAutoRefreshProps) {
+ // We do not want to spam requests in the case of slow connections and potentially recieve responses out of order
+ // pendingRequest check ensures we only have one active http call to check for query statuses
+ const [pendingRequest, setPendingRequest] = useState(false);
+
+ const checkForRefresh = () => {
+ if (!pendingRequest && shouldCheckForQueries(queries)) {
+ setPendingRequest(true);
+ SupersetClient.get({
+ endpoint: `/superset/queries/${
+ queriesLastUpdate - QUERY_UPDATE_BUFFER_MS
+ }`,
+ timeout: QUERY_TIMEOUT_LIMIT,
+ })
+ .then(({ json }) => {
+ if (json) {
+ refreshQueries?.(json);
+ }
+ })
+ .catch(() => {})
+ .finally(() => {
+ setPendingRequest(false);
+ });
+ }
+ };
+
+ // Solves issue where direct usage of setInterval in function components
+ // uses stale props / state from closure
+ // See comments in the useInterval.ts file for more information
+ useInterval(() => {
+ checkForRefresh();
+ }, QUERY_UPDATE_FREQ);
+
+ return null;
+}
+
+export default QueryAutoRefresh;
diff --git a/superset-frontend/src/SqlLab/fixtures.ts b/superset-frontend/src/SqlLab/fixtures.ts
index 5b12ee2921..58b21edd9c 100644
--- a/superset-frontend/src/SqlLab/fixtures.ts
+++ b/superset-frontend/src/SqlLab/fixtures.ts
@@ -19,6 +19,7 @@
import sinon from 'sinon';
import * as actions from 'src/SqlLab/actions/sqlLab';
import { ColumnKeyTypeType } from 'src/SqlLab/components/ColumnElement';
+import { DatasourceType, QueryResponse, QueryState } from '@superset-ui/core';
export const mockedActions = sinon.stub({ ...actions });
@@ -189,6 +190,7 @@ export const defaultQueryEditor = {
},
],
};
+
export const queries = [
{
dbId: 1,
@@ -201,7 +203,7 @@ export const queries = [
id: 'BkA1CLrJg',
progress: 100,
startDttm: 1476910566092.96,
- state: 'success',
+ state: QueryState.SUCCESS,
changedOn: 1476910566000,
tempTable: null,
userId: 1,
@@ -260,7 +262,7 @@ export const queries = [
id: 'S1zeAISkx',
progress: 100,
startDttm: 1476910570802.2,
- state: 'success',
+ state: QueryState.SUCCESS,
changedOn: 1476910572000,
tempTable: null,
userId: 1,
@@ -294,7 +296,7 @@ export const queryWithNoQueryLimit = {
id: 'BkA1CLrJg',
progress: 100,
startDttm: 1476910566092.96,
- state: 'success',
+ state: QueryState.SUCCESS,
changedOn: 1476910566000,
tempTable: null,
userId: 1,
@@ -344,6 +346,7 @@ export const queryWithNoQueryLimit = {
},
},
};
+
export const queryWithBadColumns = {
...queries[0],
results: {
@@ -407,6 +410,7 @@ export const queryWithBadColumns = {
],
},
};
+
export const databases = {
result: [
{
@@ -429,6 +433,7 @@ export const databases = {
},
],
};
+
export const tables = {
options: [
{
@@ -464,7 +469,7 @@ export const stoppedQuery = {
sql: 'SELECT ...',
sqlEditorId: 'rJaf5u9WZ',
startDttm: 1497400851936,
- state: 'stopped',
+ state: QueryState.STOPPED,
tab: 'Untitled Query 2',
tempTable: '',
};
@@ -482,7 +487,7 @@ export const failedQueryWithErrorMessage = {
sql: 'SELECT ...',
sqlEditorId: 'rJaf5u9WZ',
startDttm: 1497400851936,
- state: 'failed',
+ state: QueryState.FAILED,
tab: 'Untitled Query 2',
tempTable: '',
};
@@ -507,20 +512,113 @@ export const failedQueryWithErrors = {
sql: 'SELECT ...',
sqlEditorId: 'rJaf5u9WZ',
startDttm: 1497400851936,
- state: 'failed',
+ state: QueryState.FAILED,
tab: 'Untitled Query 2',
tempTable: '',
};
-export const runningQuery = {
+const baseQuery: QueryResponse = {
+ queryId: 567,
+ dbId: 1,
+ sql: 'SELECT * FROM superset.slices',
+ sqlEditorId: 'SJ8YO72R',
+ tab: 'Demo',
+ ctas: false,
+ cached: false,
+ id: 'BkA1CLrJg',
+ progress: 100,
+ startDttm: 1476910566092.96,
+ state: QueryState.SUCCESS,
+ tempSchema: null,
+ tempTable: 'temp',
+ userId: 1,
+ executedSql: 'SELECT * FROM superset.slices',
+ rows: 42,
+ started: 'started',
+ queryLimit: 100,
+ endDttm: 1476910566798,
+ schema: 'test_schema',
+ errorMessage: null,
+ db: { key: 'main' },
+ user: { key: 'admin' },
+ isDataPreview: false,
+ resultsKey: null,
+ trackingUrl: null,
+ templateParams: null,
+ limitingFactor: 'capacity',
+ duration: '2334645675467',
+ time: { key: 'value' },
+ querylink: { key: 'value' },
+ output: { key: 'value' },
+ actions: { key: 'value' },
+ extra: {
+ progress: null,
+ },
+ columns: [],
+ type: DatasourceType.Query,
+ results: {
+ displayLimitReached: false,
+ query: { limit: 6 },
+ columns: [
+ {
+ is_dttm: true,
+ name: 'ds',
+ type: 'STRING',
+ },
+ {
+ is_dttm: false,
+ name: 'gender',
+ type: 'STRING',
+ },
+ ],
+ selected_columns: [
+ {
+ is_dttm: true,
+ name: 'ds',
+ type: 'STRING',
+ },
+ {
+ is_dttm: false,
+ name: 'gender',
+ type: 'STRING',
+ },
+ ],
+ expanded_columns: [
+ {
+ is_dttm: true,
+ name: 'ds',
+ type: 'STRING',
+ },
+ ],
+ data: [
+ { col1: '0', col2: '1' },
+ { col1: '2', col2: '3' },
+ ],
+ },
+};
+
+export const runningQuery: QueryResponse = {
+ ...baseQuery,
dbId: 1,
cached: false,
ctas: false,
id: 'ryhMUZCGb',
progress: 90,
- state: 'running',
+ state: QueryState.RUNNING,
+ startDttm: Date.now() - 500,
+};
+
+export const successfulQuery: QueryResponse = {
+ ...baseQuery,
+ dbId: 1,
+ cached: false,
+ ctas: false,
+ id: 'ryhMUZCGb',
+ progress: 100,
+ state: QueryState.SUCCESS,
startDttm: Date.now() - 500,
};
+
export const cachedQuery = { ...queries[0], cached: true };
export const user = {
diff --git a/superset-frontend/src/SqlLab/types.ts b/superset-frontend/src/SqlLab/types.ts
index bc04277054..9a6198b864 100644
--- a/superset-frontend/src/SqlLab/types.ts
+++ b/superset-frontend/src/SqlLab/types.ts
@@ -25,6 +25,11 @@ import { ExploreRootState } from 'src/explore/types';
export type ExploreDatasource = Dataset | QueryResponse;
+// Object as Dictionary (associative array) with Query id as the key and type Query as the value
+export type QueryDictionary = {
+ [id: string]: QueryResponse;
+};
+
export interface QueryEditor {
dbId?: number;
title: string;
diff --git a/superset-frontend/src/SqlLab/utils/useInterval.ts b/superset-frontend/src/SqlLab/utils/useInterval.ts
new file mode 100644
index 0000000000..731e6c85cf
--- /dev/null
+++ b/superset-frontend/src/SqlLab/utils/useInterval.ts
@@ -0,0 +1,47 @@
+/**
+ * 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 { useEffect, useRef } from 'react';
+
+/*
+ * Functional components and setTimeout with useState do not play well
+ * and the setTimeout callback typically has stale state from a closure
+ * The useInterval function solves this issue.
+ * more info: https://overreacted.io/making-setinterval-declarative-with-react-hooks/
+ */
+function useInterval(callback: Function, delay: number | null): void {
+ const savedCallback = useRef<Function>(callback);
+ // Remember the latest function.
+ useEffect(() => {
+ savedCallback.current = callback;
+ }, [callback]);
+
+ // Set up the interval.
+ useEffect(() => {
+ function tick() {
+ savedCallback?.current?.();
+ }
+ if (delay !== null) {
+ const id = setInterval(tick, delay);
+ return () => clearInterval(id);
+ }
+ return () => {};
+ }, [delay]);
+}
+
+export default useInterval;