**Describe what's wrong**

An exception is thrown when trying to use the `sumMapFiltered` function on a distributed table. 

**Does it reproduce on recent release?**

Yes. The tests below ran on ClickHouse 21.9.3


**How to reproduce**

Create the test tables and insert a couple rows of data:
```sql
CREATE TABLE local ON CLUSTER 'cluster_name' (
  time     DateTime,
  data     Nested(
    key      Int16,
    value    Int64
  )
) ENGINE = MergeTree()
  PARTITION BY toYYYYMM(time)
  ORDER BY time

CREATE TABLE distributed ON CLUSTER 'cluster_name' (
  time     DateTime,
  data     Nested(
    key      Int16,
    value    Int64
  )
) ENGINE = Distributed('cluster_name', 'cluster_name', 'local') 

INSERT INTO local VALUES
  (1635794296, [1, 2, 3], [10, 10, 10]),
  (1635794296, [1, 2, 3], [10, 10, 10]),
  (1635794296, [1, 2, 3], [10, 10, 10])
```

Then run this query against the distributed table:

```sql
SELECT sumMapFiltered([toInt16(1),toInt16(2)])(data.key, data.value) FROM distributed
```

**Expected behavior**

I would expect the query to return the correct aggregation value, but an error is thrown instead

**Error message and/or stacktrace**

```
Received exception from server (version 21.9.3):
Code: 62. DB::Exception: Received from localhost:9000. DB::Exception: Syntax error (data type): failed at position 34 ('['): [1, 2]), Array(Int16), Array(Int64)). Expected one of: number, nested table, literal, NULL, identifier, data type argument, string literal, name and type pair list, list of elements, data type, list, delimited by binary operators, name and type pair: while receiving packet from [redacted]:9000: While executing Remote. (SYNTAX_ERROR)
```

**Additional context**

The exact same query works as expected when executed against the local table.

extern const int LOGICAL_ERROR;
}
template <typename T>
struct AggregateFunctionMapData
{
    
    std::map<T, Array> merged_maps;
};
/** Aggregate function, that takes at least two arguments: keys and values, and as a result, builds a tuple of at least 2 arrays -
  * ordered keys and variable number of argument values aggregated by corresponding keys.
  *
  * sumMap function is the most useful when using SummingMergeTree to sum Nested columns, which name ends in "Map".
  *
  * Example: sumMap(k, v...) of:
  *  k           v
  *  [1,2,3]     [10,10,10]
  *  [3,4,5]     [10,10,10]
  *  [4,5,6]     [10,10,10]
  *  [6,7,8]     [10,10,10]
  *  [7,5,3]     [5,15,25]
  *  [8,9,10]    [20,20,20]
  * will return:
  *  ([1,2,3,4,5,6,7,8,9,10],[10,10,45,20,35,20,15,30,20,20])
  *
  * minMap and maxMap share the same idea, but calculate min and max correspondingly.
  *
  * NOTE: The implementation of these functions are "amateur grade" - not efficient and low quality.
  */
template <typename T, typename Derived, typename Visitor, bool overflow, bool tuple_argument, bool compact>
class AggregateFunctionMapBase : public IAggregateFunctionDataHelper<