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

      // Add to queries, which will cause a new row to be rendered
      const nextQueries = [...queries.slice(0, index + 1), { ...query }, ...queries.slice(index + 1)];

      // Ongoing transactions need to update their row indices
      const nextQueryTransactions = queryTransactions.map(qt => {
        if (qt.rowIndex > index) {
          return {
            ...qt,
            rowIndex: qt.rowIndex + 1,
          };
        }
        return qt;
      });

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

    mapper: (state, action): ExploreItemState => {
      const { queries } = state;
      const { modification, index, modifier } = action.payload;
      let nextQueries: DataQuery[];
      if (index === undefined) {
        // Modify all queries
        nextQueries = queries.map((query, i) => {
          const nextQuery = modifier({ ...query }, modification);
          return generateNewKeyAndAddRefIdIfMissing(nextQuery, queries, i);
        });
      } else {
        // Modify query only at index
        nextQueries = queries.map((query, i) => {
          if (i === index) {
            const nextQuery = modifier({ ...query }, modification);
            return generateNewKeyAndAddRefIdIfMissing(nextQuery, queries, i);
          }

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

 mapper: (state): ExploreItemState => {
   const queries = ensureQueries();
   return {
     ...state,
     queries: queries.slice(),
     showingStartPage: Boolean(state.StartPage),
     queryKeys: getQueryKeys(queries, state.datasourceInstance),
   };
 },

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

      // Add to queries, which will cause a new row to be rendered
      const nextQueries = [...queries.slice(0, index + 1), { ...query }, ...queries.slice(index + 1)];

      return {
        ...state,
        queries: nextQueries,
        logsHighlighterExpressions: undefined,
        queryKeys: getQueryKeys(nextQueries, state.datasourceInstance),
      };
    },

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

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

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

    mapper: (state, action): ExploreItemState => {
      const { datasourceInstance } = action.payload;
      // Capabilities
      const supportsGraph = datasourceInstance.meta.metrics;
      const supportsLogs = datasourceInstance.meta.logs;
      const supportsTable = datasourceInstance.meta.tables;

      // Custom components
      const StartPage = datasourceInstance.components.ExploreStartPage;

      return {
        ...state,
        datasourceInstance,
        supportsGraph,
        supportsLogs,
        supportsTable,
        StartPage,
        showingStartPage: Boolean(StartPage),
        queryKeys: getQueryKeys(state.queries, datasourceInstance),
      };
    },

 mapper: (state, action): ExploreItemState => {
   const { queries, queryTransactions } = state;
   const { modification, index, modifier } = action.payload;
   let nextQueries: DataQuery[];
   let nextQueryTransactions: QueryTransaction[];
   if (index === undefined) {
     // Modify all queries
     nextQueries = queries.map((query, i) => ({
       ...modifier({ ...query }, modification),
       ...generateEmptyQuery(state.queries),
     }));
     // Discard all ongoing transactions
     nextQueryTransactions = [];
   } else {
     // Modify query only at index
     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;
     });
     nextQueryTransactions = queryTransactions
       // Consume the hint corresponding to the action
       .map(qt => {
         if (qt.hints != null && qt.rowIndex === index) {
           qt.hints = qt.hints.filter(hint => hint.fix.action !== modification);
         }
         return qt;
       })
       // Preserve previous row query transaction to keep results visible if next query is incomplete
       .filter(qt => modification.preventSubmit || qt.rowIndex !== index);
   }
   return {
     ...state,
     queries: nextQueries,
     queryKeys: getQueryKeys(nextQueries, state.datasourceInstance),
     queryTransactions: nextQueryTransactions,
   };
 },