Function tryMapPackedFilteredCount

src/processor/map/map_aggregate.cpp:165–244

}

static std::unique_ptr<PhysicalOperator> tryMapPackedFilteredCount(PlanMapper& mapper,
    main::ClientContext* clientContext, const LogicalAggregate& agg) {
    if (!clientContext->getClientConfig()->enablePackedPathExtend || agg.getKeys().size() != 1 ||
        agg.getAggregates().size() != 1 || agg.getDependentKeys().size() != 0) {
        return nullptr;
    }
    const auto aggregates = agg.getAggregates();
    const auto& aggregate = aggregates[0];
    if (aggregate->getNumChildren() != 0) {
        return nullptr;
    }
    auto aggregateExpr = aggregate->constPtrCast<AggregateFunctionExpression>();
    if (aggregateExpr->getFunction().name != function::CountStarFunction::name) {
        return nullptr;
    }
    const auto* projection = agg.getChild(0).get();
    if (projection->getOperatorType() != LogicalOperatorType::PROJECTION) {
        return nullptr;
    }
    const auto& logicalProjection = projection->constCast<LogicalProjection>();
    if (logicalProjection.getExpressionsToProject().size() != 1) {
        return nullptr;
    }
    const auto* filter = projection->getChild(0).get();
    if (filter->getOperatorType() != LogicalOperatorType::FILTER) {
        return nullptr;
    }
    const auto& logicalFilter = filter->constCast<LogicalFilter>();
    auto predicateInputs = tryGetModuloSumPredicateInputs(logicalFilter.getPredicate());
    if (!predicateInputs.has_value()) {
        return nullptr;
    }
    const auto* packedChild = unwrapFlattens(filter->getChild(0).get());
    auto* packedChildSchema = packedChild->getSchema();
    auto analyzer = GroupDependencyAnalyzer(true, *packedChildSchema);
    analyzer.visit(logicalFilter.getPredicate());
    const auto dependentGroups = analyzer.getDependentGroups();
    if (dependentGroups.size() != 2) {
        return nullptr;
    }
    for (auto groupPos : dependentGroups) {
        if (packedChildSchema->getGroup(groupPos)->isFlat()) {
            return nullptr;
        }
    }
    const auto keys = agg.getKeys();
    const auto& key = keys[0];
    if (key->getDataType().getLogicalTypeID() != LogicalTypeID::INT64 ||
        aggregate->getDataType().getLogicalTypeID() != LogicalTypeID::INT64) {
        return nullptr;
    }
    const auto keyGroupPos = packedChildSchema->getGroupPos(*key);
    std::vector<data_chunk_pos_t> multiplicityChunks;
    for (auto groupPos : packedChildSchema->getGroupsPosInScope()) {
        if (groupPos == keyGroupPos || dependentGroups.contains(groupPos) ||
            packedChildSchema->getGroup(groupPos)->isFlat()) {
            continue;
        }