void fastPath()

in velox/dwio/dwrf/common/DirectDecoder.h [98:216]


  void fastPath(const uint64_t* nulls, Visitor& visitor) {
    using T = typename Visitor::DataType;
    constexpr bool hasFilter =
        !std::is_same<typename Visitor::FilterType, common::AlwaysTrue>::value;
    constexpr bool filterOnly =
        std::is_same<typename Visitor::Extract, DropValues>::value;
    constexpr bool hasHook =
        !std::is_same<typename Visitor::HookType, NoHook>::value;

    int32_t numValues = 0;
    auto rows = visitor.rows();
    auto numRows = visitor.numRows();
    auto numNonNull = numRows;
    auto rowsAsRange = folly::Range<const int32_t*>(rows, numRows);
    auto data = visitor.rawValues(numRows);
    if (hasNulls) {
      int32_t tailSkip = 0;
      raw_vector<int32_t>* innerVector = nullptr;
      auto outerVector = &visitor.outerNonNullRows();
      if (Visitor::dense) {
        nonNullRowsFromDense(nulls, numRows, *outerVector);
        numNonNull = outerVector->size();
        if (!numNonNull) {
          visitor.setAllNull(hasFilter ? 0 : numRows);
          return;
        }
      } else {
        innerVector = &visitor.innerNonNullRows();
        auto anyNulls = nonNullRowsFromSparse < hasFilter,
             !hasFilter &&
            !hasHook >
                (nulls,
                 rowsAsRange,
                 *innerVector,
                 *outerVector,
                 (hasFilter || hasHook) ? nullptr : visitor.rawNulls(numRows),
                 tailSkip);
        if (anyNulls) {
          visitor.setHasNulls();
        }
        if (innerVector->empty()) {
          skip<false>(tailSkip, 0, nullptr);
          visitor.setAllNull(hasFilter ? 0 : numRows);
          return;
        }
      }
      if (super::useVInts) {
        if (Visitor::dense) {
          super::bulkRead(numNonNull, data);
        } else {
          super::bulkReadRows(*innerVector, data);
        }
        skip<false>(tailSkip, 0, nullptr);
        auto dataRows = innerVector
            ? folly::Range<const int*>(innerVector->data(), innerVector->size())
            : folly::Range<const int32_t*>(rows, outerVector->size());
        processFixedWidthRun<T, filterOnly, true, Visitor::dense>(
            dataRows,
            0,
            dataRows.size(),
            outerVector->data(),
            data,
            hasFilter ? visitor.outputRows(numRows) : nullptr,
            numValues,
            visitor.filter(),
            visitor.hook());
      } else {
        fixedWidthScan<T, filterOnly, true>(
            innerVector
                ? folly::Range<const int32_t*>(*innerVector)
                : folly::Range<const int32_t*>(rows, outerVector->size()),
            outerVector->data(),
            visitor.rawValues(numRows),
            hasFilter ? visitor.outputRows(numRows) : nullptr,
            numValues,
            *super::inputStream,
            super::bufferStart,
            super::bufferEnd,
            visitor.filter(),
            visitor.hook());
        skip<false>(tailSkip, 0, nullptr);
      }
    } else {
      if (super::useVInts) {
        if (Visitor::dense) {
          super::bulkRead(numRows, visitor.rawValues(numRows));
        } else {
          super::bulkReadRows(
              folly::Range<const int32_t*>(rows, numRows),
              visitor.rawValues(numRows));
        }
        processFixedWidthRun<T, filterOnly, false, Visitor::dense>(
            rowsAsRange,
            0,
            rowsAsRange.size(),
            hasHook ? velox::iota(numRows, visitor.innerNonNullRows())
                    : nullptr,
            visitor.rawValues(numRows),
            hasFilter ? visitor.outputRows(numRows) : nullptr,
            numValues,
            visitor.filter(),
            visitor.hook());
      } else {
        fixedWidthScan<T, filterOnly, false>(
            rowsAsRange,
            hasHook ? velox::iota(numRows, visitor.innerNonNullRows())
                    : nullptr,
            visitor.rawValues(numRows),
            visitor.outputRows(numRows),
            numValues,
            *super::inputStream,
            super::bufferStart,
            super::bufferEnd,
            visitor.filter(),
            visitor.hook());
      }
    }
    visitor.setNumValues(hasFilter ? numValues : numRows);
  }