return (dispatch, getState) => {
    const {
      datasourceInstance,
      queries,
      showingGraph,
      showingTable,
      datasourceError,
      containerWidth,
      mode,
      range,
    } = getState().explore[exploreId];

    if (datasourceError) {
      // let's not run any queries if data source is in a faulty state
      return;
    }

    if (!hasNonEmptyQuery(queries)) {
      dispatch(clearQueriesAction({ exploreId }));
      dispatch(stateSave(replaceUrl)); // Remember to save to state and update location
      return;
    }

    // Some datasource's query builders allow per-query interval limits,
    // but we're using the datasource interval limit for now
    const interval = datasourceInstance.interval;

    const timeZone = getTimeZone(getState().user);
    const updatedRange = getTimeRange(timeZone, range.raw);

    dispatch(runQueriesAction({ exploreId, range: updatedRange }));
    // Keep table queries first since they need to return quickly
    if ((ignoreUIState || showingTable) && mode === ExploreMode.Metrics) {
      dispatch(
        runQueriesForType(exploreId, 'Table', {
          interval,
          format: 'table',
          instant: true,
          valueWithRefId: true,
        })
      );
    }
    if ((ignoreUIState || showingGraph) && mode === ExploreMode.Metrics) {
      dispatch(
        runQueriesForType(exploreId, 'Graph', {
          interval,
          format: 'time_series',
          instant: false,
          maxDataPoints: containerWidth,
        })
      );
    }
    if (mode === ExploreMode.Logs) {
      dispatch(runQueriesForType(exploreId, 'Logs', { interval, format: 'logs' }));
    }

    dispatch(stateSave(replaceUrl));
  };

 return async (dispatch, getState) => {
   const timeZone = getTimeZone(getState().user);
   const range = getTimeRange(timeZone, rawRange);
   dispatch(loadExploreDatasourcesAndSetDatasource(exploreId, datasourceName));
   dispatch(
     initializeExploreAction({
       exploreId,
       containerWidth,
       eventBridge,
       queries,
       range,
       ui,
     })
   );
 };

  return (dispatch, getState) => {
    const itemState = getState().explore[exploreId];
    if (!itemState.initialized) {
      return;
    }

    const { urlState, update, containerWidth, eventBridge } = itemState;
    const { datasource, queries, range: urlRange, ui } = urlState;
    const refreshQueries = queries.map(q => ({ ...q, ...generateEmptyQuery(itemState.queries) }));
    const timeZone = getTimeZone(getState().user);
    const range = getTimeRangeFromUrl(urlRange, timeZone);

    // need to refresh datasource
    if (update.datasource) {
      const initialQueries = ensureQueries(queries);
      dispatch(initializeExplore(exploreId, datasource, initialQueries, range, containerWidth, eventBridge, ui));
      return;
    }

    if (update.range) {
      dispatch(changeTimeAction({ exploreId, range }));
    }

    // need to refresh ui state
    if (update.ui) {
      dispatch(updateUIStateAction({ ...ui, exploreId }));
    }

    // need to refresh queries
    if (update.queries) {
      dispatch(setQueriesAction({ exploreId, queries: refreshQueries }));
    }

    // always run queries when refresh is needed
    if (update.queries || update.ui || update.range) {
      dispatch(runQueries(exploreId));
    }
  };