public boolean processOneFileSplit(FileSplit split, long startTime,
      Ref<Integer> stripeIxRef, StripeData slice) throws IOException, InterruptedException {
    LlapIoImpl.LOG.info("Processing one split {" + split.getPath() + ", "
        + split.getStart() + ", " + split.getLength() + "}");
    if (LlapIoImpl.CACHE_LOGGER.isTraceEnabled()) {
      LlapIoImpl.CACHE_LOGGER.trace("Cache data for the split is " + slice);
    }
    boolean[] splitIncludes = Arrays.copyOf(writerIncludes, writerIncludes.length);
    boolean hasAllData = slice != null
        && determineSplitIncludes(slice, splitIncludes, writerIncludes);

    // We have 3 cases here:
    // 1) All the data is in the cache. Always a single slice, no disk read, no cache puts.
    // 2) Some data is in the cache. Always a single slice, disk read and a single cache put.
    // 3) No data is in the cache. Multiple slices, disk read and multiple cache puts.
    if (hasAllData) {
      // Everything comes from cache.
      CacheWriter.CacheStripeData csd = null;
      boolean result = processOneSlice(csd, splitIncludes, stripeIxRef.value, slice, startTime);
      ++stripeIxRef.value;
      return result;
    }

    boolean result = false;
    // This initializes currentFileRead.
    startReadSplitFromFile(split, splitIncludes, slice);
    try {
      if (slice != null) {
        // If we had a cache range already, we expect a single matching disk slice.
        // Given that there's cached data we expect there to be some disk data.
        Vectors vectors = currentFileRead.readNextSlice();
        assert vectors != null;
        if (!vectors.isSupported()) {
          // Not in VRB mode - the new cache data is ready, we should use it.
          CacheWriter cacheWriter = currentFileRead.getCacheWriter();
          assert cacheWriter.stripes.size() == 1;
          result = processOneSlice(
              cacheWriter.stripes.get(0), splitIncludes, stripeIxRef.value, slice, startTime);
        } else {
          // VRB mode - process the VRBs with cache data; the new cache data is coming later.
          result = processOneSlice(
              vectors, splitIncludes, stripeIxRef.value, slice, startTime);
        }
        assert null == currentFileRead.readNextSlice();
        ++stripeIxRef.value;
      } else {
        // All the data comes from disk. The reader may have split it into multiple slices.
        // It is also possible there's no data in the file.
        Vectors vectors = currentFileRead.readNextSlice();
        if (vectors == null) return true;
        result = true;
        if (!vectors.isSupported()) {
          // Not in VRB mode - the new cache data is (partially) ready, we should use it.
          while (currentFileRead.readNextSlice() != null); // Force the rest of the data thru.
          CacheWriter cacheWriter = currentFileRead.getCacheWriter();
          for (CacheWriter.CacheStripeData csd : cacheWriter.stripes) {
            if (!processOneSlice(csd, splitIncludes, stripeIxRef.value, null, startTime)) {
              result = false;
              break;
            }
            ++stripeIxRef.value;
          }
        } else {
          // VRB mode - process the VRBs with cache data; the new cache data is coming later.
          do {
            assert vectors.isSupported();
            if (!processOneSlice(vectors, splitIncludes, stripeIxRef.value, null, startTime)) {
              result = false;
              break;
            }
            ++stripeIxRef.value;
          } while ((vectors = currentFileRead.readNextSlice()) != null);
        }
      }
    } finally {
      cleanUpCurrentRead();
    }
    return result;
  }
For !doesSourceHaveIncludes case, stores global column IDs to verify writer columns.
For doesSourceHaveIncludes case, stores source column IDs used to map things.
llap-server/src/java/org/apache/hadoop/hive/llap/io/encoded/SerDeEncodedDataReader.java