See https://github.com/deeplook/sparklines

**Describe the solution you'd like**
```
sparkbar(width)(x, y)
sparkbar(width, min_x, max_x)(x, y)

▁▂▅▆▇▆▅
```

An aggregate function calculates a histogram of `y` by `x` and then reshapes it to `width` buckets if the histogram is larger.
Linear weighted average is used for reshaping. If multiple values correspond to a single bucket, they are also averaged.
The function returns a string.

The height of bar is proportional to the difference between `y` and the minimum value of `y` on the observed data (and then rounded to the nearest neighbor for rendering). The value of `y` can be negative but the bar height is always non negative. There are 8 different heights that can be rendered plus one additional character - whitespace that is used for absense of the value.

The boundaries for x and y can be calculated automatically or provided in parameters.

**Further info**

Similar function can use ANSI escape sequences for 24-bit color to render heatmaps.

We can encode server's memory usage during query processing directly inside the famous progress bar in clickhouse-client.
void registerAggregateFunctionEntropy(AggregateFunctionFactory &);
void registerAggregateFunctionSimpleLinearRegression(AggregateFunctionFactory &);
void registerAggregateFunctionMoving(AggregateFunctionFactory &);
void registerAggregateFunctionCategoricalIV(AggregateFunctionFactory &);
void registerAggregateFunctionAggThrow(AggregateFunctionFactory &);
void registerAggregateFunctionRankCorrelation(AggregateFunctionFactory &);
void registerAggregateFunctionMannWhitney(AggregateFunctionFactory &);
void registerAggregateFunctionWelchTTest(AggregateFunctionFactory &);
void registerAggregateFunctionStudentTTest(AggregateFunctionFactory &);
void registerAggregateFunctionSingleValueOrNull(AggregateFunctionFactory &);
void registerAggregateFunctionSequenceNextNode(AggregateFunctionFactory &);
class AggregateFunctionCombinatorFactory;
void registerAggregateFunctionCombinatorIf(AggregateFunctionCombinatorFactory &);
void registerAggregateFunctionCombinatorArray(AggregateFunctionCombinatorFactory &);
void registerAggregateFunctionCombinatorForEach(AggregateFunctionCombinatorFactory &);
void registerAggregateFunctionCombinatorSimpleState(AggregateFunctionCombinatorFactory &);
void registerAggregateFunctionCombinatorState(AggregateFunctionCombinatorFactory &);
void registerAggregateFunctionCombinatorMerge(AggregateFunctionCombinatorFactory &);
void registerAggregateFunctionCombinatorNull(AggregateFunctionCombinatorFactory &);
void registerAggregateFunctionCombinatorOrFill(AggregateFunctionCombinatorFactory &);
void registerAggregateFunctionCombinatorResample(AggregateFunctionCombinatorFactory &);
void registerAggregateFunctionCombinatorDistinct(AggregateFunctionCombinatorFactory &);
void registerWindowFunctions(AggregateFunctionFactory & factory);
void registerAggregateFunctionIntervalLengthSum(AggregateFunctionFactory &);
void registerAggregateFunctions()
{
    {
        auto & factory = AggregateFunctionFactory::instance();
        registerAggregateFunctionAvg(factory);
        registerAggregateFunctionAvgWeighted(factory);