void toDuckDbFilter()

in velox/dwio/parquet/reader/ParquetReader.cpp [53:158]
102 lines of code
28 McCabe index (conditional complexity)

void toDuckDbFilter(
    uint64_t colIdx,
    ::duckdb::LogicalType type,
    common::Filter* filter,
    ::duckdb::TableFilterSet& filters) {
  switch (filter->kind()) {
    case common::FilterKind::kBigintRange: {
      auto rangeFilter = static_cast<common::BigintRange*>(filter);
      if (rangeFilter->isSingleValue()) {
        filters.PushFilter(
            colIdx, constantEqualFilter(makeValue(type, rangeFilter->lower())));
      } else {
        if (rangeFilter->lower() != std::numeric_limits<int64_t>::min()) {
          filters.PushFilter(
              colIdx,
              constantFilter(
                  ::duckdb::ExpressionType::COMPARE_GREATERTHANOREQUALTO,
                  makeValue(type, rangeFilter->lower())));
        }
        if (rangeFilter->upper() != std::numeric_limits<int64_t>::max()) {
          filters.PushFilter(
              colIdx,
              constantFilter(
                  ::duckdb::ExpressionType::COMPARE_LESSTHANOREQUALTO,
                  makeValue(type, rangeFilter->upper())));
        }
      }
      break;
    }

    case common::FilterKind::kDoubleRange: {
      auto rangeFilter = static_cast<common::DoubleRange*>(filter);
      if (!rangeFilter->lowerUnbounded()) {
        auto expressionType = rangeFilter->lowerExclusive()
            ? ::duckdb::ExpressionType::COMPARE_GREATERTHAN
            : ::duckdb::ExpressionType::COMPARE_GREATERTHANOREQUALTO;
        filters.PushFilter(
            colIdx,
            constantFilter(
                expressionType, ::duckdb::Value(rangeFilter->lower())));
      }
      if (!rangeFilter->upperUnbounded()) {
        auto expressionType = rangeFilter->upperExclusive()
            ? ::duckdb::ExpressionType::COMPARE_LESSTHAN
            : ::duckdb::ExpressionType::COMPARE_LESSTHANOREQUALTO;
        filters.PushFilter(
            colIdx,
            constantFilter(
                expressionType, ::duckdb::Value(rangeFilter->upper())));
      }
      break;
    }

    case common::FilterKind::kBytesValues: {
      auto valuesFilter = static_cast<common::BytesValues*>(filter);
      const auto& values = valuesFilter->values();
      if (values.size() == 1) {
        filters.PushFilter(colIdx, constantEqualFilter(*values.begin()));
      } else {
        auto duckFilter = std::make_unique<::duckdb::ConjunctionOrFilter>();
        for (const auto& value : values) {
          duckFilter->child_filters.push_back(constantEqualFilter(value));
        }
        filters.PushFilter(colIdx, std::move(duckFilter));
      }
      break;
    }

    case common::FilterKind::kBytesRange: {
      auto rangeFilter = static_cast<common::BytesRange*>(filter);
      if (!rangeFilter->lowerUnbounded()) {
        auto expressionType = rangeFilter->lowerExclusive()
            ? ::duckdb::ExpressionType::COMPARE_GREATERTHAN
            : ::duckdb::ExpressionType::COMPARE_GREATERTHANOREQUALTO;
        filters.PushFilter(
            colIdx,
            constantFilter(
                expressionType, ::duckdb::Value(rangeFilter->lower())));
      }
      if (!rangeFilter->upperUnbounded()) {
        auto expressionType = rangeFilter->upperExclusive()
            ? ::duckdb::ExpressionType::COMPARE_LESSTHAN
            : ::duckdb::ExpressionType::COMPARE_LESSTHANOREQUALTO;
        filters.PushFilter(
            colIdx,
            constantFilter(
                expressionType, ::duckdb::Value(rangeFilter->upper())));
      }
      break;
    }

    case common::FilterKind::kAlwaysFalse:
    case common::FilterKind::kAlwaysTrue:
    case common::FilterKind::kIsNull:
    case common::FilterKind::kIsNotNull:
    case common::FilterKind::kBoolValue:
    case common::FilterKind::kBigintValuesUsingHashTable:
    case common::FilterKind::kBigintValuesUsingBitmask:
    case common::FilterKind::kFloatRange:
    case common::FilterKind::kBigintMultiRange:
    case common::FilterKind::kMultiRange:
    default:
      VELOX_UNSUPPORTED(
          "Unsupported filter in parquet reader: {}", filter->toString());
  }
}