Merge remote-tracking branch 'origin/master' into add-ext-dict-redis

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,30 @@
+---
+name: Bug report
+about: Create a report to help us improve ClickHouse
+title: ''
+labels: bug, issue
+assignees: ''
+
+---
+
+(you don't have to strictly follow this form)
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**How to reproduce**
+* Which ClickHouse server version to use
+* Which interface to use, if matters
+* Non-default settings, if any
+* `CREATE TABLE` statements for all tables involved
+* Sample data for all these tables, use [clickhouse-obfuscator](https://github.com/yandex/ClickHouse/blob/master/dbms/programs/obfuscator/Obfuscator.cpp#L42-L80) if necessary
+* Queries to run that lead to unexpected result
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Error message and/or stacktrace**
+If applicable, add screenshots to help explain your problem.
+
+**Additional context**
+Add any other context about the problem here.

.github/ISSUE_TEMPLATE/build-issue.md

@@ -0,0 +1,21 @@
+---
+name: Build issue
+about: Report failed ClickHouse build from master
+title: ''
+labels: build
+assignees: ''
+
+---
+
+Make sure that `git diff` result is empty and you've just pulled fresh master. Try cleaning up cmake cache. Just in case, official build instructions are published here: https://clickhouse.yandex/docs/en/development/build/
+
+**Operating system**
+OS kind or distribution, specific version/release, non-standard kernel if any. If you are trying to build inside virtual machine, please mention it too.
+
+**Cmake version**
+
+**Ninja version**
+
+**Compiler name and version**
+
+**Full cmake and/or ninja output**

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,22 @@
+---
+name: Feature request
+about: Suggest an idea for ClickHouse
+title: ''
+labels: feature
+assignees: ''
+
+---
+
+(you don't have to strictly follow this form)
+
+**Use case**
+A clear and concise description of what is the intended usage scenario is.
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/ISSUE_TEMPLATE/question.md

@@ -0,0 +1,12 @@
+---
+name: Question
+about: Ask question about ClickHouse
+title: ''
+labels: question
+assignees: ''
+
+---
+
+Make sure to check documentation https://clickhouse.yandex/docs/en/ first. If the question is concise and probably has a short answer, asking it in Telegram chat https://telegram.me/clickhouse_en is probably the fastest way to find the answer. For more complicated questions, consider asking them on StackOverflow with "clickhouse" tag https://stackoverflow.com/questions/tagged/clickhouse 
+
+If you still prefer GitHub issues, remove all this text and ask your question here.

.gitignore

@@ -243,3 +243,5 @@ website/package-lock.json
 
 # ccls cache
 /.ccls-cache
+
+/compile_commands.json

.gitmodules

@@ -63,4 +63,4 @@
 	url = https://github.com/ClickHouse-Extras/libgsasl.git
 [submodule "contrib/cppkafka"]
 	path = contrib/cppkafka
-	url = https://github.com/mfontanini/cppkafka.git
+	url = https://github.com/ClickHouse-Extras/cppkafka.git

CHANGELOG.draft.md

@@ -1 +0,0 @@
-

CHANGELOG.md

@@ -1,139 +1,113 @@
 ## ClickHouse release 19.1.6, 2019-01-24
 
-### Backward Incompatible Change
-* Removed `ALTER MODIFY PRIMARY KEY` command because it was superseded by the `ALTER MODIFY ORDER BY` command. [#3887](https://github.com/yandex/ClickHouse/pull/3887) ([ztlpn](https://github.com/ztlpn))
-
 ### New Features
-* Add ability to choose per column codecs for storage log and tiny log. [#4111](https://github.com/yandex/ClickHouse/pull/4111) ([alesapin](https://github.com/alesapin))
+
-* Added functions `filesystemAvailable`, `filesystemFree`, `filesystemCapacity`. [#4097](https://github.com/yandex/ClickHouse/pull/4097) ([bgranvea](https://github.com/bgranvea))
+* Custom per column compression codecs for tables. [#3899](https://github.com/yandex/ClickHouse/pull/3899) [#4111](https://github.com/yandex/ClickHouse/pull/4111) ([alesapin](https://github.com/alesapin), [Winter Zhang](https://github.com/zhang2014), [Anatoly](https://github.com/Sindbag))
-* Add custom compression codecs. [#3899](https://github.com/yandex/ClickHouse/pull/3899) ([alesapin](https://github.com/alesapin))
+* Added compression codec `Delta`. [#4052](https://github.com/yandex/ClickHouse/pull/4052) ([alesapin](https://github.com/alesapin))
+* Allow to `ALTER` compression codecs. [#4054](https://github.com/yandex/ClickHouse/pull/4054) ([alesapin](https://github.com/alesapin))
+* Added functions `left`, `right`, `trim`, `ltrim`, `rtrim`, `timestampadd`, `timestampsub` for SQL standard compatibility. [#3826](https://github.com/yandex/ClickHouse/pull/3826) ([Ivan Blinkov](https://github.com/blinkov))
+* Support for write in `HDFS` tables and `hdfs` table function. [#4084](https://github.com/yandex/ClickHouse/pull/4084) ([alesapin](https://github.com/alesapin))
+* Added functions to search for multiple constant strings from big haystack: `multiPosition`, `multiSearch` ,`firstMatch` also with `-UTF8`, `-CaseInsensitive`, and `-CaseInsensitiveUTF8` variants. [#4053](https://github.com/yandex/ClickHouse/pull/4053) ([Danila Kutenin](https://github.com/danlark1))
+* Pruning of unused shards if `SELECT` query filters by sharding key (setting `optimize_skip_unused_shards`). [#3851](https://github.com/yandex/ClickHouse/pull/3851) ([Gleb Kanterov](https://github.com/kanterov), [Ivan](https://github.com/abyss7))
+* Allow `Kafka` engine to ignore some number of parsing errors per block. [#4094](https://github.com/yandex/ClickHouse/pull/4094) ([Ivan](https://github.com/abyss7))
+* Added support for `CatBoost` multiclass models evaluation. Function `modelEvaluate` returns tuple with per-class raw predictions for multiclass models. `libcatboostmodel.so` should be built with [#607](https://github.com/catboost/catboost/pull/607). [#3959](https://github.com/yandex/ClickHouse/pull/3959) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Added functions `filesystemAvailable`, `filesystemFree`, `filesystemCapacity`. [#4097](https://github.com/yandex/ClickHouse/pull/4097) ([Boris Granveaud](https://github.com/bgranvea))
 * Added hashing functions `xxHash64` and `xxHash32`. [#3905](https://github.com/yandex/ClickHouse/pull/3905) ([filimonov](https://github.com/filimonov))
-* Added multiple joins emulation (very experimental). [#3946](https://github.com/yandex/ClickHouse/pull/3946) ([4ertus2](https://github.com/4ertus2))
+* Added `gccMurmurHash` hashing function (GCC flavoured Murmur hash) which uses the same hash seed as [gcc](https://github.com/gcc-mirror/gcc/blob/41d6b10e96a1de98e90a7c0378437c3255814b16/libstdc%2B%2B-v3/include/bits/functional_hash.h#L191) [#4000](https://github.com/yandex/ClickHouse/pull/4000) ([sundyli](https://github.com/sundy-li))
-* Added support for CatBoost multiclass models evaluation. Function `modelEvaluate` returns tuple with per-class raw predictions for multiclass models. `libcatboostmodel.so` should be built with [#607](https://github.com/catboost/catboost/pull/607). [#3959](https://github.com/yandex/ClickHouse/pull/3959) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Added hashing functions `javaHash`, `hiveHash`. [#3811](https://github.com/yandex/ClickHouse/pull/3811) ([shangshujie365](https://github.com/shangshujie365))
-* Added gccHash function which uses the same hash seed as [gcc](https://github.com/gcc-mirror/gcc/blob/41d6b10e96a1de98e90a7c0378437c3255814b16/libstdc%2B%2B-v3/include/bits/functional_hash.h#L191) [#4000](https://github.com/yandex/ClickHouse/pull/4000) ([sundy-li](https://github.com/sundy-li))
+* Added table function `remoteSecure`. Function works as `remote`, but uses secure connection. [#4088](https://github.com/yandex/ClickHouse/pull/4088) ([proller](https://github.com/proller))
-* Added compression codec delta. [#4052](https://github.com/yandex/ClickHouse/pull/4052) ([alesapin](https://github.com/alesapin))
+
-* Added multi searcher to search from multiple constant strings from big haystack. Added functions (`multiPosition`, `multiSearch` ,`firstMatch`) * (` `, `UTF8`, `CaseInsensitive`, `CaseInsensitiveUTF8`) [#4053](https://github.com/yandex/ClickHouse/pull/4053) ([danlark1](https://github.com/danlark1))
+
-* Added ability to alter compression codecs. [#4054](https://github.com/yandex/ClickHouse/pull/4054) ([alesapin](https://github.com/alesapin))
+### Experimental features
-* Add ability to write data into HDFS and small refactoring. [#4084](https://github.com/yandex/ClickHouse/pull/4084) ([alesapin](https://github.com/alesapin))
+
-* Removed some redundant objects from compiled expressions cache (optimization). [#4042](https://github.com/yandex/ClickHouse/pull/4042) ([alesapin](https://github.com/alesapin))
+* Added multiple JOINs emulation (`allow_experimental_multiple_joins_emulation` setting). [#3946](https://github.com/yandex/ClickHouse/pull/3946) ([Artem Zuikov](https://github.com/4ertus2))
-* Added functions `JavaHash`, `HiveHash`. [#3811](https://github.com/yandex/ClickHouse/pull/3811) ([shangshujie365](https://github.com/shangshujie365))
+
-* Added functions `left`, `right`, `trim`, `ltrim`, `rtrim`, `timestampadd`, `timestampsub`. [#3826](https://github.com/yandex/ClickHouse/pull/3826) ([blinkov](https://github.com/blinkov))
+
-* Added function `remoteSecure`. Function works as `remote`, but uses secure connection. [#4088](https://github.com/yandex/ClickHouse/pull/4088) ([proller](https://github.com/proller))
+### Bug Fixes
+
+* Make `compiled_expression_cache_size` setting limited by default to lower memory consumption. [#4041](https://github.com/yandex/ClickHouse/pull/4041) ([alesapin](https://github.com/alesapin))
+* Fix a bug that led to hangups in threads that perform ALTERs of Replicated tables and in the thread that updates configuration from ZooKeeper. [#2947](https://github.com/yandex/ClickHouse/issues/2947) [#3891](https://github.com/yandex/ClickHouse/issues/3891) [#3934](https://github.com/yandex/ClickHouse/pull/3934) ([Alex Zatelepin](https://github.com/ztlpn))
+* Fixed a race condition when executing a distributed ALTER task. The race condition led to more than one replica trying to execute the task and all replicas except one failing with a ZooKeeper error. [#3904](https://github.com/yandex/ClickHouse/pull/3904) ([Alex Zatelepin](https://github.com/ztlpn))
+* Fix a bug when `from_zk` config elements weren't refreshed after a request to ZooKeeper timed out. [#2947](https://github.com/yandex/ClickHouse/issues/2947) [#3947](https://github.com/yandex/ClickHouse/pull/3947) ([Alex Zatelepin](https://github.com/ztlpn))
+* Fix bug with wrong prefix for IPv4 subnet masks. [#3945](https://github.com/yandex/ClickHouse/pull/3945) ([alesapin](https://github.com/alesapin))
+* Fixed crash (`std::terminate`) in rare cases when a new thread cannot be created due to exhausted resources. [#3956](https://github.com/yandex/ClickHouse/pull/3956) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fix bug when in `remote` table function execution when wrong restrictions were used for in `getStructureOfRemoteTable`. [#4009](https://github.com/yandex/ClickHouse/pull/4009) ([alesapin](https://github.com/alesapin))
+* Fix a leak of netlink sockets. They were placed in a pool where they were never deleted and new sockets were created at the start of a new thread when all current sockets were in use. [#4017](https://github.com/yandex/ClickHouse/pull/4017) ([Alex Zatelepin](https://github.com/ztlpn))
+* Fix bug with closing `/proc/self/fd` directory earlier than all fds were read from `/proc` after forking `odbc-bridge` subprocess. [#4120](https://github.com/yandex/ClickHouse/pull/4120) ([alesapin](https://github.com/alesapin))
+* Fixed String to UInt monotonic conversion in case of usage String in primary key. [#3870](https://github.com/yandex/ClickHouse/pull/3870) ([Winter Zhang](https://github.com/zhang2014))
+* Fixed error in calculation of integer conversion function monotonicity. [#3921](https://github.com/yandex/ClickHouse/pull/3921) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed segfault in `arrayEnumerateUniq`, `arrayEnumerateDense` functions in case of some invalid arguments. [#3909](https://github.com/yandex/ClickHouse/pull/3909) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fix UB in StorageMerge. [#3910](https://github.com/yandex/ClickHouse/pull/3910) ([Amos Bird](https://github.com/amosbird))
+* Fixed segfault in functions `addDays`, `subtractDays`. [#3913](https://github.com/yandex/ClickHouse/pull/3913) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed error: functions `round`, `floor`, `trunc`, `ceil` may return bogus result when executed on integer argument and large negative scale. [#3914](https://github.com/yandex/ClickHouse/pull/3914) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed a bug induced by 'kill query sync' which leads to a core dump. [#3916](https://github.com/yandex/ClickHouse/pull/3916) ([muVulDeePecker](https://github.com/fancyqlx))
+* Fix bug with long delay after empty replication queue. [#3928](https://github.com/yandex/ClickHouse/pull/3928) [#3932](https://github.com/yandex/ClickHouse/pull/3932) ([alesapin](https://github.com/alesapin))
+* Fixed excessive memory usage in case of inserting into table with `LowCardinality` primary key. [#3955](https://github.com/yandex/ClickHouse/pull/3955) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Fixed `LowCardinality` serialization for `Native` format in case of empty arrays. [#3907](https://github.com/yandex/ClickHouse/issues/3907) [#4011](https://github.com/yandex/ClickHouse/pull/4011) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Fixed incorrect result while using distinct by single LowCardinality numeric column. [#3895](https://github.com/yandex/ClickHouse/issues/3895) [#4012](https://github.com/yandex/ClickHouse/pull/4012) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Fixed specialized aggregation with LowCardinality key (in case when `compile` setting is enabled). [#3886](https://github.com/yandex/ClickHouse/pull/3886) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Fix user and password forwarding for replicated tables queries. [#3957](https://github.com/yandex/ClickHouse/pull/3957) ([alesapin](https://github.com/alesapin)) ([小路](https://github.com/nicelulu))
+* Fixed very rare race condition that can happen when listing tables in Dictionary database while reloading dictionaries. [#3970](https://github.com/yandex/ClickHouse/pull/3970) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed incorrect result when HAVING was used with ROLLUP or CUBE. [#3756](https://github.com/yandex/ClickHouse/issues/3756) [#3837](https://github.com/yandex/ClickHouse/pull/3837) ([Sam Chou](https://github.com/reflection))
+* Fixed column aliases for query with `JOIN ON` syntax and distributed tables. [#3980](https://github.com/yandex/ClickHouse/pull/3980) ([Winter Zhang](https://github.com/zhang2014))
+* Fixed error in internal implementation of `quantileTDigest` (found by Artem Vakhrushev). This error never happens in ClickHouse and was relevant only for those who use ClickHouse codebase as a library directly. [#3935](https://github.com/yandex/ClickHouse/pull/3935) ([alexey-milovidov](https://github.com/alexey-milovidov))
 
 ### Improvements
-* Support for IF NOT EXISTS in ALTER TABLE ADD COLUMN statements, and for IF EXISTS in DROP/MODIFY/CLEAR/COMMENT COLUMN. [#3900](https://github.com/yandex/ClickHouse/pull/3900) ([bgranvea](https://github.com/bgranvea))
+
+* Support for `IF NOT EXISTS` in `ALTER TABLE ADD COLUMN` statements along with `IF EXISTS` in `DROP/MODIFY/CLEAR/COMMENT COLUMN`. [#3900](https://github.com/yandex/ClickHouse/pull/3900) ([Boris Granveaud](https://github.com/bgranvea))
 * Function `parseDateTimeBestEffort`: support for formats `DD.MM.YYYY`, `DD.MM.YY`, `DD-MM-YYYY`, `DD-Mon-YYYY`, `DD/Month/YYYY` and similar. [#3922](https://github.com/yandex/ClickHouse/pull/3922) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Add a MergeTree setting `use_minimalistic_part_header_in_zookeeper`. If enabled, Replicated tables will store compact part metadata in a single part znode. This can dramatically reduce ZooKeeper snapshot size (especially if the tables have a lot of columns). Note that after enabling this setting you will not be able to downgrade to a version that doesn't support it. [#3960](https://github.com/yandex/ClickHouse/pull/3960) ([ztlpn](https://github.com/ztlpn))
+* `CapnProtoInputStream` now support jagged structures. [#4063](https://github.com/yandex/ClickHouse/pull/4063) ([Odin Hultgren Van Der Horst](https://github.com/Miniwoffer))
-* Add an DFA-based implementation for functions `sequenceMatch` and `sequenceCount` in case pattern doesn't contain time. [#\](https://github.com/yandex/ClickHouse/pull/4004) ([ercolanelli-leo](https://github.com/ercolanelli-leo))
+* Usability improvement: added a check that server process is started from the data directory's owner. Do not allow to start server from root if the data belongs to non-root user. [#3785](https://github.com/yandex/ClickHouse/pull/3785) ([sergey-v-galtsev](https://github.com/sergey-v-galtsev))
-* Changed the way CapnProtoInputStream creates actions in such a way that it now support structures that are jagged. [#4063](https://github.com/yandex/ClickHouse/pull/4063) ([Miniwoffer](https://github.com/Miniwoffer))
+* Better logic of checking required columns during analysis of queries with JOINs. [#3930](https://github.com/yandex/ClickHouse/pull/3930) ([Artem Zuikov](https://github.com/4ertus2))
-* Better way to collect columns, tables and joins from AST when checking required columns. [#3930](https://github.com/yandex/ClickHouse/pull/3930) ([4ertus2](https://github.com/4ertus2))
+* Decreased the number of connections in case of large number of Distributed tables in a single server. [#3726](https://github.com/yandex/ClickHouse/pull/3726) ([Winter Zhang](https://github.com/zhang2014))
-* Zero left padding PODArray so that -1 element is always valid and zeroed. It's used for branchless Offset access. [#3920](https://github.com/yandex/ClickHouse/pull/3920) ([amosbird](https://github.com/amosbird))
+* Supported totals row for `WITH TOTALS` query for ODBC driver. [#3836](https://github.com/yandex/ClickHouse/pull/3836) ([Maksim Koritckiy](https://github.com/nightweb))
-* Performance improvement for int serialization. [#3968](https://github.com/yandex/ClickHouse/pull/3968) ([amosbird](https://github.com/amosbird))
+* Allowed to use `Enum`s as integers inside if function. [#3875](https://github.com/yandex/ClickHouse/pull/3875) ([Ivan](https://github.com/abyss7))
-* Moved debian/ specific entries to debian/.gitignore [#4106](https://github.com/yandex/ClickHouse/pull/4106) ([gerasiov](https://github.com/gerasiov))
+* Added `low_cardinality_allow_in_native_format` setting. If disabled, do not use `LowCadrinality` type in `Native` format. [#3879](https://github.com/yandex/ClickHouse/pull/3879) ([KochetovNicolai](https://github.com/KochetovNicolai))
-* Decreased the number of connections in case of large number of Distributed tables in a single server. [#3726](https://github.com/yandex/ClickHouse/pull/3726) ([zhang2014](https://github.com/zhang2014))
+* Removed some redundant objects from compiled expressions cache to lower memory usage. [#4042](https://github.com/yandex/ClickHouse/pull/4042) ([alesapin](https://github.com/alesapin))
-* Supported totals row for `WITH TOTALS` query for ODBC driver (ODBCDriver2 format). [#3836](https://github.com/yandex/ClickHouse/pull/3836) ([nightweb](https://github.com/nightweb))
+* Add check that `SET send_logs_level = 'value'` query accept appropriate value. [#3873](https://github.com/yandex/ClickHouse/pull/3873) ([Sabyanin Maxim](https://github.com/s-mx))
-* Better constant expression folding. Possibility to skip unused shards if SELECT query filters by sharding_key (setting `distributed_optimize_skip_select_on_unused_shards`). [#3851](https://github.com/yandex/ClickHouse/pull/3851) ([abyss7](https://github.com/abyss7))
+* Fixed data type check in type conversion functions. [#3896](https://github.com/yandex/ClickHouse/pull/3896) ([Winter Zhang](https://github.com/zhang2014))
-* Do not log from odbc-bridge when there is no console. [#3857](https://github.com/yandex/ClickHouse/pull/3857) ([alesapin](https://github.com/alesapin))
+
-* Forbid using aggregate functions inside scalar subqueries. [#3865](https://github.com/yandex/ClickHouse/pull/3865) ([abyss7](https://github.com/abyss7))
+### Performance Improvements
-* Added ability to use Enums as integers inside if function. [#3875](https://github.com/yandex/ClickHouse/pull/3875) ([abyss7](https://github.com/abyss7))
+
-* Added `low_cardinality_allow_in_native_format` setting. If disabled, do not use `LowCadrinality` type in native format. [#3879](https://github.com/yandex/ClickHouse/pull/3879) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Add a MergeTree setting `use_minimalistic_part_header_in_zookeeper`. If enabled, Replicated tables will store compact part metadata in a single part znode. This can dramatically reduce ZooKeeper snapshot size (especially if the tables have a lot of columns). Note that after enabling this setting you will not be able to downgrade to a version that doesn't support it. [#3960](https://github.com/yandex/ClickHouse/pull/3960) ([Alex Zatelepin](https://github.com/ztlpn))
-* Removed duplicate code. [#3915](https://github.com/yandex/ClickHouse/pull/3915) ([sergey-v-galtsev](https://github.com/sergey-v-galtsev))
+* Add an DFA-based implementation for functions `sequenceMatch` and `sequenceCount` in case pattern doesn't contain time. [#4004](https://github.com/yandex/ClickHouse/pull/4004) ([Léo Ercolanelli](https://github.com/ercolanelli-leo))
-* Minor improvements in StorageKafka. [#3919](https://github.com/yandex/ClickHouse/pull/3919) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Performance improvement for integer numbers serialization. [#3968](https://github.com/yandex/ClickHouse/pull/3968) ([Amos Bird](https://github.com/amosbird))
-* Automatically disable logs in negative tests. [#3940](https://github.com/yandex/ClickHouse/pull/3940) ([4ertus2](https://github.com/4ertus2))
+* Zero left padding PODArray so that -1 element is always valid and zeroed. It's used for branchless calculation of offsets. [#3920](https://github.com/yandex/ClickHouse/pull/3920) ([Amos Bird](https://github.com/amosbird))
-* Refactored SyntaxAnalyzer. [#4014](https://github.com/yandex/ClickHouse/pull/4014) ([4ertus2](https://github.com/4ertus2))
+* Reverted `jemalloc` version which lead to performance degradation. [#4018](https://github.com/yandex/ClickHouse/pull/4018) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Reverted jemalloc patch which lead to performance degradation. [#4018](https://github.com/yandex/ClickHouse/pull/4018) ([alexey-milovidov](https://github.com/alexey-milovidov))
+
-* Refactored QueryNormalizer. Unified column sources for ASTIdentifier and ASTQualifiedAsterisk (were different), removed column duplicates for ASTQualifiedAsterisk sources, cleared asterisks replacement. [#4031](https://github.com/yandex/ClickHouse/pull/4031) ([4ertus2](https://github.com/4ertus2))
+### Backward Incompatible Changes
-* Refactored code with ASTIdentifier. [#4056](https://github.com/yandex/ClickHouse/pull/4056) [#4077](https://github.com/yandex/ClickHouse/pull/4077) [#4087](https://github.com/yandex/ClickHouse/pull/4087) ([4ertus2](https://github.com/4ertus2))
+
-* Improve error message in `clickhouse-test` script when no ClickHouse binary was found. [#4130](https://github.com/yandex/ClickHouse/pull/4130) ([Miniwoffer](https://github.com/Miniwoffer))
+* Removed undocumented feature `ALTER MODIFY PRIMARY KEY` because it was superseded by the `ALTER MODIFY ORDER BY` command. [#3887](https://github.com/yandex/ClickHouse/pull/3887) ([Alex Zatelepin](https://github.com/ztlpn))
-* Rewrited code to calculate integer conversion function monotonicity. [#3921](https://github.com/yandex/ClickHouse/pull/3921) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Removed function `shardByHash`. [#3833](https://github.com/yandex/ClickHouse/pull/3833) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fixed typos in comments. [#4089](https://github.com/yandex/ClickHouse/pull/4089) ([kvinty](https://github.com/kvinty))
+* Forbid using scalar subqueries with result of type `AggregateFunction`. [#3865](https://github.com/yandex/ClickHouse/pull/3865) ([Ivan](https://github.com/abyss7))
 
 ### Build/Testing/Packaging Improvements
-* Added minimal support for powerpc build. [#4132](https://github.com/yandex/ClickHouse/pull/4132) ([danlark1](https://github.com/danlark1))
+
-* Fixed error when the server cannot start with the `bash: /usr/bin/clickhouse-extract-from-config: Operation not permitted` message within Docker or systemd-nspawn. [#4136](https://github.com/yandex/ClickHouse/pull/4136) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Added support for PowerPC (`ppc64le`) build. [#4132](https://github.com/yandex/ClickHouse/pull/4132) ([Danila Kutenin](https://github.com/danlark1))
-* Updated `mariadb-client` library. Fixed one of issues found by UBSan. [#3924](https://github.com/yandex/ClickHouse/pull/3924) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Some fixes for UBSan builds. [#3926](https://github.com/yandex/ClickHouse/pull/3926) [#3948](https://github.com/yandex/ClickHouse/pull/3948) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Move docker images to 18.10 and add compatibility file for glibc >= 2.28 [#3965](https://github.com/yandex/ClickHouse/pull/3965) ([alesapin](https://github.com/alesapin))
-* Add env variable if user don't want to chown directories in server docker image. [#3967](https://github.com/yandex/ClickHouse/pull/3967) ([alesapin](https://github.com/alesapin))
 * Stateful functional tests are run on public available dataset. [#3969](https://github.com/yandex/ClickHouse/pull/3969) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Enabled most of the warnings from `-Weverything` in clang. Enabled `-Wpedantic`. [#3986](https://github.com/yandex/ClickHouse/pull/3986) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed error when the server cannot start with the `bash: /usr/bin/clickhouse-extract-from-config: Operation not permitted` message within Docker or systemd-nspawn. [#4136](https://github.com/yandex/ClickHouse/pull/4136) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Link to libLLVM rather than to individual LLVM libs when USE_STATIC_LIBRARIES is off. [#3989](https://github.com/yandex/ClickHouse/pull/3989) ([orivej](https://github.com/orivej))
+* Updated `rdkafka` library to v1.0.0-RC5. Used cppkafka instead of raw C interface. [#4025](https://github.com/yandex/ClickHouse/pull/4025) ([Ivan](https://github.com/abyss7))
-* Added a few more warnings that are available only in clang 8. [#3993](https://github.com/yandex/ClickHouse/pull/3993) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Updated `mariadb-client` library. Fixed one of issues found by UBSan. [#3924](https://github.com/yandex/ClickHouse/pull/3924) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Some fixes for UBSan builds. [#3926](https://github.com/yandex/ClickHouse/pull/3926) [#3021](https://github.com/yandex/ClickHouse/pull/3021) [#3948](https://github.com/yandex/ClickHouse/pull/3948) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Added per-commit runs of tests with UBSan build.
+* Added per-commit runs of PVS-Studio static analyzer.
 * Fixed bugs found by PVS-Studio. [#4013](https://github.com/yandex/ClickHouse/pull/4013) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed glibc compatibility issues. [#4100](https://github.com/yandex/ClickHouse/pull/4100) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Move Docker images to 18.10 and add compatibility file for glibc >= 2.28 [#3965](https://github.com/yandex/ClickHouse/pull/3965) ([alesapin](https://github.com/alesapin))
+* Add env variable if user don't want to chown directories in server Docker image. [#3967](https://github.com/yandex/ClickHouse/pull/3967) ([alesapin](https://github.com/alesapin))
+* Enabled most of the warnings from `-Weverything` in clang. Enabled `-Wpedantic`. [#3986](https://github.com/yandex/ClickHouse/pull/3986) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Added a few more warnings that are available only in clang 8. [#3993](https://github.com/yandex/ClickHouse/pull/3993) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Link to `libLLVM` rather than to individual LLVM libs when using shared linking. [#3989](https://github.com/yandex/ClickHouse/pull/3989) ([Orivej Desh](https://github.com/orivej))
 * Added sanitizer variables for test images. [#4072](https://github.com/yandex/ClickHouse/pull/4072) ([alesapin](https://github.com/alesapin))
-* clickhouse-server debian package will recommend `libcap2-bin` package to use `setcap` tool for setting capabilities. This is optional. [#4093](https://github.com/yandex/ClickHouse/pull/4093) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* `clickhouse-server` debian package will recommend `libcap2-bin` package to use `setcap` tool for setting capabilities. This is optional. [#4093](https://github.com/yandex/ClickHouse/pull/4093) ([alexey-milovidov](https://github.com/alexey-milovidov))
 * Improved compilation time, fixed includes. [#3898](https://github.com/yandex/ClickHouse/pull/3898) ([proller](https://github.com/proller))
 * Added performance tests for hash functions. [#3918](https://github.com/yandex/ClickHouse/pull/3918) ([filimonov](https://github.com/filimonov))
 * Fixed cyclic library dependences. [#3958](https://github.com/yandex/ClickHouse/pull/3958) ([proller](https://github.com/proller))
 * Improved compilation with low available memory. [#4030](https://github.com/yandex/ClickHouse/pull/4030) ([proller](https://github.com/proller))
+* Added test script to reproduce performance degradation in `jemalloc`. [#4036](https://github.com/yandex/ClickHouse/pull/4036) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Fixed misspells in comments and string literals under `dbms`. [#4122](https://github.com/yandex/ClickHouse/pull/4122) ([maiha](https://github.com/maiha))
+* Fixed typos in comments. [#4089](https://github.com/yandex/ClickHouse/pull/4089) ([Evgenii Pravda](https://github.com/kvinty))
 
-### Bug Fixes
-* Fix bug when in remote table function execution when wrong restrictions were used for in `getStructureOfRemoteTable`. [#4009](https://github.com/yandex/ClickHouse/pull/4009) ([alesapin](https://github.com/alesapin))
-* Fix a leak of netlink sockets. They were placed in a pool where they were never deleted and new sockets were created at the start of a new thread when all current sockets were in use. [#4017](https://github.com/yandex/ClickHouse/pull/4017) ([ztlpn](https://github.com/ztlpn))
-* Regression in master. Fix "Unknown identifier" error in case column names appear in lambdas. [#4115](https://github.com/yandex/ClickHouse/pull/4115) ([4ertus2](https://github.com/4ertus2))
-* Fix bug with closing /proc/self/fd earlier than all fds were read from /proc. [#4120](https://github.com/yandex/ClickHouse/pull/4120) ([alesapin](https://github.com/alesapin))
-* Fixed misspells in **comments** and **string literals** under `dbms`. [#4122](https://github.com/yandex/ClickHouse/pull/4122) ([maiha](https://github.com/maiha))
-* Fixed String to UInt monotonic conversion in case of usage String in primary key. [#3870](https://github.com/yandex/ClickHouse/pull/3870) ([zhang2014](https://github.com/zhang2014))
-* Add checking that 'SET send_logs_level = value' query accept appropriate value. [#3873](https://github.com/yandex/ClickHouse/pull/3873) ([s-mx](https://github.com/s-mx))
-* Fixed a race condition when executing a distributed ALTER task. The race condition led to more than one replica trying to execute the task and all replicas except one failing with a ZooKeeper error. [#3904](https://github.com/yandex/ClickHouse/pull/3904) ([ztlpn](https://github.com/ztlpn))
-* Fixed segfault in `arrayEnumerateUniq`, `arrayEnumerateDense` functions in case of some invalid arguments. [#3909](https://github.com/yandex/ClickHouse/pull/3909) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fix UB in StorageMerge. [#3910](https://github.com/yandex/ClickHouse/pull/3910) ([amosbird](https://github.com/amosbird))
-* Fixed segfault in functions `addDays`, `subtractDays`. [#3913](https://github.com/yandex/ClickHouse/pull/3913) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fixed error: functions `round`, `floor`, `trunc`, `ceil` may return bogus result when executed on integer argument and large negative scale. [#3914](https://github.com/yandex/ClickHouse/pull/3914) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fixed a bug introduced by 'kill query sync' which leads to a core dump. [#3916](https://github.com/yandex/ClickHouse/pull/3916) ([fancyqlx](https://github.com/fancyqlx))
-* Fix bug with long delay after empty replication queue. [#3928](https://github.com/yandex/ClickHouse/pull/3928) ([alesapin](https://github.com/alesapin))
-* Don't do exponential backoff when there is nothing to do for task. [#3932](https://github.com/yandex/ClickHouse/pull/3932) ([alesapin](https://github.com/alesapin))
-* Fix a bug that led to hangups in threads that perform ALTERs of Replicated tables and in the thread that updates configuration from ZooKeeper. #2947 #3891 [#3934](https://github.com/yandex/ClickHouse/pull/3934) ([ztlpn](https://github.com/ztlpn))
-* Fixed error in internal implementation of `quantileTDigest` (found by Artem Vakhrushev). This error never happens in ClickHouse and was relevant only for those who use ClickHouse codebase as a library directly. [#3935](https://github.com/yandex/ClickHouse/pull/3935) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fix bug with wrong prefix for ipv4 subnet masks. [#3945](https://github.com/yandex/ClickHouse/pull/3945) ([alesapin](https://github.com/alesapin))
-* Fix a bug when `from_zk` config elements weren't refreshed after a request to ZooKeeper timed out.  #2947 [#3947](https://github.com/yandex/ClickHouse/pull/3947) ([ztlpn](https://github.com/ztlpn))
-* Fixed dictionary copying at LowCardinality::cloneEmpty() method which lead to excessive memory usage in case of inserting into table with LowCardinality primary key. [#3955](https://github.com/yandex/ClickHouse/pull/3955) ([KochetovNicolai](https://github.com/KochetovNicolai))
-* Fixed crash (`std::terminate`) in rare cases when a new thread cannot be created due to exhausted resources. [#3956](https://github.com/yandex/ClickHouse/pull/3956) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fix user and password forwarding for replicated tables queries. [#3957](https://github.com/yandex/ClickHouse/pull/3957) ([alesapin](https://github.com/alesapin))
-* Fixed very rare race condition that can happen when listing tables in Dictionary database while reloading dictionaries. [#3970](https://github.com/yandex/ClickHouse/pull/3970) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fixed LowCardinality serialization for Native format in case of empty arrays. #3907 [#4011](https://github.com/yandex/ClickHouse/pull/4011) ([KochetovNicolai](https://github.com/KochetovNicolai))
-* Fixed incorrect result while using distinct by single LowCardinality numeric column. #3895 [#4012](https://github.com/yandex/ClickHouse/pull/4012) ([KochetovNicolai](https://github.com/KochetovNicolai))
-* Make compiled_expression_cache_size setting limited by default. [#4041](https://github.com/yandex/ClickHouse/pull/4041) ([alesapin](https://github.com/alesapin))
-* Fix ubsan bug in compression codecs. [#4069](https://github.com/yandex/ClickHouse/pull/4069) ([alesapin](https://github.com/alesapin))
-* Allow Kafka Engine to ignore some number of parsing errors per block. [#4094](https://github.com/yandex/ClickHouse/pull/4094) ([abyss7](https://github.com/abyss7))
-* Fixed glibc compatibility issues. [#4100](https://github.com/yandex/ClickHouse/pull/4100) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fixed issues found by PVS-Studio. [#4103](https://github.com/yandex/ClickHouse/pull/4103) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fix a way how to collect array join columns. [#4121](https://github.com/yandex/ClickHouse/pull/4121) ([4ertus2](https://github.com/4ertus2))
-* Fixed incorrect result when HAVING was used with ROLLUP or CUBE. [#3756](https://github.com/yandex/ClickHouse/issues/3756) [#3837](https://github.com/yandex/ClickHouse/pull/3837) ([reflection](https://github.com/reflection))
-* Fixed specialized aggregation with LowCardinality key (in case when `compile` setting is enabled). [#3886](https://github.com/yandex/ClickHouse/pull/3886) ([KochetovNicolai](https://github.com/KochetovNicolai))
-* Fixed data type check in type conversion functions. [#3896](https://github.com/yandex/ClickHouse/pull/3896) ([zhang2014](https://github.com/zhang2014))
-* Fixed column aliases for query with `JOIN ON` syntax and distributed tables. [#3980](https://github.com/yandex/ClickHouse/pull/3980) ([zhang2014](https://github.com/zhang2014))
-* Fixed issues detected by UBSan. [#3021](https://github.com/yandex/ClickHouse/pull/3021) ([alexey-milovidov](https://github.com/alexey-milovidov))
-
-### Doc fixes
-* Translated table engines related part to Chinese. [#3844](https://github.com/yandex/ClickHouse/pull/3844) ([lamber-ken](https://github.com/lamber-ken))
-* Fixed `toStartOfFiveMinute` description. [#4096](https://github.com/yandex/ClickHouse/pull/4096) ([cheesedosa](https://github.com/cheesedosa))
-* Added description for client `--secure` argument. [#3961](https://github.com/yandex/ClickHouse/pull/3961) ([vicdashkov](https://github.com/vicdashkov))
-* Added descriptions for settings `merge_tree_uniform_read_distribution`, `merge_tree_min_rows_for_concurrent_read`, `merge_tree_min_rows_for_seek`, `merge_tree_coarse_index_granularity`, `merge_tree_max_rows_to_use_cache` [#4024](https://github.com/yandex/ClickHouse/pull/4024) ([BayoNet](https://github.com/BayoNet))
-* Minor doc fixes. [#4098](https://github.com/yandex/ClickHouse/pull/4098) ([blinkov](https://github.com/blinkov))
-* Updated example for zookeeper config setting. [#3883](https://github.com/yandex/ClickHouse/pull/3883) [#3894](https://github.com/yandex/ClickHouse/pull/3894) ([ogorbacheva](https://github.com/ogorbacheva))
-* Updated info about escaping in formats Vertical, Pretty and VerticalRaw. [#4118](https://github.com/yandex/ClickHouse/pull/4118) ([ogorbacheva](https://github.com/ogorbacheva))
-* Adding description of the functions for working with UUID. [#4059](https://github.com/yandex/ClickHouse/pull/4059) ([ogorbacheva](https://github.com/ogorbacheva))
-* Add the description of the CHECK TABLE query. [#3881](https://github.com/yandex/ClickHouse/pull/3881) [#4043](https://github.com/yandex/ClickHouse/pull/4043) ([ogorbacheva](https://github.com/ogorbacheva))
-* Add `zh/tests`  doc translate to Chinese. [#4034](https://github.com/yandex/ClickHouse/pull/4034) ([sundy-li](https://github.com/sundy-li))
-* Added documentation about functions `multiPosition`, `firstMatch`, `multiSearch`. [#4123](https://github.com/yandex/ClickHouse/pull/4123) ([danlark1](https://github.com/danlark1))
-* Add puppet module to the list of the third party libraries. [#3862](https://github.com/yandex/ClickHouse/pull/3862) ([Felixoid](https://github.com/Felixoid))
-* Fixed typo in the English version of Creating a Table example [#3872](https://github.com/yandex/ClickHouse/pull/3872) ([areldar](https://github.com/areldar))
-* Mention about nagios plugin for ClickHouse [#3878](https://github.com/yandex/ClickHouse/pull/3878) ([lisuml](https://github.com/lisuml))
-* Update of query language syntax description. [#4065](https://github.com/yandex/ClickHouse/pull/4065) ([BayoNet](https://github.com/BayoNet))
-* Added documentation for per-column compression codecs. [#4073](https://github.com/yandex/ClickHouse/pull/4073) ([alex-krash](https://github.com/alex-krash))
-* Updated articles about CollapsingMergeTree, GraphiteMergeTree, Replicated*MergeTree, `CREATE TABLE` query [#4085](https://github.com/yandex/ClickHouse/pull/4085) ([BayoNet](https://github.com/BayoNet))
-* Other minor improvements. [#3897](https://github.com/yandex/ClickHouse/pull/3897) [#3923](https://github.com/yandex/ClickHouse/pull/3923) [#4066](https://github.com/yandex/ClickHouse/pull/4066) [#3860](https://github.com/yandex/ClickHouse/pull/3860) [#3906](https://github.com/yandex/ClickHouse/pull/3906) [#3936](https://github.com/yandex/ClickHouse/pull/3936) [#3975](https://github.com/yandex/ClickHouse/pull/3975) ([ogorbacheva](https://github.com/ogorbacheva)) ([ogorbacheva](https://github.com/ogorbacheva)) ([ogorbacheva](https://github.com/ogorbacheva)) ([blinkov](https://github.com/blinkov)) ([blinkov](https://github.com/blinkov)) ([sdk2](https://github.com/sdk2)) ([blinkov](https://github.com/blinkov))
-
-### Other
-* Updated librdkafka to v1.0.0-RC5. Used cppkafka instead of raw C interface. [#4025](https://github.com/yandex/ClickHouse/pull/4025) ([abyss7](https://github.com/abyss7))
-* Fixed `hidden` on page title [#4033](https://github.com/yandex/ClickHouse/pull/4033) ([xboston](https://github.com/xboston))
-* Updated year in copyright to 2019. [#4039](https://github.com/yandex/ClickHouse/pull/4039) ([xboston](https://github.com/xboston))
-* Added check that server process is started from the data directory's owner. Do not start server from root. [#3785](https://github.com/yandex/ClickHouse/pull/3785) ([sergey-v-galtsev](https://github.com/sergey-v-galtsev))
-* Removed function `shardByHash`. [#3833](https://github.com/yandex/ClickHouse/pull/3833) ([alexey-milovidov](https://github.com/alexey-milovidov))
-* Fixed typo in ClusterCopier. [#3854](https://github.com/yandex/ClickHouse/pull/3854) ([dqminh](https://github.com/dqminh))
-* Minor grammar fixes. [#3855](https://github.com/yandex/ClickHouse/pull/3855) ([intgr](https://github.com/intgr))
-* Added test script to reproduce performance degradation in jemalloc. [#4036](https://github.com/yandex/ClickHouse/pull/4036) ([alexey-milovidov](https://github.com/alexey-milovidov))
 
 ## ClickHouse release 18.16.1, 2018-12-21
 

CHANGELOG_RU.md

@@ -1,3 +1,112 @@
+## ClickHouse release 19.1.6, 2019-01-24
+
+### Новые возможности:
+
+* Задание формата сжатия для отдельных столбцов. [#3899](https://github.com/yandex/ClickHouse/pull/3899) [#4111](https://github.com/yandex/ClickHouse/pull/4111) ([alesapin](https://github.com/alesapin), [Winter Zhang](https://github.com/zhang2014), [Anatoly](https://github.com/Sindbag))
+* Формат сжатия `Delta`. [#4052](https://github.com/yandex/ClickHouse/pull/4052) ([alesapin](https://github.com/alesapin))
+* Изменение формата сжатия запросом `ALTER`. [#4054](https://github.com/yandex/ClickHouse/pull/4054) ([alesapin](https://github.com/alesapin))
+* Добавлены функции `left`, `right`, `trim`, `ltrim`, `rtrim`, `timestampadd`, `timestampsub` для совместимости со стандартом SQL. [#3826](https://github.com/yandex/ClickHouse/pull/3826) ([Ivan Blinkov](https://github.com/blinkov))
+* Поддержка записи в движок `HDFS` и табличную функцию `hdfs`. [#4084](https://github.com/yandex/ClickHouse/pull/4084) ([alesapin](https://github.com/alesapin))
+* Добавлены функции поиска набора константных строк в тексте: `multiPosition`, `multiSearch` ,`firstMatch` также с суффиксами `-UTF8`, `-CaseInsensitive`, и `-CaseInsensitiveUTF8`. [#4053](https://github.com/yandex/ClickHouse/pull/4053) ([Danila Kutenin](https://github.com/danlark1))
+* Пропуск неиспользуемых шардов в случае, если запрос `SELECT` содержит фильтрацию по ключу шардирования (настройка `optimize_skip_unused_shards`). [#3851](https://github.com/yandex/ClickHouse/pull/3851) ([Gleb Kanterov](https://github.com/kanterov), [Ivan](https://github.com/abyss7))
+* Пропуск строк в случае ошибки парсинга для движка `Kafka` (настройка `kafka_skip_broken_messages`). [#4094](https://github.com/yandex/ClickHouse/pull/4094) ([Ivan](https://github.com/abyss7))
+* Поддержка применения мультиклассовых моделей `CatBoost`. Функция `modelEvaluate` возвращает кортеж в случае использования мультиклассовой модели. `libcatboostmodel.so` should be built with [#607](https://github.com/catboost/catboost/pull/607). [#3959](https://github.com/yandex/ClickHouse/pull/3959) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Добавлены функции `filesystemAvailable`, `filesystemFree`, `filesystemCapacity`. [#4097](https://github.com/yandex/ClickHouse/pull/4097) ([Boris Granveaud](https://github.com/bgranvea))
+* Добавлены функции хеширования `xxHash64` и `xxHash32`. [#3905](https://github.com/yandex/ClickHouse/pull/3905) ([filimonov](https://github.com/filimonov))
+* Добавлена функция хеширования `gccMurmurHash` (GCC flavoured Murmur hash), использующая те же hash seed, что и [gcc](https://github.com/gcc-mirror/gcc/blob/41d6b10e96a1de98e90a7c0378437c3255814b16/libstdc%2B%2B-v3/include/bits/functional_hash.h#L191) [#4000](https://github.com/yandex/ClickHouse/pull/4000) ([sundyli](https://github.com/sundy-li))
+* Добавлены функции хеширования `javaHash`, `hiveHash`. [#3811](https://github.com/yandex/ClickHouse/pull/3811) ([shangshujie365](https://github.com/shangshujie365))
+* Добавлена функция `remoteSecure`. Функция работает аналогично `remote`, но использует безопасное соединение. [#4088](https://github.com/yandex/ClickHouse/pull/4088) ([proller](https://github.com/proller))
+
+
+### Экспериментальные возможности:
+
+* Эмуляция запросов с несколькими секциями `JOIN` (настройка `allow_experimental_multiple_joins_emulation`). [#3946](https://github.com/yandex/ClickHouse/pull/3946) ([Artem Zuikov](https://github.com/4ertus2))
+
+### Исправления ошибок:
+
+* Ограничен размер кеша скомпилированных выражений в случае, если не указана настройка `compiled_expression_cache_size` для экономии потребляемой памяти. [#4041](https://github.com/yandex/ClickHouse/pull/4041) ([alesapin](https://github.com/alesapin))
+* Исправлена проблема зависания потоков, выполняющих запрос `ALTER` для таблиц семейства `Replicated`, а также потоков, обновляющих конфигурацию из ZooKeeper. [#2947](https://github.com/yandex/ClickHouse/issues/2947) [#3891](https://github.com/yandex/ClickHouse/issues/3891) [#3934](https://github.com/yandex/ClickHouse/pull/3934) ([Alex Zatelepin](https://github.com/ztlpn))
+* Исправлен race condition в случае выполнения распределенной задачи запроса `ALTER`. Race condition приводил к состоянию, когда более чем одна реплика пыталась выполнить задачу, в результате чего все такие реплики, кроме одной, падали с ошибкой обращения к ZooKeeper. [#3904](https://github.com/yandex/ClickHouse/pull/3904) ([Alex Zatelepin](https://github.com/ztlpn))
+* Исправлена проблема обновления настройки `from_zk`. Настройка, указанная в файле конфигурации, не обновлялась в случае, если запрос к ZooKeeper падал по timeout. [#2947](https://github.com/yandex/ClickHouse/issues/2947) [#3947](https://github.com/yandex/ClickHouse/pull/3947) ([Alex Zatelepin](https://github.com/ztlpn))
+* Исправлена ошибка в вычислении сетевого префикса при указании IPv4 маски подсети. [#3945](https://github.com/yandex/ClickHouse/pull/3945) ([alesapin](https://github.com/alesapin))
+* Исправлено падение (`std::terminate`) в редком сценарии, когда новый поток не мог быть создан из-за нехватки ресурсов. [#3956](https://github.com/yandex/ClickHouse/pull/3956) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Исправлено падение табличной функции `remote` в случае, когда не удавалось получить структуру таблицы из-за ограничений пользователя. [#4009](https://github.com/yandex/ClickHouse/pull/4009) ([alesapin](https://github.com/alesapin))
+* Исправлена утечка сетевых сокетов. Сокеты создавались в пуле и никогда не закрывались. При создании потока, создавались новые сокеты в случае, если все доступные использовались. [#4017](https://github.com/yandex/ClickHouse/pull/4017) ([Alex Zatelepin](https://github.com/ztlpn))
+* Исправлена проблема закрывания `/proc/self/fd` раньше, чем все файловые дескрипторы были прочитаны из `/proc` после создания процесса `odbc-bridge`. [#4120](https://github.com/yandex/ClickHouse/pull/4120) ([alesapin](https://github.com/alesapin))
+* Исправлен баг в монотонном преобразовании String в UInt в случае использования String в первичном ключе. [#3870](https://github.com/yandex/ClickHouse/pull/3870) ([Winter Zhang](https://github.com/zhang2014))
+* Исправлен баг в вычислении монотонности функции преобразования типа целых значений. [#3921](https://github.com/yandex/ClickHouse/pull/3921) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Исправлено падение в функциях `arrayEnumerateUniq`, `arrayEnumerateDense` при передаче невалидных аргументов. [#3909](https://github.com/yandex/ClickHouse/pull/3909) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Исправлен undefined behavior в StorageMerge. [#3910](https://github.com/yandex/ClickHouse/pull/3910) ([Amos Bird](https://github.com/amosbird))
+* Исправлено падение в функциях `addDays`, `subtractDays`. [#3913](https://github.com/yandex/ClickHouse/pull/3913) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Исправлена проблема, в результате которой функции `round`, `floor`, `trunc`, `ceil` могли возвращать неверный результат для отрицательных целочисленных аргументов с большим значением. [#3914](https://github.com/yandex/ClickHouse/pull/3914) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Исправлена проблема, в результате которой 'kill query sync' приводил к падению сервера. [#3916](https://github.com/yandex/ClickHouse/pull/3916) ([muVulDeePecker](https://github.com/fancyqlx))
+* Исправлен баг, приводящий к большой задержке в случае пустой очереди репликации. [#3928](https://github.com/yandex/ClickHouse/pull/3928) [#3932](https://github.com/yandex/ClickHouse/pull/3932) ([alesapin](https://github.com/alesapin))
+* Исправлено избыточное использование памяти в случае вставки в таблицу с `LowCardinality` в первичном ключе. [#3955](https://github.com/yandex/ClickHouse/pull/3955) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Исправлена сериализация пустых массивов типа `LowCardinality` для формата `Native`. [#3907](https://github.com/yandex/ClickHouse/issues/3907) [#4011](https://github.com/yandex/ClickHouse/pull/4011) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Исправлен неверный результат в случае использования distinct для числового столбца `LowCardinality`. [#3895](https://github.com/yandex/ClickHouse/issues/3895) [#4012](https://github.com/yandex/ClickHouse/pull/4012) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Исправлена компиляция вычисления агрегатных функций для ключа `LowCardinality` (для случая, когда включена настройка `compile`). [#3886](https://github.com/yandex/ClickHouse/pull/3886) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Исправлена передача пользователя и пароля для запросов с реплик. [#3957](https://github.com/yandex/ClickHouse/pull/3957) ([alesapin](https://github.com/alesapin)) ([小路](https://github.com/nicelulu))
+* Исправлен очень редкий race condition возникающий при перечислении таблиц из базы данных типа `Dictionary` во время перезагрузки словарей. [#3970](https://github.com/yandex/ClickHouse/pull/3970) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Исправлен неверный результат в случае использования HAVING с ROLLUP или CUBE. [#3756](https://github.com/yandex/ClickHouse/issues/3756) [#3837](https://github.com/yandex/ClickHouse/pull/3837) ([Sam Chou](https://github.com/reflection))
+* Исправлена проблема с алиасами столбцов для запросов с `JOIN ON` над распределенными таблицами. [#3980](https://github.com/yandex/ClickHouse/pull/3980) ([Winter Zhang](https://github.com/zhang2014))
+* Исправлена ошибка в реализации функции `quantileTDigest` (нашел Artem Vakhrushev). Эта ошибка никогда не происходит в ClickHouse и актуальна только для тех, кто использует кодовую базу ClickHouse напрямую в качестве библиотеки. [#3935](https://github.com/yandex/ClickHouse/pull/3935) ([alexey-milovidov](https://github.com/alexey-milovidov))
+
+### Улучшения:
+
+* Добавлена поддержка `IF NOT EXISTS` в выражении `ALTER TABLE ADD COLUMN`, `IF EXISTS` в выражении `DROP/MODIFY/CLEAR/COMMENT COLUMN`. [#3900](https://github.com/yandex/ClickHouse/pull/3900) ([Boris Granveaud](https://github.com/bgranvea))
+* Функция `parseDateTimeBestEffort` теперь поддерживает форматы `DD.MM.YYYY`, `DD.MM.YY`, `DD-MM-YYYY`, `DD-Mon-YYYY`, `DD/Month/YYYY` и аналогичные. [#3922](https://github.com/yandex/ClickHouse/pull/3922) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* `CapnProtoInputStream` теперь поддерживает jagged структуры. [#4063](https://github.com/yandex/ClickHouse/pull/4063) ([Odin Hultgren Van Der Horst](https://github.com/Miniwoffer))
+* Улучшение usability: добавлена проверка, что сервер запущен от пользователя, совпадающего с владельцем директории данных. Запрещен запуск от пользователя root в случае, если root не владеет директорией с данными. [#3785](https://github.com/yandex/ClickHouse/pull/3785) ([sergey-v-galtsev](https://github.com/sergey-v-galtsev))
+* Улучшена логика проверки столбцов, необходимых для JOIN, на стадии анализа запроса. [#3930](https://github.com/yandex/ClickHouse/pull/3930) ([Artem Zuikov](https://github.com/4ertus2))
+* Уменьшено число поддерживаемых соединений в случае большого числа распределенных таблиц. [#3726](https://github.com/yandex/ClickHouse/pull/3726) ([Winter Zhang](https://github.com/zhang2014))
+* Добавлена поддержка строки с totals для запроса с `WITH TOTALS` через ODBC драйвер. [#3836](https://github.com/yandex/ClickHouse/pull/3836) ([Maksim Koritckiy](https://github.com/nightweb))
+* Поддержано использование `Enum` в качестве чисел в функции `if`. [#3875](https://github.com/yandex/ClickHouse/pull/3875) ([Ivan](https://github.com/abyss7))
+* Добавлена настройка `low_cardinality_allow_in_native_format`. Если она выключена, то тип `LowCadrinality` не используется в формате `Native`. [#3879](https://github.com/yandex/ClickHouse/pull/3879) ([KochetovNicolai](https://github.com/KochetovNicolai))
+* Удалены некоторые избыточные объекты из кеша скомпилированных выражений для уменьшения потребления памяти. [#4042](https://github.com/yandex/ClickHouse/pull/4042) ([alesapin](https://github.com/alesapin))
+* Добавлена проверка того, что в запрос `SET send_logs_level = 'value'` передается верное значение. [#3873](https://github.com/yandex/ClickHouse/pull/3873) ([Sabyanin Maxim](https://github.com/s-mx))
+* Добавлена проверка типов для функций преобразования типов. [#3896](https://github.com/yandex/ClickHouse/pull/3896) ([Winter Zhang](https://github.com/zhang2014))
+
+### Улучшения производительности:
+
+* Добавлена настройка `use_minimalistic_part_header_in_zookeeper` для движка MergeTree. Если настройка включена, Replicated таблицы будут хранить метаданные куска в компактном виде (в соответствующем znode для этого куска). Это может значительно уменьшить размер для ZooKeeper snapshot (особенно для таблиц с большим числом столбцов). После включения данной настройки будет невозможно сделать откат к версии, которая эту настройку не поддерживает. [#3960](https://github.com/yandex/ClickHouse/pull/3960) ([Alex Zatelepin](https://github.com/ztlpn))
+* Добавлена реализация функций `sequenceMatch` и `sequenceCount` на основе конечного автомата в случае, если последовательность событий не содержит условия на время. [#4004](https://github.com/yandex/ClickHouse/pull/4004) ([Léo Ercolanelli](https://github.com/ercolanelli-leo))
+* Улучшена производительность сериализации целых чисел. [#3968](https://github.com/yandex/ClickHouse/pull/3968) ([Amos Bird](https://github.com/amosbird))
+* Добавлен zero left padding для PODArray. Теперь элемент с индексом -1 является валидным нулевым значением. Эта особенность используется для удаления условного выражения при вычислении оффсетов массивов. [#3920](https://github.com/yandex/ClickHouse/pull/3920) ([Amos Bird](https://github.com/amosbird))
+* Откат версии `jemalloc`, приводящей к деградации производительности. [#4018](https://github.com/yandex/ClickHouse/pull/4018) ([alexey-milovidov](https://github.com/alexey-milovidov))
+
+### Обратно несовместимые изменения:
+
+* Удалена недокументированная возможность `ALTER MODIFY PRIMARY KEY`, замененная выражением `ALTER MODIFY ORDER BY`. [#3887](https://github.com/yandex/ClickHouse/pull/3887) ([Alex Zatelepin](https://github.com/ztlpn))
+* Удалена функция `shardByHash`. [#3833](https://github.com/yandex/ClickHouse/pull/3833) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Запрещено использование скалярных подзапросов с результатом, имеющим тип `AggregateFunction`. [#3865](https://github.com/yandex/ClickHouse/pull/3865) ([Ivan](https://github.com/abyss7))
+
+### Улучшения сборки/тестирования/пакетирования:
+
+* Добавлена поддержка сборки под PowerPC (`ppc64le`). [#4132](https://github.com/yandex/ClickHouse/pull/4132) ([Danila Kutenin](https://github.com/danlark1))
+* Функциональные stateful тесты запускаются на публично доступных данных. [#3969](https://github.com/yandex/ClickHouse/pull/3969) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Исправлена ошибка, при которой сервер не мог запуститься с сообщением `bash: /usr/bin/clickhouse-extract-from-config: Operation not permitted` при использовании Docker или systemd-nspawn. [#4136](https://github.com/yandex/ClickHouse/pull/4136) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Обновлена библиотека `rdkafka` до версии v1.0.0-RC5. Использована cppkafka на замену интерфейса языка C. [#4025](https://github.com/yandex/ClickHouse/pull/4025) ([Ivan](https://github.com/abyss7))
+* Обновлена библиотека `mariadb-client`. Исправлена проблема, обнаруженная с использованием UBSan. [#3924](https://github.com/yandex/ClickHouse/pull/3924) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Исправления для сборок с UBSan. [#3926](https://github.com/yandex/ClickHouse/pull/3926) [#3021](https://github.com/yandex/ClickHouse/pull/3021) [#3948](https://github.com/yandex/ClickHouse/pull/3948) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Добавлены покоммитные запуски тестов с UBSan сборкой.
+* Добавлены покоммитные запуски тестов со статическим анализатором PVS-Studio.
+* Исправлены проблемы, найденные с использованием PVS-Studio. [#4013](https://github.com/yandex/ClickHouse/pull/4013) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Исправлены проблемы совместимости glibc. [#4100](https://github.com/yandex/ClickHouse/pull/4100) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Docker образы перемещены на Ubuntu 18.10, добавлена совместимость с glibc >= 2.28 [#3965](https://github.com/yandex/ClickHouse/pull/3965) ([alesapin](https://github.com/alesapin))
+* Добавлена переменная окружения `CLICKHOUSE_DO_NOT_CHOWN`, позволяющая не делать shown директории для Docker образа сервера. [#3967](https://github.com/yandex/ClickHouse/pull/3967) ([alesapin](https://github.com/alesapin))
+* Включены большинство предупреждений из `-Weverything` для clang. Включено `-Wpedantic`. [#3986](https://github.com/yandex/ClickHouse/pull/3986) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Добавлены некоторые предупреждения, специфичные только для clang 8. [#3993](https://github.com/yandex/ClickHouse/pull/3993) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* При использовании динамической линковки используется `libLLVM` вместо библиотеки `LLVM`. [#3989](https://github.com/yandex/ClickHouse/pull/3989) ([Orivej Desh](https://github.com/orivej))
+* Добавлены переменные окружения для параметров `TSan`, `UBSan`, `ASan` в тестовом Docker образе. [#4072](https://github.com/yandex/ClickHouse/pull/4072) ([alesapin](https://github.com/alesapin))
+* Debian пакет `clickhouse-server` будет рекомендовать пакет `libcap2-bin` для того, чтобы использовать утилиту `setcap` для настроек. Данный пакет опционален. [#4093](https://github.com/yandex/ClickHouse/pull/4093) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Уменьшено время сборки, убраны ненужные включения заголовочных файлов. [#3898](https://github.com/yandex/ClickHouse/pull/3898) ([proller](https://github.com/proller))
+* Добавлены тесты производительности для функций хеширования. [#3918](https://github.com/yandex/ClickHouse/pull/3918) ([filimonov](https://github.com/filimonov))
+* Исправлены циклические зависимости библиотек. [#3958](https://github.com/yandex/ClickHouse/pull/3958) ([proller](https://github.com/proller))
+* Улучшена компиляция при малом объеме памяти. [#4030](https://github.com/yandex/ClickHouse/pull/4030) ([proller](https://github.com/proller))
+* Добавлен тестовый скрипт для воспроизведения деградации производительности в `jemalloc`. [#4036](https://github.com/yandex/ClickHouse/pull/4036) ([alexey-milovidov](https://github.com/alexey-milovidov))
+* Исправления опечаток в комментариях и строковых литералах. [#4122](https://github.com/yandex/ClickHouse/pull/4122) ([maiha](https://github.com/maiha))
+* Исправления опечаток в комментариях. [#4089](https://github.com/yandex/ClickHouse/pull/4089) ([Evgenii Pravda](https://github.com/kvinty))
+
 ## ClickHouse release 18.16.1, 2018-12-21
 
 ### Исправления ошибок:

CMakeLists.txt

@@ -3,6 +3,21 @@ cmake_minimum_required (VERSION 3.3)
 
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")
 
+option(ENABLE_IPO "Enable inter-procedural optimization (aka LTO)" OFF) # need cmake 3.9+
+if(ENABLE_IPO)
+    cmake_policy(SET CMP0069 NEW)
+    include(CheckIPOSupported)
+    check_ipo_supported(RESULT IPO_SUPPORTED OUTPUT IPO_NOT_SUPPORTED)
+    if(IPO_SUPPORTED)
+        message(STATUS "IPO/LTO is supported, enabling")
+        set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+    else()
+        message(STATUS "IPO/LTO is not supported: <${IPO_NOT_SUPPORTED}>")
+    endif()
+else()
+    message(STATUS "IPO/LTO not enabled.")
+endif()
+
 if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
     # Require at least gcc 7
     if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7 AND NOT CMAKE_VERSION VERSION_LESS 2.8.9)
@@ -81,7 +96,7 @@ option (ENABLE_TESTS "Enables tests" ON)
 if (CMAKE_SYSTEM_PROCESSOR MATCHES "amd64|x86_64")
     option (USE_INTERNAL_MEMCPY "Use internal implementation of 'memcpy' function instead of provided by libc. Only for x86_64." ON)
 
-    if (OS_LINUX AND NOT UNBUNDLED AND MAKE_STATIC_LIBRARIES)
+    if (OS_LINUX AND NOT UNBUNDLED AND MAKE_STATIC_LIBRARIES AND CMAKE_VERSION VERSION_GREATER "3.9.0")
         option (GLIBC_COMPATIBILITY "Set to TRUE to enable compatibility with older glibc libraries. Only for x86_64, Linux. Implies USE_INTERNAL_MEMCPY." ON)
         if (GLIBC_COMPATIBILITY)
             message (STATUS "Some symbols from glibc will be replaced for compatibility")
@@ -120,7 +135,9 @@ else()
     message(STATUS "Disabling compiler -pipe option (have only ${AVAILABLE_PHYSICAL_MEMORY} mb of memory)")
 endif()
 
-include (cmake/test_cpu.cmake)
+if(NOT DISABLE_CPU_OPTIMIZE)
+    include(cmake/test_cpu.cmake)
+endif()
 
 if(NOT COMPILER_CLANG) # clang: error: the clang compiler does not support '-march=native'
     option(ARCH_NATIVE "Enable -march=native compiler flag" ${ARCH_ARM})
@@ -204,7 +221,7 @@ if (UNBUNDLED OR NOT (OS_LINUX OR APPLE) OR ARCH_32)
     option (NO_WERROR "Disable -Werror compiler option" ON)
 endif ()
 
-message (STATUS "Building for: ${CMAKE_SYSTEM} ${CMAKE_SYSTEM_PROCESSOR} ${CMAKE_LIBRARY_ARCHITECTURE} ; USE_STATIC_LIBRARIES=${USE_STATIC_LIBRARIES} MAKE_STATIC_LIBRARIES=${MAKE_STATIC_LIBRARIES} UNBUNDLED=${UNBUNDLED} CCACHE=${CCACHE_FOUND} ${CCACHE_VERSION}")
+message (STATUS "Building for: ${CMAKE_SYSTEM} ${CMAKE_SYSTEM_PROCESSOR} ${CMAKE_LIBRARY_ARCHITECTURE} ; USE_STATIC_LIBRARIES=${USE_STATIC_LIBRARIES} MAKE_STATIC_LIBRARIES=${MAKE_STATIC_LIBRARIES} SPLIT_SHARED=${SPLIT_SHARED_LIBRARIES} UNBUNDLED=${UNBUNDLED} CCACHE=${CCACHE_FOUND} ${CCACHE_VERSION}")
 
 include(GNUInstallDirs)
 
@@ -229,10 +246,14 @@ include (cmake/find_re2.cmake)
 include (cmake/find_rdkafka.cmake)
 include (cmake/find_capnp.cmake)
 include (cmake/find_llvm.cmake)
-include (cmake/find_cpuid.cmake)
+include (cmake/find_cpuid.cmake) # Freebsd, bundled
+if (NOT USE_CPUID)
+    include (cmake/find_cpuinfo.cmake) # Debian
+endif()
 include (cmake/find_libgsasl.cmake)
 include (cmake/find_libxml2.cmake)
 include (cmake/find_protobuf.cmake)
+include (cmake/find_pdqsort.cmake)
 include (cmake/find_hdfs3.cmake)
 include (cmake/find_consistent-hashing.cmake)
 include (cmake/find_base64.cmake)

README.md

@@ -13,4 +13,5 @@ ClickHouse is an open-source column-oriented database management system that all
 
 ## Upcoming Events
 
-* [C++ ClickHouse and CatBoost Sprints](https://events.yandex.ru/events/ClickHouse/2-feb-2019/) in Moscow on February 2.
+* [ClickHouse Community Meetup](https://www.eventbrite.com/e/meetup-clickhouse-in-the-wild-deployment-success-stories-registration-55305051899) in San Francisco on February 19.
+* [ClickHouse Community Meetup](https://www.eventbrite.com/e/clickhouse-meetup-in-madrid-registration-55376746339) in Madrid on April 2.

ci/build-clang-from-sources.sh

@@ -3,7 +3,6 @@ set -e -x
 
 source default-config
 
-# TODO Non debian systems
 ./install-os-packages.sh svn
 ./install-os-packages.sh cmake
 

cmake/Modules/Findmetrohash.cmake

@@ -28,7 +28,7 @@ find_library(METROHASH_LIBRARIES
 
 find_path(METROHASH_INCLUDE_DIR
     NAMES metrohash.h
-    PATHS ${METROHASH_ROOT_DIR}/include ${METROHASH_INCLUDE_PATHS}
+    PATHS ${METROHASH_ROOT_DIR}/include PATH_SUFFIXES metrohash ${METROHASH_INCLUDE_PATHS}
 )
 
 include(FindPackageHandleStandardArgs)

cmake/find_cpuid.cmake

@@ -1,12 +1,13 @@
+# ARM: Cannot cpuid_get_raw_data: CPUID instruction is not supported
 if (NOT ARCH_ARM)
     option (USE_INTERNAL_CPUID_LIBRARY "Set to FALSE to use system cpuid library instead of bundled" ${NOT_UNBUNDLED})
 endif ()
 
-#if (USE_INTERNAL_CPUID_LIBRARY AND NOT EXISTS "${ClickHouse_SOURCE_DIR}/contrib/libcpuid/include/cpuid/libcpuid.h")
+if (USE_INTERNAL_CPUID_LIBRARY AND NOT EXISTS "${ClickHouse_SOURCE_DIR}/contrib/libcpuid/CMakeLists.txt")
-#   message (WARNING "submodule contrib/libcpuid is missing. to fix try run: \n git submodule update --init --recursive")
+   message (WARNING "submodule contrib/libcpuid is missing. to fix try run: \n git submodule update --init --recursive")
-#   set (USE_INTERNAL_CPUID_LIBRARY 0)
+   set (USE_INTERNAL_CPUID_LIBRARY 0)
-#   set (MISSING_INTERNAL_CPUID_LIBRARY 1)
+   set (MISSING_INTERNAL_CPUID_LIBRARY 1)
-#endif ()
+endif ()
 
 if (NOT USE_INTERNAL_CPUID_LIBRARY)
     find_library (CPUID_LIBRARY cpuid)
@@ -20,10 +21,12 @@ if (CPUID_LIBRARY AND CPUID_INCLUDE_DIR)
         add_definitions(-DHAVE_STDINT_H)
         # TODO: make virtual target cpuid:cpuid with COMPILE_DEFINITIONS property
     endif ()
-elseif (NOT MISSING_INTERNAL_CPUID_LIBRARY)
+    set (USE_CPUID 1)
+elseif (NOT ARCH_ARM AND NOT MISSING_INTERNAL_CPUID_LIBRARY)
     set (CPUID_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/libcpuid/include)
     set (USE_INTERNAL_CPUID_LIBRARY 1)
     set (CPUID_LIBRARY cpuid)
+    set (USE_CPUID 1)
 endif ()
 
-message (STATUS "Using cpuid: ${CPUID_INCLUDE_DIR} : ${CPUID_LIBRARY}")
+message (STATUS "Using cpuid=${USE_CPUID}: ${CPUID_INCLUDE_DIR} : ${CPUID_LIBRARY}")

cmake/find_cpuinfo.cmake

@@ -0,0 +1,24 @@
+option(USE_INTERNAL_CPUINFO_LIBRARY "Set to FALSE to use system cpuinfo library instead of bundled" ${NOT_UNBUNDLED})
+
+# Now we have no contrib/libcpuinfo, use from system.
+if (USE_INTERNAL_CPUINFO_LIBRARY AND NOT EXISTS "${ClickHouse_SOURCE_DIR}/contrib/libcpuinfo/include")
+   #message (WARNING "submodule contrib/libcpuid is missing. to fix try run: \n git submodule update --init --recursive")
+   set (USE_INTERNAL_CPUINFO_LIBRARY 0)
+   set (MISSING_INTERNAL_CPUINFO_LIBRARY 1)
+endif ()
+
+if(NOT USE_INTERNAL_CPUINFO_LIBRARY)
+    find_library(CPUINFO_LIBRARY cpuinfo)
+    find_path(CPUINFO_INCLUDE_DIR NAMES cpuinfo.h PATHS ${CPUINFO_INCLUDE_PATHS})
+endif()
+
+if(CPUID_LIBRARY AND CPUID_INCLUDE_DIR)
+    set(USE_CPUINFO 1)
+elseif(NOT MISSING_INTERNAL_CPUINFO_LIBRARY)
+    set(CPUINFO_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/libcpuinfo/include)
+    set(USE_INTERNAL_CPUINFO_LIBRARY 1)
+    set(CPUINFO_LIBRARY cpuinfo)
+    set(USE_CPUINFO 1)
+endif()
+
+message(STATUS "Using cpuinfo=${USE_CPUINFO}: ${CPUINFO_INCLUDE_DIR} : ${CPUINFO_LIBRARY}")

cmake/find_gtest.cmake

@@ -8,18 +8,22 @@ if (NOT EXISTS "${ClickHouse_SOURCE_DIR}/contrib/googletest/googletest/CMakeList
    set (MISSING_INTERNAL_GTEST_LIBRARY 1)
 endif ()
 
-if (NOT USE_INTERNAL_GTEST_LIBRARY)
-    find_package (GTest)
-endif ()
 
-if (NOT GTEST_INCLUDE_DIRS AND NOT MISSING_INTERNAL_GTEST_LIBRARY)
+if(NOT USE_INTERNAL_GTEST_LIBRARY)
+    # TODO: autodetect of GTEST_SRC_DIR by EXISTS /usr/src/googletest/CMakeLists.txt
+    if(NOT GTEST_SRC_DIR)
+        find_package(GTest)
+    endif()
+endif()
+
+if (NOT GTEST_SRC_DIR AND NOT GTEST_INCLUDE_DIRS AND NOT MISSING_INTERNAL_GTEST_LIBRARY)
     set (USE_INTERNAL_GTEST_LIBRARY 1)
     set (GTEST_MAIN_LIBRARIES gtest_main)
     set (GTEST_INCLUDE_DIRS ${ClickHouse_SOURCE_DIR}/contrib/googletest/googletest)
 endif ()
 
-if(GTEST_INCLUDE_DIRS AND GTEST_MAIN_LIBRARIES)
+if((GTEST_INCLUDE_DIRS AND GTEST_MAIN_LIBRARIES) OR GTEST_SRC_DIR)
     set(USE_GTEST 1)
 endif()
 
-message (STATUS "Using gtest=${USE_GTEST}: ${GTEST_INCLUDE_DIRS} : ${GTEST_MAIN_LIBRARIES}")
+message (STATUS "Using gtest=${USE_GTEST}: ${GTEST_INCLUDE_DIRS} : ${GTEST_MAIN_LIBRARIES} : ${GTEST_SRC_DIR}")

cmake/find_pdqsort.cmake

@@ -0,0 +1,2 @@
+set(PDQSORT_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/pdqsort)
+message(STATUS "Using pdqsort: ${PDQSORT_INCLUDE_DIR}")

cmake/find_protobuf.cmake

@@ -1,5 +1,11 @@
 option(USE_INTERNAL_PROTOBUF_LIBRARY "Set to FALSE to use system protobuf instead of bundled" ${NOT_UNBUNDLED})
 
+if(OS_FREEBSD AND SANITIZE STREQUAL "address")
+    # ../contrib/protobuf/src/google/protobuf/arena_impl.h:45:10: fatal error: 'sanitizer/asan_interface.h' file not found
+    set(MISSING_INTERNAL_PROTOBUF_LIBRARY 1)
+    set(USE_INTERNAL_PROTOBUF_LIBRARY 0)
+endif()
+
 if(NOT EXISTS "${ClickHouse_SOURCE_DIR}/contrib/protobuf/cmake/CMakeLists.txt")
    if(USE_INTERNAL_PROTOBUF_LIBRARY)
        message(WARNING "submodule contrib/protobuf is missing. to fix try run: \n git submodule update --init --recursive")

cmake/find_re2.cmake

@@ -5,13 +5,24 @@ if (NOT USE_INTERNAL_RE2_LIBRARY)
     find_path (RE2_INCLUDE_DIR NAMES re2/re2.h PATHS ${RE2_INCLUDE_PATHS})
 endif ()
 
+string(FIND ${CMAKE_CURRENT_BINARY_DIR} " " _have_space)
+if(_have_space GREATER 0)
+    message(WARNING "Using spaces in build path [${CMAKE_CURRENT_BINARY_DIR}] highly not recommended. Library re2st will be disabled.")
+    set (MISSING_INTERNAL_RE2_ST_LIBRARY 1)
+endif()
+
 if (RE2_LIBRARY AND RE2_INCLUDE_DIR)
     set (RE2_ST_LIBRARY ${RE2_LIBRARY})
-else ()
+elseif (NOT MISSING_INTERNAL_RE2_LIBRARY)
     set (USE_INTERNAL_RE2_LIBRARY 1)
     set (RE2_LIBRARY re2)
-    set (RE2_ST_LIBRARY re2_st)
+    set (RE2_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/re2)
-    set (USE_RE2_ST 1)
+    if (NOT MISSING_INTERNAL_RE2_ST_LIBRARY)
+        set (RE2_ST_LIBRARY re2_st)
+        set (USE_RE2_ST 1)
+    else ()
+        set (RE2_ST_LIBRARY ${RE2_LIBRARY})
+    endif ()
 endif ()
 
 message (STATUS "Using re2: ${RE2_INCLUDE_DIR} : ${RE2_LIBRARY}; ${RE2_ST_INCLUDE_DIR} : ${RE2_ST_LIBRARY}")

cmake/lib_name.cmake

@@ -2,4 +2,5 @@ set(DIVIDE_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/libdivide)
 set(COMMON_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/libs/libcommon/include ${ClickHouse_BINARY_DIR}/libs/libcommon/include)
 set(DBMS_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/dbms/src ${ClickHouse_BINARY_DIR}/dbms/src)
 set(DOUBLE_CONVERSION_CONTRIB_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/double-conversion)
+set(METROHASH_CONTRIB_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/libmetrohash/src)
 set(PCG_RANDOM_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/libpcg-random/include)

contrib/CMakeLists.txt

@@ -8,6 +8,8 @@ elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
     set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-old-style-cast -Wno-unused-function -Wno-unused-variable -Wno-unused-result -Wno-deprecated-declarations -Wno-non-virtual-dtor -Wno-format -Wno-inconsistent-missing-override -std=c++1z")
 endif ()
 
+set_property(DIRECTORY PROPERTY EXCLUDE_FROM_ALL 1)
+
 if (USE_INTERNAL_BOOST_LIBRARY)
     add_subdirectory (boost-cmake)
 endif ()
@@ -107,6 +109,11 @@ if (USE_INTERNAL_SSL_LIBRARY)
     if (NOT MAKE_STATIC_LIBRARIES)
         set (BUILD_SHARED 1)
     endif ()
+
+    # By default, ${CMAKE_INSTALL_PREFIX}/etc/ssl is selected - that is not what we need.
+    # We need to use system wide ssl directory.
+    set (OPENSSLDIR "/etc/ssl")
+
     set (LIBRESSL_SKIP_INSTALL 1 CACHE INTERNAL "")
     add_subdirectory (ssl)
     target_include_directories(${OPENSSL_CRYPTO_LIBRARY} SYSTEM PUBLIC ${OPENSSL_INCLUDE_DIR})
@@ -166,13 +173,16 @@ if (USE_INTERNAL_POCO_LIBRARY)
     endif ()
 endif ()
 
-if (USE_INTERNAL_GTEST_LIBRARY)
+if(USE_INTERNAL_GTEST_LIBRARY)
     # Google Test from sources
     add_subdirectory(${ClickHouse_SOURCE_DIR}/contrib/googletest/googletest ${CMAKE_CURRENT_BINARY_DIR}/googletest)
     # avoid problems with <regexp.h>
     target_compile_definitions (gtest INTERFACE GTEST_HAS_POSIX_RE=0)
     target_include_directories (gtest SYSTEM INTERFACE ${ClickHouse_SOURCE_DIR}/contrib/googletest/include)
-endif ()
+elseif(GTEST_SRC_DIR)
+    add_subdirectory(${GTEST_SRC_DIR}/googletest ${CMAKE_CURRENT_BINARY_DIR}/googletest)
+    target_compile_definitions(gtest INTERFACE GTEST_HAS_POSIX_RE=0)
+endif()
 
 if (USE_INTERNAL_LLVM_LIBRARY)
     file(GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/empty.cpp CONTENT " ")

contrib/base64-cmake/CMakeLists.txt

@@ -39,5 +39,20 @@ add_library(base64 ${LINK_MODE}
         ${LIBRARY_DIR}/lib/codecs.h
         ${CMAKE_CURRENT_BINARY_DIR}/config.h)
 
-target_compile_options(base64 PRIVATE ${base64_SSSE3_opt} ${base64_SSE41_opt} ${base64_SSE42_opt} ${base64_AVX_opt} ${base64_AVX2_opt})
+if(HAVE_AVX)
+    set_source_files_properties(${LIBRARY_DIR}/lib/arch/avx/codec.c PROPERTIES COMPILE_FLAGS -mavx)
+endif()
+if(HAVE_AVX2)
+    set_source_files_properties(${LIBRARY_DIR}/lib/arch/avx2/codec.c PROPERTIES COMPILE_FLAGS -mavx2)
+endif()
+if(HAVE_SSE41)
+    set_source_files_properties(${LIBRARY_DIR}/lib/arch/sse41/codec.c PROPERTIES COMPILE_FLAGS -msse4.1)
+endif()
+if(HAVE_SSE42)
+    set_source_files_properties(${LIBRARY_DIR}/lib/arch/sse42/codec.c PROPERTIES COMPILE_FLAGS -msse4.2)
+endif()
+if(HAVE_SSSE3)
+    set_source_files_properties(${LIBRARY_DIR}/lib/arch/ssse3/codec.c PROPERTIES COMPILE_FLAGS -mssse3)
+endif()
+
 target_include_directories(base64 PRIVATE ${LIBRARY_DIR}/include ${CMAKE_CURRENT_BINARY_DIR})

contrib/cppkafka

@@ -1 +1 @@
-Subproject commit 520465510efef7704346cf8d140967c4abb057c1
+Subproject commit 860c90e92eee6690aa74a2ca7b7c5c6930dffecd

contrib/jemalloc

@@ -1 +1 @@
-Subproject commit 41b7372eadee941b9164751b8d4963f915d3ceae
+Subproject commit cd2931ad9bbd78208565716ab102e86d858c2fff

contrib/libmetrohash/CMakeLists.txt

@@ -1,5 +1,5 @@
 if (HAVE_SSE42) # Not used. Pretty easy to port.
-    set (SOURCES_SSE42_ONLY src/metrohash128crc.cpp)
+    set (SOURCES_SSE42_ONLY src/metrohash128crc.cpp src/metrohash128crc.h)
 endif ()
 
 add_library(metrohash

contrib/libmetrohash/LICENSE

@@ -1,22 +1,201 @@
-The MIT License (MIT)
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
 
-Copyright (c) 2015 J. Andrew Rogers
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
+   1. Definitions.
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
+      "License" shall mean the terms and conditions for use, reproduction,
-copies or substantial portions of the Software.
+      and distribution as defined by Sections 1 through 9 of this document.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+      "Licensor" shall mean the copyright owner or entity authorized by
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+      the copyright owner that is granting the License.
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
 
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

contrib/libmetrohash/README.md

@@ -5,12 +5,44 @@ MetroHash is a set of state-of-the-art hash functions for *non-cryptographic* us
 * Fastest general-purpose functions for bulk hashing. 
 * Fastest general-purpose functions for small, variable length keys. 
 * Robust statistical bias profile, similar to the MD5 cryptographic hash.
+* Hashes can be constructed incrementally (**new**)
 * 64-bit, 128-bit, and 128-bit CRC variants currently available.
 * Optimized for modern x86-64 microarchitectures.
 * Elegant, compact, readable functions.
  
 You can read more about the design and history [here](http://www.jandrewrogers.com/2015/05/27/metrohash/).
 
+## News
+
+### 23 October 2018
+
+The project has been re-licensed under Apache License v2.0. The purpose of this license change is consistency with the imminent release of MetroHash v2.0, which is also licensed under the Apache license.
+
+### 27 July 2015
+
+Two new 64-bit and 128-bit algorithms add the ability to construct hashes incrementally. In addition to supporting incremental construction, the algorithms are slightly superior to the prior versions. 
+
+A big change is that these new algorithms are implemented as C++ classes that support both incremental and stateless hashing. These classes also have a static method for verifying the implementation against the test vectors built into the classes. Implementations are now fully contained by their respective headers e.g. "metrohash128.h".
+
+*Note: an incremental version of the 128-bit CRC version is on its way but is not included in this push.*
+
+**Usage Example For Stateless Hashing**
+
+`MetroHash128::Hash(key, key_length, hash_ptr, seed)`
+
+**Usage Example For Incremental Hashing**
+
+`MetroHash128 hasher;`  
+`hasher.Update(partial_key, partial_key_length);`  
+`...`  
+`hasher.Update(partial_key, partial_key_length);`  
+`hasher.Finalize(hash_ptr);`  
+
+An `Initialize(seed)` method allows the hasher objects to be reused.
+
+
+### 27 May 2015
+
 Six hash functions have been included in the initial release:
 
 * 64-bit hash functions, "metrohash64_1" and "metrohash64_2"

contrib/libmetrohash/VERSION

@@ -1,7 +1,4 @@
-origin: git@github.com:jandrewrogers/MetroHash.git
+origin: https://github.com/jandrewrogers/MetroHash.git
-commit d9dee18a54a8a6766e24c1950b814ac7ca9d1a89
+commit 690a521d9beb2e1050cc8f273fdabc13b31bf8f6 tag: v1.1.3
-Merge: 761e8a4 3d06b24
 Author: J. Andrew Rogers <andrew@jarbox.org>
-Date:   Sat Jun 6 16:12:06 2015 -0700
+Date:   Tue Oct 23 09:49:53 2018 -0700
-
-    modified README

contrib/libmetrohash/src/metrohash.h

@@ -1,73 +1,24 @@
 // metrohash.h
 //
-// The MIT License (MIT)
+// Copyright 2015-2018 J. Andrew Rogers
 //
-// Copyright (c) 2015 J. Andrew Rogers
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
 //
-// Permission is hereby granted, free of charge, to any person obtaining a copy
+//     http://www.apache.org/licenses/LICENSE-2.0
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
 //
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #ifndef METROHASH_METROHASH_H
 #define METROHASH_METROHASH_H
 
-#include <stdint.h>
+#include "metrohash64.h"
-#include <string.h>
+#include "metrohash128.h"
-
+#include "metrohash128crc.h"
-// MetroHash 64-bit hash functions
-void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
-void metrohash64_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
-
-// MetroHash 128-bit hash functions
-void metrohash128_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
-void metrohash128_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
-
-// MetroHash 128-bit hash functions using CRC instruction
-void metrohash128crc_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
-void metrohash128crc_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
-
-
-/* rotate right idiom recognized by compiler*/
-inline static uint64_t rotate_right(uint64_t v, unsigned k)
-{
-    return (v >> k) | (v << (64 - k));
-}
-
-// unaligned reads, fast and safe on Nehalem and later microarchitectures
-inline static uint64_t read_u64(const void * const ptr)
-{
-    return static_cast<uint64_t>(*reinterpret_cast<const uint64_t*>(ptr));
-}
-
-inline static uint64_t read_u32(const void * const ptr)
-{
-    return static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(ptr));
-}
-
-inline static uint64_t read_u16(const void * const ptr)
-{
-    return static_cast<uint64_t>(*reinterpret_cast<const uint16_t*>(ptr));
-}
-
-inline static uint64_t read_u8 (const void * const ptr)
-{
-    return static_cast<uint64_t>(*reinterpret_cast<const uint8_t *>(ptr));
-}
-
 
 #endif // #ifndef METROHASH_METROHASH_H

contrib/libmetrohash/src/metrohash128.cpp

@@ -1,29 +1,260 @@
 // metrohash128.cpp
 //
-// The MIT License (MIT)
+// Copyright 2015-2018 J. Andrew Rogers
 //
-// Copyright (c) 2015 J. Andrew Rogers
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
 //
-// Permission is hereby granted, free of charge, to any person obtaining a copy
+//     http://www.apache.org/licenses/LICENSE-2.0
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
 //
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string.h>
+#include "platform.h"
+#include "metrohash128.h"
+
+const char * MetroHash128::test_string = "012345678901234567890123456789012345678901234567890123456789012";
+
+const uint8_t MetroHash128::test_seed_0[16] =   {
+                                                0xC7, 0x7C, 0xE2, 0xBF, 0xA4, 0xED, 0x9F, 0x9B,
+                                                0x05, 0x48, 0xB2, 0xAC, 0x50, 0x74, 0xA2, 0x97
+                                                };
+
+const uint8_t MetroHash128::test_seed_1[16] =   {
+                                                0x45, 0xA3, 0xCD, 0xB8, 0x38, 0x19, 0x9D, 0x7F,
+                                                0xBD, 0xD6, 0x8D, 0x86, 0x7A, 0x14, 0xEC, 0xEF
+                                                };
+
+
+
+MetroHash128::MetroHash128(const uint64_t seed)
+{
+    Initialize(seed);
+}
+
+
+void MetroHash128::Initialize(const uint64_t seed)
+{
+    // initialize internal hash registers
+    state.v[0] = (static_cast<uint64_t>(seed) - k0) * k3;
+    state.v[1] = (static_cast<uint64_t>(seed) + k1) * k2;
+    state.v[2] = (static_cast<uint64_t>(seed) + k0) * k2;
+    state.v[3] = (static_cast<uint64_t>(seed) - k1) * k3;
+
+    // initialize total length of input
+    bytes = 0;
+}
+
+
+void MetroHash128::Update(const uint8_t * const buffer, const uint64_t length)
+{
+    const uint8_t * ptr = reinterpret_cast<const uint8_t*>(buffer);
+    const uint8_t * const end = ptr + length;
+
+    // input buffer may be partially filled
+    if (bytes % 32)
+    {
+        uint64_t fill = 32 - (bytes % 32);
+        if (fill > length)
+            fill = length;
+
+        memcpy(input.b + (bytes % 32), ptr, static_cast<size_t>(fill));
+        ptr   += fill;
+        bytes += fill;
+        
+        // input buffer is still partially filled
+        if ((bytes % 32) != 0) return;
+
+        // process full input buffer
+        state.v[0] += read_u64(&input.b[ 0]) * k0; state.v[0] = rotate_right(state.v[0],29) + state.v[2];
+        state.v[1] += read_u64(&input.b[ 8]) * k1; state.v[1] = rotate_right(state.v[1],29) + state.v[3];
+        state.v[2] += read_u64(&input.b[16]) * k2; state.v[2] = rotate_right(state.v[2],29) + state.v[0];
+        state.v[3] += read_u64(&input.b[24]) * k3; state.v[3] = rotate_right(state.v[3],29) + state.v[1];
+    }
+    
+    // bulk update
+    bytes += (end - ptr);
+    while (ptr <= (end - 32))
+    {
+        // process directly from the source, bypassing the input buffer
+        state.v[0] += read_u64(ptr) * k0; ptr += 8; state.v[0] = rotate_right(state.v[0],29) + state.v[2];
+        state.v[1] += read_u64(ptr) * k1; ptr += 8; state.v[1] = rotate_right(state.v[1],29) + state.v[3];
+        state.v[2] += read_u64(ptr) * k2; ptr += 8; state.v[2] = rotate_right(state.v[2],29) + state.v[0];
+        state.v[3] += read_u64(ptr) * k3; ptr += 8; state.v[3] = rotate_right(state.v[3],29) + state.v[1];
+    }
+    
+    // store remaining bytes in input buffer
+    if (ptr < end)
+        memcpy(input.b, ptr, end - ptr);
+}
+
+
+void MetroHash128::Finalize(uint8_t * const hash)
+{
+    // finalize bulk loop, if used
+    if (bytes >= 32)
+    {
+        state.v[2] ^= rotate_right(((state.v[0] + state.v[3]) * k0) + state.v[1], 21) * k1;
+        state.v[3] ^= rotate_right(((state.v[1] + state.v[2]) * k1) + state.v[0], 21) * k0;
+        state.v[0] ^= rotate_right(((state.v[0] + state.v[2]) * k0) + state.v[3], 21) * k1;
+        state.v[1] ^= rotate_right(((state.v[1] + state.v[3]) * k1) + state.v[2], 21) * k0;
+    }
+    
+    // process any bytes remaining in the input buffer
+    const uint8_t * ptr = reinterpret_cast<const uint8_t*>(input.b);
+    const uint8_t * const end = ptr + (bytes % 32);
+    
+    if ((end - ptr) >= 16)
+    {
+        state.v[0] += read_u64(ptr) * k2; ptr += 8; state.v[0] = rotate_right(state.v[0],33) * k3;
+        state.v[1] += read_u64(ptr) * k2; ptr += 8; state.v[1] = rotate_right(state.v[1],33) * k3;
+        state.v[0] ^= rotate_right((state.v[0] * k2) + state.v[1], 45) * k1;
+        state.v[1] ^= rotate_right((state.v[1] * k3) + state.v[0], 45) * k0;
+    }
+
+    if ((end - ptr) >= 8)
+    {
+        state.v[0] += read_u64(ptr) * k2; ptr += 8; state.v[0] = rotate_right(state.v[0],33) * k3;
+        state.v[0] ^= rotate_right((state.v[0] * k2) + state.v[1], 27) * k1;
+    }
+
+    if ((end - ptr) >= 4)
+    {
+        state.v[1] += read_u32(ptr) * k2; ptr += 4; state.v[1] = rotate_right(state.v[1],33) * k3;
+        state.v[1] ^= rotate_right((state.v[1] * k3) + state.v[0], 46) * k0;
+    }
+
+    if ((end - ptr) >= 2)
+    {
+        state.v[0] += read_u16(ptr) * k2; ptr += 2; state.v[0] = rotate_right(state.v[0],33) * k3;
+        state.v[0] ^= rotate_right((state.v[0] * k2) + state.v[1], 22) * k1;
+    }
+
+    if ((end - ptr) >= 1)
+    {
+        state.v[1] += read_u8 (ptr) * k2; state.v[1] = rotate_right(state.v[1],33) * k3;
+        state.v[1] ^= rotate_right((state.v[1] * k3) + state.v[0], 58) * k0;
+    }
+    
+    state.v[0] += rotate_right((state.v[0] * k0) + state.v[1], 13);
+    state.v[1] += rotate_right((state.v[1] * k1) + state.v[0], 37);
+    state.v[0] += rotate_right((state.v[0] * k2) + state.v[1], 13);
+    state.v[1] += rotate_right((state.v[1] * k3) + state.v[0], 37);
+
+    bytes = 0;
+
+    // do any endian conversion here
+
+    memcpy(hash, state.v, 16);
+}
+
+
+void MetroHash128::Hash(const uint8_t * buffer, const uint64_t length, uint8_t * const hash, const uint64_t seed)
+{
+    const uint8_t * ptr = reinterpret_cast<const uint8_t*>(buffer);
+    const uint8_t * const end = ptr + length;
+
+    uint64_t v[4];
+
+    v[0] = (static_cast<uint64_t>(seed) - k0) * k3;
+    v[1] = (static_cast<uint64_t>(seed) + k1) * k2;
+
+    if (length >= 32)
+    {
+        v[2] = (static_cast<uint64_t>(seed) + k0) * k2;
+        v[3] = (static_cast<uint64_t>(seed) - k1) * k3;
+
+        do
+        {
+            v[0] += read_u64(ptr) * k0; ptr += 8; v[0] = rotate_right(v[0],29) + v[2];
+            v[1] += read_u64(ptr) * k1; ptr += 8; v[1] = rotate_right(v[1],29) + v[3];
+            v[2] += read_u64(ptr) * k2; ptr += 8; v[2] = rotate_right(v[2],29) + v[0];
+            v[3] += read_u64(ptr) * k3; ptr += 8; v[3] = rotate_right(v[3],29) + v[1];
+        }
+        while (ptr <= (end - 32));
+
+        v[2] ^= rotate_right(((v[0] + v[3]) * k0) + v[1], 21) * k1;
+        v[3] ^= rotate_right(((v[1] + v[2]) * k1) + v[0], 21) * k0;
+        v[0] ^= rotate_right(((v[0] + v[2]) * k0) + v[3], 21) * k1;
+        v[1] ^= rotate_right(((v[1] + v[3]) * k1) + v[2], 21) * k0;
+    }
+
+    if ((end - ptr) >= 16)
+    {
+        v[0] += read_u64(ptr) * k2; ptr += 8; v[0] = rotate_right(v[0],33) * k3;
+        v[1] += read_u64(ptr) * k2; ptr += 8; v[1] = rotate_right(v[1],33) * k3;
+        v[0] ^= rotate_right((v[0] * k2) + v[1], 45) * k1;
+        v[1] ^= rotate_right((v[1] * k3) + v[0], 45) * k0;
+    }
+
+    if ((end - ptr) >= 8)
+    {
+        v[0] += read_u64(ptr) * k2; ptr += 8; v[0] = rotate_right(v[0],33) * k3;
+        v[0] ^= rotate_right((v[0] * k2) + v[1], 27) * k1;
+    }
+
+    if ((end - ptr) >= 4)
+    {
+        v[1] += read_u32(ptr) * k2; ptr += 4; v[1] = rotate_right(v[1],33) * k3;
+        v[1] ^= rotate_right((v[1] * k3) + v[0], 46) * k0;
+    }
+
+    if ((end - ptr) >= 2)
+    {
+        v[0] += read_u16(ptr) * k2; ptr += 2; v[0] = rotate_right(v[0],33) * k3;
+        v[0] ^= rotate_right((v[0] * k2) + v[1], 22) * k1;
+    }
+
+    if ((end - ptr) >= 1)
+    {
+        v[1] += read_u8 (ptr) * k2; v[1] = rotate_right(v[1],33) * k3;
+        v[1] ^= rotate_right((v[1] * k3) + v[0], 58) * k0;
+    }
+
+    v[0] += rotate_right((v[0] * k0) + v[1], 13);
+    v[1] += rotate_right((v[1] * k1) + v[0], 37);
+    v[0] += rotate_right((v[0] * k2) + v[1], 13);
+    v[1] += rotate_right((v[1] * k3) + v[0], 37);
+
+    // do any endian conversion here
+
+    memcpy(hash, v, 16);
+}
+
+
+bool MetroHash128::ImplementationVerified()
+{
+    uint8_t hash[16];
+    const uint8_t * key = reinterpret_cast<const uint8_t *>(MetroHash128::test_string);
+
+    // verify one-shot implementation
+    MetroHash128::Hash(key, strlen(MetroHash128::test_string), hash, 0);
+    if (memcmp(hash, MetroHash128::test_seed_0, 16) != 0) return false;
+
+    MetroHash128::Hash(key, strlen(MetroHash128::test_string), hash, 1);
+    if (memcmp(hash, MetroHash128::test_seed_1, 16) != 0) return false;
+
+    // verify incremental implementation
+    MetroHash128 metro;
+    
+    metro.Initialize(0);
+    metro.Update(reinterpret_cast<const uint8_t *>(MetroHash128::test_string), strlen(MetroHash128::test_string));
+    metro.Finalize(hash);
+    if (memcmp(hash, MetroHash128::test_seed_0, 16) != 0) return false;
+
+    metro.Initialize(1);
+    metro.Update(reinterpret_cast<const uint8_t *>(MetroHash128::test_string), strlen(MetroHash128::test_string));
+    metro.Finalize(hash);
+    if (memcmp(hash, MetroHash128::test_seed_1, 16) != 0) return false;
+
+    return true;
+}
 
-#include "metrohash.h"
 
 void metrohash128_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out)
 {
@@ -97,6 +328,8 @@ void metrohash128_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t *
     v[0] += rotate_right((v[0] * k2) + v[1], 13);
     v[1] += rotate_right((v[1] * k3) + v[0], 37);
 
+    // do any endian conversion here
+
     memcpy(out, v, 16);
 }
 
@@ -173,6 +406,8 @@ void metrohash128_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t *
     v[0] += rotate_right((v[0] * k2) + v[1], 33);
     v[1] += rotate_right((v[1] * k3) + v[0], 33);
 
+    // do any endian conversion here
+
     memcpy(out, v, 16);
 }
 

contrib/libmetrohash/src/metrohash128.h

@@ -0,0 +1,72 @@
+// metrohash128.h
+//
+// Copyright 2015-2018 J. Andrew Rogers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef METROHASH_METROHASH_128_H
+#define METROHASH_METROHASH_128_H
+
+#include <stdint.h>
+
+class MetroHash128
+{
+public:
+    static const uint32_t bits = 128;
+
+    // Constructor initializes the same as Initialize()
+    MetroHash128(const uint64_t seed=0);
+    
+    // Initializes internal state for new hash with optional seed
+    void Initialize(const uint64_t seed=0);
+    
+    // Update the hash state with a string of bytes. If the length
+    // is sufficiently long, the implementation switches to a bulk
+    // hashing algorithm directly on the argument buffer for speed.
+    void Update(const uint8_t * buffer, const uint64_t length);
+    
+    // Constructs the final hash and writes it to the argument buffer.
+    // After a hash is finalized, this instance must be Initialized()-ed
+    // again or the behavior of Update() and Finalize() is undefined.
+    void Finalize(uint8_t * const hash);
+    
+    // A non-incremental function implementation. This can be significantly
+    // faster than the incremental implementation for some usage patterns.
+    static void Hash(const uint8_t * buffer, const uint64_t length, uint8_t * const hash, const uint64_t seed=0);
+
+    // Does implementation correctly execute test vectors?
+    static bool ImplementationVerified();
+
+    // test vectors -- Hash(test_string, seed=0) => test_seed_0
+    static const char * test_string;
+    static const uint8_t test_seed_0[16];
+    static const uint8_t test_seed_1[16];
+
+private:
+    static const uint64_t k0 = 0xC83A91E1;
+    static const uint64_t k1 = 0x8648DBDB;
+    static const uint64_t k2 = 0x7BDEC03B;
+    static const uint64_t k3 = 0x2F5870A5;
+    
+    struct { uint64_t v[4]; } state;
+    struct { uint8_t b[32]; } input;
+    uint64_t bytes;
+};
+
+
+// Legacy 128-bit hash functions -- do not use
+void metrohash128_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
+void metrohash128_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
+
+
+#endif // #ifndef METROHASH_METROHASH_128_H

contrib/libmetrohash/src/metrohash128crc.cpp

@@ -1,31 +1,24 @@
 // metrohash128crc.cpp
 //
-// The MIT License (MIT)
+// Copyright 2015-2018 J. Andrew Rogers
 //
-// Copyright (c) 2015 J. Andrew Rogers
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
 //
-// Permission is hereby granted, free of charge, to any person obtaining a copy
+//     http://www.apache.org/licenses/LICENSE-2.0
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
 //
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 
-#include "metrohash.h"
 #include <nmmintrin.h>
+#include <string.h>
+#include "metrohash.h"
+#include "platform.h"
 
 
 void metrohash128crc_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out)

contrib/libmetrohash/src/metrohash128crc.h

@@ -0,0 +1,27 @@
+// metrohash128crc.h
+//
+// Copyright 2015-2018 J. Andrew Rogers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef METROHASH_METROHASH_128_CRC_H
+#define METROHASH_METROHASH_128_CRC_H
+
+#include <stdint.h>
+
+// Legacy 128-bit hash functions
+void metrohash128crc_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
+void metrohash128crc_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
+
+
+#endif // #ifndef METROHASH_METROHASH_128_CRC_H

contrib/libmetrohash/src/metrohash64.cpp

@@ -1,29 +1,257 @@
 // metrohash64.cpp
 //
-// The MIT License (MIT)
+// Copyright 2015-2018 J. Andrew Rogers
 //
-// Copyright (c) 2015 J. Andrew Rogers
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
 //
-// Permission is hereby granted, free of charge, to any person obtaining a copy
+//     http://www.apache.org/licenses/LICENSE-2.0
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
 //
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "platform.h"
+#include "metrohash64.h"
+
+#include <cstring>
+
+const char * MetroHash64::test_string = "012345678901234567890123456789012345678901234567890123456789012";
+
+const uint8_t MetroHash64::test_seed_0[8] =   { 0x6B, 0x75, 0x3D, 0xAE, 0x06, 0x70, 0x4B, 0xAD };
+const uint8_t MetroHash64::test_seed_1[8] =   { 0x3B, 0x0D, 0x48, 0x1C, 0xF4, 0xB9, 0xB8, 0xDF };
+
+
+
+MetroHash64::MetroHash64(const uint64_t seed)
+{
+    Initialize(seed);
+}
+
+
+void MetroHash64::Initialize(const uint64_t seed)
+{
+    vseed = (static_cast<uint64_t>(seed) + k2) * k0;
+
+    // initialize internal hash registers
+    state.v[0] = vseed;
+    state.v[1] = vseed;
+    state.v[2] = vseed;
+    state.v[3] = vseed;
+
+    // initialize total length of input
+    bytes = 0;
+}
+
+
+void MetroHash64::Update(const uint8_t * const buffer, const uint64_t length)
+{
+    const uint8_t * ptr = reinterpret_cast<const uint8_t*>(buffer);
+    const uint8_t * const end = ptr + length;
+
+    // input buffer may be partially filled
+    if (bytes % 32)
+    {
+        uint64_t fill = 32 - (bytes % 32);
+        if (fill > length)
+            fill = length;
+
+        memcpy(input.b + (bytes % 32), ptr, static_cast<size_t>(fill));
+        ptr   += fill;
+        bytes += fill;
+        
+        // input buffer is still partially filled
+        if ((bytes % 32) != 0) return;
+
+        // process full input buffer
+        state.v[0] += read_u64(&input.b[ 0]) * k0; state.v[0] = rotate_right(state.v[0],29) + state.v[2];
+        state.v[1] += read_u64(&input.b[ 8]) * k1; state.v[1] = rotate_right(state.v[1],29) + state.v[3];
+        state.v[2] += read_u64(&input.b[16]) * k2; state.v[2] = rotate_right(state.v[2],29) + state.v[0];
+        state.v[3] += read_u64(&input.b[24]) * k3; state.v[3] = rotate_right(state.v[3],29) + state.v[1];
+    }
+    
+    // bulk update
+    bytes += static_cast<uint64_t>(end - ptr);
+    while (ptr <= (end - 32))
+    {
+        // process directly from the source, bypassing the input buffer
+        state.v[0] += read_u64(ptr) * k0; ptr += 8; state.v[0] = rotate_right(state.v[0],29) + state.v[2];
+        state.v[1] += read_u64(ptr) * k1; ptr += 8; state.v[1] = rotate_right(state.v[1],29) + state.v[3];
+        state.v[2] += read_u64(ptr) * k2; ptr += 8; state.v[2] = rotate_right(state.v[2],29) + state.v[0];
+        state.v[3] += read_u64(ptr) * k3; ptr += 8; state.v[3] = rotate_right(state.v[3],29) + state.v[1];
+    }
+    
+    // store remaining bytes in input buffer
+    if (ptr < end)
+        memcpy(input.b, ptr, static_cast<size_t>(end - ptr));
+}
+
+
+void MetroHash64::Finalize(uint8_t * const hash)
+{
+    // finalize bulk loop, if used
+    if (bytes >= 32)
+    {
+        state.v[2] ^= rotate_right(((state.v[0] + state.v[3]) * k0) + state.v[1], 37) * k1;
+        state.v[3] ^= rotate_right(((state.v[1] + state.v[2]) * k1) + state.v[0], 37) * k0;
+        state.v[0] ^= rotate_right(((state.v[0] + state.v[2]) * k0) + state.v[3], 37) * k1;
+        state.v[1] ^= rotate_right(((state.v[1] + state.v[3]) * k1) + state.v[2], 37) * k0;
+
+        state.v[0] = vseed + (state.v[0] ^ state.v[1]);
+    }
+    
+    // process any bytes remaining in the input buffer
+    const uint8_t * ptr = reinterpret_cast<const uint8_t*>(input.b);
+    const uint8_t * const end = ptr + (bytes % 32);
+    
+    if ((end - ptr) >= 16)
+    {
+        state.v[1]  = state.v[0] + (read_u64(ptr) * k2); ptr += 8; state.v[1] = rotate_right(state.v[1],29) * k3;
+        state.v[2]  = state.v[0] + (read_u64(ptr) * k2); ptr += 8; state.v[2] = rotate_right(state.v[2],29) * k3;
+        state.v[1] ^= rotate_right(state.v[1] * k0, 21) + state.v[2];
+        state.v[2] ^= rotate_right(state.v[2] * k3, 21) + state.v[1];
+        state.v[0] += state.v[2];
+    }
+
+    if ((end - ptr) >= 8)
+    {
+        state.v[0] += read_u64(ptr) * k3; ptr += 8;
+        state.v[0] ^= rotate_right(state.v[0], 55) * k1;
+    }
+
+    if ((end - ptr) >= 4)
+    {
+        state.v[0] += read_u32(ptr) * k3; ptr += 4;
+        state.v[0] ^= rotate_right(state.v[0], 26) * k1;
+    }
+
+    if ((end - ptr) >= 2)
+    {
+        state.v[0] += read_u16(ptr) * k3; ptr += 2;
+        state.v[0] ^= rotate_right(state.v[0], 48) * k1;
+    }
+
+    if ((end - ptr) >= 1)
+    {
+        state.v[0] += read_u8 (ptr) * k3;
+        state.v[0] ^= rotate_right(state.v[0], 37) * k1;
+    }
+    
+    state.v[0] ^= rotate_right(state.v[0], 28);
+    state.v[0] *= k0;
+    state.v[0] ^= rotate_right(state.v[0], 29);
+
+    bytes = 0;
+
+    // do any endian conversion here
+
+    memcpy(hash, state.v, 8);
+}
+
+
+void MetroHash64::Hash(const uint8_t * buffer, const uint64_t length, uint8_t * const hash, const uint64_t seed)
+{
+    const uint8_t * ptr = reinterpret_cast<const uint8_t*>(buffer);
+    const uint8_t * const end = ptr + length;
+
+    uint64_t h = (static_cast<uint64_t>(seed) + k2) * k0;
+
+    if (length >= 32)
+    {
+        uint64_t v[4];
+        v[0] = h;
+        v[1] = h;
+        v[2] = h;
+        v[3] = h;
+
+        do
+        {
+            v[0] += read_u64(ptr) * k0; ptr += 8; v[0] = rotate_right(v[0],29) + v[2];
+            v[1] += read_u64(ptr) * k1; ptr += 8; v[1] = rotate_right(v[1],29) + v[3];
+            v[2] += read_u64(ptr) * k2; ptr += 8; v[2] = rotate_right(v[2],29) + v[0];
+            v[3] += read_u64(ptr) * k3; ptr += 8; v[3] = rotate_right(v[3],29) + v[1];
+        }
+        while (ptr <= (end - 32));
+
+        v[2] ^= rotate_right(((v[0] + v[3]) * k0) + v[1], 37) * k1;
+        v[3] ^= rotate_right(((v[1] + v[2]) * k1) + v[0], 37) * k0;
+        v[0] ^= rotate_right(((v[0] + v[2]) * k0) + v[3], 37) * k1;
+        v[1] ^= rotate_right(((v[1] + v[3]) * k1) + v[2], 37) * k0;
+        h += v[0] ^ v[1];
+    }
+
+    if ((end - ptr) >= 16)
+    {
+        uint64_t v0 = h + (read_u64(ptr) * k2); ptr += 8; v0 = rotate_right(v0,29) * k3;
+        uint64_t v1 = h + (read_u64(ptr) * k2); ptr += 8; v1 = rotate_right(v1,29) * k3;
+        v0 ^= rotate_right(v0 * k0, 21) + v1;
+        v1 ^= rotate_right(v1 * k3, 21) + v0;
+        h += v1;
+    }
+
+    if ((end - ptr) >= 8)
+    {
+        h += read_u64(ptr) * k3; ptr += 8;
+        h ^= rotate_right(h, 55) * k1;
+    }
+
+    if ((end - ptr) >= 4)
+    {
+        h += read_u32(ptr) * k3; ptr += 4;
+        h ^= rotate_right(h, 26) * k1;
+    }
+
+    if ((end - ptr) >= 2)
+    {
+        h += read_u16(ptr) * k3; ptr += 2;
+        h ^= rotate_right(h, 48) * k1;
+    }
+
+    if ((end - ptr) >= 1)
+    {
+        h += read_u8 (ptr) * k3;
+        h ^= rotate_right(h, 37) * k1;
+    }
+
+    h ^= rotate_right(h, 28);
+    h *= k0;
+    h ^= rotate_right(h, 29);
+
+    memcpy(hash, &h, 8);
+}
+
+
+bool MetroHash64::ImplementationVerified()
+{
+    uint8_t hash[8];
+    const uint8_t * key = reinterpret_cast<const uint8_t *>(MetroHash64::test_string);
+
+    // verify one-shot implementation
+    MetroHash64::Hash(key, strlen(MetroHash64::test_string), hash, 0);
+    if (memcmp(hash, MetroHash64::test_seed_0, 8) != 0) return false;
+
+    MetroHash64::Hash(key, strlen(MetroHash64::test_string), hash, 1);
+    if (memcmp(hash, MetroHash64::test_seed_1, 8) != 0) return false;
+
+    // verify incremental implementation
+    MetroHash64 metro;
+    
+    metro.Initialize(0);
+    metro.Update(reinterpret_cast<const uint8_t *>(MetroHash64::test_string), strlen(MetroHash64::test_string));
+    metro.Finalize(hash);
+    if (memcmp(hash, MetroHash64::test_seed_0, 8) != 0) return false;
+
+    metro.Initialize(1);
+    metro.Update(reinterpret_cast<const uint8_t *>(MetroHash64::test_string), strlen(MetroHash64::test_string));
+    metro.Finalize(hash);
+    if (memcmp(hash, MetroHash64::test_seed_1, 8) != 0) return false;
+
+    return true;
+}
 
-#include "metrohash.h"
 
 void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out)
 {

contrib/libmetrohash/src/metrohash64.h

@@ -0,0 +1,73 @@
+// metrohash64.h
+//
+// Copyright 2015-2018 J. Andrew Rogers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef METROHASH_METROHASH_64_H
+#define METROHASH_METROHASH_64_H
+
+#include <stdint.h>
+
+class MetroHash64
+{
+public:
+    static const uint32_t bits = 64;
+
+    // Constructor initializes the same as Initialize()
+    MetroHash64(const uint64_t seed=0);
+    
+    // Initializes internal state for new hash with optional seed
+    void Initialize(const uint64_t seed=0);
+    
+    // Update the hash state with a string of bytes. If the length
+    // is sufficiently long, the implementation switches to a bulk
+    // hashing algorithm directly on the argument buffer for speed.
+    void Update(const uint8_t * buffer, const uint64_t length);
+    
+    // Constructs the final hash and writes it to the argument buffer.
+    // After a hash is finalized, this instance must be Initialized()-ed
+    // again or the behavior of Update() and Finalize() is undefined.
+    void Finalize(uint8_t * const hash);
+    
+    // A non-incremental function implementation. This can be significantly
+    // faster than the incremental implementation for some usage patterns.
+    static void Hash(const uint8_t * buffer, const uint64_t length, uint8_t * const hash, const uint64_t seed=0);
+
+    // Does implementation correctly execute test vectors?
+    static bool ImplementationVerified();
+
+    // test vectors -- Hash(test_string, seed=0) => test_seed_0
+    static const char * test_string;
+    static const uint8_t test_seed_0[8];
+    static const uint8_t test_seed_1[8];
+
+private:
+    static const uint64_t k0 = 0xD6D018F5;
+    static const uint64_t k1 = 0xA2AA033B;
+    static const uint64_t k2 = 0x62992FC1;
+    static const uint64_t k3 = 0x30BC5B29;
+    
+    struct { uint64_t v[4]; } state;
+    struct { uint8_t b[32]; } input;
+    uint64_t bytes;
+    uint64_t vseed;
+};
+
+
+// Legacy 64-bit hash functions -- do not use
+void metrohash64_1(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
+void metrohash64_2(const uint8_t * key, uint64_t len, uint32_t seed, uint8_t * out);
+
+
+#endif // #ifndef METROHASH_METROHASH_64_H

contrib/libmetrohash/src/platform.h

@@ -0,0 +1,50 @@
+// platform.h
+//
+// Copyright 2015-2018 J. Andrew Rogers
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef METROHASH_PLATFORM_H
+#define METROHASH_PLATFORM_H
+
+#include <stdint.h>
+
+// rotate right idiom recognized by most compilers
+inline static uint64_t rotate_right(uint64_t v, unsigned k)
+{
+    return (v >> k) | (v << (64 - k));
+}
+
+// unaligned reads, fast and safe on Nehalem and later microarchitectures
+inline static uint64_t read_u64(const void * const ptr)
+{
+    return static_cast<uint64_t>(*reinterpret_cast<const uint64_t*>(ptr));
+}
+
+inline static uint64_t read_u32(const void * const ptr)
+{
+    return static_cast<uint64_t>(*reinterpret_cast<const uint32_t*>(ptr));
+}
+
+inline static uint64_t read_u16(const void * const ptr)
+{
+    return static_cast<uint64_t>(*reinterpret_cast<const uint16_t*>(ptr));
+}
+
+inline static uint64_t read_u8 (const void * const ptr)
+{
+    return static_cast<uint64_t>(*reinterpret_cast<const uint8_t *>(ptr));
+}
+
+
+#endif // #ifndef METROHASH_PLATFORM_H

contrib/libmetrohash/src/testvector.h

@@ -1,27 +1,18 @@
 // testvector.h
 //
-// The MIT License (MIT)
+// Copyright 2015-2018 J. Andrew Rogers
 //
-// Copyright (c) 2015 J. Andrew Rogers
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
 //
-// Permission is hereby granted, free of charge, to any person obtaining a copy
+//     http://www.apache.org/licenses/LICENSE-2.0
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
 //
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
 
 #ifndef METROHASH_TESTVECTOR_H
 #define METROHASH_TESTVECTOR_H
@@ -46,6 +37,8 @@ struct TestVectorData
 
 static const char * test_key_63 = "012345678901234567890123456789012345678901234567890123456789012";
 
+// The hash assumes a little-endian architecture. Treating the hash results
+// as an array of uint64_t should enable conversion for big-endian implementations.
 const TestVectorData TestVector [] = 
 {
 	// seed = 0

contrib/pdqsort/README

@@ -0,0 +1,2 @@
+Source from https://github.com/orlp/pdqsort
+Mandatory for Clickhouse, not available in OS packages, we can't use it as submodule.

contrib/pdqsort/license.txt

@@ -0,0 +1,16 @@
+Copyright (c) 2015 Orson Peters <orsonpeters@gmail.com>
+
+This software is provided 'as-is', without any express or implied warranty. In no event will the
+authors be held liable for any damages arising from the use of this software.
+
+Permission is granted to anyone to use this software for any purpose, including commercial
+applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+1. The origin of this software must not be misrepresented; you must not claim that you wrote the
+   original software. If you use this software in a product, an acknowledgment in the product
+   documentation would be appreciated but is not required.
+
+2. Altered source versions must be plainly marked as such, and must not be misrepresented as
+   being the original software.
+
+3. This notice may not be removed or altered from any source distribution.

contrib/pdqsort/pdqsort.h

@@ -0,0 +1,544 @@
+/*
+    pdqsort.h - Pattern-defeating quicksort.
+
+    Copyright (c) 2015 Orson Peters
+
+    This software is provided 'as-is', without any express or implied warranty. In no event will the
+    authors be held liable for any damages arising from the use of this software.
+
+    Permission is granted to anyone to use this software for any purpose, including commercial
+    applications, and to alter it and redistribute it freely, subject to the following restrictions:
+
+    1. The origin of this software must not be misrepresented; you must not claim that you wrote the
+       original software. If you use this software in a product, an acknowledgment in the product
+       documentation would be appreciated but is not required.
+
+    2. Altered source versions must be plainly marked as such, and must not be misrepresented as
+       being the original software.
+
+    3. This notice may not be removed or altered from any source distribution.
+*/
+
+
+#ifndef PDQSORT_H
+#define PDQSORT_H
+
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <utility>
+#include <iterator>
+
+#if __cplusplus >= 201103L
+    #include <cstdint>
+    #include <type_traits>
+    #define PDQSORT_PREFER_MOVE(x) std::move(x)
+#else
+    #define PDQSORT_PREFER_MOVE(x) (x)
+#endif
+
+
+namespace pdqsort_detail {
+    enum {
+        // Partitions below this size are sorted using insertion sort.
+        insertion_sort_threshold = 24,
+
+        // Partitions above this size use Tukey's ninther to select the pivot.
+        ninther_threshold = 128,
+
+        // When we detect an already sorted partition, attempt an insertion sort that allows this
+        // amount of element moves before giving up.
+        partial_insertion_sort_limit = 8,
+
+        // Must be multiple of 8 due to loop unrolling, and < 256 to fit in unsigned char.
+        block_size = 64,
+
+        // Cacheline size, assumes power of two.
+        cacheline_size = 64
+
+    };
+
+#if __cplusplus >= 201103L
+    template<class T> struct is_default_compare : std::false_type { };
+    template<class T> struct is_default_compare<std::less<T>> : std::true_type { };
+    template<class T> struct is_default_compare<std::greater<T>> : std::true_type { };
+#endif
+
+    // Returns floor(log2(n)), assumes n > 0.
+    template<class T>
+    inline int log2(T n) {
+        int log = 0;
+        while (n >>= 1) ++log;
+        return log;
+    }
+
+    // Sorts [begin, end) using insertion sort with the given comparison function.
+    template<class Iter, class Compare>
+    inline void insertion_sort(Iter begin, Iter end, Compare comp) {
+        typedef typename std::iterator_traits<Iter>::value_type T;
+        if (begin == end) return;
+
+        for (Iter cur = begin + 1; cur != end; ++cur) {
+            Iter sift = cur;
+            Iter sift_1 = cur - 1;
+
+            // Compare first so we can avoid 2 moves for an element already positioned correctly.
+            if (comp(*sift, *sift_1)) {
+                T tmp = PDQSORT_PREFER_MOVE(*sift);
+
+                do { *sift-- = PDQSORT_PREFER_MOVE(*sift_1); }
+                while (sift != begin && comp(tmp, *--sift_1));
+
+                *sift = PDQSORT_PREFER_MOVE(tmp);
+            }
+        }
+    }
+
+    // Sorts [begin, end) using insertion sort with the given comparison function. Assumes
+    // *(begin - 1) is an element smaller than or equal to any element in [begin, end).
+    template<class Iter, class Compare>
+    inline void unguarded_insertion_sort(Iter begin, Iter end, Compare comp) {
+        typedef typename std::iterator_traits<Iter>::value_type T;
+        if (begin == end) return;
+
+        for (Iter cur = begin + 1; cur != end; ++cur) {
+            Iter sift = cur;
+            Iter sift_1 = cur - 1;
+
+            // Compare first so we can avoid 2 moves for an element already positioned correctly.
+            if (comp(*sift, *sift_1)) {
+                T tmp = PDQSORT_PREFER_MOVE(*sift);
+
+                do { *sift-- = PDQSORT_PREFER_MOVE(*sift_1); }
+                while (comp(tmp, *--sift_1));
+
+                *sift = PDQSORT_PREFER_MOVE(tmp);
+            }
+        }
+    }
+
+    // Attempts to use insertion sort on [begin, end). Will return false if more than
+    // partial_insertion_sort_limit elements were moved, and abort sorting. Otherwise it will
+    // successfully sort and return true.
+    template<class Iter, class Compare>
+    inline bool partial_insertion_sort(Iter begin, Iter end, Compare comp) {
+        typedef typename std::iterator_traits<Iter>::value_type T;
+        if (begin == end) return true;
+        
+        int limit = 0;
+        for (Iter cur = begin + 1; cur != end; ++cur) {
+            if (limit > partial_insertion_sort_limit) return false;
+
+            Iter sift = cur;
+            Iter sift_1 = cur - 1;
+
+            // Compare first so we can avoid 2 moves for an element already positioned correctly.
+            if (comp(*sift, *sift_1)) {
+                T tmp = PDQSORT_PREFER_MOVE(*sift);
+
+                do { *sift-- = PDQSORT_PREFER_MOVE(*sift_1); }
+                while (sift != begin && comp(tmp, *--sift_1));
+
+                *sift = PDQSORT_PREFER_MOVE(tmp);
+                limit += cur - sift;
+            }
+        }
+
+        return true;
+    }
+
+    template<class Iter, class Compare>
+    inline void sort2(Iter a, Iter b, Compare comp) {
+        if (comp(*b, *a)) std::iter_swap(a, b);
+    }
+
+    // Sorts the elements *a, *b and *c using comparison function comp.
+    template<class Iter, class Compare>
+    inline void sort3(Iter a, Iter b, Iter c, Compare comp) {
+        sort2(a, b, comp);
+        sort2(b, c, comp);
+        sort2(a, b, comp);
+    }
+
+    template<class T>
+    inline T* align_cacheline(T* p) {
+#if defined(UINTPTR_MAX) && __cplusplus >= 201103L
+        std::uintptr_t ip = reinterpret_cast<std::uintptr_t>(p);
+#else
+        std::size_t ip = reinterpret_cast<std::size_t>(p);
+#endif
+        ip = (ip + cacheline_size - 1) & -cacheline_size;
+        return reinterpret_cast<T*>(ip);
+    }
+
+    template<class Iter>
+    inline void swap_offsets(Iter first, Iter last,
+                             unsigned char* offsets_l, unsigned char* offsets_r,
+                             int num, bool use_swaps) {
+        typedef typename std::iterator_traits<Iter>::value_type T;
+        if (use_swaps) {
+            // This case is needed for the descending distribution, where we need
+            // to have proper swapping for pdqsort to remain O(n).
+            for (int i = 0; i < num; ++i) {
+                std::iter_swap(first + offsets_l[i], last - offsets_r[i]);
+            }
+        } else if (num > 0) {
+            Iter l = first + offsets_l[0]; Iter r = last - offsets_r[0];
+            T tmp(PDQSORT_PREFER_MOVE(*l)); *l = PDQSORT_PREFER_MOVE(*r);
+            for (int i = 1; i < num; ++i) {
+                l = first + offsets_l[i]; *r = PDQSORT_PREFER_MOVE(*l);
+                r = last - offsets_r[i]; *l = PDQSORT_PREFER_MOVE(*r);
+            }
+            *r = PDQSORT_PREFER_MOVE(tmp);
+        }
+    }
+
+    // Partitions [begin, end) around pivot *begin using comparison function comp. Elements equal
+    // to the pivot are put in the right-hand partition. Returns the position of the pivot after
+    // partitioning and whether the passed sequence already was correctly partitioned. Assumes the
+    // pivot is a median of at least 3 elements and that [begin, end) is at least
+    // insertion_sort_threshold long. Uses branchless partitioning.
+    template<class Iter, class Compare>
+    inline std::pair<Iter, bool> partition_right_branchless(Iter begin, Iter end, Compare comp) {
+        typedef typename std::iterator_traits<Iter>::value_type T;
+
+        // Move pivot into local for speed.
+        T pivot(PDQSORT_PREFER_MOVE(*begin));
+        Iter first = begin;
+        Iter last = end;
+
+        // Find the first element greater than or equal than the pivot (the median of 3 guarantees
+        // this exists).
+        while (comp(*++first, pivot));
+
+        // Find the first element strictly smaller than the pivot. We have to guard this search if
+        // there was no element before *first.
+        if (first - 1 == begin) while (first < last && !comp(*--last, pivot));
+        else                    while (                !comp(*--last, pivot));
+
+        // If the first pair of elements that should be swapped to partition are the same element,
+        // the passed in sequence already was correctly partitioned.
+        bool already_partitioned = first >= last;
+        if (!already_partitioned) {
+            std::iter_swap(first, last);
+            ++first;
+        }
+
+        // The following branchless partitioning is derived from "BlockQuicksort: How Branch
+        // Mispredictions don’t affect Quicksort" by Stefan Edelkamp and Armin Weiss.
+        unsigned char offsets_l_storage[block_size + cacheline_size];
+        unsigned char offsets_r_storage[block_size + cacheline_size];
+        unsigned char* offsets_l = align_cacheline(offsets_l_storage);
+        unsigned char* offsets_r = align_cacheline(offsets_r_storage);
+        int num_l, num_r, start_l, start_r;
+        num_l = num_r = start_l = start_r = 0;
+        
+        while (last - first > 2 * block_size) {
+            // Fill up offset blocks with elements that are on the wrong side.
+            if (num_l == 0) {
+                start_l = 0;
+                Iter it = first;
+                for (unsigned char i = 0; i < block_size;) {
+                    offsets_l[num_l] = i++; num_l += !comp(*it, pivot); ++it;
+                    offsets_l[num_l] = i++; num_l += !comp(*it, pivot); ++it;
+                    offsets_l[num_l] = i++; num_l += !comp(*it, pivot); ++it;
+                    offsets_l[num_l] = i++; num_l += !comp(*it, pivot); ++it;
+                    offsets_l[num_l] = i++; num_l += !comp(*it, pivot); ++it;
+                    offsets_l[num_l] = i++; num_l += !comp(*it, pivot); ++it;
+                    offsets_l[num_l] = i++; num_l += !comp(*it, pivot); ++it;
+                    offsets_l[num_l] = i++; num_l += !comp(*it, pivot); ++it;
+                }
+            }
+            if (num_r == 0) {
+                start_r = 0;
+                Iter it = last;
+                for (unsigned char i = 0; i < block_size;) {
+                    offsets_r[num_r] = ++i; num_r += comp(*--it, pivot);
+                    offsets_r[num_r] = ++i; num_r += comp(*--it, pivot);
+                    offsets_r[num_r] = ++i; num_r += comp(*--it, pivot);
+                    offsets_r[num_r] = ++i; num_r += comp(*--it, pivot);
+                    offsets_r[num_r] = ++i; num_r += comp(*--it, pivot);
+                    offsets_r[num_r] = ++i; num_r += comp(*--it, pivot);
+                    offsets_r[num_r] = ++i; num_r += comp(*--it, pivot);
+                    offsets_r[num_r] = ++i; num_r += comp(*--it, pivot);
+                }
+            }
+
+            // Swap elements and update block sizes and first/last boundaries.
+            int num = std::min(num_l, num_r);
+            swap_offsets(first, last, offsets_l + start_l, offsets_r + start_r,
+                         num, num_l == num_r);
+            num_l -= num; num_r -= num;
+            start_l += num; start_r += num;
+            if (num_l == 0) first += block_size;
+            if (num_r == 0) last -= block_size;
+        }
+
+        int l_size = 0, r_size = 0;
+        int unknown_left = (last - first) - ((num_r || num_l) ? block_size : 0);
+        if (num_r) {
+            // Handle leftover block by assigning the unknown elements to the other block.
+            l_size = unknown_left;
+            r_size = block_size;
+        } else if (num_l) {
+            l_size = block_size;
+            r_size = unknown_left;
+        } else {
+            // No leftover block, split the unknown elements in two blocks.
+            l_size = unknown_left/2;
+            r_size = unknown_left - l_size;
+        }
+
+        // Fill offset buffers if needed.
+        if (unknown_left && !num_l) {
+            start_l = 0;
+            Iter it = first;
+            for (unsigned char i = 0; i < l_size;) {
+                offsets_l[num_l] = i++; num_l += !comp(*it, pivot); ++it;
+            }
+        }
+        if (unknown_left && !num_r) {
+            start_r = 0;
+            Iter it = last;
+            for (unsigned char i = 0; i < r_size;) {
+                offsets_r[num_r] = ++i; num_r += comp(*--it, pivot);
+            }
+        }
+
+        int num = std::min(num_l, num_r);
+        swap_offsets(first, last, offsets_l + start_l, offsets_r + start_r, num, num_l == num_r);
+        num_l -= num; num_r -= num;
+        start_l += num; start_r += num;
+        if (num_l == 0) first += l_size;
+        if (num_r == 0) last -= r_size;
+        
+        // We have now fully identified [first, last)'s proper position. Swap the last elements.
+        if (num_l) {
+            offsets_l += start_l;
+            while (num_l--) std::iter_swap(first + offsets_l[num_l], --last);
+            first = last;
+        }
+        if (num_r) {
+            offsets_r += start_r;
+            while (num_r--) std::iter_swap(last - offsets_r[num_r], first), ++first;
+            last = first;
+        }
+
+        // Put the pivot in the right place.
+        Iter pivot_pos = first - 1;
+        *begin = PDQSORT_PREFER_MOVE(*pivot_pos);
+        *pivot_pos = PDQSORT_PREFER_MOVE(pivot);
+
+        return std::make_pair(pivot_pos, already_partitioned);
+    }
+
+    // Partitions [begin, end) around pivot *begin using comparison function comp. Elements equal
+    // to the pivot are put in the right-hand partition. Returns the position of the pivot after
+    // partitioning and whether the passed sequence already was correctly partitioned. Assumes the
+    // pivot is a median of at least 3 elements and that [begin, end) is at least
+    // insertion_sort_threshold long.
+    template<class Iter, class Compare>
+    inline std::pair<Iter, bool> partition_right(Iter begin, Iter end, Compare comp) {
+        typedef typename std::iterator_traits<Iter>::value_type T;
+        
+        // Move pivot into local for speed.
+        T pivot(PDQSORT_PREFER_MOVE(*begin));
+
+        Iter first = begin;
+        Iter last = end;
+
+        // Find the first element greater than or equal than the pivot (the median of 3 guarantees
+        // this exists).
+        while (comp(*++first, pivot));
+
+        // Find the first element strictly smaller than the pivot. We have to guard this search if
+        // there was no element before *first.
+        if (first - 1 == begin) while (first < last && !comp(*--last, pivot));
+        else                    while (                !comp(*--last, pivot));
+
+        // If the first pair of elements that should be swapped to partition are the same element,
+        // the passed in sequence already was correctly partitioned.
+        bool already_partitioned = first >= last;
+        
+        // Keep swapping pairs of elements that are on the wrong side of the pivot. Previously
+        // swapped pairs guard the searches, which is why the first iteration is special-cased
+        // above.
+        while (first < last) {
+            std::iter_swap(first, last);
+            while (comp(*++first, pivot));
+            while (!comp(*--last, pivot));
+        }
+
+        // Put the pivot in the right place.
+        Iter pivot_pos = first - 1;
+        *begin = PDQSORT_PREFER_MOVE(*pivot_pos);
+        *pivot_pos = PDQSORT_PREFER_MOVE(pivot);
+
+        return std::make_pair(pivot_pos, already_partitioned);
+    }
+
+    // Similar function to the one above, except elements equal to the pivot are put to the left of
+    // the pivot and it doesn't check or return if the passed sequence already was partitioned.
+    // Since this is rarely used (the many equal case), and in that case pdqsort already has O(n)
+    // performance, no block quicksort is applied here for simplicity.
+    template<class Iter, class Compare>
+    inline Iter partition_left(Iter begin, Iter end, Compare comp) {
+        typedef typename std::iterator_traits<Iter>::value_type T;
+
+        T pivot(PDQSORT_PREFER_MOVE(*begin));
+        Iter first = begin;
+        Iter last = end;
+        
+        while (comp(pivot, *--last));
+
+        if (last + 1 == end) while (first < last && !comp(pivot, *++first));
+        else                 while (                !comp(pivot, *++first));
+
+        while (first < last) {
+            std::iter_swap(first, last);
+            while (comp(pivot, *--last));
+            while (!comp(pivot, *++first));
+        }
+
+        Iter pivot_pos = last;
+        *begin = PDQSORT_PREFER_MOVE(*pivot_pos);
+        *pivot_pos = PDQSORT_PREFER_MOVE(pivot);
+
+        return pivot_pos;
+    }
+
+
+    template<class Iter, class Compare, bool Branchless>
+    inline void pdqsort_loop(Iter begin, Iter end, Compare comp, int bad_allowed, bool leftmost = true) {
+        typedef typename std::iterator_traits<Iter>::difference_type diff_t;
+
+        // Use a while loop for tail recursion elimination.
+        while (true) {
+            diff_t size = end - begin;
+
+            // Insertion sort is faster for small arrays.
+            if (size < insertion_sort_threshold) {
+                if (leftmost) insertion_sort(begin, end, comp);
+                else unguarded_insertion_sort(begin, end, comp);
+                return;
+            }
+
+            // Choose pivot as median of 3 or pseudomedian of 9.
+            diff_t s2 = size / 2;
+            if (size > ninther_threshold) {
+                sort3(begin, begin + s2, end - 1, comp);
+                sort3(begin + 1, begin + (s2 - 1), end - 2, comp);
+                sort3(begin + 2, begin + (s2 + 1), end - 3, comp);
+                sort3(begin + (s2 - 1), begin + s2, begin + (s2 + 1), comp);
+                std::iter_swap(begin, begin + s2);
+            } else sort3(begin + s2, begin, end - 1, comp);
+
+            // If *(begin - 1) is the end of the right partition of a previous partition operation
+            // there is no element in [begin, end) that is smaller than *(begin - 1). Then if our
+            // pivot compares equal to *(begin - 1) we change strategy, putting equal elements in
+            // the left partition, greater elements in the right partition. We do not have to
+            // recurse on the left partition, since it's sorted (all equal).
+            if (!leftmost && !comp(*(begin - 1), *begin)) {
+                begin = partition_left(begin, end, comp) + 1;
+                continue;
+            }
+
+            // Partition and get results.
+            std::pair<Iter, bool> part_result =
+                Branchless ? partition_right_branchless(begin, end, comp)
+                           : partition_right(begin, end, comp);
+            Iter pivot_pos = part_result.first;
+            bool already_partitioned = part_result.second;
+
+            // Check for a highly unbalanced partition.
+            diff_t l_size = pivot_pos - begin;
+            diff_t r_size = end - (pivot_pos + 1);
+            bool highly_unbalanced = l_size < size / 8 || r_size < size / 8;
+
+            // If we got a highly unbalanced partition we shuffle elements to break many patterns.
+            if (highly_unbalanced) {
+                // If we had too many bad partitions, switch to heapsort to guarantee O(n log n).
+                if (--bad_allowed == 0) {
+                    std::make_heap(begin, end, comp);
+                    std::sort_heap(begin, end, comp);
+                    return;
+                }
+
+                if (l_size >= insertion_sort_threshold) {
+                    std::iter_swap(begin,             begin + l_size / 4);
+                    std::iter_swap(pivot_pos - 1, pivot_pos - l_size / 4);
+
+                    if (l_size > ninther_threshold) {
+                        std::iter_swap(begin + 1,         begin + (l_size / 4 + 1));
+                        std::iter_swap(begin + 2,         begin + (l_size / 4 + 2));
+                        std::iter_swap(pivot_pos - 2, pivot_pos - (l_size / 4 + 1));
+                        std::iter_swap(pivot_pos - 3, pivot_pos - (l_size / 4 + 2));
+                    }
+                }
+                
+                if (r_size >= insertion_sort_threshold) {
+                    std::iter_swap(pivot_pos + 1, pivot_pos + (1 + r_size / 4));
+                    std::iter_swap(end - 1,                   end - r_size / 4);
+                    
+                    if (r_size > ninther_threshold) {
+                        std::iter_swap(pivot_pos + 2, pivot_pos + (2 + r_size / 4));
+                        std::iter_swap(pivot_pos + 3, pivot_pos + (3 + r_size / 4));
+                        std::iter_swap(end - 2,             end - (1 + r_size / 4));
+                        std::iter_swap(end - 3,             end - (2 + r_size / 4));
+                    }
+                }
+            } else {
+                // If we were decently balanced and we tried to sort an already partitioned
+                // sequence try to use insertion sort.
+                if (already_partitioned && partial_insertion_sort(begin, pivot_pos, comp)
+                                        && partial_insertion_sort(pivot_pos + 1, end, comp)) return;
+            }
+                
+            // Sort the left partition first using recursion and do tail recursion elimination for
+            // the right-hand partition.
+            pdqsort_loop<Iter, Compare, Branchless>(begin, pivot_pos, comp, bad_allowed, leftmost);
+            begin = pivot_pos + 1;
+            leftmost = false;
+        }
+    }
+}
+
+
+template<class Iter, class Compare>
+inline void pdqsort(Iter begin, Iter end, Compare comp) {
+    if (begin == end) return;
+
+#if __cplusplus >= 201103L
+    pdqsort_detail::pdqsort_loop<Iter, Compare,
+        pdqsort_detail::is_default_compare<typename std::decay<Compare>::type>::value &&
+        std::is_arithmetic<typename std::iterator_traits<Iter>::value_type>::value>(
+        begin, end, comp, pdqsort_detail::log2(end - begin));
+#else
+    pdqsort_detail::pdqsort_loop<Iter, Compare, false>(
+        begin, end, comp, pdqsort_detail::log2(end - begin));
+#endif
+}
+
+template<class Iter>
+inline void pdqsort(Iter begin, Iter end) {
+    typedef typename std::iterator_traits<Iter>::value_type T;
+    pdqsort(begin, end, std::less<T>());
+}
+
+template<class Iter, class Compare>
+inline void pdqsort_branchless(Iter begin, Iter end, Compare comp) {
+    if (begin == end) return;
+    pdqsort_detail::pdqsort_loop<Iter, Compare, true>(
+        begin, end, comp, pdqsort_detail::log2(end - begin));
+}
+
+template<class Iter>
+inline void pdqsort_branchless(Iter begin, Iter end) {
+    typedef typename std::iterator_traits<Iter>::value_type T;
+    pdqsort_branchless(begin, end, std::less<T>());
+}
+
+
+#undef PDQSORT_PREFER_MOVE
+
+#endif

contrib/pdqsort/readme.md

@@ -0,0 +1,119 @@
+pdqsort
+-------
+
+Pattern-defeating quicksort (pdqsort) is a novel sorting algorithm that combines the fast average
+case of randomized quicksort with the fast worst case of heapsort, while achieving linear time on
+inputs with certain patterns. pdqsort is an extension and improvement of David Mussers introsort.
+All code is available for free under the zlib license.
+
+    Best        Average     Worst       Memory      Stable      Deterministic
+    n           n log n     n log n     log n       No          Yes
+
+### Usage
+
+`pdqsort` is a drop-in replacement for [`std::sort`](http://en.cppreference.com/w/cpp/algorithm/sort).
+Just replace a call to `std::sort` with `pdqsort` to start using pattern-defeating quicksort. If your
+comparison function is branchless, you can call `pdqsort_branchless` for a potential big speedup. If
+you are using C++11, the type you're sorting is arithmetic and your comparison function is not given
+or is `std::less`/`std::greater`, `pdqsort` automatically delegates to `pdqsort_branchless`.
+
+### Benchmark
+
+A comparison of pdqsort and GCC's `std::sort` and `std::stable_sort` with various input
+distributions:
+
+![Performance graph](http://i.imgur.com/1RnIGBO.png)
+
+Compiled with `-std=c++11 -O2 -m64 -march=native`.
+
+
+### Visualization
+
+A visualization of pattern-defeating quicksort sorting a ~200 element array with some duplicates.
+Generated using Timo Bingmann's [The Sound of Sorting](http://panthema.net/2013/sound-of-sorting/)
+program, a tool that has been invaluable during the development of pdqsort. For the purposes of
+this visualization the cutoff point for insertion sort was lowered to 8 elements.
+
+![Visualization](http://i.imgur.com/QzFG09F.gif)
+
+
+### The best case
+
+pdqsort is designed to run in linear time for a couple of best-case patterns. Linear time is
+achieved for inputs that are in strictly ascending or descending order, only contain equal elements,
+or are strictly in ascending order followed by one out-of-place element. There are two separate
+mechanisms at play to achieve this.
+
+For equal elements a smart partitioning scheme is used that always puts equal elements in the
+partition containing elements greater than the pivot. When a new pivot is chosen it's compared to
+the greatest element in the partition before it. If they compare equal we can derive that there are
+no elements smaller than the chosen pivot. When this happens we switch strategy for this partition,
+and filter out all elements equal to the pivot.
+
+To get linear time for the other patterns we check after every partition if any swaps were made. If
+no swaps were made and the partition was decently balanced we will optimistically attempt to use
+insertion sort. This insertion sort aborts if more than a constant amount of moves are required to
+sort.
+
+
+### The average case
+
+On average case data where no patterns are detected pdqsort is effectively a quicksort that uses
+median-of-3 pivot selection, switching to insertion sort if the number of elements to be
+(recursively) sorted is small. The overhead associated with detecting the patterns for the best case
+is so small it lies within the error of measurement.
+
+pdqsort gets a great speedup over the traditional way of implementing quicksort when sorting large
+arrays (1000+ elements). This is due to a new technique described in "BlockQuicksort: How Branch
+Mispredictions don't affect Quicksort" by Stefan Edelkamp and Armin Weiss. In short, we bypass the
+branch predictor by using small buffers (entirely in L1 cache) of the indices of elements that need
+to be swapped. We fill these buffers in a branch-free way that's quite elegant (in pseudocode):
+
+```cpp
+buffer_num = 0; buffer_max_size = 64;
+for (int i = 0; i < buffer_max_size; ++i) {
+    // With branch:
+    if (elements[i] < pivot) { buffer[buffer_num] = i; buffer_num++; }
+    // Without:
+    buffer[buffer_num] = i; buffer_num += (elements[i] < pivot);
+}
+```
+
+This is only a speedup if the comparison function itself is branchless, however. By default pdqsort
+will detect this if you're using C++11 or higher, the type you're sorting is arithmetic (e.g.
+`int`), and you're using either `std::less` or `std::greater`. You can explicitly request branchless
+partitioning by calling `pdqsort_branchless` instead of `pdqsort`.
+
+
+### The worst case
+
+Quicksort naturally performs bad on inputs that form patterns, due to it being a partition-based
+sort. Choosing a bad pivot will result in many comparisons that give little to no progress in the
+sorting process. If the pattern does not get broken up, this can happen many times in a row. Worse,
+real world data is filled with these patterns.
+
+Traditionally the solution to this is to randomize the pivot selection of quicksort. While this
+technically still allows for a quadratic worst case, the chances of it happening are astronomically
+small. Later, in introsort, pivot selection is kept deterministic, instead switching to the
+guaranteed O(n log n) heapsort if the recursion depth becomes too big. In pdqsort we adopt a hybrid
+approach, (deterministically) shuffling some elements to break up patterns when we encounter a "bad"
+partition. If we encounter too many "bad" partitions we switch to heapsort.
+
+
+### Bad partitions
+
+A bad partition occurs when the position of the pivot after partitioning is under 12.5% (1/8th)
+percentile or over 87,5% percentile - the partition is highly unbalanced. When this happens we will
+shuffle four elements at fixed locations for both partitions. This effectively breaks up many
+patterns. If we encounter more than log(n) bad partitions we will switch to heapsort.
+
+The 1/8th percentile is not chosen arbitrarily. An upper bound of quicksorts worst case runtime can
+be approximated within a constant factor by the following recurrence:
+
+    T(n, p) = n + T(p(n-1), p) + T((1-p)(n-1), p)
+
+Where n is the number of elements, and p is the percentile of the pivot after partitioning.
+`T(n, 1/2)` is the best case for quicksort. On modern systems heapsort is profiled to be
+approximately 1.8 to 2 times as slow as quicksort. Choosing p such that `T(n, 1/2) / T(n, p) ~= 1.9`
+as n gets big will ensure that we will only switch to heapsort if it would speed up the sorting.
+p = 1/8 is a reasonably close value and is cheap to compute on every platform using a bitshift.

dbms/CMakeLists.txt

@@ -102,7 +102,9 @@ add_headers_and_sources(dbms src/Interpreters/ClusterProxy)
 add_headers_and_sources(dbms src/Columns)
 add_headers_and_sources(dbms src/Storages)
 add_headers_and_sources(dbms src/Storages/Distributed)
-add_headers_and_sources(dbms src/Storages/Kafka)
+if(USE_RDKAFKA)
+    add_headers_and_sources(dbms src/Storages/Kafka)
+endif()
 add_headers_and_sources(dbms src/Storages/MergeTree)
 add_headers_and_sources(dbms src/Client)
 add_headers_and_sources(dbms src/Formats)
@@ -200,11 +202,22 @@ target_link_libraries (clickhouse_common_io
     ${Boost_SYSTEM_LIBRARY}
         PRIVATE
     apple_rt
+        PUBLIC
+    Threads::Threads
+        PRIVATE
     ${CMAKE_DL_LIBS}
 )
 
-if (NOT ARCH_ARM AND CPUID_LIBRARY)
+target_include_directories(clickhouse_common_io SYSTEM BEFORE PUBLIC ${PDQSORT_INCLUDE_DIR})
-    target_link_libraries (clickhouse_common_io PRIVATE ${CPUID_LIBRARY})
+
+target_include_directories(clickhouse_common_io SYSTEM BEFORE PUBLIC ${RE2_INCLUDE_DIR})
+
+if(CPUID_LIBRARY)
+    target_link_libraries(clickhouse_common_io PRIVATE ${CPUID_LIBRARY})
+endif()
+
+if(CPUINFO_LIBRARY)
+    target_link_libraries(clickhouse_common_io PRIVATE ${CPUINFO_LIBRARY})
 endif()
 
 target_link_libraries (dbms
@@ -225,11 +238,9 @@ target_link_libraries (dbms
     ${Boost_PROGRAM_OPTIONS_LIBRARY}
         PUBLIC
     ${Boost_SYSTEM_LIBRARY}
+    Threads::Threads
 )
 
-if (NOT USE_INTERNAL_RE2_LIBRARY)
-    target_include_directories (dbms SYSTEM BEFORE PRIVATE ${RE2_INCLUDE_DIR})
-endif ()
 
 if (NOT USE_INTERNAL_BOOST_LIBRARY)
     target_include_directories (clickhouse_common_io SYSTEM BEFORE PUBLIC ${Boost_INCLUDE_DIRS})
@@ -249,7 +260,6 @@ if (USE_POCO_SQLODBC)
     endif()
 endif()
 
-#if (Poco_Data_FOUND AND NOT USE_INTERNAL_POCO_LIBRARY)
 if (Poco_Data_FOUND)
     target_include_directories (clickhouse_common_io SYSTEM PRIVATE ${Poco_Data_INCLUDE_DIR})
     target_include_directories (dbms SYSTEM PRIVATE ${Poco_Data_INCLUDE_DIR})
@@ -276,6 +286,7 @@ target_link_libraries (dbms PRIVATE ${Poco_Foundation_LIBRARY})
 
 if (USE_ICU)
     target_link_libraries (dbms PRIVATE ${ICU_LIBRARIES})
+    target_include_directories (dbms SYSTEM PRIVATE ${ICU_INCLUDE_DIRS})
 endif ()
 
 if (USE_CAPNP)

dbms/cmake/version.cmake

@@ -1,11 +1,11 @@
 # This strings autochanged from release_lib.sh:
-set(VERSION_REVISION 54413)
+set(VERSION_REVISION 54415)
 set(VERSION_MAJOR 19)
-set(VERSION_MINOR 1)
+set(VERSION_MINOR 3)
-set(VERSION_PATCH 6)
+set(VERSION_PATCH 0)
-set(VERSION_GITHASH f73b337a93d534671b2187660398b8573fc1d464)
+set(VERSION_GITHASH 1db4bd8c2a1a0cd610c8a6564e8194dca5265562)
-set(VERSION_DESCRIBE v19.1.6-testing)
+set(VERSION_DESCRIBE v19.3.0-testing)
-set(VERSION_STRING 19.1.6)
+set(VERSION_STRING 19.3.0)
 # end of autochange
 
 set(VERSION_EXTRA "" CACHE STRING "")

dbms/programs/CMakeLists.txt

@@ -28,11 +28,18 @@ add_subdirectory (copier)
 add_subdirectory (format)
 add_subdirectory (clang)
 add_subdirectory (obfuscator)
-add_subdirectory (odbc-bridge)
+
+if (ENABLE_CLICKHOUSE_ODBC_BRIDGE)
+    add_subdirectory (odbc-bridge)
+endif ()
 
 if (CLICKHOUSE_SPLIT_BINARY)
     set (CLICKHOUSE_ALL_TARGETS clickhouse-server clickhouse-client clickhouse-local clickhouse-benchmark clickhouse-performance-test
-            clickhouse-extract-from-config clickhouse-compressor clickhouse-format clickhouse-copier clickhouse-odbc-bridge)
+            clickhouse-extract-from-config clickhouse-compressor clickhouse-format clickhouse-copier)
+
+    if (ENABLE_CLICKHOUSE_ODBC_BRIDGE)
+        list (APPEND CLICKHOUSE_ALL_TARGETS clickhouse-odbc-bridge)
+    endif ()
 
     if (USE_EMBEDDED_COMPILER)
         list (APPEND CLICKHOUSE_ALL_TARGETS clickhouse-clang clickhouse-lld)
@@ -85,9 +92,6 @@ else ()
     if (USE_EMBEDDED_COMPILER)
         target_link_libraries (clickhouse PRIVATE clickhouse-compiler-lib)
     endif ()
-    if (ENABLE_CLICKHOUSE_ODBC_BRIDGE)
-        target_link_libraries (clickhouse PRIVATE clickhouse-odbc-bridge-lib)
-    endif()
 
     set (CLICKHOUSE_BUNDLE)
     if (ENABLE_CLICKHOUSE_SERVER)
@@ -135,15 +139,14 @@ else ()
         install (FILES ${CMAKE_CURRENT_BINARY_DIR}/clickhouse-format DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
         list(APPEND CLICKHOUSE_BUNDLE clickhouse-format)
     endif ()
-    if (ENABLE_CLICKHOUSE_COPIER)
+    if (ENABLE_CLICKHOUSE_OBFUSCATOR)
         add_custom_target (clickhouse-obfuscator ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-obfuscator DEPENDS clickhouse)
         install (FILES ${CMAKE_CURRENT_BINARY_DIR}/clickhouse-obfuscator DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
         list(APPEND CLICKHOUSE_BUNDLE clickhouse-obfuscator)
     endif ()
     if (ENABLE_CLICKHOUSE_ODBC_BRIDGE)
-        add_custom_target (clickhouse-odbc-bridge ALL COMMAND ${CMAKE_COMMAND} -E create_symlink clickhouse clickhouse-odbc-bridge DEPENDS clickhouse)
+        # just to be able to run integration tests
-        install (FILES ${CMAKE_CURRENT_BINARY_DIR}/clickhouse-odbc-bridge DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
+        add_custom_target (clickhouse-odbc-bridge-copy ALL COMMAND ${CMAKE_COMMAND} -E create_symlink ${CMAKE_CURRENT_BINARY_DIR}/odbc-bridge/clickhouse-odbc-bridge clickhouse-odbc-bridge DEPENDS clickhouse-odbc-bridge)
-        list(APPEND CLICKHOUSE_BUNDLE clickhouse-odbc-bridge)
     endif ()
 
 

dbms/programs/benchmark/Benchmark.cpp

@@ -11,7 +11,7 @@
 #include <Poco/File.h>
 #include <Poco/Util/Application.h>
 #include <Common/Stopwatch.h>
-#include <common/ThreadPool.h>
+#include <Common/ThreadPool.h>
 #include <AggregateFunctions/ReservoirSampler.h>
 #include <AggregateFunctions/registerAggregateFunctions.h>
 #include <boost/program_options.hpp>

dbms/programs/benchmark/CMakeLists.txt

@@ -5,4 +5,5 @@ target_include_directories (clickhouse-benchmark-lib SYSTEM PRIVATE ${PCG_RANDOM
 if (CLICKHOUSE_SPLIT_BINARY)
     add_executable (clickhouse-benchmark clickhouse-benchmark.cpp)
     target_link_libraries (clickhouse-benchmark PRIVATE clickhouse-benchmark-lib clickhouse_aggregate_functions)
+    install (TARGETS clickhouse-benchmark ${CLICKHOUSE_ALL_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
 endif ()

dbms/programs/client/CMakeLists.txt

@@ -7,6 +7,7 @@ endif ()
 if (CLICKHOUSE_SPLIT_BINARY)
     add_executable (clickhouse-client clickhouse-client.cpp)
     target_link_libraries (clickhouse-client PRIVATE clickhouse-client-lib)
+    install (TARGETS clickhouse-client ${CLICKHOUSE_ALL_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
 endif ()
 
 install (FILES clickhouse-client.xml DESTINATION ${CLICKHOUSE_ETC_DIR}/clickhouse-client COMPONENT clickhouse-client RENAME config.xml)

dbms/programs/client/Client.cpp

@@ -12,6 +12,7 @@
 #include <unordered_set>
 #include <algorithm>
 #include <optional>
+#include <ext/scope_guard.h>
 #include <boost/program_options.hpp>
 #include <boost/algorithm/string/replace.hpp>
 #include <Poco/String.h>
@@ -222,7 +223,7 @@ private:
 
         /// Set path for format schema files
         if (config().has("format_schema_path"))
-            context.setFormatSchemaPath(Poco::Path(config().getString("format_schema_path")).toString() + "/");
+            context.setFormatSchemaPath(Poco::Path(config().getString("format_schema_path")).toString());
     }
 
 
@@ -400,6 +401,7 @@ private:
                 throw Exception("time option could be specified only in non-interactive mode", ErrorCodes::BAD_ARGUMENTS);
 
 #if USE_READLINE
+            SCOPE_EXIT({ Suggest::instance().finalize(); });
             if (server_revision >= Suggest::MIN_SERVER_REVISION
                 && !config().getBool("disable_suggestion", false))
             {
@@ -722,7 +724,11 @@ private:
 
                 try
                 {
-                    if (!processSingleQuery(str, ast) && !ignore_error)
+                    auto ast_to_process = ast;
+                    if (insert && insert->data)
+                        ast_to_process = nullptr;
+
+                    if (!processSingleQuery(str, ast_to_process) && !ignore_error)
                         return false;
                 }
                 catch (...)
@@ -1029,25 +1035,56 @@ private:
         InterruptListener interrupt_listener;
         bool cancelled = false;
 
+        // TODO: get the poll_interval from commandline.
+        const auto receive_timeout = connection->getTimeouts().receive_timeout;
+        constexpr size_t default_poll_interval = 1000000; /// in microseconds
+        constexpr size_t min_poll_interval = 5000; /// in microseconds
+        const size_t poll_interval
+            = std::max(min_poll_interval, std::min<size_t>(receive_timeout.totalMicroseconds(), default_poll_interval));
+
         while (true)
         {
-            /// Has the Ctrl+C been pressed and thus the query should be cancelled?
+            Stopwatch receive_watch(CLOCK_MONOTONIC_COARSE);
-            /// If this is the case, inform the server about it and receive the remaining packets
-            /// to avoid losing sync.
-            if (!cancelled)
-            {
-                if (interrupt_listener.check())
-                {
-                    connection->sendCancel();
-                    cancelled = true;
-                    if (is_interactive)
-                        std::cout << "Cancelling query." << std::endl;
 
-                    /// Pressing Ctrl+C twice results in shut down.
+            while (true)
-                    interrupt_listener.unblock();
+            {
+                /// Has the Ctrl+C been pressed and thus the query should be cancelled?
+                /// If this is the case, inform the server about it and receive the remaining packets
+                /// to avoid losing sync.
+                if (!cancelled)
+                {
+                    auto cancelQuery = [&] {
+                        connection->sendCancel();
+                        cancelled = true;
+                        if (is_interactive)
+                            std::cout << "Cancelling query." << std::endl;
+
+                        /// Pressing Ctrl+C twice results in shut down.
+                        interrupt_listener.unblock();
+                    };
+
+                    if (interrupt_listener.check())
+                    {
+                        cancelQuery();
+                    }
+                    else
+                    {
+                        double elapsed = receive_watch.elapsedSeconds();
+                        if (elapsed > receive_timeout.totalSeconds())
+                        {
+                            std::cout << "Timeout exceeded while receiving data from server."
+                                      << " Waited for " << static_cast<size_t>(elapsed) << " seconds,"
+                                      << " timeout is " << receive_timeout.totalSeconds() << " seconds." << std::endl;
+
+                            cancelQuery();
+                        }
+                    }
                 }
-                else if (!connection->poll(1000000))
+
-                    continue;    /// If there is no new data, continue checking whether the query was cancelled after a timeout.
+                /// Poll for changes after a cancellation check, otherwise it never reached
+                /// because of progress updates from server.
+                if (connection->poll(poll_interval))
+                  break;
             }
 
             if (!receiveAndProcessPacket())
@@ -1303,7 +1340,11 @@ private:
 
     void onProgress(const Progress & value)
     {
-        progress.incrementPiecewiseAtomically(value);
+        if (!progress.incrementPiecewiseAtomically(value))
+        {
+            // Just a keep-alive update.
+            return;
+        }
         if (block_out_stream)
             block_out_stream->onProgress(value);
         writeProgress();
@@ -1542,12 +1583,19 @@ public:
         po::options_description main_description("Main options", line_length, min_description_length);
         main_description.add_options()
             ("help", "produce help message")
-            ("config-file,c", po::value<std::string>(), "config-file path")
+            ("config-file,C", po::value<std::string>(), "config-file path")
+            ("config,c", po::value<std::string>(), "config-file path (another shorthand)")
             ("host,h", po::value<std::string>()->default_value("localhost"), "server host")
             ("port", po::value<int>()->default_value(9000), "server port")
             ("secure,s", "Use TLS connection")
             ("user,u", po::value<std::string>()->default_value("default"), "user")
-            ("password", po::value<std::string>(), "password")
+            /** If "--password [value]" is used but the value is omitted, the bad argument exception will be thrown.
+              * implicit_value is used to avoid this exception (to allow user to type just "--password")
+              * Since currently boost provides no way to check if a value has been set implicitly for an option,
+              * the "\n" is used to distinguish this case because there is hardly a chance an user would use "\n"
+              * as the password.
+              */
+            ("password", po::value<std::string>()->implicit_value("\n"), "password")
             ("ask-password", "ask-password")
             ("query_id", po::value<std::string>(), "query_id")
             ("query,q", po::value<std::string>(), "query")
@@ -1585,13 +1633,11 @@ public:
             ("structure", po::value<std::string>(), "structure")
             ("types", po::value<std::string>(), "types")
         ;
-
         /// Parse main commandline options.
         po::parsed_options parsed = po::command_line_parser(
             common_arguments.size(), common_arguments.data()).options(main_description).run();
         po::variables_map options;
         po::store(parsed, options);
-
         if (options.count("version") || options.count("V"))
         {
             showClientVersion();
@@ -1643,15 +1689,23 @@ public:
         }
 
         /// Extract settings from the options.
-#define EXTRACT_SETTING(TYPE, NAME, DEFAULT, DESCRIPTION) \
+#define EXTRACT_SETTING(TYPE, NAME, DEFAULT, DESCRIPTION)                \
-        if (options.count(#NAME)) \
+        if (options.count(#NAME))                                        \
-            context.setSetting(#NAME, options[#NAME].as<std::string>());
+        {                                                                \
+            context.setSetting(#NAME, options[#NAME].as<std::string>()); \
+            config().setString(#NAME, options[#NAME].as<std::string>()); \
+        }
         APPLY_FOR_SETTINGS(EXTRACT_SETTING)
 #undef EXTRACT_SETTING
 
+        if (options.count("config-file") && options.count("config"))
+            throw Exception("Two or more configuration files referenced in arguments", ErrorCodes::BAD_ARGUMENTS);
+
         /// Save received data into the internal config.
         if (options.count("config-file"))
             config().setString("config-file", options["config-file"].as<std::string>());
+        if (options.count("config"))
+            config().setString("config-file", options["config"].as<std::string>());
         if (options.count("host") && !options["host"].defaulted())
             config().setString("host", options["host"].as<std::string>());
         if (options.count("query_id"))
@@ -1710,11 +1764,11 @@ public:
 
 int mainEntryClickHouseClient(int argc, char ** argv)
 {
-    DB::Client client;
-
     try
     {
+        DB::Client client;
         client.init(argc, argv);
+        return client.run();
     }
     catch (const boost::program_options::error & e)
     {
@@ -1726,6 +1780,4 @@ int mainEntryClickHouseClient(int argc, char ** argv)
         std::cerr << DB::getCurrentExceptionMessage(true) << std::endl;
         return 1;
     }
-
-    return client.run();
 }

dbms/programs/client/ConnectionParameters.h

@@ -8,7 +8,7 @@
 #include <Common/Exception.h>
 #include <IO/ConnectionTimeouts.h>
 
-#include <common/SetTerminalEcho.h>
+#include <common/setTerminalEcho.h>
 #include <ext/scope_guard.h>
 
 #include <Poco/Util/AbstractConfiguration.h>
@@ -48,35 +48,41 @@ struct ConnectionParameters
                 is_secure ? DBMS_DEFAULT_SECURE_PORT : DBMS_DEFAULT_PORT));
 
         default_database = config.getString("database", "");
-        user = config.getString("user", "");
+        /// changed the default value to "default" to fix the issue when the user in the prompt is blank
-
+        user = config.getString("user", "default");
+        bool password_prompt = false;
         if (config.getBool("ask-password", false))
         {
             if (config.has("password"))
                 throw Exception("Specified both --password and --ask-password. Remove one of them", ErrorCodes::BAD_ARGUMENTS);
-
+            password_prompt = true;
-            std::cout << "Password for user " << user << ": ";
-            SetTerminalEcho(false);
-
-            SCOPE_EXIT({
-                SetTerminalEcho(true);
-            });
-            std::getline(std::cin, password);
-            std::cout << std::endl;
         }
         else
         {
             password = config.getString("password", "");
+            /// if the value of --password is omitted, the password will be set implicitly to "\n"
+            if (password == "\n")
+                password_prompt = true;
         }
+        if (password_prompt)
+        {
+            std::cout << "Password for user (" << user << "): ";
+            setTerminalEcho(false);
 
+            SCOPE_EXIT({
+                setTerminalEcho(true);
+            });
+            std::getline(std::cin, password);
+            std::cout << std::endl;
+        }
         compression = config.getBool("compression", true)
             ? Protocol::Compression::Enable
             : Protocol::Compression::Disable;
 
         timeouts = ConnectionTimeouts(
             Poco::Timespan(config.getInt("connect_timeout", DBMS_DEFAULT_CONNECT_TIMEOUT_SEC), 0),
-            Poco::Timespan(config.getInt("receive_timeout", DBMS_DEFAULT_RECEIVE_TIMEOUT_SEC), 0),
             Poco::Timespan(config.getInt("send_timeout", DBMS_DEFAULT_SEND_TIMEOUT_SEC), 0),
+            Poco::Timespan(config.getInt("receive_timeout", DBMS_DEFAULT_RECEIVE_TIMEOUT_SEC), 0),
             Poco::Timespan(config.getInt("tcp_keep_alive_timeout", 0), 0));
     }
 };

dbms/programs/client/Suggest.h

@@ -39,7 +39,7 @@ private:
         "DATABASES", "LIKE", "PROCESSLIST", "CASE", "WHEN", "THEN", "ELSE", "END", "DESCRIBE", "DESC", "USE", "SET", "OPTIMIZE", "FINAL", "DEDUPLICATE",
         "INSERT", "VALUES", "SELECT", "DISTINCT", "SAMPLE", "ARRAY", "JOIN", "GLOBAL", "LOCAL", "ANY", "ALL", "INNER", "LEFT", "RIGHT", "FULL", "OUTER",
         "CROSS", "USING", "PREWHERE", "WHERE", "GROUP", "BY", "WITH", "TOTALS", "HAVING", "ORDER", "COLLATE", "LIMIT", "UNION", "AND", "OR", "ASC", "IN",
-        "KILL", "QUERY", "SYNC", "ASYNC", "TEST"
+        "KILL", "QUERY", "SYNC", "ASYNC", "TEST", "BETWEEN"
     };
 
     /// Words are fetched asynchonously.
@@ -194,6 +194,12 @@ public:
         });
     }
 
+    void finalize()
+    {
+        if (loading_thread.joinable())
+            loading_thread.join();
+    }
+
     /// A function for readline.
     static char * generator(const char * text, int state)
     {
@@ -211,8 +217,7 @@ public:
 
     ~Suggest()
     {
-        if (loading_thread.joinable())
+        finalize();
-            loading_thread.join();
     }
 };
 

dbms/programs/compressor/CMakeLists.txt

@@ -5,4 +5,5 @@ if (CLICKHOUSE_SPLIT_BINARY)
     # Also in utils
     add_executable (clickhouse-compressor clickhouse-compressor.cpp)
     target_link_libraries (clickhouse-compressor PRIVATE clickhouse-compressor-lib)
+    install (TARGETS clickhouse-compressor ${CLICKHOUSE_ALL_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
 endif ()

dbms/programs/copier/CMakeLists.txt

@@ -4,4 +4,5 @@ target_link_libraries (clickhouse-copier-lib PRIVATE clickhouse-server-lib click
 if (CLICKHOUSE_SPLIT_BINARY)
     add_executable (clickhouse-copier clickhouse-copier.cpp)
     target_link_libraries (clickhouse-copier clickhouse-copier-lib)
+    install (TARGETS clickhouse-copier ${CLICKHOUSE_ALL_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
 endif ()

dbms/programs/copier/ClusterCopier.cpp

@@ -18,7 +18,7 @@
 #include <pcg_random.hpp>
 
 #include <common/logger_useful.h>
-#include <common/ThreadPool.h>
+#include <Common/ThreadPool.h>
 #include <daemon/OwnPatternFormatter.h>
 
 #include <Common/Exception.h>
@@ -67,7 +67,6 @@
 #include <Storages/StorageDistributed.h>
 #include <Databases/DatabaseMemory.h>
 #include <Common/StatusFile.h>
-#include <daemon/OwnPatternFormatter.h>
 
 
 namespace DB
@@ -817,7 +816,7 @@ public:
 
             try
             {
-                type->deserializeTextQuoted(*column_dummy, rb, FormatSettings());
+                type->deserializeAsTextQuoted(*column_dummy, rb, FormatSettings());
             }
             catch (Exception & e)
             {
@@ -1179,7 +1178,7 @@ protected:
     /// Removes MATERIALIZED and ALIAS columns from create table query
     static ASTPtr removeAliasColumnsFromCreateQuery(const ASTPtr & query_ast)
     {
-        const ASTs & column_asts = typeid_cast<ASTCreateQuery &>(*query_ast).columns->children;
+        const ASTs & column_asts = typeid_cast<ASTCreateQuery &>(*query_ast).columns_list->columns->children;
         auto new_columns = std::make_shared<ASTExpressionList>();
 
         for (const ASTPtr & column_ast : column_asts)
@@ -1198,8 +1197,13 @@ protected:
 
         ASTPtr new_query_ast = query_ast->clone();
         ASTCreateQuery & new_query = typeid_cast<ASTCreateQuery &>(*new_query_ast);
-        new_query.columns = new_columns.get();
+
-        new_query.children.at(0) = std::move(new_columns);
+        auto new_columns_list = std::make_shared<ASTColumns>();
+        new_columns_list->set(new_columns_list->columns, new_columns);
+        new_columns_list->set(
+                new_columns_list->indices, typeid_cast<ASTCreateQuery &>(*query_ast).columns_list->indices->clone());
+
+        new_query.replace(new_query.columns_list, new_columns_list);
 
         return new_query_ast;
     }
@@ -1217,7 +1221,7 @@ protected:
         res->table = new_table.second;
 
         res->children.clear();
-        res->set(res->columns, create.columns->clone());
+        res->set(res->columns_list, create.columns_list->clone());
         res->set(res->storage, new_storage_ast->clone());
 
         return res;
@@ -1877,7 +1881,7 @@ protected:
             for (size_t i = 0; i < column.column->size(); ++i)
             {
                 WriteBufferFromOwnString wb;
-                column.type->serializeTextQuoted(*column.column, i, wb, FormatSettings());
+                column.type->serializeAsTextQuoted(*column.column, i, wb, FormatSettings());
                 res.emplace(wb.str());
             }
         }

dbms/programs/extract-from-config/CMakeLists.txt

@@ -4,4 +4,5 @@ target_link_libraries (clickhouse-extract-from-config-lib PRIVATE clickhouse_com
 if (CLICKHOUSE_SPLIT_BINARY)
     add_executable (clickhouse-extract-from-config clickhouse-extract-from-config.cpp)
     target_link_libraries (clickhouse-extract-from-config PRIVATE clickhouse-extract-from-config-lib)
+    install (TARGETS clickhouse-extract-from-config ${CLICKHOUSE_ALL_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
 endif ()

dbms/programs/format/CMakeLists.txt

@@ -3,4 +3,5 @@ target_link_libraries (clickhouse-format-lib PRIVATE dbms clickhouse_common_io c
 if (CLICKHOUSE_SPLIT_BINARY)
     add_executable (clickhouse-format clickhouse-format.cpp)
     target_link_libraries (clickhouse-format PRIVATE clickhouse-format-lib)
+    install (TARGETS clickhouse-format ${CLICKHOUSE_ALL_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
 endif ()

dbms/programs/local/CMakeLists.txt

@@ -4,4 +4,5 @@ target_link_libraries (clickhouse-local-lib PRIVATE clickhouse_common_io clickho
 if (CLICKHOUSE_SPLIT_BINARY)
     add_executable (clickhouse-local clickhouse-local.cpp)
     target_link_libraries (clickhouse-local PRIVATE clickhouse-local-lib)
+    install (TARGETS clickhouse-local ${CLICKHOUSE_ALL_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
 endif ()

dbms/programs/local/LocalServer.cpp

@@ -17,6 +17,7 @@
 #include <Common/Config/ConfigProcessor.h>
 #include <Common/escapeForFileName.h>
 #include <Common/ClickHouseRevision.h>
+#include <Common/ThreadStatus.h>
 #include <Common/config_version.h>
 #include <IO/ReadBufferFromString.h>
 #include <IO/WriteBufferFromString.h>
@@ -102,7 +103,7 @@ int LocalServer::main(const std::vector<std::string> & /*args*/)
 try
 {
     Logger * log = &logger();
-
+    ThreadStatus thread_status;
     UseSSL use_ssl;
 
     if (!config().has("query") && !config().has("table-structure")) /// Nothing to process
@@ -296,7 +297,7 @@ void LocalServer::processQueries()
 
         try
         {
-            executeQuery(read_buf, write_buf, /* allow_into_outfile = */ true, *context, {});
+            executeQuery(read_buf, write_buf, /* allow_into_outfile = */ true, *context, {}, {});
         }
         catch (...)
         {

dbms/programs/main.cpp

@@ -56,9 +56,6 @@ int mainEntryClickHouseClusterCopier(int argc, char ** argv);
 #if ENABLE_CLICKHOUSE_OBFUSCATOR || !defined(ENABLE_CLICKHOUSE_OBFUSCATOR)
 int mainEntryClickHouseObfuscator(int argc, char ** argv);
 #endif
-#if ENABLE_CLICKHOUSE_ODBC_BRIDGE || !defined(ENABLE_CLICKHOUSE_ODBC_BRIDGE)
-int mainEntryClickHouseODBCBridge(int argc, char ** argv);
-#endif
 
 
 #if USE_EMBEDDED_COMPILER
@@ -105,9 +102,6 @@ std::pair<const char *, MainFunc> clickhouse_applications[] =
 #if ENABLE_CLICKHOUSE_OBFUSCATOR || !defined(ENABLE_CLICKHOUSE_OBFUSCATOR)
     {"obfuscator", mainEntryClickHouseObfuscator},
 #endif
-#if ENABLE_CLICKHOUSE_ODBC_BRIDGE || !defined(ENABLE_CLICKHOUSE_ODBC_BRIDGE)
-    {"odbc-bridge", mainEntryClickHouseODBCBridge},
-#endif
 
 #if USE_EMBEDDED_COMPILER
     {"clang", mainEntryClickHouseClang},

dbms/programs/obfuscator/CMakeLists.txt

@@ -5,4 +5,5 @@ if (CLICKHOUSE_SPLIT_BINARY)
     add_executable (clickhouse-obfuscator clickhouse-obfuscator.cpp)
     set_target_properties(clickhouse-obfuscator PROPERTIES RUNTIME_OUTPUT_DIRECTORY ..)
     target_link_libraries (clickhouse-obfuscator PRIVATE clickhouse-obfuscator-lib)
+    install (TARGETS clickhouse-obfuscator ${CLICKHOUSE_ALL_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
 endif ()

dbms/programs/obfuscator/Obfuscator.cpp

@@ -1037,7 +1037,7 @@ try
 
     Obfuscator obfuscator(header, seed, markov_model_params);
 
-    size_t max_block_size = 8192;
+    UInt64 max_block_size = 8192;
 
     /// Train step
     {

dbms/programs/odbc-bridge/CMakeLists.txt

@@ -9,7 +9,7 @@ add_library (clickhouse-odbc-bridge-lib ${LINK_MODE}
     validateODBCConnectionString.cpp
 )
 
-target_link_libraries (clickhouse-odbc-bridge-lib PRIVATE clickhouse_dictionaries daemon dbms clickhouse_common_io)
+target_link_libraries (clickhouse-odbc-bridge-lib PRIVATE daemon dbms clickhouse_common_io)
 target_include_directories (clickhouse-odbc-bridge-lib PUBLIC ${ClickHouse_SOURCE_DIR}/libs/libdaemon/include)
 
 if (USE_POCO_SQLODBC)
@@ -33,7 +33,11 @@ if (ENABLE_TESTS)
     add_subdirectory (tests)
 endif ()
 
-if (CLICKHOUSE_SPLIT_BINARY)
+# clickhouse-odbc-bridge is always a separate binary.
-    add_executable (clickhouse-odbc-bridge odbc-bridge.cpp)
+# Reason: it must not export symbols from SSL, mariadb-client, etc. to not break ABI compatibility with ODBC drivers.
-    target_link_libraries (clickhouse-odbc-bridge PRIVATE clickhouse-odbc-bridge-lib)
+# For this reason, we disabling -rdynamic linker flag. But we do it in strange way:
-endif ()
+SET(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "")
+
+add_executable (clickhouse-odbc-bridge odbc-bridge.cpp)
+target_link_libraries (clickhouse-odbc-bridge PRIVATE clickhouse-odbc-bridge-lib)
+install (TARGETS clickhouse-odbc-bridge RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)

dbms/programs/odbc-bridge/MainHandler.cpp

@@ -75,7 +75,7 @@ void ODBCHandler::handleRequest(Poco::Net::HTTPServerRequest & request, Poco::Ne
         return;
     }
 
-    size_t max_block_size = DEFAULT_BLOCK_SIZE;
+    UInt64 max_block_size = DEFAULT_BLOCK_SIZE;
     if (params.has("max_block_size"))
     {
         std::string max_block_size_str = params.get("max_block_size", "");

dbms/programs/performance-test/CMakeLists.txt

@@ -1,8 +1,21 @@
-add_library (clickhouse-performance-test-lib ${LINK_MODE} PerformanceTest.cpp)
+add_library (clickhouse-performance-test-lib ${LINK_MODE}
+  JSONString.cpp
+  StopConditionsSet.cpp
+  TestStopConditions.cpp
+  TestStats.cpp
+  ConfigPreprocessor.cpp
+  PerformanceTest.cpp
+  PerformanceTestInfo.cpp
+  executeQuery.cpp
+  applySubstitutions.cpp
+  ReportBuilder.cpp
+  PerformanceTestSuite.cpp
+)
 target_link_libraries (clickhouse-performance-test-lib PRIVATE dbms clickhouse_common_io clickhouse_common_config ${Boost_PROGRAM_OPTIONS_LIBRARY})
 target_include_directories (clickhouse-performance-test-lib SYSTEM PRIVATE ${PCG_RANDOM_INCLUDE_DIR})
 
 if (CLICKHOUSE_SPLIT_BINARY)
     add_executable (clickhouse-performance-test clickhouse-performance-test.cpp)
     target_link_libraries (clickhouse-performance-test PRIVATE clickhouse-performance-test-lib)
+    install (TARGETS clickhouse-performance-test ${CLICKHOUSE_ALL_TARGETS} RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT clickhouse)
 endif ()

dbms/programs/performance-test/ConfigPreprocessor.cpp

@@ -0,0 +1,90 @@
+#include "ConfigPreprocessor.h"
+#include <Core/Types.h>
+#include <Poco/Path.h>
+#include <regex>
+namespace DB
+{
+std::vector<XMLConfigurationPtr> ConfigPreprocessor::processConfig(
+    const Strings & tests_tags,
+    const Strings & tests_names,
+    const Strings & tests_names_regexp,
+    const Strings & skip_tags,
+    const Strings & skip_names,
+    const Strings & skip_names_regexp) const
+{
+
+    std::vector<XMLConfigurationPtr> result;
+    for (const auto & path : paths)
+    {
+        result.emplace_back(new XMLConfiguration(path));
+        result.back()->setString("path", Poco::Path(path).absolute().toString());
+    }
+
+    /// Leave tests:
+    removeConfigurationsIf(result, FilterType::Tag, tests_tags, true);
+    removeConfigurationsIf(result, FilterType::Name, tests_names, true);
+    removeConfigurationsIf(result, FilterType::Name_regexp, tests_names_regexp, true);
+
+    /// Skip tests
+    removeConfigurationsIf(result, FilterType::Tag, skip_tags, false);
+    removeConfigurationsIf(result, FilterType::Name, skip_names, false);
+    removeConfigurationsIf(result, FilterType::Name_regexp, skip_names_regexp, false);
+    return result;
+}
+
+void ConfigPreprocessor::removeConfigurationsIf(
+    std::vector<XMLConfigurationPtr> & configs,
+    ConfigPreprocessor::FilterType filter_type,
+    const Strings & values,
+    bool leave) const
+{
+    auto checker = [&filter_type, &values, &leave] (XMLConfigurationPtr & config)
+    {
+        if (values.size() == 0)
+            return false;
+
+        bool remove_or_not = false;
+
+        if (filter_type == FilterType::Tag)
+        {
+            Strings tags_keys;
+            config->keys("tags", tags_keys);
+
+            Strings tags(tags_keys.size());
+            for (size_t i = 0; i != tags_keys.size(); ++i)
+                tags[i] = config->getString("tags.tag[" + std::to_string(i) + "]");
+
+            for (const std::string & config_tag : tags)
+            {
+                if (std::find(values.begin(), values.end(), config_tag) != values.end())
+                    remove_or_not = true;
+            }
+        }
+
+        if (filter_type == FilterType::Name)
+        {
+            remove_or_not = (std::find(values.begin(), values.end(), config->getString("name", "")) != values.end());
+        }
+
+        if (filter_type == FilterType::Name_regexp)
+        {
+            std::string config_name = config->getString("name", "");
+            auto regex_checker = [&config_name](const std::string & name_regexp)
+            {
+                std::regex pattern(name_regexp);
+                return std::regex_search(config_name, pattern);
+            };
+
+            remove_or_not = config->has("name") ? (std::find_if(values.begin(), values.end(), regex_checker) != values.end()) : false;
+        }
+
+        if (leave)
+            remove_or_not = !remove_or_not;
+        return remove_or_not;
+    };
+
+    auto new_end = std::remove_if(configs.begin(), configs.end(), checker);
+    configs.erase(new_end, configs.end());
+}
+
+}

dbms/programs/performance-test/ConfigPreprocessor.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <Poco/DOM/Document.h>
+#include <Poco/Util/XMLConfiguration.h>
+#include <Core/Types.h>
+#include <vector>
+#include <string>
+
+namespace DB
+{
+
+using XMLConfiguration = Poco::Util::XMLConfiguration;
+using XMLConfigurationPtr = Poco::AutoPtr<XMLConfiguration>;
+using XMLDocumentPtr = Poco::AutoPtr<Poco::XML::Document>;
+
+class ConfigPreprocessor
+{
+public:
+    ConfigPreprocessor(const Strings & paths_)
+        : paths(paths_)
+    {}
+
+    std::vector<XMLConfigurationPtr> processConfig(
+        const Strings & tests_tags,
+        const Strings & tests_names,
+        const Strings & tests_names_regexp,
+        const Strings & skip_tags,
+        const Strings & skip_names,
+        const Strings & skip_names_regexp) const;
+
+private:
+
+    enum class FilterType
+    {
+        Tag,
+        Name,
+        Name_regexp
+    };
+
+    /// Removes configurations that has a given value.
+    /// If leave is true, the logic is reversed.
+    void removeConfigurationsIf(
+        std::vector<XMLConfigurationPtr> & configs,
+        FilterType filter_type,
+        const Strings & values,
+        bool leave = false) const;
+
+    const Strings paths;
+};
+}

dbms/programs/performance-test/JSONString.cpp

@@ -0,0 +1,66 @@
+#include "JSONString.h"
+
+#include <regex>
+#include <sstream>
+namespace DB
+{
+
+namespace
+{
+std::string pad(size_t padding)
+{
+    return std::string(padding * 4, ' ');
+}
+
+const std::regex NEW_LINE{"\n"};
+}
+
+void JSONString::set(const std::string & key, std::string value, bool wrap)
+{
+    if (value.empty())
+        value = "null";
+
+    bool reserved = (value[0] == '[' || value[0] == '{' || value == "null");
+    if (!reserved && wrap)
+        value = '"' + std::regex_replace(value, NEW_LINE, "\\n") + '"';
+
+    content[key] = value;
+}
+
+void JSONString::set(const std::string & key, const std::vector<JSONString> & run_infos)
+{
+    std::ostringstream value;
+    value << "[\n";
+
+    for (size_t i = 0; i < run_infos.size(); ++i)
+    {
+        value << pad(padding + 1) + run_infos[i].asString(padding + 2);
+        if (i != run_infos.size() - 1)
+            value << ',';
+
+        value << "\n";
+    }
+
+    value << pad(padding) << ']';
+    content[key] = value.str();
+}
+
+std::string JSONString::asString(size_t cur_padding) const
+{
+    std::ostringstream repr;
+    repr << "{";
+
+    for (auto it = content.begin(); it != content.end(); ++it)
+    {
+        if (it != content.begin())
+            repr << ',';
+        /// construct "key": "value" string with padding
+        repr << "\n" << pad(cur_padding) << '"' << it->first << '"' << ": " << it->second;
+    }
+
+    repr << "\n" << pad(cur_padding - 1) << '}';
+    return repr.str();
+}
+
+
+}

dbms/programs/performance-test/JSONString.h

@@ -0,0 +1,40 @@
+#pragma once
+#include <Core/Types.h>
+
+#include <sys/stat.h>
+#include <type_traits>
+#include <vector>
+#include <map>
+
+namespace DB
+{
+
+/// NOTE The code is totally wrong.
+class JSONString
+{
+private:
+    std::map<std::string, std::string> content;
+    size_t padding;
+
+public:
+    explicit JSONString(size_t padding_ = 1) : padding(padding_) {}
+
+    void set(const std::string & key, std::string value, bool wrap = true);
+
+    template <typename T>
+    std::enable_if_t<std::is_arithmetic_v<T>> set(const std::string key, T value)
+    {
+        set(key, std::to_string(value), /*wrap= */ false);
+    }
+
+    void set(const std::string & key, const std::vector<JSONString> & run_infos);
+
+    std::string asString() const
+    {
+        return asString(padding);
+    }
+
+    std::string asString(size_t cur_padding) const;
+};
+
+}

dbms/programs/performance-test/PerformanceTest.h

@@ -0,0 +1,64 @@
+#pragma once
+
+#include <Client/Connection.h>
+#include <Common/InterruptListener.h>
+#include <common/logger_useful.h>
+#include <Poco/Util/XMLConfiguration.h>
+
+#include "PerformanceTestInfo.h"
+
+namespace DB
+{
+
+using XMLConfiguration = Poco::Util::XMLConfiguration;
+using XMLConfigurationPtr = Poco::AutoPtr<XMLConfiguration>;
+using QueriesWithIndexes = std::vector<std::pair<std::string, size_t>>;
+
+class PerformanceTest
+{
+public:
+    PerformanceTest(
+        const XMLConfigurationPtr & config_,
+        Connection & connection_,
+        InterruptListener & interrupt_listener_,
+        const PerformanceTestInfo & test_info_,
+        Context & context_,
+        const std::vector<size_t> & queries_to_run_);
+
+    bool checkPreconditions() const;
+    void prepare() const;
+    std::vector<TestStats> execute();
+    void finish() const;
+
+    const PerformanceTestInfo & getTestInfo() const
+    {
+        return test_info;
+    }
+
+    bool checkSIGINT() const
+    {
+        return got_SIGINT;
+    }
+
+private:
+    void runQueries(
+        const QueriesWithIndexes & queries_with_indexes,
+        std::vector<TestStats> & statistics_by_run);
+
+    UInt64 calculateMaxExecTime() const;
+
+private:
+    XMLConfigurationPtr config;
+    Connection & connection;
+    InterruptListener & interrupt_listener;
+
+    PerformanceTestInfo test_info;
+    Context & context;
+
+    std::vector<size_t> queries_to_run;
+    Poco::Logger * log;
+
+    bool got_SIGINT = false;
+};
+
+}

dbms/programs/performance-test/PerformanceTestInfo.cpp

@@ -0,0 +1,225 @@
+#include "PerformanceTestInfo.h"
+#include <Common/getMultipleKeysFromConfig.h>
+#include <IO/ReadBufferFromFile.h>
+#include <IO/ReadHelpers.h>
+#include <IO/WriteBufferFromFile.h>
+#include <boost/filesystem.hpp>
+#include "applySubstitutions.h"
+#include <iostream>
+
+namespace DB
+{
+namespace ErrorCodes
+{
+extern const int BAD_ARGUMENTS;
+}
+
+namespace
+{
+
+void extractSettings(
+    const XMLConfigurationPtr & config,
+    const std::string & key,
+    const Strings & settings_list,
+    std::map<std::string, std::string> & settings_to_apply)
+{
+    for (const std::string & setup : settings_list)
+    {
+        if (setup == "profile")
+            continue;
+
+        std::string value = config->getString(key + "." + setup);
+        if (value.empty())
+            value = "true";
+
+        settings_to_apply[setup] = value;
+    }
+}
+
+}
+
+
+namespace fs = boost::filesystem;
+
+PerformanceTestInfo::PerformanceTestInfo(
+    XMLConfigurationPtr config,
+    const std::string & profiles_file_)
+    : profiles_file(profiles_file_)
+{
+    test_name = config->getString("name");
+    path = config->getString("path");
+    if (config->has("main_metric"))
+    {
+        Strings main_metrics;
+        config->keys("main_metric", main_metrics);
+        if (main_metrics.size())
+            main_metric = main_metrics[0];
+    }
+
+    applySettings(config);
+    extractQueries(config);
+    processSubstitutions(config);
+    getExecutionType(config);
+    getStopConditions(config);
+    extractAuxiliaryQueries(config);
+}
+
+void PerformanceTestInfo::applySettings(XMLConfigurationPtr config)
+{
+    if (config->has("settings"))
+    {
+        std::map<std::string, std::string> settings_to_apply;
+        Strings config_settings;
+        config->keys("settings", config_settings);
+
+        auto settings_contain = [&config_settings] (const std::string & setting)
+        {
+            auto position = std::find(config_settings.begin(), config_settings.end(), setting);
+            return position != config_settings.end();
+
+        };
+        /// Preprocess configuration file
+        if (settings_contain("profile"))
+        {
+            if (!profiles_file.empty())
+            {
+                std::string profile_name = config->getString("settings.profile");
+                XMLConfigurationPtr profiles_config(new XMLConfiguration(profiles_file));
+
+                Strings profile_settings;
+                profiles_config->keys("profiles." + profile_name, profile_settings);
+
+                extractSettings(profiles_config, "profiles." + profile_name, profile_settings, settings_to_apply);
+            }
+        }
+
+        extractSettings(config, "settings", config_settings, settings_to_apply);
+
+        /// This macro goes through all settings in the Settings.h
+        /// and, if found any settings in test's xml configuration
+        /// with the same name, sets its value to settings
+        std::map<std::string, std::string>::iterator it;
+#define EXTRACT_SETTING(TYPE, NAME, DEFAULT, DESCRIPTION)   \
+        it = settings_to_apply.find(#NAME);                 \
+        if (it != settings_to_apply.end())                  \
+            settings.set(#NAME, settings_to_apply[#NAME]);
+
+        APPLY_FOR_SETTINGS(EXTRACT_SETTING)
+
+#undef EXTRACT_SETTING
+
+        if (settings_contain("average_rows_speed_precision"))
+            TestStats::avg_rows_speed_precision =
+                config->getDouble("settings.average_rows_speed_precision");
+
+        if (settings_contain("average_bytes_speed_precision"))
+            TestStats::avg_bytes_speed_precision =
+                config->getDouble("settings.average_bytes_speed_precision");
+    }
+}
+
+void PerformanceTestInfo::extractQueries(XMLConfigurationPtr config)
+{
+    if (config->has("query"))
+        queries = getMultipleValuesFromConfig(*config, "", "query");
+
+    if (config->has("query_file"))
+    {
+        const std::string filename = config->getString("query_file");
+        if (filename.empty())
+            throw Exception("Empty file name", ErrorCodes::BAD_ARGUMENTS);
+
+        bool tsv = fs::path(filename).extension().string() == ".tsv";
+
+        ReadBufferFromFile query_file(filename);
+        std::string query;
+
+        if (tsv)
+        {
+            while (!query_file.eof())
+            {
+                readEscapedString(query, query_file);
+                assertChar('\n', query_file);
+                queries.push_back(query);
+            }
+        }
+        else
+        {
+            readStringUntilEOF(query, query_file);
+            queries.push_back(query);
+        }
+    }
+
+    if (queries.empty())
+        throw Exception("Did not find any query to execute: " + test_name,
+            ErrorCodes::BAD_ARGUMENTS);
+}
+
+void PerformanceTestInfo::processSubstitutions(XMLConfigurationPtr config)
+{
+    if (config->has("substitutions"))
+    {
+        /// Make "subconfig" of inner xml block
+        ConfigurationPtr substitutions_view(config->createView("substitutions"));
+        constructSubstitutions(substitutions_view, substitutions);
+
+        auto queries_pre_format = queries;
+        queries.clear();
+        for (const auto & query : queries_pre_format)
+        {
+            auto formatted = formatQueries(query, substitutions);
+            queries.insert(queries.end(), formatted.begin(), formatted.end());
+        }
+    }
+}
+
+void PerformanceTestInfo::getExecutionType(XMLConfigurationPtr config)
+{
+    if (!config->has("type"))
+        throw Exception("Missing type property in config: " + test_name,
+            ErrorCodes::BAD_ARGUMENTS);
+
+    std::string config_exec_type = config->getString("type");
+    if (config_exec_type == "loop")
+        exec_type = ExecutionType::Loop;
+    else if (config_exec_type == "once")
+        exec_type = ExecutionType::Once;
+    else
+        throw Exception("Unknown type " + config_exec_type + " in :" + test_name,
+            ErrorCodes::BAD_ARGUMENTS);
+}
+
+
+void PerformanceTestInfo::getStopConditions(XMLConfigurationPtr config)
+{
+    TestStopConditions stop_conditions_template;
+    if (config->has("stop_conditions"))
+    {
+        ConfigurationPtr stop_conditions_config(config->createView("stop_conditions"));
+        stop_conditions_template.loadFromConfig(stop_conditions_config);
+    }
+
+    if (stop_conditions_template.empty())
+        throw Exception("No termination conditions were found in config",
+            ErrorCodes::BAD_ARGUMENTS);
+
+    times_to_run = config->getUInt("times_to_run", 1);
+
+    for (size_t i = 0; i < times_to_run * queries.size(); ++i)
+        stop_conditions_by_run.push_back(stop_conditions_template);
+
+}
+
+void PerformanceTestInfo::extractAuxiliaryQueries(XMLConfigurationPtr config)
+{
+    if (config->has("create_query"))
+        create_queries = getMultipleValuesFromConfig(*config, "", "create_query");
+
+    if (config->has("fill_query"))
+        fill_queries = getMultipleValuesFromConfig(*config, "", "fill_query");
+
+    if (config->has("drop_query"))
+        drop_queries = getMultipleValuesFromConfig(*config, "", "drop_query");
+}
+
+}

dbms/programs/performance-test/PerformanceTestInfo.h

@@ -0,0 +1,59 @@
+#pragma once
+#include <string>
+#include <vector>
+#include <map>
+#include <Interpreters/Settings.h>
+#include <Poco/Util/XMLConfiguration.h>
+#include <Poco/AutoPtr.h>
+
+#include "StopConditionsSet.h"
+#include "TestStopConditions.h"
+#include "TestStats.h"
+
+namespace DB
+{
+enum class ExecutionType
+{
+    Loop,
+    Once
+};
+
+using XMLConfiguration = Poco::Util::XMLConfiguration;
+using XMLConfigurationPtr = Poco::AutoPtr<XMLConfiguration>;
+using StringToVector = std::map<std::string, Strings>;
+
+/// Class containing all info to run performance test
+class PerformanceTestInfo
+{
+public:
+    PerformanceTestInfo(XMLConfigurationPtr config, const std::string & profiles_file_);
+
+    std::string test_name;
+    std::string path;
+    std::string main_metric;
+
+    Strings queries;
+
+    Settings settings;
+    ExecutionType exec_type;
+    StringToVector substitutions;
+    size_t times_to_run;
+
+    std::string profiles_file;
+    std::vector<TestStopConditions> stop_conditions_by_run;
+
+    Strings create_queries;
+    Strings fill_queries;
+    Strings drop_queries;
+
+private:
+    void applySettings(XMLConfigurationPtr config);
+    void extractQueries(XMLConfigurationPtr config);
+    void processSubstitutions(XMLConfigurationPtr config);
+    void getExecutionType(XMLConfigurationPtr config);
+    void getStopConditions(XMLConfigurationPtr config);
+    void getMetrics(XMLConfigurationPtr config);
+    void extractAuxiliaryQueries(XMLConfigurationPtr config);
+};
+
+}

dbms/programs/performance-test/PerformanceTestSuite.cpp

@@ -0,0 +1,418 @@
+#include <algorithm>
+#include <iostream>
+#include <limits>
+#include <regex>
+#include <thread>
+#include <memory>
+
+#include <port/unistd.h>
+#include <sys/stat.h>
+
+#include <boost/filesystem.hpp>
+#include <boost/program_options.hpp>
+
+#include <Poco/AutoPtr.h>
+#include <Poco/ConsoleChannel.h>
+#include <Poco/FormattingChannel.h>
+#include <Poco/Logger.h>
+#include <Poco/Path.h>
+#include <Poco/PatternFormatter.h>
+#include <Poco/Util/XMLConfiguration.h>
+
+#include <common/logger_useful.h>
+#include <Client/Connection.h>
+#include <Core/Types.h>
+#include <Interpreters/Context.h>
+#include <IO/ConnectionTimeouts.h>
+#include <IO/UseSSL.h>
+#include <Interpreters/Settings.h>
+#include <Common/Exception.h>
+#include <Common/InterruptListener.h>
+
+#include "TestStopConditions.h"
+#include "TestStats.h"
+#include "ConfigPreprocessor.h"
+#include "PerformanceTest.h"
+#include "ReportBuilder.h"
+
+
+namespace fs = boost::filesystem;
+namespace po = boost::program_options;
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int BAD_ARGUMENTS;
+    extern const int FILE_DOESNT_EXIST;
+}
+
+/** Tests launcher for ClickHouse.
+ * The tool walks through given or default folder in order to find files with
+ * tests' descriptions and launches it.
+ */
+class PerformanceTestSuite
+{
+public:
+
+    PerformanceTestSuite(const std::string & host_,
+        const UInt16 port_,
+        const bool secure_,
+        const std::string & default_database_,
+        const std::string & user_,
+        const std::string & password_,
+        const bool lite_output_,
+        const std::string & profiles_file_,
+        Strings && input_files_,
+        Strings && tests_tags_,
+        Strings && skip_tags_,
+        Strings && tests_names_,
+        Strings && skip_names_,
+        Strings && tests_names_regexp_,
+        Strings && skip_names_regexp_,
+        const std::unordered_map<std::string, std::vector<size_t>> query_indexes_,
+        const ConnectionTimeouts & timeouts)
+        : connection(host_, port_, default_database_, user_,
+            password_, timeouts, "performance-test", Protocol::Compression::Enable,
+            secure_ ? Protocol::Secure::Enable : Protocol::Secure::Disable)
+        , tests_tags(std::move(tests_tags_))
+        , tests_names(std::move(tests_names_))
+        , tests_names_regexp(std::move(tests_names_regexp_))
+        , skip_tags(std::move(skip_tags_))
+        , skip_names(std::move(skip_names_))
+        , skip_names_regexp(std::move(skip_names_regexp_))
+        , query_indexes(query_indexes_)
+        , lite_output(lite_output_)
+        , profiles_file(profiles_file_)
+        , input_files(input_files_)
+        , log(&Poco::Logger::get("PerformanceTestSuite"))
+    {
+        if (input_files.size() < 1)
+            throw Exception("No tests were specified", ErrorCodes::BAD_ARGUMENTS);
+    }
+
+    /// This functionality seems strange.
+    //void initialize(Poco::Util::Application & self [[maybe_unused]])
+    //{
+    //    std::string home_path;
+    //    const char * home_path_cstr = getenv("HOME");
+    //    if (home_path_cstr)
+    //        home_path = home_path_cstr;
+    //    configReadClient(Poco::Util::Application::instance().config(), home_path);
+    //}
+
+    int run()
+    {
+        std::string name;
+        UInt64 version_major;
+        UInt64 version_minor;
+        UInt64 version_patch;
+        UInt64 version_revision;
+        connection.getServerVersion(name, version_major, version_minor, version_patch, version_revision);
+
+        std::stringstream ss;
+        ss << version_major << "." << version_minor << "." << version_patch;
+        server_version = ss.str();
+
+        report_builder = std::make_shared<ReportBuilder>(server_version);
+
+        processTestsConfigurations(input_files);
+
+        return 0;
+    }
+
+private:
+    Connection connection;
+
+    const Strings & tests_tags;
+    const Strings & tests_names;
+    const Strings & tests_names_regexp;
+    const Strings & skip_tags;
+    const Strings & skip_names;
+    const Strings & skip_names_regexp;
+    std::unordered_map<std::string, std::vector<size_t>> query_indexes;
+
+    Context global_context = Context::createGlobal();
+    std::shared_ptr<ReportBuilder> report_builder;
+
+    std::string server_version;
+
+    InterruptListener interrupt_listener;
+
+    using XMLConfiguration = Poco::Util::XMLConfiguration;
+    using XMLConfigurationPtr = Poco::AutoPtr<XMLConfiguration>;
+
+    bool lite_output;
+    std::string profiles_file;
+
+    Strings input_files;
+    std::vector<XMLConfigurationPtr> tests_configurations;
+    Poco::Logger * log;
+
+    void processTestsConfigurations(const Strings & paths)
+    {
+        LOG_INFO(log, "Preparing test configurations");
+        ConfigPreprocessor config_prep(paths);
+        tests_configurations = config_prep.processConfig(
+            tests_tags,
+            tests_names,
+            tests_names_regexp,
+            skip_tags,
+            skip_names,
+            skip_names_regexp);
+
+        LOG_INFO(log, "Test configurations prepared");
+
+        if (tests_configurations.size())
+        {
+            Strings outputs;
+
+            for (auto & test_config : tests_configurations)
+            {
+                auto [output, signal] = runTest(test_config);
+                if (!output.empty())
+                {
+                    if (lite_output)
+                        std::cout << output;
+                    else
+                        outputs.push_back(output);
+                }
+                if (signal)
+                    break;
+            }
+
+            if (!lite_output && outputs.size())
+            {
+                std::cout << "[" << std::endl;
+
+                for (size_t i = 0; i != outputs.size(); ++i)
+                {
+                    std::cout << outputs[i];
+                    if (i != outputs.size() - 1)
+                        std::cout << ",";
+
+                    std::cout << std::endl;
+                }
+
+                std::cout << "]" << std::endl;
+            }
+        }
+    }
+
+    std::pair<std::string, bool> runTest(XMLConfigurationPtr & test_config)
+    {
+        PerformanceTestInfo info(test_config, profiles_file);
+        LOG_INFO(log, "Config for test '" << info.test_name << "' parsed");
+        PerformanceTest current(test_config, connection, interrupt_listener, info, global_context, query_indexes[info.path]);
+
+        if (current.checkPreconditions())
+        {
+            LOG_INFO(log, "Preconditions for test '" << info.test_name << "' are fullfilled");
+            LOG_INFO(
+                log,
+                "Preparing for run, have " << info.create_queries.size() << " create queries and " << info.fill_queries.size()
+                                           << " fill queries");
+            current.prepare();
+            LOG_INFO(log, "Prepared");
+            LOG_INFO(log, "Running test '" << info.test_name << "'");
+            auto result = current.execute();
+            LOG_INFO(log, "Test '" << info.test_name << "' finished");
+
+            LOG_INFO(log, "Running post run queries");
+            current.finish();
+            LOG_INFO(log, "Postqueries finished");
+            if (lite_output)
+                return {report_builder->buildCompactReport(info, result, query_indexes[info.path]), current.checkSIGINT()};
+            else
+                return {report_builder->buildFullReport(info, result, query_indexes[info.path]), current.checkSIGINT()};
+        }
+        else
+            LOG_INFO(log, "Preconditions for test '" << info.test_name << "' are not fullfilled, skip run");
+
+        return {"", current.checkSIGINT()};
+    }
+};
+
+}
+
+static void getFilesFromDir(const fs::path & dir, std::vector<std::string> & input_files, const bool recursive = false)
+{
+    Poco::Logger * log = &Poco::Logger::get("PerformanceTestSuite");
+    if (dir.extension().string() == ".xml")
+        LOG_WARNING(log, dir.string() + "' is a directory, but has .xml extension");
+
+    fs::directory_iterator end;
+    for (fs::directory_iterator it(dir); it != end; ++it)
+    {
+        const fs::path file = (*it);
+        if (recursive && fs::is_directory(file))
+            getFilesFromDir(file, input_files, recursive);
+        else if (!fs::is_directory(file) && file.extension().string() == ".xml")
+            input_files.push_back(file.string());
+    }
+}
+
+static std::vector<std::string> getInputFiles(const po::variables_map & options, Poco::Logger * log)
+{
+    std::vector<std::string> input_files;
+    bool recursive = options.count("recursive");
+
+    if (!options.count("input-files"))
+    {
+        LOG_INFO(log, "Trying to find test scenario files in the current folder...");
+        fs::path curr_dir(".");
+
+        getFilesFromDir(curr_dir, input_files, recursive);
+
+        if (input_files.empty())
+            throw DB::Exception("Did not find any xml files", DB::ErrorCodes::BAD_ARGUMENTS);
+        else
+            LOG_INFO(log, "Found " << input_files.size() << " files");
+    }
+    else
+    {
+        input_files = options["input-files"].as<std::vector<std::string>>();
+        LOG_INFO(log, "Found " + std::to_string(input_files.size()) + " input files");
+        std::vector<std::string> collected_files;
+
+        for (const std::string & filename : input_files)
+        {
+            fs::path file(filename);
+
+            if (!fs::exists(file))
+                throw DB::Exception("File '" + filename + "' does not exist", DB::ErrorCodes::FILE_DOESNT_EXIST);
+
+            if (fs::is_directory(file))
+            {
+                getFilesFromDir(file, collected_files, recursive);
+            }
+            else
+            {
+                if (file.extension().string() != ".xml")
+                    throw DB::Exception("File '" + filename + "' does not have .xml extension", DB::ErrorCodes::BAD_ARGUMENTS);
+                collected_files.push_back(filename);
+            }
+        }
+
+        input_files = std::move(collected_files);
+    }
+    std::sort(input_files.begin(), input_files.end());
+    return input_files;
+}
+
+std::unordered_map<std::string, std::vector<std::size_t>> getTestQueryIndexes(const po::basic_parsed_options<char> & parsed_opts)
+{
+    std::unordered_map<std::string, std::vector<std::size_t>> result;
+    const auto & options = parsed_opts.options;
+    for (size_t i = 0; i < options.size() - 1; ++i)
+    {
+        const auto & opt = options[i];
+        if (opt.string_key == "input-files")
+        {
+            if (options[i + 1].string_key == "query-indexes")
+            {
+                const std::string & test_path = Poco::Path(opt.value[0]).absolute().toString();
+                for (const auto & query_num_str : options[i + 1].value)
+                {
+                    size_t query_num = std::stoul(query_num_str);
+                    result[test_path].push_back(query_num);
+                }
+            }
+        }
+    }
+    return result;
+}
+
+int mainEntryClickHousePerformanceTest(int argc, char ** argv)
+try
+{
+    using po::value;
+    using Strings = DB::Strings;
+
+
+    po::options_description desc("Allowed options");
+    desc.add_options()
+        ("help", "produce help message")
+        ("lite", "use lite version of output")
+        ("profiles-file", value<std::string>()->default_value(""), "Specify a file with global profiles")
+        ("host,h", value<std::string>()->default_value("localhost"), "")
+        ("port", value<UInt16>()->default_value(9000), "")
+        ("secure,s", "Use TLS connection")
+        ("database", value<std::string>()->default_value("default"), "")
+        ("user", value<std::string>()->default_value("default"), "")
+        ("password", value<std::string>()->default_value(""), "")
+        ("log-level", value<std::string>()->default_value("information"), "Set log level")
+        ("tags", value<Strings>()->multitoken(), "Run only tests with tag")
+        ("skip-tags", value<Strings>()->multitoken(), "Do not run tests with tag")
+        ("names", value<Strings>()->multitoken(), "Run tests with specific name")
+        ("skip-names", value<Strings>()->multitoken(), "Do not run tests with name")
+        ("names-regexp", value<Strings>()->multitoken(), "Run tests with names matching regexp")
+        ("skip-names-regexp", value<Strings>()->multitoken(), "Do not run tests with names matching regexp")
+        ("input-files", value<Strings>()->multitoken(), "Input .xml files")
+        ("query-indexes", value<std::vector<size_t>>()->multitoken(), "Input query indexes")
+        ("recursive,r", "Recurse in directories to find all xml's");
+
+    po::options_description cmdline_options;
+    cmdline_options.add(desc);
+
+    po::variables_map options;
+    po::basic_parsed_options<char> parsed = po::command_line_parser(argc, argv).options(cmdline_options).run();
+    auto queries_with_indexes = getTestQueryIndexes(parsed);
+    po::store(parsed, options);
+
+    po::notify(options);
+
+    Poco::AutoPtr<Poco::PatternFormatter> formatter(new Poco::PatternFormatter("%Y.%m.%d %H:%M:%S.%F <%p> %s: %t"));
+    Poco::AutoPtr<Poco::ConsoleChannel> console_chanel(new Poco::ConsoleChannel);
+    Poco::AutoPtr<Poco::FormattingChannel> channel(new Poco::FormattingChannel(formatter, console_chanel));
+
+    Poco::Logger::root().setLevel(options["log-level"].as<std::string>());
+    Poco::Logger::root().setChannel(channel);
+
+    Poco::Logger * log = &Poco::Logger::get("PerformanceTestSuite");
+    if (options.count("help"))
+    {
+        std::cout << "Usage: " << argv[0] << " [options] [test_file ...] [tests_folder]\n";
+        std::cout << desc << "\n";
+        return 0;
+    }
+
+    Strings input_files = getInputFiles(options, log);
+
+    Strings tests_tags = options.count("tags") ? options["tags"].as<Strings>() : Strings({});
+    Strings skip_tags = options.count("skip-tags") ? options["skip-tags"].as<Strings>() : Strings({});
+    Strings tests_names = options.count("names") ? options["names"].as<Strings>() : Strings({});
+    Strings skip_names = options.count("skip-names") ? options["skip-names"].as<Strings>() : Strings({});
+    Strings tests_names_regexp = options.count("names-regexp") ? options["names-regexp"].as<Strings>() : Strings({});
+    Strings skip_names_regexp = options.count("skip-names-regexp") ? options["skip-names-regexp"].as<Strings>() : Strings({});
+
+    auto timeouts = DB::ConnectionTimeouts::getTCPTimeoutsWithoutFailover(DB::Settings());
+
+    DB::UseSSL use_ssl;
+
+    DB::PerformanceTestSuite performance_test_suite(
+        options["host"].as<std::string>(),
+        options["port"].as<UInt16>(),
+        options.count("secure"),
+        options["database"].as<std::string>(),
+        options["user"].as<std::string>(),
+        options["password"].as<std::string>(),
+        options.count("lite") > 0,
+        options["profiles-file"].as<std::string>(),
+        std::move(input_files),
+        std::move(tests_tags),
+        std::move(skip_tags),
+        std::move(tests_names),
+        std::move(skip_names),
+        std::move(tests_names_regexp),
+        std::move(skip_names_regexp),
+        queries_with_indexes,
+        timeouts);
+    return performance_test_suite.run();
+}
+catch (...)
+{
+    std::cout << DB::getCurrentExceptionMessage(/*with stacktrace = */ true) << std::endl;
+    int code = DB::getCurrentExceptionCode();
+    return code ? code : 1;
+}

dbms/programs/performance-test/ReportBuilder.cpp

@@ -0,0 +1,199 @@
+#include "ReportBuilder.h"
+
+#include <algorithm>
+#include <regex>
+#include <sstream>
+#include <thread>
+
+#include <Common/getNumberOfPhysicalCPUCores.h>
+#include <Common/getFQDNOrHostName.h>
+#include <common/getMemoryAmount.h>
+
+#include "JSONString.h"
+
+namespace DB
+{
+
+namespace
+{
+const std::regex QUOTE_REGEX{"\""};
+std::string getMainMetric(const PerformanceTestInfo & test_info)
+{
+    std::string main_metric;
+    if (test_info.main_metric.empty())
+        if (test_info.exec_type == ExecutionType::Loop)
+            main_metric = "min_time";
+        else
+            main_metric = "rows_per_second";
+    else
+        main_metric = test_info.main_metric;
+    return main_metric;
+}
+}
+
+ReportBuilder::ReportBuilder(const std::string & server_version_)
+    : server_version(server_version_)
+    , hostname(getFQDNOrHostName())
+    , num_cores(getNumberOfPhysicalCPUCores())
+    , num_threads(std::thread::hardware_concurrency())
+    , ram(getMemoryAmount())
+{
+}
+
+std::string ReportBuilder::getCurrentTime() const
+{
+    return DateLUT::instance().timeToString(time(nullptr));
+}
+
+std::string ReportBuilder::buildFullReport(
+    const PerformanceTestInfo & test_info,
+    std::vector<TestStats> & stats,
+    const std::vector<std::size_t> & queries_to_run) const
+{
+    JSONString json_output;
+
+    json_output.set("hostname", hostname);
+    json_output.set("num_cores", num_cores);
+    json_output.set("num_threads", num_threads);
+    json_output.set("ram", ram);
+    json_output.set("server_version", server_version);
+    json_output.set("time", getCurrentTime());
+    json_output.set("test_name", test_info.test_name);
+    json_output.set("path", test_info.path);
+    json_output.set("main_metric", getMainMetric(test_info));
+
+    if (test_info.substitutions.size())
+    {
+        JSONString json_parameters(2); /// here, 2 is the size of \t padding
+
+        for (auto it = test_info.substitutions.begin(); it != test_info.substitutions.end(); ++it)
+        {
+            std::string parameter = it->first;
+            Strings values = it->second;
+
+            std::ostringstream array_string;
+            array_string << "[";
+            for (size_t i = 0; i != values.size(); ++i)
+            {
+                array_string << '"' << std::regex_replace(values[i], QUOTE_REGEX, "\\\"") << '"';
+                if (i != values.size() - 1)
+                {
+                    array_string << ", ";
+                }
+            }
+            array_string << ']';
+
+            json_parameters.set(parameter, array_string.str());
+        }
+
+        json_output.set("parameters", json_parameters.asString());
+    }
+
+    std::vector<JSONString> run_infos;
+    for (size_t query_index = 0; query_index < test_info.queries.size(); ++query_index)
+    {
+        if (!queries_to_run.empty() && std::find(queries_to_run.begin(), queries_to_run.end(), query_index) == queries_to_run.end())
+            continue;
+
+        for (size_t number_of_launch = 0; number_of_launch < test_info.times_to_run; ++number_of_launch)
+        {
+            size_t stat_index = number_of_launch * test_info.queries.size() + query_index;
+            TestStats & statistics = stats[stat_index];
+
+            if (!statistics.ready)
+                continue;
+
+            JSONString runJSON;
+
+            auto query = std::regex_replace(test_info.queries[query_index], QUOTE_REGEX, "\\\"");
+            runJSON.set("query", query);
+            runJSON.set("query_index", query_index);
+            if (!statistics.exception.empty())
+                runJSON.set("exception", statistics.exception);
+
+            if (test_info.exec_type == ExecutionType::Loop)
+            {
+                /// in seconds
+                runJSON.set("min_time", statistics.min_time / double(1000));
+
+                if (statistics.sampler.size() != 0)
+                {
+                    JSONString quantiles(4); /// here, 4 is the size of \t padding
+                    for (double percent = 10; percent <= 90; percent += 10)
+                    {
+                        std::string quantile_key = std::to_string(percent / 100.0);
+                        while (quantile_key.back() == '0')
+                            quantile_key.pop_back();
+
+                        quantiles.set(quantile_key,
+                            statistics.sampler.quantileInterpolated(percent / 100.0));
+                    }
+                    quantiles.set("0.95",
+                        statistics.sampler.quantileInterpolated(95 / 100.0));
+                    quantiles.set("0.99",
+                        statistics.sampler.quantileInterpolated(99 / 100.0));
+                    quantiles.set("0.999",
+                        statistics.sampler.quantileInterpolated(99.9 / 100.0));
+                    quantiles.set("0.9999",
+                        statistics.sampler.quantileInterpolated(99.99 / 100.0));
+
+                    runJSON.set("quantiles", quantiles.asString());
+                }
+
+                runJSON.set("total_time", statistics.total_time);
+
+                if (statistics.total_time != 0)
+                {
+                    runJSON.set("queries_per_second", static_cast<double>(statistics.queries) / statistics.total_time);
+                    runJSON.set("rows_per_second", static_cast<double>(statistics.total_rows_read) / statistics.total_time);
+                    runJSON.set("bytes_per_second", static_cast<double>(statistics.total_bytes_read) / statistics.total_time);
+                }
+            }
+            else
+            {
+                runJSON.set("max_rows_per_second", statistics.max_rows_speed);
+                runJSON.set("max_bytes_per_second", statistics.max_bytes_speed);
+                runJSON.set("avg_rows_per_second", statistics.avg_rows_speed_value);
+                runJSON.set("avg_bytes_per_second", statistics.avg_bytes_speed_value);
+            }
+
+            run_infos.push_back(runJSON);
+        }
+    }
+
+    json_output.set("runs", run_infos);
+
+    return json_output.asString();
+}
+
+std::string ReportBuilder::buildCompactReport(
+    const PerformanceTestInfo & test_info,
+    std::vector<TestStats> & stats,
+    const std::vector<std::size_t> & queries_to_run) const
+{
+
+    std::ostringstream output;
+
+    for (size_t query_index = 0; query_index < test_info.queries.size(); ++query_index)
+    {
+        if (!queries_to_run.empty() && std::find(queries_to_run.begin(), queries_to_run.end(), query_index) == queries_to_run.end())
+            continue;
+
+        for (size_t number_of_launch = 0; number_of_launch < test_info.times_to_run; ++number_of_launch)
+        {
+            if (test_info.queries.size() > 1)
+                output << "query \"" << test_info.queries[query_index] << "\", ";
+
+            output << "run " << std::to_string(number_of_launch + 1) << ": ";
+
+            std::string main_metric = getMainMetric(test_info);
+
+            output << main_metric << " = ";
+            size_t index = number_of_launch * test_info.queries.size() + query_index;
+            output << stats[index].getStatisticByName(main_metric);
+            output << "\n";
+        }
+    }
+    return output.str();
+}
+}

dbms/programs/performance-test/ReportBuilder.h

@@ -0,0 +1,36 @@
+#pragma once
+#include "PerformanceTestInfo.h"
+#include <vector>
+#include <string>
+
+namespace DB
+{
+
+class ReportBuilder
+{
+public:
+    ReportBuilder(const std::string & server_version_);
+    std::string buildFullReport(
+        const PerformanceTestInfo & test_info,
+        std::vector<TestStats> & stats,
+        const std::vector<std::size_t> & queries_to_run) const;
+
+
+    std::string buildCompactReport(
+        const PerformanceTestInfo & test_info,
+        std::vector<TestStats> & stats,
+        const std::vector<std::size_t> & queries_to_run) const;
+
+private:
+    std::string server_version;
+    std::string hostname;
+    size_t num_cores;
+    size_t num_threads;
+    size_t ram;
+
+private:
+    std::string getCurrentTime() const;
+
+};
+
+}

dbms/programs/performance-test/StopConditionsSet.cpp

@@ -0,0 +1,63 @@
+#include "StopConditionsSet.h"
+#include <Common/Exception.h>
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+extern const int LOGICAL_ERROR;
+}
+
+void StopConditionsSet::loadFromConfig(const ConfigurationPtr & stop_conditions_view)
+{
+    Strings keys;
+    stop_conditions_view->keys(keys);
+
+    for (const std::string & key : keys)
+    {
+        if (key == "total_time_ms")
+            total_time_ms.value = stop_conditions_view->getUInt64(key);
+        else if (key == "rows_read")
+            rows_read.value = stop_conditions_view->getUInt64(key);
+        else if (key == "bytes_read_uncompressed")
+            bytes_read_uncompressed.value = stop_conditions_view->getUInt64(key);
+        else if (key == "iterations")
+            iterations.value = stop_conditions_view->getUInt64(key);
+        else if (key == "min_time_not_changing_for_ms")
+            min_time_not_changing_for_ms.value = stop_conditions_view->getUInt64(key);
+        else if (key == "max_speed_not_changing_for_ms")
+            max_speed_not_changing_for_ms.value = stop_conditions_view->getUInt64(key);
+        else if (key == "average_speed_not_changing_for_ms")
+            average_speed_not_changing_for_ms.value = stop_conditions_view->getUInt64(key);
+        else
+            throw Exception("Met unkown stop condition: " + key, ErrorCodes::LOGICAL_ERROR);
+    }
+    ++initialized_count;
+}
+
+void StopConditionsSet::reset()
+{
+    total_time_ms.fulfilled = false;
+    rows_read.fulfilled = false;
+    bytes_read_uncompressed.fulfilled = false;
+    iterations.fulfilled = false;
+    min_time_not_changing_for_ms.fulfilled = false;
+    max_speed_not_changing_for_ms.fulfilled = false;
+    average_speed_not_changing_for_ms.fulfilled = false;
+
+    fulfilled_count = 0;
+}
+
+void StopConditionsSet::report(UInt64 value, StopConditionsSet::StopCondition & condition)
+{
+    if (condition.value && !condition.fulfilled && value >= condition.value)
+    {
+        condition.fulfilled = true;
+        ++fulfilled_count;
+    }
+}
+
+
+
+}

dbms/programs/performance-test/StopConditionsSet.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <Core/Types.h>
+#include <Poco/Util/XMLConfiguration.h>
+
+namespace DB
+{
+
+using ConfigurationPtr = Poco::AutoPtr<Poco::Util::AbstractConfiguration>;
+
+/// A set of supported stop conditions.
+struct StopConditionsSet
+{
+    void loadFromConfig(const ConfigurationPtr & stop_conditions_view);
+    void reset();
+
+    /// Note: only conditions with UInt64 minimal thresholds are supported.
+    /// I.e. condition is fulfilled when value is exceeded.
+    struct StopCondition
+    {
+        UInt64 value = 0;
+        bool fulfilled = false;
+    };
+
+    void report(UInt64 value, StopCondition & condition);
+
+    StopCondition total_time_ms;
+    StopCondition rows_read;
+    StopCondition bytes_read_uncompressed;
+    StopCondition iterations;
+    StopCondition min_time_not_changing_for_ms;
+    StopCondition max_speed_not_changing_for_ms;
+    StopCondition average_speed_not_changing_for_ms;
+
+    size_t initialized_count = 0;
+    size_t fulfilled_count = 0;
+};
+
+}

dbms/programs/performance-test/TestStats.cpp

@@ -0,0 +1,165 @@
+#include "TestStats.h"
+namespace DB
+{
+
+namespace
+{
+const std::string FOUR_SPACES = "    ";
+}
+
+std::string TestStats::getStatisticByName(const std::string & statistic_name)
+{
+    if (statistic_name == "min_time")
+        return std::to_string(min_time) + "ms";
+
+    if (statistic_name == "quantiles")
+    {
+        std::string result = "\n";
+
+        for (double percent = 10; percent <= 90; percent += 10)
+        {
+            result += FOUR_SPACES + std::to_string((percent / 100));
+            result += ": " + std::to_string(sampler.quantileInterpolated(percent / 100.0));
+            result += "\n";
+        }
+        result += FOUR_SPACES + "0.95:   " + std::to_string(sampler.quantileInterpolated(95 / 100.0)) + "\n";
+        result += FOUR_SPACES + "0.99: " + std::to_string(sampler.quantileInterpolated(99 / 100.0)) + "\n";
+        result += FOUR_SPACES + "0.999: " + std::to_string(sampler.quantileInterpolated(99.9 / 100.)) + "\n";
+        result += FOUR_SPACES + "0.9999: " + std::to_string(sampler.quantileInterpolated(99.99 / 100.));
+
+        return result;
+    }
+    if (statistic_name == "total_time")
+        return std::to_string(total_time) + "s";
+
+    if (statistic_name == "queries_per_second")
+        return std::to_string(queries / total_time);
+
+    if (statistic_name == "rows_per_second")
+        return std::to_string(total_rows_read / total_time);
+
+    if (statistic_name == "bytes_per_second")
+        return std::to_string(total_bytes_read / total_time);
+
+    if (statistic_name == "max_rows_per_second")
+        return std::to_string(max_rows_speed);
+
+    if (statistic_name == "max_bytes_per_second")
+        return std::to_string(max_bytes_speed);
+
+    if (statistic_name == "avg_rows_per_second")
+        return std::to_string(avg_rows_speed_value);
+
+    if (statistic_name == "avg_bytes_per_second")
+        return std::to_string(avg_bytes_speed_value);
+
+    return "";
+}
+
+
+void TestStats::update_min_time(UInt64 min_time_candidate)
+{
+    if (min_time_candidate < min_time)
+    {
+        min_time = min_time_candidate;
+        min_time_watch.restart();
+    }
+}
+
+void TestStats::update_max_speed(
+    size_t max_speed_candidate,
+    Stopwatch & max_speed_watch,
+    UInt64 & max_speed)
+{
+    if (max_speed_candidate > max_speed)
+    {
+        max_speed = max_speed_candidate;
+        max_speed_watch.restart();
+    }
+}
+
+
+void TestStats::update_average_speed(
+    double new_speed_info,
+    Stopwatch & avg_speed_watch,
+    size_t & number_of_info_batches,
+    double precision,
+    double & avg_speed_first,
+    double & avg_speed_value)
+{
+    avg_speed_value = ((avg_speed_value * number_of_info_batches) + new_speed_info);
+    ++number_of_info_batches;
+    avg_speed_value /= number_of_info_batches;
+
+    if (avg_speed_first == 0)
+    {
+        avg_speed_first = avg_speed_value;
+    }
+
+    if (std::abs(avg_speed_value - avg_speed_first) >= precision)
+    {
+        avg_speed_first = avg_speed_value;
+        avg_speed_watch.restart();
+    }
+}
+
+void TestStats::add(size_t rows_read_inc, size_t bytes_read_inc)
+{
+    total_rows_read += rows_read_inc;
+    total_bytes_read += bytes_read_inc;
+    last_query_rows_read += rows_read_inc;
+    last_query_bytes_read += bytes_read_inc;
+
+    double new_rows_speed = last_query_rows_read / watch_per_query.elapsedSeconds();
+    double new_bytes_speed = last_query_bytes_read / watch_per_query.elapsedSeconds();
+
+    /// Update rows speed
+    update_max_speed(new_rows_speed, max_rows_speed_watch, max_rows_speed);
+    update_average_speed(new_rows_speed,
+        avg_rows_speed_watch,
+        number_of_rows_speed_info_batches,
+        avg_rows_speed_precision,
+        avg_rows_speed_first,
+        avg_rows_speed_value);
+    /// Update bytes speed
+    update_max_speed(new_bytes_speed, max_bytes_speed_watch, max_bytes_speed);
+    update_average_speed(new_bytes_speed,
+        avg_bytes_speed_watch,
+        number_of_bytes_speed_info_batches,
+        avg_bytes_speed_precision,
+        avg_bytes_speed_first,
+        avg_bytes_speed_value);
+}
+
+void TestStats::updateQueryInfo()
+{
+    ++queries;
+    sampler.insert(watch_per_query.elapsedSeconds());
+    update_min_time(watch_per_query.elapsed() / (1000 * 1000)); /// ns to ms
+}
+
+
+TestStats::TestStats()
+{
+    watch.reset();
+    watch_per_query.reset();
+    min_time_watch.reset();
+    max_rows_speed_watch.reset();
+    max_bytes_speed_watch.reset();
+    avg_rows_speed_watch.reset();
+    avg_bytes_speed_watch.reset();
+}
+
+
+void TestStats::startWatches()
+{
+    watch.start();
+    watch_per_query.start();
+    min_time_watch.start();
+    max_rows_speed_watch.start();
+    max_bytes_speed_watch.start();
+    avg_rows_speed_watch.start();
+    avg_bytes_speed_watch.start();
+}
+
+}

dbms/programs/performance-test/TestStats.h

@@ -0,0 +1,87 @@
+#pragma once
+
+#include <Core/Types.h>
+#include <limits>
+#include <Common/Stopwatch.h>
+#include <AggregateFunctions/ReservoirSampler.h>
+
+namespace DB
+{
+struct TestStats
+{
+    TestStats();
+    Stopwatch watch;
+    Stopwatch watch_per_query;
+    Stopwatch min_time_watch;
+    Stopwatch max_rows_speed_watch;
+    Stopwatch max_bytes_speed_watch;
+    Stopwatch avg_rows_speed_watch;
+    Stopwatch avg_bytes_speed_watch;
+
+    bool last_query_was_cancelled = false;
+
+    size_t queries = 0;
+
+    size_t total_rows_read = 0;
+    size_t total_bytes_read = 0;
+
+    size_t last_query_rows_read = 0;
+    size_t last_query_bytes_read = 0;
+
+    using Sampler = ReservoirSampler<double>;
+    Sampler sampler{1 << 16};
+
+    /// min_time in ms
+    UInt64 min_time = std::numeric_limits<UInt64>::max();
+    double total_time = 0;
+
+    UInt64 max_rows_speed = 0;
+    UInt64 max_bytes_speed = 0;
+
+    double avg_rows_speed_value = 0;
+    double avg_rows_speed_first = 0;
+    static inline double avg_rows_speed_precision = 0.001;
+
+    double avg_bytes_speed_value = 0;
+    double avg_bytes_speed_first = 0;
+    static inline double avg_bytes_speed_precision = 0.001;
+
+    size_t number_of_rows_speed_info_batches = 0;
+    size_t number_of_bytes_speed_info_batches = 0;
+
+    bool ready = false; // check if a query wasn't interrupted by SIGINT
+    std::string exception;
+
+    /// Hack, actually this field doesn't required for statistics
+    bool got_SIGINT = false;
+
+    std::string getStatisticByName(const std::string & statistic_name);
+
+    void update_min_time(UInt64 min_time_candidate);
+
+    void update_average_speed(
+        double new_speed_info,
+        Stopwatch & avg_speed_watch,
+        size_t & number_of_info_batches,
+        double precision,
+        double & avg_speed_first,
+        double & avg_speed_value);
+
+    void update_max_speed(
+        size_t max_speed_candidate,
+        Stopwatch & max_speed_watch,
+        UInt64 & max_speed);
+
+    void add(size_t rows_read_inc, size_t bytes_read_inc);
+
+    void updateQueryInfo();
+
+    void setTotalTime()
+    {
+        total_time = watch.elapsedSeconds();
+    }
+
+    void startWatches();
+};
+
+}

dbms/programs/performance-test/TestStopConditions.cpp

@@ -0,0 +1,38 @@
+#include "TestStopConditions.h"
+
+namespace DB
+{
+
+void TestStopConditions::loadFromConfig(ConfigurationPtr & stop_conditions_config)
+{
+    if (stop_conditions_config->has("all_of"))
+    {
+        ConfigurationPtr config_all_of(stop_conditions_config->createView("all_of"));
+        conditions_all_of.loadFromConfig(config_all_of);
+    }
+    if (stop_conditions_config->has("any_of"))
+    {
+        ConfigurationPtr config_any_of(stop_conditions_config->createView("any_of"));
+        conditions_any_of.loadFromConfig(config_any_of);
+    }
+}
+
+bool TestStopConditions::areFulfilled() const
+{
+    return (conditions_all_of.initialized_count && conditions_all_of.fulfilled_count >= conditions_all_of.initialized_count)
+        || (conditions_any_of.initialized_count && conditions_any_of.fulfilled_count);
+}
+
+UInt64 TestStopConditions::getMaxExecTime() const
+{
+    UInt64 all_of_time = conditions_all_of.total_time_ms.value;
+    if (all_of_time == 0 && conditions_all_of.initialized_count != 0) /// max time is not set in all conditions
+        return 0;
+    else if(all_of_time != 0 && conditions_all_of.initialized_count > 1) /// max time is set, but we have other conditions
+        return 0;
+
+    UInt64 any_of_time = conditions_any_of.total_time_ms.value;
+    return std::max(all_of_time, any_of_time);
+}
+
+}

dbms/programs/performance-test/TestStopConditions.h

@@ -0,0 +1,57 @@
+#pragma once
+#include "StopConditionsSet.h"
+#include <Poco/Util/XMLConfiguration.h>
+
+namespace DB
+{
+/// Stop conditions for a test run. The running test will be terminated in either of two conditions:
+/// 1. All conditions marked 'all_of' are fulfilled
+/// or
+/// 2. Any condition  marked 'any_of' is  fulfilled
+
+using ConfigurationPtr = Poco::AutoPtr<Poco::Util::AbstractConfiguration>;
+
+class TestStopConditions
+{
+public:
+    void loadFromConfig(ConfigurationPtr & stop_conditions_config);
+    inline bool empty() const
+    {
+        return !conditions_all_of.initialized_count && !conditions_any_of.initialized_count;
+    }
+
+#define DEFINE_REPORT_FUNC(FUNC_NAME, CONDITION)                      \
+    void FUNC_NAME(UInt64 value)                                      \
+    {                                                                 \
+        conditions_all_of.report(value, conditions_all_of.CONDITION); \
+        conditions_any_of.report(value, conditions_any_of.CONDITION); \
+    }
+
+    DEFINE_REPORT_FUNC(reportTotalTime, total_time_ms)
+    DEFINE_REPORT_FUNC(reportRowsRead, rows_read)
+    DEFINE_REPORT_FUNC(reportBytesReadUncompressed, bytes_read_uncompressed)
+    DEFINE_REPORT_FUNC(reportIterations, iterations)
+    DEFINE_REPORT_FUNC(reportMinTimeNotChangingFor, min_time_not_changing_for_ms)
+    DEFINE_REPORT_FUNC(reportMaxSpeedNotChangingFor, max_speed_not_changing_for_ms)
+    DEFINE_REPORT_FUNC(reportAverageSpeedNotChangingFor, average_speed_not_changing_for_ms)
+
+#undef REPORT
+
+    bool areFulfilled() const;
+
+    void reset()
+    {
+        conditions_all_of.reset();
+        conditions_any_of.reset();
+    }
+
+    /// Return max exec time for these conditions
+    /// Return zero if max time cannot be determined
+    UInt64 getMaxExecTime() const;
+
+private:
+    StopConditionsSet conditions_all_of;
+    StopConditionsSet conditions_any_of;
+};
+
+}

dbms/programs/performance-test/applySubstitutions.cpp

@@ -0,0 +1,82 @@
+#include "applySubstitutions.h"
+#include <algorithm>
+#include <vector>
+
+namespace DB
+{
+
+void constructSubstitutions(ConfigurationPtr & substitutions_view, StringToVector & out_substitutions)
+{
+    Strings xml_substitutions;
+    substitutions_view->keys(xml_substitutions);
+
+    for (size_t i = 0; i != xml_substitutions.size(); ++i)
+    {
+        const ConfigurationPtr xml_substitution(substitutions_view->createView("substitution[" + std::to_string(i) + "]"));
+
+        /// Property values for substitution will be stored in a vector
+        /// accessible by property name
+        Strings xml_values;
+        xml_substitution->keys("values", xml_values);
+
+        std::string name = xml_substitution->getString("name");
+
+        for (size_t j = 0; j != xml_values.size(); ++j)
+        {
+            out_substitutions[name].push_back(xml_substitution->getString("values.value[" + std::to_string(j) + "]"));
+        }
+    }
+}
+
+/// Recursive method which goes through all substitution blocks in xml
+/// and replaces property {names} by their values
+void runThroughAllOptionsAndPush(StringToVector::iterator substitutions_left,
+    StringToVector::iterator substitutions_right,
+    const std::string & template_query,
+    Strings & out_queries)
+{
+    if (substitutions_left == substitutions_right)
+    {
+        out_queries.push_back(template_query); /// completely substituted query
+        return;
+    }
+
+    std::string substitution_mask = "{" + substitutions_left->first + "}";
+
+    if (template_query.find(substitution_mask) == std::string::npos) /// nothing to substitute here
+    {
+        runThroughAllOptionsAndPush(std::next(substitutions_left), substitutions_right, template_query, out_queries);
+        return;
+    }
+
+    for (const std::string & value : substitutions_left->second)
+    {
+        /// Copy query string for each unique permutation
+        std::string query = template_query;
+        size_t substr_pos = 0;
+
+        while (substr_pos != std::string::npos)
+        {
+            substr_pos = query.find(substitution_mask);
+
+            if (substr_pos != std::string::npos)
+                query.replace(substr_pos, substitution_mask.length(), value);
+        }
+
+        runThroughAllOptionsAndPush(std::next(substitutions_left), substitutions_right, query, out_queries);
+    }
+}
+
+Strings formatQueries(const std::string & query, StringToVector substitutions_to_generate)
+{
+    Strings queries_res;
+    runThroughAllOptionsAndPush(
+        substitutions_to_generate.begin(),
+        substitutions_to_generate.end(),
+        query,
+        queries_res);
+    return queries_res;
+}
+
+
+}

dbms/programs/performance-test/applySubstitutions.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <Poco/Util/XMLConfiguration.h>
+#include <Core/Types.h>
+#include <vector>
+#include <string>
+#include <map>
+
+namespace DB
+{
+
+using StringToVector = std::map<std::string, Strings>;
+using ConfigurationPtr = Poco::AutoPtr<Poco::Util::AbstractConfiguration>;
+
+void constructSubstitutions(ConfigurationPtr & substitutions_view, StringToVector & out_substitutions);
+
+Strings formatQueries(const std::string & query, StringToVector substitutions_to_generate);
+
+}

dbms/programs/performance-test/executeQuery.cpp

@@ -0,0 +1,73 @@
+#include "executeQuery.h"
+#include <IO/Progress.h>
+#include <DataStreams/RemoteBlockInputStream.h>
+#include <Core/Block.h>
+
+namespace DB
+{
+namespace
+{
+
+void checkFulfilledConditionsAndUpdate(
+    const Progress & progress, RemoteBlockInputStream & stream,
+    TestStats & statistics, TestStopConditions & stop_conditions,
+    InterruptListener & interrupt_listener)
+{
+    statistics.add(progress.rows, progress.bytes);
+
+    stop_conditions.reportRowsRead(statistics.total_rows_read);
+    stop_conditions.reportBytesReadUncompressed(statistics.total_bytes_read);
+    stop_conditions.reportTotalTime(statistics.watch.elapsed() / (1000 * 1000));
+    stop_conditions.reportMinTimeNotChangingFor(statistics.min_time_watch.elapsed() / (1000 * 1000));
+    stop_conditions.reportMaxSpeedNotChangingFor(statistics.max_rows_speed_watch.elapsed() / (1000 * 1000));
+    stop_conditions.reportAverageSpeedNotChangingFor(statistics.avg_rows_speed_watch.elapsed() / (1000 * 1000));
+
+    if (stop_conditions.areFulfilled())
+    {
+        statistics.last_query_was_cancelled = true;
+        stream.cancel(false);
+    }
+
+    if (interrupt_listener.check())
+    {
+        statistics.got_SIGINT = true;
+        statistics.last_query_was_cancelled = true;
+        stream.cancel(false);
+    }
+}
+
+}
+
+void executeQuery(
+    Connection & connection,
+    const std::string & query,
+    TestStats & statistics,
+    TestStopConditions & stop_conditions,
+    InterruptListener & interrupt_listener,
+    Context & context,
+    const Settings & settings)
+{
+    statistics.watch_per_query.restart();
+    statistics.last_query_was_cancelled = false;
+    statistics.last_query_rows_read = 0;
+    statistics.last_query_bytes_read = 0;
+
+    RemoteBlockInputStream stream(connection, query, {}, context, &settings);
+
+    stream.setProgressCallback(
+        [&](const Progress & value)
+        {
+            checkFulfilledConditionsAndUpdate(
+                value, stream, statistics,
+                stop_conditions, interrupt_listener);
+        });
+    stream.readPrefix();
+    while (Block block = stream.read());
+    stream.readSuffix();
+
+    if (!statistics.last_query_was_cancelled)
+        statistics.updateQueryInfo();
+
+    statistics.setTotalTime();
+}
+}

dbms/programs/performance-test/executeQuery.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <string>
+#include "TestStats.h"
+#include "TestStopConditions.h"
+#include <Common/InterruptListener.h>
+#include <Interpreters/Context.h>
+#include <Interpreters/Settings.h>
+#include <Client/Connection.h>
+
+namespace DB
+{
+void executeQuery(
+    Connection & connection,
+    const std::string & query,
+    TestStats & statistics,
+    TestStopConditions & stop_conditions,
+    InterruptListener & interrupt_listener,
+    Context & context,
+    const Settings & settings);
+}

dbms/programs/server/HTTPHandler.cpp

@@ -4,6 +4,7 @@
 #include <Poco/File.h>
 #include <Poco/Net/HTTPBasicCredentials.h>
 #include <Poco/Net/HTTPServerRequest.h>
+#include <Poco/Net/HTTPServerRequestImpl.h>
 #include <Poco/Net/HTTPServerResponse.h>
 #include <Poco/Net/NetException.h>
 
@@ -15,12 +16,11 @@
 #include <Common/getFQDNOrHostName.h>
 #include <Common/CurrentThread.h>
 #include <Common/setThreadName.h>
+#include <Compression/CompressedReadBuffer.h>
+#include <Compression/CompressedWriteBuffer.h>
 #include <IO/ReadBufferFromIStream.h>
 #include <IO/ZlibInflatingReadBuffer.h>
 #include <IO/ReadBufferFromString.h>
-#include <IO/ConcatReadBuffer.h>
-#include <Compression/CompressedReadBuffer.h>
-#include <Compression/CompressedWriteBuffer.h>
 #include <IO/WriteBufferFromString.h>
 #include <IO/WriteBufferFromHTTPServerResponse.h>
 #include <IO/WriteBufferFromFile.h>
@@ -558,12 +558,51 @@ void HTTPHandler::processQuery(
     client_info.http_method = http_method;
     client_info.http_user_agent = request.get("User-Agent", "");
 
+    auto appendCallback = [&context] (ProgressCallback callback)
+    {
+        auto prev = context.getProgressCallback();
+
+        context.setProgressCallback([prev, callback] (const Progress & progress)
+        {
+            if (prev)
+                prev(progress);
+
+            callback(progress);
+        });
+    };
+
     /// While still no data has been sent, we will report about query execution progress by sending HTTP headers.
     if (settings.send_progress_in_http_headers)
-        context.setProgressCallback([&used_output] (const Progress & progress) { used_output.out->onProgress(progress); });
+        appendCallback([&used_output] (const Progress & progress) { used_output.out->onProgress(progress); });
+
+    if (settings.readonly > 0 && settings.cancel_http_readonly_queries_on_client_close)
+    {
+        Poco::Net::StreamSocket & socket = dynamic_cast<Poco::Net::HTTPServerRequestImpl &>(request).socket();
+
+        appendCallback([&context, &socket](const Progress &)
+        {
+            /// Assume that at the point this method is called no one is reading data from the socket any more.
+            /// True for read-only queries.
+            try
+            {
+                char b;
+                int status = socket.receiveBytes(&b, 1, MSG_DONTWAIT | MSG_PEEK);
+                if (status == 0)
+                    context.killCurrentQuery();
+            }
+            catch (Poco::TimeoutException &)
+            {
+            }
+            catch (...)
+            {
+                context.killCurrentQuery();
+            }
+        });
+    }
 
     executeQuery(*in, *used_output.out_maybe_delayed_and_compressed, /* allow_into_outfile = */ false, context,
-        [&response] (const String & content_type) { response.setContentType(content_type); });
+        [&response] (const String & content_type) { response.setContentType(content_type); },
+        [&response] (const String & current_query_id) { response.add("Query-Id", current_query_id); });
 
     if (used_output.hasDelayed())
     {
@@ -647,6 +686,7 @@ void HTTPHandler::trySendExceptionToClient(const std::string & s, int exception_
 void HTTPHandler::handleRequest(Poco::Net::HTTPServerRequest & request, Poco::Net::HTTPServerResponse & response)
 {
     setThreadName("HTTPHandler");
+    ThreadStatus thread_status;
 
     Output used_output;
 

dbms/programs/server/MetricsTransmitter.cpp

@@ -41,7 +41,7 @@ void MetricsTransmitter::run()
     const auto & config = context.getConfigRef();
     auto interval = config.getInt(config_name + ".interval", 60);
 
-    const std::string thread_name = "MericsTrns " + std::to_string(interval) + "s";
+    const std::string thread_name = "MetrTx" + std::to_string(interval);
     setThreadName(thread_name.c_str());
 
     const auto get_next_time = [](size_t seconds)

dbms/programs/server/MetricsTransmitter.h

@@ -6,6 +6,7 @@
 #include <thread>
 #include <vector>
 #include <Common/ProfileEvents.h>
+#include <Common/ThreadPool.h>
 
 
 namespace DB
@@ -46,7 +47,7 @@ private:
     bool quit = false;
     std::mutex mutex;
     std::condition_variable cond;
-    std::thread thread{&MetricsTransmitter::run, this};
+    ThreadFromGlobalPool thread{&MetricsTransmitter::run, this};
 
     static constexpr auto profile_events_path_prefix = "ClickHouse.ProfileEvents.";
     static constexpr auto current_metrics_path_prefix = "ClickHouse.Metrics.";

dbms/programs/server/Server.cpp

@@ -11,6 +11,7 @@
 #include <Poco/DirectoryIterator.h>
 #include <Poco/Net/HTTPServer.h>
 #include <Poco/Net/NetException.h>
+#include <Poco/Util/HelpFormatter.h>
 #include <ext/scope_guard.h>
 #include <common/logger_useful.h>
 #include <common/ErrorHandlers.h>
@@ -27,6 +28,7 @@
 #include <Common/getMultipleKeysFromConfig.h>
 #include <Common/getNumberOfPhysicalCPUCores.h>
 #include <Common/TaskStatsInfoGetter.h>
+#include <Common/ThreadStatus.h>
 #include <IO/HTTPCommon.h>
 #include <IO/UseSSL.h>
 #include <Interpreters/AsynchronousMetrics.h>
@@ -46,6 +48,7 @@
 #include "MetricsTransmitter.h"
 #include <Common/StatusFile.h>
 #include "TCPHandlerFactory.h"
+#include "Common/config_version.h"
 
 #if defined(__linux__)
 #include <Common/hasLinuxCapability.h>
@@ -115,6 +118,26 @@ void Server::uninitialize()
     BaseDaemon::uninitialize();
 }
 
+int Server::run()
+{
+    if (config().hasOption("help"))
+    {
+        Poco::Util::HelpFormatter helpFormatter(Server::options());
+        std::stringstream header;
+        header << commandName() << " [OPTION] [-- [ARG]...]\n";
+        header << "positional arguments can be used to rewrite config.xml properties, for example, --http_port=8010";
+        helpFormatter.setHeader(header.str());
+        helpFormatter.format(std::cout);
+        return 0;
+    }
+    if (config().hasOption("version"))
+    {
+        std::cout << DBMS_NAME << " server version " << VERSION_STRING << "." << std::endl;
+        return 0;
+    }
+    return Application::run();
+}
+
 void Server::initialize(Poco::Util::Application & self)
 {
     BaseDaemon::initialize(self);
@@ -126,12 +149,28 @@ std::string Server::getDefaultCorePath() const
     return getCanonicalPath(config().getString("path", DBMS_DEFAULT_PATH)) + "cores";
 }
 
+void Server::defineOptions(Poco::Util::OptionSet & _options)
+{
+    _options.addOption(
+        Poco::Util::Option("help", "h", "show help and exit")
+            .required(false)
+            .repeatable(false)
+            .binding("help"));
+    _options.addOption(
+        Poco::Util::Option("version", "V", "show version and exit")
+            .required(false)
+            .repeatable(false)
+            .binding("version"));
+    BaseDaemon::defineOptions(_options);
+}
+
 int Server::main(const std::vector<std::string> & /*args*/)
 {
     Logger * log = &logger();
-
     UseSSL use_ssl;
 
+    ThreadStatus thread_status;
+
     registerFunctions();
     registerAggregateFunctions();
     registerTableFunctions();
@@ -396,19 +435,37 @@ int Server::main(const std::vector<std::string> & /*args*/)
     if (config().has("max_partition_size_to_drop"))
         global_context->setMaxPartitionSizeToDrop(config().getUInt64("max_partition_size_to_drop"));
 
+    /// Set up caches.
+
+    /// Lower cache size on low-memory systems.
+    double cache_size_to_ram_max_ratio = config().getDouble("cache_size_to_ram_max_ratio", 0.5);
+    size_t max_cache_size = memory_amount * cache_size_to_ram_max_ratio;
+
     /// Size of cache for uncompressed blocks. Zero means disabled.
     size_t uncompressed_cache_size = config().getUInt64("uncompressed_cache_size", 0);
-    if (uncompressed_cache_size)
+    if (uncompressed_cache_size > max_cache_size)
-        global_context->setUncompressedCache(uncompressed_cache_size);
+    {
+        uncompressed_cache_size = max_cache_size;
+        LOG_INFO(log, "Uncompressed cache size was lowered to " << formatReadableSizeWithBinarySuffix(uncompressed_cache_size)
+            << " because the system has low amount of memory");
+    }
+    global_context->setUncompressedCache(uncompressed_cache_size);
 
     /// Load global settings from default_profile and system_profile.
     global_context->setDefaultProfiles(config());
     Settings & settings = global_context->getSettingsRef();
 
-    /// Size of cache for marks (index of MergeTree family of tables). It is necessary.
+    /// Size of cache for marks (index of MergeTree family of tables). It is mandatory.
     size_t mark_cache_size = config().getUInt64("mark_cache_size");
-    if (mark_cache_size)
+    if (!mark_cache_size)
-        global_context->setMarkCache(mark_cache_size);
+        LOG_ERROR(log, "Too low mark cache size will lead to severe performance degradation.");
+    if (mark_cache_size > max_cache_size)
+    {
+        mark_cache_size = max_cache_size;
+        LOG_INFO(log, "Mark cache size was lowered to " << formatReadableSizeWithBinarySuffix(uncompressed_cache_size)
+            << " because the system has low amount of memory");
+    }
+    global_context->setMarkCache(mark_cache_size);
 
 #if USE_EMBEDDED_COMPILER
     size_t compiled_expression_cache_size = config().getUInt64("compiled_expression_cache_size", 500);
@@ -418,7 +475,7 @@ int Server::main(const std::vector<std::string> & /*args*/)
 
     /// Set path for format schema files
     auto format_schema_path = Poco::File(config().getString("format_schema_path", path + "format_schemas/"));
-    global_context->setFormatSchemaPath(format_schema_path.path() + "/");
+    global_context->setFormatSchemaPath(format_schema_path.path());
     format_schema_path.createDirectories();
 
     LOG_INFO(log, "Loading metadata.");
@@ -695,10 +752,10 @@ int Server::main(const std::vector<std::string> & /*args*/)
 
         {
             std::stringstream message;
-            message << "Available RAM = " << formatReadableSizeWithBinarySuffix(memory_amount) << ";"
+            message << "Available RAM: " << formatReadableSizeWithBinarySuffix(memory_amount) << ";"
-                << " physical cores = " << getNumberOfPhysicalCPUCores() << ";"
+                << " physical cores: " << getNumberOfPhysicalCPUCores() << ";"
                 // on ARM processors it can show only enabled at current moment cores
-                << " threads = " << std::thread::hardware_concurrency() << ".";
+                << " logical cores: " << std::thread::hardware_concurrency() << ".";
             LOG_INFO(log, message.str());
         }
 

dbms/programs/server/Server.h

@@ -21,6 +21,8 @@ namespace DB
 class Server : public BaseDaemon, public IServer
 {
 public:
+    using ServerApplication::run;
+
     Poco::Util::LayeredConfiguration & config() const override
     {
         return BaseDaemon::config();
@@ -41,7 +43,10 @@ public:
         return BaseDaemon::isCancelled();
     }
 
+    void defineOptions(Poco::Util::OptionSet & _options) override;
 protected:
+    int run() override;
+
     void initialize(Application & self) override;
 
     void uninitialize() override;

dbms/programs/server/TCPHandler.cpp

@@ -6,8 +6,6 @@
 #include <Common/ClickHouseRevision.h>
 #include <Common/CurrentThread.h>
 #include <Common/Stopwatch.h>
-#include <Common/ClickHouseRevision.h>
-#include <Common/Stopwatch.h>
 #include <Common/NetException.h>
 #include <Common/setThreadName.h>
 #include <Common/config_version.h>
@@ -55,6 +53,7 @@ namespace ErrorCodes
 void TCPHandler::runImpl()
 {
     setThreadName("TCPHandler");
+    ThreadStatus thread_status;
 
     connection_context = server.context();
     connection_context.setSessionContext(connection_context);
@@ -301,10 +300,10 @@ void TCPHandler::runImpl()
 
 void TCPHandler::readData(const Settings & global_settings)
 {
-    auto receive_timeout = query_context.getSettingsRef().receive_timeout.value;
+    const auto receive_timeout = query_context.getSettingsRef().receive_timeout.value;
 
     /// Poll interval should not be greater than receive_timeout
-    size_t default_poll_interval = global_settings.poll_interval.value * 1000000;
+    const size_t default_poll_interval = global_settings.poll_interval.value * 1000000;
     size_t current_poll_interval = static_cast<size_t>(receive_timeout.totalMicroseconds());
     constexpr size_t min_poll_interval = 5000; // 5 ms
     size_t poll_interval = std::max(min_poll_interval, std::min(default_poll_interval, current_poll_interval));
@@ -408,7 +407,7 @@ void TCPHandler::processOrdinaryQuery()
                 }
                 else
                 {
-                    if (state.progress.rows && after_send_progress.elapsed() / 1000 >= query_context.getSettingsRef().interactive_delay)
+                    if (after_send_progress.elapsed() / 1000 >= query_context.getSettingsRef().interactive_delay)
                     {
                         /// Some time passed and there is a progress.
                         after_send_progress.restart();

dbms/programs/server/config.d/listen.xml

@@ -1 +0,0 @@
-<yandex><listen_host>0.0.0.0</listen_host></yandex>

dbms/programs/server/config.d/zookeeper.xml

@@ -1,16 +1,8 @@
 <yandex>
-    <zookeeper>
+<!--    <zookeeper>
         <node>
             <host>localhost</host>
             <port>2181</port>
         </node>
-        <node>
+    </zookeeper>-->
-            <host>yandex.ru</host>
-            <port>2181</port>
-        </node>
-        <node>
-            <host>111.0.1.2</host>
-            <port>2181</port>
-        </node>
-    </zookeeper>
 </yandex>

dbms/src/AggregateFunctions/AggregateFunctionCount.h

@@ -1,12 +1,12 @@
 #pragma once
 
 #include <IO/VarInt.h>
+#include <IO/WriteHelpers.h>
 
 #include <array>
 #include <DataTypes/DataTypesNumber.h>
 #include <Columns/ColumnNullable.h>
 #include <AggregateFunctions/IAggregateFunction.h>
-#include <IO/WriteHelpers.h>
 
 
 namespace DB

dbms/src/AggregateFunctions/AggregateFunctionEntropy.cpp

@@ -0,0 +1,44 @@
+#include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <AggregateFunctions/AggregateFunctionEntropy.h>
+#include <AggregateFunctions/FactoryHelpers.h>
+#include <AggregateFunctions/Helpers.h>
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+    extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH;
+}
+
+namespace
+{
+
+AggregateFunctionPtr createAggregateFunctionEntropy(const std::string & name, const DataTypes & argument_types, const Array & parameters)
+{
+    assertNoParameters(name, parameters);
+    if (argument_types.empty())
+        throw Exception("Incorrect number of arguments for aggregate function " + name,
+                        ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
+
+    size_t num_args = argument_types.size();
+    if (num_args == 1)
+    {
+        /// Specialized implementation for single argument of numeric type.
+        if (auto res = createWithNumericBasedType<AggregateFunctionEntropy>(*argument_types[0], num_args))
+            return AggregateFunctionPtr(res);
+    }
+
+    /// Generic implementation for other types or for multiple arguments.
+    return std::make_shared<AggregateFunctionEntropy<UInt128>>(num_args);
+}
+
+}
+
+void registerAggregateFunctionEntropy(AggregateFunctionFactory & factory)
+{
+    factory.registerFunction("entropy", createAggregateFunctionEntropy);
+}
+
+}

dbms/src/AggregateFunctions/AggregateFunctionEntropy.h

@@ -0,0 +1,149 @@
+#pragma once
+
+#include <Common/HashTable/HashMap.h>
+#include <Common/NaNUtils.h>
+
+#include <AggregateFunctions/IAggregateFunction.h>
+#include <AggregateFunctions/UniqVariadicHash.h>
+#include <DataTypes/DataTypesNumber.h>
+#include <Columns/ColumnVector.h>
+
+#include <cmath>
+
+
+namespace DB
+{
+
+/** Calculates Shannon Entropy, using HashMap and computing empirical distribution function.
+  * Entropy is measured in bits (base-2 logarithm is used).
+  */
+template <typename Value>
+struct EntropyData
+{
+    using Weight = UInt64;
+
+    using HashingMap = HashMap<
+        Value, Weight,
+        HashCRC32<Value>,
+        HashTableGrower<4>,
+        HashTableAllocatorWithStackMemory<sizeof(std::pair<Value, Weight>) * (1 << 3)>>;
+
+    /// For the case of pre-hashed values.
+    using TrivialMap = HashMap<
+        Value, Weight,
+        UInt128TrivialHash,
+        HashTableGrower<4>,
+        HashTableAllocatorWithStackMemory<sizeof(std::pair<Value, Weight>) * (1 << 3)>>;
+
+    using Map = std::conditional_t<std::is_same_v<UInt128, Value>, TrivialMap, HashingMap>;
+
+    Map map;
+
+    void add(const Value & x)
+    {
+        if (!isNaN(x))
+            ++map[x];
+    }
+
+    void add(const Value & x, const Weight & weight)
+    {
+        if (!isNaN(x))
+            map[x] += weight;
+    }
+
+    void merge(const EntropyData & rhs)
+    {
+        for (const auto & pair : rhs.map)
+            map[pair.first] += pair.second;
+    }
+
+    void serialize(WriteBuffer & buf) const
+    {
+        map.write(buf);
+    }
+
+    void deserialize(ReadBuffer & buf)
+    {
+        typename Map::Reader reader(buf);
+        while (reader.next())
+        {
+            const auto & pair = reader.get();
+            map[pair.first] = pair.second;
+        }
+    }
+
+    Float64 get() const
+    {
+        UInt64 total_value = 0;
+        for (const auto & pair : map)
+            total_value += pair.second;
+
+        Float64 shannon_entropy = 0;
+        for (const auto & pair : map)
+        {
+            Float64 frequency = Float64(pair.second) / total_value;
+            shannon_entropy -= frequency * log2(frequency);
+        }
+
+        return shannon_entropy;
+    }
+};
+
+
+template <typename Value>
+class AggregateFunctionEntropy final : public IAggregateFunctionDataHelper<EntropyData<Value>, AggregateFunctionEntropy<Value>>
+{
+private:
+    size_t num_args;
+
+public:
+    AggregateFunctionEntropy(size_t num_args) : num_args(num_args)
+    {
+    }
+
+    String getName() const override { return "entropy"; }
+
+    DataTypePtr getReturnType() const override
+    {
+        return std::make_shared<DataTypeNumber<Float64>>();
+    }
+
+    void add(AggregateDataPtr place, const IColumn ** columns, size_t row_num, Arena *) const override
+    {
+        if constexpr (!std::is_same_v<UInt128, Value>)
+        {
+            /// Here we manage only with numerical types
+            const auto & column = static_cast<const ColumnVector <Value> &>(*columns[0]);
+            this->data(place).add(column.getData()[row_num]);
+        }
+        else
+        {
+            this->data(place).add(UniqVariadicHash<true, false>::apply(num_args, columns, row_num));
+        }
+    }
+
+    void merge(AggregateDataPtr place, ConstAggregateDataPtr rhs, Arena *) const override
+    {
+        this->data(place).merge(this->data(rhs));
+    }
+
+    void serialize(ConstAggregateDataPtr place, WriteBuffer & buf) const override
+    {
+        this->data(const_cast<AggregateDataPtr>(place)).serialize(buf);
+    }
+
+    void deserialize(AggregateDataPtr place, ReadBuffer & buf, Arena *) const override
+    {
+        this->data(place).deserialize(buf);
+    }
+
+    void insertResultInto(ConstAggregateDataPtr place, IColumn & to) const override
+    {
+        auto & column = static_cast<ColumnVector<Float64> &>(to);
+        column.getData().push_back(this->data(place).get());
+    }
+
+    const char * getHeaderFilePath() const override { return __FILE__; }
+};
+
+}

dbms/src/AggregateFunctions/AggregateFunctionFactory.cpp

@@ -5,15 +5,17 @@
 #include <DataTypes/DataTypeArray.h>
 #include <DataTypes/DataTypeNullable.h>
 #include <DataTypes/DataTypesNumber.h>
+#include <DataTypes/DataTypeLowCardinality.h>
+
 #include <IO/WriteBuffer.h>
 #include <IO/WriteHelpers.h>
+
 #include <Interpreters/Context.h>
 
 #include <Common/StringUtils/StringUtils.h>
 #include <Common/typeid_cast.h>
 
 #include <Poco/String.h>
-#include <DataTypes/DataTypeLowCardinality.h>
 
 
 namespace DB
@@ -128,7 +130,11 @@ AggregateFunctionPtr AggregateFunctionFactory::getImpl(
         return combinator->transformAggregateFunction(nested_function, argument_types, parameters);
     }
 
-    throw Exception("Unknown aggregate function " + name, ErrorCodes::UNKNOWN_AGGREGATE_FUNCTION);
+    auto hints = this->getHints(name);
+    if (!hints.empty())
+        throw Exception("Unknown aggregate function " + name + ". Maybe you meant: " + toString(hints), ErrorCodes::UNKNOWN_AGGREGATE_FUNCTION);
+    else
+        throw Exception("Unknown aggregate function " + name, ErrorCodes::UNKNOWN_AGGREGATE_FUNCTION);
 }
 
 

dbms/src/AggregateFunctions/AggregateFunctionHistogram.h

@@ -13,6 +13,8 @@
 
 #include <IO/WriteBuffer.h>
 #include <IO/ReadBuffer.h>
+#include <IO/WriteHelpers.h>
+#include <IO/ReadHelpers.h>
 #include <IO/VarInt.h>
 
 #include <AggregateFunctions/IAggregateFunction.h>
@@ -268,15 +270,13 @@ public:
         lower_bound = std::min(lower_bound, other.lower_bound);
         upper_bound = std::max(lower_bound, other.upper_bound);
         for (size_t i = 0; i < other.size; i++)
-        {
             add(other.points[i].mean, other.points[i].weight, max_bins);
-        }
     }
 
     void write(WriteBuffer & buf) const
     {
-        buf.write(reinterpret_cast<const char *>(&lower_bound), sizeof(lower_bound));
+        writeBinary(lower_bound, buf);
-        buf.write(reinterpret_cast<const char *>(&upper_bound), sizeof(upper_bound));
+        writeBinary(upper_bound, buf);
 
         writeVarUInt(size, buf);
         buf.write(reinterpret_cast<const char *>(points), size * sizeof(WeightedValue));
@@ -284,11 +284,10 @@ public:
 
     void read(ReadBuffer & buf, UInt32 max_bins)
     {
-        buf.read(reinterpret_cast<char *>(&lower_bound), sizeof(lower_bound));
+        readBinary(lower_bound, buf);
-        buf.read(reinterpret_cast<char *>(&upper_bound), sizeof(upper_bound));
+        readBinary(upper_bound, buf);
 
         readVarUInt(size, buf);
-
         if (size > max_bins * 2)
             throw Exception("Too many bins", ErrorCodes::TOO_LARGE_ARRAY_SIZE);
 

dbms/src/AggregateFunctions/AggregateFunctionMerge.h

@@ -3,7 +3,6 @@
 #include <DataTypes/DataTypeAggregateFunction.h>
 #include <AggregateFunctions/IAggregateFunction.h>
 #include <Columns/ColumnAggregateFunction.h>
-#include <DataTypes/DataTypeAggregateFunction.h>
 #include <Common/typeid_cast.h>
 
 

dbms/src/AggregateFunctions/AggregateFunctionQuantile.cpp

@@ -41,7 +41,7 @@ template <typename T> using FuncQuantilesTDigestWeighted = AggregateFunctionQuan
 
 
 template <template <typename> class Function>
-static constexpr bool SupportDecimal()
+static constexpr bool supportDecimal()
 {
     return std::is_same_v<Function<Float32>, FuncQuantileExact<Float32>> ||
         std::is_same_v<Function<Float32>, FuncQuantilesExact<Float32>>;
@@ -61,11 +61,10 @@ AggregateFunctionPtr createAggregateFunctionQuantile(const std::string & name, c
     if (which.idx == TypeIndex::TYPE) return std::make_shared<Function<TYPE>>(argument_type, params);
     FOR_NUMERIC_TYPES(DISPATCH)
 #undef DISPATCH
-#undef FOR_NUMERIC_TYPES
     if (which.idx == TypeIndex::Date) return std::make_shared<Function<DataTypeDate::FieldType>>(argument_type, params);
     if (which.idx == TypeIndex::DateTime) return std::make_shared<Function<DataTypeDateTime::FieldType>>(argument_type, params);
 
-    if constexpr (SupportDecimal<Function>())
+    if constexpr (supportDecimal<Function>())
     {
         if (which.idx == TypeIndex::Decimal32) return std::make_shared<Function<Decimal32>>(argument_type, params);
         if (which.idx == TypeIndex::Decimal64) return std::make_shared<Function<Decimal64>>(argument_type, params);

dbms/src/AggregateFunctions/AggregateFunctionSumMap.cpp

@@ -12,6 +12,37 @@ namespace DB
 namespace
 {
 
+struct WithOverflowPolicy
+{
+    /// Overflow, meaning that the returned type is the same as the input type.
+    static DataTypePtr promoteType(const DataTypePtr & data_type) { return data_type; }
+};
+
+struct WithoutOverflowPolicy
+{
+    /// No overflow, meaning we promote the types if necessary.
+    static DataTypePtr promoteType(const DataTypePtr & data_type)
+    {
+        if (!data_type->canBePromoted())
+            throw new Exception{"Values to be summed are expected to be Numeric, Float or Decimal.",
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT};
+
+        return data_type->promoteNumericType();
+    }
+};
+
+template <typename T>
+using SumMapWithOverflow = AggregateFunctionSumMap<T, WithOverflowPolicy>;
+
+template <typename T>
+using SumMapWithoutOverflow = AggregateFunctionSumMap<T, WithoutOverflowPolicy>;
+
+template <typename T>
+using SumMapFilteredWithOverflow = AggregateFunctionSumMapFiltered<T, WithOverflowPolicy>;
+
+template <typename T>
+using SumMapFilteredWithoutOverflow = AggregateFunctionSumMapFiltered<T, WithoutOverflowPolicy>;
+
 using SumMapArgs = std::pair<DataTypePtr, DataTypes>;
 
 SumMapArgs parseArguments(const std::string & name, const DataTypes & arguments)
@@ -42,21 +73,23 @@ SumMapArgs parseArguments(const std::string & name, const DataTypes & arguments)
     return  {std::move(keys_type), std::move(values_types)};
 }
 
+template <template <typename> class Function>
 AggregateFunctionPtr createAggregateFunctionSumMap(const std::string & name, const DataTypes & arguments, const Array & params)
 {
     assertNoParameters(name, params);
 
     auto [keys_type, values_types] = parseArguments(name, arguments);
 
-    AggregateFunctionPtr res(createWithNumericBasedType<AggregateFunctionSumMap>(*keys_type, keys_type, values_types));
+    AggregateFunctionPtr res(createWithNumericBasedType<Function>(*keys_type, keys_type, values_types));
     if (!res)
-        res.reset(createWithDecimalType<AggregateFunctionSumMap>(*keys_type, keys_type, values_types));
+        res.reset(createWithDecimalType<Function>(*keys_type, keys_type, values_types));
     if (!res)
         throw Exception("Illegal type of argument for aggregate function " + name, ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
     return res;
 }
 
+template <template <typename> class Function>
 AggregateFunctionPtr createAggregateFunctionSumMapFiltered(const std::string & name, const DataTypes & arguments, const Array & params)
 {
     if (params.size() != 1)
@@ -70,9 +103,9 @@ AggregateFunctionPtr createAggregateFunctionSumMapFiltered(const std::string & n
 
     auto [keys_type, values_types] = parseArguments(name, arguments);
 
-    AggregateFunctionPtr res(createWithNumericBasedType<AggregateFunctionSumMapFiltered>(*keys_type, keys_type, values_types, keys_to_keep));
+    AggregateFunctionPtr res(createWithNumericBasedType<Function>(*keys_type, keys_type, values_types, keys_to_keep));
     if (!res)
-        res.reset(createWithDecimalType<AggregateFunctionSumMapFiltered>(*keys_type, keys_type, values_types, keys_to_keep));
+        res.reset(createWithDecimalType<Function>(*keys_type, keys_type, values_types, keys_to_keep));
     if (!res)
         throw Exception("Illegal type of argument for aggregate function " + name, ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT);
 
@@ -82,8 +115,10 @@ AggregateFunctionPtr createAggregateFunctionSumMapFiltered(const std::string & n
 
 void registerAggregateFunctionSumMap(AggregateFunctionFactory & factory)
 {
-    factory.registerFunction("sumMap", createAggregateFunctionSumMap);
+    factory.registerFunction("sumMap", createAggregateFunctionSumMap<SumMapWithoutOverflow>);
-    factory.registerFunction("sumMapFiltered", createAggregateFunctionSumMapFiltered);
+    factory.registerFunction("sumMapWithOverflow", createAggregateFunctionSumMap<SumMapWithOverflow>);
+    factory.registerFunction("sumMapFiltered", createAggregateFunctionSumMapFiltered<SumMapFilteredWithoutOverflow>);
+    factory.registerFunction("sumMapFilteredWithOverflow", createAggregateFunctionSumMapFiltered<SumMapFilteredWithOverflow>);
 }
 
 }