
**Bug description**
Unlike `cluster()`, `clusterAllReplicas()` does not implement `_shard_num`. 

I would expect
```
SELECT _shard_num
FROM clusterAllReplicas(prod, system.one)
ORDER BY _shard_num ASC
FORMAT PrettyCompactMonoBlock

┌─_shard_num─┐
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
│          0 │
└────────────┘
```
to have an output more useful like
```
SELECT _shard_num
FROM cluster(prod, system.one)
ORDER BY _shard_num ASC
FORMAT PrettyCompactMonoBlock

┌─_shard_num─┐
│          1 │
│          2 │
│          3 │
│          4 │
│          5 │
│          6 │
│          7 │
│          8 │
│          9 │
│         10 │
│         11 │
│         12 │
│         13 │
│         14 │
│         15 │
└────────────┘
```

**Releases where this has been tested**

* v20.3.12.112-stable

**References**

[cluster, clusterAllReplicas documentation](https://clickhouse.tech/docs/en/sql-reference/table-functions/cluster/)

[_shard_num documentation](https://clickhouse.tech/docs/en/engines/table-engines/special/distributed/#virtual-columns)

{
    for (size_t i_stage = 1; i_stage < prepared_stages.size(); ++i_stage)
    {
        const Stage & stage = prepared_stages[i_stage];
        for (size_t i = 0; i < stage.expressions_chain.steps.size(); ++i)
        {
            const auto & step = stage.expressions_chain.steps[i];
            if (i < stage.filter_column_names.size())
            {
                
                plan.addStep(std::make_unique<FilterStep>(plan.getCurrentDataStream(), step->actions(), stage.filter_column_names[i], false));
            }
            else
            {
                
                plan.addStep(std::make_unique<ExpressionStep>(plan.getCurrentDataStream(), step->actions()));
            }
        }
        SubqueriesForSets & subqueries_for_sets = stage.analyzer->getSubqueriesForSets();
        if (!subqueries_for_sets.empty())
        {
            const Settings & settings = context.getSettingsRef();
            SizeLimits network_transfer_limits(
                    settings.max_rows_to_transfer, settings.max_bytes_to_transfer, settings.transfer_overflow_mode);
            addCreatingSetsStep(plan, std::move(subqueries_for_sets), network_transfer_limits, context);
        }
    }
    auto pipeline = plan.buildQueryPipeline(
        QueryPlanOptimizationSettings::fromContext(context),
        BuildQueryPipelineSettings::fromContext(context));