Merge master

2024-09-21 09:10:48 +00:00 · 2020-07-29 19:32:30 +03:00 · 2020-07-29 19:32:30 +03:00 · ce25924871
commit ce25924871
parent f4efe3c2fd 7a806eb90f
132 changed files with 4225 additions and 2141 deletions
--- a/benchmark/omnisci/benchmark.sh
+++ b/benchmark/omnisci/benchmark.sh
@ -0,0 +1,17 @@
+#!/bin/bash
+
+grep -v -P '^#' queries.sql | sed -e 's/{table}/hits/' | while read query; do
+
+    echo 3 | sudo tee /proc/sys/vm/drop_caches
+    sudo systemctl restart omnisci_server
+    for i in {1..1000}; do
+        /opt/omnisci/bin/omnisql -t -p HyperInteractive <<< "SELECT 1;" 2>&1 | grep -q '1 rows returned' && break;
+        sleep 0.1;
+    done
+    sleep 10;
+
+    echo "$query";
+    for i in {1..3}; do
+        /opt/omnisci/bin/omnisql -t -p HyperInteractive <<< "$query" 2>&1 | grep -P 'Exception:|Execution time:';
+    done;
+done;
--- a/benchmark/omnisci/instruction.md
+++ b/benchmark/omnisci/instruction.md
@ -0,0 +1,332 @@
+# Instruction to run benchmark for OmniSci on web-analytics dataset
+
+OmniSci (former name "MapD") is open-source (open-core) in-memory analytical DBMS with support for GPU processing.
+It can run on CPU without GPU as well. It can show competitive performance on simple queries (like - simple aggregation on a single column).
+
+# How to install
+
+https://docs.omnisci.com/installation-and-configuration/installation/installing-on-ubuntu
+
+# Caveats
+
+- Dataset (at least needed columns) must fit in memory.
+- It does not support data compression (only dictionary encoding for strings).
+- First query execution is very slow because uncompressed data is read from disk.
+- It does not support index for quick range queries.
+- It does not support NOT NULL for data types.
+- It does not support BLOB.
+- No support for UNSIGNED data type (it's Ok according to SQL standard).
+- Lack of string processing functions.
+- Strings are limited to 32767 bytes.
+- GROUP BY on text data type is supported only if it has dictionary encoding.
+`Exception: Cannot group by string columns which are not dictionary encoded`
+- Some aggregate functions are not supported for strings at all.
+`Aggregate on TEXT is not supported yet.`
+- Sometimes I hit a bug when query is run in infinite loop and does not finish (after retry it's finished successfully).
+- One query executed in hours even with retries.
+- Sorting is slow and disabled with default settings for large resultsets.
+`Exception: Sorting the result would be too slow`
+`Cast from dictionary-encoded string to none-encoded would be slow`
+- There is approximate count distinct function but the precision is not documented.
+
+To enable sorting of large resultsets, see:
+https://stackoverflow.com/questions/62977734/omnissci-sorting-the-result-would-be-too-slow
+
+The list of known issues is here:
+https://github.com/omnisci/omniscidb/issues?q=is%3Aissue+author%3Aalexey-milovidov
+
+# How to prepare data
+
+Download the 100 million rows dataset from here and insert into ClickHouse:
+https://clickhouse.tech/docs/en/getting-started/example-datasets/metrica/
+
+Convert the CREATE TABLE query:
+
+```
+clickhouse-client --query "SHOW CREATE TABLE hits_100m" --format TSVRaw |
+    tr '`' '"' |
+    sed -r -e '
+        s/U?Int64/BIGINT/;
+        s/U?Int32/INTEGER/;
+        s/U?Int16/SMALLINT/;
+        s/U?Int8/TINYINT/;
+        s/DateTime/TIMESTAMP ENCODING FIXED(32)/;
+        s/ Date/ DATE ENCODING DAYS(16)/;
+        s/FixedString\(2\)/TEXT ENCODING DICT(16)/;
+        s/FixedString\(3\)/TEXT ENCODING DICT/;
+        s/FixedString\(\d+\)/TEXT ENCODING DICT/;
+        s/String/TEXT ENCODING DICT/;'
+```
+And cut `ENGINE` part.
+
+The resulting CREATE TABLE query:
+```
+CREATE TABLE hits
+(
+    "WatchID" BIGINT,
+    "JavaEnable" TINYINT,
+    "Title" TEXT ENCODING DICT,
+    "GoodEvent" SMALLINT,
+    "EventTime" TIMESTAMP ENCODING FIXED(32),
+    "EventDate" ENCODING DAYS(16) Date,
+    "CounterID" INTEGER,
+    "ClientIP" INTEGER,
+    "RegionID" INTEGER,
+    "UserID" BIGINT,
+    "CounterClass" TINYINT,
+    "OS" TINYINT,
+    "UserAgent" TINYINT,
+    "URL" TEXT ENCODING DICT,
+    "Referer" TEXT ENCODING DICT,
+    "Refresh" TINYINT,
+    "RefererCategoryID" SMALLINT,
+    "RefererRegionID" INTEGER,
+    "URLCategoryID" SMALLINT,
+    "URLRegionID" INTEGER,
+    "ResolutionWidth" SMALLINT,
+    "ResolutionHeight" SMALLINT,
+    "ResolutionDepth" TINYINT,
+    "FlashMajor" TINYINT,
+    "FlashMinor" TINYINT,
+    "FlashMinor2" TEXT ENCODING DICT,
+    "NetMajor" TINYINT,
+    "NetMinor" TINYINT,
+    "UserAgentMajor" SMALLINT,
+    "UserAgentMinor" TEXT ENCODING DICT(16),
+    "CookieEnable" TINYINT,
+    "JavascriptEnable" TINYINT,
+    "IsMobile" TINYINT,
+    "MobilePhone" TINYINT,
+    "MobilePhoneModel" TEXT ENCODING DICT,
+    "Params" TEXT ENCODING DICT,
+    "IPNetworkID" INTEGER,
+    "TraficSourceID" TINYINT,
+    "SearchEngineID" SMALLINT,
+    "SearchPhrase" TEXT ENCODING DICT,
+    "AdvEngineID" TINYINT,
+    "IsArtifical" TINYINT,
+    "WindowClientWidth" SMALLINT,
+    "WindowClientHeight" SMALLINT,
+    "ClientTimeZone" SMALLINT,
+    "ClientEventTime" TIMESTAMP ENCODING FIXED(32),
+    "SilverlightVersion1" TINYINT,
+    "SilverlightVersion2" TINYINT,
+    "SilverlightVersion3" INTEGER,
+    "SilverlightVersion4" SMALLINT,
+    "PageCharset" TEXT ENCODING DICT,
+    "CodeVersion" INTEGER,
+    "IsLink" TINYINT,
+    "IsDownload" TINYINT,
+    "IsNotBounce" TINYINT,
+    "FUniqID" BIGINT,
+    "OriginalURL" TEXT ENCODING DICT,
+    "HID" INTEGER,
+    "IsOldCounter" TINYINT,
+    "IsEvent" TINYINT,
+    "IsParameter" TINYINT,
+    "DontCountHits" TINYINT,
+    "WithHash" TINYINT,
+    "HitColor" TEXT ENCODING DICT(8),
+    "LocalEventTime" TIMESTAMP ENCODING FIXED(32),
+    "Age" TINYINT,
+    "Sex" TINYINT,
+    "Income" TINYINT,
+    "Interests" SMALLINT,
+    "Robotness" TINYINT,
+    "RemoteIP" INTEGER,
+    "WindowName" INTEGER,
+    "OpenerName" INTEGER,
+    "HistoryLength" SMALLINT,
+    "BrowserLanguage" TEXT ENCODING DICT(16),
+    "BrowserCountry" TEXT ENCODING DICT(16),
+    "SocialNetwork" TEXT ENCODING DICT,
+    "SocialAction" TEXT ENCODING DICT,
+    "HTTPError" SMALLINT,
+    "SendTiming" INTEGER,
+    "DNSTiming" INTEGER,
+    "ConnectTiming" INTEGER,
+    "ResponseStartTiming" INTEGER,
+    "ResponseEndTiming" INTEGER,
+    "FetchTiming" INTEGER,
+    "SocialSourceNetworkID" TINYINT,
+    "SocialSourcePage" TEXT ENCODING DICT,
+    "ParamPrice" BIGINT,
+    "ParamOrderID" TEXT ENCODING DICT,
+    "ParamCurrency" TEXT ENCODING DICT,
+    "ParamCurrencyID" SMALLINT,
+    "OpenstatServiceName" TEXT ENCODING DICT,
+    "OpenstatCampaignID" TEXT ENCODING DICT,
+    "OpenstatAdID" TEXT ENCODING DICT,
+    "OpenstatSourceID" TEXT ENCODING DICT,
+    "UTMSource" TEXT ENCODING DICT,
+    "UTMMedium" TEXT ENCODING DICT,
+    "UTMCampaign" TEXT ENCODING DICT,
+    "UTMContent" TEXT ENCODING DICT,
+    "UTMTerm" TEXT ENCODING DICT,
+    "FromTag" TEXT ENCODING DICT,
+    "HasGCLID" TINYINT,
+    "RefererHash" BIGINT,
+    "URLHash" BIGINT,
+    "CLID" INTEGER
+);
+```
+
+Convert the dataset, prepare the list of fields for SELECT:
+
+```
+clickhouse-client --query "SHOW CREATE TABLE hits_100m" --format TSVRaw |
+    tr '`' '"' |
+    sed -r -e '
+        s/"(\w+)" U?Int([0-9]+)/toInt\2(\1)/;
+        s/"(\w+)" (Fixed)?String(\([0-9]+\))?/toValidUTF8(toString(\1))/;
+        s/"(\w+)" \w+/\1/'
+```
+
+The resulting SELECT query for data preparation:
+
+```
+SELECT
+    toInt64(WatchID),
+    toInt8(JavaEnable),
+    toValidUTF8(toString(Title)),
+    toInt16(GoodEvent),
+    EventTime,
+    EventDate,
+    toInt32(CounterID),
+    toInt32(ClientIP),
+    toInt32(RegionID),
+    toInt64(UserID),
+    toInt8(CounterClass),
+    toInt8(OS),
+    toInt8(UserAgent),
+    toValidUTF8(toString(URL)),
+    toValidUTF8(toString(Referer)),
+    toInt8(Refresh),
+    toInt16(RefererCategoryID),
+    toInt32(RefererRegionID),
+    toInt16(URLCategoryID),
+    toInt32(URLRegionID),
+    toInt16(ResolutionWidth),
+    toInt16(ResolutionHeight),
+    toInt8(ResolutionDepth),
+    toInt8(FlashMajor),
+    toInt8(FlashMinor),
+    toValidUTF8(toString(FlashMinor2)),
+    toInt8(NetMajor),
+    toInt8(NetMinor),
+    toInt16(UserAgentMajor),
+    toValidUTF8(toString(UserAgentMinor)),
+    toInt8(CookieEnable),
+    toInt8(JavascriptEnable),
+    toInt8(IsMobile),
+    toInt8(MobilePhone),
+    toValidUTF8(toString(MobilePhoneModel)),
+    toValidUTF8(toString(Params)),
+    toInt32(IPNetworkID),
+    toInt8(TraficSourceID),
+    toInt16(SearchEngineID),
+    toValidUTF8(toString(SearchPhrase)),
+    toInt8(AdvEngineID),
+    toInt8(IsArtifical),
+    toInt16(WindowClientWidth),
+    toInt16(WindowClientHeight),
+    toInt16(ClientTimeZone),
+    ClientEventTime,
+    toInt8(SilverlightVersion1),
+    toInt8(SilverlightVersion2),
+    toInt32(SilverlightVersion3),
+    toInt16(SilverlightVersion4),
+    toValidUTF8(toString(PageCharset)),
+    toInt32(CodeVersion),
+    toInt8(IsLink),
+    toInt8(IsDownload),
+    toInt8(IsNotBounce),
+    toInt64(FUniqID),
+    toValidUTF8(toString(OriginalURL)),
+    toInt32(HID),
+    toInt8(IsOldCounter),
+    toInt8(IsEvent),
+    toInt8(IsParameter),
+    toInt8(DontCountHits),
+    toInt8(WithHash),
+    toValidUTF8(toString(HitColor)),
+    LocalEventTime,
+    toInt8(Age),
+    toInt8(Sex),
+    toInt8(Income),
+    toInt16(Interests),
+    toInt8(Robotness),
+    toInt32(RemoteIP),
+    toInt32(WindowName),
+    toInt32(OpenerName),
+    toInt16(HistoryLength),
+    toValidUTF8(toString(BrowserLanguage)),
+    toValidUTF8(toString(BrowserCountry)),
+    toValidUTF8(toString(SocialNetwork)),
+    toValidUTF8(toString(SocialAction)),
+    toInt16(HTTPError),
+    toInt32(SendTiming),
+    toInt32(DNSTiming),
+    toInt32(ConnectTiming),
+    toInt32(ResponseStartTiming),
+    toInt32(ResponseEndTiming),
+    toInt32(FetchTiming),
+    toInt8(SocialSourceNetworkID),
+    toValidUTF8(toString(SocialSourcePage)),
+    toInt64(ParamPrice),
+    toValidUTF8(toString(ParamOrderID)),
+    toValidUTF8(toString(ParamCurrency)),
+    toInt16(ParamCurrencyID),
+    toValidUTF8(toString(OpenstatServiceName)),
+    toValidUTF8(toString(OpenstatCampaignID)),
+    toValidUTF8(toString(OpenstatAdID)),
+    toValidUTF8(toString(OpenstatSourceID)),
+    toValidUTF8(toString(UTMSource)),
+    toValidUTF8(toString(UTMMedium)),
+    toValidUTF8(toString(UTMCampaign)),
+    toValidUTF8(toString(UTMContent)),
+    toValidUTF8(toString(UTMTerm)),
+    toValidUTF8(toString(FromTag)),
+    toInt8(HasGCLID),
+    toInt64(RefererHash),
+    toInt64(URLHash),
+    toInt32(CLID)
+FROM hits_100m_obfuscated
+INTO OUTFILE '/home/milovidov/example_datasets/hits_100m_obfuscated.csv'
+FORMAT CSV;
+```
+
+Upload data to OmniSci:
+```
+/opt/omnisci/bin/omnisql -t -p HyperInteractive
+```
+Run CREATE TABLE statement, then run:
+```
+COPY hits FROM '/home/milovidov/example_datasets/hits_100m_obfuscated.csv' WITH (HEADER = 'false');
+```
+
+Data loading took
+```
+336639 ms
+```
+on a server (Linux Ubuntu, Xeon E5-2560v2, 32 logical CPU, 128 GiB RAM, 8xHDD RAID-5, 40 TB).
+
+Run benchmark:
+
+```
+./benchmark.sh
+```
+
+Prepare the result to paste into JSON:
+
+```
+grep -oP 'Total time: \d+' log.txt |
+    grep -oP '\d+' |
+    awk '{
+        if (i % 3 == 0) { a = $1 }
+        else if (i % 3 == 1) { b = $1 }
+        else if (i % 3 == 2) { c = $1; print "[" a / 1000 ", " b / 1000 ", " c / 1000 "]," };
+        ++i; }'
+```
+
+And fill out `[null, null, null]` for missing runs.
--- a/benchmark/omnisci/log.txt
+++ b/benchmark/omnisci/log.txt
@ -0,0 +1,210 @@
+3
+SELECT count(*) FROM hits;
+Execution time: 23471 ms, Total time: 23471 ms
+Execution time: 42 ms, Total time: 43 ms
+Execution time: 35 ms, Total time: 35 ms
+3
+SELECT count(*) FROM hits WHERE AdvEngineID != 0;
+Execution time: 17328 ms, Total time: 17329 ms
+Execution time: 58 ms, Total time: 59 ms
+Execution time: 57 ms, Total time: 59 ms
+3
+SELECT sum(AdvEngineID), count(*), avg(ResolutionWidth) FROM hits;
+Execution time: 17309 ms, Total time: 17310 ms
+Execution time: 115 ms, Total time: 115 ms
+Execution time: 129 ms, Total time: 130 ms
+3
+SELECT sum(UserID) FROM hits;
+Execution time: 26091 ms, Total time: 26091 ms
+Execution time: 88 ms, Total time: 89 ms
+Execution time: 71 ms, Total time: 72 ms
+3
+SELECT APPROX_COUNT_DISTINCT(UserID) FROM hits;
+Execution time: 21720 ms, Total time: 21720 ms
+Execution time: 364 ms, Total time: 364 ms
+Execution time: 344 ms, Total time: 345 ms
+3
+SELECT APPROX_COUNT_DISTINCT(SearchPhrase) FROM hits;
+Execution time: 19314 ms, Total time: 19315 ms
+Execution time: 385 ms, Total time: 386 ms
+Execution time: 382 ms, Total time: 382 ms
+3
+SELECT min(EventDate), max(EventDate) FROM hits;
+Execution time: 19431 ms, Total time: 19432 ms
+Execution time: 130 ms, Total time: 131 ms
+Execution time: 147 ms, Total time: 148 ms
+3
+SELECT AdvEngineID, count(*) FROM hits WHERE AdvEngineID != 0 GROUP BY AdvEngineID ORDER BY count(*) DESC;
+Execution time: 20660 ms, Total time: 20661 ms
+Execution time: 63 ms, Total time: 64 ms
+Execution time: 88 ms, Total time: 89 ms
+3
+SELECT RegionID, APPROX_COUNT_DISTINCT(UserID) AS u FROM hits GROUP BY RegionID ORDER BY u DESC LIMIT 10;
+Execution time: 21364 ms, Total time: 21472 ms
+Execution time: 1387 ms, Total time: 1504 ms
+Execution time: 1443 ms, Total time: 1505 ms
+3
+SELECT RegionID, sum(AdvEngineID), count(*) AS c, avg(ResolutionWidth), APPROX_COUNT_DISTINCT(UserID) FROM hits GROUP BY RegionID ORDER BY c DESC LIMIT 10;
+Execution time: 22205 ms, Total time: 22285 ms
+Execution time: 1590 ms, Total time: 1655 ms
+Execution time: 1591 ms, Total time: 1658 ms
+3
+SELECT MobilePhoneModel, APPROX_COUNT_DISTINCT(UserID) AS u FROM hits WHERE MobilePhoneModel != '' GROUP BY MobilePhoneModel ORDER BY u DESC LIMIT 10;
+Execution time: 22343 ms, Total time: 22344 ms
+Execution time: 122 ms, Total time: 123 ms
+Execution time: 117 ms, Total time: 118 ms
+3
+SELECT MobilePhone, MobilePhoneModel, APPROX_COUNT_DISTINCT(UserID) AS u FROM hits WHERE MobilePhoneModel != '' GROUP BY MobilePhone, MobilePhoneModel ORDER BY u DESC LIMIT 10;
+Execution time: 21681 ms, Total time: 21695 ms
+Execution time: 299 ms, Total time: 310 ms
+Execution time: 275 ms, Total time: 292 ms
+3
+SELECT SearchPhrase, count(*) AS c FROM hits WHERE SearchPhrase != '' GROUP BY SearchPhrase ORDER BY c DESC LIMIT 10;
+Execution time: 23346 ms, Total time: 23360 ms
+Execution time: 613 ms, Total time: 631 ms
+Execution time: 606 ms, Total time: 624 ms
+3
+SELECT SearchPhrase, APPROX_COUNT_DISTINCT(UserID) AS u FROM hits WHERE SearchPhrase != '' GROUP BY SearchPhrase ORDER BY u DESC LIMIT 10;
+Execution time: 66014 ms, Total time: 68618 ms
+Execution time: 44309 ms, Total time: 47296 ms
+Execution time: 44019 ms, Total time: 46866 ms
+3
+SELECT SearchEngineID, SearchPhrase, count(*) AS c FROM hits WHERE SearchPhrase != '' GROUP BY SearchEngineID, SearchPhrase ORDER BY c DESC LIMIT 10;
+Execution time: 25853 ms, Total time: 25984 ms
+Execution time: 2590 ms, Total time: 2728 ms
+Execution time: 2652 ms, Total time: 2789 ms
+3
+SELECT UserID, count(*) FROM hits GROUP BY UserID ORDER BY count(*) DESC LIMIT 10;
+Execution time: 26581 ms, Total time: 26953 ms
+Execution time: 5843 ms, Total time: 6158 ms
+Execution time: 5970 ms, Total time: 6286 ms
+3
+SELECT UserID, SearchPhrase, count(*) FROM hits GROUP BY UserID, SearchPhrase ORDER BY count(*) DESC LIMIT 10;
+Execution time: 33007 ms, Total time: 33581 ms
+Execution time: 9943 ms, Total time: 10509 ms
+Execution time: 9470 ms, Total time: 10047 ms
+3
+SELECT UserID, SearchPhrase, count(*) FROM hits GROUP BY UserID, SearchPhrase LIMIT 10;
+Execution time: 39009 ms, Total time: 39575 ms
+Execution time: 8151 ms, Total time: 8785 ms
+Execution time: 8037 ms, Total time: 8665 ms
+3
+SELECT UserID, extract(minute FROM EventTime) AS m, SearchPhrase, count(*) FROM hits GROUP BY UserID, m, SearchPhrase ORDER BY count(*) DESC LIMIT 10;
+Execution time: 56207 ms, Total time: 57764 ms
+Execution time: 26653 ms, Total time: 28199 ms
+Execution time: 25614 ms, Total time: 27336 ms
+3
+SELECT UserID FROM hits WHERE UserID = -6101065172474983726;
+Execution time: 18975 ms, Total time: 18976 ms
+Execution time: 136 ms, Total time: 136 ms
+Execution time: 136 ms, Total time: 136 ms
+3
+SELECT count(*) FROM hits WHERE URL LIKE '%metrika%';
+Execution time: 32444 ms, Total time: 32445 ms
+Execution time: 125 ms, Total time: 126 ms
+Execution time: 134 ms, Total time: 136 ms
+3
+SELECT SearchPhrase, min(URL), count(*) AS c FROM hits WHERE URL LIKE '%metrika%' AND SearchPhrase != '' GROUP BY SearchPhrase ORDER BY c DESC LIMIT 10;
+Exception: Aggregate on TEXT is not supported yet.
+Exception: Aggregate on TEXT is not supported yet.
+Exception: Aggregate on TEXT is not supported yet.
+3
+SELECT SearchPhrase, min(URL), min(Title), count(*) AS c, APPROX_COUNT_DISTINCT(UserID) FROM hits WHERE Title LIKE '%Яндекс%' AND URL NOT LIKE '%.yandex.%' AND SearchPhrase != '' GROUP BY SearchPhrase ORDER BY c DESC LIMIT 10;
+Exception: Aggregate on TEXT is not supported yet.
+Exception: Aggregate on TEXT is not supported yet.
+Exception: Aggregate on TEXT is not supported yet.
+3
+SELECT * FROM hits WHERE URL LIKE '%metrika%' ORDER BY EventTime LIMIT 10;
+Execution time: 96163 ms, Total time: 96166 ms
+Execution time: 312 ms, Total time: 314 ms
+Execution time: 303 ms, Total time: 305 ms
+3
+SELECT SearchPhrase FROM hits WHERE SearchPhrase != '' ORDER BY EventTime LIMIT 10;
+Execution time: 27493 ms, Total time: 27494 ms
+Execution time: 216 ms, Total time: 216 ms
+Execution time: 221 ms, Total time: 222 ms
+3
+SELECT SearchPhrase FROM hits WHERE SearchPhrase != '' ORDER BY SearchPhrase LIMIT 10;
+Execution time: 38230 ms, Total time: 38308 ms
+Execution time: 17175 ms, Total time: 17256 ms
+Execution time: 17225 ms, Total time: 17310 ms
+3
+SELECT SearchPhrase FROM hits WHERE SearchPhrase != '' ORDER BY EventTime, SearchPhrase LIMIT 10;
+Execution time: 115614 ms, Total time: 115714 ms
+Execution time: 95944 ms, Total time: 96041 ms
+Execution time: 94274 ms, Total time: 94383 ms
+3
+SELECT CounterID, avg(length(URL)) AS l, count(*) AS c FROM hits WHERE URL != '' GROUP BY CounterID HAVING c > 100000 ORDER BY l DESC LIMIT 25;
+Execution time: 31775 ms, Total time: 31779 ms
+Execution time: 2643 ms, Total time: 2647 ms
+Execution time: 2933 ms, Total time: 2937 ms
+3
+SELECT domainWithoutWWW(Referer) AS key, avg(length(Referer)) AS l, count(*) AS c, min(Referer) FROM hits WHERE Referer != '' GROUP BY key HAVING c > 100000 ORDER BY l DESC LIMIT 25;
+Exception: Exception occurred: org.apache.calcite.runtime.CalciteContextException: From line 1, column 8 to line 1, column 36: No match found for function signature domainWithoutWWW(<CHARACTER>)
+Exception: Exception occurred: org.apache.calcite.runtime.CalciteContextException: From line 1, column 8 to line 1, column 36: No match found for function signature domainWithoutWWW(<CHARACTER>)
+Exception: Exception occurred: org.apache.calcite.runtime.CalciteContextException: From line 1, column 8 to line 1, column 36: No match found for function signature domainWithoutWWW(<CHARACTER>)
+3
+SELECT sum(ResolutionWidth), sum(ResolutionWidth + 1), sum(ResolutionWidth + 2), sum(ResolutionWidth + 3), sum(ResolutionWidth + 4), sum(ResolutionWidth + 5), sum(ResolutionWidth + 6), sum(ResolutionWidth + 7), sum(ResolutionWidth + 8), sum(ResolutionWidth + 9), sum(ResolutionWidth + 10), sum(ResolutionWidth + 11), sum(ResolutionWidth + 12), sum(ResolutionWidth + 13), sum(ResolutionWidth + 14), sum(ResolutionWidth + 15), sum(ResolutionWidth + 16), sum(ResolutionWidth + 17), sum(ResolutionWidth + 18), sum(ResolutionWidth + 19), sum(ResolutionWidth + 20), sum(ResolutionWidth + 21), sum(ResolutionWidth + 22), sum(ResolutionWidth + 23), sum(ResolutionWidth + 24), sum(ResolutionWidth + 25), sum(ResolutionWidth + 26), sum(ResolutionWidth + 27), sum(ResolutionWidth + 28), sum(ResolutionWidth + 29), sum(ResolutionWidth + 30), sum(ResolutionWidth + 31), sum(ResolutionWidth + 32), sum(ResolutionWidth + 33), sum(ResolutionWidth + 34), sum(ResolutionWidth + 35), sum(ResolutionWidth + 36), sum(ResolutionWidth + 37), sum(ResolutionWidth + 38), sum(ResolutionWidth + 39), sum(ResolutionWidth + 40), sum(ResolutionWidth + 41), sum(ResolutionWidth + 42), sum(ResolutionWidth + 43), sum(ResolutionWidth + 44), sum(ResolutionWidth + 45), sum(ResolutionWidth + 46), sum(ResolutionWidth + 47), sum(ResolutionWidth + 48), sum(ResolutionWidth + 49), sum(ResolutionWidth + 50), sum(ResolutionWidth + 51), sum(ResolutionWidth + 52), sum(ResolutionWidth + 53), sum(ResolutionWidth + 54), sum(ResolutionWidth + 55), sum(ResolutionWidth + 56), sum(ResolutionWidth + 57), sum(ResolutionWidth + 58), sum(ResolutionWidth + 59), sum(ResolutionWidth + 60), sum(ResolutionWidth + 61), sum(ResolutionWidth + 62), sum(ResolutionWidth + 63), sum(ResolutionWidth + 64), sum(ResolutionWidth + 65), sum(ResolutionWidth + 66), sum(ResolutionWidth + 67), sum(ResolutionWidth + 68), sum(ResolutionWidth + 69), sum(ResolutionWidth + 70), sum(ResolutionWidth + 71), sum(ResolutionWidth + 72), sum(ResolutionWidth + 73), sum(ResolutionWidth + 74), sum(ResolutionWidth + 75), sum(ResolutionWidth + 76), sum(ResolutionWidth + 77), sum(ResolutionWidth + 78), sum(ResolutionWidth + 79), sum(ResolutionWidth + 80), sum(ResolutionWidth + 81), sum(ResolutionWidth + 82), sum(ResolutionWidth + 83), sum(ResolutionWidth + 84), sum(ResolutionWidth + 85), sum(ResolutionWidth + 86), sum(ResolutionWidth + 87), sum(ResolutionWidth + 88), sum(ResolutionWidth + 89) FROM hits;
+Execution time: 28853 ms, Total time: 28854 ms
+Execution time: 5654 ms, Total time: 5655 ms
+Execution time: 5579 ms, Total time: 5581 ms
+3
+SELECT SearchEngineID, ClientIP, count(*) AS c, sum("Refresh"), avg(ResolutionWidth) FROM hits WHERE SearchPhrase != '' GROUP BY SearchEngineID, ClientIP ORDER BY c DESC LIMIT 10;
+Execution time: 31694 ms, Total time: 31925 ms
+Execution time: 3872 ms, Total time: 4142 ms
+Execution time: 3928 ms, Total time: 4162 ms
+3
+SELECT WatchID, ClientIP, count(*) AS c, sum("Refresh"), avg(ResolutionWidth) FROM hits WHERE SearchPhrase != '' GROUP BY WatchID, ClientIP ORDER BY c DESC LIMIT 10;
+Execution time: 43690 ms, Total time: 44297 ms
+Execution time: 8221 ms, Total time: 8825 ms
+Execution time: 8115 ms, Total time: 8711 ms
+3
+SELECT URL, count(*) AS c FROM hits GROUP BY URL ORDER BY c DESC LIMIT 10;
+Execution time: 29669 ms, Total time: 29715 ms
+Execution time: 1623 ms, Total time: 1669 ms
+Execution time: 1534 ms, Total time: 1586 ms
+3
+SELECT 1, URL, count(*) AS c FROM hits GROUP BY 1, URL ORDER BY c DESC LIMIT 10;
+Execution time: 34860 ms, Total time: 35201 ms
+Execution time: 7075 ms, Total time: 7414 ms
+Execution time: 7164 ms, Total time: 7567 ms
+3
+SELECT ClientIP, ClientIP - 1, ClientIP - 2, ClientIP - 3, count(*) AS c FROM hits GROUP BY ClientIP, ClientIP - 1, ClientIP - 2, ClientIP - 3 ORDER BY c DESC LIMIT 10;
+Execution time: 26467 ms, Total time: 26724 ms
+Execution time: 5740 ms, Total time: 6026 ms
+Execution time: 5667 ms, Total time: 5920 ms
+3
+SELECT URL, count(*) AS PageViews FROM hits WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND DontCountHits = 0 AND "Refresh" = 0 AND URL != '' GROUP BY URL ORDER BY PageViews DESC LIMIT 10;
+Execution time: 31899 ms, Total time: 31908 ms
+Execution time: 1141 ms, Total time: 1154 ms
+Execution time: 1155 ms, Total time: 1168 ms
+3
+SELECT Title, count(*) AS PageViews FROM hits WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND DontCountHits = 0 AND "Refresh" = 0 AND Title != '' GROUP BY Title ORDER BY PageViews DESC LIMIT 10;
+Execution time: 27991 ms, Total time: 27997 ms
+Execution time: 719 ms, Total time: 724 ms
+Execution time: 737 ms, Total time: 744 ms
+3
+SELECT URL, count(*) AS PageViews FROM hits WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND "Refresh" = 0 AND IsLink != 0 AND IsDownload = 0 GROUP BY URL ORDER BY PageViews DESC LIMIT 1000;
+Execution time: 34651 ms, Total time: 34661 ms
+Execution time: 1182 ms, Total time: 1200 ms
+Execution time: 1142 ms, Total time: 1159 ms
+3
+SELECT TraficSourceID, SearchEngineID, AdvEngineID, CASE WHEN (SearchEngineID = 0 AND AdvEngineID = 0) THEN Referer ELSE '' END AS Src, URL AS Dst, count(*) AS PageViews FROM hits WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND "Refresh" = 0 GROUP BY TraficSourceID, SearchEngineID, AdvEngineID, Src, Dst ORDER BY PageViews DESC LIMIT 1000;
+Execution time: 30130 ms, Total time: 30136 ms
+Execution time: 461 ms, Total time: 467 ms
+Execution time: 445 ms, Total time: 451 ms
+3
+SELECT URLHash, EventDate, count(*) AS PageViews FROM hits WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND "Refresh" = 0 AND TraficSourceID IN (-1, 6) AND RefererHash = 686716256552154761 GROUP BY URLHash, EventDate ORDER BY PageViews DESC LIMIT 100;
+Execution time: 19989 ms, Total time: 19991 ms
+Execution time: 326 ms, Total time: 327 ms
+Execution time: 325 ms, Total time: 326 ms
+3
+SELECT WindowClientWidth, WindowClientHeight, count(*) AS PageViews FROM hits WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND "Refresh" = 0 AND DontCountHits = 0 AND URLHash = 686716256552154761 GROUP BY WindowClientWidth, WindowClientHeight ORDER BY PageViews DESC LIMIT 10000;
+Execution time: 18658 ms, Total time: 18660 ms
+Execution time: 265 ms, Total time: 266 ms
+Execution time: 254 ms, Total time: 255 ms
+3
+SELECT DATE_TRUNC(minute, EventTime) AS "Minute", count(*) AS PageViews FROM hits WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-02' AND "Refresh" = 0 AND DontCountHits = 0 GROUP BY DATE_TRUNC(minute, EventTime) ORDER BY DATE_TRUNC(minute, EventTime);
+Execution time: 25225 ms, Total time: 25227 ms
+Execution time: 210 ms, Total time: 212 ms
+Execution time: 199 ms, Total time: 200 ms
--- a/benchmark/omnisci/queries.sql
+++ b/benchmark/omnisci/queries.sql
@ -0,0 +1,43 @@
+SELECT count(*) FROM {table};
+SELECT count(*) FROM {table} WHERE AdvEngineID != 0;
+SELECT sum(AdvEngineID), count(*), avg(ResolutionWidth) FROM {table};
+SELECT sum(UserID) FROM {table};
+SELECT APPROX_COUNT_DISTINCT(UserID) FROM {table};
+SELECT APPROX_COUNT_DISTINCT(SearchPhrase) FROM {table};
+SELECT min(EventDate), max(EventDate) FROM {table};
+SELECT AdvEngineID, count(*) FROM {table} WHERE AdvEngineID != 0 GROUP BY AdvEngineID ORDER BY count(*) DESC;
+SELECT RegionID, APPROX_COUNT_DISTINCT(UserID) AS u FROM {table} GROUP BY RegionID ORDER BY u DESC LIMIT 10;
+SELECT RegionID, sum(AdvEngineID), count(*) AS c, avg(ResolutionWidth), APPROX_COUNT_DISTINCT(UserID) FROM {table} GROUP BY RegionID ORDER BY c DESC LIMIT 10;
+SELECT MobilePhoneModel, APPROX_COUNT_DISTINCT(UserID) AS u FROM {table} WHERE MobilePhoneModel != '' GROUP BY MobilePhoneModel ORDER BY u DESC LIMIT 10;
+SELECT MobilePhone, MobilePhoneModel, APPROX_COUNT_DISTINCT(UserID) AS u FROM {table} WHERE MobilePhoneModel != '' GROUP BY MobilePhone, MobilePhoneModel ORDER BY u DESC LIMIT 10;
+SELECT SearchPhrase, count(*) AS c FROM {table} WHERE SearchPhrase != '' GROUP BY SearchPhrase ORDER BY c DESC LIMIT 10;
+SELECT SearchPhrase, APPROX_COUNT_DISTINCT(UserID) AS u FROM {table} WHERE SearchPhrase != '' GROUP BY SearchPhrase ORDER BY u DESC LIMIT 10;
+SELECT SearchEngineID, SearchPhrase, count(*) AS c FROM {table} WHERE SearchPhrase != '' GROUP BY SearchEngineID, SearchPhrase ORDER BY c DESC LIMIT 10;
+SELECT UserID, count(*) FROM {table} GROUP BY UserID ORDER BY count(*) DESC LIMIT 10;
+SELECT UserID, SearchPhrase, count(*) FROM {table} GROUP BY UserID, SearchPhrase ORDER BY count(*) DESC LIMIT 10;
+SELECT UserID, SearchPhrase, count(*) FROM {table} GROUP BY UserID, SearchPhrase LIMIT 10;
+SELECT UserID, extract(minute FROM EventTime) AS m, SearchPhrase, count(*) FROM {table} GROUP BY UserID, m, SearchPhrase ORDER BY count(*) DESC LIMIT 10;
+SELECT UserID FROM {table} WHERE UserID = -6101065172474983726;
+SELECT count(*) FROM {table} WHERE URL LIKE '%metrika%';
+SELECT SearchPhrase, min(URL), count(*) AS c FROM {table} WHERE URL LIKE '%metrika%' AND SearchPhrase != '' GROUP BY SearchPhrase ORDER BY c DESC LIMIT 10;
+SELECT SearchPhrase, min(URL), min(Title), count(*) AS c, APPROX_COUNT_DISTINCT(UserID) FROM {table} WHERE Title LIKE '%Яндекс%' AND URL NOT LIKE '%.yandex.%' AND SearchPhrase != '' GROUP BY SearchPhrase ORDER BY c DESC LIMIT 10;
+SELECT * FROM {table} WHERE URL LIKE '%metrika%' ORDER BY EventTime LIMIT 10;
+SELECT SearchPhrase FROM {table} WHERE SearchPhrase != '' ORDER BY EventTime LIMIT 10;
+SELECT SearchPhrase FROM {table} WHERE SearchPhrase != '' ORDER BY SearchPhrase LIMIT 10;
+SELECT SearchPhrase FROM {table} WHERE SearchPhrase != '' ORDER BY EventTime, SearchPhrase LIMIT 10;
+SELECT CounterID, avg(length(URL)) AS l, count(*) AS c FROM {table} WHERE URL != '' GROUP BY CounterID HAVING c > 100000 ORDER BY l DESC LIMIT 25;
+SELECT domainWithoutWWW(Referer) AS key, avg(length(Referer)) AS l, count(*) AS c, min(Referer) FROM {table} WHERE Referer != '' GROUP BY key HAVING c > 100000 ORDER BY l DESC LIMIT 25;
+SELECT sum(ResolutionWidth), sum(ResolutionWidth + 1), sum(ResolutionWidth + 2), sum(ResolutionWidth + 3), sum(ResolutionWidth + 4), sum(ResolutionWidth + 5), sum(ResolutionWidth + 6), sum(ResolutionWidth + 7), sum(ResolutionWidth + 8), sum(ResolutionWidth + 9), sum(ResolutionWidth + 10), sum(ResolutionWidth + 11), sum(ResolutionWidth + 12), sum(ResolutionWidth + 13), sum(ResolutionWidth + 14), sum(ResolutionWidth + 15), sum(ResolutionWidth + 16), sum(ResolutionWidth + 17), sum(ResolutionWidth + 18), sum(ResolutionWidth + 19), sum(ResolutionWidth + 20), sum(ResolutionWidth + 21), sum(ResolutionWidth + 22), sum(ResolutionWidth + 23), sum(ResolutionWidth + 24), sum(ResolutionWidth + 25), sum(ResolutionWidth + 26), sum(ResolutionWidth + 27), sum(ResolutionWidth + 28), sum(ResolutionWidth + 29), sum(ResolutionWidth + 30), sum(ResolutionWidth + 31), sum(ResolutionWidth + 32), sum(ResolutionWidth + 33), sum(ResolutionWidth + 34), sum(ResolutionWidth + 35), sum(ResolutionWidth + 36), sum(ResolutionWidth + 37), sum(ResolutionWidth + 38), sum(ResolutionWidth + 39), sum(ResolutionWidth + 40), sum(ResolutionWidth + 41), sum(ResolutionWidth + 42), sum(ResolutionWidth + 43), sum(ResolutionWidth + 44), sum(ResolutionWidth + 45), sum(ResolutionWidth + 46), sum(ResolutionWidth + 47), sum(ResolutionWidth + 48), sum(ResolutionWidth + 49), sum(ResolutionWidth + 50), sum(ResolutionWidth + 51), sum(ResolutionWidth + 52), sum(ResolutionWidth + 53), sum(ResolutionWidth + 54), sum(ResolutionWidth + 55), sum(ResolutionWidth + 56), sum(ResolutionWidth + 57), sum(ResolutionWidth + 58), sum(ResolutionWidth + 59), sum(ResolutionWidth + 60), sum(ResolutionWidth + 61), sum(ResolutionWidth + 62), sum(ResolutionWidth + 63), sum(ResolutionWidth + 64), sum(ResolutionWidth + 65), sum(ResolutionWidth + 66), sum(ResolutionWidth + 67), sum(ResolutionWidth + 68), sum(ResolutionWidth + 69), sum(ResolutionWidth + 70), sum(ResolutionWidth + 71), sum(ResolutionWidth + 72), sum(ResolutionWidth + 73), sum(ResolutionWidth + 74), sum(ResolutionWidth + 75), sum(ResolutionWidth + 76), sum(ResolutionWidth + 77), sum(ResolutionWidth + 78), sum(ResolutionWidth + 79), sum(ResolutionWidth + 80), sum(ResolutionWidth + 81), sum(ResolutionWidth + 82), sum(ResolutionWidth + 83), sum(ResolutionWidth + 84), sum(ResolutionWidth + 85), sum(ResolutionWidth + 86), sum(ResolutionWidth + 87), sum(ResolutionWidth + 88), sum(ResolutionWidth + 89) FROM {table};
+SELECT SearchEngineID, ClientIP, count(*) AS c, sum("Refresh"), avg(ResolutionWidth) FROM {table} WHERE SearchPhrase != '' GROUP BY SearchEngineID, ClientIP ORDER BY c DESC LIMIT 10;
+SELECT WatchID, ClientIP, count(*) AS c, sum("Refresh"), avg(ResolutionWidth) FROM {table} WHERE SearchPhrase != '' GROUP BY WatchID, ClientIP ORDER BY c DESC LIMIT 10;
+#SELECT WatchID, ClientIP, count(*) AS c, sum("Refresh"), avg(ResolutionWidth) FROM {table} GROUP BY WatchID, ClientIP ORDER BY c DESC LIMIT 10;
+SELECT URL, count(*) AS c FROM {table} GROUP BY URL ORDER BY c DESC LIMIT 10;
+SELECT 1, URL, count(*) AS c FROM {table} GROUP BY 1, URL ORDER BY c DESC LIMIT 10;
+SELECT ClientIP, ClientIP - 1, ClientIP - 2, ClientIP - 3, count(*) AS c FROM {table} GROUP BY ClientIP, ClientIP - 1, ClientIP - 2, ClientIP - 3 ORDER BY c DESC LIMIT 10;
+SELECT URL, count(*) AS PageViews FROM {table} WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND DontCountHits = 0 AND "Refresh" = 0 AND URL != '' GROUP BY URL ORDER BY PageViews DESC LIMIT 10;
+SELECT Title, count(*) AS PageViews FROM {table} WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND DontCountHits = 0 AND "Refresh" = 0 AND Title != '' GROUP BY Title ORDER BY PageViews DESC LIMIT 10;
+SELECT URL, count(*) AS PageViews FROM {table} WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND "Refresh" = 0 AND IsLink != 0 AND IsDownload = 0 GROUP BY URL ORDER BY PageViews DESC LIMIT 1000;
+SELECT TraficSourceID, SearchEngineID, AdvEngineID, CASE WHEN (SearchEngineID = 0 AND AdvEngineID = 0) THEN Referer ELSE '' END AS Src, URL AS Dst, count(*) AS PageViews FROM {table} WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND "Refresh" = 0 GROUP BY TraficSourceID, SearchEngineID, AdvEngineID, Src, Dst ORDER BY PageViews DESC LIMIT 1000;
+SELECT URLHash, EventDate, count(*) AS PageViews FROM {table} WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND "Refresh" = 0 AND TraficSourceID IN (-1, 6) AND RefererHash = 686716256552154761 GROUP BY URLHash, EventDate ORDER BY PageViews DESC LIMIT 100;
+SELECT WindowClientWidth, WindowClientHeight, count(*) AS PageViews FROM {table} WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-31' AND "Refresh" = 0 AND DontCountHits = 0 AND URLHash = 686716256552154761 GROUP BY WindowClientWidth, WindowClientHeight ORDER BY PageViews DESC LIMIT 10000;
+SELECT DATE_TRUNC(minute, EventTime) AS "Minute", count(*) AS PageViews FROM {table} WHERE CounterID = 62 AND EventDate >= '2013-07-01' AND EventDate <= '2013-07-02' AND "Refresh" = 0 AND DontCountHits = 0 GROUP BY DATE_TRUNC(minute, EventTime) ORDER BY DATE_TRUNC(minute, EventTime);
--- a/docs/en/getting-started/example-datasets/metrica.md
+++ b/docs/en/getting-started/example-datasets/metrica.md
@ -7,7 +7,7 @@ toc_title: Yandex.Metrica Data

 Dataset consists of two tables containing anonymized data about hits (`hits_v1`) and visits (`visits_v1`) of Yandex.Metrica. You can read more about Yandex.Metrica in [ClickHouse history](../../introduction/history.md) section.

-The dataset consists of two tables, either of them can be downloaded as a compressed `tsv.xz` file or as prepared partitions. In addition to that, an extended version of the `hits` table containing 100 million rows is available as TSV at https://clickhouse-datasets.s3.yandex.net/hits/tsv/hits\_100m\_obfuscated\_v1.tsv.xz and as prepared partitions at https://clickhouse-datasets.s3.yandex.net/hits/partitions/hits\_100m\_obfuscated\_v1.tar.xz.
+The dataset consists of two tables, either of them can be downloaded as a compressed `tsv.xz` file or as prepared partitions. In addition to that, an extended version of the `hits` table containing 100 million rows is available as TSV at https://clickhouse-datasets.s3.yandex.net/hits/tsv/hits_100m_obfuscated_v1.tsv.xz and as prepared partitions at https://clickhouse-datasets.s3.yandex.net/hits/partitions/hits_100m_obfuscated_v1.tar.xz.

 ## Obtaining Tables from Prepared Partitions {#obtaining-tables-from-prepared-partitions}

--- a/docs/en/operations/settings/settings.md
+++ b/docs/en/operations/settings/settings.md
@ -1723,4 +1723,21 @@ SELECT * FROM a;
 +---+
 ```

+## mutations_sync {#mutations_sync}
+
+Allows to execute `ALTER TABLE ... UPDATE|DELETE` queries ([mutations](../../sql-reference/statements/alter/index.md#mutations)) synchronously.
+
+Possible values:
+
+-   0 - Mutations execute asynchronously. 
+-   1 - The query waits for all mutations to complete on the current server. 
+-   2 - The query waits for all mutations to complete on all replicas (if they exist).
+
+Default value: `0`.
+
+**See Also**
+
+-   [Synchronicity of ALTER Queries](../../sql-reference/statements/alter/index.md#synchronicity-of-alter-queries)
+-   [Mutations](../../sql-reference/statements/alter/index.md#mutations)
+
 [Original article](https://clickhouse.tech/docs/en/operations/settings/settings/) <!-- hide -->
--- a/docs/en/operations/system-tables/metric_log.md
+++ b/docs/en/operations/system-tables/metric_log.md
@ -50,6 +50,6 @@ CurrentMetric_ReplicatedChecks:                             0
 **See also**

 -   [system.asynchronous\_metrics](../../operations/system-tables/asynchronous_metrics.md) — Contains periodically calculated metrics.
-   [system.events](../../operations/system-tables/events.md) — Contains a number of events that occurred.
+-   [system.events](../../operations/system-tables/events.md#system_tables-events) — Contains a number of events that occurred.
 -   [system.metrics](../../operations/system-tables/metrics.md) — Contains instantly calculated metrics.
 -   [Monitoring](../../operations/monitoring.md) — Base concepts of ClickHouse monitoring.
--- a/docs/en/sql-reference/functions/tuple-map-functions.md
+++ b/docs/en/sql-reference/functions/tuple-map-functions.md
@ -0,0 +1,48 @@
+---
+toc_priority: 46
+toc_title: Working with maps
+---
+
+# Functions for maps {#functions-for-working-with-tuple-maps}
+
+## mapAdd(Tuple(Array, Array), Tuple(Array, Array) [, ...]) {#function-mapadd}
+
+Collect all the keys and sum corresponding values.
+
+Arguments are tuples of two arrays, where items in the first array represent keys, and the second array
+contains values for the each key.
+All key arrays should have same type, and all value arrays should contain items which are promotable to the one type (Int64, UInt64 or Float64).
+The common promoted type is used as a type for the result array.
+
+Returns one tuple, where the first array contains the sorted keys and the second array contains values.
+
+```sql
+SELECT mapAdd(([toUInt8(1), 2], [1, 1]), ([toUInt8(1), 2], [1, 1])) as res, toTypeName(res) as type;
+```
+
+```text
+┌─res───────────┬─type───────────────────────────────┐
+│ ([1,2],[2,2]) │ Tuple(Array(UInt8), Array(UInt64)) │
+└───────────────┴────────────────────────────────────┘
+```
+
+## mapSubtract(Tuple(Array, Array), Tuple(Array, Array) [, ...]) {#function-mapsubtract}
+
+Collect all the keys and subtract corresponding values.
+
+Arguments are tuples of two arrays, where items in the first array represent keys, and the second array
+contains values for the each key.
+All key arrays should have same type, and all value arrays should contain items which are promotable to the one type (Int64, UInt64 or Float64).
+The common promoted type is used as a type for the result array.
+
+Returns one tuple, where the first array contains the sorted keys and the second array contains values.
+
+```sql
+SELECT mapSubtract(([toUInt8(1), 2], [toInt32(1), 1]), ([toUInt8(1), 2], [toInt32(2), 1])) as res, toTypeName(res) as type;
+```
+
+```text
+┌─res────────────┬─type──────────────────────────────┐
+│ ([1,2],[-1,0]) │ Tuple(Array(UInt8), Array(Int64)) │
+└────────────────┴───────────────────────────────────┘
+````
--- a/docs/en/sql-reference/statements/alter/delete.md
+++ b/docs/en/sql-reference/statements/alter/delete.md
@ -9,7 +9,7 @@ toc_title: DELETE
 ALTER TABLE [db.]table [ON CLUSTER cluster] DELETE WHERE filter_expr
 ```

-Allows to asynchronously delete data matching the specified filtering expression. Implemented as a [mutation](../../../sql-reference/statements/index.md#mutations).
+Allows to delete data matching the specified filtering expression. Implemented as a [mutation](../../../sql-reference/statements/alter/index.md#mutations).

 !!! note "Note"
    The `ALTER TABLE` prefix makes this syntax different from most other systems supporting SQL. It is intended to signify that unlike similar queries in OLTP databases this is a heavy operation not designed for frequent use.
@ -17,3 +17,11 @@ Allows to asynchronously delete data matching the specified filtering expression
 The `filter_expr` must be of type `UInt8`. The query deletes rows in the table for which this expression takes a non-zero value.

 One query can contain several commands separated by commas.
+
+The synchronicity of the query processing is defined by the [mutations_sync](../../../operations/settings/settings.md#mutations_sync) setting. By default, it is asynchronous.
+
+**See also**
+
+-   [Mutations](../../../sql-reference/statements/alter/index.md#mutations)
+-   [Synchronicity of ALTER Queries](../../../sql-reference/statements/alter/index.md#synchronicity-of-alter-queries)
+-   [mutations_sync](../../../operations/settings/settings.md#mutations_sync) setting
--- a/docs/en/sql-reference/statements/alter/index.md
+++ b/docs/en/sql-reference/statements/alter/index.md
@ -27,12 +27,6 @@ While these `ALTER` settings modify entities related to role-based access contro
 -   [ROW POLICY](../../../sql-reference/statements/alter/row-policy.md)
 -   [SETTINGS PROFILE](../../../sql-reference/statements/alter/settings-profile.md)

-## Synchronicity of ALTER Queries {#synchronicity-of-alter-queries}
-
-For non-replicated tables, all `ALTER` queries are performed synchronously. For replicated tables, the query just adds instructions for the appropriate actions to `ZooKeeper`, and the actions themselves are performed as soon as possible. However, the query can wait for these actions to be completed on all the replicas.
-
-For `ALTER ... ATTACH|DETACH|DROP` queries, you can use the `replication_alter_partitions_sync` setting to set up waiting. Possible values: `0` – do not wait; `1` – only wait for own execution (default); `2` – wait for all.
-
 ## Mutations {#mutations}

 `ALTER` queries that are intended to manipulate table data are implemented with a mechanism called “mutations”, most notably [ALTER TABLE … DELETE](../../../sql-reference/statements/alter/delete.md) and [ALTER TABLE … UPDATE](../../../sql-reference/statements/alter/update.md). They are asynchronous background processes similar to merges in [MergeTree](../../../engines/table-engines/mergetree-family/index.md) tables that to produce new “mutated” versions of parts.
@ -45,4 +39,12 @@ A mutation query returns immediately after the mutation entry is added (in case

 Entries for finished mutations are not deleted right away (the number of preserved entries is determined by the `finished_mutations_to_keep` storage engine parameter). Older mutation entries are deleted.

+## Synchronicity of ALTER Queries {#synchronicity-of-alter-queries}
+
+For non-replicated tables, all `ALTER` queries are performed synchronously. For replicated tables, the query just adds instructions for the appropriate actions to `ZooKeeper`, and the actions themselves are performed as soon as possible. However, the query can wait for these actions to be completed on all the replicas.
+
+For `ALTER ... ATTACH|DETACH|DROP` queries, you can use the `replication_alter_partitions_sync` setting to set up waiting. Possible values: `0` – do not wait; `1` – only wait for own execution (default); `2` – wait for all.
+
+For `ALTER TABLE ... UPDATE|DELETE` queries the synchronicity is defined by the [mutations_sync](../../../operations/settings/settings.md#mutations_sync) setting.
+
 [Original article](https://clickhouse.tech/docs/en/query_language/alter/) <!--hide-->
--- a/docs/en/sql-reference/statements/alter/update.md
+++ b/docs/en/sql-reference/statements/alter/update.md
@ -9,7 +9,7 @@ toc_title: UPDATE
 ALTER TABLE [db.]table UPDATE column1 = expr1 [, ...] WHERE filter_expr
 ```

-Allows to asynchronously manipulate data matching the specified filtering expression. Implemented as a [mutation](../../../sql-reference/statements/index.md#mutations).
+Allows to manipulate data matching the specified filtering expression. Implemented as a [mutation](../../../sql-reference/statements/alter/index.md#mutations).

 !!! note "Note"
    The `ALTER TABLE` prefix makes this syntax different from most other systems supporting SQL. It is intended to signify that unlike similar queries in OLTP databases this is a heavy operation not designed for frequent use.
@ -17,3 +17,12 @@ Allows to asynchronously manipulate data matching the specified filtering expres
 The `filter_expr` must be of type `UInt8`. This query updates values of specified columns to the values of corresponding expressions in rows for which the `filter_expr` takes a non-zero value. Values are casted to the column type using the `CAST` operator. Updating columns that are used in the calculation of the primary or the partition key is not supported.

 One query can contain several commands separated by commas.
+
+The synchronicity of the query processing is defined by the [mutations_sync](../../../operations/settings/settings.md#mutations_sync) setting. By default, it is asynchronous.
+
+**See also**
+
+-   [Mutations](../../../sql-reference/statements/alter/index.md#mutations)
+-   [Synchronicity of ALTER Queries](../../../sql-reference/statements/alter/index.md#synchronicity-of-alter-queries)
+-   [mutations_sync](../../../operations/settings/settings.md#mutations_sync) setting
+
--- a/docs/es/engines/table-engines/special/materializedview.md
+++ b/docs/es/engines/table-engines/special/materializedview.md
@ -7,6 +7,6 @@ toc_title: "M\xE9todo de codificaci\xF3n de datos:"

 # Método de codificación de datos: {#materializedview}

-Se utiliza para implementar vistas materializadas (para obtener más información, consulte [CREATE TABLE](../../../sql-reference/statements/create.md)). Para almacenar datos, utiliza un motor diferente que se especificó al crear la vista. Al leer desde una tabla, solo usa este motor.
+Se utiliza para implementar vistas materializadas (para obtener más información, consulte [CREATE TABLE](../../../sql-reference/statements/create.md#create-table-query)). Para almacenar datos, utiliza un motor diferente que se especificó al crear la vista. Al leer desde una tabla, solo usa este motor.

 [Artículo Original](https://clickhouse.tech/docs/en/operations/table_engines/materializedview/) <!--hide-->
--- a/docs/fa/engines/table-engines/special/materializedview.md
+++ b/docs/fa/engines/table-engines/special/materializedview.md
@ -7,6 +7,6 @@ toc_title: "\u0645\u0627\u062F\u0647 \u0628\u06CC\u0646\u06CC"

 # ماده بینی {#materializedview}

-مورد استفاده برای اجرای نمایش محقق (برای اطلاعات بیشتر, دیدن [CREATE TABLE](../../../sql-reference/statements/create.md)). برای ذخیره سازی داده ها از یک موتور مختلف استفاده می کند که هنگام ایجاد دیدگاه مشخص شده است. هنگام خواندن از یک جدول, فقط با استفاده از این موتور.
+مورد استفاده برای اجرای نمایش محقق (برای اطلاعات بیشتر, دیدن [CREATE TABLE](../../../sql-reference/statements/create.md#create-table-query)). برای ذخیره سازی داده ها از یک موتور مختلف استفاده می کند که هنگام ایجاد دیدگاه مشخص شده است. هنگام خواندن از یک جدول, فقط با استفاده از این موتور.

 [مقاله اصلی](https://clickhouse.tech/docs/en/operations/table_engines/materializedview/) <!--hide-->
--- a/docs/fr/engines/table-engines/special/materializedview.md
+++ b/docs/fr/engines/table-engines/special/materializedview.md
@ -7,6 +7,6 @@ toc_title: MaterializedView

 # Materializedview {#materializedview}

-Utilisé pour implémenter des vues matérialisées (pour plus d'informations, voir [CREATE TABLE](../../../sql-reference/statements/create.md)). Pour stocker des données, il utilise un moteur différent qui a été spécifié lors de la création de la vue. Lors de la lecture d'une table, il utilise juste ce moteur.
+Utilisé pour implémenter des vues matérialisées (pour plus d'informations, voir [CREATE TABLE](../../../sql-reference/statements/create.md#create-table-query)). Pour stocker des données, il utilise un moteur différent qui a été spécifié lors de la création de la vue. Lors de la lecture d'une table, il utilise juste ce moteur.

 [Article Original](https://clickhouse.tech/docs/en/operations/table_engines/materializedview/) <!--hide-->
--- a/docs/ja/engines/table-engines/special/materializedview.md
+++ b/docs/ja/engines/table-engines/special/materializedview.md
@ -7,6 +7,6 @@ toc_title: "\u30DE\u30C6\u30EA\u30A2\u30E9\u30A4\u30BA\u30C9\u30D3\u30E5\u30FC"

 # マテリアライズドビュー {#materializedview}

-マテリアライズドビューの実装に使用されます(詳細については、 [CREATE TABLE](../../../sql-reference/statements/create.md)). データを格納するために、ビューの作成時に指定された別のエンジンを使用します。 読み込み時にテーブルから、使用してこのエンジンです。
+マテリアライズドビューの実装に使用されます(詳細については、 [CREATE TABLE](../../../sql-reference/statements/create.md#create-table-query)). データを格納するために、ビューの作成時に指定された別のエンジンを使用します。 読み込み時にテーブルから、使用してこのエンジンです。

 [元の記事](https://clickhouse.tech/docs/en/operations/table_engines/materializedview/) <!--hide-->
--- a/docs/ru/engines/table-engines/special/materializedview.md
+++ b/docs/ru/engines/table-engines/special/materializedview.md
@ -1,5 +1,5 @@
 # MaterializedView {#materializedview}

-Используется для реализации материализованных представлений (подробнее см. запрос [CREATE TABLE](../../../engines/table-engines/special/materializedview.md)). Для хранения данных, использует другой движок, который был указан при создании представления. При чтении из таблицы, просто использует этот движок.
+Используется для реализации материализованных представлений (подробнее см. запрос [CREATE TABLE](../../../sql-reference/statements/create.md#create-table-query)). Для хранения данных, использует другой движок, который был указан при создании представления. При чтении из таблицы, просто использует этот движок.

 [Оригинальная статья](https://clickhouse.tech/docs/ru/operations/table_engines/materializedview/) <!--hide-->
--- a/docs/ru/guides/apply-catboost-model.md
+++ b/docs/ru/guides/apply-catboost-model.md
@ -227,4 +227,4 @@ FROM
 ```

 !!! note "Примечание"
-    Подробнее про функции [avg()](../sql-reference/aggregate-functions/reference.md#agg_function-avg), [log()](../sql-reference/functions/math-functions.md).
+    Подробнее про функции [avg()](../sql-reference/aggregate-functions/reference/avg.md#agg_function-avg), [log()](../sql-reference/functions/math-functions.md).
--- a/docs/ru/operations/settings/settings.md
+++ b/docs/ru/operations/settings/settings.md
@ -1012,15 +1012,15 @@ ClickHouse генерирует исключение

 ## count\_distinct\_implementation {#settings-count_distinct_implementation}

-Задаёт, какая из функций `uniq*` используется при выполнении конструкции [COUNT(DISTINCT …)](../../sql-reference/aggregate-functions/reference.md#agg_function-count).
+Задаёт, какая из функций `uniq*` используется при выполнении конструкции [COUNT(DISTINCT …)](../../sql-reference/aggregate-functions/reference/count.md#agg_function-count).

 Возможные значения:

-   [uniq](../../sql-reference/aggregate-functions/reference.md#agg_function-uniq)
-   [uniqCombined](../../sql-reference/aggregate-functions/reference.md#agg_function-uniqcombined)
-   [uniqCombined64](../../sql-reference/aggregate-functions/reference.md#agg_function-uniqcombined64)
-   [uniqHLL12](../../sql-reference/aggregate-functions/reference.md#agg_function-uniqhll12)
-   [uniqExact](../../sql-reference/aggregate-functions/reference.md#agg_function-uniqexact)
+-   [uniq](../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniq)
+-   [uniqCombined](../../sql-reference/aggregate-functions/reference/uniqcombined.md#agg_function-uniqcombined)
+-   [uniqCombined64](../../sql-reference/aggregate-functions/reference/uniqcombined64.md#agg_function-uniqcombined64)
+-   [uniqHLL12](../../sql-reference/aggregate-functions/reference/uniqhll12.md#agg_function-uniqhll12)
+-   [uniqExact](../../sql-reference/aggregate-functions/reference/uniqexact.md#agg_function-uniqexact)

 Значение по умолчанию: `uniqExact`.

@ -1480,4 +1480,21 @@ SELECT idx, i FROM null_in WHERE i IN (1, NULL) SETTINGS transform_null_in = 1;

 -   [min_insert_block_size_bytes](#min-insert-block-size-bytes)

+## mutations_sync {#mutations_sync}
+
+Позволяет выполнять запросы `ALTER TABLE ... UPDATE|DELETE` ([мутации](../../sql-reference/statements/alter.md#mutations)) синхронно.
+
+Возможные значения:
+
+-   0 - мутации выполняются асинхронно. 
+-   1 - запрос ждет завершения всех мутаций на текущем сервере. 
+-   2 - запрос ждет завершения всех мутаций на всех репликах (если они есть).
+
+Значение по умолчанию: `0`.
+
+**См. также**
+
+-   [Синхронность запросов ALTER](../../sql-reference/statements/alter.md#synchronicity-of-alter-queries)
+-   [Мутации](../../sql-reference/statements/alter.md#mutations)
+
 [Оригинальная статья](https://clickhouse.tech/docs/ru/operations/settings/settings/) <!--hide-->
--- a/docs/ru/sql-reference/aggregate-functions/combinators.md
+++ b/docs/ru/sql-reference/aggregate-functions/combinators.md
@ -23,7 +23,7 @@

 ## -State {#state}

-В случае применения этого комбинатора, агрегатная функция возвращает не готовое значение (например, в случае функции [uniq](reference.md#agg_function-uniq) — количество уникальных значений), а промежуточное состояние агрегации (например, в случае функции `uniq` — хэш-таблицу для расчёта количества уникальных значений), которое имеет тип `AggregateFunction(...)` и может использоваться для дальнейшей обработки или может быть сохранено в таблицу для последующей доагрегации.
+В случае применения этого комбинатора, агрегатная функция возвращает не готовое значение (например, в случае функции [uniq](reference/uniq.md#agg_function-uniq) — количество уникальных значений), а промежуточное состояние агрегации (например, в случае функции `uniq` — хэш-таблицу для расчёта количества уникальных значений), которое имеет тип `AggregateFunction(...)` и может использоваться для дальнейшей обработки или может быть сохранено в таблицу для последующей доагрегации.

 Для работы с промежуточными состояниями предназначены:

@ -206,7 +206,7 @@ FROM

 Получим имена людей, чей возраст находится в интервалах `[30,60)` и `[60,75)`. Поскольку мы используем целочисленное представление возраста, то интервалы будут выглядеть как `[30, 59]` и `[60,74]`.

-Чтобы собрать имена в массив, возьмём агрегатную функцию [groupArray](reference.md#agg_function-grouparray). Она принимает один аргумент. В нашем случае, это столбец `name`. Функция `groupArrayResample` должна использовать столбец `age` для агрегирования имён по возрасту. Чтобы определить необходимые интервалы, передадим в функцию `groupArrayResample` аргументы `30, 75, 30`.
+Чтобы собрать имена в массив, возьмём агрегатную функцию [groupArray](../../sql-reference/aggregate-functions/reference/grouparray.md#agg_function-grouparray). Она принимает один аргумент. В нашем случае, это столбец `name`. Функция `groupArrayResample` должна использовать столбец `age` для агрегирования имён по возрасту. Чтобы определить необходимые интервалы, передадим в функцию `groupArrayResample` аргументы `30, 75, 30`.

 ``` sql
 SELECT groupArrayResample(30, 75, 30)(name, age) from people
--- a/docs/ru/sql-reference/aggregate-functions/reference.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference.md
--- a/docs/ru/sql-reference/aggregate-functions/reference/any.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/any.md
@ -0,0 +1,13 @@
+---
+toc_priority: 6
+---
+
+# any {#agg_function-any}
+
+Выбирает первое попавшееся значение.
+Порядок выполнения запроса может быть произвольным и даже каждый раз разным, поэтому результат данной функции недетерминирован.
+Для получения детерминированного результата, можно использовать функции min или max вместо any.
+
+В некоторых случаях, вы всё-таки можете рассчитывать на порядок выполнения запроса. Это - случаи, когда SELECT идёт из подзапроса, в котором используется ORDER BY.
+
+При наличии в запросе `SELECT` секции `GROUP BY` или хотя бы одной агрегатной функции, ClickHouse (в отличие от, например, MySQL) требует, чтобы все выражения в секциях `SELECT`, `HAVING`, `ORDER BY` вычислялись из ключей или из агрегатных функций. То есть, каждый выбираемый из таблицы столбец, должен использоваться либо в ключах, либо внутри агрегатных функций. Чтобы получить поведение, как в MySQL, вы можете поместить остальные столбцы в агрегатную функцию `any`.
--- a/docs/ru/sql-reference/aggregate-functions/reference/anyheavy.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/anyheavy.md
@ -0,0 +1,30 @@
+---
+toc_priority: 103
+---
+
+# anyHeavy {#anyheavyx}
+
+Выбирает часто встречающееся значение с помощью алгоритма «[heavy hitters](http://www.cs.umd.edu/~samir/498/karp.pdf)». Если существует значение, которое встречается чаще, чем в половине случаев, в каждом потоке выполнения запроса, то возвращается данное значение. В общем случае, результат недетерминирован.
+
+``` sql
+anyHeavy(column)
+```
+
+**Аргументы**
+
+-   `column` — имя столбца.
+
+**Пример**
+
+Возьмём набор данных [OnTime](../../../getting-started/example-datasets/ontime.md) и выберем произвольное часто встречающееся значение в столбце `AirlineID`.
+
+``` sql
+SELECT anyHeavy(AirlineID) AS res
+FROM ontime
+```
+
+``` text
+┌───res─┐
+│ 19690 │
+└───────┘
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/anylast.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/anylast.md
@ -0,0 +1,8 @@
+---
+toc_priority: 104
+---
+
+## anyLast {#anylastx}
+
+Выбирает последнее попавшееся значение.
+Результат так же недетерминирован, как и для функции [any](../../../sql-reference/aggregate-functions/reference/any.md).
--- a/docs/ru/sql-reference/aggregate-functions/reference/argmax.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/argmax.md
@ -0,0 +1,9 @@
+---
+toc_priority: 106
+---
+
+# argMax {#agg-function-argmax}
+
+Синтаксис: `argMax(arg, val)`
+
+Вычисляет значение arg при максимальном значении val. Если есть несколько разных значений arg для максимальных значений val, то выдаётся первое попавшееся из таких значений.
--- a/docs/ru/sql-reference/aggregate-functions/reference/argmin.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/argmin.md
@ -0,0 +1,29 @@
+---
+toc_priority: 105
+---
+
+# argMin {#agg-function-argmin}
+
+Синтаксис: `argMin(arg, val)`
+
+Вычисляет значение arg при минимальном значении val. Если есть несколько разных значений arg для минимальных значений val, то выдаётся первое попавшееся из таких значений.
+
+**Пример:**
+
+``` text
+┌─user─────┬─salary─┐
+│ director │   5000 │
+│ manager  │   3000 │
+│ worker   │   1000 │
+└──────────┴────────┘
+```
+
+``` sql
+SELECT argMin(user, salary) FROM salary
+```
+
+``` text
+┌─argMin(user, salary)─┐
+│ worker               │
+└──────────────────────┘
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/avg.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/avg.md
@ -0,0 +1,9 @@
+---
+toc_priority: 5
+---
+
+# avg {#agg_function-avg}
+
+Вычисляет среднее.
+Работает только для чисел.
+Результат всегда Float64.
--- a/docs/ru/sql-reference/aggregate-functions/reference/avgweighted.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/avgweighted.md
@ -0,0 +1,44 @@
+---
+toc_priority: 107
+---
+
+# avgWeighted {#avgweighted}
+
+Вычисляет [среднее арифметическое взвешенное](https://ru.wikipedia.org/wiki/Среднее_арифметическое_взвешенное).
+
+**Синтаксис**
+
+``` sql
+avgWeighted(x, weight)
+```
+
+**Параметры**
+
+-   `x` — Значения. [Целые числа](../../../sql-reference/data-types/int-uint.md) или [числа с плавающей запятой](../../../sql-reference/data-types/float.md).
+-   `weight` — Веса отдельных значений. [Целые числа](../../../sql-reference/data-types/int-uint.md) или [числа с плавающей запятой](../../../sql-reference/data-types/float.md).
+
+Типы параметров должны совпадать.
+
+**Возвращаемое значение**
+
+-   Среднее арифметическое взвешенное.
+-   `NaN`, если все веса равны 0.
+
+Тип: [Float64](../../../sql-reference/data-types/float.md)
+
+**Пример**
+
+Запрос:
+
+``` sql
+SELECT avgWeighted(x, w)
+FROM values('x Int8, w Int8', (4, 1), (1, 0), (10, 2))
+```
+
+Результат:
+
+``` text
+┌─avgWeighted(x, weight)─┐
+│                      8 │
+└────────────────────────┘
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/corr.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/corr.md
@ -0,0 +1,12 @@
+---
+toc_priority: 107
+---
+
+# corr {#corrx-y}
+
+Синтаксис: `corr(x, y)`
+
+Вычисляет коэффициент корреляции Пирсона: `Σ((x - x̅)(y - y̅)) / sqrt(Σ((x - x̅)^2) * Σ((y - y̅)^2))`.
+
+!!! note "Примечание"
+    Функция использует вычислительно неустойчивый алгоритм. Если для ваших расчётов необходима [вычислительная устойчивость](https://ru.wikipedia.org/wiki/Вычислительная_устойчивость), используйте функцию `corrStable`. Она работает медленнее, но обеспечивает меньшую вычислительную ошибку.
--- a/docs/ru/sql-reference/aggregate-functions/reference/count.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/count.md
@ -0,0 +1,70 @@
+---
+toc_priority: 1
+---
+
+# count {#agg_function-count}
+
+Вычисляет количество строк или не NULL значений .
+
+ClickHouse поддерживает следующие виды синтаксиса для `count`:
+
+-   `count(expr)` или `COUNT(DISTINCT expr)`.
+-   `count()` или `COUNT(*)`. Синтаксис `count()` специфичен для ClickHouse.
+
+**Параметры**
+
+Функция может принимать:
+
+-   Ноль параметров.
+-   Одно [выражение](../../syntax.md#syntax-expressions).
+
+**Возвращаемое значение**
+
+-   Если функция вызывается без параметров, она вычисляет количество строк.
+-   Если передаётся [выражение](../../syntax.md#syntax-expressions) , то функция вычисляет количество раз, когда выражение возвращает не NULL. Если выражение возвращает значение типа [Nullable](../../../sql-reference/data-types/nullable.md), то результат `count` не становится `Nullable`. Функция возвращает 0, если выражение возвращает `NULL` для всех строк.
+
+В обоих случаях тип возвращаемого значения [UInt64](../../../sql-reference/data-types/int-uint.md).
+
+**Подробности**
+
+ClickHouse поддерживает синтаксис `COUNT(DISTINCT ...)`. Поведение этой конструкции зависит от настройки [count\_distinct\_implementation](../../../operations/settings/settings.md#settings-count_distinct_implementation). Она определяет, какая из функций [uniq\*](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniq) используется для выполнения операции. По умолчанию — функция [uniqExact](../../../sql-reference/aggregate-functions/reference/uniqexact.md#agg_function-uniqexact).
+
+Запрос `SELECT count() FROM table` не оптимизирован, поскольку количество записей в таблице не хранится отдельно. Он выбирает небольшой столбец из таблицы и подсчитывает количество значений в нём.
+
+**Примеры**
+
+Пример 1:
+
+``` sql
+SELECT count() FROM t
+```
+
+``` text
+┌─count()─┐
+│       5 │
+└─────────┘
+```
+
+Пример 2:
+
+``` sql
+SELECT name, value FROM system.settings WHERE name = 'count_distinct_implementation'
+```
+
+``` text
+┌─name──────────────────────────┬─value─────┐
+│ count_distinct_implementation │ uniqExact │
+└───────────────────────────────┴───────────┘
+```
+
+``` sql
+SELECT count(DISTINCT num) FROM t
+```
+
+``` text
+┌─uniqExact(num)─┐
+│              3 │
+└────────────────┘
+```
+
+Этот пример показывает, что `count(DISTINCT num)` выполняется с помощью функции `uniqExact` в соответствии со значением настройки `count_distinct_implementation`.
--- a/docs/ru/sql-reference/aggregate-functions/reference/covarpop.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/covarpop.md
@ -0,0 +1,12 @@
+---
+toc_priority: 36
+---
+
+# covarPop {#covarpop}
+
+Синтаксис: `covarPop(x, y)`
+
+Вычисляет величину `Σ((x - x̅)(y - y̅)) / n`.
+
+!!! note "Примечание"
+    Функция использует вычислительно неустойчивый алгоритм. Если для ваших расчётов необходима [вычислительная устойчивость](https://ru.wikipedia.org/wiki/Вычислительная_устойчивость), используйте функцию `covarPopStable`. Она работает медленнее, но обеспечивает меньшую вычислительную ошибку.
--- a/docs/ru/sql-reference/aggregate-functions/reference/covarsamp.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/covarsamp.md
@ -0,0 +1,14 @@
+---
+toc_priority: 37
+---
+
+# covarSamp {#covarsamp}
+
+Синтаксис: `covarSamp(x, y)`
+
+Вычисляет величину `Σ((x - x̅)(y - y̅)) / (n - 1)`.
+
+Возвращает Float64. В случае, когда `n <= 1`, возвращается +∞.
+
+!!! note "Примечание"
+    Функция использует вычислительно неустойчивый алгоритм. Если для ваших расчётов необходима [вычислительная устойчивость](https://ru.wikipedia.org/wiki/Вычислительная_устойчивость), используйте функцию `covarSampStable`. Она работает медленнее, но обеспечивает меньшую вычислительную ошибку.
--- a/docs/ru/sql-reference/aggregate-functions/reference/grouparray.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/grouparray.md
@ -0,0 +1,15 @@
+---
+toc_priority: 110
+---
+
+# groupArray {#agg_function-grouparray}
+
+Синтаксис: `groupArray(x)` или `groupArray(max_size)(x)`
+
+Составляет массив из значений аргумента.
+Значения в массив могут быть добавлены в любом (недетерминированном) порядке.
+
+Вторая версия (с параметром `max_size`) ограничивает размер результирующего массива `max_size` элементами.
+Например, `groupArray(1)(x)` эквивалентно `[any(x)]`.
+
+В некоторых случаях, вы всё же можете рассчитывать на порядок выполнения запроса. Это — случаи, когда `SELECT` идёт из подзапроса, в котором используется `ORDER BY`.
--- a/docs/ru/sql-reference/aggregate-functions/reference/grouparrayinsertat.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/grouparrayinsertat.md
@ -0,0 +1,91 @@
+---
+toc_priority: 112
+---
+
+# groupArrayInsertAt {#grouparrayinsertat}
+
+Вставляет значение в заданную позицию массива.
+
+**Синтаксис**
+
+```sql
+groupArrayInsertAt(default_x, size)(x, pos);
+```
+
+Если запрос вставляет вставляется несколько значений в одну и ту же позицию, то функция ведет себя следующим образом:
+
+- Если запрос выполняется в одном потоке, то используется первое из вставляемых значений.
+- Если запрос выполняется в нескольких потоках, то в результирующем массиве может оказаться любое из вставляемых значений.
+
+**Параметры**
+
+- `x` — Значение, которое будет вставлено. [Выражение](../../syntax.md#syntax-expressions), возвращающее значение одного из [поддерживаемых типов данных](../../../sql-reference/data-types/index.md#data_types).
+- `pos` — Позиция, в которую вставляется заданный элемент `x`. Нумерация индексов в массиве начинается с нуля. [UInt32](../../../sql-reference/data-types/int-uint.md#uint8-uint16-uint32-uint64-int8-int16-int32-int64).
+- `default_x` — Значение по умолчанию для подстановки на пустые позиции. Опциональный параметр. [Выражение](../../syntax.md#syntax-expressions), возвращающее значение с типом параметра `x`. Если `default_x` не определен, используются [значения по умолчанию](../../../sql-reference/statements/create.md#create-default-values).
+- `size`— Длина результирующего массива. Опциональный параметр. При использовании этого параметра должно быть указано значение по умолчанию `default_x`. [UInt32](../../../sql-reference/data-types/int-uint.md#uint-ranges).
+
+**Возвращаемое значение**
+
+- Массив со вставленными значениями.
+
+Тип: [Array](../../../sql-reference/data-types/array.md#data-type-array).
+
+**Примеры**
+
+Запрос:
+
+```sql
+SELECT groupArrayInsertAt(toString(number), number * 2) FROM numbers(5);
+```
+
+Результат:
+
+```text
+┌─groupArrayInsertAt(toString(number), multiply(number, 2))─┐
+│ ['0','','1','','2','','3','','4']                         │
+└───────────────────────────────────────────────────────────┘
+```
+
+Запрос:
+
+```sql
+SELECT groupArrayInsertAt('-')(toString(number), number * 2) FROM numbers(5);
+```
+
+Результат:
+
+```text
+┌─groupArrayInsertAt('-')(toString(number), multiply(number, 2))─┐
+│ ['0','-','1','-','2','-','3','-','4']                          │
+└────────────────────────────────────────────────────────────────┘
+```
+
+Запрос:
+
+```sql
+SELECT groupArrayInsertAt('-', 5)(toString(number), number * 2) FROM numbers(5);
+```
+
+Результат:
+
+```text
+┌─groupArrayInsertAt('-', 5)(toString(number), multiply(number, 2))─┐
+│ ['0','-','1','-','2']                                             │
+└───────────────────────────────────────────────────────────────────┘
+```
+
+Многопоточная вставка элементов в одну позицию.
+
+Запрос:
+
+```sql
+SELECT groupArrayInsertAt(number, 0) FROM numbers_mt(10) SETTINGS max_block_size = 1;
+```
+
+В результат этого запроса мы получите случайное целое число в диапазоне `[0,9]`. Например:
+
+```text
+┌─groupArrayInsertAt(number, 0)─┐
+│ [7]                           │
+└───────────────────────────────┘
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/grouparraymovingavg.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/grouparraymovingavg.md
@ -0,0 +1,76 @@
+---
+toc_priority: 114
+---
+
+# groupArrayMovingAvg {#agg_function-grouparraymovingavg}
+
+Вычисляет скользящее среднее для входных значений.
+
+    groupArrayMovingAvg(numbers_for_summing)
+    groupArrayMovingAvg(window_size)(numbers_for_summing)
+
+Функция может принимать размер окна в качестве параметра. Если окно не указано, то функция использует размер окна, равный количеству строк в столбце.
+
+**Параметры**
+
+-   `numbers_for_summing` — [выражение](../../syntax.md#syntax-expressions), возвращающее значение числового типа.
+-   `window_size` — размер окна.
+
+**Возвращаемые значения**
+
+-   Массив того же размера и типа, что и входные данные.
+
+Функция использует [округление к меньшему по модулю](https://ru.wikipedia.org/wiki/Округление#Методы). Оно усекает десятичные разряды, незначимые для результирующего типа данных.
+
+**Пример**
+
+Таблица с исходными данными:
+
+``` sql
+CREATE TABLE t
+(
+    `int` UInt8,
+    `float` Float32,
+    `dec` Decimal32(2)
+)
+ENGINE = TinyLog
+```
+
+``` text
+┌─int─┬─float─┬──dec─┐
+│   1 │   1.1 │ 1.10 │
+│   2 │   2.2 │ 2.20 │
+│   4 │   4.4 │ 4.40 │
+│   7 │  7.77 │ 7.77 │
+└─────┴───────┴──────┘
+```
+
+Запросы:
+
+``` sql
+SELECT
+    groupArrayMovingAvg(int) AS I,
+    groupArrayMovingAvg(float) AS F,
+    groupArrayMovingAvg(dec) AS D
+FROM t
+```
+
+``` text
+┌─I─────────┬─F───────────────────────────────────┬─D─────────────────────┐
+│ [0,0,1,3] │ [0.275,0.82500005,1.9250001,3.8675] │ [0.27,0.82,1.92,3.86] │
+└───────────┴─────────────────────────────────────┴───────────────────────┘
+```
+
+``` sql
+SELECT
+    groupArrayMovingAvg(2)(int) AS I,
+    groupArrayMovingAvg(2)(float) AS F,
+    groupArrayMovingAvg(2)(dec) AS D
+FROM t
+```
+
+``` text
+┌─I─────────┬─F────────────────────────────────┬─D─────────────────────┐
+│ [0,1,3,5] │ [0.55,1.6500001,3.3000002,6.085] │ [0.55,1.65,3.30,6.08] │
+└───────────┴──────────────────────────────────┴───────────────────────┘
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/grouparraymovingsum.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/grouparraymovingsum.md
@ -0,0 +1,76 @@
+---
+toc_priority: 113
+---
+
+# groupArrayMovingSum {#agg_function-grouparraymovingsum}
+
+Вычисляет скользящую сумму входных значений.
+
+``` sql
+groupArrayMovingSum(numbers_for_summing)
+groupArrayMovingSum(window_size)(numbers_for_summing)
+```
+
+Функция может принимать размер окна в качестве параметра. Если окно не указано, то функция использует размер окна, равный количеству строк в столбце.
+
+**Параметры**
+
+-   `numbers_for_summing` — [выражение](../../syntax.md#syntax-expressions), возвращающее значение числового типа.
+-   `window_size` — размер окна.
+
+**Возвращаемые значения**
+
+-   Массив того же размера и типа, что и входные данные.
+
+**Пример**
+
+Таблица с исходными данными:
+
+``` sql
+CREATE TABLE t
+(
+    `int` UInt8,
+    `float` Float32,
+    `dec` Decimal32(2)
+)
+ENGINE = TinyLog
+```
+
+``` text
+┌─int─┬─float─┬──dec─┐
+│   1 │   1.1 │ 1.10 │
+│   2 │   2.2 │ 2.20 │
+│   4 │   4.4 │ 4.40 │
+│   7 │  7.77 │ 7.77 │
+└─────┴───────┴──────┘
+```
+
+Запросы:
+
+``` sql
+SELECT
+    groupArrayMovingSum(int) AS I,
+    groupArrayMovingSum(float) AS F,
+    groupArrayMovingSum(dec) AS D
+FROM t
+```
+
+``` text
+┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐
+│ [1,3,7,14] │ [1.1,3.3000002,7.7000003,15.47] │ [1.10,3.30,7.70,15.47] │
+└────────────┴─────────────────────────────────┴────────────────────────┘
+```
+
+``` sql
+SELECT
+    groupArrayMovingSum(2)(int) AS I,
+    groupArrayMovingSum(2)(float) AS F,
+    groupArrayMovingSum(2)(dec) AS D
+FROM t
+```
+
+``` text
+┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐
+│ [1,3,6,11] │ [1.1,3.3000002,6.6000004,12.17] │ [1.10,3.30,6.60,12.17] │
+└────────────┴─────────────────────────────────┴────────────────────────┘
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/groupbitand.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/groupbitand.md
@ -0,0 +1,46 @@
+---
+toc_priority: 125
+---
+
+# groupBitAnd {#groupbitand}
+
+Применяет побитовое `И` для последовательности чисел.
+
+``` sql
+groupBitAnd(expr)
+```
+
+**Параметры**
+
+`expr` – выражение, результат которого имеет тип данных `UInt*`.
+
+**Возвращаемое значение**
+
+Значение типа `UInt*`.
+
+**Пример**
+
+Тестовые данные:
+
+``` text
+binary     decimal
+00101100 = 44
+00011100 = 28
+00001101 = 13
+01010101 = 85
+```
+
+Запрос:
+
+``` sql
+SELECT groupBitAnd(num) FROM t
+```
+
+Где `num` — столбец с тестовыми данными.
+
+Результат:
+
+``` text
+binary     decimal
+00000100 = 4
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/groupbitmap.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/groupbitmap.md
@ -0,0 +1,44 @@
+---
+toc_priority: 128
+---
+
+# groupBitmap {#groupbitmap}
+
+Bitmap или агрегатные вычисления для столбца с типом данных `UInt*`, возвращают кардинальность в виде значения типа UInt64, если добавить суффикс -State, то возвращают [объект bitmap](../../../sql-reference/functions/bitmap-functions.md).
+
+``` sql
+groupBitmap(expr)
+```
+
+**Параметры**
+
+`expr` – выражение, результат которого имеет тип данных `UInt*`.
+
+**Возвращаемое значение**
+
+Значение типа `UInt64`.
+
+**Пример**
+
+Тестовые данные:
+
+``` text
+UserID
+1
+1
+2
+3
+```
+
+Запрос:
+
+``` sql
+SELECT groupBitmap(UserID) as num FROM t
+```
+
+Результат:
+
+``` text
+num
+3
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/groupbitor.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/groupbitor.md
@ -0,0 +1,46 @@
+---
+toc_priority: 126
+---
+
+# groupBitOr {#groupbitor}
+
+Применяет побитовое `ИЛИ` для последовательности чисел.
+
+``` sql
+groupBitOr(expr)
+```
+
+**Параметры**
+
+`expr` – выражение, результат которого имеет тип данных `UInt*`.
+
+**Возвращаемое значение**
+
+Значение типа `UInt*`.
+
+**Пример**
+
+Тестовые данные:
+
+``` text
+binary     decimal
+00101100 = 44
+00011100 = 28
+00001101 = 13
+01010101 = 85
+```
+
+Запрос:
+
+``` sql
+SELECT groupBitOr(num) FROM t
+```
+
+Где `num` — столбец с тестовыми данными.
+
+Результат:
+
+``` text
+binary     decimal
+01111101 = 125
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/groupbitxor.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/groupbitxor.md
@ -0,0 +1,46 @@
+---
+toc_priority: 127
+---
+
+# groupBitXor {#groupbitxor}
+
+Применяет побитовое `ИСКЛЮЧАЮЩЕЕ ИЛИ` для последовательности чисел.
+
+``` sql
+groupBitXor(expr)
+```
+
+**Параметры**
+
+`expr` – выражение, результат которого имеет тип данных `UInt*`.
+
+**Возвращаемое значение**
+
+Значение типа `UInt*`.
+
+**Пример**
+
+Тестовые данные:
+
+``` text
+binary     decimal
+00101100 = 44
+00011100 = 28
+00001101 = 13
+01010101 = 85
+```
+
+Запрос:
+
+``` sql
+SELECT groupBitXor(num) FROM t
+```
+
+Где `num` — столбец с тестовыми данными.
+
+Результат:
+
+``` text
+binary     decimal
+01101000 = 104
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/groupuniqarray.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/groupuniqarray.md
@ -0,0 +1,12 @@
+---
+toc_priority: 111
+---
+
+# groupUniqArray {#groupuniqarray}
+
+Синтаксис: `groupUniqArray(x)` или `groupUniqArray(max_size)(x)`
+
+Составляет массив из различных значений аргумента. Расход оперативной памяти такой же, как у функции `uniqExact`.
+
+Функция `groupUniqArray(max_size)(x)` ограничивает размер результирующего массива до `max_size` элементов. Например, `groupUniqArray(1)(x)` равнозначно `[any(x)]`.
+
--- a/docs/ru/sql-reference/aggregate-functions/reference/index.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/index.md
@ -0,0 +1,108 @@
+---
+toc_folder_title: Reference
+toc_priority: 36
+toc_title: Reference
+---
+
+# Aggregate Function Reference {#aggregate-functions-reference}
+
+Стандартные агрегатные функции:
+
+-   [count](../../../sql-reference/aggregate-functions/reference/count.md)
+-   [min](../../../sql-reference/aggregate-functions/reference/min.md)
+-   [max](../../../sql-reference/aggregate-functions/reference/max.md)
+-   [sum](../../../sql-reference/aggregate-functions/reference/sum.md)
+-   [avg](../../../sql-reference/aggregate-functions/reference/avg.md)
+-   [any](../../../sql-reference/aggregate-functions/reference/any.md)
+-   [stddevPop](../../../sql-reference/aggregate-functions/reference/stddevpop.md)
+-   [stddevSamp](../../../sql-reference/aggregate-functions/reference/stddevsamp.md)
+-   [varPop](../../../sql-reference/aggregate-functions/reference/varpop.md)
+-   [varSamp](../../../sql-reference/aggregate-functions/reference/varsamp.md)
+-   [covarPop](../../../sql-reference/aggregate-functions/reference/covarpop.md)
+-   [covarSamp](../../../sql-reference/aggregate-functions/reference/covarsamp.md)
+
+Агрегатные функции, специфичные для ClickHouse:
+
+-   [anyHeavy](../../../sql-reference/aggregate-functions/reference/anyheavy.md)
+
+-   [anyLast](../../../sql-reference/aggregate-functions/reference/anylast.md)
+
+-   [argMin](../../../sql-reference/aggregate-functions/reference/argmin.md)
+
+-   [argMax](../../../sql-reference/aggregate-functions/reference/argmax.md)
+
+-   [avgWeighted](../../../sql-reference/aggregate-functions/reference/avgweighted.md)
+
+-   [topK](../../../sql-reference/aggregate-functions/reference/topkweighted.md)
+
+-   [topKWeighted](../../../sql-reference/aggregate-functions/reference/topkweighted.md)
+
+-   [groupArray](../../../sql-reference/aggregate-functions/reference/grouparray.md)
+
+-   [groupUniqArray](../../../sql-reference/aggregate-functions/reference/groupuniqarray.md)
+
+-   [groupArrayInsertAt](../../../sql-reference/aggregate-functions/reference/grouparrayinsertat.md)
+
+-   [groupArrayMovingAvg](../../../sql-reference/aggregate-functions/reference/grouparraymovingavg.md)
+
+-   [groupArrayMovingSum](../../../sql-reference/aggregate-functions/reference/grouparraymovingsum.md)
+
+-   [groupBitAnd](../../../sql-reference/aggregate-functions/reference/groupbitand.md)
+
+-   [groupBitOr](../../../sql-reference/aggregate-functions/reference/groupbitor.md)
+
+-   [groupBitXor](../../../sql-reference/aggregate-functions/reference/groupbitxor.md)
+
+-   [groupBitmap](../../../sql-reference/aggregate-functions/reference/groupbitmap.md)
+
+-   [sumWithOverflow](../../../sql-reference/aggregate-functions/reference/sumwithoverflow.md)
+
+-   [sumMap](../../../sql-reference/aggregate-functions/reference/summap.md)
+
+-   [skewSamp](../../../sql-reference/aggregate-functions/reference/skewsamp.md)
+
+-   [skewPop](../../../sql-reference/aggregate-functions/reference/skewpop.md)
+
+-   [kurtSamp](../../../sql-reference/aggregate-functions/reference/kurtsamp.md)
+
+-   [kurtPop](../../../sql-reference/aggregate-functions/reference/kurtpop.md)
+
+-   [timeSeriesGroupSum](../../../sql-reference/aggregate-functions/reference/timeseriesgroupsum.md)
+
+-   [timeSeriesGroupRateSum](../../../sql-reference/aggregate-functions/reference/timeseriesgroupratesum.md)
+
+-   [uniq](../../../sql-reference/aggregate-functions/reference/uniq.md)
+
+-   [uniqExact](../../../sql-reference/aggregate-functions/reference/uniqexact.md)
+
+-   [uniqCombined](../../../sql-reference/aggregate-functions/reference/uniqcombined.md)
+
+-   [uniqCombined64](../../../sql-reference/aggregate-functions/reference/uniqcombined64.md)
+
+-   [uniqHLL12](../../../sql-reference/aggregate-functions/reference/uniqhll12.md)
+
+-   [quantile](../../../sql-reference/aggregate-functions/reference/quantile.md)
+
+-   [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md)
+
+-   [quantileExact](../../../sql-reference/aggregate-functions/reference/quantileexact.md)
+
+-   [quantileExactWeighted](../../../sql-reference/aggregate-functions/reference/quantileexactweighted.md)
+
+-   [quantileTiming](../../../sql-reference/aggregate-functions/reference/quantiletiming.md)
+
+-   [quantileTimingWeighted](../../../sql-reference/aggregate-functions/reference/quantiletimingweighted.md)
+
+-   [quantileDeterministic](../../../sql-reference/aggregate-functions/reference/quantiledeterministic.md)
+
+-   [quantileTDigest](../../../sql-reference/aggregate-functions/reference/quantiletdigest.md)
+
+-   [quantileTDigestWeighted](../../../sql-reference/aggregate-functions/reference/quantiletdigestweighted.md)
+
+-   [simpleLinearRegression](../../../sql-reference/aggregate-functions/reference/simplelinearregression.md)
+
+-   [stochasticLinearRegression](../../../sql-reference/aggregate-functions/reference/stochasticlinearregression.md)
+
+-   [stochasticLogisticRegression](../../../sql-reference/aggregate-functions/reference/stochasticlogisticregression.md)
+
+[Original article](https://clickhouse.tech/docs/en/sql-reference/aggregate-functions/reference/) <!--hide-->
--- a/docs/ru/sql-reference/aggregate-functions/reference/kurtpop.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/kurtpop.md
@ -0,0 +1,25 @@
+---
+toc_priority: 153
+---
+
+# kurtPop {#kurtpop}
+
+Вычисляет [коэффициент эксцесса](https://ru.wikipedia.org/wiki/Коэффициент_эксцесса) последовательности.
+
+``` sql
+kurtPop(expr)
+```
+
+**Параметры**
+
+`expr` — [Выражение](../../syntax.md#syntax-expressions), возвращающее число.
+
+**Возвращаемое значение**
+
+Коэффициент эксцесса заданного распределения. Тип — [Float64](../../../sql-reference/data-types/float.md)
+
+**Пример**
+
+``` sql
+SELECT kurtPop(value) FROM series_with_value_column
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/kurtsamp.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/kurtsamp.md
@ -0,0 +1,27 @@
+---
+toc_priority: 154
+---
+
+# kurtSamp {#kurtsamp}
+
+Вычисляет [выборочный коэффициент эксцесса](https://ru.wikipedia.org/wiki/Статистика_(функция_выборки)) для последовательности.
+
+Он представляет собой несмещенную оценку эксцесса случайной величины, если переданные значения образуют ее выборку.
+
+``` sql
+kurtSamp(expr)
+```
+
+**Параметры**
+
+`expr` — [Выражение](../../syntax.md#syntax-expressions), возвращающее число.
+
+**Возвращаемое значение**
+
+Коэффициент эксцесса заданного распределения. Тип — [Float64](../../../sql-reference/data-types/float.md). Если `n <= 1` (`n` — размер выборки), тогда функция возвращает `nan`.
+
+**Пример**
+
+``` sql
+SELECT kurtSamp(value) FROM series_with_value_column
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/max.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/max.md
@ -0,0 +1,7 @@
+---
+toc_priority: 3
+---
+
+# max {#agg_function-max}
+
+Вычисляет максимум.
--- a/docs/ru/sql-reference/aggregate-functions/reference/median.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/median.md
@ -0,0 +1,41 @@
+# median {#median}
+
+Функции `median*` — алиасы для соответствущих функций `quantile*`. Они вычисляют медиану числовой последовательности.
+
+Functions:
+
+-   `median` — алиас [quantile](#quantile).
+-   `medianDeterministic` — алиас [quantileDeterministic](#quantiledeterministic).
+-   `medianExact` — алиас [quantileExact](#quantileexact).
+-   `medianExactWeighted` — алиас [quantileExactWeighted](#quantileexactweighted).
+-   `medianTiming` — алиас [quantileTiming](#quantiletiming).
+-   `medianTimingWeighted` — алиас [quantileTimingWeighted](#quantiletimingweighted).
+-   `medianTDigest` — алиас [quantileTDigest](#quantiletdigest).
+-   `medianTDigestWeighted` — алиас [quantileTDigestWeighted](#quantiletdigestweighted).
+
+**Пример**
+
+Входная таблица:
+
+``` text
+┌─val─┐
+│   1 │
+│   1 │
+│   2 │
+│   3 │
+└─────┘
+```
+
+Запрос:
+
+``` sql
+SELECT medianDeterministic(val, 1) FROM t
+```
+
+Результат:
+
+``` text
+┌─medianDeterministic(val, 1)─┐
+│                         1.5 │
+└─────────────────────────────┘
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/min.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/min.md
@ -0,0 +1,7 @@
+---
+toc_priority: 2
+---
+
+## min {#agg_function-min}
+
+Вычисляет минимум.
--- a/docs/ru/sql-reference/aggregate-functions/reference/quantile.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/quantile.md
@ -0,0 +1,66 @@
+---
+toc_priority: 200
+---
+
+# quantile {#quantile}
+
+Приблизительно вычисляет [квантиль](https://ru.wikipedia.org/wiki/Квантиль) числовой последовательности.
+
+Функция использует алгоритм [reservoir sampling](https://en.wikipedia.org/wiki/Reservoir_sampling) с размером резервуара до 8192 и случайным генератором чисел для для сэмплирования. Результат не детерминирован. Чтобы получить точную квантиль используйте функцию [quantileExact](#quantileexact).
+
+Внутренние состояния функций `quantile*` не объединяются, если они используются в одном запросе. Если вам необходимо вычислить квантили нескольких уровней, используйте функцию [quantiles](#quantiles), это повысит эффективность запроса.
+
+**Синтаксис**
+
+``` sql
+quantile(level)(expr)
+```
+
+Алиас: `median`.
+
+**Параметры**
+
+-   `level` — Уровень квантили. Опционально. Константное значение с плавающей запятой от 0 до 1. Мы рекомендуем использовать значение `level` из диапазона `[0.01, 0.99]`. Значение по умолчанию: 0.5. При `level=0.5` функция вычисляет [медиану](https://ru.wikipedia.org/wiki/Медиана_(статистика)).
+-   `expr` — Выражение над значениями столбца, которое возвращает данные [числовых типов](../../../sql-reference/data-types/index.md#data_types) или типов [Date](../../../sql-reference/data-types/date.md), [DateTime](../../../sql-reference/data-types/datetime.md).
+
+**Возвращаемое значение**
+
+-   Приблизительный квантиль заданного уровня.
+
+Тип:
+
+-   [Float64](../../../sql-reference/data-types/float.md) для входных данных числового типа.
+-   [Date](../../../sql-reference/data-types/date.md), если входные значения имеют тип `Date`.
+-   [DateTime](../../../sql-reference/data-types/datetime.md), если входные значения имеют тип `DateTime`.
+
+**Пример**
+
+Входная таблица:
+
+``` text
+┌─val─┐
+│   1 │
+│   1 │
+│   2 │
+│   3 │
+└─────┘
+```
+
+Запрос:
+
+``` sql
+SELECT quantile(val) FROM t
+```
+
+Результат:
+
+``` text
+┌─quantile(val)─┐
+│           1.5 │
+└───────────────┘
+```
+
+**Смотрите также**
+
+-   [median](../../../sql-reference/aggregate-functions/reference/median.md#median)
+-   [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md#quantiles)
--- a/docs/ru/sql-reference/aggregate-functions/reference/quantiledeterministic.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/quantiledeterministic.md
@ -0,0 +1,66 @@
+---
+toc_priority: 206
+---
+
+# quantileDeterministic {#quantiledeterministic}
+
+Приблизительно вычисляет [квантиль](https://ru.wikipedia.org/wiki/Квантиль) числовой последовательности.
+
+Функция использует алгоритм [reservoir sampling](https://en.wikipedia.org/wiki/Reservoir_sampling) с размером резервуара до 8192 и детерминированным алгоритмом сэмплирования. Результат детерминирован. Чтобы получить точную квантиль используйте функцию [quantileExact](#quantileexact).
+
+Внутренние состояния функций `quantile*` не объединяются, если они используются в одном запросе. Если вам необходимо вычислить квантили нескольких уровней, используйте функцию [quantiles](#quantiles), это повысит эффективность запроса.
+
+**Синтаксис**
+
+``` sql
+quantileDeterministic(level)(expr, determinator)
+```
+
+Алиас: `medianDeterministic`.
+
+**Параметры**
+
+-   `level` — Уровень квантили. Опционально. Константное значение с плавающей запятой от 0 до 1. Мы рекомендуем использовать значение `level` из диапазона `[0.01, 0.99]`. Значение по умолчанию: 0.5. При `level=0.5` функция вычисляет [медиану](https://ru.wikipedia.org/wiki/Медиана_(статистика)).
+-   `expr` — Выражение над значениями столбца, которое возвращает данные [числовых типов](../../../sql-reference/data-types/index.md#data_types) или типов [Date](../../../sql-reference/data-types/date.md), [DateTime](../../../sql-reference/data-types/datetime.md).
+-   `determinator` — Число, хэш которого используется при сэмплировании в алгоритме reservoir sampling, чтобы сделать результат детерминированным. В качестве детерминатора можно использовать любое определённое положительное число, например, идентификатор пользователя или события. Если одно и то же значение детерминатора попадается в выборке слишком часто, то функция выдаёт некорректный результат.
+
+**Возвращаемое значение**
+
+-   Приблизительный квантиль заданного уровня.
+
+Тип:
+
+-   [Float64](../../../sql-reference/data-types/float.md) для входных данных числового типа.
+-   [Date](../../../sql-reference/data-types/date.md), если входные значения имеют тип `Date`.
+-   [DateTime](../../../sql-reference/data-types/datetime.md), если входные значения имеют тип `DateTime`.
+**Пример**
+
+Входная таблица:
+
+``` text
+┌─val─┐
+│   1 │
+│   1 │
+│   2 │
+│   3 │
+└─────┘
+```
+
+Запрос:
+
+``` sql
+SELECT quantileDeterministic(val, 1) FROM t
+```
+
+Результат:
+
+``` text
+┌─quantileDeterministic(val, 1)─┐
+│                           1.5 │
+└───────────────────────────────┘
+```
+
+**Смотрите также**
+
+-   [median](../../../sql-reference/aggregate-functions/reference/median.md#median)
+-   [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md#quantiles)
--- a/docs/ru/sql-reference/aggregate-functions/reference/quantileexact.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/quantileexact.md
@ -0,0 +1,54 @@
+---
+toc_priority: 202
+---
+
+# quantileExact {#quantileexact}
+
+Точно вычисляет [квантиль](https://ru.wikipedia.org/wiki/Квантиль) числовой последовательности.
+
+Чтобы получить точный результат, все переданные значения собираются в массив, который затем частично сортируется. Таким образом, функция потребляет объем памяти `O(n)`, где `n` — количество переданных значений. Для небольшого числа значений эта функция эффективна.
+
+Внутренние состояния функций `quantile*` не объединяются, если они используются в одном запросе. Если вам необходимо вычислить квантили нескольких уровней, используйте функцию [quantiles](#quantiles), это повысит эффективность запроса.
+
+**Синтаксис**
+
+``` sql
+quantileExact(level)(expr)
+```
+
+Алиас: `medianExact`.
+
+**Параметры**
+
+-   `level` — Уровень квантили. Опционально. Константное значение с плавающей запятой от 0 до 1. Мы рекомендуем использовать значение `level` из диапазона `[0.01, 0.99]`. Значение по умолчанию: 0.5. При `level=0.5` функция вычисляет [медиану](https://ru.wikipedia.org/wiki/Медиана_(статистика)).
+-   `expr` — Выражение над значениями столбца, которое возвращает данные [числовых типов](../../../sql-reference/data-types/index.md#data_types) или типов [Date](../../../sql-reference/data-types/date.md), [DateTime](../../../sql-reference/data-types/datetime.md).
+
+**Возвращаемое значение**
+
+-   Квантиль заданного уровня.
+
+Тип:
+
+-   [Float64](../../../sql-reference/data-types/float.md) для входных данных числового типа.
+-   [Date](../../../sql-reference/data-types/date.md), если входные значения имеют тип `Date`.
+-   [DateTime](../../../sql-reference/data-types/datetime.md), если входные значения имеют тип `DateTime`.
+**Пример**
+
+Запрос:
+
+``` sql
+SELECT quantileExact(number) FROM numbers(10)
+```
+
+Результат:
+
+``` text
+┌─quantileExact(number)─┐
+│                     5 │
+└───────────────────────┘
+```
+
+**Смотрите также**
+
+-   [median](../../../sql-reference/aggregate-functions/reference/median.md#median)
+-   [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md#quantiles)
--- a/docs/ru/sql-reference/aggregate-functions/reference/quantileexactweighted.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/quantileexactweighted.md
@ -0,0 +1,67 @@
+---
+toc_priority: 203
+---
+
+# quantileExactWeighted {#quantileexactweighted}
+
+Точно вычисляет [квантиль](https://ru.wikipedia.org/wiki/Квантиль) числовой последовательности, учитывая вес каждого её элемента.
+
+Чтобы получить точный результат, все переданные значения собираются в массив, который затем частично сортируется. Для каждого значения учитывается его вес (количество значений в выборке). В алгоритме используется хэш-таблица. Таким образом, если переданные значения часто повторяются, функция потребляет меньше оперативной памяти, чем [quantileExact](#quantileexact). Эту функцию можно использовать вместо `quantileExact` если указать вес 1.
+
+Внутренние состояния функций `quantile*` не объединяются, если они используются в одном запросе. Если вам необходимо вычислить квантили нескольких уровней, используйте функцию [quantiles](#quantiles), это повысит эффективность запроса.
+
+**Синтаксис**
+
+``` sql
+quantileExactWeighted(level)(expr, weight)
+```
+
+Алиас: `medianExactWeighted`.
+
+**Параметры**
+
+-   `level` — Уровень квантили. Опционально. Константное значение с плавающей запятой от 0 до 1. Мы рекомендуем использовать значение `level` из диапазона `[0.01, 0.99]`. Значение по умолчанию: 0.5. При `level=0.5` функция вычисляет [медиану](https://ru.wikipedia.org/wiki/Медиана_(статистика)).
+-   `expr` — Выражение над значениями столбца, которое возвращает данные [числовых типов](../../../sql-reference/data-types/index.md#data_types) или типов [Date](../../../sql-reference/data-types/date.md), [DateTime](../../../sql-reference/data-types/datetime.md).
+-   `weight` — Столбец с весам элементов последовательности. Вес — это количество повторений элемента в последовательности.
+
+**Возвращаемое значение**
+
+-   Quantile of the specified level.
+
+Тип:
+
+-   [Float64](../../../sql-reference/data-types/float.md) для входных данных числового типа.
+-   [Date](../../../sql-reference/data-types/date.md), если входные значения имеют тип `Date`.
+-   [DateTime](../../../sql-reference/data-types/datetime.md), если входные значения имеют тип `DateTime`.
+
+**Пример**
+
+Входная таблица:
+
+``` text
+┌─n─┬─val─┐
+│ 0 │   3 │
+│ 1 │   2 │
+│ 2 │   1 │
+│ 5 │   4 │
+└───┴─────┘
+```
+
+Запрос:
+
+``` sql
+SELECT quantileExactWeighted(n, val) FROM t
+```
+
+Результат:
+
+``` text
+┌─quantileExactWeighted(n, val)─┐
+│                             1 │
+└───────────────────────────────┘
+```
+
+**Смотрите также**
+
+-   [median](../../../sql-reference/aggregate-functions/reference/median.md#median)
+-   [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md#quantiles)
--- a/docs/ru/sql-reference/aggregate-functions/reference/quantiles.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/quantiles.md
@ -0,0 +1,9 @@
+---
+toc_priority: 201
+---
+
+# quantiles {#quantiles}
+
+Syntax: `quantiles(level1, level2, …)(x)`
+
+All the quantile functions also have corresponding quantiles functions: `quantiles`, `quantilesDeterministic`, `quantilesTiming`, `quantilesTimingWeighted`, `quantilesExact`, `quantilesExactWeighted`, `quantilesTDigest`. These functions calculate all the quantiles of the listed levels in one pass, and return an array of the resulting values.
--- a/docs/ru/sql-reference/aggregate-functions/reference/quantiletdigest.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/quantiletdigest.md
@ -0,0 +1,57 @@
+---
+toc_priority: 207
+---
+
+# quantileTDigest {#quantiletdigest}
+
+Приблизительно вычисляет [квантиль](https://ru.wikipedia.org/wiki/Квантиль) числовой последовательности, используя алгоритм [t-digest](https://github.com/tdunning/t-digest/blob/master/docs/t-digest-paper/histo.pdf).
+
+Максимальная ошибка 1%. Потребление памяти — `log(n)`, где `n` — число значений. Результат не детерминирован и зависит от порядка выполнения запроса.
+
+Производительность функции ниже, чем производительность функции [quantile](#quantile) или [quantileTiming](#quantiletiming). По соотношению размера состояния к точности вычисления, эта функция значительно превосходит `quantile`.
+
+Внутренние состояния функций `quantile*` не объединяются, если они используются в одном запросе. Если вам необходимо вычислить квантили нескольких уровней, используйте функцию [quantiles](#quantiles), это повысит эффективность запроса.
+
+**Синтаксис**
+
+``` sql
+quantileTDigest(level)(expr)
+```
+
+Алиас: `medianTDigest`.
+
+**Параметры**
+
+-   `level` — Уровень квантили. Опционально. Константное значение с плавающей запятой от 0 до 1. Мы рекомендуем использовать значение `level` из диапазона `[0.01, 0.99]`. Значение по умолчанию: 0.5. При `level=0.5` функция вычисляет [медиану](https://ru.wikipedia.org/wiki/Медиана_(статистика)).
+-   `expr` — Выражение над значениями столбца, которое возвращает данные [числовых типов](../../../sql-reference/data-types/index.md#data_types) или типов [Date](../../../sql-reference/data-types/date.md), [DateTime](../../../sql-reference/data-types/datetime.md).
+
+**Возвращаемое значение**
+
+-   Приблизительную квантиль заданного уровня.
+
+Тип:
+
+-   [Float64](../../../sql-reference/data-types/float.md) для входных данных числового типа.
+-   [Date](../../../sql-reference/data-types/date.md), если входные значения имеют тип `Date`.
+-   [DateTime](../../../sql-reference/data-types/datetime.md), если входные значения имеют тип `DateTime`.
+
+**Пример**
+
+Запрос:
+
+``` sql
+SELECT quantileTDigest(number) FROM numbers(10)
+```
+
+Результат:
+
+``` text
+┌─quantileTDigest(number)─┐
+│                     4.5 │
+└─────────────────────────┘
+```
+
+**Смотрите также**
+
+-   [median](../../../sql-reference/aggregate-functions/reference/median.md#median)
+-   [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md#quantiles)
--- a/docs/ru/sql-reference/aggregate-functions/reference/quantiletdigestweighted.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/quantiletdigestweighted.md
@ -0,0 +1,58 @@
+---
+toc_priority: 208
+---
+
+# quantileTDigestWeighted {#quantiletdigestweighted}
+
+Приблизительно вычисляет [квантиль](https://ru.wikipedia.org/wiki/Квантиль) числовой последовательности, используя алгоритм [t-digest](https://github.com/tdunning/t-digest/blob/master/docs/t-digest-paper/histo.pdf). Функция учитывает вес каждого элемента последовательности.
+
+Максимальная ошибка 1%. Потребление памяти — `log(n)`, где `n` — число значений. Результат не детерминирован и зависит от порядка выполнения запроса.
+
+Производительность функции ниже, чем производительность функции [quantile](#quantile) или [quantileTiming](#quantiletiming). По соотношению размера состояния к точности вычисления, эта функция значительно превосходит `quantile`.
+
+Внутренние состояния функций `quantile*` не объединяются, если они используются в одном запросе. Если вам необходимо вычислить квантили нескольких уровней, используйте функцию [quantiles](#quantiles), это повысит эффективность запроса.
+
+**Синтаксис**
+
+``` sql
+quantileTDigestWeighted(level)(expr, weight)
+```
+
+Алиас: `medianTDigest`.
+
+**Параметры**
+
+-   `level` — Уровень квантили. Опционально. Константное значение с плавающей запятой от 0 до 1. Мы рекомендуем использовать значение `level` из диапазона `[0.01, 0.99]`. Значение по умолчанию: 0.5. При `level=0.5` функция вычисляет [медиану](https://ru.wikipedia.org/wiki/Медиана_(статистика)).
+-   `expr` — Выражение над значениями столбца, которое возвращает данные [числовых типов](../../../sql-reference/data-types/index.md#data_types) или типов [Date](../../../sql-reference/data-types/date.md), [DateTime](../../../sql-reference/data-types/datetime.md).
+-   `weight` — Столбец с весам элементов последовательности. Вес — это количество повторений элемента в последовательности.
+
+**Возвращаемое значение**
+
+-   Приблизительный квантиль заданного уровня.
+
+Тип:
+
+-   [Float64](../../../sql-reference/data-types/float.md) для входных данных числового типа.
+-   [Date](../../../sql-reference/data-types/date.md), если входные значения имеют тип `Date`.
+-   [DateTime](../../../sql-reference/data-types/datetime.md), если входные значения имеют тип `DateTime`.
+
+**Пример**
+
+Запрос:
+
+``` sql
+SELECT quantileTDigestWeighted(number, 1) FROM numbers(10)
+```
+
+Результат:
+
+``` text
+┌─quantileTDigestWeighted(number, 1)─┐
+│                                4.5 │
+└────────────────────────────────────┘
+```
+
+**Смотрите также**
+
+-   [median](../../../sql-reference/aggregate-functions/reference/median.md#median)
+-   [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md#quantiles)
--- a/docs/ru/sql-reference/aggregate-functions/reference/quantiletiming.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/quantiletiming.md
@ -0,0 +1,86 @@
+---
+toc_priority: 204
+---
+
+# quantileTiming {#quantiletiming}
+
+Вычисляет [квантиль](https://ru.wikipedia.org/wiki/Квантиль) числовой последовательности с детерминированной точностью.
+
+Результат детерминирован (не зависит от порядка обработки запроса). Функция оптимизирована для работы с последовательностями, описывающими такие распределения, как время загрузки веб-страниц или время отклика бэкенда.
+
+Внутренние состояния функций `quantile*` не объединяются, если они используются в одном запросе. Если вам необходимо вычислить квантили нескольких уровней, используйте функцию [quantiles](#quantiles), это повысит эффективность запроса.
+
+**Синтаксис**
+
+``` sql
+quantileTiming(level)(expr)
+```
+
+Алиас: `medianTiming`.
+
+**Параметры**
+
+-   `level` — Уровень квантили. Опционально. Константное значение с плавающей запятой от 0 до 1. Мы рекомендуем использовать значение `level` из диапазона `[0.01, 0.99]`. Значение по умолчанию: 0.5. При `level=0.5` функция вычисляет [медиану](https://ru.wikipedia.org/wiki/Медиана_(статистика)).
+
+-   `expr` — [Выражение](../../syntax.md#syntax-expressions) над значения столбца, которые возвращают данные типа [Float\*](../../../sql-reference/data-types/float.md).
+
+        - Если в функцию передать отрицательные значения, то её поведение не определено.
+        - Если значение больше, чем 30 000 (например, время загрузки страницы превышает 30 секунд), то оно приравнивается к 30 000.
+
+**Точность**
+
+Вычисления точны при соблюдении следующих условий:
+
+-   Размер выборки не превышает 5670 элементов.
+-   Размер выборки превышает 5670 элементов, но значение каждого элемента не больше 1024.
+
+В противном случае, результат вычисления округляется до ближайшего множителя числа 16.
+
+!!! note "Примечание"
+    Для указанного типа последовательностей функция производительнее и точнее, чем [quantile](#quantile).
+
+**Возвращаемое значение**
+
+-   Квантиль заданного уровня.
+
+Тип: `Float32`.
+
+!!! note "Примечания"
+    Если в функцию `quantileTimingIf` не передать значений, то вернётся [NaN](../../../sql-reference/data-types/float.md#data_type-float-nan-inf). Это необходимо для отделения подобных случаев от случаев, когда результат 0. Подробности про сортировку `NaN` cмотрите в разделе [Секция ORDER BY](../../../sql-reference/statements/select/order-by.md#select-order-by).
+
+**Пример**
+
+Входная таблица:
+
+``` text
+┌─response_time─┐
+│            72 │
+│           112 │
+│           126 │
+│           145 │
+│           104 │
+│           242 │
+│           313 │
+│           168 │
+│           108 │
+└───────────────┘
+```
+
+Запрос:
+
+``` sql
+SELECT quantileTiming(response_time) FROM t
+```
+
+Результат:
+
+``` text
+┌─quantileTiming(response_time)─┐
+│                           126 │
+└───────────────────────────────┘
+```
+
+**Смотрите также**
+
+-   [median](../../../sql-reference/aggregate-functions/reference/median.md#median)
+-   [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md#quantiles)
--- a/docs/ru/sql-reference/aggregate-functions/reference/quantiletimingweighted.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/quantiletimingweighted.md
@ -0,0 +1,85 @@
+---
+toc_priority: 205
+---
+
+# quantileTimingWeighted {#quantiletimingweighted}
+
+С детерминированной точностью вычисляет [квантиль](https://ru.wikipedia.org/wiki/Квантиль) числовой последовательности, учитывая вес каждого элемента.
+
+Результат детерминирован (не зависит от порядка обработки запроса). Функция оптимизирована для работы с последовательностями, описывающими такие распределения, как время загрузки веб-страниц или время отклика бэкенда.
+
+Внутренние состояния функций `quantile*` не объединяются, если они используются в одном запросе. Если вам необходимо вычислить квантили нескольких уровней, используйте функцию [quantiles](#quantiles), это повысит эффективность запроса.
+
+**Синтаксис**
+
+``` sql
+quantileTimingWeighted(level)(expr, weight)
+```
+
+Алиас: `medianTimingWeighted`.
+
+**Параметры**
+
+-   `level` — Уровень квантили. Опционально. Константное значение с плавающей запятой от 0 до 1. Мы рекомендуем использовать значение `level` из диапазона `[0.01, 0.99]`. Значение по умолчанию: 0.5. При `level=0.5` функция вычисляет [медиану](https://ru.wikipedia.org/wiki/Медиана_(статистика)).
+
+-   `expr` — [Выражение](../../syntax.md#syntax-expressions) над значения столбца, которые возвращают данные типа [Float\*](../../../sql-reference/data-types/float.md).
+
+        - Если в функцию передать отрицательные значения, то её поведение не определено.
+        - Если значение больше, чем 30 000 (например, время загрузки страницы превышает 30 секунд), то оно приравнивается к 30 000.
+
+-   `weight` — Столбец с весам элементов последовательности. Вес — это количество повторений элемента в последовательности.
+
+**Точность**
+
+Вычисления точны при соблюдении следующих условий:
+
+-   Размер выборки не превышает 5670 элементов.
+-   Размер выборки превышает 5670 элементов, но значение каждого элемента не больше 1024.
+
+В противном случае, результат вычисления округляется до ближайшего множителя числа 16.
+
+!!! note "Примечание"
+    Для указанного типа последовательностей функция производительнее и точнее, чем [quantile](#quantile).
+
+**Возвращаемое значение**
+
+-   Квантиль заданного уровня.
+
+Тип: `Float32`.
+
+!!! note "Примечания"
+    Если в функцию `quantileTimingIf` не передать значений, то вернётся [NaN](../../../sql-reference/data-types/float.md#data_type-float-nan-inf). Это необходимо для отделения подобных случаев от случаев, когда результат 0. Подробности про сортировку `NaN` cмотрите в разделе [Секция ORDER BY](../../../sql-reference/statements/select/order-by.md#select-order-by).
+
+**Пример**
+
+Входная таблица:
+
+``` text
+┌─response_time─┬─weight─┐
+│            68 │      1 │
+│           104 │      2 │
+│           112 │      3 │
+│           126 │      2 │
+│           138 │      1 │
+│           162 │      1 │
+└───────────────┴────────┘
+```
+
+Запрос:
+
+``` sql
+SELECT quantileTimingWeighted(response_time, weight) FROM t
+```
+
+Результат:
+
+``` text
+┌─quantileTimingWeighted(response_time, weight)─┐
+│                                           112 │
+└───────────────────────────────────────────────┘
+```
+
+**Смотрите также**
+
+-   [median](../../../sql-reference/aggregate-functions/reference/median.md#median)
+-   [quantiles](../../../sql-reference/aggregate-functions/reference/quantiles.md#quantiles)
--- a/docs/ru/sql-reference/aggregate-functions/reference/simplelinearregression.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/simplelinearregression.md
@ -0,0 +1,42 @@
+---
+toc_priority: 220
+---
+
+# simpleLinearRegression {#simplelinearregression}
+
+Выполняет простую (одномерную) линейную регрессию.
+
+``` sql
+simpleLinearRegression(x, y)
+```
+
+Параметры:
+
+-   `x` — столбец со значениями зависимой переменной.
+-   `y` — столбец со значениями наблюдаемой переменной.
+
+Возвращаемые значения:
+
+Константы `(a, b)` результирующей прямой `y = a*x + b`.
+
+**Примеры**
+
+``` sql
+SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3])
+```
+
+``` text
+┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3])─┐
+│ (1,0)                                                             │
+└───────────────────────────────────────────────────────────────────┘
+```
+
+``` sql
+SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6])
+```
+
+``` text
+┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6])─┐
+│ (1,3)                                                             │
+└───────────────────────────────────────────────────────────────────┘
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/skewpop.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/skewpop.md
@ -0,0 +1,25 @@
+---
+toc_priority: 150
+---
+
+# skewPop {#skewpop}
+
+Вычисляет [коэффициент асимметрии](https://ru.wikipedia.org/wiki/Коэффициент_асимметрии) для последовательности.
+
+``` sql
+skewPop(expr)
+```
+
+**Параметры**
+
+`expr` — [Выражение](../../syntax.md#syntax-expressions), возвращающее число.
+
+**Возвращаемое значение**
+
+Коэффициент асимметрии заданного распределения. Тип — [Float64](../../../sql-reference/data-types/float.md)
+
+**Пример**
+
+``` sql
+SELECT skewPop(value) FROM series_with_value_column
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/skewsamp.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/skewsamp.md
@ -0,0 +1,27 @@
+---
+toc_priority: 151
+---
+
+# skewSamp {#skewsamp}
+
+Вычисляет [выборочный коэффициент асимметрии](https://ru.wikipedia.org/wiki/Статистика_(функция_выборки)) для последовательности.
+
+Он представляет собой несмещенную оценку асимметрии случайной величины, если переданные значения образуют ее выборку.
+
+``` sql
+skewSamp(expr)
+```
+
+**Параметры**
+
+`expr` — [Выражение](../../syntax.md#syntax-expressions), возвращающее число.
+
+**Возвращаемое значение**
+
+Коэффициент асимметрии заданного распределения. Тип — [Float64](../../../sql-reference/data-types/float.md). Если `n <= 1` (`n` — размер выборки), тогда функция возвращает `nan`.
+
+**Пример**
+
+``` sql
+SELECT skewSamp(value) FROM series_with_value_column
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/stddevpop.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/stddevpop.md
@ -0,0 +1,10 @@
+---
+toc_priority: 30
+---
+
+# stddevPop {#stddevpop}
+
+Результат равен квадратному корню от `varPop(x)`.
+
+!!! note "Примечание"
+    Функция использует вычислительно неустойчивый алгоритм. Если для ваших расчётов необходима [вычислительная устойчивость](https://ru.wikipedia.org/wiki/Вычислительная_устойчивость), используйте функцию `stddevPopStable`. Она работает медленнее, но обеспечивает меньшую вычислительную ошибку.
--- a/docs/ru/sql-reference/aggregate-functions/reference/stddevsamp.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/stddevsamp.md
@ -0,0 +1,10 @@
+---
+toc_priority: 31
+---
+
+# stddevSamp {#stddevsamp}
+
+Результат равен квадратному корню от `varSamp(x)`.
+
+!!! note "Примечание"
+    Функция использует вычислительно неустойчивый алгоритм. Если для ваших расчётов необходима [вычислительная устойчивость](https://ru.wikipedia.org/wiki/Вычислительная_устойчивость), используйте функцию `stddevSampStable`. Она работает медленнее, но обеспечивает меньшую вычислительную ошибку.
--- a/docs/ru/sql-reference/aggregate-functions/reference/stochasticlinearregression.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/stochasticlinearregression.md
@ -0,0 +1,87 @@
+---
+toc_priority: 221
+---
+
+# stochasticLinearRegression {#agg_functions-stochasticlinearregression}
+
+Функция реализует стохастическую линейную регрессию. Поддерживает пользовательские параметры для скорости обучения, коэффициента регуляризации L2, размера mini-batch и имеет несколько методов обновления весов ([Adam](https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Adam) (по умолчанию), [simple SGD](https://en.wikipedia.org/wiki/Stochastic_gradient_descent), [Momentum](https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Momentum), [Nesterov](https://mipt.ru/upload/medialibrary/d7e/41-91.pdf)).
+
+### Параметры {#agg_functions-stochasticlinearregression-parameters}
+
+Есть 4 настраиваемых параметра. Они передаются в функцию последовательно, однако не обязательно указывать все, используются значения по умолчанию, однако хорошая модель требует некоторой настройки параметров.
+
+``` text
+stochasticLinearRegression(1.0, 1.0, 10, 'SGD')
+```
+
+1.  Скорость обучения — коэффициент длины шага, при выполнении градиентного спуска. Слишком большая скорость обучения может привести к бесконечным весам модели. По умолчанию `0.00001`.
+2.  Коэффициент регуляризации l2. Помогает предотвратить подгонку. По умолчанию `0.1`.
+3.  Размер mini-batch задаёт количество элементов, чьи градиенты будут вычислены и просуммированы при выполнении одного шага градиентного спуска. Чистый стохастический спуск использует один элемент, однако использование mini-batch (около 10 элементов) делает градиентные шаги более стабильными. По умолчанию `15`.
+4.  Метод обновления весов, можно выбрать один из следующих: `Adam` (по умолчанию), `SGD`, `Momentum`, `Nesterov`. `Momentum` и `Nesterov` более требовательные к вычислительным ресурсам и памяти, однако они имеют высокую скорость схождения и устойчивости методов стохастического градиента.
+
+### Использование {#agg_functions-stochasticlinearregression-usage}
+
+`stochasticLinearRegression` используется на двух этапах: построение модели и предсказание новых данных. Чтобы построить модель и сохранить её состояние для дальнейшего использования, мы используем комбинатор `-State`.
+Для прогнозирования мы используем функцию [evalMLMethod](../../functions/machine-learning-functions.md#machine_learning_methods-evalmlmethod), которая принимает в качестве аргументов состояние и свойства для прогнозирования.
+
+<a name="stochasticlinearregression-usage-fitting"></a>
+
+**1.** Построение модели
+
+Пример запроса:
+
+``` sql
+CREATE TABLE IF NOT EXISTS train_data
+(
+    param1 Float64,
+    param2 Float64,
+    target Float64
+) ENGINE = Memory;
+
+CREATE TABLE your_model ENGINE = Memory AS SELECT
+stochasticLinearRegressionState(0.1, 0.0, 5, 'SGD')(target, param1, param2)
+AS state FROM train_data;
+```
+
+Здесь нам также нужно вставить данные в таблицу `train_data`. Количество параметров не фиксировано, оно зависит только от количества аргументов, перешедших в `linearRegressionState`. Все они должны быть числовыми значениями.
+Обратите внимание, что столбец с целевым значением (которое мы хотели бы научиться предсказывать) вставляется в качестве первого аргумента.
+
+**2.** Прогнозирование
+
+После сохранения состояния в таблице мы можем использовать его несколько раз для прогнозирования или смёржить с другими состояниями и создать новые, улучшенные модели.
+
+``` sql
+WITH (SELECT state FROM your_model) AS model SELECT
+evalMLMethod(model, param1, param2) FROM test_data
+```
+
+Запрос возвращает столбец прогнозируемых значений. Обратите внимание, что первый аргумент `evalMLMethod` это объект `AggregateFunctionState`, далее идут столбцы свойств.
+
+`test_data` — это таблица, подобная `train_data`, но при этом может не содержать целевое значение.
+
+### Примечания {#agg_functions-stochasticlinearregression-notes}
+
+1.  Объединить две модели можно следующим запросом:
+
+<!-- -->
+
+    ``` sql
+    SELECT state1 + state2 FROM your_models
+    ```
+
+где таблица `your_models` содержит обе модели. Запрос вернёт новый объект `AggregateFunctionState`.
+
+1.  Пользователь может получать веса созданной модели для своих целей без сохранения модели, если не использовать комбинатор `-State`.
+
+<!-- -->
+
+    ``` sql
+    SELECT stochasticLinearRegression(0.01)(target, param1, param2) FROM train_data
+    ```
+
+Подобный запрос строит модель и возвращает её веса, отвечающие параметрам моделей и смещение. Таким образом, в приведенном выше примере запрос вернет столбец с тремя значениями.
+
+**Смотрите также**
+
+-   [stochasticLogisticRegression](../../../sql-reference/aggregate-functions/reference/stochasticlinearregression.md#agg_functions-stochasticlogisticregression)
+-   [Отличие линейной от логистической регрессии.](https://stackoverflow.com/questions/12146914/what-is-the-difference-between-linear-regression-and-logistic-regression)
--- a/docs/ru/sql-reference/aggregate-functions/reference/stochasticlogisticregression.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/stochasticlogisticregression.md
@ -0,0 +1,55 @@
+---
+toc_priority: 222
+---
+
+# stochasticLogisticRegression {#agg_functions-stochasticlogisticregression}
+
+Функция реализует стохастическую логистическую регрессию. Её можно использовать для задачи бинарной классификации, функция поддерживает те же пользовательские параметры, что и stochasticLinearRegression и работает таким же образом.
+
+### Параметры {#agg_functions-stochasticlogisticregression-parameters}
+
+Параметры те же, что и в stochasticLinearRegression:
+`learning rate`, `l2 regularization coefficient`, `mini-batch size`, `method for updating weights`.
+Смотрите раздел [parameters](../../../sql-reference/aggregate-functions/reference/stochasticlinearregression.md#agg_functions-stochasticlinearregression-parameters).
+
+``` text
+stochasticLogisticRegression(1.0, 1.0, 10, 'SGD')
+```
+
+1.  Построение модели
+
+<!-- -->
+
+Смотрите раздел `Построение модели` в описании [stochasticLinearRegression](../../../sql-reference/aggregate-functions/reference/stochasticlinearregression.md#stochasticlinearregression-usage-fitting) .
+
+    Прогнозируемые метки должны быть в диапазоне \[-1, 1\].
+
+1.  Прогнозирование
+
+<!-- -->
+
+Используя сохраненное состояние, можно предсказать вероятность наличия у объекта метки `1`.
+
+    ``` sql
+    WITH (SELECT state FROM your_model) AS model SELECT
+    evalMLMethod(model, param1, param2) FROM test_data
+    ```
+
+Запрос возвращает столбец вероятностей. Обратите внимание, что первый аргумент `evalMLMethod` это объект `AggregateFunctionState`, далее идут столбцы свойств.
+
+Мы также можем установить границу вероятности, которая присваивает элементам различные метки.
+
+    ``` sql
+    SELECT ans < 1.1 AND ans > 0.5 FROM
+    (WITH (SELECT state FROM your_model) AS model SELECT
+    evalMLMethod(model, param1, param2) AS ans FROM test_data)
+    ```
+
+Тогда результатом будут метки.
+
+`test_data` — это таблица, подобная `train_data`, но при этом может не содержать целевое значение.
+
+**Смотрите также**
+
+-   [stochasticLinearRegression](../../../sql-reference/aggregate-functions/reference/stochasticlinearregression.md#agg_functions-stochasticlinearregression)
+-   [Отличие линейной от логистической регрессии](https://moredez.ru/q/51225972/)
--- a/docs/ru/sql-reference/aggregate-functions/reference/sum.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/sum.md
@ -0,0 +1,8 @@
+---
+toc_priority: 4
+---
+
+# sum {#agg_function-sum}
+
+Вычисляет сумму.
+Работает только для чисел.
--- a/docs/ru/sql-reference/aggregate-functions/reference/summap.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/summap.md
@ -0,0 +1,41 @@
+---
+toc_priority: 141
+---
+
+# sumMap {#agg_functions-summap}
+
+Синтаксис: `sumMap(key, value)` или `sumMap(Tuple(key, value))`
+
+Производит суммирование массива ‘value’ по соответствующим ключам заданным в массиве ‘key’.
+Количество элементов в ‘key’ и ‘value’ должно быть одинаковым для каждой строки, для которой происходит суммирование.
+Возвращает кортеж из двух массивов - ключи в отсортированном порядке и значения, просуммированные по соответствующим ключам.
+
+Пример:
+
+``` sql
+CREATE TABLE sum_map(
+    date Date,
+    timeslot DateTime,
+    statusMap Nested(
+        status UInt16,
+        requests UInt64
+    )
+) ENGINE = Log;
+INSERT INTO sum_map VALUES
+    ('2000-01-01', '2000-01-01 00:00:00', [1, 2, 3], [10, 10, 10]),
+    ('2000-01-01', '2000-01-01 00:00:00', [3, 4, 5], [10, 10, 10]),
+    ('2000-01-01', '2000-01-01 00:01:00', [4, 5, 6], [10, 10, 10]),
+    ('2000-01-01', '2000-01-01 00:01:00', [6, 7, 8], [10, 10, 10]);
+SELECT
+    timeslot,
+    sumMap(statusMap.status, statusMap.requests)
+FROM sum_map
+GROUP BY timeslot
+```
+
+``` text
+┌────────────timeslot─┬─sumMap(statusMap.status, statusMap.requests)─┐
+│ 2000-01-01 00:00:00 │ ([1,2,3,4,5],[10,10,20,10,10])               │
+│ 2000-01-01 00:01:00 │ ([4,5,6,7,8],[10,10,20,10,10])               │
+└─────────────────────┴──────────────────────────────────────────────┘
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/sumwithoverflow.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/sumwithoverflow.md
@ -0,0 +1,9 @@
+---
+toc_priority: 140
+---
+
+# sumWithOverflow {#sumwithoverflowx}
+
+Вычисляет сумму чисел, используя для результата тот же тип данных, что и для входных параметров. Если сумма выйдет за максимальное значение для заданного типа данных, то функция вернёт ошибку.
+
+Работает только для чисел.
--- a/docs/ru/sql-reference/aggregate-functions/reference/timeseriesgroupratesum.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/timeseriesgroupratesum.md
@ -0,0 +1,17 @@
+---
+toc_priority: 171
+---
+
+# timeSeriesGroupRateSum {#agg-function-timeseriesgroupratesum}
+
+Синтаксис: `timeSeriesGroupRateSum(uid, ts, val)`
+
+Аналогично timeSeriesGroupSum, timeSeriesGroupRateSum будет вычислять производные по timestamp для рядов, а затем суммировать полученные производные для всех рядов для одного значения timestamp.
+Также ряды должны быть отсортированы по возрастанию timestamp.
+
+Для пример из описания timeSeriesGroupSum результат будет следующим:
+
+``` text
+[(2,0),(3,0.1),(7,0.3),(8,0.3),(12,0.3),(17,0.3),(18,0.3),(24,0.3),(25,0.1)]
+```
+
--- a/docs/ru/sql-reference/aggregate-functions/reference/timeseriesgroupsum.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/timeseriesgroupsum.md
@ -0,0 +1,57 @@
+---
+toc_priority: 170
+---
+
+# timeSeriesGroupSum {#agg-function-timeseriesgroupsum}
+
+Синтаксис: `timeSeriesGroupSum(uid, timestamp, value)`
+
+`timeSeriesGroupSum` агрегирует временные ряды в которых не совпадают моменты.
+Функция использует линейную интерполяцию между двумя значениями времени, а затем суммирует значения для одного и того же момента (как измеренные так и интерполированные) по всем рядам.
+
+-   `uid` уникальный идентификатор временного ряда, `UInt64`.
+-   `timestamp` имеет тип `Int64` чтобы можно было учитывать милли и микросекунды.
+-   `value` представляет собой значение метрики.
+
+Функция возвращает массив кортежей с парами `(timestamp, aggregated_value)`.
+
+Временные ряды должны быть отсортированы по возрастанию `timestamp`.
+
+Пример:
+
+``` text
+┌─uid─┬─timestamp─┬─value─┐
+│ 1   │     2     │   0.2 │
+│ 1   │     7     │   0.7 │
+│ 1   │    12     │   1.2 │
+│ 1   │    17     │   1.7 │
+│ 1   │    25     │   2.5 │
+│ 2   │     3     │   0.6 │
+│ 2   │     8     │   1.6 │
+│ 2   │    12     │   2.4 │
+│ 2   │    18     │   3.6 │
+│ 2   │    24     │   4.8 │
+└─────┴───────────┴───────┘
+```
+
+``` sql
+CREATE TABLE time_series(
+    uid       UInt64,
+    timestamp Int64,
+    value     Float64
+) ENGINE = Memory;
+INSERT INTO time_series VALUES
+    (1,2,0.2),(1,7,0.7),(1,12,1.2),(1,17,1.7),(1,25,2.5),
+    (2,3,0.6),(2,8,1.6),(2,12,2.4),(2,18,3.6),(2,24,4.8);
+
+SELECT timeSeriesGroupSum(uid, timestamp, value)
+FROM (
+    SELECT * FROM time_series order by timestamp ASC
+);
+```
+
+И результат будет:
+
+``` text
+[(2,0.2),(3,0.9),(7,2.1),(8,2.4),(12,3.6),(17,5.1),(18,5.4),(24,7.2),(25,2.5)]
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/topk.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/topk.md
@ -0,0 +1,37 @@
+---
+toc_priority: 108
+---
+
+# topK {#topk}
+
+Возвращает массив наиболее часто встречающихся значений в указанном столбце. Результирующий массив упорядочен по убыванию частоты значения (не по самим значениям).
+
+Реализует [Filtered Space-Saving](http://www.l2f.inesc-id.pt/~fmmb/wiki/uploads/Work/misnis.ref0a.pdf) алгоритм для анализа TopK, на основе reduce-and-combine алгоритма из методики [Parallel Space Saving](https://arxiv.org/pdf/1401.0702.pdf).
+
+``` sql
+topK(N)(column)
+```
+
+Функция не дает гарантированного результата. В некоторых ситуациях могут возникать ошибки, и функция возвращает частые, но не наиболее частые значения.
+
+Рекомендуем использовать значения `N < 10`, при больших `N` снижается производительность. Максимально возможное значение `N = 65536`.
+
+**Аргументы**
+
+-   ‘N’ - Количество значений.
+-   ‘x’ – Столбец.
+
+**Пример**
+
+Возьмём набор данных [OnTime](../../../getting-started/example-datasets/ontime.md) и выберем 3 наиболее часто встречающихся значения в столбце `AirlineID`.
+
+``` sql
+SELECT topK(3)(AirlineID) AS res
+FROM ontime
+```
+
+``` text
+┌─res─────────────────┐
+│ [19393,19790,19805] │
+└─────────────────────┘
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/topkweighted.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/topkweighted.md
@ -0,0 +1,42 @@
+---
+toc_priority: 109
+---
+
+# topKWeighted {#topkweighted}
+
+Аналогична `topK`, но дополнительно принимает положительный целочисленный параметр `weight`. Каждое значение учитывается `weight` раз при расчёте частоты.
+
+**Синтаксис**
+
+``` sql
+topKWeighted(N)(x, weight)
+```
+
+**Параметры**
+
+-   `N` — Количество элементов для выдачи.
+
+**Аргументы**
+
+-   `x` – значение.
+-   `weight` — вес. [UInt8](../../../sql-reference/data-types/int-uint.md).
+
+**Возвращаемое значение**
+
+Возвращает массив значений с максимально приближенной суммой весов.
+
+**Пример**
+
+Запрос:
+
+``` sql
+SELECT topKWeighted(10)(number, number) FROM numbers(1000)
+```
+
+Результат:
+
+``` text
+┌─topKWeighted(10)(number, number)──────────┐
+│ [999,998,997,996,995,994,993,992,991,990] │
+└───────────────────────────────────────────┘
+```
--- a/docs/ru/sql-reference/aggregate-functions/reference/uniq.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/uniq.md
@ -0,0 +1,40 @@
+---
+toc_priority: 190
+---
+
+# uniq {#agg_function-uniq}
+
+Приближённо вычисляет количество различных значений аргумента.
+
+``` sql
+uniq(x[, ...])
+```
+
+**Параметры**
+
+Функция принимает переменное число входных параметров. Параметры могут быть числовых типов, а также `Tuple`, `Array`, `Date`, `DateTime`, `String`.
+
+**Возвращаемое значение**
+
+-   Значение с типом данных [UInt64](../../../sql-reference/data-types/int-uint.md).
+
+**Детали реализации**
+
+Функция:
+
+-   Вычисляет хэш для всех параметров агрегации, а затем использует его в вычислениях.
+
+-   Использует адаптивный алгоритм выборки. В качестве состояния вычисления функция использует выборку хэш-значений элементов размером до 65536.
+
+        Этот алгоритм очень точен и очень эффективен по использованию CPU. Если запрос содержит небольшое количество этих функций, использование `uniq` почти так же эффективно,  как и использование других агрегатных функций.
+
+-   Результат детерминирован (не зависит от порядка выполнения запроса).
+
+Эту функцию рекомендуется использовать практически во всех сценариях.
+
+**Смотрите также**
+
+-   [uniqCombined](../../../sql-reference/aggregate-functions/reference/uniqcombined.md#agg_function-uniqcombined)
+-   [uniqCombined64](../../../sql-reference/aggregate-functions/reference/uniqcombined64.md#agg_function-uniqcombined64)
+-   [uniqHLL12](../../../sql-reference/aggregate-functions/reference/uniqhll12.md#agg_function-uniqhll12)
+-   [uniqExact](../../../sql-reference/aggregate-functions/reference/uniqexact.md#agg_function-uniqexact)
--- a/docs/ru/sql-reference/aggregate-functions/reference/uniqcombined.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/uniqcombined.md
@ -0,0 +1,51 @@
+---
+toc_priority: 192
+---
+
+# uniqCombined {#agg_function-uniqcombined}
+
+Приближённо вычисляет количество различных значений аргумента.
+
+``` sql
+uniqCombined(HLL_precision)(x[, ...])
+```
+
+Функция `uniqCombined` — это хороший выбор для вычисления количества различных значений.
+
+**Параметры**
+
+Функция принимает переменное число входных параметров. Параметры могут быть числовых типов, а также `Tuple`, `Array`, `Date`, `DateTime`, `String`.
+
+`HLL_precision` — это логарифм по основанию 2 от числа ячеек в [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog). Необязательный, можно использовать функцию как `uniqCombined (x [,...])`. Для `HLL_precision` значение по умолчанию — 17, что фактически составляет 96 КБ пространства (2^17 ячеек, 6 бит каждая).
+
+**Возвращаемое значение**
+
+-   Число типа [UInt64](../../../sql-reference/data-types/int-uint.md).
+
+**Детали реализации**
+
+Функция:
+
+-   Вычисляет хэш (64-битный для `String` и 32-битный для всех остальных типов) для всех параметров агрегации, а затем использует его в вычислениях.
+
+-   Используется комбинация трёх алгоритмов: массив, хэш-таблица и HyperLogLog с таблицей коррекции погрешности.
+
+        Для небольшого количества различных значений используется массив. Если размер набора больше, используется хэш-таблица. При дальнейшем увеличении количества значений, используется структура HyperLogLog, имеющая фиксированный размер в памяти.
+
+-   Результат детерминирован (не зависит от порядка выполнения запроса).
+
+!!! note "Note"
+    Так как используется 32-битный хэш для не-`String` типов, результат будет иметь очень очень большую ошибку для количества разичных элементов существенно больше `UINT_MAX` (ошибка быстро растёт начиная с нескольких десятков миллиардов различных значений), таким образом в этом случае нужно использовать [uniqCombined64](#agg_function-uniqcombined64)
+
+По сравнению с функцией [uniq](#agg_function-uniq), `uniqCombined`:
+
+-   Потребляет в несколько раз меньше памяти.
+-   Вычисляет с в несколько раз более высокой точностью.
+-   Обычно имеет немного более низкую производительность. В некоторых сценариях `uniqCombined` может показывать более высокую производительность, чем `uniq`, например, в случае распределенных запросов, при которых по сети передаётся большое количество состояний агрегации.
+
+**Смотрите также**
+
+-   [uniq](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniq)
+-   [uniqCombined64](../../../sql-reference/aggregate-functions/reference/uniqcombined64.md#agg_function-uniqcombined64)
+-   [uniqHLL12](../../../sql-reference/aggregate-functions/reference/uniqhll12.md#agg_function-uniqhll12)
+-   [uniqExact](../../../sql-reference/aggregate-functions/reference/uniqexact.md#agg_function-uniqexact)
--- a/docs/ru/sql-reference/aggregate-functions/reference/uniqcombined64.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/uniqcombined64.md
@ -0,0 +1,7 @@
+---
+toc_priority: 193
+---
+
+# uniqCombined64 {#agg_function-uniqcombined64}
+
+Использует 64-битный хэш для всех типов, в отличие от [uniqCombined](../../../sql-reference/aggregate-functions/reference/uniqcombined.md#agg_function-uniqcombined).
--- a/docs/ru/sql-reference/aggregate-functions/reference/uniqexact.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/uniqexact.md
@ -0,0 +1,25 @@
+---
+toc_priority: 191
+---
+
+# uniqExact {#agg_function-uniqexact}
+
+Вычисляет точное количество различных значений аргументов.
+
+``` sql
+uniqExact(x[, ...])
+```
+
+Функцию `uniqExact` следует использовать, если вам обязательно нужен точный результат. В противном случае используйте функцию [uniq](#agg_function-uniq).
+
+Функция `uniqExact` расходует больше оперативной памяти, чем функция `uniq`, так как размер состояния неограниченно растёт по мере роста количества различных значений.
+
+**Параметры**
+
+Функция принимает переменное число входных параметров. Параметры могут быть числовых типов, а также `Tuple`, `Array`, `Date`, `DateTime`, `String`.
+
+**Смотрите также**
+
+-   [uniq](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniq)
+-   [uniqCombined](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniqcombined)
+-   [uniqHLL12](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniqhll12)
--- a/docs/ru/sql-reference/aggregate-functions/reference/uniqhll12.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/uniqhll12.md
@ -0,0 +1,38 @@
+---
+toc_priority: 194
+---
+
+# uniqHLL12 {#agg_function-uniqhll12}
+
+Вычисляет приблизительное число различных значений аргументов, используя алгоритм [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog).
+
+``` sql
+uniqHLL12(x[, ...])
+```
+
+**Параметры**
+
+Функция принимает переменное число входных параметров. Параметры могут быть числовых типов, а также `Tuple`, `Array`, `Date`, `DateTime`, `String`.
+
+**Возвращаемое значение**
+
+-   Значение хэша с типом данных [UInt64](../../../sql-reference/data-types/int-uint.md).
+
+**Детали реализации**
+
+Функция:
+
+-   Вычисляет хэш для всех параметров агрегации, а затем использует его в вычислениях.
+
+-   Использует алгоритм HyperLogLog для аппроксимации числа различных значений аргументов.
+
+        Используется 212 5-битовых ячеек. Размер состояния чуть больше 2.5 КБ. Результат не точный (ошибка до ~10%) для небольших множеств (<10K элементов). Однако для множеств большой кардинальности (10K - 100M) результат довольно точен (ошибка до ~1.6%). Начиная с 100M ошибка оценки будет только расти и для множеств огромной кардинальности (1B+ элементов) функция возвращает результат с очень большой неточностью.
+
+-   Результат детерминирован (не зависит от порядка выполнения запроса).
+
+Мы не рекомендуем использовать эту функцию. В большинстве случаев используйте функцию [uniq](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniq) или [uniqCombined](../../../sql-reference/aggregate-functions/reference/uniqcombined.md#agg_function-uniqcombined).
+
+
+-   [uniq](../../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniq)
+-   [uniqCombined](../../../sql-reference/aggregate-functions/reference/uniqcombined.md#agg_function-uniqcombined)
+-   [uniqExact](../../../sql-reference/aggregate-functions/reference/uniqexact.md#agg_function-uniqexact)
--- a/docs/ru/sql-reference/aggregate-functions/reference/varpop.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/varpop.md
@ -0,0 +1,12 @@
+---
+toc_priority: 32
+---
+
+# varPop(x) {#varpopx}
+
+Вычисляет величину `Σ((x - x̅)^2) / n`, где `n` - размер выборки, `x̅`- среднее значение `x`.
+
+То есть, дисперсию для множества значений. Возвращает `Float64`.
+
+!!! note "Примечание"
+    Функция использует вычислительно неустойчивый алгоритм. Если для ваших расчётов необходима [вычислительная устойчивость](https://ru.wikipedia.org/wiki/Вычислительная_устойчивость), используйте функцию `varPopStable`. Она работает медленнее, но обеспечивает меньшую вычислительную ошибку.
--- a/docs/ru/sql-reference/aggregate-functions/reference/varsamp.md
+++ b/docs/ru/sql-reference/aggregate-functions/reference/varsamp.md
@ -0,0 +1,14 @@
+---
+toc_priority: 33
+---
+
+# varSamp {#varsamp}
+
+Вычисляет величину `Σ((x - x̅)^2) / (n - 1)`, где `n` - размер выборки, `x̅`- среднее значение `x`.
+
+Она представляет собой несмещённую оценку дисперсии случайной величины, если переданные в функцию значения являются выборкой этой случайной величины.
+
+Возвращает `Float64`. В случае, когда `n <= 1`, возвращается `+∞`.
+
+!!! note "Примечание"
+    Функция использует вычислительно неустойчивый алгоритм. Если для ваших расчётов необходима [вычислительная устойчивость](https://ru.wikipedia.org/wiki/Вычислительная_устойчивость), используйте функцию `varSampStable`. Она работает медленнее, но обеспечиват меньшую вычислительную ошибку.
--- a/docs/ru/sql-reference/data-types/aggregatefunction.md
+++ b/docs/ru/sql-reference/data-types/aggregatefunction.md
@ -23,7 +23,7 @@ CREATE TABLE t
 ) ENGINE = ...
 ```

-[uniq](../../sql-reference/data-types/aggregatefunction.md#agg_function-uniq), anyIf ([any](../../sql-reference/data-types/aggregatefunction.md#agg_function-any)+[If](../../sql-reference/data-types/aggregatefunction.md#agg-functions-combinator-if)) и [quantiles](../../sql-reference/data-types/aggregatefunction.md) — агрегатные функции, поддержанные в ClickHouse.
+[uniq](../../sql-reference/aggregate-functions/reference/uniq.md#agg_function-uniq), anyIf ([any](../../sql-reference/aggregate-functions/reference/any.md#agg_function-any)+[If](../../sql-reference/aggregate-functions/combinators.md#agg-functions-combinator-if)) и [quantiles](../../sql-reference/aggregate-functions/reference/quantiles.md) — агрегатные функции, поддержанные в ClickHouse.

 ## Особенности использования {#osobennosti-ispolzovaniia}

--- a/docs/ru/sql-reference/data-types/simpleaggregatefunction.md
+++ b/docs/ru/sql-reference/data-types/simpleaggregatefunction.md
@ -4,16 +4,16 @@

 The following aggregate functions are supported:

-   [`any`](../../sql-reference/aggregate-functions/reference.md#agg_function-any)
-   [`anyLast`](../../sql-reference/aggregate-functions/reference.md#anylastx)
-   [`min`](../../sql-reference/aggregate-functions/reference.md#agg_function-min)
-   [`max`](../../sql-reference/aggregate-functions/reference.md#agg_function-max)
-   [`sum`](../../sql-reference/aggregate-functions/reference.md#agg_function-sum)
-   [`groupBitAnd`](../../sql-reference/aggregate-functions/reference.md#groupbitand)
-   [`groupBitOr`](../../sql-reference/aggregate-functions/reference.md#groupbitor)
-   [`groupBitXor`](../../sql-reference/aggregate-functions/reference.md#groupbitxor)
-   [`groupArrayArray`](../../sql-reference/aggregate-functions/reference.md#agg_function-grouparray)
-   [`groupUniqArrayArray`](../../sql-reference/aggregate-functions/reference.md#groupuniqarrayx-groupuniqarraymax-sizex)
+-   [`any`](../../sql-reference/aggregate-functions/reference/any.md#agg_function-any)
+-   [`anyLast`](../../sql-reference/aggregate-functions/reference/anylast.md#anylastx)
+-   [`min`](../../sql-reference/aggregate-functions/reference/min.md#agg_function-min)
+-   [`max`](../../sql-reference/aggregate-functions/reference/max.md#agg_function-max)
+-   [`sum`](../../sql-reference/aggregate-functions/reference/sum.md#agg_function-sum)
+-   [`groupBitAnd`](../../sql-reference/aggregate-functions/reference/groupbitand.md#groupbitand)
+-   [`groupBitOr`](../../sql-reference/aggregate-functions/reference/groupbitor.md#groupbitor)
+-   [`groupBitXor`](../../sql-reference/aggregate-functions/reference/groupbitxor.md#groupbitxor)
+-   [`groupArrayArray`](../../sql-reference/aggregate-functions/reference/grouparray.md#agg_function-grouparray)
+-   [`groupUniqArrayArray`](../../sql-reference/aggregate-functions/reference/groupuniqarray.md#groupuniqarray)

 Values of the `SimpleAggregateFunction(func, Type)` look and stored the same way as `Type`, so you do not need to apply functions with `-Merge`/`-State` suffixes. `SimpleAggregateFunction` has better performance than `AggregateFunction` with same aggregation function.

--- a/docs/ru/sql-reference/functions/other-functions.md
+++ b/docs/ru/sql-reference/functions/other-functions.md
@ -1087,7 +1087,7 @@ SELECT k, runningAccumulate(sum_k) AS res FROM (SELECT number as k, sumState(k)
 └───┴─────┘
 ```

-Подзапрос формирует `sumState` для каждого числа от `0` до `9`. `sumState` возвращает состояние функции [sum](../../sql-reference/aggregate-functions/reference.md#agg_function-sum), содержащее сумму одного числа.
+Подзапрос формирует `sumState` для каждого числа от `0` до `9`. `sumState` возвращает состояние функции [sum](../../sql-reference/aggregate-functions/reference/sum.md#agg_function-sum), содержащее сумму одного числа.

 Весь запрос делает следующее:

--- a/docs/ru/sql-reference/statements/alter.md
+++ b/docs/ru/sql-reference/statements/alter.md
@ -461,14 +461,7 @@ OPTIMIZE TABLE table_not_partitioned PARTITION tuple() FINAL;
 ALTER TABLE table-name MODIFY TTL ttl-expression
 ```

-### Синхронность запросов ALTER {#sinkhronnost-zaprosov-alter}
-
-Для нереплицируемых таблиц, все запросы `ALTER` выполняются синхронно. Для реплицируемых таблиц, запрос всего лишь добавляет инструкцию по соответствующим действиям в `ZooKeeper`, а сами действия осуществляются при первой возможности. Но при этом, запрос может ждать завершения выполнения этих действий на всех репликах.
-
-Для запросов `ALTER ... ATTACH|DETACH|DROP` можно настроить ожидание, с помощью настройки `replication_alter_partitions_sync`.
-Возможные значения: `0` - не ждать, `1` - ждать выполнения только у себя (по умолчанию), `2` - ждать всех.
-
-### Мутации {#alter-mutations}
+### Мутации {#mutations}

 Мутации - разновидность запроса ALTER, позволяющая изменять или удалять данные в таблице. В отличие от стандартных запросов `DELETE` и `UPDATE`, рассчитанных на точечное изменение данных, область применения мутаций - достаточно тяжёлые изменения, затрагивающие много строк в таблице. Поддержана для движков таблиц семейства `MergeTree`, в том числе для движков с репликацией.

@ -504,6 +497,15 @@ ALTER TABLE [db.]table MATERIALIZE INDEX name IN PARTITION partition_name

 Записи о последних выполненных мутациях удаляются не сразу (количество сохраняемых мутаций определяется параметром движка таблиц `finished_mutations_to_keep`). Более старые записи удаляются.

+### Синхронность запросов ALTER {#synchronicity-of-alter-queries}
+
+Для нереплицируемых таблиц, все запросы `ALTER` выполняются синхронно. Для реплицируемых таблиц, запрос всего лишь добавляет инструкцию по соответствующим действиям в `ZooKeeper`, а сами действия осуществляются при первой возможности. Но при этом, запрос может ждать завершения выполнения этих действий на всех репликах.
+
+Для запросов `ALTER ... ATTACH|DETACH|DROP` можно настроить ожидание, с помощью настройки `replication_alter_partitions_sync`.
+Возможные значения: `0` - не ждать, `1` - ждать выполнения только у себя (по умолчанию), `2` - ждать всех.
+
+Для запросов `ALTER TABLE ... UPDATE|DELETE` синхронность выполнения определяется настройкой [mutations_sync](../../operations/settings/settings.md#mutations_sync). 
+
 ## ALTER USER {#alter-user-statement}

 Изменяет аккаунт пользователя ClickHouse.
--- a/docs/ru/sql-reference/statements/misc.md
+++ b/docs/ru/sql-reference/statements/misc.md
@ -212,7 +212,7 @@ KILL MUTATION [ON CLUSTER cluster]
  [FORMAT format]
 ```

-Пытается остановить выполняющиеся в данные момент [мутации](alter.md#alter-mutations). Мутации для остановки выбираются из таблицы [`system.mutations`](../../operations/system-tables.md#system_tables-mutations) с помощью условия, указанного в секции `WHERE` запроса `KILL`.
+Пытается остановить выполняющиеся в данные момент [мутации](alter.md#mutations). Мутации для остановки выбираются из таблицы [`system.mutations`](../../operations/system-tables.md#system_tables-mutations) с помощью условия, указанного в секции `WHERE` запроса `KILL`.

 Тестовый вариант запроса (`TEST`) только проверяет права пользователя и выводит список запросов для остановки.

--- a/docs/tr/engines/table-engines/special/materializedview.md
+++ b/docs/tr/engines/table-engines/special/materializedview.md
@ -7,6 +7,6 @@ toc_title: MaterializedView

 # Materializedview {#materializedview}

-Somut görünümler uygulamak için kullanılır (Daha fazla bilgi için bkz . [CREATE TABLE](../../../sql-reference/statements/create.md)). Verileri depolamak için, görünümü oluştururken belirtilen farklı bir motor kullanır. Bir tablodan okurken, sadece bu motoru kullanır.
+Somut görünümler uygulamak için kullanılır (Daha fazla bilgi için bkz . [CREATE TABLE](../../../sql-reference/statements/create.md#create-table-query)). Verileri depolamak için, görünümü oluştururken belirtilen farklı bir motor kullanır. Bir tablodan okurken, sadece bu motoru kullanır.

 [Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/materializedview/) <!--hide-->
--- a/docs/zh/engines/table-engines/special/materializedview.md
+++ b/docs/zh/engines/table-engines/special/materializedview.md
@ -1,5 +1,5 @@
 # MaterializedView {#materializedview}

-物化视图的使用（更多信息请参阅 [CREATE TABLE](../../../engines/table-engines/special/materializedview.md) ）。它需要使用一个不同的引擎来存储数据，这个引擎要在创建物化视图时指定。当从表中读取时，它就会使用该引擎。
+物化视图的使用（更多信息请参阅 [CREATE TABLE](../../../sql-reference/statements/create.md#create-table-query) ）。它需要使用一个不同的引擎来存储数据，这个引擎要在创建物化视图时指定。当从表中读取时，它就会使用该引擎。

 [来源文章](https://clickhouse.tech/docs/en/operations/table_engines/materializedview/) <!--hide-->
--- a/src/Access/IAccessStorage.cpp
+++ b/src/Access/IAccessStorage.cpp
@ -1,6 +1,4 @@
 #include <Access/IAccessStorage.h>
-#include <Access/User.h>
-#include <Access/Role.h>
 #include <Common/Exception.h>
 #include <Common/quoteString.h>
 #include <IO/WriteHelpers.h>
@ -39,110 +37,71 @@ namespace
    }


-    template <typename Func, typename ResultType = std::result_of_t<Func()>>
-    ResultType doTry(const Func & func)
+    template <typename Func>
+    bool tryCall(const Func & function)
    {
        try
        {
-            return func();
+            function();
+            return true;
        }
-        catch (Exception &)
+        catch (...)
        {
-            return {};
+            return false;
        }
    }


-    template <bool ignore_errors, typename T, typename ApplyFunc, typename GetNameFunc = std::nullptr_t,
-              typename ResultTypeOfApplyFunc = std::result_of_t<ApplyFunc(T)>,
-              typename ResultType = std::conditional_t<std::is_same_v<ResultTypeOfApplyFunc, void>, void, std::vector<ResultTypeOfApplyFunc>>>
-    ResultType applyToMultipleEntities(
-        const std::vector<T> & multiple_entities,
-        const ApplyFunc & apply_function,
-        const char * error_message_format [[maybe_unused]] = nullptr,
-        const GetNameFunc & get_name_function [[maybe_unused]] = nullptr)
+    class ErrorsTracker
    {
-        std::optional<Exception> exception;
-        std::vector<bool> success;
+    public:
+        explicit ErrorsTracker(size_t count_) { succeed.reserve(count_); }

-        auto helper = [&](const auto & apply_and_store_result_function)
+        template <typename Func>
+        bool tryCall(const Func & func)
        {
-            for (size_t i = 0; i != multiple_entities.size(); ++i)
+            try
            {
-                try
-                {
-                    apply_and_store_result_function(multiple_entities[i]);
-                    if constexpr (!ignore_errors)
-                        success[i] = true;
-                }
-                catch (Exception & e)
-                {
-                    if (!ignore_errors && !exception)
-                        exception.emplace(e);
-                }
-                catch (Poco::Exception & e)
-                {
-                    if (!ignore_errors && !exception)
-                        exception.emplace(Exception::CreateFromPocoTag{}, e);
-                }
-                catch (std::exception & e)
-                {
-                    if (!ignore_errors && !exception)
-                        exception.emplace(Exception::CreateFromSTDTag{}, e);
-                }
+                func();
            }
-        };
-
-        if constexpr (std::is_same_v<ResultType, void>)
-        {
-            if (multiple_entities.empty())
-                return;
-
-            if (multiple_entities.size() == 1)
+            catch (Exception & e)
            {
-                apply_function(multiple_entities.front());
-                return;
+                if (!exception)
+                    exception.emplace(e);
+                succeed.push_back(false);
+                return false;
            }
-
-            if constexpr (!ignore_errors)
-                success.resize(multiple_entities.size(), false);
-
-            helper(apply_function);
-
-            if (ignore_errors || !exception)
-                return;
-        }
-        else
-        {
-            ResultType result;
-            if (multiple_entities.empty())
-                return result;
-
-            if (multiple_entities.size() == 1)
+            catch (Poco::Exception & e)
            {
-                result.emplace_back(apply_function(multiple_entities.front()));
-                return result;
+                if (!exception)
+                    exception.emplace(Exception::CreateFromPocoTag{}, e);
+                succeed.push_back(false);
+                return false;
            }
-
-            result.reserve(multiple_entities.size());
-            if constexpr (!ignore_errors)
-                success.resize(multiple_entities.size(), false);
-
-            helper([&](const T & entity) { result.emplace_back(apply_function(entity)); });
-
-            if (ignore_errors || !exception)
-                return result;
+            catch (std::exception & e)
+            {
+                if (!exception)
+                    exception.emplace(Exception::CreateFromSTDTag{}, e);
+                succeed.push_back(false);
+                return false;
+            }
+            succeed.push_back(true);
+            return true;
        }

-        if constexpr (!ignore_errors)
+        bool errors() const { return exception.has_value(); }
+
+        void showErrors(const char * format, const std::function<String(size_t)> & get_name_function)
        {
+            if (!exception)
+                return;
+
            Strings succeeded_names_list;
            Strings failed_names_list;
-            for (size_t i = 0; i != multiple_entities.size(); ++i)
+            for (size_t i = 0; i != succeed.size(); ++i)
            {
-                const auto & entity = multiple_entities[i];
-                String name = get_name_function(entity);
-                if (success[i])
+                String name = get_name_function(i);
+                if (succeed[i])
                    succeeded_names_list.emplace_back(name);
                else
                    failed_names_list.emplace_back(name);
@ -152,14 +111,17 @@ namespace
            if (succeeded_names.empty())
                succeeded_names = "none";

-            String error_message = error_message_format;
+            String error_message = format;
            boost::replace_all(error_message, "{succeeded_names}", succeeded_names);
            boost::replace_all(error_message, "{failed_names}", failed_names);
            exception->addMessage(error_message);
            exception->rethrow();
        }
-        __builtin_unreachable();
-    }
+
+    private:
+        std::vector<bool> succeed;
+        std::optional<Exception> exception;
+    };
 }


@ -216,7 +178,11 @@ bool IAccessStorage::exists(const UUID & id) const

 AccessEntityPtr IAccessStorage::tryReadBase(const UUID & id) const
 {
-    return doTry([&] { return readImpl(id); });
+    AccessEntityPtr entity;
+    auto func = [&] { entity = readImpl(id); };
+    if (!tryCall(func))
+        return nullptr;
+    return entity;
 }


@ -228,7 +194,11 @@ String IAccessStorage::readName(const UUID & id) const

 std::optional<String> IAccessStorage::tryReadName(const UUID & id) const
 {
-    return doTry([&] { return std::optional<String>{readNameImpl(id)}; });
+    String name;
+    auto func = [&] { name = readNameImpl(id); };
+    if (!tryCall(func))
+        return {};
+    return name;
 }


@ -240,41 +210,77 @@ UUID IAccessStorage::insert(const AccessEntityPtr & entity)

 std::vector<UUID> IAccessStorage::insert(const std::vector<AccessEntityPtr> & multiple_entities)
 {
-    return applyToMultipleEntities</* ignore_errors = */ false>(
-        multiple_entities,
-        [this](const AccessEntityPtr & entity) { return insertImpl(entity, /* replace_if_exists = */ false); },
-        "Couldn't insert {failed_names}. Successfully inserted: {succeeded_names}",
-        [](const AccessEntityPtr & entity) { return entity->outputTypeAndName(); });
+    ErrorsTracker tracker(multiple_entities.size());
+
+    std::vector<UUID> ids;
+    for (const auto & entity : multiple_entities)
+    {
+        UUID id;
+        auto func = [&] { id = insertImpl(entity, /* replace_if_exists = */ false); };
+        if (tracker.tryCall(func))
+            ids.push_back(id);
+    }
+
+    if (tracker.errors())
+    {
+        auto get_name_function = [&](size_t i) { return multiple_entities[i]->outputTypeAndName(); };
+        tracker.showErrors("Couldn't insert {failed_names}. Successfully inserted: {succeeded_names}", get_name_function);
+    }
+
+    return ids;
 }


 std::optional<UUID> IAccessStorage::tryInsert(const AccessEntityPtr & entity)
 {
-    return doTry([&] { return std::optional<UUID>{insertImpl(entity, false)}; });
+    UUID id;
+    auto func = [&] { id = insertImpl(entity, /* replace_if_exists = */ false); };
+    if (!tryCall(func))
+        return {};
+    return id;
 }


 std::vector<UUID> IAccessStorage::tryInsert(const std::vector<AccessEntityPtr> & multiple_entities)
 {
-    return applyToMultipleEntities</* ignore_errors = */ true>(
-        multiple_entities,
-        [this](const AccessEntityPtr & entity) { return insertImpl(entity, /* replace_if_exists = */ false); });
+    std::vector<UUID> ids;
+    for (const auto & entity : multiple_entities)
+    {
+        UUID id;
+        auto func = [&] { id = insertImpl(entity, /* replace_if_exists = */ false); };
+        if (tryCall(func))
+            ids.push_back(id);
+    }
+    return ids;
 }


 UUID IAccessStorage::insertOrReplace(const AccessEntityPtr & entity)
 {
-    return insertImpl(entity, true);
+    return insertImpl(entity, /* replace_if_exists = */ true);
 }


 std::vector<UUID> IAccessStorage::insertOrReplace(const std::vector<AccessEntityPtr> & multiple_entities)
 {
-    return applyToMultipleEntities</* ignore_errors = */ false>(
-        multiple_entities,
-        [this](const AccessEntityPtr & entity) { return insertImpl(entity, /* replace_if_exists = */ true); },
-        "Couldn't insert {failed_names}. Successfully inserted: {succeeded_names}",
-        [](const AccessEntityPtr & entity) -> String { return entity->outputTypeAndName(); });
+    ErrorsTracker tracker(multiple_entities.size());
+
+    std::vector<UUID> ids;
+    for (const auto & entity : multiple_entities)
+    {
+        UUID id;
+        auto func = [&] { id = insertImpl(entity, /* replace_if_exists = */ true); };
+        if (tracker.tryCall(func))
+            ids.push_back(id);
+    }
+
+    if (tracker.errors())
+    {
+        auto get_name_function = [&](size_t i) { return multiple_entities[i]->outputTypeAndName(); };
+        tracker.showErrors("Couldn't insert {failed_names}. Successfully inserted: {succeeded_names}", get_name_function);
+    }
+
+    return ids;
 }


@ -286,25 +292,39 @@ void IAccessStorage::remove(const UUID & id)

 void IAccessStorage::remove(const std::vector<UUID> & ids)
 {
-    applyToMultipleEntities</* ignore_errors = */ false>(
-        ids,
-        [this](const UUID & id) { removeImpl(id); },
-        "Couldn't remove {failed_names}. Successfully removed: {succeeded_names}",
-        [this](const UUID & id) { return outputTypeAndNameOrID(*this, id); });
+    ErrorsTracker tracker(ids.size());
+
+    for (const auto & id : ids)
+    {
+        auto func = [&] { removeImpl(id); };
+        tracker.tryCall(func);
+    }
+
+    if (tracker.errors())
+    {
+        auto get_name_function = [&](size_t i) { return outputTypeAndNameOrID(*this, ids[i]); };
+        tracker.showErrors("Couldn't remove {failed_names}. Successfully removed: {succeeded_names}", get_name_function);
+    }
 }


 bool IAccessStorage::tryRemove(const UUID & id)
 {
-    return doTry([&] { removeImpl(id); return true; });
+    auto func = [&] { removeImpl(id); };
+    return tryCall(func);
 }


 std::vector<UUID> IAccessStorage::tryRemove(const std::vector<UUID> & ids)
 {
-    return applyToMultipleEntities</* ignore_errors = */ true>(
-        ids,
-        [this](const UUID & id) { removeImpl(id); return id; });
+    std::vector<UUID> removed_ids;
+    for (const auto & id : ids)
+    {
+        auto func = [&] { removeImpl(id); };
+        if (tryCall(func))
+            removed_ids.push_back(id);
+    }
+    return removed_ids;
 }


@ -316,25 +336,39 @@ void IAccessStorage::update(const UUID & id, const UpdateFunc & update_func)

 void IAccessStorage::update(const std::vector<UUID> & ids, const UpdateFunc & update_func)
 {
-    applyToMultipleEntities</* ignore_errors = */ false>(
-        ids,
-        [this, &update_func](const UUID & id) { updateImpl(id, update_func); },
-        "Couldn't update {failed_names}. Successfully updated: {succeeded_names}",
-        [this](const UUID & id) { return outputTypeAndNameOrID(*this, id); });
+    ErrorsTracker tracker(ids.size());
+
+    for (const auto & id : ids)
+    {
+        auto func = [&] { updateImpl(id, update_func); };
+        tracker.tryCall(func);
+    }
+
+    if (tracker.errors())
+    {
+        auto get_name_function = [&](size_t i) { return outputTypeAndNameOrID(*this, ids[i]); };
+        tracker.showErrors("Couldn't update {failed_names}. Successfully updated: {succeeded_names}", get_name_function);
+    }
 }


 bool IAccessStorage::tryUpdate(const UUID & id, const UpdateFunc & update_func)
 {
-    return doTry([&] { updateImpl(id, update_func); return true; });
+    auto func = [&] { updateImpl(id, update_func); };
+    return tryCall(func);
 }


 std::vector<UUID> IAccessStorage::tryUpdate(const std::vector<UUID> & ids, const UpdateFunc & update_func)
 {
-    return applyToMultipleEntities</* ignore_errors = */ true>(
-        ids,
-        [this, &update_func](const UUID & id) { updateImpl(id, update_func); return id; });
+    std::vector<UUID> updated_ids;
+    for (const auto & id : ids)
+    {
+        auto func = [&] { updateImpl(id, update_func); };
+        if (tryCall(func))
+            updated_ids.push_back(id);
+    }
+    return updated_ids;
 }


--- a/src/Columns/ColumnTuple.cpp
+++ b/src/Columns/ColumnTuple.cpp
@ -349,7 +349,7 @@ void ColumnTuple::updatePermutation(bool reverse, size_t limit, int nan_directio
    for (const auto& column : columns)
    {
        column->updatePermutation(reverse, limit, nan_direction_hint, res, equal_range);
-        while (limit && limit <= equal_range.back().first)
+        while (limit && !equal_range.empty() && limit <= equal_range.back().first)
            equal_range.pop_back();

        if (equal_range.empty())
--- a/src/Common/ErrorCodes.cpp
+++ b/src/Common/ErrorCodes.cpp
@ -175,7 +175,6 @@ namespace ErrorCodes
    extern const int TOO_BIG_AST = 168;
    extern const int BAD_TYPE_OF_FIELD = 169;
    extern const int BAD_GET = 170;
-    extern const int BLOCKS_HAVE_DIFFERENT_STRUCTURE = 171;
    extern const int CANNOT_CREATE_DIRECTORY = 172;
    extern const int CANNOT_ALLOCATE_MEMORY = 173;
    extern const int CYCLIC_ALIASES = 174;
--- a/src/Core/Block.cpp
+++ b/src/Core/Block.cpp
@ -24,7 +24,6 @@ namespace ErrorCodes
    extern const int POSITION_OUT_OF_BOUND;
    extern const int NOT_FOUND_COLUMN_IN_BLOCK;
    extern const int SIZES_OF_COLUMNS_DOESNT_MATCH;
-    extern const int BLOCKS_HAVE_DIFFERENT_STRUCTURE;
 }


@ -477,7 +476,7 @@ static ReturnType checkBlockStructure(const Block & lhs, const Block & rhs, cons
    size_t columns = rhs.columns();
    if (lhs.columns() != columns)
        return on_error("Block structure mismatch in " + context_description + " stream: different number of columns:\n"
-            + lhs.dumpStructure() + "\n" + rhs.dumpStructure(), ErrorCodes::BLOCKS_HAVE_DIFFERENT_STRUCTURE);
+            + lhs.dumpStructure() + "\n" + rhs.dumpStructure(), ErrorCodes::LOGICAL_ERROR);

    for (size_t i = 0; i < columns; ++i)
    {
@ -486,18 +485,18 @@ static ReturnType checkBlockStructure(const Block & lhs, const Block & rhs, cons

        if (actual.name != expected.name)
            return on_error("Block structure mismatch in " + context_description + " stream: different names of columns:\n"
-                + lhs.dumpStructure() + "\n" + rhs.dumpStructure(), ErrorCodes::BLOCKS_HAVE_DIFFERENT_STRUCTURE);
+                + lhs.dumpStructure() + "\n" + rhs.dumpStructure(), ErrorCodes::LOGICAL_ERROR);

        if (!actual.type->equals(*expected.type))
            return on_error("Block structure mismatch in " + context_description + " stream: different types:\n"
-                + lhs.dumpStructure() + "\n" + rhs.dumpStructure(), ErrorCodes::BLOCKS_HAVE_DIFFERENT_STRUCTURE);
+                + lhs.dumpStructure() + "\n" + rhs.dumpStructure(), ErrorCodes::LOGICAL_ERROR);

        if (!actual.column || !expected.column)
            continue;

        if (actual.column->getName() != expected.column->getName())
            return on_error("Block structure mismatch in " + context_description + " stream: different columns:\n"
-                + lhs.dumpStructure() + "\n" + rhs.dumpStructure(), ErrorCodes::BLOCKS_HAVE_DIFFERENT_STRUCTURE);
+                + lhs.dumpStructure() + "\n" + rhs.dumpStructure(), ErrorCodes::LOGICAL_ERROR);

        if (isColumnConst(*actual.column) && isColumnConst(*expected.column))
        {
@ -507,7 +506,7 @@ static ReturnType checkBlockStructure(const Block & lhs, const Block & rhs, cons
            if (actual_value != expected_value)
                return on_error("Block structure mismatch in " + context_description + " stream: different values of constants, actual: "
                    + applyVisitor(FieldVisitorToString(), actual_value) + ", expected: " + applyVisitor(FieldVisitorToString(), expected_value),
-                    ErrorCodes::BLOCKS_HAVE_DIFFERENT_STRUCTURE);
+                    ErrorCodes::LOGICAL_ERROR);
        }
    }

--- a/src/Core/Settings.h
+++ b/src/Core/Settings.h
@ -393,6 +393,7 @@ struct Settings : public SettingsCollection<Settings>
    M(SettingBool, allow_experimental_geo_types, false, "Allow geo data types such as Point, Ring, Polygon, MultiPolygon", 0) \
    M(SettingBool, data_type_default_nullable, false, "Data types without NULL or NOT NULL will make Nullable", 0) \
    M(SettingBool, cast_keep_nullable, false, "CAST operator keep Nullable for result data type", 0) \
+    M(SettingBool, alter_partition_verbose_result, false, "Output information about affected parts. Currently works only for FREEZE and ATTACH commands.", 0) \
    \
    /** Obsolete settings that do nothing but left for compatibility reasons. Remove each one after half a year of obsolescence. */ \
    \
--- a/src/DataStreams/ConvertingBlockInputStream.cpp
+++ b/src/DataStreams/ConvertingBlockInputStream.cpp
@ -12,7 +12,7 @@ namespace DB
 namespace ErrorCodes
 {
    extern const int THERE_IS_NO_COLUMN;
-    extern const int BLOCKS_HAVE_DIFFERENT_STRUCTURE;
+    extern const int ILLEGAL_COLUMN;
    extern const int NUMBER_OF_COLUMNS_DOESNT_MATCH;
 }

@ -75,11 +75,11 @@ ConvertingBlockInputStream::ConvertingBlockInputStream(
            if (!isColumnConst(*src_elem.column))
                throw Exception("Cannot convert column " + backQuoteIfNeed(res_elem.name)
                    + " because it is non constant in source stream but must be constant in result",
-                    ErrorCodes::BLOCKS_HAVE_DIFFERENT_STRUCTURE);
+                    ErrorCodes::ILLEGAL_COLUMN);
            else if (assert_cast<const ColumnConst &>(*src_elem.column).getField() != assert_cast<const ColumnConst &>(*res_elem.column).getField())
                throw Exception("Cannot convert column " + backQuoteIfNeed(res_elem.name)
                    + " because it is constant but values of constants are different in source and result",
-                    ErrorCodes::BLOCKS_HAVE_DIFFERENT_STRUCTURE);
+                    ErrorCodes::ILLEGAL_COLUMN);
        }

        /// Check conversion by dry run CAST function.
--- a/src/Functions/array/mapOp.cpp
+++ b/src/Functions/array/mapOp.cpp
@ -0,0 +1,331 @@
+#include <cassert>
+#include <Columns/ColumnVector.h>
+#include <Columns/ColumnTuple.h>
+#include <DataTypes/DataTypeArray.h>
+#include <DataTypes/DataTypeTuple.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionHelpers.h>
+#include "Core/ColumnWithTypeAndName.h"
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_COLUMN;
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+}
+
+namespace
+{
+
+struct TupArg
+{
+    const IColumn & key_column;
+    const IColumn & val_column;
+    const IColumn::Offsets & key_offsets;
+    const IColumn::Offsets & val_offsets;
+    bool is_const;
+};
+using TupleMaps = std::vector<struct TupArg>;
+
+namespace OpTypes
+{
+    extern const int ADD = 0;
+    extern const int SUBTRACT = 1;
+}
+
+template <int op_type>
+class FunctionMapOp : public IFunction
+{
+public:
+    static constexpr auto name = (op_type == OpTypes::ADD) ? "mapAdd" : "mapSubtract";
+    static FunctionPtr create(const Context &) { return std::make_shared<FunctionMapOp>(); }
+
+private:
+    String getName() const override { return name; }
+
+    size_t getNumberOfArguments() const override { return 0; }
+    bool isVariadic() const override { return true; }
+    bool useDefaultImplementationForConstants() const override { return true; }
+
+    DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override
+    {
+        bool is_float = false;
+        DataTypePtr key_type, val_type, res;
+
+        if (arguments.size() < 2)
+            throw Exception{getName() + " accepts at least two map tuples", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+
+        for (const auto & tup_arg : arguments)
+        {
+            const DataTypeTuple * tup = checkAndGetDataType<DataTypeTuple>(tup_arg.get());
+            if (!tup)
+                throw Exception{getName() + " accepts at least two map tuples", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH};
+
+            auto elems = tup->getElements();
+            if (elems.size() != 2)
+                throw Exception(
+                    "Each tuple in " + getName() + " arguments should consist of two arrays", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+            const DataTypeArray * k = checkAndGetDataType<DataTypeArray>(elems[0].get());
+            const DataTypeArray * v = checkAndGetDataType<DataTypeArray>(elems[1].get());
+
+            if (!k || !v)
+                throw Exception(
+                    "Each tuple in " + getName() + " arguments should consist of two arrays", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+            auto result_type = v->getNestedType();
+            if (!result_type->canBePromoted())
+                throw Exception{"Values to be summed are expected to be Numeric, Float or Decimal.",
+                                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+
+            WhichDataType which_val(result_type);
+
+            auto promoted_type = result_type->promoteNumericType();
+            if (!key_type)
+            {
+                key_type = k->getNestedType();
+                val_type = promoted_type;
+                is_float = which_val.isFloat();
+            }
+            else
+            {
+                if (!(k->getNestedType()->equals(*key_type)))
+                    throw Exception(
+                        "All key types in " + getName() + " should be same: " + key_type->getName(),
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+                if (is_float != which_val.isFloat())
+                    throw Exception(
+                        "All value types in " + getName() + " should be or float or integer", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+
+                if (!(promoted_type->equals(*val_type)))
+                {
+                    throw Exception(
+                        "All value types in " + getName() + " should be promotable to " + val_type->getName() + ", got "
+                            + promoted_type->getName(),
+                        ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
+                }
+            }
+
+            if (!res)
+            {
+                res = std::make_shared<DataTypeTuple>(
+                    DataTypes{std::make_shared<DataTypeArray>(k->getNestedType()), std::make_shared<DataTypeArray>(promoted_type)});
+            }
+        }
+
+        return res;
+    }
+
+    template <typename KeyType, bool is_str_key, typename ValType>
+    void execute2(Block & block, const size_t result, size_t row_count, TupleMaps & args, const DataTypeTuple & res_type) const
+    {
+        MutableColumnPtr res_tuple = res_type.createColumn();
+
+        auto * to_tuple = assert_cast<ColumnTuple *>(res_tuple.get());
+        auto & to_keys_arr = assert_cast<ColumnArray &>(to_tuple->getColumn(0));
+        auto & to_keys_data = to_keys_arr.getData();
+        auto & to_keys_offset = to_keys_arr.getOffsets();
+
+        auto & to_vals_arr = assert_cast<ColumnArray &>(to_tuple->getColumn(1));
+        auto & to_vals_data = to_vals_arr.getData();
+
+        size_t res_offset = 0;
+        std::map<KeyType, ValType> summing_map;
+
+        for (size_t i = 0; i < row_count; i++)
+        {
+            [[maybe_unused]] bool first = true;
+            for (auto & arg : args)
+            {
+                size_t offset = 0, len = arg.key_offsets[0];
+
+                if (!arg.is_const)
+                {
+                    offset = i > 0 ? arg.key_offsets[i - 1] : 0;
+                    len = arg.key_offsets[i] - offset;
+
+                    if (arg.val_offsets[i] != arg.key_offsets[i])
+                        throw Exception(
+                            "Key and value array should have same amount of elements", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+                }
+
+                for (size_t j = 0; j < len; j++)
+                {
+                    KeyType key;
+                    if constexpr (is_str_key)
+                    {
+                        // have to use Field structs to get strings
+                        key = arg.key_column.operator[](offset + j).get<KeyType>();
+                    }
+                    else
+                    {
+                        key = assert_cast<const ColumnVector<KeyType> &>(arg.key_column).getData()[offset + j];
+                    }
+
+                    auto value = arg.val_column.operator[](offset + j).get<ValType>();
+
+                    if constexpr (op_type == OpTypes::ADD)
+                    {
+                        const auto [it, inserted] = summing_map.insert({key, value});
+                        if (!inserted)
+                            it->second += value;
+                    }
+                    else
+                    {
+                        static_assert(op_type == OpTypes::SUBTRACT);
+                        const auto [it, inserted] = summing_map.insert({key, first ? value : -value});
+                        if (!inserted)
+                            it->second -= value;
+                    }
+                }
+
+                first = false;
+            }
+
+            for (const auto & elem : summing_map)
+            {
+                res_offset++;
+                to_keys_data.insert(elem.first);
+                to_vals_data.insert(elem.second);
+            }
+            to_keys_offset.push_back(res_offset);
+            summing_map.clear();
+        }
+
+        // same offsets as in keys
+        to_vals_arr.getOffsets().insert(to_keys_offset.begin(), to_keys_offset.end());
+
+        block.getByPosition(result).column = std::move(res_tuple);
+    }
+
+    template <typename KeyType, bool is_str_key>
+    void execute1(Block & block, const size_t result, size_t row_count, const DataTypeTuple & res_type, TupleMaps & args) const
+    {
+        const auto & promoted_type = (assert_cast<const DataTypeArray *>(res_type.getElements()[1].get()))->getNestedType();
+#define MATCH_EXECUTE(is_str) \
+        switch (promoted_type->getTypeId()) { \
+            case TypeIndex::Int64: execute2<KeyType, is_str, Int64>(block, result, row_count, args, res_type); break; \
+            case TypeIndex::UInt64: execute2<KeyType, is_str, UInt64>(block, result, row_count, args, res_type); break; \
+            case TypeIndex::Float64: execute2<KeyType, is_str, Float64>(block, result, row_count, args, res_type); break; \
+            default: \
+                throw Exception{"Illegal columns in arguments of function " + getName(), ErrorCodes::ILLEGAL_COLUMN}; \
+        }
+
+        if constexpr (is_str_key)
+        {
+            MATCH_EXECUTE(true)
+        }
+        else
+        {
+            MATCH_EXECUTE(false)
+        }
+#undef MATCH_EXECUTE
+    }
+
+    void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result, size_t) const override
+    {
+        const DataTypeTuple * tup_type = checkAndGetDataType<DataTypeTuple>((block.safeGetByPosition(arguments[0])).type.get());
+        const DataTypeArray * key_array_type = checkAndGetDataType<DataTypeArray>(tup_type->getElements()[0].get());
+        const DataTypeArray * val_array_type = checkAndGetDataType<DataTypeArray>(tup_type->getElements()[1].get());
+
+        /* determine output type */
+        const DataTypeTuple & res_type
+            = DataTypeTuple(DataTypes{std::make_shared<DataTypeArray>(key_array_type->getNestedType()),
+                                      std::make_shared<DataTypeArray>(val_array_type->getNestedType()->promoteNumericType())});
+
+        TupleMaps args{};
+        args.reserve(arguments.size());
+
+        //prepare columns, extract data columns for direct access and put them to the vector
+        for (auto arg : arguments)
+        {
+            auto & col = block.getByPosition(arg);
+            const ColumnTuple * tup;
+            bool is_const = isColumnConst(*col.column);
+            if (is_const)
+            {
+                const auto * c = assert_cast<const ColumnConst *>(col.column.get());
+                tup = assert_cast<const ColumnTuple *>(c->getDataColumnPtr().get());
+            }
+            else
+                tup = assert_cast<const ColumnTuple *>(col.column.get());
+
+            const auto & arr1 = assert_cast<const ColumnArray &>(tup->getColumn(0));
+            const auto & arr2 = assert_cast<const ColumnArray &>(tup->getColumn(1));
+
+            const auto & key_offsets = arr1.getOffsets();
+            const auto & key_column = arr1.getData();
+
+            const auto & val_offsets = arr2.getOffsets();
+            const auto & val_column = arr2.getData();
+
+            // we can check const columns before any processing
+            if (is_const)
+            {
+                if (val_offsets[0] != key_offsets[0])
+                    throw Exception(
+                        "Key and value array should have same amount of elements", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+            }
+
+            args.push_back({key_column, val_column, key_offsets, val_offsets, is_const});
+        }
+
+        size_t row_count = block.getByPosition(arguments[0]).column->size();
+        auto key_type_id = key_array_type->getNestedType()->getTypeId();
+
+        switch (key_type_id)
+        {
+            case TypeIndex::Enum8:
+            case TypeIndex::Int8:
+                execute1<Int8, false>(block, result, row_count, res_type, args);
+                break;
+            case TypeIndex::Enum16:
+            case TypeIndex::Int16:
+                execute1<Int16, false>(block, result, row_count, res_type, args);
+                break;
+            case TypeIndex::Int32:
+                execute1<Int32, false>(block, result, row_count, res_type, args);
+                break;
+            case TypeIndex::Int64:
+                execute1<Int64, false>(block, result, row_count, res_type, args);
+                break;
+            case TypeIndex::UInt8:
+                execute1<UInt8, false>(block, result, row_count, res_type, args);
+                break;
+            case TypeIndex::Date:
+            case TypeIndex::UInt16:
+                execute1<UInt16, false>(block, result, row_count, res_type, args);
+                break;
+            case TypeIndex::DateTime:
+            case TypeIndex::UInt32:
+                execute1<UInt32, false>(block, result, row_count, res_type, args);
+                break;
+            case TypeIndex::UInt64:
+                execute1<UInt64, false>(block, result, row_count, res_type, args);
+                break;
+            case TypeIndex::UUID:
+                execute1<UInt128, false>(block, result, row_count, res_type, args);
+                break;
+            case TypeIndex::FixedString:
+            case TypeIndex::String:
+                execute1<String, true>(block, result, row_count, res_type, args);
+                break;
+            default:
+                throw Exception{"Illegal columns in arguments of function " + getName(), ErrorCodes::ILLEGAL_COLUMN};
+        }
+    }
+};
+
+}
+
+void registerFunctionMapOp(FunctionFactory & factory)
+{
+    factory.registerFunction<FunctionMapOp<OpTypes::ADD>>();
+    factory.registerFunction<FunctionMapOp<OpTypes::SUBTRACT>>();
+}
+
+}
--- a/src/Functions/array/registerFunctionsArray.cpp
+++ b/src/Functions/array/registerFunctionsArray.cpp
@ -35,6 +35,7 @@ void registerFunctionArrayWithConstant(FunctionFactory &);
 void registerFunctionArrayZip(FunctionFactory &);
 void registerFunctionArrayAUC(FunctionFactory &);
 void registerFunctionArrayReduceInRanges(FunctionFactory &);
+void registerFunctionMapOp(FunctionFactory &);

 void registerFunctionsArray(FunctionFactory & factory)
 {
@ -71,6 +72,7 @@ void registerFunctionsArray(FunctionFactory & factory)
    registerFunctionArrayWithConstant(factory);
    registerFunctionArrayZip(factory);
    registerFunctionArrayAUC(factory);
+    registerFunctionMapOp(factory);
 }

 }
--- a/src/Functions/tests/abtesting.cpp
+++ b/src/Functions/tests/abtesting.cpp
@ -63,7 +63,7 @@ Variants test_bayesab(std::string dist, PODArray<Float64> xs, PODArray<Float64>

 int main(int, char **)
 {
-    size_t max, min;
+    size_t max = 0, min = 0;

    auto variants = test_bayesab("beta", {10000, 1000, 900}, {600, 110, 90}, max, min);
    if (max != 1) exit(1);
--- a/src/Functions/ya.make
+++ b/src/Functions/ya.make
@ -96,6 +96,7 @@ SRCS(
    array/hasSubstr.cpp
    array/indexOf.cpp
    array/length.cpp
+    array/mapOp.cpp
    array/range.cpp
    array/registerFunctionsArray.cpp
    asin.cpp
--- a/src/Interpreters/InterpreterAlterQuery.cpp
+++ b/src/Interpreters/InterpreterAlterQuery.cpp
@ -34,6 +34,7 @@ InterpreterAlterQuery::InterpreterAlterQuery(const ASTPtr & query_ptr_, const Co

 BlockIO InterpreterAlterQuery::execute()
 {
+    BlockIO res;
    const auto & alter = query_ptr->as<ASTAlterQuery &>();

    if (!alter.cluster.empty())
@ -86,7 +87,9 @@ BlockIO InterpreterAlterQuery::execute()
    if (!partition_commands.empty())
    {
        table->checkAlterPartitionIsPossible(partition_commands, metadata_snapshot, context.getSettingsRef());
-        table->alterPartition(query_ptr, metadata_snapshot, partition_commands, context);
+        auto partition_commands_pipes = table->alterPartition(query_ptr, metadata_snapshot, partition_commands, context);
+        if (!partition_commands_pipes.empty())
+            res.pipeline.init(std::move(partition_commands_pipes));
    }

    if (!live_view_commands.empty())
@ -113,7 +116,7 @@ BlockIO InterpreterAlterQuery::execute()
        table->alter(alter_commands, context, alter_lock);
    }

-    return {};
+    return res;
 }


--- a/src/Processors/Chunk.cpp
+++ b/src/Processors/Chunk.cpp
@ -65,10 +65,13 @@ void Chunk::setColumns(MutableColumns columns_, UInt64 num_rows_)

 void Chunk::checkNumRowsIsConsistent()
 {
-    for (auto & column : columns)
+    for (size_t i = 0; i < columns.size(); ++i)
+    {
+        auto & column = columns[i];
        if (column->size() != num_rows)
-            throw Exception("Invalid number of rows in Chunk column " + column->getName()+ ": expected " +
+            throw Exception("Invalid number of rows in Chunk column " + column->getName()+ " position " + toString(i) + ": expected " +
                            toString(num_rows) + ", got " + toString(column->size()), ErrorCodes::LOGICAL_ERROR);
+    }
 }

 MutableColumns Chunk::mutateColumns()
--- a/src/Processors/QueryPipeline.cpp
+++ b/src/Processors/QueryPipeline.cpp
@ -654,7 +654,7 @@ void QueryPipeline::unitePipelines(
        if (extremes.size() == 1)
            extremes_port = extremes.back();
        else
-            extremes_port = uniteExtremes(extremes, current_header, processors);
+            extremes_port = uniteExtremes(extremes, common_header, processors);
    }

    if (!totals.empty())
@ -662,7 +662,7 @@ void QueryPipeline::unitePipelines(
        if (totals.size() == 1)
            totals_having_port = totals.back();
        else
-            totals_having_port = uniteTotals(totals, current_header, processors);
+            totals_having_port = uniteTotals(totals, common_header, processors);
    }

    current_header = common_header;
--- a/src/Processors/Transforms/ConvertingTransform.cpp
+++ b/src/Processors/Transforms/ConvertingTransform.cpp
@ -12,7 +12,7 @@ namespace DB
 namespace ErrorCodes
 {
    extern const int THERE_IS_NO_COLUMN;
-    extern const int BLOCKS_HAVE_DIFFERENT_STRUCTURE;
+    extern const int ILLEGAL_COLUMN;
    extern const int NUMBER_OF_COLUMNS_DOESNT_MATCH;
 }

@ -82,12 +82,12 @@ ConvertingTransform::ConvertingTransform(
                if (res_const->getField() != src_const->getField())
                    throw Exception("Cannot convert column " + backQuoteIfNeed(res_elem.name) + " because "
                                    "it is constant but values of constants are different in source and result",
-                                    ErrorCodes::BLOCKS_HAVE_DIFFERENT_STRUCTURE);
+                                    ErrorCodes::ILLEGAL_COLUMN);
            }
            else
                throw Exception("Cannot convert column " + backQuoteIfNeed(res_elem.name) + " because "
                                "it is non constant in source stream but must be constant in result",
-                                ErrorCodes::BLOCKS_HAVE_DIFFERENT_STRUCTURE);
+                                ErrorCodes::ILLEGAL_COLUMN);
        }

        /// Check conversion by dry run CAST function.
--- a/src/Storages/IStorage.h
+++ b/src/Storages/IStorage.h
@ -355,7 +355,7 @@ public:
    /** ALTER tables with regard to its partitions.
      * Should handle locks for each command on its own.
      */
-    virtual void alterPartition(const ASTPtr & /* query */, const StorageMetadataPtr & /* metadata_snapshot */, const PartitionCommands & /* commands */, const Context & /* context */)
+    virtual Pipes alterPartition(const ASTPtr & /* query */, const StorageMetadataPtr & /* metadata_snapshot */, const PartitionCommands & /* commands */, const Context & /* context */)
    {
        throw Exception("Partition operations are not supported by storage " + getName(), ErrorCodes::NOT_IMPLEMENTED);
    }
--- a/src/Storages/MergeTree/MergeTreeData.cpp
+++ b/src/Storages/MergeTree/MergeTreeData.cpp
@ -1662,9 +1662,9 @@ void MergeTreeData::changeSettings(
    }
 }

-void MergeTreeData::freezeAll(const String & with_name, const StorageMetadataPtr & metadata_snapshot, const Context & context, TableLockHolder &)
+PartitionCommandsResultInfo MergeTreeData::freezeAll(const String & with_name, const StorageMetadataPtr & metadata_snapshot, const Context & context, TableLockHolder &)
 {
-    freezePartitionsByMatcher([] (const DataPartPtr &){ return true; }, metadata_snapshot, with_name, context);
+    return freezePartitionsByMatcher([] (const DataPartPtr &) { return true; }, metadata_snapshot, with_name, context);
 }

 void MergeTreeData::PartsTemporaryRename::addPart(const String & old_name, const String & new_name)
@ -2408,11 +2408,6 @@ static void loadPartAndFixMetadataImpl(MergeTreeData::MutableDataPartPtr part)
    auto disk = part->volume->getDisk();
    String full_part_path = part->getFullRelativePath();

-    /// Earlier the list of  columns was written incorrectly. Delete it and re-create.
-    /// But in compact parts we can't get list of columns without this file.
-    if (isWidePart(part))
-        disk->removeIfExists(full_part_path + "columns.txt");
-
    part->loadColumnsChecksumsIndexes(false, true);
    part->modification_time = disk->getLastModified(full_part_path).epochTime();
 }
@ -2468,7 +2463,7 @@ void MergeTreeData::removePartContributionToColumnSizes(const DataPartPtr & part
 }


-void MergeTreeData::freezePartition(const ASTPtr & partition_ast, const StorageMetadataPtr & metadata_snapshot, const String & with_name, const Context & context, TableLockHolder &)
+PartitionCommandsResultInfo MergeTreeData::freezePartition(const ASTPtr & partition_ast, const StorageMetadataPtr & metadata_snapshot, const String & with_name, const Context & context, TableLockHolder &)
 {
    std::optional<String> prefix;
    String partition_id;
@ -2492,7 +2487,7 @@ void MergeTreeData::freezePartition(const ASTPtr & partition_ast, const StorageM
        LOG_DEBUG(log, "Freezing parts with partition ID {}", partition_id);


-    freezePartitionsByMatcher(
+    return freezePartitionsByMatcher(
        [&prefix, &partition_id](const DataPartPtr & part)
        {
            if (prefix)
@ -3319,7 +3314,7 @@ MergeTreeData::PathsWithDisks MergeTreeData::getRelativeDataPathsWithDisks() con
    return res;
 }

-void MergeTreeData::freezePartitionsByMatcher(MatcherFn matcher, const StorageMetadataPtr & metadata_snapshot, const String & with_name, const Context & context)
+PartitionCommandsResultInfo MergeTreeData::freezePartitionsByMatcher(MatcherFn matcher, const StorageMetadataPtr & metadata_snapshot, const String & with_name, const Context & context)
 {
    String clickhouse_path = Poco::Path(context.getPath()).makeAbsolute().toString();
    String default_shadow_path = clickhouse_path + "shadow/";
@ -3331,6 +3326,10 @@ void MergeTreeData::freezePartitionsByMatcher(MatcherFn matcher, const StorageMe
    /// Acquire a snapshot of active data parts to prevent removing while doing backup.
    const auto data_parts = getDataParts();

+    String backup_name = (!with_name.empty() ? escapeForFileName(with_name) : toString(increment));
+
+    PartitionCommandsResultInfo result;
+
    size_t parts_processed = 0;
    for (const auto & part : data_parts)
    {
@ -3339,11 +3338,7 @@ void MergeTreeData::freezePartitionsByMatcher(MatcherFn matcher, const StorageMe

        part->volume->getDisk()->createDirectories(shadow_path);

-        String backup_path = shadow_path
-            + (!with_name.empty()
-                ? escapeForFileName(with_name)
-                : toString(increment))
-            + "/";
+        String backup_path = shadow_path + backup_name + "/";

        LOG_DEBUG(log, "Freezing part {} snapshot will be placed at {}", part->name, backup_path);

@ -3356,10 +3351,17 @@ void MergeTreeData::freezePartitionsByMatcher(MatcherFn matcher, const StorageMe
        part->volume->getDisk()->removeIfExists(backup_part_path + "/" + DELETE_ON_DESTROY_MARKER_PATH);

        part->is_frozen.store(true, std::memory_order_relaxed);
+        result.push_back(PartitionCommandResultInfo{
+            .partition_id = part->info.partition_id,
+            .part_name = part->name,
+            .backup_path = backup_path,
+            .backup_name = backup_name,
+        });
        ++parts_processed;
    }

    LOG_DEBUG(log, "Freezed {} parts", parts_processed);
+    return result;
 }

 bool MergeTreeData::canReplacePartition(const DataPartPtr & src_part) const
--- a/src/Storages/MergeTree/MergeTreeData.h
+++ b/src/Storages/MergeTree/MergeTreeData.h
@ -515,7 +515,7 @@ public:
        TableLockHolder & table_lock_holder);

    /// Freezes all parts.
-    void freezeAll(
+    PartitionCommandsResultInfo freezeAll(
        const String & with_name,
        const StorageMetadataPtr & metadata_snapshot,
        const Context & context,
@ -541,7 +541,7 @@ public:
      * Backup is created in directory clickhouse_dir/shadow/i/, where i - incremental number,
      *  or if 'with_name' is specified - backup is created in directory with specified name.
      */
-    void freezePartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, const String & with_name, const Context & context, TableLockHolder & table_lock_holder);
+    PartitionCommandsResultInfo freezePartition(const ASTPtr & partition, const StorageMetadataPtr & metadata_snapshot, const String & with_name, const Context & context, TableLockHolder & table_lock_holder);


 public:
@ -836,7 +836,7 @@ protected:

    /// Common part for |freezePartition()| and |freezeAll()|.
    using MatcherFn = std::function<bool(const DataPartPtr &)>;
-    void freezePartitionsByMatcher(MatcherFn matcher, const StorageMetadataPtr & metadata_snapshot, const String & with_name, const Context & context);
+    PartitionCommandsResultInfo freezePartitionsByMatcher(MatcherFn matcher, const StorageMetadataPtr & metadata_snapshot, const String & with_name, const Context & context);

    bool canReplacePartition(const DataPartPtr & src_part) const;

--- a/Show More
+++ b/Show More