nextQueries = queries.map((query, i) => {
   // Synchronize all queries with local query cache to ensure consistency
   // TODO still needed?
   return i === index
     ? { ...modifier({ ...query }, modification), ...generateEmptyQuery(state.queries) }
     : query;
 });

  return (dispatch, getState) => {
    // Null query means reset
    if (query === null) {
      query = { ...generateEmptyQuery(getState().explore[exploreId].queries) };
    }

    dispatch(changeQueryAction({ exploreId, query, index, override }));
    if (override) {
      dispatch(runQueries(exploreId));
    }
  };

  return dispatch => {
    // Null query means reset
    if (query === null) {
      query = { ...generateEmptyQuery(index) };
    }

    dispatch(changeQueryAction({ exploreId, query, index, override }));
    if (override) {
      dispatch(runQueries(exploreId));
    }
  };

    mapper: (state, action): ExploreItemState => {
      const { queries, queryTransactions } = state;
      const { query, index } = action.payload;

      // Override path: queries are completely reset
      const nextQuery: DataQuery = { ...query, ...generateEmptyQuery(index) };
      const nextQueries = [...queries];
      nextQueries[index] = nextQuery;

      // Discard ongoing transaction related to row query
      const nextQueryTransactions = queryTransactions.filter(qt => qt.rowIndex !== index);

      return {
        ...state,
        queries: nextQueries,
        queryTransactions: nextQueryTransactions,
        queryKeys: getQueryKeys(nextQueries, state.datasourceInstance),
      };
    },

 const refreshQueries = queries.map(q => ({ ...q, ...generateEmptyQuery(itemState.queries) }));

 nextQueries = queries.map((query, i) => ({
   ...modifier({ ...query }, modification),
   ...generateEmptyQuery(i),
 }));

export function addQueryRow(exploreId: ExploreId, index: number): ActionOf<AddQueryRowPayload> {
  const query = generateEmptyQuery(index + 1);
  return addQueryRowAction({ exploreId, index, query });
}