From b9931863eff3b528109b89d94a555ed81575cc07 Mon Sep 17 00:00:00 2001 From: Avogar Date: Mon, 13 Apr 2020 00:01:17 +0300 Subject: [PATCH 01/73] Fix FixedString packing --- src/Processors/Formats/Impl/MsgPackRowOutputFormat.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/Processors/Formats/Impl/MsgPackRowOutputFormat.cpp b/src/Processors/Formats/Impl/MsgPackRowOutputFormat.cpp index 7c5e2c5b522..cef7b001505 100644 --- a/src/Processors/Formats/Impl/MsgPackRowOutputFormat.cpp +++ b/src/Processors/Formats/Impl/MsgPackRowOutputFormat.cpp @@ -85,7 +85,6 @@ void MsgPackRowOutputFormat::serializeField(const IColumn & column, DataTypePtr packer.pack_uint64(assert_cast(column).getElement(row_num)); return; } - case TypeIndex::FixedString: [[fallthrough]]; case TypeIndex::String: { const StringRef & string = assert_cast(column).getDataAt(row_num); @@ -93,6 +92,13 @@ void MsgPackRowOutputFormat::serializeField(const IColumn & column, DataTypePtr packer.pack_str_body(string.data, string.size); return; } + case TypeIndex::FixedString: + { + const StringRef & string = assert_cast(column).getDataAt(row_num); + packer.pack_str(string.size); + packer.pack_str_body(string.data, string.size); + return; + } case TypeIndex::Array: { auto nested_type = assert_cast(*data_type).getNestedType(); From d49dc5c008cbd3802dd35066f4607e5f3e21fde9 Mon Sep 17 00:00:00 2001 From: Avogar Date: Mon, 13 Apr 2020 00:16:27 +0300 Subject: [PATCH 02/73] Add test --- tests/queries/0_stateless/01098_msgpack_format.reference | 3 +++ tests/queries/0_stateless/01098_msgpack_format.sh | 8 ++++++++ 2 files changed, 11 insertions(+) diff --git a/tests/queries/0_stateless/01098_msgpack_format.reference b/tests/queries/0_stateless/01098_msgpack_format.reference index 8059526a38f..ad116a5ba91 100644 --- a/tests/queries/0_stateless/01098_msgpack_format.reference +++ b/tests/queries/0_stateless/01098_msgpack_format.reference @@ -8,3 +8,6 @@ [[1,2,3],[1001,2002],[3167]] [[['one'],['two']],[['three']],[['four'],['five']]] [0,1,2,3,42,253,254,255] [255,254,253,42,3,2,1,0] +2020-01-01 +2020-01-02 +2020-01-02 diff --git a/tests/queries/0_stateless/01098_msgpack_format.sh b/tests/queries/0_stateless/01098_msgpack_format.sh index afebd6de3dc..233399570bb 100755 --- a/tests/queries/0_stateless/01098_msgpack_format.sh +++ b/tests/queries/0_stateless/01098_msgpack_format.sh @@ -52,3 +52,11 @@ $CLICKHOUSE_CLIENT --query="SELECT * FROM msgpack"; $CLICKHOUSE_CLIENT --query="DROP TABLE msgpack"; +$CLICKHOUSE_CLIENT --query="CREATE TABLE msgpack (date FixedString(10)) ENGINE = Memory"; + +$CLICKHOUSE_CLIENT --query="INSERT INTO msgpack VALUES ('2020-01-01'), ('2020-01-02'), ('2020-01-02')"; + +$CLICKHOUSE_CLIENT --query="SELECT * FROM msgpack"; + +$CLICKHOUSE_CLIENT --query="DROP TABLE msgpack"; + From 9860ffee5189189b7285dc5641c92c35bae49591 Mon Sep 17 00:00:00 2001 From: Avogar Date: Mon, 13 Apr 2020 00:59:28 +0300 Subject: [PATCH 03/73] Add MsgPack performance test --- tests/performance/parse_engine_file.xml | 1 + tests/performance/select_format.xml | 1 + 2 files changed, 2 insertions(+) diff --git a/tests/performance/parse_engine_file.xml b/tests/performance/parse_engine_file.xml index fb10fa97915..c96f4e537ff 100644 --- a/tests/performance/parse_engine_file.xml +++ b/tests/performance/parse_engine_file.xml @@ -34,6 +34,7 @@ RowBinary Native Avro + MsgPack diff --git a/tests/performance/select_format.xml b/tests/performance/select_format.xml index b8df874304f..e47d981c4d7 100644 --- a/tests/performance/select_format.xml +++ b/tests/performance/select_format.xml @@ -44,6 +44,7 @@ ODBCDriver2 MySQLWire Avro + MsgPack From 910ab8a26567e0e440d73549eeb10808bc038142 Mon Sep 17 00:00:00 2001 From: Ivan Lezhankin Date: Mon, 13 Apr 2020 18:42:30 +0300 Subject: [PATCH 04/73] =?UTF-8?q?Move=20contrib/libpcg-random=20=E2=86=92?= =?UTF-8?q?=20base/pcg-random?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- base/CMakeLists.txt | 3 +- base/pcg-random/CMakeLists.txt | 2 + .../pcg-random/LICENSE | 0 .../libpcg-random => base/pcg-random}/README | 0 .../pcg-random}/pcg_extras.hpp | 8 +-- .../pcg-random}/pcg_random.hpp | 0 .../pcg-random}/pcg_uint128.hpp | 0 cmake/lib_name.cmake | 1 - contrib/libpcg-random/README.md | 52 ------------------- programs/benchmark/CMakeLists.txt | 1 - programs/copier/CMakeLists.txt | 2 +- src/CMakeLists.txt | 4 +- 12 files changed, 10 insertions(+), 63 deletions(-) create mode 100644 base/pcg-random/CMakeLists.txt rename contrib/libpcg-random/LICENSE-APACHE.txt => base/pcg-random/LICENSE (100%) rename {contrib/libpcg-random => base/pcg-random}/README (100%) rename {contrib/libpcg-random/include => base/pcg-random}/pcg_extras.hpp (98%) rename {contrib/libpcg-random/include => base/pcg-random}/pcg_random.hpp (100%) rename {contrib/libpcg-random/include => base/pcg-random}/pcg_uint128.hpp (100%) delete mode 100644 contrib/libpcg-random/README.md diff --git a/base/CMakeLists.txt b/base/CMakeLists.txt index e202021fe48..1ead921f7e4 100644 --- a/base/CMakeLists.txt +++ b/base/CMakeLists.txt @@ -3,8 +3,9 @@ if (USE_CLANG_TIDY) endif () add_subdirectory (common) -add_subdirectory (loggers) add_subdirectory (daemon) +add_subdirectory (loggers) +add_subdirectory (pcg-random) if (USE_MYSQL) add_subdirectory (mysqlxx) diff --git a/base/pcg-random/CMakeLists.txt b/base/pcg-random/CMakeLists.txt new file mode 100644 index 00000000000..88acabba6a7 --- /dev/null +++ b/base/pcg-random/CMakeLists.txt @@ -0,0 +1,2 @@ +add_library(pcg_random INTERFACE) +target_include_directories(pcg_random INTERFACE .) diff --git a/contrib/libpcg-random/LICENSE-APACHE.txt b/base/pcg-random/LICENSE similarity index 100% rename from contrib/libpcg-random/LICENSE-APACHE.txt rename to base/pcg-random/LICENSE diff --git a/contrib/libpcg-random/README b/base/pcg-random/README similarity index 100% rename from contrib/libpcg-random/README rename to base/pcg-random/README diff --git a/contrib/libpcg-random/include/pcg_extras.hpp b/base/pcg-random/pcg_extras.hpp similarity index 98% rename from contrib/libpcg-random/include/pcg_extras.hpp rename to base/pcg-random/pcg_extras.hpp index 929c756b151..118b726dd57 100644 --- a/contrib/libpcg-random/include/pcg_extras.hpp +++ b/base/pcg-random/pcg_extras.hpp @@ -292,7 +292,7 @@ inline itype rotl(itype value, bitcount_t rot) { constexpr bitcount_t bits = sizeof(itype) * 8; constexpr bitcount_t mask = bits - 1; -#if PCG_USE_ZEROCHECK_ROTATE_IDIOM +#if defined(PCG_USE_ZEROCHECK_ROTATE_IDIOM) return rot ? (value << rot) | (value >> (bits - rot)) : value; #else return (value << rot) | (value >> ((- rot) & mask)); @@ -304,7 +304,7 @@ inline itype rotr(itype value, bitcount_t rot) { constexpr bitcount_t bits = sizeof(itype) * 8; constexpr bitcount_t mask = bits - 1; -#if PCG_USE_ZEROCHECK_ROTATE_IDIOM +#if defined(PCG_USE_ZEROCHECK_ROTATE_IDIOM) return rot ? (value >> rot) | (value << (bits - rot)) : value; #else return (value >> rot) | (value << ((- rot) & mask)); @@ -318,7 +318,7 @@ inline itype rotr(itype value, bitcount_t rot) * * These overloads will be preferred over the general template code above. */ -#if PCG_USE_INLINE_ASM && __GNUC__ && (__x86_64__ || __i386__) +#if defined(PCG_USE_INLINE_ASM) && __GNUC__ && (__x86_64__ || __i386__) inline uint8_t rotr(uint8_t value, bitcount_t rot) { @@ -600,7 +600,7 @@ std::ostream& operator<<(std::ostream& out, printable_typename) { #ifdef __GNUC__ int status; char* pretty_name = - abi::__cxa_demangle(implementation_typename, NULL, NULL, &status); + abi::__cxa_demangle(implementation_typename, nullptr, nullptr, &status); if (status == 0) out << pretty_name; free(static_cast(pretty_name)); diff --git a/contrib/libpcg-random/include/pcg_random.hpp b/base/pcg-random/pcg_random.hpp similarity index 100% rename from contrib/libpcg-random/include/pcg_random.hpp rename to base/pcg-random/pcg_random.hpp diff --git a/contrib/libpcg-random/include/pcg_uint128.hpp b/base/pcg-random/pcg_uint128.hpp similarity index 100% rename from contrib/libpcg-random/include/pcg_uint128.hpp rename to base/pcg-random/pcg_uint128.hpp diff --git a/cmake/lib_name.cmake b/cmake/lib_name.cmake index 8f5bebf4abe..f18b2e52576 100644 --- a/cmake/lib_name.cmake +++ b/cmake/lib_name.cmake @@ -2,4 +2,3 @@ set(DIVIDE_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/contrib/libdivide) set(DBMS_INCLUDE_DIR ${ClickHouse_SOURCE_DIR}/src ${ClickHouse_BINARY_DIR}/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) diff --git a/contrib/libpcg-random/README.md b/contrib/libpcg-random/README.md deleted file mode 100644 index c6e579cc2cc..00000000000 --- a/contrib/libpcg-random/README.md +++ /dev/null @@ -1,52 +0,0 @@ -# PCG Random Number Generation, C++ Edition - -[PCG-Random website]: http://www.pcg-random.org - -This code provides an implementation of the PCG family of random number -generators, which are fast, statistically excellent, and offer a number of -useful features. - -Full details can be found at the [PCG-Random website]. This version -of the code provides many family members -- if you just want one -simple generator, you may prefer the minimal C version of the library. - -There are two kinds of generator, normal generators and extended generators. -Extended generators provide *k* dimensional equidistribution and can perform -party tricks, but generally speaking most people only need the normal -generators. - -There are two ways to access the generators, using a convenience typedef -or by using the underlying templates directly (similar to C++11's `std::mt19937` typedef vs its `std::mersenne_twister_engine` template). For most users, the convenience typedef is what you want, and probably you're fine with `pcg32` for 32-bit numbers. If you want 64-bit numbers, either use `pcg64` (or, if you're on a 32-bit system, making 64 bits from two calls to `pcg32_k2` may be faster). - -## Documentation and Examples - -Visit [PCG-Random website] for information on how to use this library, or look -at the sample code in the `sample` directory -- hopefully it should be fairly -self explanatory. - -## Building - -The code is written in C++11, as an include-only library (i.e., there is -nothing you need to build). There are some provided demo programs and tests -however. On a Unix-style system (e.g., Linux, Mac OS X) you should be able -to just type - - make - -To build the demo programs. - -## Testing - -Run - - make test - -## Directory Structure - -The directories are arranged as follows: - -* `include` -- contains `pcg_random.hpp` and supporting include files -* `test-high` -- test code for the high-level API where the functions have - shorter, less scary-looking names. -* `sample` -- sample code, some similar to the code in `test-high` but more - human readable, some other examples too diff --git a/programs/benchmark/CMakeLists.txt b/programs/benchmark/CMakeLists.txt index 58096985037..be999aafe80 100644 --- a/programs/benchmark/CMakeLists.txt +++ b/programs/benchmark/CMakeLists.txt @@ -1,6 +1,5 @@ set(CLICKHOUSE_BENCHMARK_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/Benchmark.cpp) set(CLICKHOUSE_BENCHMARK_LINK PRIVATE dbms clickhouse_aggregate_functions clickhouse_common_config ${Boost_PROGRAM_OPTIONS_LIBRARY}) -set(CLICKHOUSE_BENCHMARK_INCLUDE SYSTEM PRIVATE ${PCG_RANDOM_INCLUDE_DIR}) clickhouse_program_add(benchmark) diff --git a/programs/copier/CMakeLists.txt b/programs/copier/CMakeLists.txt index 5573fbc5e5d..76db6ce1ffc 100644 --- a/programs/copier/CMakeLists.txt +++ b/programs/copier/CMakeLists.txt @@ -12,6 +12,6 @@ set(CLICKHOUSE_COPIER_LINK PRIVATE clickhouse_dictionaries string_utils ${Poco_XML_LIBRARY} PUBLIC daemon) -set(CLICKHOUSE_COPIER_INCLUDE SYSTEM PRIVATE ${PCG_RANDOM_INCLUDE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}) +set(CLICKHOUSE_COPIER_INCLUDE SYSTEM PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}) clickhouse_program_add(copier) diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 2393e0be18d..9949f13def0 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -398,6 +398,7 @@ endif() target_link_libraries(clickhouse_common_io PUBLIC ${CITYHASH_LIBRARIES} + pcg_random PRIVATE ${Poco_XML_LIBRARY} ${ZLIB_LIBRARIES} @@ -453,9 +454,6 @@ dbms_target_link_libraries ( target_include_directories(clickhouse_common_io PUBLIC ${CMAKE_CURRENT_BINARY_DIR}/Core/include) # uses some includes from core dbms_target_include_directories(PUBLIC ${CMAKE_CURRENT_BINARY_DIR}/Core/include) -target_include_directories(clickhouse_common_io SYSTEM PUBLIC ${PCG_RANDOM_INCLUDE_DIR}) -dbms_target_include_directories(SYSTEM PUBLIC ${PCG_RANDOM_INCLUDE_DIR}) - dbms_target_include_directories(SYSTEM BEFORE PUBLIC ${PDQSORT_INCLUDE_DIR}) if (NOT USE_INTERNAL_LZ4_LIBRARY AND LZ4_INCLUDE_DIR) From 871d3f2aa0c77455cf31c47f40a1ad4904304403 Mon Sep 17 00:00:00 2001 From: Ivan Lezhankin Date: Mon, 13 Apr 2020 18:55:48 +0300 Subject: [PATCH 05/73] =?UTF-8?q?Move=20contrib/widecharwidth=20=E2=86=92?= =?UTF-8?q?=20base/widechar=5Fwidth?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- base/CMakeLists.txt | 1 + {contrib/widecharwidth => base/widechar_width}/CMakeLists.txt | 0 {contrib/widecharwidth => base/widechar_width}/LICENSE | 0 {contrib/widecharwidth => base/widechar_width}/README.md | 0 .../widecharwidth => base/widechar_width}/widechar_width.cpp | 0 {contrib/widecharwidth => base/widechar_width}/widechar_width.h | 0 contrib/CMakeLists.txt | 1 - 7 files changed, 1 insertion(+), 1 deletion(-) rename {contrib/widecharwidth => base/widechar_width}/CMakeLists.txt (100%) rename {contrib/widecharwidth => base/widechar_width}/LICENSE (100%) rename {contrib/widecharwidth => base/widechar_width}/README.md (100%) rename {contrib/widecharwidth => base/widechar_width}/widechar_width.cpp (100%) rename {contrib/widecharwidth => base/widechar_width}/widechar_width.h (100%) diff --git a/base/CMakeLists.txt b/base/CMakeLists.txt index 1ead921f7e4..cfa54fe2ca4 100644 --- a/base/CMakeLists.txt +++ b/base/CMakeLists.txt @@ -6,6 +6,7 @@ add_subdirectory (common) add_subdirectory (daemon) add_subdirectory (loggers) add_subdirectory (pcg-random) +add_subdirectory (widechar_width) if (USE_MYSQL) add_subdirectory (mysqlxx) diff --git a/contrib/widecharwidth/CMakeLists.txt b/base/widechar_width/CMakeLists.txt similarity index 100% rename from contrib/widecharwidth/CMakeLists.txt rename to base/widechar_width/CMakeLists.txt diff --git a/contrib/widecharwidth/LICENSE b/base/widechar_width/LICENSE similarity index 100% rename from contrib/widecharwidth/LICENSE rename to base/widechar_width/LICENSE diff --git a/contrib/widecharwidth/README.md b/base/widechar_width/README.md similarity index 100% rename from contrib/widecharwidth/README.md rename to base/widechar_width/README.md diff --git a/contrib/widecharwidth/widechar_width.cpp b/base/widechar_width/widechar_width.cpp similarity index 100% rename from contrib/widecharwidth/widechar_width.cpp rename to base/widechar_width/widechar_width.cpp diff --git a/contrib/widecharwidth/widechar_width.h b/base/widechar_width/widechar_width.h similarity index 100% rename from contrib/widecharwidth/widechar_width.h rename to base/widechar_width/widechar_width.h diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt index 9c0a0aac0dd..1d438e29dae 100644 --- a/contrib/CMakeLists.txt +++ b/contrib/CMakeLists.txt @@ -333,6 +333,5 @@ add_subdirectory(grpc-cmake) add_subdirectory(replxx-cmake) add_subdirectory(FastMemcpy) -add_subdirectory(widecharwidth) add_subdirectory(consistent-hashing) add_subdirectory(consistent-hashing-sumbur) From e46322fcefb1d3e1d88fcd24c4776f91ae0a037a Mon Sep 17 00:00:00 2001 From: Avogar Date: Mon, 13 Apr 2020 22:33:02 +0300 Subject: [PATCH 06/73] Update MsgPack input format. --- src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp b/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp index ee32aeb6bfe..53c5a623a35 100644 --- a/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp +++ b/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp @@ -119,8 +119,8 @@ void MsgPackRowInputFormat::insertObject(IColumn & column, DataTypePtr data_type case TypeIndex::FixedString: [[fallthrough]]; case TypeIndex::String: { - String str = object.as(); - column.insertData(str.data(), str.size()); + msgpack::object_str obj_str = object.via.str; + column.insertData(obj_str.ptr, obj_str.size); return; } case TypeIndex::Array: From 37a971fbe58046827273ccc8edbf5b104a4a8c30 Mon Sep 17 00:00:00 2001 From: Sergei Shtykov Date: Tue, 14 Apr 2020 15:56:34 +0300 Subject: [PATCH 07/73] CLICKHOUSEDOCS-580: Fixed select.md and some of the broken links. --- .../data_types/special_data_types/set.md | 2 +- docs/en/sql_reference/statements/select.md | 778 +++++++++++++++++- 2 files changed, 775 insertions(+), 5 deletions(-) diff --git a/docs/en/sql_reference/data_types/special_data_types/set.md b/docs/en/sql_reference/data_types/special_data_types/set.md index 61f3c302ce4..05ca97910b6 100644 --- a/docs/en/sql_reference/data_types/special_data_types/set.md +++ b/docs/en/sql_reference/data_types/special_data_types/set.md @@ -5,6 +5,6 @@ toc_title: Set # Set {#set} -Used for the right half of an [IN](../../../sql_reference/statements/select.md#select-in-operators) expression. +Used for the right half of an [IN](../../statements/select.md#select-in-operators) expression. [Original article](https://clickhouse.tech/docs/en/data_types/special_data_types/set/) diff --git a/docs/en/sql_reference/statements/select.md b/docs/en/sql_reference/statements/select.md index 83ead5b26e1..9232011a8e2 100644 --- a/docs/en/sql_reference/statements/select.md +++ b/docs/en/sql_reference/statements/select.md @@ -248,7 +248,7 @@ Here, a sample of 10% is taken from the second half of the data. ### ARRAY JOIN Clause {#select-array-join-clause} -Allows executing `JOIN` with an array or nested data structure. The intent is similar to the [arrayJoin](../../sql_reference/functions/array_join.md#functions_arrayjoin) function, but its functionality is broader. +Allows executing `JOIN` with an array or nested data structure. The intent is similar to the [arrayJoin](../functions/array_join.md#functions_arrayjoin) function, but its functionality is broader. ``` sql SELECT @@ -602,7 +602,777 @@ USING (equi_column1, ... equi_columnN, asof_column) For example, consider the following tables: -\`\`\` text -table\_1 table\_2 + table_1 table_2 + event | ev_time | user_id event | ev_time | user_id + ----------|---------|---------- ----------|---------|---------- + ... ... + event_1_1 | 12:00 | 42 event_2_1 | 11:59 | 42 + ... event_2_2 | 12:30 | 42 + event_1_2 | 13:00 | 42 event_2_3 | 13:00 | 42 + ... ... -event \| ev\_time \| user\_id event \| ev\_time \| user\_id + +`ASOF JOIN` can take the timestamp of a user event from `table_1` and find an event in `table_2` where the timestamp is closest to the timestamp of the event from `table_1` corresponding to the closest match condition. Equal timestamp values are the closest if available. Here, the `user_id` column can be used for joining on equality and the `ev_time` column can be used for joining on the closest match. In our example, `event_1_1` can be joined with `event_2_1` and `event_1_2` can be joined with `event_2_3`, but `event_2_2` can’t be joined. + +!!! note "Note" + `ASOF` join is **not** supported in the [Join](../../engines/table_engines/special/join.md) table engine. + +To set the default strictness value, use the session configuration parameter [join\_default\_strictness](../../operations/settings/settings.md#settings-join_default_strictness). + +#### GLOBAL JOIN {#global-join} + +When using a normal `JOIN`, the query is sent to remote servers. Subqueries are run on each of them in order to make the right table, and the join is performed with this table. In other words, the right table is formed on each server separately. + +When using `GLOBAL ... JOIN`, first the requestor server runs a subquery to calculate the right table. This temporary table is passed to each remote server, and queries are run on them using the temporary data that was transmitted. + +Be careful when using `GLOBAL`. For more information, see the section [Distributed subqueries](#select-distributed-subqueries). + +#### Usage Recommendations {#usage-recommendations} + +When running a `JOIN`, there is no optimization of the order of execution in relation to other stages of the query. The join (a search in the right table) is run before filtering in `WHERE` and before aggregation. In order to explicitly set the processing order, we recommend running a `JOIN` subquery with a subquery. + +Example: + +``` sql +SELECT + CounterID, + hits, + visits +FROM +( + SELECT + CounterID, + count() AS hits + FROM test.hits + GROUP BY CounterID +) ANY LEFT JOIN +( + SELECT + CounterID, + sum(Sign) AS visits + FROM test.visits + GROUP BY CounterID +) USING CounterID +ORDER BY hits DESC +LIMIT 10 +``` + +``` text +┌─CounterID─┬───hits─┬─visits─┐ +│ 1143050 │ 523264 │ 13665 │ +│ 731962 │ 475698 │ 102716 │ +│ 722545 │ 337212 │ 108187 │ +│ 722889 │ 252197 │ 10547 │ +│ 2237260 │ 196036 │ 9522 │ +│ 23057320 │ 147211 │ 7689 │ +│ 722818 │ 90109 │ 17847 │ +│ 48221 │ 85379 │ 4652 │ +│ 19762435 │ 77807 │ 7026 │ +│ 722884 │ 77492 │ 11056 │ +└───────────┴────────┴────────┘ +``` + +Subqueries don’t allow you to set names or use them for referencing a column from a specific subquery. +The columns specified in `USING` must have the same names in both subqueries, and the other columns must be named differently. You can use aliases to change the names of columns in subqueries (the example uses the aliases `hits` and `visits`). + +The `USING` clause specifies one or more columns to join, which establishes the equality of these columns. The list of columns is set without brackets. More complex join conditions are not supported. + +The right table (the subquery result) resides in RAM. If there isn’t enough memory, you can’t run a `JOIN`. + +Each time a query is run with the same `JOIN`, the subquery is run again because the result is not cached. To avoid this, use the special [Join](../../engines/table_engines/special/join.md) table engine, which is a prepared array for joining that is always in RAM. + +In some cases, it is more efficient to use `IN` instead of `JOIN`. +Among the various types of `JOIN`, the most efficient is `ANY LEFT JOIN`, then `ANY INNER JOIN`. The least efficient are `ALL LEFT JOIN` and `ALL INNER JOIN`. + +If you need a `JOIN` for joining with dimension tables (these are relatively small tables that contain dimension properties, such as names for advertising campaigns), a `JOIN` might not be very convenient due to the fact that the right table is re-accessed for every query. For such cases, there is an “external dictionaries” feature that you should use instead of `JOIN`. For more information, see the section [External dictionaries](../dictionaries/external_dictionaries/external_dicts.md). + +**Memory Limitations** + +ClickHouse uses the [hash join](https://en.wikipedia.org/wiki/Hash_join) algorithm. ClickHouse takes the `` and creates a hash table for it in RAM. If you need to restrict join operation memory consumption use the following settings: + +- [max\_rows\_in\_join](../../operations/settings/query_complexity.md#settings-max_rows_in_join) — Limits number of rows in the hash table. +- [max\_bytes\_in\_join](../../operations/settings/query_complexity.md#settings-max_bytes_in_join) — Limits size of the hash table. + +When any of these limits is reached, ClickHouse acts as the [join\_overflow\_mode](../../operations/settings/query_complexity.md#settings-join_overflow_mode) setting instructs. + +#### Processing of Empty or NULL Cells {#processing-of-empty-or-null-cells} + +While joining tables, the empty cells may appear. The setting [join\_use\_nulls](../../operations/settings/settings.md#join_use_nulls) define how ClickHouse fills these cells. + +If the `JOIN` keys are [Nullable](../data_types/nullable.md) fields, the rows where at least one of the keys has the value [NULL](../syntax.md#null-literal) are not joined. + +#### Syntax Limitations {#syntax-limitations} + +For multiple `JOIN` clauses in a single `SELECT` query: + +- Taking all the columns via `*` is available only if tables are joined, not subqueries. +- The `PREWHERE` clause is not available. + +For `ON`, `WHERE`, and `GROUP BY` clauses: + +- Arbitrary expressions cannot be used in `ON`, `WHERE`, and `GROUP BY` clauses, but you can define an expression in a `SELECT` clause and then use it in these clauses via an alias. + +### WHERE Clause {#select-where} + +If there is a WHERE clause, it must contain an expression with the UInt8 type. This is usually an expression with comparison and logical operators. +This expression will be used for filtering data before all other transformations. + +If indexes are supported by the database table engine, the expression is evaluated on the ability to use indexes. + +### PREWHERE Clause {#prewhere-clause} + +This clause has the same meaning as the WHERE clause. The difference is in which data is read from the table. +When using PREWHERE, first only the columns necessary for executing PREWHERE are read. Then the other columns are read that are needed for running the query, but only those blocks where the PREWHERE expression is true. + +It makes sense to use PREWHERE if there are filtration conditions that are used by a minority of the columns in the query, but that provide strong data filtration. This reduces the volume of data to read. + +For example, it is useful to write PREWHERE for queries that extract a large number of columns, but that only have filtration for a few columns. + +PREWHERE is only supported by tables from the `*MergeTree` family. + +A query may simultaneously specify PREWHERE and WHERE. In this case, PREWHERE precedes WHERE. + +If the ‘optimize\_move\_to\_prewhere’ setting is set to 1 and PREWHERE is omitted, the system uses heuristics to automatically move parts of expressions from WHERE to PREWHERE. + +### GROUP BY Clause {#select-group-by-clause} + +This is one of the most important parts of a column-oriented DBMS. + +If there is a GROUP BY clause, it must contain a list of expressions. Each expression will be referred to here as a “key”. +All the expressions in the SELECT, HAVING, and ORDER BY clauses must be calculated from keys or from aggregate functions. In other words, each column selected from the table must be used either in keys or inside aggregate functions. + +If a query contains only table columns inside aggregate functions, the GROUP BY clause can be omitted, and aggregation by an empty set of keys is assumed. + +Example: + +``` sql +SELECT + count(), + median(FetchTiming > 60 ? 60 : FetchTiming), + count() - sum(Refresh) +FROM hits +``` + +However, in contrast to standard SQL, if the table doesn’t have any rows (either there aren’t any at all, or there aren’t any after using WHERE to filter), an empty result is returned, and not the result from one of the rows containing the initial values of aggregate functions. + +As opposed to MySQL (and conforming to standard SQL), you can’t get some value of some column that is not in a key or aggregate function (except constant expressions). To work around this, you can use the ‘any’ aggregate function (get the first encountered value) or ‘min/max’. + +Example: + +``` sql +SELECT + domainWithoutWWW(URL) AS domain, + count(), + any(Title) AS title -- getting the first occurred page header for each domain. +FROM hits +GROUP BY domain +``` + +For every different key value encountered, GROUP BY calculates a set of aggregate function values. + +GROUP BY is not supported for array columns. + +A constant can’t be specified as arguments for aggregate functions. Example: sum(1). Instead of this, you can get rid of the constant. Example: `count()`. + +#### NULL processing {#null-processing} + +For grouping, ClickHouse interprets [NULL](../syntax.md) as a value, and `NULL=NULL`. + +Here’s an example to show what this means. + +Assume you have this table: + +``` text +┌─x─┬────y─┐ +│ 1 │ 2 │ +│ 2 │ ᴺᵁᴸᴸ │ +│ 3 │ 2 │ +│ 3 │ 3 │ +│ 3 │ ᴺᵁᴸᴸ │ +└───┴──────┘ +``` + +The query `SELECT sum(x), y FROM t_null_big GROUP BY y` results in: + +``` text +┌─sum(x)─┬────y─┐ +│ 4 │ 2 │ +│ 3 │ 3 │ +│ 5 │ ᴺᵁᴸᴸ │ +└────────┴──────┘ +``` + +You can see that `GROUP BY` for `y = NULL` summed up `x`, as if `NULL` is this value. + +If you pass several keys to `GROUP BY`, the result will give you all the combinations of the selection, as if `NULL` were a specific value. + +#### WITH TOTALS Modifier {#with-totals-modifier} + +If the WITH TOTALS modifier is specified, another row will be calculated. This row will have key columns containing default values (zeros or empty lines), and columns of aggregate functions with the values calculated across all the rows (the “total” values). + +This extra row is output in JSON\*, TabSeparated\*, and Pretty\* formats, separately from the other rows. In the other formats, this row is not output. + +In JSON\* formats, this row is output as a separate ‘totals’ field. In TabSeparated\* formats, the row comes after the main result, preceded by an empty row (after the other data). In Pretty\* formats, the row is output as a separate table after the main result. + +`WITH TOTALS` can be run in different ways when HAVING is present. The behavior depends on the ‘totals\_mode’ setting. +By default, `totals_mode = 'before_having'`. In this case, ‘totals’ is calculated across all rows, including the ones that don’t pass through HAVING and ‘max\_rows\_to\_group\_by’. + +The other alternatives include only the rows that pass through HAVING in ‘totals’, and behave differently with the setting `max_rows_to_group_by` and `group_by_overflow_mode = 'any'`. + +`after_having_exclusive` – Don’t include rows that didn’t pass through `max_rows_to_group_by`. In other words, ‘totals’ will have less than or the same number of rows as it would if `max_rows_to_group_by` were omitted. + +`after_having_inclusive` – Include all the rows that didn’t pass through ‘max\_rows\_to\_group\_by’ in ‘totals’. In other words, ‘totals’ will have more than or the same number of rows as it would if `max_rows_to_group_by` were omitted. + +`after_having_auto` – Count the number of rows that passed through HAVING. If it is more than a certain amount (by default, 50%), include all the rows that didn’t pass through ‘max\_rows\_to\_group\_by’ in ‘totals’. Otherwise, do not include them. + +`totals_auto_threshold` – By default, 0.5. The coefficient for `after_having_auto`. + +If `max_rows_to_group_by` and `group_by_overflow_mode = 'any'` are not used, all variations of `after_having` are the same, and you can use any of them (for example, `after_having_auto`). + +You can use WITH TOTALS in subqueries, including subqueries in the JOIN clause (in this case, the respective total values are combined). + +#### GROUP BY in External Memory {#select-group-by-in-external-memory} + +You can enable dumping temporary data to the disk to restrict memory usage during `GROUP BY`. +The [max\_bytes\_before\_external\_group\_by](../../operations/settings/settings.md#settings-max_bytes_before_external_group_by) setting determines the threshold RAM consumption for dumping `GROUP BY` temporary data to the file system. If set to 0 (the default), it is disabled. + +When using `max_bytes_before_external_group_by`, we recommend that you set `max_memory_usage` about twice as high. This is necessary because there are two stages to aggregation: reading the date and forming intermediate data (1) and merging the intermediate data (2). Dumping data to the file system can only occur during stage 1. If the temporary data wasn’t dumped, then stage 2 might require up to the same amount of memory as in stage 1. + +For example, if [max\_memory\_usage](../../operations/settings/settings.md#settings_max_memory_usage) was set to 10000000000 and you want to use external aggregation, it makes sense to set `max_bytes_before_external_group_by` to 10000000000, and max\_memory\_usage to 20000000000. When external aggregation is triggered (if there was at least one dump of temporary data), maximum consumption of RAM is only slightly more than `max_bytes_before_external_group_by`. + +With distributed query processing, external aggregation is performed on remote servers. In order for the requester server to use only a small amount of RAM, set `distributed_aggregation_memory_efficient` to 1. + +When merging data flushed to the disk, as well as when merging results from remote servers when the `distributed_aggregation_memory_efficient` setting is enabled, consumes up to `1/256 * the_number_of_threads` from the total amount of RAM. + +When external aggregation is enabled, if there was less than `max_bytes_before_external_group_by` of data (i.e. data was not flushed), the query runs just as fast as without external aggregation. If any temporary data was flushed, the run time will be several times longer (approximately three times). + +If you have an `ORDER BY` with a `LIMIT` after `GROUP BY`, then the amount of used RAM depends on the amount of data in `LIMIT`, not in the whole table. But if the `ORDER BY` doesn’t have `LIMIT`, don’t forget to enable external sorting (`max_bytes_before_external_sort`). + +### LIMIT BY Clause {#limit-by-clause} + +A query with the `LIMIT n BY expressions` clause selects the first `n` rows for each distinct value of `expressions`. The key for `LIMIT BY` can contain any number of [expressions](../syntax.md#syntax-expressions). + +ClickHouse supports the following syntax: + +- `LIMIT [offset_value, ]n BY expressions` +- `LIMIT n OFFSET offset_value BY expressions` + +During query processing, ClickHouse selects data ordered by sorting key. The sorting key is set explicitly using an [ORDER BY](#select-order-by) clause or implicitly as a property of the table engine. Then ClickHouse applies `LIMIT n BY expressions` and returns the first `n` rows for each distinct combination of `expressions`. If `OFFSET` is specified, then for each data block that belongs to a distinct combination of `expressions`, ClickHouse skips `offset_value` number of rows from the beginning of the block and returns a maximum of `n` rows as a result. If `offset_value` is bigger than the number of rows in the data block, ClickHouse returns zero rows from the block. + +`LIMIT BY` is not related to `LIMIT`. They can both be used in the same query. + +**Examples** + +Sample table: + +``` sql +CREATE TABLE limit_by(id Int, val Int) ENGINE = Memory; +INSERT INTO limit_by values(1, 10), (1, 11), (1, 12), (2, 20), (2, 21); +``` + +Queries: + +``` sql +SELECT * FROM limit_by ORDER BY id, val LIMIT 2 BY id +``` + +``` text +┌─id─┬─val─┐ +│ 1 │ 10 │ +│ 1 │ 11 │ +│ 2 │ 20 │ +│ 2 │ 21 │ +└────┴─────┘ +``` + +``` sql +SELECT * FROM limit_by ORDER BY id, val LIMIT 1, 2 BY id +``` + +``` text +┌─id─┬─val─┐ +│ 1 │ 11 │ +│ 1 │ 12 │ +│ 2 │ 21 │ +└────┴─────┘ +``` + +The `SELECT * FROM limit_by ORDER BY id, val LIMIT 2 OFFSET 1 BY id` query returns the same result. + +The following query returns the top 5 referrers for each `domain, device_type` pair with a maximum of 100 rows in total (`LIMIT n BY + LIMIT`). + +``` sql +SELECT + domainWithoutWWW(URL) AS domain, + domainWithoutWWW(REFERRER_URL) AS referrer, + device_type, + count() cnt +FROM hits +GROUP BY domain, referrer, device_type +ORDER BY cnt DESC +LIMIT 5 BY domain, device_type +LIMIT 100 +``` + +### HAVING Clause {#having-clause} + +Allows filtering the result received after GROUP BY, similar to the WHERE clause. +WHERE and HAVING differ in that WHERE is performed before aggregation (GROUP BY), while HAVING is performed after it. +If aggregation is not performed, HAVING can’t be used. + +### ORDER BY Clause {#select-order-by} + +The ORDER BY clause contains a list of expressions, which can each be assigned DESC or ASC (the sorting direction). If the direction is not specified, ASC is assumed. ASC is sorted in ascending order, and DESC in descending order. The sorting direction applies to a single expression, not to the entire list. Example: `ORDER BY Visits DESC, SearchPhrase` + +For sorting by String values, you can specify collation (comparison). Example: `ORDER BY SearchPhrase COLLATE 'tr'` - for sorting by keyword in ascending order, using the Turkish alphabet, case insensitive, assuming that strings are UTF-8 encoded. COLLATE can be specified or not for each expression in ORDER BY independently. If ASC or DESC is specified, COLLATE is specified after it. When using COLLATE, sorting is always case-insensitive. + +We only recommend using COLLATE for final sorting of a small number of rows, since sorting with COLLATE is less efficient than normal sorting by bytes. + +Rows that have identical values for the list of sorting expressions are output in an arbitrary order, which can also be nondeterministic (different each time). +If the ORDER BY clause is omitted, the order of the rows is also undefined, and may be nondeterministic as well. + +`NaN` and `NULL` sorting order: + +- With the modifier `NULLS FIRST` — First `NULL`, then `NaN`, then other values. +- With the modifier `NULLS LAST` — First the values, then `NaN`, then `NULL`. +- Default — The same as with the `NULLS LAST` modifier. + +Example: + +For the table + +``` text +┌─x─┬────y─┐ +│ 1 │ ᴺᵁᴸᴸ │ +│ 2 │ 2 │ +│ 1 │ nan │ +│ 2 │ 2 │ +│ 3 │ 4 │ +│ 5 │ 6 │ +│ 6 │ nan │ +│ 7 │ ᴺᵁᴸᴸ │ +│ 6 │ 7 │ +│ 8 │ 9 │ +└───┴──────┘ +``` + +Run the query `SELECT * FROM t_null_nan ORDER BY y NULLS FIRST` to get: + +``` text +┌─x─┬────y─┐ +│ 1 │ ᴺᵁᴸᴸ │ +│ 7 │ ᴺᵁᴸᴸ │ +│ 1 │ nan │ +│ 6 │ nan │ +│ 2 │ 2 │ +│ 2 │ 2 │ +│ 3 │ 4 │ +│ 5 │ 6 │ +│ 6 │ 7 │ +│ 8 │ 9 │ +└───┴──────┘ +``` + +When floating point numbers are sorted, NaNs are separate from the other values. Regardless of the sorting order, NaNs come at the end. In other words, for ascending sorting they are placed as if they are larger than all the other numbers, while for descending sorting they are placed as if they are smaller than the rest. + +Less RAM is used if a small enough LIMIT is specified in addition to ORDER BY. Otherwise, the amount of memory spent is proportional to the volume of data for sorting. For distributed query processing, if GROUP BY is omitted, sorting is partially done on remote servers, and the results are merged on the requestor server. This means that for distributed sorting, the volume of data to sort can be greater than the amount of memory on a single server. + +If there is not enough RAM, it is possible to perform sorting in external memory (creating temporary files on a disk). Use the setting `max_bytes_before_external_sort` for this purpose. If it is set to 0 (the default), external sorting is disabled. If it is enabled, when the volume of data to sort reaches the specified number of bytes, the collected data is sorted and dumped into a temporary file. After all data is read, all the sorted files are merged and the results are output. Files are written to the /var/lib/clickhouse/tmp/ directory in the config (by default, but you can use the ‘tmp\_path’ parameter to change this setting). + +Running a query may use more memory than ‘max\_bytes\_before\_external\_sort’. For this reason, this setting must have a value significantly smaller than ‘max\_memory\_usage’. As an example, if your server has 128 GB of RAM and you need to run a single query, set ‘max\_memory\_usage’ to 100 GB, and ‘max\_bytes\_before\_external\_sort’ to 80 GB. + +External sorting works much less effectively than sorting in RAM. + +### SELECT Clause {#select-select} + +[Expressions](../syntax.md#syntax-expressions) specified in the `SELECT` clause are calculated after all the operations in the clauses described above are finished. These expressions work as if they apply to separate rows in the result. If expressions in the `SELECT` clause contain aggregate functions, then ClickHouse processes aggregate functions and expressions used as their arguments during the [GROUP BY](#select-group-by-clause) aggregation. + +If you want to include all columns in the result, use the asterisk (`*`) symbol. For example, `SELECT * FROM ...`. + +To match some columns in the result with a [re2](https://en.wikipedia.org/wiki/RE2_(software)) regular expression, you can use the `COLUMNS` expression. + +``` sql +COLUMNS('regexp') +``` + +For example, consider the table: + +``` sql +CREATE TABLE default.col_names (aa Int8, ab Int8, bc Int8) ENGINE = TinyLog +``` + +The following query selects data from all the columns containing the `a` symbol in their name. + +``` sql +SELECT COLUMNS('a') FROM col_names +``` + +``` text +┌─aa─┬─ab─┐ +│ 1 │ 1 │ +└────┴────┘ +``` + +The selected columns are returned not in the alphabetical order. + +You can use multiple `COLUMNS` expressions in a query and apply functions to them. + +For example: + +``` sql +SELECT COLUMNS('a'), COLUMNS('c'), toTypeName(COLUMNS('c')) FROM col_names +``` + +``` text +┌─aa─┬─ab─┬─bc─┬─toTypeName(bc)─┐ +│ 1 │ 1 │ 1 │ Int8 │ +└────┴────┴────┴────────────────┘ +``` + +Each column returned by the `COLUMNS` expression is passed to the function as a separate argument. Also you can pass other arguments to the function if it supports them. Be careful when using functions. If a function doesn’t support the number of arguments you have passed to it, ClickHouse throws an exception. + +For example: + +``` sql +SELECT COLUMNS('a') + COLUMNS('c') FROM col_names +``` + +``` text +Received exception from server (version 19.14.1): +Code: 42. DB::Exception: Received from localhost:9000. DB::Exception: Number of arguments for function plus doesn't match: passed 3, should be 2. +``` + +In this example, `COLUMNS('a')` returns two columns: `aa` and `ab`. `COLUMNS('c')` returns the `bc` column. The `+` operator can’t apply to 3 arguments, so ClickHouse throws an exception with the relevant message. + +Columns that matched the `COLUMNS` expression can have different data types. If `COLUMNS` doesn’t match any columns and is the only expression in `SELECT`, ClickHouse throws an exception. + +### DISTINCT Clause {#select-distinct} + +If DISTINCT is specified, only a single row will remain out of all the sets of fully matching rows in the result. +The result will be the same as if GROUP BY were specified across all the fields specified in SELECT without aggregate functions. But there are several differences from GROUP BY: + +- DISTINCT can be applied together with GROUP BY. +- When ORDER BY is omitted and LIMIT is defined, the query stops running immediately after the required number of different rows has been read. +- Data blocks are output as they are processed, without waiting for the entire query to finish running. + +DISTINCT is not supported if SELECT has at least one array column. + +`DISTINCT` works with [NULL](../syntax.md) as if `NULL` were a specific value, and `NULL=NULL`. In other words, in the `DISTINCT` results, different combinations with `NULL` only occur once. + +ClickHouse supports using the `DISTINCT` and `ORDER BY` clauses for different columns in one query. The `DISTINCT` clause is executed before the `ORDER BY` clause. + +Example table: + +``` text +┌─a─┬─b─┐ +│ 2 │ 1 │ +│ 1 │ 2 │ +│ 3 │ 3 │ +│ 2 │ 4 │ +└───┴───┘ +``` + +When selecting data with the `SELECT DISTINCT a FROM t1 ORDER BY b ASC` query, we get the following result: + +``` text +┌─a─┐ +│ 2 │ +│ 1 │ +│ 3 │ +└───┘ +``` + +If we change the sorting direction `SELECT DISTINCT a FROM t1 ORDER BY b DESC`, we get the following result: + +``` text +┌─a─┐ +│ 3 │ +│ 1 │ +│ 2 │ +└───┘ +``` + +Row `2, 4` was cut before sorting. + +Take this implementation specificity into account when programming queries. + +### LIMIT Clause {#limit-clause} + +`LIMIT m` allows you to select the first `m` rows from the result. + +`LIMIT n, m` allows you to select the first `m` rows from the result after skipping the first `n` rows. The `LIMIT m OFFSET n` syntax is also supported. + +`n` and `m` must be non-negative integers. + +If there isn’t an `ORDER BY` clause that explicitly sorts results, the result may be arbitrary and nondeterministic. + +### UNION ALL Clause {#union-all-clause} + +You can use UNION ALL to combine any number of queries. Example: + +``` sql +SELECT CounterID, 1 AS table, toInt64(count()) AS c + FROM test.hits + GROUP BY CounterID + +UNION ALL + +SELECT CounterID, 2 AS table, sum(Sign) AS c + FROM test.visits + GROUP BY CounterID + HAVING c > 0 +``` + +Only UNION ALL is supported. The regular UNION (UNION DISTINCT) is not supported. If you need UNION DISTINCT, you can write SELECT DISTINCT from a subquery containing UNION ALL. + +Queries that are parts of UNION ALL can be run simultaneously, and their results can be mixed together. + +The structure of results (the number and type of columns) must match for the queries. But the column names can differ. In this case, the column names for the final result will be taken from the first query. Type casting is performed for unions. For example, if two queries being combined have the same field with non-`Nullable` and `Nullable` types from a compatible type, the resulting `UNION ALL` has a `Nullable` type field. + +Queries that are parts of UNION ALL can’t be enclosed in brackets. ORDER BY and LIMIT are applied to separate queries, not to the final result. If you need to apply a conversion to the final result, you can put all the queries with UNION ALL in a subquery in the FROM clause. + +### INTO OUTFILE Clause {#into-outfile-clause} + +Add the `INTO OUTFILE filename` clause (where filename is a string literal) to redirect query output to the specified file. +In contrast to MySQL, the file is created on the client side. The query will fail if a file with the same filename already exists. +This functionality is available in the command-line client and clickhouse-local (a query sent via HTTP interface will fail). + +The default output format is TabSeparated (the same as in the command-line client batch mode). + +### FORMAT Clause {#format-clause} + +Specify ‘FORMAT format’ to get data in any specified format. +You can use this for convenience, or for creating dumps. +For more information, see the section “Formats”. +If the FORMAT clause is omitted, the default format is used, which depends on both the settings and the interface used for accessing the DB. For the HTTP interface and the command-line client in batch mode, the default format is TabSeparated. For the command-line client in interactive mode, the default format is PrettyCompact (it has attractive and compact tables). + +When using the command-line client, data is passed to the client in an internal efficient format. The client independently interprets the FORMAT clause of the query and formats the data itself (thus relieving the network and the server from the load). + +### IN Operators {#select-in-operators} + +The `IN`, `NOT IN`, `GLOBAL IN`, and `GLOBAL NOT IN` operators are covered separately, since their functionality is quite rich. + +The left side of the operator is either a single column or a tuple. + +Examples: + +``` sql +SELECT UserID IN (123, 456) FROM ... +SELECT (CounterID, UserID) IN ((34, 123), (101500, 456)) FROM ... +``` + +If the left side is a single column that is in the index, and the right side is a set of constants, the system uses the index for processing the query. + +Don’t list too many values explicitly (i.e. millions). If a data set is large, put it in a temporary table (for example, see the section “External data for query processing”), then use a subquery. + +The right side of the operator can be a set of constant expressions, a set of tuples with constant expressions (shown in the examples above), or the name of a database table or SELECT subquery in brackets. + +If the right side of the operator is the name of a table (for example, `UserID IN users`), this is equivalent to the subquery `UserID IN (SELECT * FROM users)`. Use this when working with external data that is sent along with the query. For example, the query can be sent together with a set of user IDs loaded to the ‘users’ temporary table, which should be filtered. + +If the right side of the operator is a table name that has the Set engine (a prepared data set that is always in RAM), the data set will not be created over again for each query. + +The subquery may specify more than one column for filtering tuples. +Example: + +``` sql +SELECT (CounterID, UserID) IN (SELECT CounterID, UserID FROM ...) FROM ... +``` + +The columns to the left and right of the IN operator should have the same type. + +The IN operator and subquery may occur in any part of the query, including in aggregate functions and lambda functions. +Example: + +``` sql +SELECT + EventDate, + avg(UserID IN + ( + SELECT UserID + FROM test.hits + WHERE EventDate = toDate('2014-03-17') + )) AS ratio +FROM test.hits +GROUP BY EventDate +ORDER BY EventDate ASC +``` + +``` text +┌──EventDate─┬────ratio─┐ +│ 2014-03-17 │ 1 │ +│ 2014-03-18 │ 0.807696 │ +│ 2014-03-19 │ 0.755406 │ +│ 2014-03-20 │ 0.723218 │ +│ 2014-03-21 │ 0.697021 │ +│ 2014-03-22 │ 0.647851 │ +│ 2014-03-23 │ 0.648416 │ +└────────────┴──────────┘ +``` + +For each day after March 17th, count the percentage of pageviews made by users who visited the site on March 17th. +A subquery in the IN clause is always run just one time on a single server. There are no dependent subqueries. + +#### NULL processing {#null-processing-1} + +During request processing, the IN operator assumes that the result of an operation with [NULL](../syntax.md) is always equal to `0`, regardless of whether `NULL` is on the right or left side of the operator. `NULL` values are not included in any dataset, do not correspond to each other and cannot be compared. + +Here is an example with the `t_null` table: + +``` text +┌─x─┬────y─┐ +│ 1 │ ᴺᵁᴸᴸ │ +│ 2 │ 3 │ +└───┴──────┘ +``` + +Running the query `SELECT x FROM t_null WHERE y IN (NULL,3)` gives you the following result: + +``` text +┌─x─┐ +│ 2 │ +└───┘ +``` + +You can see that the row in which `y = NULL` is thrown out of the query results. This is because ClickHouse can’t decide whether `NULL` is included in the `(NULL,3)` set, returns `0` as the result of the operation, and `SELECT` excludes this row from the final output. + +``` sql +SELECT y IN (NULL, 3) +FROM t_null +``` + +``` text +┌─in(y, tuple(NULL, 3))─┐ +│ 0 │ +│ 1 │ +└───────────────────────┘ +``` + +#### Distributed Subqueries {#select-distributed-subqueries} + +There are two options for IN-s with subqueries (similar to JOINs): normal `IN` / `JOIN` and `GLOBAL IN` / `GLOBAL JOIN`. They differ in how they are run for distributed query processing. + +!!! attention "Attention" + Remember that the algorithms described below may work differently depending on the [settings](../../operations/settings/settings.md) `distributed_product_mode` setting. + +When using the regular IN, the query is sent to remote servers, and each of them runs the subqueries in the `IN` or `JOIN` clause. + +When using `GLOBAL IN` / `GLOBAL JOINs`, first all the subqueries are run for `GLOBAL IN` / `GLOBAL JOINs`, and the results are collected in temporary tables. Then the temporary tables are sent to each remote server, where the queries are run using this temporary data. + +For a non-distributed query, use the regular `IN` / `JOIN`. + +Be careful when using subqueries in the `IN` / `JOIN` clauses for distributed query processing. + +Let’s look at some examples. Assume that each server in the cluster has a normal **local\_table**. Each server also has a **distributed\_table** table with the **Distributed** type, which looks at all the servers in the cluster. + +For a query to the **distributed\_table**, the query will be sent to all the remote servers and run on them using the **local\_table**. + +For example, the query + +``` sql +SELECT uniq(UserID) FROM distributed_table +``` + +will be sent to all remote servers as + +``` sql +SELECT uniq(UserID) FROM local_table +``` + +and run on each of them in parallel, until it reaches the stage where intermediate results can be combined. Then the intermediate results will be returned to the requestor server and merged on it, and the final result will be sent to the client. + +Now let’s examine a query with IN: + +``` sql +SELECT uniq(UserID) FROM distributed_table WHERE CounterID = 101500 AND UserID IN (SELECT UserID FROM local_table WHERE CounterID = 34) +``` + +- Calculation of the intersection of audiences of two sites. + +This query will be sent to all remote servers as + +``` sql +SELECT uniq(UserID) FROM local_table WHERE CounterID = 101500 AND UserID IN (SELECT UserID FROM local_table WHERE CounterID = 34) +``` + +In other words, the data set in the IN clause will be collected on each server independently, only across the data that is stored locally on each of the servers. + +This will work correctly and optimally if you are prepared for this case and have spread data across the cluster servers such that the data for a single UserID resides entirely on a single server. In this case, all the necessary data will be available locally on each server. Otherwise, the result will be inaccurate. We refer to this variation of the query as “local IN”. + +To correct how the query works when data is spread randomly across the cluster servers, you could specify **distributed\_table** inside a subquery. The query would look like this: + +``` sql +SELECT uniq(UserID) FROM distributed_table WHERE CounterID = 101500 AND UserID IN (SELECT UserID FROM distributed_table WHERE CounterID = 34) +``` + +This query will be sent to all remote servers as + +``` sql +SELECT uniq(UserID) FROM local_table WHERE CounterID = 101500 AND UserID IN (SELECT UserID FROM distributed_table WHERE CounterID = 34) +``` + +The subquery will begin running on each remote server. Since the subquery uses a distributed table, the subquery that is on each remote server will be resent to every remote server as + +``` sql +SELECT UserID FROM local_table WHERE CounterID = 34 +``` + +For example, if you have a cluster of 100 servers, executing the entire query will require 10,000 elementary requests, which is generally considered unacceptable. + +In such cases, you should always use GLOBAL IN instead of IN. Let’s look at how it works for the query + +``` sql +SELECT uniq(UserID) FROM distributed_table WHERE CounterID = 101500 AND UserID GLOBAL IN (SELECT UserID FROM distributed_table WHERE CounterID = 34) +``` + +The requestor server will run the subquery + +``` sql +SELECT UserID FROM distributed_table WHERE CounterID = 34 +``` + +and the result will be put in a temporary table in RAM. Then the request will be sent to each remote server as + +``` sql +SELECT uniq(UserID) FROM local_table WHERE CounterID = 101500 AND UserID GLOBAL IN _data1 +``` + +and the temporary table `_data1` will be sent to every remote server with the query (the name of the temporary table is implementation-defined). + +This is more optimal than using the normal IN. However, keep the following points in mind: + +1. When creating a temporary table, data is not made unique. To reduce the volume of data transmitted over the network, specify DISTINCT in the subquery. (You don’t need to do this for a normal IN.) +2. The temporary table will be sent to all the remote servers. Transmission does not account for network topology. For example, if 10 remote servers reside in a datacenter that is very remote in relation to the requestor server, the data will be sent 10 times over the channel to the remote datacenter. Try to avoid large data sets when using GLOBAL IN. +3. When transmitting data to remote servers, restrictions on network bandwidth are not configurable. You might overload the network. +4. Try to distribute data across servers so that you don’t need to use GLOBAL IN on a regular basis. +5. If you need to use GLOBAL IN often, plan the location of the ClickHouse cluster so that a single group of replicas resides in no more than one data center with a fast network between them, so that a query can be processed entirely within a single data center. + +It also makes sense to specify a local table in the `GLOBAL IN` clause, in case this local table is only available on the requestor server and you want to use data from it on remote servers. + +### Extreme Values {#extreme-values} + +In addition to results, you can also get minimum and maximum values for the results columns. To do this, set the **extremes** setting to 1. Minimums and maximums are calculated for numeric types, dates, and dates with times. For other columns, the default values are output. + +An extra two rows are calculated – the minimums and maximums, respectively. These extra two rows are output in `JSON*`, `TabSeparated*`, and `Pretty*` [formats](../../interfaces/formats.md), separate from the other rows. They are not output for other formats. + +In `JSON*` formats, the extreme values are output in a separate ‘extremes’ field. In `TabSeparated*` formats, the row comes after the main result, and after ‘totals’ if present. It is preceded by an empty row (after the other data). In `Pretty*` formats, the row is output as a separate table after the main result, and after `totals` if present. + +Extreme values are calculated for rows before `LIMIT`, but after `LIMIT BY`. However, when using `LIMIT offset, size`, the rows before `offset` are included in `extremes`. In stream requests, the result may also include a small number of rows that passed through `LIMIT`. + +### Notes {#notes} + +The `GROUP BY` and `ORDER BY` clauses do not support positional arguments. This contradicts MySQL, but conforms to standard SQL. +For example, `GROUP BY 1, 2` will be interpreted as grouping by constants (i.e. aggregation of all rows into one). + +You can use synonyms (`AS` aliases) in any part of a query. + +You can put an asterisk in any part of a query instead of an expression. When the query is analyzed, the asterisk is expanded to a list of all table columns (excluding the `MATERIALIZED` and `ALIAS` columns). There are only a few cases when using an asterisk is justified: + +- When creating a table dump. +- For tables containing just a few columns, such as system tables. +- For getting information about what columns are in a table. In this case, set `LIMIT 1`. But it is better to use the `DESC TABLE` query. +- When there is strong filtration on a small number of columns using `PREWHERE`. +- In subqueries (since columns that aren’t needed for the external query are excluded from subqueries). + +In all other cases, we don’t recommend using the asterisk, since it only gives you the drawbacks of a columnar DBMS instead of the advantages. In other words using the asterisk is not recommended. + +[Original article](https://clickhouse.tech/docs/en/query_language/select/) From 24f715ad87785e0c55b62f6b3392f7772ae9205b Mon Sep 17 00:00:00 2001 From: Artem Zuikov Date: Tue, 14 Apr 2020 17:43:09 +0300 Subject: [PATCH 08/73] tech debt --- src/IO/readDecimalText.h | 5 +- src/Interpreters/ColumnNamesContext.h | 89 ------------------- src/Interpreters/DatabaseAndTableWithAlias.h | 44 ++++----- src/Interpreters/JoinedTables.h | 2 + ...text.cpp => RequiredSourceColumnsData.cpp} | 43 +++------ src/Interpreters/RequiredSourceColumnsData.h | 51 +++++++++++ .../RequiredSourceColumnsVisitor.cpp | 13 +-- .../RequiredSourceColumnsVisitor.h | 6 +- src/Parsers/ASTIdentifier.h | 2 + 9 files changed, 90 insertions(+), 165 deletions(-) delete mode 100644 src/Interpreters/ColumnNamesContext.h rename src/Interpreters/{ColumnNamesContext.cpp => RequiredSourceColumnsData.cpp} (62%) create mode 100644 src/Interpreters/RequiredSourceColumnsData.h diff --git a/src/IO/readDecimalText.h b/src/IO/readDecimalText.h index 5b2a3f76481..6edc300eac8 100644 --- a/src/IO/readDecimalText.h +++ b/src/IO/readDecimalText.h @@ -10,7 +10,10 @@ namespace ErrorCodes extern const int ARGUMENT_OUT_OF_BOUND; } - +/// Try to read Decimal into underlying type T from ReadBuffer. Throws if 'digits_only' is set and there's unexpected symbol in input. +/// Returns integer 'exponent' factor that x should be muntiplyed by to get correct Decimal value: result = x * 10^exponent. +/// Use 'digits' input as max allowed meaning decimal digits in result. Place actual meanin digits in 'digits' output. +/// Do not care about decimal scale, only about meaning digits in decimal text representation. template inline bool readDigits(ReadBuffer & buf, T & x, unsigned int & digits, int & exponent, bool digits_only = false) { diff --git a/src/Interpreters/ColumnNamesContext.h b/src/Interpreters/ColumnNamesContext.h deleted file mode 100644 index c30102cf8d7..00000000000 --- a/src/Interpreters/ColumnNamesContext.h +++ /dev/null @@ -1,89 +0,0 @@ -#pragma once - -#include -#include - -#include -#include -#include -#include - -namespace DB -{ - -/// Information about table and column names extracted from ASTSelectQuery block. Do not include info from subselects. -struct ColumnNamesContext -{ - struct JoinedTable - { - const ASTTableExpression * expr = nullptr; - const ASTTableJoin * join = nullptr; - - std::optional alias() const - { - String alias; - if (expr) - { - if (expr->database_and_table_name) - alias = expr->database_and_table_name->tryGetAlias(); - else if (expr->table_function) - alias = expr->table_function->tryGetAlias(); - else if (expr->subquery) - alias = expr->subquery->tryGetAlias(); - } - if (!alias.empty()) - return alias; - return {}; - } - - std::optional name() const - { - if (expr) - return tryGetIdentifierName(expr->database_and_table_name); - return {}; - } - - std::optional joinKind() const - { - if (join) - return join->kind; - return {}; - } - }; - - struct NameInfo - { - std::set aliases; - size_t appears = 0; - - void addInclusion(const String & alias) - { - if (!alias.empty()) - aliases.insert(alias); - ++appears; - } - }; - - std::unordered_map required_names; - NameSet table_aliases; - NameSet private_aliases; - NameSet complex_aliases; - NameSet masked_columns; - NameSet array_join_columns; - std::vector tables; /// ordered list of visited tables in FROM section with joins - bool has_table_join = false; - bool has_array_join = false; - - bool addTableAliasIfAny(const IAST & ast); - bool addColumnAliasIfAny(const IAST & ast); - void addColumnIdentifier(const ASTIdentifier & node); - bool addArrayJoinAliasIfAny(const IAST & ast); - void addArrayJoinIdentifier(const ASTIdentifier & node); - - NameSet requiredColumns() const; - size_t nameInclusion(const String & name) const; -}; - -std::ostream & operator << (std::ostream & os, const ColumnNamesContext & cols); - -} diff --git a/src/Interpreters/DatabaseAndTableWithAlias.h b/src/Interpreters/DatabaseAndTableWithAlias.h index 92d6d40b455..e28d76b12f3 100644 --- a/src/Interpreters/DatabaseAndTableWithAlias.h +++ b/src/Interpreters/DatabaseAndTableWithAlias.h @@ -49,61 +49,51 @@ struct TableWithColumnNames { DatabaseAndTableWithAlias table; Names columns; - Names hidden_columns; + Names hidden_columns; /// Not general columns like MATERIALIZED and ALIAS. They are omitted in * and t.* results. TableWithColumnNames(const DatabaseAndTableWithAlias & table_, const Names & columns_) : table(table_) , columns(columns_) - {} + { + columns_set.insert(columns.begin(), columns.end()); + } TableWithColumnNames(const DatabaseAndTableWithAlias table_, Names && columns_, Names && hidden_columns_) : table(table_) , columns(columns_) , hidden_columns(hidden_columns_) - {} - - bool hasColumn(const String & name) const { - if (columns_set.empty()) - { - columns_set.insert(columns.begin(), columns.end()); - columns_set.insert(hidden_columns.begin(), hidden_columns.end()); - } - - return columns_set.count(name); + columns_set.insert(columns.begin(), columns.end()); + columns_set.insert(hidden_columns.begin(), hidden_columns.end()); } + bool hasColumn(const String & name) const { return columns_set.count(name); } + private: - mutable NameSet columns_set; + NameSet columns_set; }; struct TableWithColumnNamesAndTypes { DatabaseAndTableWithAlias table; NamesAndTypesList columns; - NamesAndTypesList hidden_columns; + NamesAndTypesList hidden_columns; /// Not general columns like MATERIALIZED and ALIAS. They are omitted in * and t.* results. TableWithColumnNamesAndTypes(const DatabaseAndTableWithAlias & table_, const NamesAndTypesList & columns_) : table(table_) , columns(columns_) - {} - - bool hasColumn(const String & name) const { - if (names.empty()) - { - for (auto & col : columns) - names.insert(col.name); - for (auto & col : hidden_columns) - names.insert(col.name); - } - - return names.count(name); + for (auto & col : columns) + names.insert(col.name); } + bool hasColumn(const String & name) const { return names.count(name); } + void addHiddenColumns(const NamesAndTypesList & addition) { hidden_columns.insert(hidden_columns.end(), addition.begin(), addition.end()); + for (auto & col : addition) + names.insert(col.name); } TableWithColumnNames removeTypes() const @@ -122,7 +112,7 @@ struct TableWithColumnNamesAndTypes } private: - mutable NameSet names; + NameSet names; }; std::vector getDatabaseAndTables(const ASTSelectQuery & select_query, const String & current_database); diff --git a/src/Interpreters/JoinedTables.h b/src/Interpreters/JoinedTables.h index 66b3c8de609..3bcec883f30 100644 --- a/src/Interpreters/JoinedTables.h +++ b/src/Interpreters/JoinedTables.h @@ -27,6 +27,8 @@ public: StoragePtr getLeftTableStorage(); bool resolveTables(); + + /// Make fake tables_with_columns[0] in case we have predefined input in InterpreterSelectQuery void makeFakeTable(StoragePtr storage, const Block & source_header); const std::vector & tablesWithColumns() const { return tables_with_columns; } diff --git a/src/Interpreters/ColumnNamesContext.cpp b/src/Interpreters/RequiredSourceColumnsData.cpp similarity index 62% rename from src/Interpreters/ColumnNamesContext.cpp rename to src/Interpreters/RequiredSourceColumnsData.cpp index c8fde183d96..b5a3544f22f 100644 --- a/src/Interpreters/ColumnNamesContext.cpp +++ b/src/Interpreters/RequiredSourceColumnsData.cpp @@ -1,21 +1,13 @@ -#include +#include +#include #include #include +#include namespace DB { -bool ColumnNamesContext::addTableAliasIfAny(const IAST & ast) -{ - String alias = ast.tryGetAlias(); - if (alias.empty()) - return false; - - table_aliases.insert(alias); - return true; -} - -bool ColumnNamesContext::addColumnAliasIfAny(const IAST & ast) +bool RequiredSourceColumnsData::addColumnAliasIfAny(const IAST & ast) { String alias = ast.tryGetAlias(); if (alias.empty()) @@ -28,7 +20,7 @@ bool ColumnNamesContext::addColumnAliasIfAny(const IAST & ast) return true; } -void ColumnNamesContext::addColumnIdentifier(const ASTIdentifier & node) +void RequiredSourceColumnsData::addColumnIdentifier(const ASTIdentifier & node) { if (!IdentifierSemantic::getColumnName(node)) return; @@ -38,7 +30,7 @@ void ColumnNamesContext::addColumnIdentifier(const ASTIdentifier & node) required_names[node.name].addInclusion(alias); } -bool ColumnNamesContext::addArrayJoinAliasIfAny(const IAST & ast) +bool RequiredSourceColumnsData::addArrayJoinAliasIfAny(const IAST & ast) { String alias = ast.tryGetAlias(); if (alias.empty()) @@ -48,12 +40,12 @@ bool ColumnNamesContext::addArrayJoinAliasIfAny(const IAST & ast) return true; } -void ColumnNamesContext::addArrayJoinIdentifier(const ASTIdentifier & node) +void RequiredSourceColumnsData::addArrayJoinIdentifier(const ASTIdentifier & node) { array_join_columns.insert(node.name); } -size_t ColumnNamesContext::nameInclusion(const String & name) const +size_t RequiredSourceColumnsData::nameInclusion(const String & name) const { auto it = required_names.find(name); if (it != required_names.end()) @@ -61,7 +53,7 @@ size_t ColumnNamesContext::nameInclusion(const String & name) const return 0; } -NameSet ColumnNamesContext::requiredColumns() const +NameSet RequiredSourceColumnsData::requiredColumns() const { NameSet required; for (const auto & pr : required_names) @@ -79,7 +71,7 @@ NameSet ColumnNamesContext::requiredColumns() const return required; } -std::ostream & operator << (std::ostream & os, const ColumnNamesContext & cols) +std::ostream & operator << (std::ostream & os, const RequiredSourceColumnsData & cols) { os << "required_names: "; for (const auto & pr : cols.required_names) @@ -89,21 +81,6 @@ std::ostream & operator << (std::ostream & os, const ColumnNamesContext & cols) os << "/'" << alias << "'"; os << ", "; } - os << "source_tables: "; - for (const auto & x : cols.tables) - { - auto alias = x.alias(); - auto name = x.name(); - if (alias && name) - os << "'" << *alias << "'/'" << *name << "', "; - else if (alias) - os << "'" << *alias << "', "; - else if (name) - os << "'" << *name << "', "; - } - os << "table_aliases: "; - for (const auto & x : cols.table_aliases) - os << "'" << x << "', "; os << "complex_aliases: "; for (const auto & x : cols.complex_aliases) os << "'" << x << "', "; diff --git a/src/Interpreters/RequiredSourceColumnsData.h b/src/Interpreters/RequiredSourceColumnsData.h new file mode 100644 index 00000000000..de1f3bc2721 --- /dev/null +++ b/src/Interpreters/RequiredSourceColumnsData.h @@ -0,0 +1,51 @@ +#pragma once + +#include +#include + +#include +#include +#include + +namespace DB +{ + +class ASTIdentifier; + +/// Information about table and column names extracted from ASTSelectQuery block. Do not include info from subselects. +struct RequiredSourceColumnsData +{ + struct NameInfo + { + std::set aliases; + size_t appears = 0; + + void addInclusion(const String & alias) + { + if (!alias.empty()) + aliases.insert(alias); + ++appears; + } + }; + + std::unordered_map required_names; + NameSet private_aliases; /// lambda aliases that should not be interpreted as required columns + NameSet complex_aliases; /// aliases to functions results: they are not required cause calculated by query itself + NameSet masked_columns; /// columns names masked by function aliases: we still need them in required columns + NameSet array_join_columns; /// Tech debt: we exclude ArrayJoin columns from general logic cause they have own logic outside + + bool has_table_join = false; + bool has_array_join = false; + + bool addColumnAliasIfAny(const IAST & ast); + void addColumnIdentifier(const ASTIdentifier & node); + bool addArrayJoinAliasIfAny(const IAST & ast); + void addArrayJoinIdentifier(const ASTIdentifier & node); + + NameSet requiredColumns() const; + size_t nameInclusion(const String & name) const; +}; + +std::ostream & operator << (std::ostream & os, const RequiredSourceColumnsData & cols); + +} diff --git a/src/Interpreters/RequiredSourceColumnsVisitor.cpp b/src/Interpreters/RequiredSourceColumnsVisitor.cpp index 469a5852fa5..08bfbf30f7f 100644 --- a/src/Interpreters/RequiredSourceColumnsVisitor.cpp +++ b/src/Interpreters/RequiredSourceColumnsVisitor.cpp @@ -91,14 +91,12 @@ void RequiredSourceColumnsMatcher::visit(const ASTPtr & ast, Data & data) if (auto * t = ast->as()) { - data.addTableAliasIfAny(*ast); visit(*t, ast, data); return; } if (ast->as()) { - data.addTableAliasIfAny(*ast); return; } @@ -174,20 +172,11 @@ void RequiredSourceColumnsMatcher::visit(const ASTTablesInSelectQueryElement & n if (join) data.has_table_join = true; - data.tables.emplace_back(ColumnNamesContext::JoinedTable{expr, join}); } /// ASTIdentifiers here are tables. Do not visit them as generic ones. -void RequiredSourceColumnsMatcher::visit(const ASTTableExpression & node, const ASTPtr &, Data & data) +void RequiredSourceColumnsMatcher::visit(const ASTTableExpression &, const ASTPtr &, Data &) { - if (node.database_and_table_name) - data.addTableAliasIfAny(*node.database_and_table_name); - - if (node.table_function) - data.addTableAliasIfAny(*node.table_function); - - if (node.subquery) - data.addTableAliasIfAny(*node.subquery); } void RequiredSourceColumnsMatcher::visit(const ASTArrayJoin & node, const ASTPtr &, Data & data) diff --git a/src/Interpreters/RequiredSourceColumnsVisitor.h b/src/Interpreters/RequiredSourceColumnsVisitor.h index 1f6ff482e3a..53decb3a849 100644 --- a/src/Interpreters/RequiredSourceColumnsVisitor.h +++ b/src/Interpreters/RequiredSourceColumnsVisitor.h @@ -1,6 +1,6 @@ #pragma once -#include +#include #include namespace DB @@ -21,7 +21,7 @@ class RequiredSourceColumnsMatcher { public: using Visitor = ConstInDepthNodeVisitor; - using Data = ColumnNamesContext; + using Data = RequiredSourceColumnsData; static bool needChildVisit(const ASTPtr & node, const ASTPtr & child); static void visit(const ASTPtr & ast, Data & data); @@ -35,7 +35,7 @@ private: static void visit(const ASTSelectQuery & select, const ASTPtr &, Data & data); }; -/// Extracts all the information about columns and tables from ASTSelectQuery block into ColumnNamesContext object. +/// Extracts all the information about columns and tables from ASTSelectQuery block into Data object. /// It doesn't use anything but AST. It visits nodes from bottom to top except ASTFunction content to get aliases in right manner. /// @note There's some ambiguousness with nested columns names that can't be solved without schema. using RequiredSourceColumnsVisitor = RequiredSourceColumnsMatcher::Visitor; diff --git a/src/Parsers/ASTIdentifier.h b/src/Parsers/ASTIdentifier.h index 9e28a1461ca..c13c2c3f977 100644 --- a/src/Parsers/ASTIdentifier.h +++ b/src/Parsers/ASTIdentifier.h @@ -40,6 +40,8 @@ public: bool isShort() const { return name_parts.empty() || name == name_parts.back(); } void setShortName(const String & new_name); + + /// Restore name field from name_parts in case it was cropped by analyzer but we need a full form for future (re)analyze. void restoreCompoundName(); const String & shortName() const From c454c5ae6210edcfc5ae9b7198977081b00edd87 Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Wed, 15 Apr 2020 01:39:36 +0300 Subject: [PATCH 09/73] Trigger CI --- tests/queries/0_stateless/01098_msgpack_format.sh | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/queries/0_stateless/01098_msgpack_format.sh b/tests/queries/0_stateless/01098_msgpack_format.sh index 233399570bb..4cb0731604d 100755 --- a/tests/queries/0_stateless/01098_msgpack_format.sh +++ b/tests/queries/0_stateless/01098_msgpack_format.sh @@ -8,7 +8,7 @@ $CLICKHOUSE_CLIENT --query="DROP TABLE IF EXISTS msgpack"; $CLICKHOUSE_CLIENT --query="CREATE TABLE msgpack (uint8 UInt8, uint16 UInt16, uint32 UInt32, uint64 UInt64, int8 Int8, int16 Int16, int32 Int32, int64 Int64, float Float32, double Float64, string String, date Date, datetime DateTime, datetime64 DateTime64, array Array(UInt32)) ENGINE = Memory"; -$CLICKHOUSE_CLIENT --query="INSERT INTO msgpack VALUES (255, 65535, 4294967295, 100000000000, -128, -32768, -2147483648, -100000000000, 2.02, 10000.0000001, 'String', 18980, 1639872000, 1639872000000, [1,2,3,4,5]), (4, 1234, 3244467295, 500000000000, -1, -256, -14741221, -7000000000, 100.1, 14321.032141201, 'Another string', 20000, 1839882000, 1639872891123, [5,4,3,2,1]),(42, 42, 42, 42, 42, 42, 42, 42, 42.42, 42.42, '42', 42, 42, 42, [42])"; +$CLICKHOUSE_CLIENT --query="INSERT INTO msgpack VALUES (255, 65535, 4294967295, 100000000000, -128, -32768, -2147483648, -100000000000, 2.02, 10000.0000001, 'String', 18980, 1639872000, 1639872000000, [1,2,3,4,5]), (4, 1234, 3244467295, 500000000000, -1, -256, -14741221, -7000000000, 100.1, 14321.032141201, 'Another string', 20000, 1839882000, 1639872891123, [5,4,3,2,1]), (42, 42, 42, 42, 42, 42, 42, 42, 42.42, 42.42, '42', 42, 42, 42, [42])"; $CLICKHOUSE_CLIENT --query="SELECT * FROM msgpack FORMAT MsgPack" > $CURDIR/tmp_msgpac_test_all_types.msgpk; From b8061356b0cb443d77d404828b5c93e51cf16a58 Mon Sep 17 00:00:00 2001 From: Avogar Date: Wed, 15 Apr 2020 02:08:55 +0300 Subject: [PATCH 10/73] Update parsing method in MsgPackRowInputFormat --- .../Formats/Impl/MsgPackRowInputFormat.cpp | 39 ++++++++++--------- .../Formats/Impl/MsgPackRowInputFormat.h | 7 +++- 2 files changed, 26 insertions(+), 20 deletions(-) diff --git a/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp b/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp index 53c5a623a35..9b24978cf52 100644 --- a/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp +++ b/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp @@ -24,34 +24,35 @@ namespace ErrorCodes } MsgPackRowInputFormat::MsgPackRowInputFormat(const Block & header_, ReadBuffer & in_, Params params_) - : IRowInputFormat(header_, in_, std::move(params_)), buf(in_), data_types(header_.getDataTypes()) {} + : IRowInputFormat(header_, in_, std::move(params_)), buf(in), ctx(&reference_func, nullptr, msgpack::unpack_limit()), data_types(header_.getDataTypes()) {} + +int MsgPackRowInputFormat::unpack(msgpack::zone & zone, size_t & offset) +{ + offset = 0; + ctx.init(); + ctx.user().set_zone(zone); + return ctx.execute(buf.position(), buf.buffer().end() - buf.position(), offset); +} bool MsgPackRowInputFormat::readObject() { if (buf.eof()) return false; + PeekableReadBufferCheckpoint checkpoint{buf}; - size_t offset = 0; - bool need_more_data = true; - while (need_more_data) + std::unique_ptr zone(new msgpack::zone); + size_t offset; + while(!unpack(*zone, offset)) { - offset = 0; - try - { - object_handle = msgpack::unpack(buf.position(), buf.buffer().end() - buf.position(), offset); - need_more_data = false; - } - catch (msgpack::insufficient_bytes &) - { - buf.position() = buf.buffer().end(); - if (buf.eof()) - throw Exception("Unexpected end of file while parsing msgpack object.", ErrorCodes::INCORRECT_DATA); - buf.position() = buf.buffer().end(); - buf.makeContinuousMemoryFromCheckpointToPos(); - buf.rollbackToCheckpoint(); - } + buf.position() = buf.buffer().end(); + if (buf.eof()) + throw Exception("Unexpected end of file while parsing msgpack object.", ErrorCodes::INCORRECT_DATA); + buf.position() = buf.buffer().end(); + buf.makeContinuousMemoryFromCheckpointToPos(); + buf.rollbackToCheckpoint(); } buf.position() += offset; + object_handle = msgpack::object_handle(ctx.data(), std::move(zone)); return true; } diff --git a/src/Processors/Formats/Impl/MsgPackRowInputFormat.h b/src/Processors/Formats/Impl/MsgPackRowInputFormat.h index 8ed23a1e0f4..a426dc4950c 100644 --- a/src/Processors/Formats/Impl/MsgPackRowInputFormat.h +++ b/src/Processors/Formats/Impl/MsgPackRowInputFormat.h @@ -20,10 +20,15 @@ public: private: bool readObject(); void insertObject(IColumn & column, DataTypePtr type, const msgpack::object & object); + int unpack(msgpack::zone & zone, size_t & offset); + + // msgpack makes a copy of object by default, this function tells unpacker not to copy. + static bool reference_func(msgpack::type::object_type, size_t, void *) { return true; } PeekableReadBuffer buf; - DataTypes data_types; msgpack::object_handle object_handle; + msgpack::v1::detail::context ctx; + DataTypes data_types; }; } From 93c322bc30c7122c300b849a1c03c092eb3c1254 Mon Sep 17 00:00:00 2001 From: Avogar Date: Wed, 15 Apr 2020 02:58:36 +0300 Subject: [PATCH 11/73] Fix style error --- src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp b/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp index 9b24978cf52..b7da335f0c5 100644 --- a/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp +++ b/src/Processors/Formats/Impl/MsgPackRowInputFormat.cpp @@ -42,7 +42,7 @@ bool MsgPackRowInputFormat::readObject() PeekableReadBufferCheckpoint checkpoint{buf}; std::unique_ptr zone(new msgpack::zone); size_t offset; - while(!unpack(*zone, offset)) + while (!unpack(*zone, offset)) { buf.position() = buf.buffer().end(); if (buf.eof()) From eed2ea3b364e7baf70de4165dfc125fa4ad47788 Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Wed, 15 Apr 2020 06:02:51 +0300 Subject: [PATCH 12/73] Remove strange code --- src/Functions/array/arrayIndex.h | 18 +----------------- 1 file changed, 1 insertion(+), 17 deletions(-) diff --git a/src/Functions/array/arrayIndex.h b/src/Functions/array/arrayIndex.h index 1b1ac172f24..96a7ba3c143 100644 --- a/src/Functions/array/arrayIndex.h +++ b/src/Functions/array/arrayIndex.h @@ -225,21 +225,6 @@ public: } }; -/// Specialization that catches internal errors. -template -struct ArrayIndexNumImpl -{ - template - static void vector( - const PaddedPODArray &, const ColumnArray::Offsets &, - const ScalarOrVector &, - PaddedPODArray &, - const PaddedPODArray *, - const PaddedPODArray *) - { - throw Exception{"Logical error in implementation of a function that returns array index", ErrorCodes::LOGICAL_ERROR}; - } -}; /// Implementation for arrays of numbers when the 2nd function argument /// is a NULL value. @@ -623,8 +608,7 @@ private: || executeNumberNumber(block, arguments, result) || executeNumberNumber(block, arguments, result) || executeNumberNumber(block, arguments, result) - || executeNumberNumber(block, arguments, result) - || executeNumberNumber(block, arguments, result); + || executeNumberNumber(block, arguments, result); } template From 738fef71f497d2297c36606f90ab838e9d0f2efb Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Wed, 15 Apr 2020 06:32:33 +0300 Subject: [PATCH 13/73] Allow to parse +inf #1839 --- src/IO/readFloatText.h | 27 +++++++++++++++++-- .../0_stateless/01198_plus_inf.reference | 3 +++ tests/queries/0_stateless/01198_plus_inf.sql | 3 +++ 3 files changed, 31 insertions(+), 2 deletions(-) create mode 100644 tests/queries/0_stateless/01198_plus_inf.reference create mode 100644 tests/queries/0_stateless/01198_plus_inf.sql diff --git a/src/IO/readFloatText.h b/src/IO/readFloatText.h index fc3ffc43a91..4e0825222a7 100644 --- a/src/IO/readFloatText.h +++ b/src/IO/readFloatText.h @@ -156,6 +156,9 @@ ReturnType readFloatTextPreciseImpl(T & x, ReadBuffer & buf) { switch (*buf.position()) { + case '+': + continue; + case '-': { negative = true; @@ -335,6 +338,7 @@ ReturnType readFloatTextFastImpl(T & x, ReadBuffer & in) ++in.position(); } + auto count_after_sign = in.count(); constexpr int significant_digits = std::numeric_limits::digits10; @@ -380,7 +384,7 @@ ReturnType readFloatTextFastImpl(T & x, ReadBuffer & in) if (in.eof()) { if constexpr (throw_exception) - throw Exception("Cannot read floating point value", ErrorCodes::CANNOT_PARSE_NUMBER); + throw Exception("Cannot read floating point value: nothing after exponent", ErrorCodes::CANNOT_PARSE_NUMBER); else return false; } @@ -418,11 +422,30 @@ ReturnType readFloatTextFastImpl(T & x, ReadBuffer & in) if (in.eof()) { if constexpr (throw_exception) - throw Exception("Cannot read floating point value", ErrorCodes::CANNOT_PARSE_NUMBER); + throw Exception("Cannot read floating point value: no digits read", ErrorCodes::CANNOT_PARSE_NUMBER); else return false; } + if (*in.position() == '+') + { + ++in.position(); + if (in.eof()) + { + if constexpr (throw_exception) + throw Exception("Cannot read floating point value: nothing after plus sign", ErrorCodes::CANNOT_PARSE_NUMBER); + else + return false; + } + else if (negative) + { + if constexpr (throw_exception) + throw Exception("Cannot read floating point value: plus after minus sign", ErrorCodes::CANNOT_PARSE_NUMBER); + else + return false; + } + } + if (*in.position() == 'i' || *in.position() == 'I') { if (assertOrParseInfinity(in)) diff --git a/tests/queries/0_stateless/01198_plus_inf.reference b/tests/queries/0_stateless/01198_plus_inf.reference new file mode 100644 index 00000000000..f726b8429b6 --- /dev/null +++ b/tests/queries/0_stateless/01198_plus_inf.reference @@ -0,0 +1,3 @@ +inf +-inf +inf diff --git a/tests/queries/0_stateless/01198_plus_inf.sql b/tests/queries/0_stateless/01198_plus_inf.sql new file mode 100644 index 00000000000..e06faa2fd21 --- /dev/null +++ b/tests/queries/0_stateless/01198_plus_inf.sql @@ -0,0 +1,3 @@ +SELECT DISTINCT toFloat64(arrayJoin(['+inf', '+Inf', '+INF', '+infinity', '+Infinity'])); +SELECT DISTINCT toFloat64(arrayJoin(['-inf', '-Inf', '-INF', '-infinity', '-Infinity'])); +SELECT DISTINCT toFloat64(arrayJoin(['inf', 'Inf', 'INF', 'infinity', 'Infinity'])); From ddd840a81b329758e18db4c1fdf24f9fb909761d Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Wed, 15 Apr 2020 06:56:42 +0300 Subject: [PATCH 14/73] Avoid error message on RST --- programs/server/TCPHandlerFactory.h | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-) diff --git a/programs/server/TCPHandlerFactory.h b/programs/server/TCPHandlerFactory.h index 0eb8be13a2d..3b764af96ec 100644 --- a/programs/server/TCPHandlerFactory.h +++ b/programs/server/TCPHandlerFactory.h @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include "IServer.h" #include "TCPHandler.h" @@ -16,6 +17,13 @@ private: IServer & server; Poco::Logger * log; + class DummyTCPHandler : public Poco::Net::TCPServerConnection + { + public: + using Poco::Net::TCPServerConnection::TCPServerConnection; + void run() override {} + }; + public: explicit TCPHandlerFactory(IServer & server_, bool secure_ = false) : server(server_) @@ -25,12 +33,16 @@ public: Poco::Net::TCPServerConnection * createConnection(const Poco::Net::StreamSocket & socket) override { - LOG_TRACE(log, - "TCP Request. " - << "Address: " - << socket.peerAddress().toString()); - - return new TCPHandler(server, socket); + try + { + LOG_TRACE(log, "TCP Request. Address: " << socket.peerAddress().toString()); + return new TCPHandler(server, socket); + } + catch (const Poco::Net::NetException & e) + { + LOG_TRACE(log, "TCP Request. Client is not connected (most likely RST packet was sent)."); + return new DummyTCPHandler(socket); + } } }; From 19c4968ca6c0c9887d7ef2855cc690328852ad21 Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Wed, 15 Apr 2020 07:02:41 +0300 Subject: [PATCH 15/73] Update arrayIndex.h --- src/Functions/array/arrayIndex.h | 1 - 1 file changed, 1 deletion(-) diff --git a/src/Functions/array/arrayIndex.h b/src/Functions/array/arrayIndex.h index 96a7ba3c143..fab1332cbda 100644 --- a/src/Functions/array/arrayIndex.h +++ b/src/Functions/array/arrayIndex.h @@ -19,7 +19,6 @@ namespace DB namespace ErrorCodes { - extern const int LOGICAL_ERROR; extern const int ILLEGAL_COLUMN; extern const int ILLEGAL_TYPE_OF_ARGUMENT; } From 00973217b815e9b27f443fca524c3d95e42d66d3 Mon Sep 17 00:00:00 2001 From: "dependabot-preview[bot]" <27856297+dependabot-preview[bot]@users.noreply.github.com> Date: Wed, 15 Apr 2020 07:41:23 +0000 Subject: [PATCH 16/73] Bump lunr from 0.5.6 to 0.5.7 in /docs/tools Bumps [lunr](https://github.com/yeraydiazdiaz/lunr.py) from 0.5.6 to 0.5.7. - [Release notes](https://github.com/yeraydiazdiaz/lunr.py/releases) - [Changelog](https://github.com/yeraydiazdiaz/lunr.py/blob/master/CHANGELOG.md) - [Commits](https://github.com/yeraydiazdiaz/lunr.py/commits) Signed-off-by: dependabot-preview[bot] --- docs/tools/requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tools/requirements.txt b/docs/tools/requirements.txt index d161ae22ebd..ff5722ff28e 100644 --- a/docs/tools/requirements.txt +++ b/docs/tools/requirements.txt @@ -14,7 +14,7 @@ Jinja2==2.11.2 jinja2-highlight==0.6.1 jsmin==2.2.2 livereload==2.6.1 -lunr==0.5.6 +lunr==0.5.7 Markdown==3.2.1 MarkupSafe==1.1.1 mkdocs==1.1 From 3d8562452d9818c9679374bc1cc65c29b66fca13 Mon Sep 17 00:00:00 2001 From: Artem Zuikov Date: Wed, 15 Apr 2020 13:07:16 +0300 Subject: [PATCH 17/73] remove more code --- src/Interpreters/RequiredSourceColumnsVisitor.cpp | 14 ++------------ 1 file changed, 2 insertions(+), 12 deletions(-) diff --git a/src/Interpreters/RequiredSourceColumnsVisitor.cpp b/src/Interpreters/RequiredSourceColumnsVisitor.cpp index 08bfbf30f7f..9542b2882c5 100644 --- a/src/Interpreters/RequiredSourceColumnsVisitor.cpp +++ b/src/Interpreters/RequiredSourceColumnsVisitor.cpp @@ -159,19 +159,9 @@ void RequiredSourceColumnsMatcher::visit(const ASTFunction & node, const ASTPtr void RequiredSourceColumnsMatcher::visit(const ASTTablesInSelectQueryElement & node, const ASTPtr &, Data & data) { - ASTTableExpression * expr = nullptr; - ASTTableJoin * join = nullptr; - for (auto & child : node.children) - { - if (auto * e = child->as()) - expr = e; - if (auto * j = child->as()) - join = j; - } - - if (join) - data.has_table_join = true; + if (child->as()) + data.has_table_join = true; } /// ASTIdentifiers here are tables. Do not visit them as generic ones. From e8cd92bba3269f47787db090899f7c242adf7818 Mon Sep 17 00:00:00 2001 From: alesapin Date: Wed, 15 Apr 2020 13:12:03 +0300 Subject: [PATCH 18/73] Fix debug build --- src/Functions/if.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Functions/if.cpp b/src/Functions/if.cpp index 514c416fd99..8974e0f3886 100644 --- a/src/Functions/if.cpp +++ b/src/Functions/if.cpp @@ -590,7 +590,7 @@ private: return true; } - void executeGeneric(const ColumnUInt8 * cond_col, Block & block, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) + static void executeGeneric(const ColumnUInt8 * cond_col, Block & block, const ColumnNumbers & arguments, size_t result, size_t input_rows_count) { /// Convert both columns to the common type (if needed). From 0c2d3417e2531b9d0ab70f0f3e13817fae52fc1b Mon Sep 17 00:00:00 2001 From: Nikolai Kochetov Date: Wed, 15 Apr 2020 13:18:52 +0300 Subject: [PATCH 19/73] Fix pipeline stuck with max_rows_to_group_by. --- src/Processors/Transforms/AggregatingTransform.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/Processors/Transforms/AggregatingTransform.cpp b/src/Processors/Transforms/AggregatingTransform.cpp index 4a76e0f2273..c25b2478862 100644 --- a/src/Processors/Transforms/AggregatingTransform.cpp +++ b/src/Processors/Transforms/AggregatingTransform.cpp @@ -432,7 +432,12 @@ IProcessor::Status AggregatingTransform::prepare() /// Finish data processing, prepare to generating. if (is_consume_finished && !is_generate_initialized) + { + /// Close input port in case max_rows_to_group_by was reached but not all data was read. + inputs.front().close(); + return Status::Ready; + } if (is_generate_initialized && !is_pipeline_created && !processors.empty()) return Status::ExpandPipeline; From 41baae33d416e9aeb2f41ee21ebecad403ec385f Mon Sep 17 00:00:00 2001 From: Nikolai Kochetov Date: Wed, 15 Apr 2020 13:20:42 +0300 Subject: [PATCH 20/73] Add test. --- .../01134_max_rows_to_group_by.reference | 33 +++++++++++++++++++ .../01134_max_rows_to_group_by.sql | 17 ++++++++++ 2 files changed, 50 insertions(+) create mode 100644 tests/queries/0_stateless/01134_max_rows_to_group_by.reference create mode 100644 tests/queries/0_stateless/01134_max_rows_to_group_by.sql diff --git a/tests/queries/0_stateless/01134_max_rows_to_group_by.reference b/tests/queries/0_stateless/01134_max_rows_to_group_by.reference new file mode 100644 index 00000000000..caaf3394975 --- /dev/null +++ b/tests/queries/0_stateless/01134_max_rows_to_group_by.reference @@ -0,0 +1,33 @@ +test2 0 +test2 1 +test2 2 +test2 3 +test2 4 +test2 5 +test2 6 +test2 7 +test2 8 +test2 9 +test2 10 +test3 0 +test3 1 +test3 2 +test3 3 +test3 4 +test3 5 +test3 6 +test3 7 +test3 8 +test3 9 +test3 10 +test5 0 +test5 1 +test5 2 +test5 3 +test5 4 +test5 5 +test5 6 +test5 7 +test5 8 +test5 9 +test5 10 diff --git a/tests/queries/0_stateless/01134_max_rows_to_group_by.sql b/tests/queries/0_stateless/01134_max_rows_to_group_by.sql new file mode 100644 index 00000000000..bfbc499e1c3 --- /dev/null +++ b/tests/queries/0_stateless/01134_max_rows_to_group_by.sql @@ -0,0 +1,17 @@ +SET max_block_size = 1; +SET max_rows_to_group_by = 10; +SET group_by_overflow_mode = 'throw'; + +SELECT 'test1', number FROM system.numbers GROUP BY number; -- { serverError 158 } + +SET group_by_overflow_mode = 'break'; +SELECT 'test2', number FROM system.numbers GROUP BY number ORDER BY number; + +SET max_rows_to_read = 500; +SELECT 'test3', number FROM system.numbers GROUP BY number ORDER BY number; + +SET group_by_overflow_mode = 'any'; +SELECT 'test4', number FROM numbers(1000) GROUP BY number ORDER BY number; -- { serverError 158 } + +SET max_rows_to_read = 1000; +SELECT 'test5', number FROM numbers(1000) GROUP BY number ORDER BY number; From 95916e39cff15e64088067d132abaf5a91e709ef Mon Sep 17 00:00:00 2001 From: Nikolai Kochetov Date: Wed, 15 Apr 2020 13:57:42 +0300 Subject: [PATCH 21/73] Added more comments to AggregatingTransform. --- .../Transforms/AggregatingTransform.cpp | 3 +++ src/Processors/Transforms/AggregatingTransform.h | 15 +++++++++++++++ 2 files changed, 18 insertions(+) diff --git a/src/Processors/Transforms/AggregatingTransform.cpp b/src/Processors/Transforms/AggregatingTransform.cpp index c25b2478862..78607323996 100644 --- a/src/Processors/Transforms/AggregatingTransform.cpp +++ b/src/Processors/Transforms/AggregatingTransform.cpp @@ -413,6 +413,9 @@ AggregatingTransform::~AggregatingTransform() = default; IProcessor::Status AggregatingTransform::prepare() { + /// There are one or two input ports. + /// The first one is used at aggregation step, the second one - while reading merged data from ConvertingAggregated + auto & output = outputs.front(); /// Last output is current. All other outputs should already be closed. auto & input = inputs.back(); diff --git a/src/Processors/Transforms/AggregatingTransform.h b/src/Processors/Transforms/AggregatingTransform.h index 469392e5840..9c1e9d4e2db 100644 --- a/src/Processors/Transforms/AggregatingTransform.h +++ b/src/Processors/Transforms/AggregatingTransform.h @@ -49,6 +49,21 @@ struct ManyAggregatedData using AggregatingTransformParamsPtr = std::shared_ptr; using ManyAggregatedDataPtr = std::shared_ptr; +/** Aggregates the stream of blocks using the specified key columns and aggregate functions. + * Columns with aggregate functions adds to the end of the block. + * If final = false, the aggregate functions are not finalized, that is, they are not replaced by their value, but contain an intermediate state of calculations. + * This is necessary so that aggregation can continue (for example, by combining streams of partially aggregated data). + * + * For every separate stream of data separate AggregatingTransform is created. + * Every AggregatingTransform reads data from the first port till is is not run out, or max_rows_to_group_by reached. + * When the last AggregatingTransform finish reading, the result of aggregation is needed to be merged together. + * This task is performed by ConvertingAggregatedToChunksTransform. + * Last AggregatingTransform expands pipeline and adds second input port, which reads from ConvertingAggregated. + * + * Aggregation data is passed by ManyAggregatedData structure, which is shared between all aggregating transforms. + * At aggregation step, every transform uses it's own AggregatedDataVariants structure. + * At merging step, all structures pass to ConvertingAggregatedToChunksTransform. + */ class AggregatingTransform : public IProcessor { public: From 394b4ebd7dc07d3489c7e8262da7503f260b8a74 Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Wed, 15 Apr 2020 16:31:05 +0300 Subject: [PATCH 22/73] Update requirements.txt --- docs/tools/requirements.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/tools/requirements.txt b/docs/tools/requirements.txt index ff5722ff28e..8414ae2c533 100644 --- a/docs/tools/requirements.txt +++ b/docs/tools/requirements.txt @@ -14,7 +14,6 @@ Jinja2==2.11.2 jinja2-highlight==0.6.1 jsmin==2.2.2 livereload==2.6.1 -lunr==0.5.7 Markdown==3.2.1 MarkupSafe==1.1.1 mkdocs==1.1 From 76a8efbd807a8026e757926f678d479d7bc523dd Mon Sep 17 00:00:00 2001 From: Ivan Blinkov Date: Wed, 15 Apr 2020 16:35:16 +0300 Subject: [PATCH 23/73] Indicate LTS releases in docs version selector (#10281) --- docs/tools/build.py | 3 +- docs/tools/github.py | 54 +++++++++++++++++++++++------ website/templates/docs/sidebar.html | 2 +- 3 files changed, 46 insertions(+), 13 deletions(-) diff --git a/docs/tools/build.py b/docs/tools/build.py index f96e79ea53a..65fc6d12f58 100755 --- a/docs/tools/build.py +++ b/docs/tools/build.py @@ -381,7 +381,8 @@ if __name__ == '__main__': arg_parser.add_argument('--website-dir', default=website_dir) arg_parser.add_argument('--output-dir', default='build') arg_parser.add_argument('--enable-stable-releases', action='store_true') - arg_parser.add_argument('--stable-releases-limit', type=int, default='10') + arg_parser.add_argument('--stable-releases-limit', type=int, default='4') + arg_parser.add_argument('--lts-releases-limit', type=int, default='1') arg_parser.add_argument('--version-prefix', type=str, default='') arg_parser.add_argument('--is-stable-release', action='store_true') arg_parser.add_argument('--skip-single-page', action='store_true') diff --git a/docs/tools/github.py b/docs/tools/github.py index d32c78abb14..abe41cc79fe 100644 --- a/docs/tools/github.py +++ b/docs/tools/github.py @@ -11,38 +11,58 @@ import requests import util +def yield_candidates(): + for page in range(1, 100): + url = 'https://api.github.com/repos/ClickHouse/ClickHouse/tags?per_page=100&page=%d' % page + for candidate in requests.get(url).json(): + yield candidate + + def choose_latest_releases(args): logging.info('Collecting release candidates') seen = collections.OrderedDict() candidates = [] - for page in range(1, args.stable_releases_limit): - url = 'https://api.github.com/repos/ClickHouse/ClickHouse/tags?per_page=100&page=%d' % page - candidates += requests.get(url).json() - logging.info('Collected all release candidates') + stable_count = 0 + lts_count = 0 - for tag in candidates: + for tag in yield_candidates(): if isinstance(tag, dict): name = tag.get('name', '') - is_unstable = ('stable' not in name) and ('lts' not in name) + is_stable = 'stable' in name + is_lts = 'lts' in name + is_unstable = not (is_stable or is_lts) is_in_blacklist = ('v18' in name) or ('prestable' in name) or ('v1.1' in name) if is_unstable or is_in_blacklist: continue major_version = '.'.join((name.split('.', 2))[:2]) if major_version not in seen: - seen[major_version] = (name, tag.get('tarball_url'),) - if len(seen) > args.stable_releases_limit: + if (stable_count >= args.stable_releases_limit) and (lts_count >= args.lts_releases_limit): break + + payload = (name, tag.get('tarball_url'), is_lts,) + if is_lts: + if lts_count < args.lts_releases_limit: + seen[major_version] = payload + lts_count += 1 + else: + if stable_count < args.stable_releases_limit: + seen[major_version] = payload + stable_count += 1 + + logging.debug( + f'Stables: {stable_count}/{args.stable_releases_limit} LTS: {lts_count}/{args.lts_releases_limit}' + ) else: logging.fatal('Unexpected GitHub response: %s', str(candidates)) sys.exit(1) - logging.info('Found stable releases: %s', str(seen.keys())) + logging.info('Found stable releases: %s', ', '.join(seen.keys())) return seen.items() def process_release(args, callback, release): - name, (full_name, tarball_url,) = release - logging.info('Building docs for %s', full_name) + name, (full_name, tarball_url, is_lts,) = release + logging.info(f'Building docs for {full_name}') buf = io.BytesIO(requests.get(tarball_url).content) tar = tarfile.open(mode='r:gz', fileobj=buf) with util.temp_dir() as base_dir: @@ -79,3 +99,15 @@ def get_events(args): 'event_date': tail[1].replace('on ', '').replace('.', '') }) return events + + +if __name__ == '__main__': + class DummyArgs(object): + lts_releases_limit = 1 + stable_releases_limit = 3 + logging.basicConfig( + level=logging.DEBUG, + stream=sys.stderr + ) + for item in choose_latest_releases(DummyArgs()): + print(item) diff --git a/website/templates/docs/sidebar.html b/website/templates/docs/sidebar.html index f3ce0b5be7e..a4ff0e780d8 100644 --- a/website/templates/docs/sidebar.html +++ b/website/templates/docs/sidebar.html @@ -21,7 +21,7 @@ {% for release in config.extra.stable_releases %} {{ release.0 }} + href="/docs/{{ release.0 }}/{{ language }}/">{{ release.0 }}{% if release.1.2 %} LTS{% endif %} {% endfor %} From 98769778f465c3afbd943ea03e145cf8b1086baa Mon Sep 17 00:00:00 2001 From: Ivan Blinkov Date: Wed, 15 Apr 2020 16:56:49 +0300 Subject: [PATCH 24/73] Turkish docs translation stub (#10282) --- .gitignore | 4 +- docs/tools/build.py | 4 +- docs/tools/make_links.sh | 2 +- docs/tools/translate/translate.py | 4 +- docs/tools/translate/update-po.sh | 4 +- docs/tr/commercial/cloud.md | 21 + docs/tr/commercial/index.md | 9 + docs/tr/development/architecture.md | 203 ++ docs/tr/development/browse_code.md | 14 + docs/tr/development/build.md | 141 ++ docs/tr/development/build_cross_arm.md | 43 + docs/tr/development/build_cross_osx.md | 64 + docs/tr/development/build_osx.md | 93 + docs/tr/development/contrib.md | 42 + docs/tr/development/developer_instruction.md | 285 +++ docs/tr/development/index.md | 12 + docs/tr/development/style.md | 841 +++++++ docs/tr/development/tests.md | 252 ++ docs/tr/engines/database_engines/index.md | 21 + docs/tr/engines/database_engines/lazy.md | 18 + docs/tr/engines/database_engines/mysql.md | 135 ++ docs/tr/engines/index.md | 8 + docs/tr/engines/table_engines/index.md | 85 + .../table_engines/integrations/hdfs.md | 123 + .../table_engines/integrations/index.md | 8 + .../table_engines/integrations/jdbc.md | 90 + .../table_engines/integrations/kafka.md | 176 ++ .../table_engines/integrations/mysql.md | 105 + .../table_engines/integrations/odbc.md | 132 ++ .../engines/table_engines/log_family/index.md | 8 + .../engines/table_engines/log_family/log.md | 16 + .../table_engines/log_family/log_family.md | 46 + .../table_engines/log_family/stripelog.md | 95 + .../table_engines/log_family/tinylog.md | 16 + .../mergetree_family/aggregatingmergetree.md | 102 + .../mergetree_family/collapsingmergetree.md | 309 +++ .../custom_partitioning_key.md | 127 + .../mergetree_family/graphitemergetree.md | 174 ++ .../table_engines/mergetree_family/index.md | 8 + .../mergetree_family/mergetree.md | 654 ++++++ .../mergetree_family/replacingmergetree.md | 69 + .../mergetree_family/replication.md | 218 ++ .../mergetree_family/summingmergetree.md | 141 ++ .../versionedcollapsingmergetree.md | 238 ++ .../engines/table_engines/special/buffer.md | 71 + .../table_engines/special/dictionary.md | 97 + .../table_engines/special/distributed.md | 152 ++ .../table_engines/special/external_data.md | 68 + docs/tr/engines/table_engines/special/file.md | 90 + .../engines/table_engines/special/generate.md | 61 + .../tr/engines/table_engines/special/index.md | 8 + docs/tr/engines/table_engines/special/join.md | 111 + .../table_engines/special/materializedview.md | 12 + .../engines/table_engines/special/memory.md | 19 + .../tr/engines/table_engines/special/merge.md | 70 + docs/tr/engines/table_engines/special/null.md | 14 + docs/tr/engines/table_engines/special/set.md | 19 + docs/tr/engines/table_engines/special/url.md | 82 + docs/tr/engines/table_engines/special/view.md | 12 + docs/tr/faq/general.md | 60 + docs/tr/faq/index.md | 8 + .../example_datasets/amplab_benchmark.md | 129 + .../example_datasets/criteo.md | 81 + .../getting_started/example_datasets/index.md | 22 + .../example_datasets/metrica.md | 70 + .../example_datasets/nyc_taxi.md | 390 ++++ .../example_datasets/ontime.md | 412 ++++ .../example_datasets/star_schema.md | 370 +++ .../example_datasets/wikistat.md | 35 + docs/tr/getting_started/index.md | 17 + docs/tr/getting_started/install.md | 191 ++ docs/tr/getting_started/playground.md | 48 + docs/tr/getting_started/tutorial.md | 671 ++++++ docs/tr/guides/apply_catboost_model.md | 239 ++ docs/tr/guides/index.md | 16 + docs/tr/images | 1 + docs/tr/index.md | 139 ++ docs/tr/interfaces/cli.md | 149 ++ docs/tr/interfaces/cpp.md | 12 + docs/tr/interfaces/formats.md | 1212 ++++++++++ docs/tr/interfaces/http.md | 511 ++++ docs/tr/interfaces/index.md | 29 + docs/tr/interfaces/jdbc.md | 15 + docs/tr/interfaces/mysql.md | 49 + docs/tr/interfaces/odbc.md | 12 + docs/tr/interfaces/tcp.md | 12 + .../third-party/client_libraries.md | 59 + docs/tr/interfaces/third-party/gui.md | 152 ++ docs/tr/interfaces/third-party/index.md | 8 + .../tr/interfaces/third-party/integrations.md | 96 + docs/tr/interfaces/third-party/proxy.md | 46 + docs/tr/introduction/adopters.md | 83 + docs/tr/introduction/distinctive_features.md | 77 + docs/tr/introduction/history.md | 56 + docs/tr/introduction/index.md | 8 + docs/tr/introduction/performance.md | 32 + docs/tr/operations/access_rights.md | 113 + docs/tr/operations/backup.md | 41 + docs/tr/operations/configuration_files.md | 57 + docs/tr/operations/index.md | 28 + docs/tr/operations/monitoring.md | 46 + .../optimizing_performance/index.md | 8 + .../sampling_query_profiler.md | 64 + ...sampling_query_profiler_example_result.txt | 1 + docs/tr/operations/performance_test.md | 82 + docs/tr/operations/quotas.md | 112 + docs/tr/operations/requirements.md | 61 + .../server_configuration_parameters/index.md | 19 + .../settings.md | 896 +++++++ .../settings/constraints_on_settings.md | 75 + docs/tr/operations/settings/index.md | 32 + .../settings/permissions_for_queries.md | 61 + .../operations/settings/query_complexity.md | 302 +++ docs/tr/operations/settings/settings.md | 1235 ++++++++++ .../operations/settings/settings_profiles.md | 71 + docs/tr/operations/settings/settings_users.md | 148 ++ docs/tr/operations/system_tables.md | 1166 +++++++++ docs/tr/operations/tips.md | 251 ++ docs/tr/operations/troubleshooting.md | 146 ++ docs/tr/operations/update.md | 20 + .../utilities/clickhouse-benchmark.md | 156 ++ .../operations/utilities/clickhouse-copier.md | 176 ++ .../operations/utilities/clickhouse-local.md | 81 + docs/tr/operations/utilities/index.md | 15 + .../aggregate_functions/combinators.md | 166 ++ .../aggregate_functions/index.md | 62 + .../parametric_functions.md | 499 ++++ .../aggregate_functions/reference.md | 1878 +++++++++++++++ .../data_types/aggregatefunction.md | 70 + docs/tr/sql_reference/data_types/array.md | 77 + docs/tr/sql_reference/data_types/boolean.md | 12 + docs/tr/sql_reference/data_types/date.md | 15 + docs/tr/sql_reference/data_types/datetime.md | 129 + .../tr/sql_reference/data_types/datetime64.md | 104 + docs/tr/sql_reference/data_types/decimal.md | 109 + .../sql_reference/data_types/domains/index.md | 8 + .../sql_reference/data_types/domains/ipv4.md | 84 + .../sql_reference/data_types/domains/ipv6.md | 86 + .../data_types/domains/overview.md | 32 + docs/tr/sql_reference/data_types/enum.md | 132 ++ .../sql_reference/data_types/fixedstring.md | 63 + docs/tr/sql_reference/data_types/float.md | 87 + docs/tr/sql_reference/data_types/index.md | 15 + docs/tr/sql_reference/data_types/int_uint.md | 26 + .../nested_data_structures/index.md | 12 + .../nested_data_structures/nested.md | 106 + docs/tr/sql_reference/data_types/nullable.md | 46 + .../special_data_types/expression.md | 12 + .../data_types/special_data_types/index.md | 14 + .../data_types/special_data_types/interval.md | 85 + .../data_types/special_data_types/nothing.md | 26 + .../data_types/special_data_types/set.md | 12 + docs/tr/sql_reference/data_types/string.md | 20 + docs/tr/sql_reference/data_types/tuple.md | 52 + docs/tr/sql_reference/data_types/uuid.md | 77 + .../external_dictionaries/external_dicts.md | 56 + .../external_dicts_dict.md | 53 + .../external_dicts_dict_hierarchical.md | 70 + .../external_dicts_dict_layout.md | 373 +++ .../external_dicts_dict_lifetime.md | 91 + .../external_dicts_dict_sources.md | 608 +++++ .../external_dicts_dict_structure.md | 175 ++ .../external_dictionaries/index.md | 8 + docs/tr/sql_reference/dictionaries/index.md | 22 + .../dictionaries/internal_dicts.md | 55 + .../functions/arithmetic_functions.md | 87 + .../functions/array_functions.md | 1061 +++++++++ docs/tr/sql_reference/functions/array_join.md | 37 + .../sql_reference/functions/bit_functions.md | 255 ++ .../functions/bitmap_functions.md | 496 ++++ .../functions/comparison_functions.md | 37 + .../functions/conditional_functions.md | 207 ++ .../functions/date_time_functions.md | 450 ++++ .../functions/encoding_functions.md | 175 ++ .../functions/ext_dict_functions.md | 205 ++ .../functions/functions_for_nulls.md | 312 +++ docs/tr/sql_reference/functions/geo.md | 510 ++++ .../sql_reference/functions/hash_functions.md | 446 ++++ .../functions/higher_order_functions.md | 264 +++ .../sql_reference/functions/in_functions.md | 26 + docs/tr/sql_reference/functions/index.md | 74 + .../sql_reference/functions/introspection.md | 310 +++ .../functions/ip_address_functions.md | 248 ++ .../sql_reference/functions/json_functions.md | 231 ++ .../functions/logical_functions.md | 22 + .../functions/machine_learning_functions.md | 20 + .../sql_reference/functions/math_functions.md | 116 + .../functions/other_functions.md | 1079 +++++++++ .../functions/random_functions.md | 30 + .../functions/rounding_functions.md | 190 ++ .../functions/splitting_merging_functions.md | 116 + .../functions/string_functions.md | 489 ++++ .../functions/string_replace_functions.md | 94 + .../functions/string_search_functions.md | 379 +++ .../functions/type_conversion_functions.md | 534 +++++ .../sql_reference/functions/url_functions.md | 209 ++ .../sql_reference/functions/uuid_functions.md | 122 + .../functions/ym_dict_functions.md | 155 ++ docs/tr/sql_reference/index.md | 18 + docs/tr/sql_reference/operators.md | 277 +++ docs/tr/sql_reference/statements/alter.md | 504 ++++ docs/tr/sql_reference/statements/create.md | 305 +++ docs/tr/sql_reference/statements/index.md | 8 + .../sql_reference/statements/insert_into.md | 80 + docs/tr/sql_reference/statements/misc.md | 252 ++ docs/tr/sql_reference/statements/select.md | 610 +++++ docs/tr/sql_reference/statements/show.md | 105 + docs/tr/sql_reference/statements/system.md | 113 + docs/tr/sql_reference/syntax.md | 187 ++ docs/tr/sql_reference/table_functions/file.md | 121 + .../sql_reference/table_functions/generate.md | 45 + docs/tr/sql_reference/table_functions/hdfs.md | 104 + .../tr/sql_reference/table_functions/index.md | 38 + .../tr/sql_reference/table_functions/input.md | 47 + docs/tr/sql_reference/table_functions/jdbc.md | 29 + .../tr/sql_reference/table_functions/merge.md | 14 + .../tr/sql_reference/table_functions/mysql.md | 86 + .../sql_reference/table_functions/numbers.md | 30 + docs/tr/sql_reference/table_functions/odbc.md | 108 + .../sql_reference/table_functions/remote.md | 83 + docs/tr/sql_reference/table_functions/url.md | 26 + docs/tr/whats_new/changelog/2017.md | 268 +++ docs/tr/whats_new/changelog/2018.md | 1063 +++++++++ docs/tr/whats_new/changelog/2019.md | 2074 +++++++++++++++++ docs/tr/whats_new/changelog/index.md | 668 ++++++ docs/tr/whats_new/index.md | 8 + docs/tr/whats_new/roadmap.md | 19 + docs/tr/whats_new/security_changelog.md | 76 + website/images/flags/tr.svg | 8 + website/locale/en/LC_MESSAGES/messages.po | 14 +- website/locale/es/LC_MESSAGES/messages.mo | Bin 6235 -> 6382 bytes website/locale/es/LC_MESSAGES/messages.po | 14 +- website/locale/fa/LC_MESSAGES/messages.mo | Bin 6903 -> 7107 bytes website/locale/fa/LC_MESSAGES/messages.po | 14 +- website/locale/fr/LC_MESSAGES/messages.mo | Bin 6113 -> 6272 bytes website/locale/fr/LC_MESSAGES/messages.po | 16 +- website/locale/ja/LC_MESSAGES/messages.mo | Bin 6205 -> 6365 bytes website/locale/ja/LC_MESSAGES/messages.po | 14 +- website/locale/messages.pot | 14 +- website/locale/ru/LC_MESSAGES/messages.mo | Bin 7850 -> 8075 bytes website/locale/ru/LC_MESSAGES/messages.po | 24 +- website/locale/tr/LC_MESSAGES/messages.mo | Bin 0 -> 6158 bytes website/locale/tr/LC_MESSAGES/messages.po | 271 +++ website/locale/zh/LC_MESSAGES/messages.mo | Bin 5610 -> 5743 bytes website/locale/zh/LC_MESSAGES/messages.po | 14 +- website/templates/docs/content.html | 2 +- 246 files changed, 39357 insertions(+), 53 deletions(-) create mode 100644 docs/tr/commercial/cloud.md create mode 100644 docs/tr/commercial/index.md create mode 100644 docs/tr/development/architecture.md create mode 100644 docs/tr/development/browse_code.md create mode 100644 docs/tr/development/build.md create mode 100644 docs/tr/development/build_cross_arm.md create mode 100644 docs/tr/development/build_cross_osx.md create mode 100644 docs/tr/development/build_osx.md create mode 100644 docs/tr/development/contrib.md create mode 100644 docs/tr/development/developer_instruction.md create mode 100644 docs/tr/development/index.md create mode 100644 docs/tr/development/style.md create mode 100644 docs/tr/development/tests.md create mode 100644 docs/tr/engines/database_engines/index.md create mode 100644 docs/tr/engines/database_engines/lazy.md create mode 100644 docs/tr/engines/database_engines/mysql.md create mode 100644 docs/tr/engines/index.md create mode 100644 docs/tr/engines/table_engines/index.md create mode 100644 docs/tr/engines/table_engines/integrations/hdfs.md create mode 100644 docs/tr/engines/table_engines/integrations/index.md create mode 100644 docs/tr/engines/table_engines/integrations/jdbc.md create mode 100644 docs/tr/engines/table_engines/integrations/kafka.md create mode 100644 docs/tr/engines/table_engines/integrations/mysql.md create mode 100644 docs/tr/engines/table_engines/integrations/odbc.md create mode 100644 docs/tr/engines/table_engines/log_family/index.md create mode 100644 docs/tr/engines/table_engines/log_family/log.md create mode 100644 docs/tr/engines/table_engines/log_family/log_family.md create mode 100644 docs/tr/engines/table_engines/log_family/stripelog.md create mode 100644 docs/tr/engines/table_engines/log_family/tinylog.md create mode 100644 docs/tr/engines/table_engines/mergetree_family/aggregatingmergetree.md create mode 100644 docs/tr/engines/table_engines/mergetree_family/collapsingmergetree.md create mode 100644 docs/tr/engines/table_engines/mergetree_family/custom_partitioning_key.md create mode 100644 docs/tr/engines/table_engines/mergetree_family/graphitemergetree.md create mode 100644 docs/tr/engines/table_engines/mergetree_family/index.md create mode 100644 docs/tr/engines/table_engines/mergetree_family/mergetree.md create mode 100644 docs/tr/engines/table_engines/mergetree_family/replacingmergetree.md create mode 100644 docs/tr/engines/table_engines/mergetree_family/replication.md create mode 100644 docs/tr/engines/table_engines/mergetree_family/summingmergetree.md create mode 100644 docs/tr/engines/table_engines/mergetree_family/versionedcollapsingmergetree.md create mode 100644 docs/tr/engines/table_engines/special/buffer.md create mode 100644 docs/tr/engines/table_engines/special/dictionary.md create mode 100644 docs/tr/engines/table_engines/special/distributed.md create mode 100644 docs/tr/engines/table_engines/special/external_data.md create mode 100644 docs/tr/engines/table_engines/special/file.md create mode 100644 docs/tr/engines/table_engines/special/generate.md create mode 100644 docs/tr/engines/table_engines/special/index.md create mode 100644 docs/tr/engines/table_engines/special/join.md create mode 100644 docs/tr/engines/table_engines/special/materializedview.md create mode 100644 docs/tr/engines/table_engines/special/memory.md create mode 100644 docs/tr/engines/table_engines/special/merge.md create mode 100644 docs/tr/engines/table_engines/special/null.md create mode 100644 docs/tr/engines/table_engines/special/set.md create mode 100644 docs/tr/engines/table_engines/special/url.md create mode 100644 docs/tr/engines/table_engines/special/view.md create mode 100644 docs/tr/faq/general.md create mode 100644 docs/tr/faq/index.md create mode 100644 docs/tr/getting_started/example_datasets/amplab_benchmark.md create mode 100644 docs/tr/getting_started/example_datasets/criteo.md create mode 100644 docs/tr/getting_started/example_datasets/index.md create mode 100644 docs/tr/getting_started/example_datasets/metrica.md create mode 100644 docs/tr/getting_started/example_datasets/nyc_taxi.md create mode 100644 docs/tr/getting_started/example_datasets/ontime.md create mode 100644 docs/tr/getting_started/example_datasets/star_schema.md create mode 100644 docs/tr/getting_started/example_datasets/wikistat.md create mode 100644 docs/tr/getting_started/index.md create mode 100644 docs/tr/getting_started/install.md create mode 100644 docs/tr/getting_started/playground.md create mode 100644 docs/tr/getting_started/tutorial.md create mode 100644 docs/tr/guides/apply_catboost_model.md create mode 100644 docs/tr/guides/index.md create mode 120000 docs/tr/images create mode 100644 docs/tr/index.md create mode 100644 docs/tr/interfaces/cli.md create mode 100644 docs/tr/interfaces/cpp.md create mode 100644 docs/tr/interfaces/formats.md create mode 100644 docs/tr/interfaces/http.md create mode 100644 docs/tr/interfaces/index.md create mode 100644 docs/tr/interfaces/jdbc.md create mode 100644 docs/tr/interfaces/mysql.md create mode 100644 docs/tr/interfaces/odbc.md create mode 100644 docs/tr/interfaces/tcp.md create mode 100644 docs/tr/interfaces/third-party/client_libraries.md create mode 100644 docs/tr/interfaces/third-party/gui.md create mode 100644 docs/tr/interfaces/third-party/index.md create mode 100644 docs/tr/interfaces/third-party/integrations.md create mode 100644 docs/tr/interfaces/third-party/proxy.md create mode 100644 docs/tr/introduction/adopters.md create mode 100644 docs/tr/introduction/distinctive_features.md create mode 100644 docs/tr/introduction/history.md create mode 100644 docs/tr/introduction/index.md create mode 100644 docs/tr/introduction/performance.md create mode 100644 docs/tr/operations/access_rights.md create mode 100644 docs/tr/operations/backup.md create mode 100644 docs/tr/operations/configuration_files.md create mode 100644 docs/tr/operations/index.md create mode 100644 docs/tr/operations/monitoring.md create mode 100644 docs/tr/operations/optimizing_performance/index.md create mode 100644 docs/tr/operations/optimizing_performance/sampling_query_profiler.md create mode 120000 docs/tr/operations/performance/sampling_query_profiler_example_result.txt create mode 100644 docs/tr/operations/performance_test.md create mode 100644 docs/tr/operations/quotas.md create mode 100644 docs/tr/operations/requirements.md create mode 100644 docs/tr/operations/server_configuration_parameters/index.md create mode 100644 docs/tr/operations/server_configuration_parameters/settings.md create mode 100644 docs/tr/operations/settings/constraints_on_settings.md create mode 100644 docs/tr/operations/settings/index.md create mode 100644 docs/tr/operations/settings/permissions_for_queries.md create mode 100644 docs/tr/operations/settings/query_complexity.md create mode 100644 docs/tr/operations/settings/settings.md create mode 100644 docs/tr/operations/settings/settings_profiles.md create mode 100644 docs/tr/operations/settings/settings_users.md create mode 100644 docs/tr/operations/system_tables.md create mode 100644 docs/tr/operations/tips.md create mode 100644 docs/tr/operations/troubleshooting.md create mode 100644 docs/tr/operations/update.md create mode 100644 docs/tr/operations/utilities/clickhouse-benchmark.md create mode 100644 docs/tr/operations/utilities/clickhouse-copier.md create mode 100644 docs/tr/operations/utilities/clickhouse-local.md create mode 100644 docs/tr/operations/utilities/index.md create mode 100644 docs/tr/sql_reference/aggregate_functions/combinators.md create mode 100644 docs/tr/sql_reference/aggregate_functions/index.md create mode 100644 docs/tr/sql_reference/aggregate_functions/parametric_functions.md create mode 100644 docs/tr/sql_reference/aggregate_functions/reference.md create mode 100644 docs/tr/sql_reference/data_types/aggregatefunction.md create mode 100644 docs/tr/sql_reference/data_types/array.md create mode 100644 docs/tr/sql_reference/data_types/boolean.md create mode 100644 docs/tr/sql_reference/data_types/date.md create mode 100644 docs/tr/sql_reference/data_types/datetime.md create mode 100644 docs/tr/sql_reference/data_types/datetime64.md create mode 100644 docs/tr/sql_reference/data_types/decimal.md create mode 100644 docs/tr/sql_reference/data_types/domains/index.md create mode 100644 docs/tr/sql_reference/data_types/domains/ipv4.md create mode 100644 docs/tr/sql_reference/data_types/domains/ipv6.md create mode 100644 docs/tr/sql_reference/data_types/domains/overview.md create mode 100644 docs/tr/sql_reference/data_types/enum.md create mode 100644 docs/tr/sql_reference/data_types/fixedstring.md create mode 100644 docs/tr/sql_reference/data_types/float.md create mode 100644 docs/tr/sql_reference/data_types/index.md create mode 100644 docs/tr/sql_reference/data_types/int_uint.md create mode 100644 docs/tr/sql_reference/data_types/nested_data_structures/index.md create mode 100644 docs/tr/sql_reference/data_types/nested_data_structures/nested.md create mode 100644 docs/tr/sql_reference/data_types/nullable.md create mode 100644 docs/tr/sql_reference/data_types/special_data_types/expression.md create mode 100644 docs/tr/sql_reference/data_types/special_data_types/index.md create mode 100644 docs/tr/sql_reference/data_types/special_data_types/interval.md create mode 100644 docs/tr/sql_reference/data_types/special_data_types/nothing.md create mode 100644 docs/tr/sql_reference/data_types/special_data_types/set.md create mode 100644 docs/tr/sql_reference/data_types/string.md create mode 100644 docs/tr/sql_reference/data_types/tuple.md create mode 100644 docs/tr/sql_reference/data_types/uuid.md create mode 100644 docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts.md create mode 100644 docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict.md create mode 100644 docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_hierarchical.md create mode 100644 docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_layout.md create mode 100644 docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_lifetime.md create mode 100644 docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_sources.md create mode 100644 docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_structure.md create mode 100644 docs/tr/sql_reference/dictionaries/external_dictionaries/index.md create mode 100644 docs/tr/sql_reference/dictionaries/index.md create mode 100644 docs/tr/sql_reference/dictionaries/internal_dicts.md create mode 100644 docs/tr/sql_reference/functions/arithmetic_functions.md create mode 100644 docs/tr/sql_reference/functions/array_functions.md create mode 100644 docs/tr/sql_reference/functions/array_join.md create mode 100644 docs/tr/sql_reference/functions/bit_functions.md create mode 100644 docs/tr/sql_reference/functions/bitmap_functions.md create mode 100644 docs/tr/sql_reference/functions/comparison_functions.md create mode 100644 docs/tr/sql_reference/functions/conditional_functions.md create mode 100644 docs/tr/sql_reference/functions/date_time_functions.md create mode 100644 docs/tr/sql_reference/functions/encoding_functions.md create mode 100644 docs/tr/sql_reference/functions/ext_dict_functions.md create mode 100644 docs/tr/sql_reference/functions/functions_for_nulls.md create mode 100644 docs/tr/sql_reference/functions/geo.md create mode 100644 docs/tr/sql_reference/functions/hash_functions.md create mode 100644 docs/tr/sql_reference/functions/higher_order_functions.md create mode 100644 docs/tr/sql_reference/functions/in_functions.md create mode 100644 docs/tr/sql_reference/functions/index.md create mode 100644 docs/tr/sql_reference/functions/introspection.md create mode 100644 docs/tr/sql_reference/functions/ip_address_functions.md create mode 100644 docs/tr/sql_reference/functions/json_functions.md create mode 100644 docs/tr/sql_reference/functions/logical_functions.md create mode 100644 docs/tr/sql_reference/functions/machine_learning_functions.md create mode 100644 docs/tr/sql_reference/functions/math_functions.md create mode 100644 docs/tr/sql_reference/functions/other_functions.md create mode 100644 docs/tr/sql_reference/functions/random_functions.md create mode 100644 docs/tr/sql_reference/functions/rounding_functions.md create mode 100644 docs/tr/sql_reference/functions/splitting_merging_functions.md create mode 100644 docs/tr/sql_reference/functions/string_functions.md create mode 100644 docs/tr/sql_reference/functions/string_replace_functions.md create mode 100644 docs/tr/sql_reference/functions/string_search_functions.md create mode 100644 docs/tr/sql_reference/functions/type_conversion_functions.md create mode 100644 docs/tr/sql_reference/functions/url_functions.md create mode 100644 docs/tr/sql_reference/functions/uuid_functions.md create mode 100644 docs/tr/sql_reference/functions/ym_dict_functions.md create mode 100644 docs/tr/sql_reference/index.md create mode 100644 docs/tr/sql_reference/operators.md create mode 100644 docs/tr/sql_reference/statements/alter.md create mode 100644 docs/tr/sql_reference/statements/create.md create mode 100644 docs/tr/sql_reference/statements/index.md create mode 100644 docs/tr/sql_reference/statements/insert_into.md create mode 100644 docs/tr/sql_reference/statements/misc.md create mode 100644 docs/tr/sql_reference/statements/select.md create mode 100644 docs/tr/sql_reference/statements/show.md create mode 100644 docs/tr/sql_reference/statements/system.md create mode 100644 docs/tr/sql_reference/syntax.md create mode 100644 docs/tr/sql_reference/table_functions/file.md create mode 100644 docs/tr/sql_reference/table_functions/generate.md create mode 100644 docs/tr/sql_reference/table_functions/hdfs.md create mode 100644 docs/tr/sql_reference/table_functions/index.md create mode 100644 docs/tr/sql_reference/table_functions/input.md create mode 100644 docs/tr/sql_reference/table_functions/jdbc.md create mode 100644 docs/tr/sql_reference/table_functions/merge.md create mode 100644 docs/tr/sql_reference/table_functions/mysql.md create mode 100644 docs/tr/sql_reference/table_functions/numbers.md create mode 100644 docs/tr/sql_reference/table_functions/odbc.md create mode 100644 docs/tr/sql_reference/table_functions/remote.md create mode 100644 docs/tr/sql_reference/table_functions/url.md create mode 100644 docs/tr/whats_new/changelog/2017.md create mode 100644 docs/tr/whats_new/changelog/2018.md create mode 100644 docs/tr/whats_new/changelog/2019.md create mode 100644 docs/tr/whats_new/changelog/index.md create mode 100644 docs/tr/whats_new/index.md create mode 100644 docs/tr/whats_new/roadmap.md create mode 100644 docs/tr/whats_new/security_changelog.md create mode 100644 website/images/flags/tr.svg create mode 100644 website/locale/tr/LC_MESSAGES/messages.mo create mode 100644 website/locale/tr/LC_MESSAGES/messages.po diff --git a/.gitignore b/.gitignore index f53598b4b4c..7acee3ad016 100644 --- a/.gitignore +++ b/.gitignore @@ -16,8 +16,8 @@ /docs/publish /docs/edit /docs/website -/docs/venv/ -/docs/tools/venv/ +/docs/venv +/docs/tools/venv /docs/tools/translate/venv /docs/tools/translate/output.md /docs/en/single.md diff --git a/docs/tools/build.py b/docs/tools/build.py index 65fc6d12f58..30a8d6f1eee 100755 --- a/docs/tools/build.py +++ b/docs/tools/build.py @@ -82,6 +82,7 @@ def build_for_lang(lang, args): 'fr': 'Français', 'ru': 'Русский', 'ja': '日本語', + 'tr': 'Türkçe', 'fa': 'فارسی' } @@ -92,6 +93,7 @@ def build_for_lang(lang, args): 'fr': 'Documentation ClickHouse %s', 'ru': 'Документация ClickHouse %s', 'ja': 'ClickHouseドキュメント %s', + 'tr': 'ClickHouse Belgeleri %s', 'fa': 'مستندات %sClickHouse' } @@ -375,7 +377,7 @@ if __name__ == '__main__': os.chdir(os.path.join(os.path.dirname(__file__), '..')) website_dir = os.path.join('..', 'website') arg_parser = argparse.ArgumentParser() - arg_parser.add_argument('--lang', default='en,es,fr,ru,zh,ja,fa') + arg_parser.add_argument('--lang', default='en,es,fr,ru,zh,ja,tr,fa') arg_parser.add_argument('--docs-dir', default='.') arg_parser.add_argument('--theme-dir', default=website_dir) arg_parser.add_argument('--website-dir', default=website_dir) diff --git a/docs/tools/make_links.sh b/docs/tools/make_links.sh index dfe9c56615d..2a27990f445 100755 --- a/docs/tools/make_links.sh +++ b/docs/tools/make_links.sh @@ -6,7 +6,7 @@ function do_make_links() { - langs=(en es zh fr ru ja fa) + langs=(en es zh fr ru ja tr fa) src_file="$1" for lang in "${langs[@]}" do diff --git a/docs/tools/translate/translate.py b/docs/tools/translate/translate.py index 5b4dc3f5486..759e5b849d2 100755 --- a/docs/tools/translate/translate.py +++ b/docs/tools/translate/translate.py @@ -63,8 +63,8 @@ def translate_toc(root, lang): def translate_po(): import babel.messages.pofile - base_dir = os.path.join(os.path.dirname(__file__), '..', '..', 'website', 'locale') - for lang in ['en', 'zh', 'es', 'fr', 'ru', 'ja', 'fa']: + base_dir = os.path.join(os.path.dirname(__file__), '..', '..', '..', 'website', 'locale') + for lang in ['en', 'zh', 'es', 'fr', 'ru', 'ja', 'tr', 'fa']: po_path = os.path.join(base_dir, lang, 'LC_MESSAGES', 'messages.po') with open(po_path, 'r') as f: po_file = babel.messages.pofile.read_po(f, locale=lang, domain='messages') diff --git a/docs/tools/translate/update-po.sh b/docs/tools/translate/update-po.sh index bf9d1d4b7fb..f2f4039bcb8 100755 --- a/docs/tools/translate/update-po.sh +++ b/docs/tools/translate/update-po.sh @@ -2,11 +2,11 @@ # Usage: update-po.sh set -ex BASE_DIR=$(dirname $(readlink -f $0)) -WEBSITE_DIR="${BASE_DIR}/../../website" +WEBSITE_DIR="${BASE_DIR}/../../../website" LOCALE_DIR="${WEBSITE_DIR}/locale" MESSAGES_POT="${LOCALE_DIR}/messages.pot" BABEL_INI="${BASE_DIR}/babel-mapping.ini" -LANGS="en zh es fr ru ja fa" +LANGS="en zh es fr ru ja tr fa" source "${BASE_DIR}/venv/bin/activate" cd "${WEBSITE_DIR}" pybabel extract "." -o "${MESSAGES_POT}" -F "${BABEL_INI}" diff --git a/docs/tr/commercial/cloud.md b/docs/tr/commercial/cloud.md new file mode 100644 index 00000000000..f20656cc428 --- /dev/null +++ b/docs/tr/commercial/cloud.md @@ -0,0 +1,21 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +--- + +# ClickHouse Bulut Servis Sağlayıcıları {#clickhouse-cloud-service-providers} + +!!! info "Bilgin" + Yönetilen ClickHouse hizmeti ile genel bir bulut başlattıysanız, çekinmeyin [çekme isteği aç](https://github.com/ClickHouse/ClickHouse/edit/master/docs/en/commercial/cloud.md) aşağıdaki listeye ekleyerek. + +## Yandex Bulut {#yandex-cloud} + +[Yandex Clickhouse için yönetilen hizmet](https://cloud.yandex.com/services/managed-clickhouse?utm_source=referrals&utm_medium=clickhouseofficialsite&utm_campaign=link3) aşağıdaki temel özellikleri sağlar: + +- İçin tamamen yönetilen ZooKeeper hizmeti [ClickHouse çoğaltma](../engines/table_engines/mergetree_family/replication.md) +- Çoklu depolama tipi seçenekleri +- Farklı kullanılabilirlik bölgelerinde yinelemeler +- Şifreleme ve izolasyon +- Otomatik bakım + +{## [Orijinal makale](https://clickhouse.tech/docs/en/commercial/cloud/) ##} diff --git a/docs/tr/commercial/index.md b/docs/tr/commercial/index.md new file mode 100644 index 00000000000..104a3427146 --- /dev/null +++ b/docs/tr/commercial/index.md @@ -0,0 +1,9 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: Ticari +toc_priority: 70 +toc_title: Ticari +--- + + diff --git a/docs/tr/development/architecture.md b/docs/tr/development/architecture.md new file mode 100644 index 00000000000..4713c2e5409 --- /dev/null +++ b/docs/tr/development/architecture.md @@ -0,0 +1,203 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 62 +toc_title: "ClickHouse mimarisine genel bak\u0131\u015F" +--- + +# ClickHouse mimarisine genel bakış {#overview-of-clickhouse-architecture} + +ClickHouse gerçek bir sütun yönelimli DBMS olduğunu. Veriler sütunlar tarafından ve dizilerin yürütülmesi sırasında (vektörler veya sütun parçaları) saklanır. Mümkün olduğunda, işlemler tek tek değerler yerine dizilere gönderilir. Buna denir “vectorized query execution,” ve gerçek veri işleme maliyetini düşürmeye yardımcı olur. + +> Bu fikir yeni bir şey değil. Bu kadar uzanır `APL` programlama dili ve Tor andunları: `A +`, `J`, `K`, ve `Q`. Dizi programlama bilimsel veri işlemede kullanılır. Bu fikir ilişkisel veritabanlarında yeni bir şey değildir: örneğin, `Vectorwise` sistem. + +Sorgu işlemeyi hızlandırmak için iki farklı yaklaşım vardır: vektörize sorgu yürütme ve çalışma zamanı kodu oluşturma. İkincisi, tüm Yönlendirme ve dinamik gönderimi kaldırır. Bu yaklaşımların hiçbiri diğerinden kesinlikle daha iyi değildir. Çalışma zamanı kodu üretimi, birçok işlemi birleştirdiğinde daha iyi olabilir, böylece CPU yürütme birimlerini ve boru hattını tam olarak kullanır. Vectorized sorgu yürütme daha az pratik olabilir, çünkü önbelleğe yazılması ve geri okunması gereken geçici vektörler içerir. Geçici veri L2 önbelleğinde uymuyorsa, bu bir sorun haline gelir. Ancak vektörize sorgu yürütme, CPU'nun SIMD yeteneklerini daha kolay kullanır. Bir [araştırma öd paperevi](http://15721.courses.cs.cmu.edu/spring2016/papers/p5-sompolski.pdf) arkadaşlarımız tarafından yazıldı, her iki yaklaşımı birleştirmenin daha iyi olduğunu gösteriyor. ClickHouse vectorized sorgu yürütme kullanır ve çalışma zamanı kodu üretimi için başlangıç desteği sınırlıdır. + +## Sütun {#columns} + +`IColumn` arabirim, bellekteki sütunları temsil etmek için kullanılır (aslında, sütunların parçaları). Bu arayüz, çeşitli ilişkisel operatörlerin uygulanması için yardımcı yöntemler sağlar. Hemen hemen tüm işlemler değişmez: orijinal sütunu değiştirmezler, ancak yeni bir değiştirilmiş bir tane oluştururlar. Örneğin, `IColumn :: filter` yöntem bir filtre bayt maskesi kabul eder. Bu için kullanılır `WHERE` ve `HAVING` ilişkisel operatörler. Ek örnekler: `IColumn :: permute` desteklemek için yöntem `ORDER BY`, bu `IColumn :: cut` desteklemek için yöntem `LIMIT`. + +Çeşitli `IColumn` uygulanışlar (`ColumnUInt8`, `ColumnString` ve benzeri) sütunların bellek düzeninden sorumludur. Bellek düzeni genellikle bitişik bir dizidir. Sütunların tamsayı türü için, sadece bir bitişik dizidir, örneğin `std :: vector`. İçin `String` ve `Array` sütunlar, iki vektördür: biri bitişik olarak yerleştirilmiş tüm dizi elemanları için ve her dizinin başlangıcına ait ofsetler için ikinci bir tane. Ayrıca var `ColumnConst` bu bellekte sadece bir değer depolar, ancak bir sütuna benziyor. + +## Alan {#field} + +Bununla birlikte, bireysel değerlerle de çalışmak mümkündür. Bireysel bir değeri temsil etmek için, `Field` kullanılır. `Field` sadece ayrımcılığa uğramış bir birlik mi `UInt64`, `Int64`, `Float64`, `String` ve `Array`. `IColumn` has the `operator[]` n - inci değerini bir olarak alma yöntemi `Field` ve... `insert` bir ekleme yöntemi `Field` bir sütunun sonuna. Bu yöntemler çok verimli değildir, çünkü geçici olarak uğraşmayı gerektirirler `Field` tek bir değeri temsil eden nesneler. Daha etkili yöntemleri vardır, mesela: `insertFrom`, `insertRangeFrom` ve bu yüzden. + +`Field` bir tablo için belirli bir veri türü hakkında yeterli bilgiye sahip değildir. Mesela, `UInt8`, `UInt16`, `UInt32`, ve `UInt64` hepsi olarak temsil edilir `UInt64` in a `Field`. + +## Sızdıran Soyutlamalar {#leaky-abstractions} + +`IColumn` verilerin ortak ilişkisel dönüşümleri için yöntemler vardır, ancak tüm ihtiyaçları karşılamazlar. Mesela, `ColumnUInt64` iki sütunun toplamını hesaplamak için bir yöntem yoktur ve `ColumnString` bir alt dize araması çalıştırmak için bir yöntem yok. Bu sayısız rutinleri dışında uygulanmaktadır `IColumn`. + +Sütunlar üzerinde çeşitli işlevler kullanarak genel, verimli olmayan bir şekilde uygulanabilir `IColumn` çıkarma yöntemleri `Field` değerleri veya belirli bir veri iç bellek düzeni bilgisini kullanarak özel bir şekilde `IColumn` uygulanış. Döküm fonksiyonları ile belirli bir `IColumn` yazın ve doğrudan iç temsil ile anlaşma. Mesela, `ColumnUInt64` has the `getData` bir iç diziye başvuru döndüren yöntem, daha sonra ayrı bir yordam okur veya bu diziyi doğrudan doldurur. Sahibiz “leaky abstractions” çeşitli rutinlerin verimli uzmanlıklarına izin vermek. + +## Veri Türleri {#data_types} + +`IDataType` seri hale getirme ve serileştirmeden sorumludur: ikili veya metin biçiminde sütunların veya bireysel değerlerin parçalarını okumak ve yazmak için. `IDataType` tablolardaki veri türlerine doğrudan karşılık gelir. Örneğin, `DataTypeUInt32`, `DataTypeDateTime`, `DataTypeString` ve böyle devam eder. + +`IDataType` ve `IColumn` sadece gevşek birbirleriyle ilişkilidir. Farklı veri türleri bellekte aynı tarafından temsil edilebilir `IColumn` uygulanışlar. Mesela, `DataTypeUInt32` ve `DataTypeDateTime` her ikisi de tarafından temsil edilir `ColumnUInt32` veya `ColumnConstUInt32`. Buna ek olarak, aynı veri türü farklı tarafından temsil edilebilir `IColumn` uygulanışlar. Mesela, `DataTypeUInt8` tarafından temsil edilebilir `ColumnUInt8` veya `ColumnConstUInt8`. + +`IDataType` yalnızca meta verileri depolar. Mesela, `DataTypeUInt8` hiçbir şey saklamıyor (vptr hariç) ve `DataTypeFixedString` mağazalar sadece `N` (sabit boyutlu dizelerin boyutu). + +`IDataType` çeşitli veri formatları için yardımcı yöntemlere sahiptir. Örnekler, Olası Alıntı ile bir değeri serileştirmek, json için bir değeri serileştirmek ve XML formatının bir parçası olarak bir değeri serileştirmek için kullanılan yöntemlerdir. Veri formatlarına doğrudan yazışma yoktur. Örneğin, farklı veri biçimleri `Pretty` ve `TabSeparated` aynı kullanabilirsiniz `serializeTextEscaped` hel methodper yöntemi `IDataType` Arabirim. + +## Blok {#block} + +A `Block` bellekteki bir tablonun bir alt kümesini (yığın) temsil eden bir kapsayıcıdır. Bu sadece üçlü bir dizi: `(IColumn, IDataType, column name)`. Sorgu yürütme sırasında veri tarafından işlenir `Block`s. Eğer bir `Block`(bu yaptığımız verileri `IColumn` nesne), biz onun türü hakkında bilgi var (içinde `IDataType`) bu bize bu sütunla nasıl başa çıkacağımızı söyler ve sütun adına sahibiz. Tablodan orijinal sütun adı veya hesaplamaların geçici sonuçlarını almak için atanan bazı yapay ad olabilir. + +Bir bloktaki sütunlar üzerinde bazı işlevleri hesapladığımızda, bloğa sonucu olan başka bir sütun ekleriz ve işlemler değişmez olduğu için işlevin argümanları için sütunlara dokunmayız. Daha sonra, gereksiz sütunlar bloktan kaldırılabilir, ancak değiştirilemez. Ortak alt ifadelerin ortadan kaldırılması için uygundur. + +İşlenen her veri yığını için bloklar oluşturulur. Aynı hesaplama türü için, sütun adları ve türleri farklı bloklar için aynı kalır ve yalnızca sütun verileri değişir unutmayın. Küçük blok boyutları shared\_ptrs ve sütun adlarını kopyalamak için geçici dizeleri yüksek bir ek yükü olduğundan blok üstbilgisinden blok verileri bölmek daha iyidir. + +## Blok Akışları {#block-streams} + +Blok akışları veri işleme içindir. Bir yerden veri okumak, veri dönüşümleri gerçekleştirmek veya bir yere veri yazmak için blok akışları kullanıyoruz. `IBlockInputStream` has the `read` mevcut iken bir sonraki bloğu getirme yöntemi. `IBlockOutputStream` has the `write` bloğu bir yere itmek için yöntem. + +Akar responsibles areular sorumludur: + +1. Bir tabloya okuma veya yazma. Tablo sadece okuma veya yazma blokları için bir akış döndürür. +2. Veri formatlarının uygulanması. Örneğin, bir terminale veri çıkışı yapmak istiyorsanız `Pretty` biçim, blokları ittiğiniz bir blok çıkış akışı oluşturursunuz ve bunları biçimlendirir. +3. Veri dönüşümleri gerçekleştirme. Diyelim ki var `IBlockInputStream` ve filtrelenmiş bir akış oluşturmak istiyorum. Yarat createtığınız `FilterBlockInputStream` ve akışı ile başlatın. Sonra bir blok çektiğinizde `FilterBlockInputStream`, akışınızdan bir blok çeker, filtreler ve filtrelenmiş bloğu size döndürür. Sorgu yürütme boru hatları bu şekilde temsil edilir. + +Daha sofistike dönüşümler var. Örneğin, çektiğiniz zaman `AggregatingBlockInputStream`, kaynağındaki tüm verileri okur, toplar ve sizin için toplanmış bir veri akışı döndürür. Başka bir örnek: `UnionBlockInputStream` yapıcıdaki birçok giriş kaynağını ve ayrıca bir dizi iş parçacığını kabul eder. Birden çok iş parçacığı başlatır ve paralel olarak birden fazla kaynaktan okur. + +> Blok akışları “pull” akışı kontrol etme yaklaşımı: ilk akıştan bir blok çektiğinizde, gerekli blokları iç içe geçmiş akışlardan çeker ve tüm yürütme boru hattı çalışır. Ne “pull” ne “push” en iyi çözümdür, çünkü kontrol akışı örtükdür ve bu, birden fazla sorgunun eşzamanlı yürütülmesi (birçok boru hattının birlikte birleştirilmesi) gibi çeşitli özelliklerin uygulanmasını sınırlar. Bu sınırlama, coroutines ile veya sadece birbirlerini bekleyen ekstra iş parçacıkları çalıştırarak aşılabilir. Kontrol akışını açık hale getirirsek daha fazla olasılığa sahip olabiliriz: verileri bir hesaplama biriminden diğerine bu hesaplama birimlerinin dışında geçirme mantığını bulursak. Re thisad this [makale](http://journal.stuffwithstuff.com/2013/01/13/iteration-inside-and-out/) daha fazla düşünce için. + +Sorgu yürütme boru hattının her adımda geçici veri oluşturduğuna dikkat etmeliyiz. Blok boyutunu yeterince küçük tutmaya çalışıyoruz, böylece geçici veriler CPU önbelleğine sığıyor. Bu varsayımla, geçici veri yazmak ve okumak, diğer hesaplamalarla karşılaştırıldığında neredeyse ücretsizdir. Boru hattındaki birçok operasyonu bir araya getirmek için bir alternatif düşünebiliriz. Boru hattını mümkün olduğunca kısa hale getirebilir ve geçici verilerin çoğunu kaldırabilir, bu da bir avantaj olabilir, ancak dezavantajları da vardır. Örneğin, bölünmüş bir boru hattı, Ara verileri önbelleğe almayı, aynı anda çalışan benzer sorgulardan Ara verileri çalmayı ve benzer sorgular için boru hatlarını birleştirmeyi kolaylaştırır. + +## Biçimliler {#formats} + +Veri formatları blok akışları ile uygulanır. Var “presentational” sadece müşteriye veri çıkışı için uygun biçimler, örneğin `Pretty` sadece sağlayan biçim `IBlockOutputStream`. Ve gibi giriş / çıkış biçimleri vardır `TabSeparated` veya `JSONEachRow`. + +Satır akışları da vardır: `IRowInputStream` ve `IRowOutputStream`. Verileri bloklarla değil, tek tek satırlarla çekmenize/itmenize izin verirler. Ve sadece satır yönelimli formatların uygulanmasını basitleştirmek için gereklidir. Sarıcı `BlockInputStreamFromRowInputStream` ve `BlockOutputStreamFromRowOutputStream` satır yönelimli akışları normal blok yönelimli akışlara dönüştürmenize izin verin. + +## I/O {#io} + +Bayt yönelimli giriş / çıkış için, `ReadBuffer` ve `WriteBuffer` soyut sınıflar. C++yerine kullanılırlar `iostream`s. merak etmeyin: her olgun C++ projesi başka bir şey kullanıyor `iostream`s iyi nedenlerden dolayı. + +`ReadBuffer` ve `WriteBuffer` sadece bitişik bir tampon ve bu tampondaki konuma işaret eden bir imleç. Uygulamalar, arabellek belleğine sahip olabilir veya sahip olmayabilir. Arabelleği aşağıdaki verilerle doldurmak için sanal bir yöntem vardır (for `ReadBuffer`) veya tamponu bir yere yıkamak için (için `WriteBuffer`). Sanal yöntemler nadiren denir. + +Uygulamaları `ReadBuffer`/`WriteBuffer` sıkıştırma uygulamak için dosyalar ve dosya tanımlayıcıları ve ağ soketleri ile çalışmak için kullanılır (`CompressedWriteBuffer` is initialized with another WriteBuffer and performs compression before writing data to it), and for other purposes – the names `ConcatReadBuffer`, `LimitReadBuffer`, ve `HashingWriteBuffer` kendileri için konuşuyoruz. + +Read / WriteBuffers sadece baytlarla ilgilenir. Fonksiyonları vardır `ReadHelpers` ve `WriteHelpers` başlık dosyaları biçimlendirme giriş/çıkış ile yardımcı olmak için. Örneğin, ondalık biçimde bir sayı yazmak için yardımcılar vardır. + +Bir sonuç kümesi yazmak istediğinizde neler olduğuna bakalım `JSON` stdout için biçimlendirin. Eğer bir sonuç getirilecek hazır set var `IBlockInputStream`. Yarat createtığınız `WriteBufferFromFileDescriptor(STDOUT_FILENO)` STDOUT için bayt yazmak için. Yarat createtığınız `JSONRowOutputStream` bununla başlatıldı `WriteBuffer`, satır yazmak için `JSON` stdout. Yarat createtığınız `BlockOutputStreamFromRowOutputStream` bu da yetmiyormuş gibi göstermek için `IBlockOutputStream`. Sonra Ara `copyData` veri aktarmak için `IBlockInputStream` -e doğru `IBlockOutputStream` ve her şey çalışıyor. İçten, `JSONRowOutputStream` çeşitli json sınırlayıcıları yazacak ve `IDataType::serializeTextJSON` bir referans ile yöntem `IColumn` ve satır numarası argüman olarak. Sonuç olarak, `IDataType::serializeTextJSON` bir yöntem çağırır `WriteHelpers.h`: mesela, `writeText` sayısal türler ve `writeJSONString` için `DataTypeString`. + +## Tablolar {#tables} + +Bu `IStorage` arayüz tabloları temsil eder. Bu arayüzün farklı uygulamaları farklı tablo motorlarıdır. Örnekler şunlardır `StorageMergeTree`, `StorageMemory` ve bu yüzden. Bu sınıfların örnekleri sadece tablolardır. + +Anahtar `IStorage` yöntemler şunlardır `read` ve `write`. Ayrıca vardır `alter`, `rename`, `drop` ve bu yüzden. Bu `read` yöntem aşağıdaki bağımsız değişkenleri kabul eder: bir tablodan okunacak sütun kümesi, `AST` dikkate alınması gereken sorgu ve döndürülmesi gereken akış sayısı. Bir veya birden fazla döndürür `IBlockInputStream` nesneler ve sorgu yürütme sırasında bir tablo altyapısı içinde tamamlanan veri işleme aşaması hakkında bilgi. + +Çoğu durumda, read yöntemi yalnızca belirtilen sütunları bir tablodan okumaktan sorumludur, daha fazla veri işleme için değil. Tüm diğer veri işleme sorgu yorumlayıcısı tarafından yapılır ve sorumluluk dışında `IStorage`. + +Ancak önemli istisnalar var: + +- AST sorgusu için geçirilir `read` yöntemi ve tablo altyapısı dizin kullanımını türetmek ve bir tablodan daha az veri okumak için kullanabilirsiniz. +- Bazen tablo motoru verileri belirli bir aşamaya kadar işleyebilir. Mesela, `StorageDistributed` uzak sunuculara sorgu gönderebilir, farklı uzak sunuculardan gelen verilerin birleştirilebileceği bir aşamaya veri işlemelerini isteyebilir ve bu önceden işlenmiş verileri döndürebilir. Sorgu yorumlayıcısı daha sonra verileri işlemeyi tamamlar. + +Tablo `read` yöntem birden çok döndürebilir `IBlockInputStream` nesneleri paralel veri işleme izin vermek için. Bu çoklu blok giriş akışları bir tablodan paralel olarak okuyabilir. Ardından, bu akışları bağımsız olarak hesaplanabilen çeşitli dönüşümlerle (ifade değerlendirme veya filtreleme gibi) sarabilir ve bir `UnionBlockInputStream` bunların üzerine, paralel olarak birden fazla akıştan okumak için. + +Ayrıca vardır `TableFunction`s. bunlar geçici olarak dönen işlevlerdir `IStorage` içinde kullanılacak nesne `FROM` bir sorgu yan tümcesi. + +Tablo motorunuzu nasıl uygulayacağınıza dair hızlı bir fikir edinmek için, basit bir şeye bakın `StorageMemory` veya `StorageTinyLog`. + +> Bu sonucu `read` yöntem, `IStorage` dönüşler `QueryProcessingStage` – information about what parts of the query were already calculated inside storage. + +## Ayrıştırıcılar {#parsers} + +Elle yazılmış özyinelemeli iniş ayrıştırıcı bir sorgu ayrıştırır. Mesela, `ParserSelectQuery` sorgunun çeşitli bölümleri için temel ayrıştırıcıları yinelemeli olarak çağırır. Ayrıştırıcılar bir `AST`. Bu `AST` örnekleri olan düğüm bylerle temsil edilir `IAST`. + +> Ayrıştırıcı jeneratörler tarihsel nedenlerle kullanılmaz. + +## Tercümanlar {#interpreters} + +Sorgu yürütme kanalının oluşturulmasından tercümanlar sorumludur. `AST`. Gibi basit tercümanlar vardır `InterpreterExistsQuery` ve `InterpreterDropQuery` veya daha sofistike `InterpreterSelectQuery`. Sorgu yürütme boru hattı, blok giriş veya çıkış akışlarının birleşimidir. Örneğin, yorumlama sonucu `SELECT` sorgu olduğunu `IBlockInputStream` sonuç kümesini okumak için; INSERT sorgusunun sonucu `IBlockOutputStream` ekleme için veri yazmak ve yorumlama sonucu `INSERT SELECT` sorgu olduğunu `IBlockInputStream` bu, ilk okumada boş bir sonuç kümesi döndürür, ancak verileri kopyalar `SELECT` -e doğru `INSERT` aynı zamanda. + +`InterpreterSelectQuery` kullanma `ExpressionAnalyzer` ve `ExpressionActions` sorgu analizi ve dönüşümler için makine. Bu, kural tabanlı sorgu iyileştirmelerinin çoğunun yapıldığı yerdir. `ExpressionAnalyzer` oldukça dağınık ve yeniden yazılmalıdır: modüler dönüşümlere veya sorguya izin vermek için ayrı sınıflara çeşitli sorgu dönüşümleri ve optimizasyonlar çıkarılmalıdır. + +## İşlevler {#functions} + +Sıradan fonksiyonlar ve toplam fonksiyonlar vardır. Toplama işlevleri için bir sonraki bölüme bakın. + +Ordinary functions don't change the number of rows – they work as if they are processing each row independently. In fact, functions are not called for individual rows, but for `Block`'s vectorized sorgu yürütme uygulamak için veri. + +Gibi bazı çeşitli fonksiyonlar vardır [blockSize](../sql_reference/functions/other_functions.md#function-blocksize), [rowNumberİnBlock](../sql_reference/functions/other_functions.md#function-rownumberinblock), ve [runningAccumulate](../sql_reference/functions/other_functions.md#function-runningaccumulate), blok işlemeyi istismar eden ve satırların bağımsızlığını ihlal eden. + +Clickhouse'un güçlü yazımı var, bu yüzden örtük tür dönüşümü yok. Bir işlev belirli bir tür kombinasyonunu desteklemiyorsa, bir istisna atar. Ancak, birçok farklı tür kombinasyonu için işlevler çalışabilir (aşırı yüklenebilir). Örneğin, `plus` fonksiyonu (uygulamak için `+` operatör) sayısal türlerin herhangi bir kombinasyonu için çalışır: `UInt8` + `Float32`, `UInt16` + `Int8` ve bu yüzden. Ayrıca, bazı variadic işlevleri gibi bağımsız değişkenlerin herhangi bir sayıda kabul edebilir `concat` işlev. + +Bir işlev açıkça desteklenen veri türlerini gönderir ve desteklenen çünkü bir işlev uygulamak biraz rahatsız edici olabilir `IColumns`. Örneğin, `plus` işlev, sayısal türlerin ve sabit veya sabit olmayan sol ve sağ bağımsız değişkenlerin her birleşimi için bir C++ şablonunun örneklendirilmesiyle oluşturulan koda sahiptir. + +Bu şablon kodu kabartmak önlemek için çalışma zamanı kodu nesil uygulamak için mükemmel bir yerdir. Ayrıca, kaynaşmış çarpma-ekleme gibi kaynaşmış işlevler eklemeyi veya bir döngü yinelemesinde birden fazla karşılaştırma yapmayı mümkün kılar. + +Vektörize sorgu yürütme nedeniyle, işlevler kısa devre değildir. Örneğin, yazarsanız `WHERE f(x) AND g(y)`, her iki taraf da satırlar için bile hesaplanır `f(x)` sıfırdır (hariç `f(x)` sıfır sabit bir ifadedir). Ama eğer seçicilik `f(x)` durum yüksek ve hesaplama `f(x)` çok daha ucuzdur `g(y)`, çok geçişli hesaplama uygulamak daha iyidir. İlk önce hesaplayacaktı `f(x)`, daha sonra sonucu sütunları süzün ve sonra hesaplayın `g(y)` sadece daha küçük, filtrelenmiş veri parçaları için. + +## Toplama Fonksiyonları {#aggregate-functions} + +Toplama işlevleri durumsal işlevlerdir. Geçirilen değerleri bir duruma biriktirir ve bu durumdan sonuç almanıza izin verir. İle Yönet theyil theirler. `IAggregateFunction` Arabirim. Devletler oldukça basit olabilir (devlet `AggregateFunctionCount` sadece bir tek `UInt64` değeri) veya oldukça karmaşık (devlet `AggregateFunctionUniqCombined` doğrusal bir dizi, bir karma tablo ve bir kombinasyonudur `HyperLogLog` olasılıksal veri yapısı). + +Devletler tahsis edilir `Arena` (bir bellek havuzu) yüksek önemlilik yürütürken birden çok durumla başa çıkmak için `GROUP BY` sorgu. Devletler önemsiz olmayan bir yapıcı ve yıkıcı olabilir: örneğin, karmaşık toplama durumları ek belleği kendileri tahsis edebilir. Devletlerin yaratılmasına ve yok edilmesine ve mülkiyet ve yıkım düzeninin doğru bir şekilde geçmesine biraz dikkat gerektirir. + +Toplama durumları serileştirilmiş ve dağıtılmış sorgu yürütme sırasında ağ üzerinden geçmek veya bunları yeterli RAM olmadığı diskte yazmak için serileştirilmiş. Hatta bir tablo ile saklanabilir `DataTypeAggregateFunction` verilerin artımlı toplanmasına izin vermek için. + +> Toplu işlev durumları için seri hale getirilmiş veri biçimi şu anda sürümlendirilmemiş. Toplama durumları yalnızca geçici olarak saklanırsa sorun olmaz. Ama biz var `AggregatingMergeTree` artan toplama için tablo motoru ve insanlar zaten üretimde kullanıyor. Gelecekte herhangi bir toplama işlevi için seri hale getirilmiş biçimi değiştirirken geriye dönük uyumluluğun gerekli olmasının nedeni budur. + +## Hizmetçi {#server} + +Sunucu birkaç farklı arayüz uygular: + +- Herhangi bir yabancı istemciler için bir HTTP arabirimi. +- Dağıtılmış sorgu yürütme sırasında yerel ClickHouse istemcisi ve sunucular arası iletişim için bir TCP arabirimi. +- Çoğaltma için veri aktarımı için bir arabirim. + +DAHİLİ olarak, coroutines veya lifler olmadan sadece ilkel bir çok iş parçacıklı sunucudur. Sunucu, yüksek oranda basit sorguları işlemek için değil, nispeten düşük oranda karmaşık sorguları işlemek için tasarlandığından, her biri analitik için çok miktarda veri işleyebilir. + +Sunucu başlatır `Context` sorgu yürütme için gerekli ortama sahip sınıf: kullanılabilir veritabanlarının, kullanıcıların ve erişim haklarının, ayarların, kümelerin, işlem listesinin, sorgu günlüğünün vb. listesi. Tercümanlar bu ortamı kullanır. + +Sunucu TCP protokolü için tam geriye ve ileriye dönük uyumluluk sağlıyoruz: eski istemciler yeni sunucularla konuşabilir ve yeni istemciler eski sunucularla konuşabilir. Ancak sonsuza dek korumak istemiyoruz ve yaklaşık bir yıl sonra eski sürümler için destek kaldırıyoruz. + +!!! note "Not" + Çoğu harici uygulama için, HTTP arayüzünü kullanmanızı öneririz, çünkü basit ve kullanımı kolaydır. TCP protokolü, iç veri yapılarına daha sıkı bir şekilde bağlanır: veri bloklarını geçirmek için bir iç biçim kullanır ve sıkıştırılmış veriler için özel çerçeveleme kullanır. Bu protokol için bir C kütüphanesi yayınlamadık çünkü pratik olmayan ClickHouse kod tabanının çoğunu bağlamayı gerektiriyor. + +## Dağıtılmış Sorgu Yürütme {#distributed-query-execution} + +Bir küme kurulumundaki sunucular çoğunlukla bağımsızdır. Sen-ebilmek yaratmak a `Distributed` bir kümedeki bir veya tüm sunucularda tablo. Bu `Distributed` table does not store data itself – it only provides a “view” Bir kümenin birden çok düğümündeki tüm yerel tablolara. Bir seçtiğinizde `Distributed` tablo, bu sorguyu yeniden yazar, Yük Dengeleme ayarlarına göre uzak düğümleri seçer ve sorguyu onlara gönderir. Bu `Distributed` tablo, farklı sunuculardan gelen Ara sonuçların birleştirilebileceği bir aşamaya kadar bir sorguyu işlemek için uzak sunuculardan ister. Sonra Ara sonuçları alır ve onları birleştirir. Dağıtılmış tablo, uzak sunuculara mümkün olduğunca fazla çalışma dağıtmaya çalışır ve ağ üzerinden çok fazla ara veri göndermez. + +In veya JOIN yan tümcelerinde alt sorgular olduğunda işler daha karmaşık hale gelir ve her biri bir `Distributed` Tablo. Bu sorguların yürütülmesi için farklı stratejilerimiz var. + +Dağıtılmış sorgu yürütme için genel bir sorgu planı yoktur. Her düğüm, işin kendi kısmı için yerel sorgu planına sahiptir. Biz sadece basit tek geçişli dağıtılmış sorgu yürütme var: biz uzak düğümler için sorgular göndermek ve sonra sonuçları birleştirmek. Ancak bu, yüksek önemlilik grubu BYs ile veya JOIN için büyük miktarda geçici veri içeren karmaşık sorgular için mümkün değildir. Bu gibi durumlarda, gerek “reshuffle” ek koordinasyon gerektiren sunucular arasındaki veriler. ClickHouse bu tür bir sorgu yürütülmesini desteklemiyor ve üzerinde çalışmamız gerekiyor. + +## Ağaç Birleştirme {#merge-tree} + +`MergeTree` birincil anahtarla dizin oluşturmayı destekleyen bir depolama altyapısı ailesidir. Birincil anahtar, isteğe bağlı bir sütun veya ifade kümesi olabilir. Veri `MergeTree` tablo saklanır “parts”. Her bölüm verileri birincil anahtar sırasına göre saklar, böylece veriler birincil anahtar tuple tarafından lexicographically sıralanır. Tüm tablo sütunları ayrı olarak saklanır `column.bin` bu kısımlardaki dosyalar. Dosyalar sıkıştırılmış bloklardan oluşur. Her blok, ortalama değer boyutuna bağlı olarak genellikle 64 KB ila 1 MB sıkıştırılmamış veridir. Bloklar, birbiri ardına bitişik olarak yerleştirilmiş sütun değerlerinden oluşur. Sütun değerleri her sütun için aynı sıradadır (birincil anahtar siparişi tanımlar), bu nedenle birçok sütun tarafından yineleme yaptığınızda, karşılık gelen satırlar için değerler alırsınız. + +Birincil anahtarın kendisi “sparse”. Her satır Adres yok ama verilerin sadece biraz değişir. Ayıran `primary.idx` dosya, n'nin çağrıldığı her N-inci satır için birincil anahtarın değerine sahiptir `index_granularity` (genellikle, n = 8192). Ayrıca, her sütun için, biz var `column.mrk` dosyaları ile “marks,” veri dosyasındaki her N-inci satıra ofset olan. Her işaret bir çifttir: dosyadaki ofset sıkıştırılmış bloğun başlangıcına ve sıkıştırılmış bloktaki ofset verilerin başlangıcına. Genellikle, sıkıştırılmış bloklar işaretlerle hizalanır ve sıkıştırılmış bloktaki ofset sıfırdır. İçin veri `primary.idx` her zaman bellekte bulunur ve veri `column.mrk` dosyalar önbelleğe alınır. + +Bir kısm aından bir şey okuy readacağımız zaman `MergeTree` bak biz `primary.idx` veri ve istenen verileri içerebilecek aralıkları bulun, ardından `column.mrk` veri ve bu aralıkları okumaya başlamak için nerede için uzaklıklar hesaplayın. Çünkü seyrek, fazla veri okunabilir. ClickHouse, basit nokta sorgularının yüksek bir yükü için uygun değildir, çünkü tüm Aralık `index_granularity` her anahtar için satırlar okunmalı ve her sütun için sıkıştırılmış bloğun tamamı sıkıştırılmalıdır. Dizin için fark edilebilir bellek tüketimi olmadan tek bir sunucu başına trilyonlarca satır tutabilmemiz gerektiğinden dizini seyrek yaptık. Ayrıca, birincil anahtar seyrek olduğundan, benzersiz değildir: ekleme zamanında tablodaki anahtarın varlığını denetleyemez. Bir tabloda aynı anahtara sahip birçok satır olabilir. + +Ne zaman sen `INSERT` içine veri bir demet `MergeTree`, bu grup birincil anahtar sırasına göre sıralanır ve yeni bir bölüm oluşturur. Bazı parçaları periyodik olarak seçen ve parça sayısını nispeten düşük tutmak için bunları tek bir sıralanmış parçaya birleştiren arka plan iş parçacıkları vardır. Bu yüzden denir `MergeTree`. Tabii ki, birleştirme yol açar “write amplification”. Tüm parçalar değişmez: sadece oluşturulur ve silinir, ancak değiştirilmez. SELECT yürütüldüğünde, tablonun bir anlık görüntüsünü (bir parça kümesi) tutar. Birleştirildikten sonra, arızadan sonra iyileşmeyi kolaylaştırmak için eski parçaları bir süre tutuyoruz, bu nedenle birleştirilmiş bir parçanın muhtemelen kırıldığını görürsek, kaynak parçalarıyla değiştirebiliriz. + +`MergeTree` içermediği için bir lsm ağacı değildir “memtable” ve “log”: inserted data is written directly to the filesystem. This makes it suitable only to INSERT data in batches, not by individual row and not very frequently – about once per second is ok, but a thousand times a second is not. We did it this way for simplicity's sake, and because we are already inserting data in batches in our applications. + +> MergeTree tabloları yalnızca bir (birincil) dizine sahip olabilir: herhangi bir ikincil dizin yoktur. Bir mantıksal tablo altında birden fazla fiziksel gösterime izin vermek, örneğin verileri birden fazla fiziksel sırayla depolamak veya hatta orijinal verilerle birlikte önceden toplanmış verilerle gösterimlere izin vermek güzel olurdu. + +Arka plan birleştirmeleri sırasında ek iş yapan MergeTree motorları vardır. Örnekler şunlardır `CollapsingMergeTree` ve `AggregatingMergeTree`. Bu, güncellemeler için özel destek olarak kabul edilebilir. Kullanıcıların genellikle arka plan birleştirmeleri yürütüldüğünde zaman üzerinde hiçbir kontrole sahip çünkü bu gerçek güncellemeler olmadığını unutmayın, ve bir veri `MergeTree` tablo hemen hemen her zaman tamamen birleştirilmiş formda değil, birden fazla bölümde saklanır. + +## Çoğalma {#replication} + +Clickhouse çoğaltma başına tablo bazında yapılandırılabilir. Aynı sunucuda bazı çoğaltılmış ve bazı çoğaltılmamış tablolar olabilir. Ayrıca, iki faktörlü çoğaltmaya sahip bir tablo ve üç faktörlü bir tablo gibi farklı şekillerde çoğaltılmış tablolar da olabilir. + +Çoğaltma uygulanır `ReplicatedMergeTree` depolama motoru. The path in `ZooKeeper` depolama altyapısı için bir parametre olarak belirtilir. Aynı yolu olan tüm tablolar `ZooKeeper` birbirlerinin kopyaları haline gelir: verilerini senkronize eder ve tutarlılığı korurlar. Yinelemeler, bir tablo oluşturarak veya bırakarak dinamik olarak eklenebilir ve kaldırılabilir. + +Çoğaltma, zaman uyumsuz bir çoklu ana düzeni kullanır. Bir oturum olan herhangi bir yinelemeye veri ekleyebilirsiniz. `ZooKeeper` ve veriler diğer tüm yinelemelere zaman uyumsuz olarak çoğaltılır. ClickHouse güncelleştirmeleri desteklemediğinden, çoğaltma çakışmaz. Eklerin çekirdek onayı olmadığından, bir düğüm başarısız olursa, yalnızca eklenen veriler kaybolabilir. + +Çoğaltma için meta veri zookeeper saklanır. Hangi eylemlerin yapılacağını listeleyen bir çoğaltma günlüğü vardır. Eylemler şunlardır: parça al; parçaları Birleştir; bir bölüm bırak vb. Her çoğaltma, çoğaltma günlüğünü kendi kuyruğuna kopyalar ve sonra da sıradaki eylemleri yürütür. Örneğin, ekleme, “get the part” eylem günlüğüne oluşturulur ve her çoğaltma bu bölümü indirir. Birleştirmeler, baytla aynı sonuçları elde etmek için yinelemeler arasında koordine edilir. Tüm parçalar tüm kopyalarda aynı şekilde birleştirilir. Bir kopyayı lider olarak seçerek elde edilir ve bu çoğaltma birleştirir ve yazar “merge parts” günlük eylemler. + +Çoğaltma fiziksel: yalnızca sıkıştırılmış parçalar sorgular değil düğümler arasında aktarılır. Birleştirmeler, çoğu durumda ağ amplifikasyonundan kaçınarak ağ maliyetlerini düşürmek için her yinelemede bağımsız olarak işlenir. Büyük birleştirilmiş parçalar, yalnızca önemli çoğaltma gecikmesi durumunda ağ üzerinden gönderilir. + +Ayrıca, her bir kopya, ZooKeeper içindeki durumunu parça seti ve sağlama toplamı olarak depolar. Yerel dosya sistemindeki durum ZooKeeper referans durumundan ayrıldığında, kopya diğer kopyalardan eksik ve bozuk parçaları indirerek tutarlılığını geri yükler. Yerel dosya sisteminde beklenmeyen veya bozuk bazı veriler olduğunda, ClickHouse onu kaldırmaz, ancak ayrı bir dizine taşır ve unutur. + +!!! note "Not" + ClickHouse kümesi bağımsız parçalardan oluşur ve her parça kopyalardan oluşur. Küme **elastik değil**, böylece yeni bir parça ekledikten sonra, veriler otomatik olarak kırıklar arasında yeniden dengelenmez. Bunun yerine, küme yükünün eşit olmayan şekilde ayarlanması gerekiyor. Bu uygulama size daha fazla kontrol sağlar ve onlarca düğüm gibi nispeten küçük kümeler için uygundur. Ancak üretimde kullandığımız yüzlerce düğüm içeren kümeler için bu yaklaşım önemli bir dezavantaj haline gelir. Kümeler arasında otomatik olarak bölünebilen ve dengelenebilen dinamik olarak çoğaltılmış bölgelerle kümeye yayılan bir tablo altyapısı uygulamalıyız. + +{## [Orijinal makale](https://clickhouse.tech/docs/en/development/architecture/) ##} diff --git a/docs/tr/development/browse_code.md b/docs/tr/development/browse_code.md new file mode 100644 index 00000000000..dacebf01050 --- /dev/null +++ b/docs/tr/development/browse_code.md @@ -0,0 +1,14 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 63 +toc_title: "ClickHouse Kaynak Koduna G\xF6z At\u0131n" +--- + +# ClickHouse Kaynak Koduna Göz Atın {#browse-clickhouse-source-code} + +Kullanabilirsiniz **Woboq** online kod tarayıcı mevcut [burada](https://clickhouse.tech/codebrowser/html_report///ClickHouse/src/index.html). Bu kod navigasyon ve semantik vurgulama, arama ve indeksleme sağlar. Kod anlık görüntüsü günlük olarak güncellenir. + +Ayrıca, kaynaklara göz atabilirsiniz [GitHub](https://github.com/ClickHouse/ClickHouse) herzamanki. + +IDE'NİN ne kullanacağı ile ilgileniyorsanız, CLion, QT Creator, vs Code ve KDevelop (uyarılar ile) öneririz. Herhangi bir favori IDE kullanabilirsiniz. Vim ve Emacs da sayılır. diff --git a/docs/tr/development/build.md b/docs/tr/development/build.md new file mode 100644 index 00000000000..3a3cda15f1b --- /dev/null +++ b/docs/tr/development/build.md @@ -0,0 +1,141 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 64 +toc_title: "Linux \xFCzerinde ClickHouse nas\u0131l olu\u015Fturulur" +--- + +# Geliştirme için ClickHouse nasıl inşa edilir {#how-to-build-clickhouse-for-development} + +Aşağıdaki öğretici Ubuntu Linux sistemine dayanmaktadır. +Uygun değişikliklerle, başka herhangi bir Linux dağıtımı üzerinde de çalışması gerekir. +Desteklenen platformlar: x86\_64 ve AArch64. Power9 için destek deneyseldir. + +## Git, Cmake, Python ve Ninja'yı yükleyin {#install-git-cmake-python-and-ninja} + +``` bash +$ sudo apt-get install git cmake python ninja-build +``` + +Veya eski sistemlerde cmake yerine cmake3. + +## Gcc 9'u yükle {#install-gcc-9} + +Bunu yapmak için çeşitli yollar vardır. + +### Bir PPA paketinden yükleme {#install-from-a-ppa-package} + +``` bash +$ sudo apt-get install software-properties-common +$ sudo apt-add-repository ppa:ubuntu-toolchain-r/test +$ sudo apt-get update +$ sudo apt-get install gcc-9 g++-9 +``` + +### Kaynaklardan yükleyin {#install-from-sources} + +Bakmak [utils/ci/build-gcc-from-sources.sh](https://github.com/ClickHouse/ClickHouse/blob/master/utils/ci/build-gcc-from-sources.sh) + +## Yapılar için GCC 9 kullanın {#use-gcc-9-for-builds} + +``` bash +$ export CC=gcc-9 +$ export CXX=g++-9 +``` + +## Checkout ClickHouse Kaynakları {#checkout-clickhouse-sources} + +``` bash +$ git clone --recursive git@github.com:ClickHouse/ClickHouse.git +``` + +veya + +``` bash +$ git clone --recursive https://github.com/ClickHouse/ClickHouse.git +``` + +## ClickHouse İnşa {#build-clickhouse} + +``` bash +$ cd ClickHouse +$ mkdir build +$ cd build +$ cmake .. +$ ninja +$ cd .. +``` + +Bir yürütülebilir dosya oluşturmak için çalıştırın `ninja clickhouse`. +Bu yaratacak `programs/clickhouse` ile kullanılabilecek çalıştırılabilir `client` veya `server` değişkenler. + +# Herhangi bir Linux üzerinde ClickHouse nasıl oluşturulur {#how-to-build-clickhouse-on-any-linux} + +Yapı aşağıdaki bileşenleri gerektirir: + +- Git (yalnızca kaynakları kontrol etmek için kullanılır, yapı için gerekli değildir) +- Cmake 3.10 veya daha yeni +- Ninja (önerilir) veya yapmak +- C ++ derleyici: gcc 9 veya clang 8 veya daha yeni +- Linker :lld veya altın (klasik GNU ld çalışmaz) +- Python (sadece LLVM yapısında kullanılır ve isteğe bağlıdır) + +Tüm bileşenler yüklüyse, yukarıdaki adımlarla aynı şekilde oluşturabilirsiniz. + +Ubuntu Eoan için örnek: + + sudo apt update + sudo apt install git cmake ninja-build g++ python + git clone --recursive https://github.com/ClickHouse/ClickHouse.git + mkdir build && cd build + cmake ../ClickHouse + ninja + +OpenSUSE Tumbleweed için örnek: + + sudo zypper install git cmake ninja gcc-c++ python lld + git clone --recursive https://github.com/ClickHouse/ClickHouse.git + mkdir build && cd build + cmake ../ClickHouse + ninja + +Fedora Rawhide için örnek: + + sudo yum update + yum --nogpg install git cmake make gcc-c++ python2 + git clone --recursive https://github.com/ClickHouse/ClickHouse.git + mkdir build && cd build + cmake ../ClickHouse + make -j $(nproc) + +# ClickHouse inşa etmek zorunda değilsiniz {#you-dont-have-to-build-clickhouse} + +ClickHouse önceden oluşturulmuş ikili ve paketlerde mevcuttur. İkili dosyalar taşınabilir ve herhangi bir Linux lezzet üzerinde çalıştırılabilir. + +Onlar sürece her Master taahhüt ve her çekme isteği için kararlı, prestable ve test bültenleri için inşa edilmiştir. + +En taze yapıyı bulmak için `master`, go to [taahhüt sayfası](https://github.com/ClickHouse/ClickHouse/commits/master), commit yakınındaki ilk yeşil onay işaretini veya kırmızı çarpı işaretini tıklayın ve “Details” hemen sonra bağlantı “ClickHouse Build Check”. + +# ClickHouse Debian paketi nasıl oluşturulur {#how-to-build-clickhouse-debian-package} + +## Git ve Pbuilder'ı yükleyin {#install-git-and-pbuilder} + +``` bash +$ sudo apt-get update +$ sudo apt-get install git python pbuilder debhelper lsb-release fakeroot sudo debian-archive-keyring debian-keyring +``` + +## Checkout ClickHouse Kaynakları {#checkout-clickhouse-sources-1} + +``` bash +$ git clone --recursive --branch master https://github.com/ClickHouse/ClickHouse.git +$ cd ClickHouse +``` + +## Run Release Script {#run-release-script} + +``` bash +$ ./release +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/development/build/) diff --git a/docs/tr/development/build_cross_arm.md b/docs/tr/development/build_cross_arm.md new file mode 100644 index 00000000000..d0d18162d6f --- /dev/null +++ b/docs/tr/development/build_cross_arm.md @@ -0,0 +1,43 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 67 +toc_title: "AARCH64 (ARM64) i\xE7in Linux'ta ClickHouse nas\u0131l olu\u015Fturulur)" +--- + +# AARCH64 (ARM64) mimarisi için Linux'ta ClickHouse nasıl oluşturulur {#how-to-build-clickhouse-on-linux-for-aarch64-arm64-architecture} + +Bu, Linux makineniz olduğunda ve onu oluşturmak için kullanmak istediğinizde geçerlidir `clickhouse` AARCH64 CPU mimarisi ile başka bir Linux makinede çalışacak ikili. Bu, Linux sunucularında çalışan sürekli entegrasyon kontrolleri için tasarlanmıştır. + +AARCH64 için çapraz yapı, [Inşa talimatları](build.md) önce onları takip et. + +# Clang-8'i Yükle {#install-clang-8} + +Yönergeleri izleyin https://apt.llvm.org / Ubuntu veya Debian kurulumunuz için. +Örneğin, Ubuntu Bionic'te aşağıdaki komutları kullanabilirsiniz: + +``` bash +echo "deb [trusted=yes] http://apt.llvm.org/bionic/ llvm-toolchain-bionic-8 main" | sudo tee /etc/apt/sources.list.d/llvm.list +sudo apt-get update +sudo apt-get install clang-8 +``` + +# Çapraz Derleme Araç Setini Yükle {#install-cross-compilation-toolset} + +``` bash +cd ClickHouse +mkdir -p build-aarch64/cmake/toolchain/linux-aarch64 +wget 'https://developer.arm.com/-/media/Files/downloads/gnu-a/8.3-2019.03/binrel/gcc-arm-8.3-2019.03-x86_64-aarch64-linux-gnu.tar.xz?revision=2e88a73f-d233-4f96-b1f4-d8b36e9bb0b9&la=en' -O gcc-arm-8.3-2019.03-x86_64-aarch64-linux-gnu.tar.xz +tar xJf gcc-arm-8.3-2019.03-x86_64-aarch64-linux-gnu.tar.xz -C build-aarch64/cmake/toolchain/linux-aarch64 --strip-components=1 +``` + +# ClickHouse İnşa {#build-clickhouse} + +``` bash +cd ClickHouse +mkdir build-arm64 +CC=clang-8 CXX=clang++-8 cmake . -Bbuild-arm64 -DCMAKE_TOOLCHAIN_FILE=cmake/linux/toolchain-aarch64.cmake +ninja -C build-arm64 +``` + +Ortaya çıkan ikili, yalnızca AARCH64 CPU mimarisi ile Linux'ta çalışacaktır. diff --git a/docs/tr/development/build_cross_osx.md b/docs/tr/development/build_cross_osx.md new file mode 100644 index 00000000000..2001ad985e2 --- /dev/null +++ b/docs/tr/development/build_cross_osx.md @@ -0,0 +1,64 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 66 +toc_title: "Mac OS X i\xE7in Linux'ta ClickHouse nas\u0131l olu\u015Fturulur" +--- + +# Mac OS X için Linux'ta ClickHouse nasıl oluşturulur {#how-to-build-clickhouse-on-linux-for-mac-os-x} + +Bu, Linux makineniz olduğunda ve onu oluşturmak için kullanmak istediğinizde geçerlidir `clickhouse` OS X üzerinde çalışacak ikili. bu, Linux sunucularında çalışan sürekli entegrasyon kontrolleri için tasarlanmıştır. Clickhouse'u doğrudan Mac OS X'te oluşturmak istiyorsanız, devam edin [başka bir talimat](build_osx.md). + +Mac OS X için çapraz yapı, [Inşa talimatları](build.md) önce onları takip et. + +# Clang-8'i Yükle {#install-clang-8} + +Yönergeleri izleyin https://apt.llvm.org / Ubuntu veya Debian kurulumunuz için. +Örneğin biyonik için komutlar gibidir: + +``` bash +sudo echo "deb [trusted=yes] http://apt.llvm.org/bionic/ llvm-toolchain-bionic-8 main" >> /etc/apt/sources.list +sudo apt-get install clang-8 +``` + +# Çapraz Derleme Araç Setini Yükle {#install-cross-compilation-toolset} + +Yüklediğimiz yolu hatırlayalım `cctools` olarak $ {CCTOOLS} + +``` bash +mkdir ${CCTOOLS} + +git clone https://github.com/tpoechtrager/apple-libtapi.git +cd apple-libtapi +INSTALLPREFIX=${CCTOOLS} ./build.sh +./install.sh +cd .. + +git clone https://github.com/tpoechtrager/cctools-port.git +cd cctools-port/cctools +./configure --prefix=${CCTOOLS} --with-libtapi=${CCTOOLS} --target=x86_64-apple-darwin +make install +``` + +Ayrıca, MacOS X SDK'YI çalışma ağacına indirmemiz gerekiyor. + +``` bash +cd ClickHouse +wget 'https://github.com/phracker/MacOSX-SDKs/releases/download/10.14-beta4/MacOSX10.14.sdk.tar.xz' +mkdir -p build-darwin/cmake/toolchain/darwin-x86_64 +tar xJf MacOSX10.14.sdk.tar.xz -C build-darwin/cmake/toolchain/darwin-x86_64 --strip-components=1 +``` + +# ClickHouse İnşa {#build-clickhouse} + +``` bash +cd ClickHouse +mkdir build-osx +CC=clang-8 CXX=clang++-8 cmake . -Bbuild-osx -DCMAKE_TOOLCHAIN_FILE=cmake/darwin/toolchain-x86_64.cmake \ + -DCMAKE_AR:FILEPATH=${CCTOOLS}/bin/x86_64-apple-darwin-ar \ + -DCMAKE_RANLIB:FILEPATH=${CCTOOLS}/bin/x86_64-apple-darwin-ranlib \ + -DLINKER_NAME=${CCTOOLS}/bin/x86_64-apple-darwin-ld +ninja -C build-osx +``` + +Ortaya çıkan ikili bir Mach-O yürütülebilir biçimine sahip olacak ve Linux üzerinde çalıştırılamaz. diff --git a/docs/tr/development/build_osx.md b/docs/tr/development/build_osx.md new file mode 100644 index 00000000000..af750725070 --- /dev/null +++ b/docs/tr/development/build_osx.md @@ -0,0 +1,93 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 65 +toc_title: "Mac OS X \xFCzerinde ClickHouse nas\u0131l olu\u015Fturulur" +--- + +# Mac OS X üzerinde ClickHouse nasıl oluşturulur {#how-to-build-clickhouse-on-mac-os-x} + +Build Mac OS X 10.15 (Catalina) üzerinde çalışmalıdır) + +## Homebrew Yüklemek {#install-homebrew} + +``` bash +$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" +``` + +## Gerekli derleyicileri, araçları ve kitaplıkları yükleyin {#install-required-compilers-tools-and-libraries} + +``` bash +$ brew install cmake ninja libtool gettext +``` + +## Checkout ClickHouse Kaynakları {#checkout-clickhouse-sources} + +``` bash +$ git clone --recursive git@github.com:ClickHouse/ClickHouse.git +``` + +veya + +``` bash +$ git clone --recursive https://github.com/ClickHouse/ClickHouse.git + +$ cd ClickHouse +``` + +## ClickHouse İnşa {#build-clickhouse} + +``` bash +$ mkdir build +$ cd build +$ cmake .. -DCMAKE_CXX_COMPILER=`which clang++` -DCMAKE_C_COMPILER=`which clang` +$ ninja +$ cd .. +``` + +## Uyarılar {#caveats} + +Clickhouse-server çalıştırmak istiyorsanız, sistemin maxfiles değişken artırmak için emin olun. + +!!! info "Not" + Sudo kullanmanız gerekecek. + +Bunu yapmak için aşağıdaki dosyayı oluşturun: + +/ Kütüphane / LaunchDaemons / sınırı.maxfiles.plist: + +``` xml + + + + + Label + limit.maxfiles + ProgramArguments + + launchctl + limit + maxfiles + 524288 + 524288 + + RunAtLoad + + ServiceIPC + + + +``` + +Aşağıdaki komutu çalıştırın: + +``` bash +$ sudo chown root:wheel /Library/LaunchDaemons/limit.maxfiles.plist +``` + +Başlatmak. + +Çalışıp çalışmadığını kontrol etmek için şunları kullanabilirsiniz `ulimit -n` komut. + +[Orijinal makale](https://clickhouse.tech/docs/en/development/build_osx/) diff --git a/docs/tr/development/contrib.md b/docs/tr/development/contrib.md new file mode 100644 index 00000000000..7f09d9bc49b --- /dev/null +++ b/docs/tr/development/contrib.md @@ -0,0 +1,42 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 70 +toc_title: "Kullan\u0131lan \xDC\xE7\xFCnc\xFC Taraf K\xFCt\xFCphaneleri" +--- + +# Kullanılan Üçüncü Taraf Kütüphaneleri {#third-party-libraries-used} + +| Kitaplık | Lisans | +|---------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------| +| base64 | [BSD 2-Clause Lisansı](https://github.com/aklomp/base64/blob/a27c565d1b6c676beaf297fe503c4518185666f7/LICENSE) | +| artırmak | [Bo Boostost Software Lic 1.0ense 1.0](https://github.com/ClickHouse-Extras/boost-extra/blob/6883b40449f378019aec792f9983ce3afc7ff16e/LICENSE_1_0.txt) | +| brotli | [MIT](https://github.com/google/brotli/blob/master/LICENSE) | +| capnproto | [MIT](https://github.com/capnproto/capnproto/blob/master/LICENSE) | +| cctz | [Apache Lic 2.0ense 2.0](https://github.com/google/cctz/blob/4f9776a310f4952454636363def82c2bf6641d5f/LICENSE.txt) | +| çift dönüşüm | [BSD 3-Clause Lisansı](https://github.com/google/double-conversion/blob/cf2f0f3d547dc73b4612028a155b80536902ba02/LICENSE) | +| FastMemcpy | [MIT](https://github.com/ClickHouse/ClickHouse/blob/master/libs/libmemcpy/impl/LICENSE) | +| googletest | [BSD 3-Clause Lisansı](https://github.com/google/googletest/blob/master/LICENSE) | +| h33 | [Apache Lic 2.0ense 2.0](https://github.com/uber/h3/blob/master/LICENSE) | +| hyperscan | [BSD 3-Clause Lisansı](https://github.com/intel/hyperscan/blob/master/LICENSE) | +| libbtrie | [BSD 2-Clause Lisansı](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/libbtrie/LICENSE) | +| libcxxabi | [BSD + MIT](https://github.com/ClickHouse/ClickHouse/blob/master/libs/libglibc-compatibility/libcxxabi/LICENSE.TXT) | +| libdivide | [Zlib Lisansı](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/libdivide/LICENSE.txt) | +| libgsasl | [LGPL v2. 1](https://github.com/ClickHouse-Extras/libgsasl/blob/3b8948a4042e34fb00b4fb987535dc9e02e39040/LICENSE) | +| libhdfs3 | [Apache Lic 2.0ense 2.0](https://github.com/ClickHouse-Extras/libhdfs3/blob/bd6505cbb0c130b0db695305b9a38546fa880e5a/LICENSE.txt) | +| libmetrohash | [Apache Lic 2.0ense 2.0](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/libmetrohash/LICENSE) | +| libpcg-rastgele | [Apache Lic 2.0ense 2.0](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/libpcg-random/LICENSE-APACHE.txt) | +| libressl | [OpenSSL Lisansı](https://github.com/ClickHouse-Extras/ssl/blob/master/COPYING) | +| librdkafka | [BSD 2-Clause Lisansı](https://github.com/edenhill/librdkafka/blob/363dcad5a23dc29381cc626620e68ae418b3af19/LICENSE) | +| libwidechar\_width | [CC0 1.0 Evrensel](https://github.com/ClickHouse/ClickHouse/blob/master/libs/libwidechar_width/LICENSE) | +| llvm | [BSD 3-Clause Lisansı](https://github.com/ClickHouse-Extras/llvm/blob/163def217817c90fb982a6daf384744d8472b92b/llvm/LICENSE.TXT) | +| lz4 | [BSD 2-Clause Lisansı](https://github.com/lz4/lz4/blob/c10863b98e1503af90616ae99725ecd120265dfb/LICENSE) | +| mariadb-bağlayıcı-c | [LGPL v2. 1](https://github.com/ClickHouse-Extras/mariadb-connector-c/blob/3.1/COPYING.LIB) | +| murmurhash | [Kamu Malı](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/murmurhash/LICENSE) | +| pdqsort | [Zlib Lisansı](https://github.com/ClickHouse/ClickHouse/blob/master/contrib/pdqsort/license.txt) | +| az | [Boost Yazılım Lisansı-Sürüm 1.0](https://github.com/ClickHouse-Extras/poco/blob/fe5505e56c27b6ecb0dcbc40c49dc2caf4e9637f/LICENSE) | +| protobuf | [BSD 3-Clause Lisansı](https://github.com/ClickHouse-Extras/protobuf/blob/12735370922a35f03999afff478e1c6d7aa917a4/LICENSE) | +| re2 | [BSD 3-Clause Lisansı](https://github.com/google/re2/blob/7cf8b88e8f70f97fd4926b56aa87e7f53b2717e0/LICENSE) | +| UnixODBC | [LGPL v2. 1](https://github.com/ClickHouse-Extras/UnixODBC/tree/b0ad30f7f6289c12b76f04bfb9d466374bb32168) | +| zlib-ng | [Zlib Lisansı](https://github.com/ClickHouse-Extras/zlib-ng/blob/develop/LICENSE.md) | +| zstd | [BSD 3-Clause Lisansı](https://github.com/facebook/zstd/blob/dev/LICENSE) | diff --git a/docs/tr/development/developer_instruction.md b/docs/tr/development/developer_instruction.md new file mode 100644 index 00000000000..f9984d9bf20 --- /dev/null +++ b/docs/tr/development/developer_instruction.md @@ -0,0 +1,285 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 61 +toc_title: "Acemi ClickHouse Geli\u015Ftirici Talimat" +--- + +ClickHouse binası Linux, FreeBSD ve Mac OS X üzerinde desteklenmektedir. + +# Windows Kullanıyorsanız {#if-you-use-windows} + +Windows kullanıyorsanız, Ubuntu ile bir sanal makine oluşturmanız gerekir. Bir sanal makine ile çalışmaya başlamak için VirtualBox yükleyin. UB :unt :u'yu web sitesinden indirebilirsiniz: https://www.ubuntu.com/\#download. lütfen indirilen görüntüden bir sanal makine oluşturun (bunun için en az 4GB RAM ayırmalısınız). Ubuntu'da bir komut satırı terminali çalıştırmak için lütfen kelimeyi içeren bir program bulun “terminal” adına (gnome-terminal, konsole vb.)) veya sadece Ctrl+Alt+T tuşlarına basın. + +# 32 bit sistem kullanıyorsanız {#if-you-use-a-32-bit-system} + +ClickHouse çalışamaz veya 32-bit bir sistem üzerinde oluşturun. 64-bit bir sisteme erişim kazanmanız gerekir ve okumaya devam edebilirsiniz. + +# Github'da bir depo oluşturma {#creating-a-repository-on-github} + +ClickHouse repository ile çalışmaya başlamak için bir GitHub hesabına ihtiyacınız olacaktır. + +Muhtemelen zaten bir tane var, ama yapmazsanız, lütfen kayıt olun https://github.com. SSH anahtarlarınız yoksa, bunları üretmeli ve daha sonra Github'a yüklemelisiniz. Bu yamalar üzerinden göndermek için gereklidir. Diğer SSH sunucularıyla kullandığınız aynı SSH anahtarlarını kullanmak da mümkündür - muhtemelen zaten bunlara sahipsiniz. + +ClickHouse deposunun bir çatalı oluşturun. Bunu yapmak için lütfen tıklayın “fork” sağ üst köşedeki düğme https://github.com/ClickHouse/ClickHouse. bu hesabınıza ClickHouse / ClickHouse kendi kopyasını çatal olacaktır. + +Geliştirme süreci ilk ClickHouse sizin çatal içine amaçlanan değişiklikleri işlemekle ve daha sonra bir oluşturma oluşur “pull request” bu değişikliklerin ana depoya kabul edilmesi için (ClickHouse/ClickHouse). + +Git depoları ile çalışmak için lütfen yükleyin `git`. + +Bunu Ubuntu'da yapmak için komut satırı terminalinde çalışırsınız: + + sudo apt update + sudo apt install git + +Git kullanımı ile ilgili kısa bir el kitabı burada bulunabilir: https://services.github.com/on-demand/downloads/github-git-cheat-sheet.pdf. +Git ile ilgili ayrıntılı bir el kitabı için bkz. https://git-scm.com/book/en/v2. + +# Geliştirme Makinenize bir depo klonlama {#cloning-a-repository-to-your-development-machine} + +Ardından, kaynak dosyaları çalışma makinenize indirmeniz gerekir. Bu denir “to clone a repository” çünkü çalışma makinenizde deponun yerel bir kopyasını oluşturur. + +Komut satırında terminal Çalıştır: + + git clone --recursive git@guthub.com:your_github_username/ClickHouse.git + cd ClickHouse + +Not: lütfen, yerine *your\_github\_username* uygun olanı ile! + +Bu komut bir dizin oluşturacaktır `ClickHouse` projenin çalışma kopyasını içeren. + +Yapı sistemini çalıştırmakla ilgili sorunlara yol açabileceğinden, çalışma dizininin yolunun hiçbir boşluk içermemesi önemlidir. + +ClickHouse deposunun kullandığını lütfen unutmayın `submodules`. That is what the references to additional repositories are called (i.e. external libraries on which the project depends). It means that when cloning the repository you need to specify the `--recursive` yukarıdaki örnekte olduğu gibi bayrak. Depo alt modüller olmadan klonlanmışsa, bunları indirmek için aşağıdakileri çalıştırmanız gerekir: + + git submodule init + git submodule update + +Komutu ile durumunu kontrol edebilirsiniz: `git submodule status`. + +Aşağıdaki hata iletisini alırsanız: + + Permission denied (publickey). + fatal: Could not read from remote repository. + + Please make sure you have the correct access rights + and the repository exists. + +Genellikle Github'a bağlanmak için SSH anahtarlarının eksik olduğu anlamına gelir. Bu anahtarlar normalde `~/.ssh`. SSH anahtarlarının kabul edilmesi için bunları GitHub kullanıcı arayüzünün ayarlar bölümüne yüklemeniz gerekir. + +Depoyu https protokolü aracılığıyla da klonlayabilirsiniz: + + git clone https://github.com/ClickHouse/ClickHouse.git + +Ancak bu, değişikliklerinizi sunucuya göndermenize izin vermez. Yine de geçici olarak kullanabilir ve SSH anahtarlarını daha sonra deponun uzak adresini değiştirerek ekleyebilirsiniz `git remote` komut. + +Oradan güncellemeleri çekmek için orijinal ClickHouse repo'nun adresini yerel deponuza da ekleyebilirsiniz: + + git remote add upstream git@github.com:ClickHouse/ClickHouse.git + +Başarıyla bu komutu çalıştırdıktan sonra çalıştırarak ana ClickHouse repo güncellemeleri çekmek mümkün olacak `git pull upstream master`. + +## Alt modüllerle çalışma {#working-with-submodules} + +Git'teki alt modüllerle çalışmak acı verici olabilir. Sonraki komutlar onu yönetmeye yardımcı olacaktır: + + # ! each command accepts --recursive + # Update remote URLs for submodules. Barely rare case + git submodule sync + # Add new submodules + git submodule init + # Update existing submodules to the current state + git submodule update + # Two last commands could be merged together + git submodule update --init + +Bir sonraki komutlar, tüm alt modülleri başlangıç durumuna sıfırlamanıza yardımcı olacaktır (!UYARI! - herhangi bir değişiklik içinde silinecektir): + + # Synchronizes submodules' remote URL with .gitmodules + git submodule sync --recursive + # Update the registered submodules with initialize not yet initialized + git submodule update --init --recursive + # Reset all changes done after HEAD + git submodule foreach git reset --hard + # Clean files from .gitignore + git submodule foreach git clean -xfd + # Repeat last 4 commands for all submodule + git submodule foreach git submodule sync --recursive + git submodule foreach git submodule update --init --recursive + git submodule foreach git submodule foreach git reset --hard + git submodule foreach git submodule foreach git clean -xfd + +# Yapı Sistemi {#build-system} + +ClickHouse bina için Cmake ve Ninja kullanır. + +Cmake-ninja dosyaları (yapı görevleri) üretebilir bir meta-yapı sistemi. +Ninja-bu cmake oluşturulan görevleri yürütmek için kullanılan hıza odaklanarak daha küçük bir yapı sistemi. + +Ubuntu, Debian veya Mint run'a yüklemek için `sudo apt install cmake ninja-build`. + +Centos'ta, RedHat koşusu `sudo yum install cmake ninja-build`. + +Arch veya Gentoo kullanıyorsanız, muhtemelen cmake'i nasıl kuracağınızı kendiniz biliyorsunuz. + +Mac OS X üzerinde cmake ve Ninja yüklemek için ilk homebrew yüklemek ve daha sonra demlemek yoluyla her şeyi yüklemek: + + /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" + brew install cmake ninja + +Ardından, cmake sürümünü kontrol edin: `cmake --version`. 3.3'ün altındaysa, web sitesinden daha yeni bir sürüm yüklemelisiniz: https://cmake.org/download/. + +# İsteğe Bağlı Harici Kütüphaneler {#optional-external-libraries} + +ClickHouse, bina için birkaç dış kütüphane kullanır. Alt modüllerde bulunan kaynaklardan ClickHouse ile birlikte oluşturuldukları için hepsinin ayrı olarak kurulması gerekmez. Listeyi kontrol edebilirsiniz `contrib`. + +# C++ Derleyici {#c-compiler} + +Derleyiciler gcc sürüm 9 ve Clang sürüm 8 veya üzeri başlayarak ClickHouse bina için desteklenmektedir. + +Resmi Yandex şu anda GCC'Yİ kullanıyor çünkü biraz daha iyi performansa sahip makine kodu üretiyor (kriterlerimize göre yüzde birkaçına kadar bir fark yaratıyor). Ve Clang genellikle geliştirme için daha uygundur. Yine de, sürekli entegrasyon (CI) platformumuz yaklaşık bir düzine yapı kombinasyonunu denetler. + +Ubuntu run GCC yüklemek için: `sudo apt install gcc g++` + +Gcc sürümünü kontrol edin: `gcc --version`. 9'un altındaysa, buradaki talimatları izleyin: https://clickhouse.tech / docs/TR/development / build / \#ınstall-gcc-9. + +Mac OS X build sadece Clang için desteklenir. Sadece koş `brew install llvm` + +Eğer Clang kullanmaya karar verirseniz, ayrıca yükleyebilirsiniz `libc++` ve `lld` eğer ne olduğunu biliyorsan. Kullanım `ccache` ayrıca tavsiye edilir. + +# İnşaat Süreci {#the-building-process} + +Artık ClickHouse oluşturmaya hazır olduğunuza göre ayrı bir dizin oluşturmanızı öneririz `build` için `ClickHouse` bu, tüm yapı eserlerini içerecek: + + mkdir build + cd build + +Birkaç farklı dizine (build\_release, build\_debug, vb.) sahip olabilirsiniz.) farklı yapı türleri için. + +İçinde iken `build` dizin, cmake çalıştırarak yapı yapılandırın. İlk çalıştırmadan önce, derleyici belirten ortam değişkenlerini tanımlamanız gerekir (bu örnekte sürüm 9 gcc derleyicisi). + +Linux: + + export CC=gcc-9 CXX=g++-9 + cmake .. + +Mac OS X: + + export CC=clang CXX=clang++ + cmake .. + +Bu `CC` değişken C için derleyiciyi belirtir (C derleyicisi için kısa) ve `CXX` değişken, hangi C++ derleyicisinin bina için kullanılacağını bildirir. + +Daha hızlı bir yapı için, `debug` yapı türü-hiçbir optimizasyonları ile bir yapı. Bunun için aşağıdaki parametreyi sağlayın `-D CMAKE_BUILD_TYPE=Debug`: + + cmake -D CMAKE_BUILD_TYPE=Debug .. + +Bu komutu çalıştırarak yapı türünü değiştirebilirsiniz. `build` dizin. + +İnşa etmek için ninja çalıştırın: + + ninja clickhouse-server clickhouse-client + +Bu örnekte yalnızca gerekli ikili dosyalar oluşturulacaktır. + +Tüm ikili dosyaları (Yardımcı Programlar ve testler) oluşturmanız gerekiyorsa, ninja'yı parametre olmadan çalıştırmalısınız: + + ninja + +Tam yapı, ana ikili dosyaları oluşturmak için yaklaşık 30GB boş disk alanı veya 15GB gerektirir. + +Yapı makinesinde büyük miktarda RAM mevcut olduğunda, paralel olarak çalışan yapı görevlerinin sayısını sınırlamanız gerekir `-j` param: + + ninja -j 1 clickhouse-server clickhouse-client + +4GB RAM'Lİ makinelerde, 8GB RAM için 1 belirtmeniz önerilir `-j 2` tavsiye edilir. + +Mesajı alırsanız: `ninja: error: loading 'build.ninja': No such file or directory` bu, bir yapı yapılandırması oluşturmanın başarısız olduğu ve yukarıdaki mesajı incelemeniz gerektiği anlamına gelir. + +Bina işleminin başarılı bir şekilde başlatılmasının ardından, yapı ilerlemesini görürsünüz-işlenmiş görevlerin sayısı ve toplam görev sayısı. + +Libhdfs2 kütüphanesinde protobuf dosyaları hakkında mesajlar oluştururken `libprotobuf WARNING` ortaya çıkabilir. Hiçbir şeyi etkilemezler ve göz ardı edilmeleri güvenlidir. + +Başarılı bir yapı üzerine yürütülebilir bir dosya alırsınız `ClickHouse//programs/clickhouse`: + + ls -l programs/clickhouse + +# Clickhouse'un yerleşik yürütülebilir dosyasını çalıştırma {#running-the-built-executable-of-clickhouse} + +Sunucuyu geçerli kullanıcı altında çalıştırmak için aşağıdakilere gitmeniz gerekir `ClickHouse/programs/server/` (dışında bulunan `build`) ve koş: + + ../../../build/programs/clickhouse server + +Bu durumda, ClickHouse geçerli dizinde bulunan yapılandırma dosyalarını kullanır. Koş youabilirsiniz `clickhouse server` komut satırı parametresi olarak bir yapılandırma dosyasının yolunu belirten herhangi bir dizinden `--config-file`. + +Başka bir terminalde clickhouse-client ile Clickhouse'a bağlanmak için `ClickHouse/build/programs/` ve koş `clickhouse client`. + +Eğer alırsanız `Connection refused` Mac OS X veya Freebsd'de mesaj, ana bilgisayar adresi 127.0.0.1 belirtmeyi deneyin: + + clickhouse client --host 127.0.0.1 + +Sisteminizde yüklü olan ClickHouse binary'nin üretim sürümünü özel olarak oluşturulmuş ClickHouse binaryinizle değiştirebilirsiniz. Bunu yapmak için resmi web sitesinden talimatları izleyerek Makinenize ClickHouse yükleyin. Ardından, aşağıdakileri çalıştırın: + + sudo service clickhouse-server stop + sudo cp ClickHouse/build/programs/clickhouse /usr/bin/ + sudo service clickhouse-server start + +Not thate that `clickhouse-client`, `clickhouse-server` ve diğerleri yaygın olarak paylaşılan sembolik bağlardır `clickhouse` ikilik. + +Ayrıca sisteminizde yüklü ClickHouse paketinden yapılandırma dosyası ile özel inşa ClickHouse ikili çalıştırabilirsiniz: + + sudo service clickhouse-server stop + sudo -u clickhouse ClickHouse/build/programs/clickhouse server --config-file /etc/clickhouse-server/config.xml + +# IDE (entegre geliştirme ortamı) {#ide-integrated-development-environment} + +Hangi IDE kullanmak bilmiyorsanız, clion kullanmanızı öneririz. CLion ticari bir yazılımdır, ancak 30 günlük ücretsiz deneme süresi sunar. Öğrenciler için de ücretsizdir. CLion Linux ve Mac OS X hem de kullanılabilir. + +KDevelop ve QTCreator, ClickHouse geliştirmek için bir IDE'NİN diğer harika alternatifleridir. KDevelop kararsız olmasına rağmen çok kullanışlı bir IDE olarak geliyor. KDevelop projeyi açtıktan sonra bir süre sonra çökerse, tıklamanız gerekir “Stop All” proje dosyalarının listesini açar açmaz düğme. Bunu yaptıktan sonra KDevelop ile çalışmak iyi olmalıdır. + +Basit kod editörleri olarak, Yüce metin veya Visual Studio kodunu veya Kate'i (hepsi Linux'ta kullanılabilir) kullanabilirsiniz. + +Her ihtimale karşı, Clion'un yarattığını belirtmek gerekir `build` kendi başına yol, aynı zamanda kendi seçtikleri `debug` yapı türü için, yapılandırma için Clion'da tanımlanan ve sizin tarafınızdan yüklenmeyen bir cmake sürümünü kullanır ve son olarak CLion kullanacaktır `make` yerine yapı görevlerini çalıştırmak için `ninja`. Bu normal bir davranıştır, sadece karışıklığı önlemek için bunu aklınızda bulundurun. + +# Kod Yazma {#writing-code} + +Açıklaması ClickHouse mimarisi burada bulabilirsiniz: https://clickhouse.tech / doscs/TR / development / Arch /it /ec /ture/ + +Kod stili Kılavuzu: https://clickhouse.tech / doscs / TR / development / style/ + +Yazma testleri: https://clickhouse.teknoloji / doscs / TR / geliştirme / testler/ + +Görevlerin listesi: https://github.com/ClickHouse/ClickHouse/blob/master/testsructions/easy\_tasks\_sorted\_en.md + +# Test Verileri {#test-data} + +Clickhouse'un geliştirilmesi genellikle gerçekçi veri kümelerinin yüklenmesini gerektirir. Performans testi için özellikle önemlidir. Yandex'ten özel olarak hazırlanmış anonim veri setimiz var.Metrica. Ayrıca bazı 3GB boş disk alanı gerektirir. Bu verilerin geliştirme görevlerinin çoğunu gerçekleştirmek için gerekli olmadığını unutmayın. + + sudo apt install wget xz-utils + + wget https://clickhouse-datasets.s3.yandex.net/hits/tsv/hits_v1.tsv.xz + wget https://clickhouse-datasets.s3.yandex.net/visits/tsv/visits_v1.tsv.xz + + xz -v -d hits_v1.tsv.xz + xz -v -d visits_v1.tsv.xz + + clickhouse-client + + CREATE TABLE test.hits ( WatchID UInt64, JavaEnable UInt8, Title String, GoodEvent Int16, EventTime DateTime, EventDate Date, CounterID UInt32, ClientIP UInt32, ClientIP6 FixedString(16), RegionID UInt32, UserID UInt64, CounterClass Int8, OS UInt8, UserAgent UInt8, URL String, Referer String, URLDomain String, RefererDomain String, Refresh UInt8, IsRobot UInt8, RefererCategories Array(UInt16), URLCategories Array(UInt16), URLRegions Array(UInt32), RefererRegions Array(UInt32), ResolutionWidth UInt16, ResolutionHeight UInt16, ResolutionDepth UInt8, FlashMajor UInt8, FlashMinor UInt8, FlashMinor2 String, NetMajor UInt8, NetMinor UInt8, UserAgentMajor UInt16, UserAgentMinor FixedString(2), CookieEnable UInt8, JavascriptEnable UInt8, IsMobile UInt8, MobilePhone UInt8, MobilePhoneModel String, Params String, IPNetworkID UInt32, TraficSourceID Int8, SearchEngineID UInt16, SearchPhrase String, AdvEngineID UInt8, IsArtifical UInt8, WindowClientWidth UInt16, WindowClientHeight UInt16, ClientTimeZone Int16, ClientEventTime DateTime, SilverlightVersion1 UInt8, SilverlightVersion2 UInt8, SilverlightVersion3 UInt32, SilverlightVersion4 UInt16, PageCharset String, CodeVersion UInt32, IsLink UInt8, IsDownload UInt8, IsNotBounce UInt8, FUniqID UInt64, HID UInt32, IsOldCounter UInt8, IsEvent UInt8, IsParameter UInt8, DontCountHits UInt8, WithHash UInt8, HitColor FixedString(1), UTCEventTime DateTime, Age UInt8, Sex UInt8, Income UInt8, Interests UInt16, Robotness UInt8, GeneralInterests Array(UInt16), RemoteIP UInt32, RemoteIP6 FixedString(16), WindowName Int32, OpenerName Int32, HistoryLength Int16, BrowserLanguage FixedString(2), BrowserCountry FixedString(2), SocialNetwork String, SocialAction String, HTTPError UInt16, SendTiming Int32, DNSTiming Int32, ConnectTiming Int32, ResponseStartTiming Int32, ResponseEndTiming Int32, FetchTiming Int32, RedirectTiming Int32, DOMInteractiveTiming Int32, DOMContentLoadedTiming Int32, DOMCompleteTiming Int32, LoadEventStartTiming Int32, LoadEventEndTiming Int32, NSToDOMContentLoadedTiming Int32, FirstPaintTiming Int32, RedirectCount Int8, SocialSourceNetworkID UInt8, SocialSourcePage String, ParamPrice Int64, ParamOrderID String, ParamCurrency FixedString(3), ParamCurrencyID UInt16, GoalsReached Array(UInt32), OpenstatServiceName String, OpenstatCampaignID String, OpenstatAdID String, OpenstatSourceID String, UTMSource String, UTMMedium String, UTMCampaign String, UTMContent String, UTMTerm String, FromTag String, HasGCLID UInt8, RefererHash UInt64, URLHash UInt64, CLID UInt32, YCLID UInt64, ShareService String, ShareURL String, ShareTitle String, `ParsedParams.Key1` Array(String), `ParsedParams.Key2` Array(String), `ParsedParams.Key3` Array(String), `ParsedParams.Key4` Array(String), `ParsedParams.Key5` Array(String), `ParsedParams.ValueDouble` Array(Float64), IslandID FixedString(16), RequestNum UInt32, RequestTry UInt8) ENGINE = MergeTree PARTITION BY toYYYYMM(EventDate) SAMPLE BY intHash32(UserID) ORDER BY (CounterID, EventDate, intHash32(UserID), EventTime); + + CREATE TABLE test.visits ( CounterID UInt32, StartDate Date, Sign Int8, IsNew UInt8, VisitID UInt64, UserID UInt64, StartTime DateTime, Duration UInt32, UTCStartTime DateTime, PageViews Int32, Hits Int32, IsBounce UInt8, Referer String, StartURL String, RefererDomain String, StartURLDomain String, EndURL String, LinkURL String, IsDownload UInt8, TraficSourceID Int8, SearchEngineID UInt16, SearchPhrase String, AdvEngineID UInt8, PlaceID Int32, RefererCategories Array(UInt16), URLCategories Array(UInt16), URLRegions Array(UInt32), RefererRegions Array(UInt32), IsYandex UInt8, GoalReachesDepth Int32, GoalReachesURL Int32, GoalReachesAny Int32, SocialSourceNetworkID UInt8, SocialSourcePage String, MobilePhoneModel String, ClientEventTime DateTime, RegionID UInt32, ClientIP UInt32, ClientIP6 FixedString(16), RemoteIP UInt32, RemoteIP6 FixedString(16), IPNetworkID UInt32, SilverlightVersion3 UInt32, CodeVersion UInt32, ResolutionWidth UInt16, ResolutionHeight UInt16, UserAgentMajor UInt16, UserAgentMinor UInt16, WindowClientWidth UInt16, WindowClientHeight UInt16, SilverlightVersion2 UInt8, SilverlightVersion4 UInt16, FlashVersion3 UInt16, FlashVersion4 UInt16, ClientTimeZone Int16, OS UInt8, UserAgent UInt8, ResolutionDepth UInt8, FlashMajor UInt8, FlashMinor UInt8, NetMajor UInt8, NetMinor UInt8, MobilePhone UInt8, SilverlightVersion1 UInt8, Age UInt8, Sex UInt8, Income UInt8, JavaEnable UInt8, CookieEnable UInt8, JavascriptEnable UInt8, IsMobile UInt8, BrowserLanguage UInt16, BrowserCountry UInt16, Interests UInt16, Robotness UInt8, GeneralInterests Array(UInt16), Params Array(String), `Goals.ID` Array(UInt32), `Goals.Serial` Array(UInt32), `Goals.EventTime` Array(DateTime), `Goals.Price` Array(Int64), `Goals.OrderID` Array(String), `Goals.CurrencyID` Array(UInt32), WatchIDs Array(UInt64), ParamSumPrice Int64, ParamCurrency FixedString(3), ParamCurrencyID UInt16, ClickLogID UInt64, ClickEventID Int32, ClickGoodEvent Int32, ClickEventTime DateTime, ClickPriorityID Int32, ClickPhraseID Int32, ClickPageID Int32, ClickPlaceID Int32, ClickTypeID Int32, ClickResourceID Int32, ClickCost UInt32, ClickClientIP UInt32, ClickDomainID UInt32, ClickURL String, ClickAttempt UInt8, ClickOrderID UInt32, ClickBannerID UInt32, ClickMarketCategoryID UInt32, ClickMarketPP UInt32, ClickMarketCategoryName String, ClickMarketPPName String, ClickAWAPSCampaignName String, ClickPageName String, ClickTargetType UInt16, ClickTargetPhraseID UInt64, ClickContextType UInt8, ClickSelectType Int8, ClickOptions String, ClickGroupBannerID Int32, OpenstatServiceName String, OpenstatCampaignID String, OpenstatAdID String, OpenstatSourceID String, UTMSource String, UTMMedium String, UTMCampaign String, UTMContent String, UTMTerm String, FromTag String, HasGCLID UInt8, FirstVisit DateTime, PredLastVisit Date, LastVisit Date, TotalVisits UInt32, `TraficSource.ID` Array(Int8), `TraficSource.SearchEngineID` Array(UInt16), `TraficSource.AdvEngineID` Array(UInt8), `TraficSource.PlaceID` Array(UInt16), `TraficSource.SocialSourceNetworkID` Array(UInt8), `TraficSource.Domain` Array(String), `TraficSource.SearchPhrase` Array(String), `TraficSource.SocialSourcePage` Array(String), Attendance FixedString(16), CLID UInt32, YCLID UInt64, NormalizedRefererHash UInt64, SearchPhraseHash UInt64, RefererDomainHash UInt64, NormalizedStartURLHash UInt64, StartURLDomainHash UInt64, NormalizedEndURLHash UInt64, TopLevelDomain UInt64, URLScheme UInt64, OpenstatServiceNameHash UInt64, OpenstatCampaignIDHash UInt64, OpenstatAdIDHash UInt64, OpenstatSourceIDHash UInt64, UTMSourceHash UInt64, UTMMediumHash UInt64, UTMCampaignHash UInt64, UTMContentHash UInt64, UTMTermHash UInt64, FromHash UInt64, WebVisorEnabled UInt8, WebVisorActivity UInt32, `ParsedParams.Key1` Array(String), `ParsedParams.Key2` Array(String), `ParsedParams.Key3` Array(String), `ParsedParams.Key4` Array(String), `ParsedParams.Key5` Array(String), `ParsedParams.ValueDouble` Array(Float64), `Market.Type` Array(UInt8), `Market.GoalID` Array(UInt32), `Market.OrderID` Array(String), `Market.OrderPrice` Array(Int64), `Market.PP` Array(UInt32), `Market.DirectPlaceID` Array(UInt32), `Market.DirectOrderID` Array(UInt32), `Market.DirectBannerID` Array(UInt32), `Market.GoodID` Array(String), `Market.GoodName` Array(String), `Market.GoodQuantity` Array(Int32), `Market.GoodPrice` Array(Int64), IslandID FixedString(16)) ENGINE = CollapsingMergeTree(Sign) PARTITION BY toYYYYMM(StartDate) SAMPLE BY intHash32(UserID) ORDER BY (CounterID, StartDate, intHash32(UserID), VisitID); + + clickhouse-client --max_insert_block_size 100000 --query "INSERT INTO test.hits FORMAT TSV" < hits_v1.tsv + clickhouse-client --max_insert_block_size 100000 --query "INSERT INTO test.visits FORMAT TSV" < visits_v1.tsv + +# Çekme İsteği Oluşturma {#creating-pull-request} + +Github'un kullanıcı arayüzünde çatal deposuna gidin. Bir dalda gelişiyorsanız, o Dalı seçmeniz gerekir. Bir olacak “Pull request” ekranda bulunan düğme. Özünde, bu demektir “create a request for accepting my changes into the main repository”. + +Çalışma henüz tamamlanmamış olsa bile bir çekme isteği oluşturulabilir. Bu durumda lütfen kelimeyi koyun “WIP” (devam eden çalışma) başlığın başında, daha sonra değiştirilebilir. Bu, kooperatif Gözden geçirme ve değişikliklerin tartışılması ve mevcut tüm testlerin çalıştırılması için kullanışlıdır. Değişikliklerinizin kısa bir açıklamasını sağlamanız önemlidir, daha sonra sürüm değişiklikleri oluşturmak için kullanılacaktır. + +Yandex çalışanları PR'NİZİ bir etiketle etiketlediğinde testler başlayacaktır “can be tested”. The results of some first checks (e.g. code style) will come in within several minutes. Build check results will arrive within half an hour. And the main set of tests will report itself within an hour. + +Sistem, çekme isteğiniz için ayrı ayrı ClickHouse ikili yapıları hazırlayacaktır. Bu yapıları almak için tıklayın “Details” yanındaki bağlantı “ClickHouse build check” çekler listesinde giriş. Orada inşa doğrudan bağlantılar bulacaksınız .eğer üretim sunucularında bile dağıtabilirsiniz ClickHouse DEB paketleri (eğer hiçbir korku varsa). + +Büyük olasılıkla bazı yapılar ilk kez başarısız olur. Bunun nedeni, hem gcc hem de clang ile, hemen hemen tüm mevcut uyarılarla (her zaman `-Werror` bayrak) clang için etkin. Aynı sayfada, tüm yapı günlüklerini bulabilirsiniz, böylece tüm olası yollarla ClickHouse oluşturmak zorunda kalmazsınız. diff --git a/docs/tr/development/index.md b/docs/tr/development/index.md new file mode 100644 index 00000000000..fdd4c0c0805 --- /dev/null +++ b/docs/tr/development/index.md @@ -0,0 +1,12 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "Geli\u015Fme" +toc_hidden: true +toc_priority: 58 +toc_title: "gizlenmi\u015F" +--- + +# ClickHouse Geliştirme {#clickhouse-development} + +[Orijinal makale](https://clickhouse.tech/docs/en/development/) diff --git a/docs/tr/development/style.md b/docs/tr/development/style.md new file mode 100644 index 00000000000..713f95cf053 --- /dev/null +++ b/docs/tr/development/style.md @@ -0,0 +1,841 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 68 +toc_title: "C++ kodu nas\u0131l yaz\u0131l\u0131r" +--- + +# C++ kodu nasıl yazılır {#how-to-write-c-code} + +## Genel Öneriler {#general-recommendations} + +**1.** Aşağıdakiler önerilerdir, gereksinimler değildir. + +**2.** Kod düzenliyorsanız, varolan kodun biçimlendirmesini takip etmek mantıklıdır. + +**3.** Kod stili tutarlılık için gereklidir. Tutarlılık, kodu okumayı kolaylaştırır ve aynı zamanda kodu aramayı da kolaylaştırır. + +**4.** Kuralların çoğunun mantıklı nedenleri yoktur, yerleşik uygulamalar tarafından belirlenir. + +## Biçimlendirir {#formatting} + +**1.** Biçimlendirme çoğu tarafından otomatik olarak yapılacaktır `clang-format`. + +**2.** Girintiler 4 boşluk vardır. Bir sekme dört boşluk ekleyecek şekilde geliştirme ortamınızı yapılandırın. + +**3.** Kıvırcık parantezlerin açılması ve kapatılması ayrı bir satırda olmalıdır. + +``` cpp +inline void readBoolText(bool & x, ReadBuffer & buf) +{ + char tmp = '0'; + readChar(tmp, buf); + x = tmp != '0'; +} +``` + +**4.** Tüm fonksiyon gövdesi tek ise `statement`, tek bir satır üzerine yerleştirilebilir. Yer (satır sonunda boşluk dışında) etrafında ayraç boşluk. + +``` cpp +inline size_t mask() const { return buf_size() - 1; } +inline size_t place(HashValue x) const { return x & mask(); } +``` + +**5.** Fonksiyonlar için. Parantezlerin etrafına boşluk koymayın. + +``` cpp +void reinsert(const Value & x) +``` + +``` cpp +memcpy(&buf[place_value], &x, sizeof(x)); +``` + +**6.** İçinde `if`, `for`, `while` ve diğer ifadeler, açılış braketinin önüne bir boşluk yerleştirilir (işlev çağrılarının aksine). + +``` cpp +for (size_t i = 0; i < rows; i += storage.index_granularity) +``` + +**7.** İkili operatörlerin etrafına boşluk Ekle (`+`, `-`, `*`, `/`, `%`, …) and the ternary operator `?:`. + +``` cpp +UInt16 year = (s[0] - '0') * 1000 + (s[1] - '0') * 100 + (s[2] - '0') * 10 + (s[3] - '0'); +UInt8 month = (s[5] - '0') * 10 + (s[6] - '0'); +UInt8 day = (s[8] - '0') * 10 + (s[9] - '0'); +``` + +**8.** Bir satır beslemesi girilirse, operatörü yeni bir satıra koyun ve girintiyi ondan önce artırın. + +``` cpp +if (elapsed_ns) + message << " (" + << rows_read_on_server * 1000000000 / elapsed_ns << " rows/s., " + << bytes_read_on_server * 1000.0 / elapsed_ns << " MB/s.) "; +``` + +**9.** İsterseniz, bir çizgi içinde hizalama için boşluk kullanabilirsiniz. + +``` cpp +dst.ClickLogID = click.LogID; +dst.ClickEventID = click.EventID; +dst.ClickGoodEvent = click.GoodEvent; +``` + +**10.** Operatörler etrafında boşluk kullanmayın `.`, `->`. + +Gerekirse, operatör bir sonraki satıra sarılabilir. Bu durumda, önündeki ofset artar. + +**11.** Tekli operatörleri ayırmak için boşluk kullanmayın (`--`, `++`, `*`, `&`, …) from the argument. + +**12.** Virgülden sonra bir boşluk koyun, ancak ondan önce değil. Aynı kural, bir içindeki noktalı virgül için de geçerlidir `for` ifade. + +**13.** Ayırmak için boşluk kullanmayın `[]` operatör. + +**14.** İn a `template <...>` ifade, arasında bir boşluk kullanın `template` ve `<`; sonra boşluk yok `<` ya da önce `>`. + +``` cpp +template +struct AggregatedStatElement +{} +``` + +**15.** Sınıflarda ve yapılarda, yazın `public`, `private`, ve `protected` aynı seviyede `class/struct` ve kodun geri kalanını girinti. + +``` cpp +template +class MultiVersion +{ +public: + /// Version of object for usage. shared_ptr manage lifetime of version. + using Version = std::shared_ptr; + ... +} +``` + +**16.** Eğer aynı `namespace` tüm dosya için kullanılır ve başka önemli bir şey yoktur, içinde bir ofset gerekli değildir `namespace`. + +**17.** Eğer blok için bir `if`, `for`, `while` veya başka bir ifade tek bir `statement`, kıvırcık parantez isteğe bağlıdır. Place the `statement` bunun yerine ayrı bir satırda. Bu kural iç içe geçmiş için de geçerlidir `if`, `for`, `while`, … + +Ama eğer iç `statement` kıvırcık parantez içerir veya `else`, dış blok kıvırcık parantez içinde yazılmalıdır. + +``` cpp +/// Finish write. +for (auto & stream : streams) + stream.second->finalize(); +``` + +**18.** Çizgilerin uçlarında boşluk olmamalıdır. + +**19.** Kaynak dosyalar UTF-8 kodlanmıştır. + +**20.** ASCII olmayan karakterler dize değişmezlerinde kullanılabilir. + +``` cpp +<< ", " << (timer.elapsed() / chunks_stats.hits) << " μsec/hit."; +``` + +**21.** Tek bir satırda birden çok ifade yazmayın. + +**22.** Fonksiyonların içindeki kod bölümlerini gruplandırın ve bunları birden fazla boş satırla ayırın. + +**23.** Bir veya iki boş satırla ayrı işlevler, sınıflar vb. + +**24.** `A const` (bir değerle ilgili) tür adından önce yazılmalıdır. + +``` cpp +//correct +const char * pos +const std::string & s +//incorrect +char const * pos +``` + +**25.** Bir işaretçi veya başvuru bildirirken, `*` ve `&` semboller her iki taraftaki boşluklarla ayrılmalıdır. + +``` cpp +//correct +const char * pos +//incorrect +const char* pos +const char *pos +``` + +**26.** Şablon türlerini kullanırken, `using` anahtar kelime (en basit durumlar hariç). + +Başka bir deyişle, şablon parametreleri yalnızca `using` ve kodda tekrarlanmıyor. + +`using` bir işlevin içinde olduğu gibi yerel olarak bildirilebilir. + +``` cpp +//correct +using FileStreams = std::map>; +FileStreams streams; +//incorrect +std::map> streams; +``` + +**27.** Bir ifadede farklı türde birkaç değişken bildirmeyin. + +``` cpp +//incorrect +int x, *y; +``` + +**28.** C tarzı yayınları kullanmayın. + +``` cpp +//incorrect +std::cerr << (int)c <<; std::endl; +//correct +std::cerr << static_cast(c) << std::endl; +``` + +**29.** Sınıflarda ve yapılarda, grup üyeleri ve işlevleri her görünürlük kapsamı içinde ayrı ayrı. + +**30.** Küçük sınıflar ve yapılar için, yöntem bildirimini uygulamadan ayırmak gerekli değildir. + +Aynı şey, herhangi bir sınıf veya yapıdaki küçük yöntemler için de geçerlidir. + +Templated sınıflar ve yapılar için, yöntem bildirimlerini uygulamadan ayırmayın(aksi takdirde aynı çeviri biriminde tanımlanmaları gerekir). + +**31.** Satırları 80 yerine 140 karakterle sarabilirsiniz. + +**32.** Postfix gerekli değilse, her zaman önek artış / azaltma işleçlerini kullanın. + +``` cpp +for (Names::const_iterator it = column_names.begin(); it != column_names.end(); ++it) +``` + +## Yorumlar {#comments} + +**1.** Kodun önemsiz olmayan tüm bölümleri için yorum eklediğinizden emin olun. + +Bu çok önemli. Yorumu yazmak, kodun gerekli olmadığını veya yanlış tasarlandığını anlamanıza yardımcı olabilir. + +``` cpp +/** Part of piece of memory, that can be used. + * For example, if internal_buffer is 1MB, and there was only 10 bytes loaded to buffer from file for reading, + * then working_buffer will have size of only 10 bytes + * (working_buffer.end() will point to position right after those 10 bytes available for read). + */ +``` + +**2.** Yorumlar gerektiği kadar ayrıntılı olabilir. + +**3.** Açıklama yaptıkları koddan önce yorumları yerleştirin. Nadir durumlarda, yorumlar aynı satırda koddan sonra gelebilir. + +``` cpp +/** Parses and executes the query. +*/ +void executeQuery( + ReadBuffer & istr, /// Where to read the query from (and data for INSERT, if applicable) + WriteBuffer & ostr, /// Where to write the result + Context & context, /// DB, tables, data types, engines, functions, aggregate functions... + BlockInputStreamPtr & query_plan, /// Here could be written the description on how query was executed + QueryProcessingStage::Enum stage = QueryProcessingStage::Complete /// Up to which stage process the SELECT query + ) +``` + +**4.** Yorumlar sadece İngilizce olarak yazılmalıdır. + +**5.** Bir kitaplık yazıyorsanız, ana başlık dosyasına açıklayan ayrıntılı yorumları ekleyin. + +**6.** Ek bilgi vermeyen yorumlar eklemeyin. Özellikle, bu gibi boş yorumlar bırakmayın: + +``` cpp +/* +* Procedure Name: +* Original procedure name: +* Author: +* Date of creation: +* Dates of modification: +* Modification authors: +* Original file name: +* Purpose: +* Intent: +* Designation: +* Classes used: +* Constants: +* Local variables: +* Parameters: +* Date of creation: +* Purpose: +*/ +``` + +Örnek kaynaktan ödünç alınmıştır http://home.tamk.fi / ~ jaalto / kurs / kodlama stili / doc/ulaşılamaz-kod/. + +**7.** Çöp yorum yazmayın (yazar, oluşturma tarihi ..) her dosyanın başında. + +**8.** Tek satırlı yorumlar üç eğik çizgi ile başlar: `///` ve çok satırlı yorumlar ile başlar `/**`. Bu yorumlar dikkate alınır “documentation”. + +Not: bu yorumlardan belgeler oluşturmak için Doxygen kullanabilirsiniz. Ancak DOXYGEN genellikle kullanılmaz, çünkü IDE'DEKİ kodda gezinmek daha uygundur. + +**9.** Çok satırlı açıklamaların başında ve sonunda (çok satırlı bir açıklamayı kapatan satır hariç) boş satırları olmamalıdır. + +**10.** Kodu yorumlamak için temel yorumları kullanın, değil “documenting” yorumlar. + +**11.** İşlem yapmadan önce kodun yorumlanan kısımlarını silin. + +**12.** Yorumlarda veya kodda küfür kullanmayın. + +**13.** Büyük harf kullanmayın. Aşırı noktalama kullanmayın. + +``` cpp +/// WHAT THE FAIL??? +``` + +**14.** Sınırlayıcılar yapmak için yorum kullanmayın. + +``` cpp +///****************************************************** +``` + +**15.** Yorumlarda tartışmalara başlamayın. + +``` cpp +/// Why did you do this stuff? +``` + +**16.** Ne hakkında olduğunu açıklayan bir bloğun sonunda bir yorum yazmaya gerek yok. + +``` cpp +/// for +``` + +## Adlar {#names} + +**1.** Değişkenlerin ve sınıf üyelerinin adlarında alt çizgi içeren küçük harfler kullanın. + +``` cpp +size_t max_block_size; +``` + +**2.** İşlevlerin (yöntemlerin) adları için, küçük harfle başlayan camelCase kullanın. + +``` cpp +std::string getName() const override { return "Memory"; } +``` + +**3.** Sınıfların (yapıların) adları için büyük harfle başlayan CamelCase kullanın. Ben dışındaki önekler arayüzler için kullanılmaz. + +``` cpp +class StorageMemory : public IStorage +``` + +**4.** `using` sınıf aslarla aynı şekilde adlandırılır veya `_t` ucunda. + +**5.** Şablon Türü argümanlarının isimleri: basit durumlarda, kullanın `T`; `T`, `U`; `T1`, `T2`. + +Daha karmaşık durumlar için, sınıf adları için kuralları izleyin veya öneki ekleyin `T`. + +``` cpp +template +struct AggregatedStatElement +``` + +**6.** Şablon sabit argümanlarının adları: değişken adları için kurallara uyun veya kullanın `N` basit durumlarda. + +``` cpp +template +struct ExtractDomain +``` + +**7.** Soyut sınıflar (arayüzler) için şunları ekleyebilirsiniz `I` önek. + +``` cpp +class IBlockInputStream +``` + +**8.** Yerel olarak bir değişken kullanırsanız, kısa adı kullanabilirsiniz. + +Diğer tüm durumlarda, anlamı açıklayan bir isim kullanın. + +``` cpp +bool info_successfully_loaded = false; +``` + +**9.** İsimleri `define`s ve genel sabitler alt çizgi ile ALL\_CAPS kullanın. + +``` cpp +#define MAX_SRC_TABLE_NAMES_TO_STORE 1000 +``` + +**10.** Dosya adları, içerikleriyle aynı stili kullanmalıdır. + +Bir dosya tek bir sınıf içeriyorsa, dosyayı sınıfla aynı şekilde adlandırın (CamelCase). + +Dosya tek bir işlev içeriyorsa, dosyayı işlevle aynı şekilde adlandırın (camelCase). + +**11.** İsim bir kısaltma içeriyorsa, o zaman: + +- Değişken adları için kısaltma küçük harfler kullanmalıdır `mysql_connection` (değil `mySQL_connection`). +- Sınıfların ve işlevlerin adları için, büyük harfleri kısaltmada tutun`MySQLConnection` (değil `MySqlConnection`). + +**12.** Yalnızca sınıf üyelerini başlatmak için kullanılan yapıcı bağımsız değişkenleri, sınıf üyeleri ile aynı şekilde, ancak sonunda bir alt çizgi ile adlandırılmalıdır. + +``` cpp +FileQueueProcessor( + const std::string & path_, + const std::string & prefix_, + std::shared_ptr handler_) + : path(path_), + prefix(prefix_), + handler(handler_), + log(&Logger::get("FileQueueProcessor")) +{ +} +``` + +Bağımsız değişken yapıcı gövdesinde kullanılmazsa, alt çizgi soneki atlanabilir. + +**13.** Yerel değişkenlerin ve sınıf üyelerinin adlarında fark yoktur (önek gerekmez). + +``` cpp +timer (not m_timer) +``` + +**14.** Bir de SAB theitler için `enum`, büyük harfle CamelCase kullanın. ALL\_CAPS da kabul edilebilir. Eğer... `enum` yerel olmayan, bir `enum class`. + +``` cpp +enum class CompressionMethod +{ + QuickLZ = 0, + LZ4 = 1, +}; +``` + +**15.** Tüm isimler İngilizce olmalıdır. Rusça kelimelerin çevirisi izin verilmez. + + not Stroka + +**16.** Kısaltmalar iyi biliniyorsa kabul edilebilir (kısaltmanın anlamını Wikipedia'da veya bir arama motorunda kolayca bulabilirsiniz). + + `AST`, `SQL`. + + Not `NVDH` (some random letters) + +Kısaltılmış versiyon ortak kullanım ise eksik kelimeler kabul edilebilir. + +Yorumlarda tam ad yanında yer alıyorsa bir kısaltma da kullanabilirsiniz. + +**17.** C++ kaynak kodu ile dosya adları olmalıdır `.cpp` uzantı. Başlık dosyaları olmalıdır `.h` uzantı. + +## Kod nasıl yazılır {#how-to-write-code} + +**1.** Bellek yönetimi. + +El ile bellek ayırma (`delete`) sadece kütüphane kodunda kullanılabilir. + +Kütüphane kod inunda, `delete` operatör yalnızca yıkıcılarda kullanılabilir. + +Uygulama kodunda, bellek sahibi olan nesne tarafından serbest bırakılmalıdır. + +Örnekler: + +- En kolay yol, bir nesneyi yığına yerleştirmek veya onu başka bir sınıfın üyesi yapmaktır. +- Çok sayıda küçük nesne için kapları kullanın. +- Öbekte bulunan az sayıda nesnenin otomatik olarak ayrılması için şunları kullanın `shared_ptr/unique_ptr`. + +**2.** Kaynak yönetimi. + +Kullanmak `RAII` ve yukarıya bakın. + +**3.** Hata işleme. + +İstisnaları kullanın. Çoğu durumda, yalnızca bir istisna atmanız gerekir ve onu yakalamanız gerekmez (çünkü `RAII`). + +Çevrimdışı veri işleme uygulamalarında, istisnaları yakalamamak genellikle kabul edilebilir. + +Kullanıcı isteklerini işleyen sunucularda, bağlantı işleyicisinin en üst düzeyindeki istisnaları yakalamak genellikle yeterlidir. + +İş parçacığı işlevlerinde, bunları ana iş parçacığında yeniden taramak için tüm istisnaları yakalamalı ve tutmalısınız `join`. + +``` cpp +/// If there weren't any calculations yet, calculate the first block synchronously +if (!started) +{ + calculate(); + started = true; +} +else /// If calculations are already in progress, wait for the result + pool.wait(); + +if (exception) + exception->rethrow(); +``` + +İşleme olmadan istisnaları asla gizlemeyin. Sadece körü körüne log tüm istisnaları koymak asla. + +``` cpp +//Not correct +catch (...) {} +``` + +Eğer bazı özel durumlar göz ardı etmek gerekiyorsa, sadece özel olanlar için bunu yapmak ve diğerleri yeniden oluşturma. + +``` cpp +catch (const DB::Exception & e) +{ + if (e.code() == ErrorCodes::UNKNOWN_AGGREGATE_FUNCTION) + return nullptr; + else + throw; +} +``` + +Yanıt kodlarıyla işlevleri kullanırken veya `errno`, her zaman sonucu kontrol edin ve hata durumunda bir istisna atın. + +``` cpp +if (0 != close(fd)) + throwFromErrno("Cannot close file " + file_name, ErrorCodes::CANNOT_CLOSE_FILE); +``` + +`Do not use assert`. + +**4.** İstisna türleri. + +Uygulama kodunda karmaşık özel durum hiyerarşisini kullanmaya gerek yoktur. Özel durum metni bir sistem yöneticisi için anlaşılabilir olmalıdır. + +**5.** Yıkıcılardan istisnalar atmak. + +Bu tavsiye edilmez, ancak izin verilir. + +Aşağıdaki seçenekleri kullanın: + +- Bir işlev oluşturma (`done()` veya `finalize()`) bu, bir istisnaya yol açabilecek tüm işleri önceden yapacaktır. Bu işlev çağrıldıysa, daha sonra yıkıcıda istisna olmamalıdır. +- Çok karmaşık olan görevler (ağ üzerinden ileti gönderme gibi), sınıf kullanıcısının imha edilmeden önce çağırması gereken ayrı bir yöntemle yerleştirilebilir. +- Yıkıcıda bir istisna varsa, onu gizlemek yerine günlüğe kaydetmek daha iyidir (logger mevcutsa). +- Basit uygulamalarda, güvenmek kabul edilebilir `std::terminate` bu (vakaların `noexcept` varsayılan olarak C++11) istisnaları işlemek için. + +**6.** Anonim kod blokları. + +Belirli değişkenleri yerel hale getirmek için tek bir işlevin içinde ayrı bir kod bloğu oluşturabilirsiniz, böylece bloktan çıkarken yıkıcılar çağrılır. + +``` cpp +Block block = data.in->read(); + +{ + std::lock_guard lock(mutex); + data.ready = true; + data.block = block; +} + +ready_any.set(); +``` + +**7.** Multithreading. + +Çevrimdışı veri işleme programlarında: + +- Tek bir CPU çekirdeğinde mümkün olan en iyi performansı elde etmeye çalışın. Daha sonra gerekirse kodunuzu parallelize edebilirsiniz. + +Sunucu uygulamalarında: + +- İstekleri işlemek için iş parçacığı havuzunu kullanın. Bu noktada, userspace bağlam değiştirme gerektiren herhangi bir görevimiz olmadı. + +Çatal paralelleştirme için kullanılmaz. + +**8.** İş parçacıklarını senkronize etme. + +Genellikle farklı iş parçacıklarının farklı bellek hücreleri kullanmasını sağlamak mümkündür (daha da iyisi: farklı önbellek çizgileri) ve herhangi bir iş parçacığı senkronizasyonu kullanmamak (hariç `joinAll`). + +Senkronizasyon gerekiyorsa, çoğu durumda, mutex altında kullanmak yeterlidir `lock_guard`. + +Diğer durumlarda sistem senkronizasyonu ilkellerini kullanın. Meşgul bekleme kullanmayın. + +Atomik işlemler sadece en basit durumlarda kullanılmalıdır. + +Birincil uzmanlık alanınız olmadığı sürece kilitsiz veri yapılarını uygulamaya çalışmayın. + +**9.** İşaretçiler vs referanslar. + +Çoğu durumda, referansları tercih edin. + +**10.** const. + +Sabit referanslar, sabitler için işaretçiler kullanın, `const_iterator` ve const yöntemleri. + +Düşünmek `const` varsayılan olmak ve olmayan kullanmak-`const` sadece gerektiğinde. + +Değişkenleri değere göre geçirirken, `const` genellikle mantıklı değil. + +**11.** imzasız. + +Kullanmak `unsigned` gerekirse. + +**12.** Sayısal türleri. + +Türleri kullanın `UInt8`, `UInt16`, `UInt32`, `UInt64`, `Int8`, `Int16`, `Int32`, ve `Int64` gibi `size_t`, `ssize_t`, ve `ptrdiff_t`. + +Bu türleri sayılar için kullanmayın: `signed/unsigned long`, `long long`, `short`, `signed/unsigned char`, `char`. + +**13.** Argümanları geçmek. + +Karmaşık değerleri referansla geçirin (dahil `std::string`). + +Bir işlev öbekte oluşturulan bir nesnenin sahipliğini yakalarsa, bağımsız değişken türünü yapın `shared_ptr` veya `unique_ptr`. + +**14.** Değerleri döndürür. + +Çoğu durumda, sadece kullanın `return`. Yaz domayın `[return std::move(res)]{.strike}`. + +İşlev öbek üzerinde bir nesne ayırır ve döndürürse, şunları kullanın `shared_ptr` veya `unique_ptr`. + +Nadir durumlarda, değeri bir argüman aracılığıyla döndürmeniz gerekebilir. Bu durumda, argüman bir referans olmalıdır. + +``` cpp +using AggregateFunctionPtr = std::shared_ptr; + +/** Allows creating an aggregate function by its name. + */ +class AggregateFunctionFactory +{ +public: + AggregateFunctionFactory(); + AggregateFunctionPtr get(const String & name, const DataTypes & argument_types) const; +``` + +**15.** ad. + +Ayrı bir kullanmaya gerek yoktur `namespace` uygulama kodu için. + +Küçük kütüphanelerin de buna ihtiyacı yok. + +Orta ve büyük kütüphaneler için her şeyi bir `namespace`. + +Kütüphan theede `.h` dosya, kullanabilirsiniz `namespace detail` uygulama kodu için gerekli olmayan uygulama ayrıntılarını gizlemek için. + +İn a `.cpp` dosya, bir kullanabilirsiniz `static` veya sembolleri gizlemek için anonim ad alanı. + +Ayrıca, bir `namespace` bir için kullanılabilir `enum` ilgili isimlerin harici bir yere düşmesini önlemek için `namespace` (ama kullanmak daha iyidir `enum class`). + +**16.** Ertelenmiş başlatma. + +Başlatma için bağımsız değişkenler gerekiyorsa, normalde varsayılan bir yapıcı yazmamalısınız. + +Daha sonra başlatmayı geciktirmeniz gerekiyorsa, geçersiz bir nesne oluşturacak varsayılan bir yapıcı ekleyebilirsiniz. Veya, az sayıda nesne için şunları kullanabilirsiniz `shared_ptr/unique_ptr`. + +``` cpp +Loader(DB::Connection * connection_, const std::string & query, size_t max_block_size_); + +/// For deferred initialization +Loader() {} +``` + +**17.** Sanal fonksiyonlar. + +Sınıf polimorfik kullanım için tasarlanmamışsa, işlevleri sanal hale getirmeniz gerekmez. Bu aynı zamanda yıkıcı için de geçerlidir. + +**18.** Kodlamalar. + +Her yerde UTF-8 kullanın. Kullanmak `std::string`ve`char *`. Kullanmayın `std::wstring`ve`wchar_t`. + +**19.** Günlük. + +Koddaki her yerde örneklere bakın. + +Taahhütte bulunmadan önce, tüm anlamsız ve hata ayıklama günlüğünü ve diğer hata ayıklama çıktı türlerini silin. + +İzleme düzeyinde bile döngülerde oturum açmaktan kaçınılmalıdır. + +Günlükleri herhangi bir günlük düzeyinde okunabilir olmalıdır. + +Günlük kaydı yalnızca uygulama kodunda, çoğunlukla kullanılmalıdır. + +Günlük mesajları İngilizce olarak yazılmalıdır. + +Günlük, tercihen Sistem Yöneticisi için anlaşılabilir olmalıdır. + +Günlüğünde küfür kullanmayın. + +Günlüğünde UTF-8 kodlamasını kullanın. Nadir durumlarda, günlüğünde ASCII olmayan karakterler kullanabilirsiniz. + +**20.** Giriş-çıkış. + +Kullanmayın `iostreams` uygulama performansı için kritik olan iç döngülerde (ve asla kullanmayın `stringstream`). + +Kullan... `DB/IO` kütüphane yerine. + +**21.** Tarih ve zaman. + +Görmek `DateLUT` kitaplık. + +**22.** içermek. + +Her zaman kullanın `#pragma once` korumaları dahil etmek yerine. + +**23.** kullanım. + +`using namespace` kullanılmaz. Kullanabilirsiniz `using` özel bir şeyle. Ancak bir sınıf veya işlev içinde yerel yapın. + +**24.** Kullanmayın `trailing return type` gerekli olmadıkça fonksiyonlar için. + +``` cpp +[auto f() -> void;]{.strike} +``` + +**25.** Değişkenlerin bildirimi ve başlatılması. + +``` cpp +//right way +std::string s = "Hello"; +std::string s{"Hello"}; + +//wrong way +auto s = std::string{"Hello"}; +``` + +**26.** Sanal işlevler için yaz `virtual` temel sınıfta, ama yaz `override` yerine `virtual` soyundan gelen sınıflarda. + +## C++ ' ın kullanılmayan özellikleri {#unused-features-of-c} + +**1.** Sanal devralma kullanılmaz. + +**2.** C++03 özel durum belirteçleri kullanılmaz. + +## Platform {#platform} + +**1.** Belirli bir platform için kod yazıyoruz. + +Ama diğer şeyler eşit olmak, çapraz platform veya taşınabilir kod tercih edilir. + +**2.** Dil: C++17. + +**3.** Derleyici: `gcc`. Şu anda (Aralık 2017), kod sürüm 7.2 kullanılarak derlenmiştir. (Ayrıca kullanılarak derlenebilir `clang 4`.) + +Standart kütüphane kullanılır (`libstdc++` veya `libc++`). + +**4.**OS: Linux UB .untu, daha eski değil. + +**5.**Kod x86\_64 CPU mimarisi için yazılmıştır. + +CPU komut seti, sunucularımız arasında desteklenen minimum kümedir. Şu anda, sse 4.2. + +**6.** Kullanmak `-Wall -Wextra -Werror` derleme bayrakları. + +**7.** Statik olarak bağlanması zor olanlar hariç tüm kitaplıklarla statik bağlantı kullanın (bkz. `ldd` komut). + +**8.** Kod geliştirilmiş ve yayın ayarları ile ayıklanır. + +## Araçlar {#tools} + +**1.** KDevelop iyi bir IDE. + +**2.** Hata ayıklama için kullanın `gdb`, `valgrind` (`memcheck`), `strace`, `-fsanitize=...`, veya `tcmalloc_minimal_debug`. + +**3.** Profilleme için kullanın `Linux Perf`, `valgrind` (`callgrind`), veya `strace -cf`. + +**4.** Kaynaklar Git'te. + +**5.** Montaj kullanımları `CMake`. + +**6.** Programlar kullanılarak serbest bırakılır `deb` paketler. + +**7.** Ana taahhüt yapı kırmak gerekir. + +Sadece seçilen revizyonlar uygulanabilir olarak kabul edilir. + +**8.** Kod yalnızca kısmen hazır olsa bile, mümkün olduğunca sık taahhüt yapın. + +Bu amaçla dalları kullanın. + +Eğer kod inunuz `master` şube henüz imara değil, önce inşa onu hariç `push`. Bunu bitirmek veya birkaç gün içinde kaldırmak gerekir. + +**9.** Non-önemsiz değişiklik, kullanım şubeleri ve sunucu bunları yayımlamak. + +**10.** Kullanılmayan kod depodan kaldırılır. + +## Kitaplık {#libraries} + +**1.** C++14 standart Kütüphanesi kullanılır (deneysel uzantılara izin verilir) ve `boost` ve `Poco` çerçeveler. + +**2.** Gerekirse, OS paketinde bulunan iyi bilinen kütüphaneleri kullanabilirsiniz. + +Zaten mevcut olan iyi bir çözüm varsa, başka bir kütüphane yüklemeniz gerektiği anlamına gelse bile kullanın. + +(Ancak kötü kütüphaneleri koddan kaldırmaya hazır olun .) + +**3.** Paketlerde ihtiyacınız olan şey yoksa veya eski bir sürüme veya yanlış derleme türüne sahip değilseniz, paketlerde olmayan bir kitaplık yükleyebilirsiniz. + +**4.** Kütüphane küçükse ve kendi karmaşık yapı sistemine sahip değilse, kaynak dosyaları `contrib` klasör. + +**5.** Tercih her zaman zaten kullanımda olan kütüphanelere verilir. + +## Genel Öneriler {#general-recommendations-1} + +**1.** Mümkün olduğunca az kod yazın. + +**2.** En basit çözümü deneyin. + +**3.** Nasıl çalışacağını ve iç döngünün nasıl çalışacağını bilene kadar kod yazmayın. + +**4.** En basit durumlarda, kullanın `using` sınıflar veya yapılar yerine. + +**5.** Mümkünse, kopya oluşturucuları, atama işleçleri, yıkıcılar (sınıf en az bir sanal işlev içeriyorsa, sanal bir işlev dışında) yazmayın, oluşturucuları taşıyın veya atama işleçlerini taşıyın. Başka bir deyişle, derleyici tarafından oluşturulan işlevleri düzgün çalışması gerekir. Kullanabilirsiniz `default`. + +**6.** Kod sadeleştirme teşvik edilir. Mümkünse kodunuzun boyutunu azaltın. + +## Ek Öneriler {#additional-recommendations} + +**1.** Açıkça belirtme `std::` türleri için `stddef.h` + +tavsiye edilmez. Başka bir deyişle, yazmanızı öneririz `size_t` yerine `std::size_t` daha kısa olduğu için. + +Eklemek kabul edilebilir `std::`. + +**2.** Açıkça belirtme `std::` standart C kitap fromlığından fonksiyonlar için + +tavsiye edilmez. Başka bir deyişle, yazın `memcpy` yerine `std::memcpy`. + +Bunun nedeni, aşağıdaki gibi benzer standart dışı işlevlerin olmasıdır `memmem`. Bu işlevleri zaman zaman kullanıyoruz. Bu işlevler mevcut değil `namespace std`. + +Yazar yousan `std::memcpy` yerine `memcpy` her yerde, o zaman `memmem` olarak `std::` garip görünecek. + +Yine de, hala kullanabilirsiniz `std::` eğer tercih ederseniz edin. + +**3.** Aynı olanlar standart C++ kütüphanesinde mevcut olduğunda C'den işlevleri kullanma. + +Daha verimli ise bu kabul edilebilir. + +Örneğin, kullanın `memcpy` yerine `std::copy` büyük bellek parçalarını kopyalamak için. + +**4.** Çok satırlı fonksiyon argümanları. + +Aşağıdaki sarma stillerinden herhangi birine izin verilir: + +``` cpp +function( + T1 x1, + T2 x2) +``` + +``` cpp +function( + size_t left, size_t right, + const & RangesInDataParts ranges, + size_t limit) +``` + +``` cpp +function(size_t left, size_t right, + const & RangesInDataParts ranges, + size_t limit) +``` + +``` cpp +function(size_t left, size_t right, + const & RangesInDataParts ranges, + size_t limit) +``` + +``` cpp +function( + size_t left, + size_t right, + const & RangesInDataParts ranges, + size_t limit) +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/development/style/) diff --git a/docs/tr/development/tests.md b/docs/tr/development/tests.md new file mode 100644 index 00000000000..1d39c24da5f --- /dev/null +++ b/docs/tr/development/tests.md @@ -0,0 +1,252 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 69 +toc_title: "ClickHouse testleri nas\u0131l \xE7al\u0131\u015Ft\u0131r\u0131l\u0131\ + r" +--- + +# ClickHouse Testi {#clickhouse-testing} + +## Fonksiyonel Testler {#functional-tests} + +Fonksiyonel testler en basit ve kullanımı kolay olanlardır. ClickHouse özelliklerinin çoğu fonksiyonel testlerle test edilebilir ve bu şekilde test edilebilecek ClickHouse kodundaki her değişiklik için kullanılması zorunludur. + +Her işlevsel test, çalışan ClickHouse sunucusuna bir veya birden çok sorgu gönderir ve sonucu referansla karşılaştırır. + +Testler bulunur `queries` dizin. İki alt dizin var: `stateless` ve `stateful`. Durumsuz testler, önceden yüklenmiş test verileri olmadan sorguları çalıştırır - genellikle testin kendisinde anında küçük sentetik veri kümeleri oluştururlar. Durum bilgisi testleri, Yandex'ten önceden yüklenmiş test verileri gerektirir.Metrica ve halka açık değil. Biz sadece kullanmak eğilimindedir `stateless` testler ve yeni eklemekten kaçının `stateful` testler. + +Her test iki tipten biri olabilir: `.sql` ve `.sh`. `.sql` test için borulu basit SQL komut dosyasıdır `clickhouse-client --multiquery --testmode`. `.sh` test kendisi tarafından çalıştırılan bir komut dosyasıdır. + +Tüm testleri çalıştırmak için şunları kullanın `clickhouse-test` aracı. Bak `--help` Olası seçeneklerin listesi için. Sadece tüm testleri çalıştırmak veya test adı alt dize tarafından süzülmüş testlerin alt kümesini çalıştırabilirsiniz: `./clickhouse-test substring`. + +Fonksiyonel testleri çağırmanın en basit yolu kopyalamaktır `clickhouse-client` -e doğru `/usr/bin/`, çalıştırmak `clickhouse-server` ve sonra koş `./clickhouse-test` kendi dizininden. + +Yeni test eklemek için, bir `.sql` veya `.sh` dosya içinde `queries/0_stateless` dizin, elle kontrol edin ve sonra oluşturun `.reference` aşağıdaki şekilde dosya: `clickhouse-client -n --testmode < 00000_test.sql > 00000_test.reference` veya `./00000_test.sh > ./00000_test.reference`. + +Testler yalnızca tabloları (create, drop, vb.) kullanmalıdır `test` önceden oluşturulduğu varsayılır veritabanı; ayrıca testler geçici tablolar kullanabilirsiniz. + +İşlevsel testlerde dağıtılmış sorgular kullanmak istiyorsanız, kaldıraç `remote` tablo fonksiyonu ile `127.0.0.{1..2}` sunucunun kendisini sorgulaması için adresler; veya sunucu yapılandırma dosyasında önceden tanımlanmış test kümelerini kullanabilirsiniz `test_shard_localhost`. + +Bazı testler ile işaretlenir `zookeeper`, `shard` veya `long` kendi adlarına. +`zookeeper` ZooKeeper kullanan testler içindir. `shard` testler içindir +dinlemek için sunucu gerektirir `127.0.0.*`; `distributed` veya `global` aynı var +anlama. `long` bir saniye biraz daha uzun süren testler içindir. Yapabilirsin +kullanarak bu test gruplarını devre dışı bırakın `--no-zookeeper`, `--no-shard` ve +`--no-long` sırasıyla seçenekler. + +## Bilinen Hatalar {#known-bugs} + +Fonksiyonel testlerle kolayca çoğaltılabilen bazı hatalar biliyorsak, hazırlanmış fonksiyonel testleri `tests/queries/bugs` dizin. Bu testler taşınacaktır `tests/queries/0_stateless` hatalar düzeltildiğinde. + +## Entegrasyon Testleri {#integration-tests} + +Entegrasyon testleri, kümelenmiş konfigürasyonda Clickhouse'u ve MySQL, Postgres, MongoDB gibi diğer sunucularla ClickHouse etkileşimini test etmeyi sağlar. Ağ bölmelerini, paket damlalarını vb. taklit etmek için kullanışlıdırlar. Bu testler Docker altında çalıştırılır ve çeşitli yazılımlarla birden fazla konteyner oluşturur. + +Görmek `tests/integration/README.md` bu testlerin nasıl çalıştırılacağı hakkında. + +Clickhouse'un üçüncü taraf sürücülerle entegrasyonunun sınanmadığını unutmayın. Ayrıca şu anda JDBC ve ODBC sürücülerimizle entegrasyon testlerimiz yok. + +## Ünite Testleri {#unit-tests} + +Birim testleri, Clickhouse'u bir bütün olarak değil, tek bir yalıtılmış kitaplık veya sınıfı test etmek istediğinizde kullanışlıdır. Etkinleştirebilir veya devre dışı bırakma ile testlerin yapı `ENABLE_TESTS` Cmake seçeneği. Birim testleri (ve diğer test programları) bulunur `tests` kodun alt dizinleri. Birim testlerini çalıştırmak için şunları yazın `ninja test`. Bazı testler kullanın `gtest`, ancak bazıları test başarısızlığında sıfır olmayan çıkış kodunu döndüren programlardır. + +Kodun zaten işlevsel testler tarafından kapsanması durumunda birim testlerine sahip olmak zorunlu değildir (ve işlevsel testler genellikle kullanımı çok daha basittir). + +## Performans Testleri {#performance-tests} + +Performans testleri ölçmek ve sentetik sorguları ClickHouse bazı izole kısmının performansını karşılaştırmak için izin verir. Testler bulunur `tests/performance`. Her test ile temsil edilir `.xml` test durumunun açıklaması ile dosya. Testler ile çalıştırılır `clickhouse performance-test` Aracı (Bu gömülü `clickhouse` ikilik). Görmek `--help` çağırma için. + +Her test, durdurma için bazı koşullarla (örneğin, bir döngüde bir veya birden fazla sorgu (muhtemelen parametre kombinasyonlarıyla) çalıştırır “maximum execution speed is not changing in three seconds”) ve sorgu performansı ile ilgili bazı metrikleri ölçün (örneğin “maximum execution speed”). Bazı testler önceden yüklenmiş test veri kümesinde Önkoşullar içerebilir. + +Bazı senaryoda Clickhouse'un performansını artırmak istiyorsanız ve basit sorgularda iyileştirmeler gözlemlenebiliyorsa, bir performans testi yazmanız önerilir. Her zaman kullanmak mantıklı `perf top` testleriniz sırasında veya diğer perf araçları. + +## Test araçları ve komut dosyaları {#test-tools-and-scripts} + +Bazı programlar `tests` dizin testleri hazırlanmış değil, ancak test araçlarıdır. Örneğin, için `Lexer` bir araç var `src/Parsers/tests/lexer` bu sadece stdin'in tokenizasyonunu yapar ve renklendirilmiş sonucu stdout'a yazar. Bu tür araçları kod örnekleri olarak ve keşif ve manuel test için kullanabilirsiniz. + +Ayrıca Çift Dosya yerleştirebilirsiniz `.sh` ve `.reference` aracı ile birlikte bazı önceden tanımlanmış giriş üzerinde çalıştırmak için-daha sonra komut sonucu karşılaştırılabilir `.reference` Dosya. Bu tür testler otomatik değildir. + +## Çeşitli Testler {#miscellaneous-tests} + +Bulunan dış sözlükler için testler vardır `tests/external_dictionaries` ve makine öğrenilen modeller için `tests/external_models`. Bu testler güncelleştirilmez ve tümleştirme testlerine aktarılmalıdır. + +Çekirdek ekler için ayrı bir test var. Bu test, ayrı sunucularda ClickHouse kümesini çalıştırır ve çeşitli arıza durumlarını taklit eder: ağ bölünmesi, paket bırakma (ClickHouse düğümleri arasında, ClickHouse ve ZooKeeper arasında, ClickHouse sunucusu ve istemci arasında, vb.), `kill -9`, `kill -STOP` ve `kill -CONT` , istemek [Jepsen](https://aphyr.com/tags/Jepsen). Daha sonra test, kabul edilen tüm eklerin yazıldığını ve reddedilen tüm eklerin olmadığını kontrol eder. + +Clickhouse açık kaynaklı önce çekirdek testi ayrı ekip tarafından yazılmıştır. Bu takım artık ClickHouse ile çalışmıyor. Test yanlışlıkla Java ile yazılmıştır. Bu nedenlerden dolayı, çekirdek testi yeniden yazılmalı ve entegrasyon testlerine taşınmalıdır. + +## Manuel Test {#manual-testing} + +Yeni bir özellik geliştirdiğinizde, el ile de test etmek mantıklıdır. Bunu aşağıdaki adımlarla yapabilirsiniz: + +ClickHouse Oluşturun. Terminalden Clickhouse'u çalıştırın: dizini değiştir `programs/clickhouse-server` ve ile çalıştırın `./clickhouse-server`. Bu yapılandırma kullanacak (`config.xml`, `users.xml` ve içindeki dosyalar `config.d` ve `users.d` dizinler) geçerli dizinden varsayılan olarak. ClickHouse sunucusuna bağlanmak için, çalıştırın `programs/clickhouse-client/clickhouse-client`. + +Tüm clickhouse araçlarının (sunucu, istemci, vb.) sadece tek bir ikili için symlinks olduğunu unutmayın `clickhouse`. Bu ikili bulabilirsiniz `programs/clickhouse`. Tüm araçlar olarak da çağrılabilir `clickhouse tool` yerine `clickhouse-tool`. + +Alternatif olarak ClickHouse paketini yükleyebilirsiniz: Yandex deposundan kararlı sürüm veya kendiniz için paket oluşturabilirsiniz `./release` ClickHouse kaynakları kökünde. Ardından sunucuyu şu şekilde başlatın `sudo service clickhouse-server start` (veya sunucuyu durdurmak için durdurun). Günlükleri arayın `/etc/clickhouse-server/clickhouse-server.log`. + +ClickHouse sisteminizde zaten yüklü olduğunda, yeni bir `clickhouse` ikili ve mevcut ikili değiştirin: + +``` bash +$ sudo service clickhouse-server stop +$ sudo cp ./clickhouse /usr/bin/ +$ sudo service clickhouse-server start +``` + +Ayrıca sistem clickhouse-server durdurmak ve aynı yapılandırma ile ancak terminale günlüğü ile kendi çalıştırabilirsiniz: + +``` bash +$ sudo service clickhouse-server stop +$ sudo -u clickhouse /usr/bin/clickhouse server --config-file /etc/clickhouse-server/config.xml +``` + +Gdb ile örnek: + +``` bash +$ sudo -u clickhouse gdb --args /usr/bin/clickhouse server --config-file /etc/clickhouse-server/config.xml +``` + +Sistem clickhouse-sunucu zaten çalışıyorsa ve bunu durdurmak istemiyorsanız, sizin port numaralarını değiştirebilirsiniz `config.xml` (veya bunları bir dosyada geçersiz kılma `config.d` dizin), uygun veri yolu sağlayın ve çalıştırın. + +`clickhouse` ikili neredeyse hiçbir bağımlılıkları vardır ve Linux dağıtımları geniş genelinde çalışır. Hızlı ve kirli bir sunucuda değişikliklerinizi test etmek için, sadece yapabilirsiniz `scp` taze inşa `clickhouse` sunucunuza ikili ve daha sonra yukarıdaki örneklerde olduğu gibi çalıştırın. + +## Test Ortamı {#testing-environment} + +Kararlı olarak yayınlamadan önce test ortamında dağıtın. Test ortamı, 1/39 bölümünü işleyen bir kümedir [Üye.Metrica](https://metrica.yandex.com/) veriler. Test ortamımızı Yandex ile paylaşıyoruz.Metrica takımı. ClickHouse mevcut verilerin üstünde kesinti olmadan yükseltilir. İlk önce verilerin gerçek zamanlı olarak gecikmeden başarıyla işlendiğine bakıyoruz, çoğaltma çalışmaya devam ediyor ve Yandex tarafından görülebilen herhangi bir sorun yok.Metrica takımı. İlk kontrol aşağıdaki şekilde yapılabilir: + +``` sql +SELECT hostName() AS h, any(version()), any(uptime()), max(UTCEventTime), count() FROM remote('example01-01-{1..3}t', merge, hits) WHERE EventDate >= today() - 2 GROUP BY h ORDER BY h; +``` + +Bazı durumlarda yandex'teki arkadaş ekiplerimizin test ortamına da dağıtım yapıyoruz: Pazar, Bulut, vb. Ayrıca geliştirme amacıyla kullanılan bazı donanım sunucularımız var. + +## Yük Testi {#load-testing} + +Test ortamına dağıtıldıktan sonra, üretim kümesinden gelen sorgularla yük testini çalıştırıyoruz. Bu elle yapılır. + +Etkinleştirdiğinizden emin olun `query_log` üretim kümenizde. + +Bir gün veya daha fazla sorgu günlüğü toplayın: + +``` bash +$ clickhouse-client --query="SELECT DISTINCT query FROM system.query_log WHERE event_date = today() AND query LIKE '%ym:%' AND query NOT LIKE '%system.query_log%' AND type = 2 AND is_initial_query" > queries.tsv +``` + +Bu şekilde karmaşık bir örnektir. `type = 2` başarıyla yürütülen sorguları süzer. `query LIKE '%ym:%'` yandex'ten ilgili sorguları seçmektir.Metrica. `is_initial_query` yalnızca istemci tarafından başlatılan sorguları seçmektir, Clickhouse'un kendisi tarafından değil (dağıtılmış sorgu işlemenin parçaları olarak). + +`scp` bu test kümenize günlük ve aşağıdaki gibi çalıştırın: + +``` bash +$ clickhouse benchmark --concurrency 16 < queries.tsv +``` + +(muhtemelen de belirtmek istiyorum `--user`) + +Sonra bir gece ya da hafta sonu için bırakın ve dinlenin. + +Kontrol etmelisiniz `clickhouse-server` çökmez, bellek ayak izi sınırlıdır ve performans zamanla aşağılayıcı değildir. + +Kesin sorgu yürütme zamanlamaları kaydedilmez ve sorguların ve ortamın yüksek değişkenliği nedeniyle karşılaştırılmaz. + +## Yapı Testleri {#build-tests} + +Yapı testleri, yapının çeşitli alternatif konfigürasyonlarda ve bazı yabancı sistemlerde bozulmadığını kontrol etmeyi sağlar. Testler bulunur `ci` dizin. Docker, Vagrant ve bazen de `qemu-user-static` Docker'ın içinde. Bu testler geliştirme aşamasındadır ve test çalıştırmaları otomatik değildir. + +Motivasyon: + +Normalde tüm testleri ClickHouse yapısının tek bir varyantında serbest bırakırız ve çalıştırırız. Ancak, iyice test edilmeyen alternatif yapı varyantları vardır. Örnekler: + +- FreeBSD üzerine inşa; +- sistem paketlerinden kütüphaneler ile Debian üzerine inşa; +- kütüphanelerin paylaşılan bağlantısı ile oluşturun; +- AArch64 platformunda oluşturun; +- PowerPc platformunda oluşturun. + +Örneğin, sistem paketleri ile oluştur kötü bir uygulamadır, çünkü bir sistemin hangi paketlerin tam sürümüne sahip olacağını garanti edemeyiz. Ancak bu gerçekten Debian bakıcılarına ihtiyaç duyuyor. Bu nedenle en azından bu yapı varyantını desteklemeliyiz. Başka bir örnek: paylaşılan bağlantı ortak bir sorun kaynağıdır, ancak bazı Meraklılar için gereklidir. + +Tüm yapı varyantlarında tüm testleri çalıştıramasak da, en azından çeşitli yapı varyantlarının bozulmadığını kontrol etmek istiyoruz. Bu amaçla yapı testlerini kullanıyoruz. + +## Protokol uyumluluğu testi {#testing-for-protocol-compatibility} + +ClickHouse ağ protokolünü genişlettiğimizde, eski clickhouse istemcisinin yeni clickhouse sunucusu ile çalıştığını ve yeni clickhouse istemcisinin eski clickhouse sunucusu ile çalıştığını (sadece ilgili paketlerden ikili dosyaları çalıştırarak) manuel olarak test ediyoruz. + +## Derleyiciden yardım {#help-from-the-compiler} + +Ana ClickHouse kodu (bu `dbms` dizin) ile inşa edilmiştir `-Wall -Wextra -Werror` ve bazı ek etkin uyarılar ile. Bu seçenekler üçüncü taraf kitaplıkları için etkin olmasa da. + +Clang daha yararlı uyarılar vardır-Sen ile onları arayabilirsiniz `-Weverything` ve varsayılan oluşturmak için bir şey seçin. + +Üretim yapıları için gcc kullanılır (hala clang'dan biraz daha verimli kod üretir). Geliştirme için, clang genellikle kullanımı daha uygundur. Hata ayıklama modu ile kendi makinenizde inşa edebilirsiniz (dizüstü bilgisayarınızın pilinden tasarruf etmek için), ancak derleyicinin daha fazla uyarı üretebileceğini lütfen unutmayın `-O3` daha iyi kontrol akışı ve prosedürler arası analiz nedeniyle. Clang ile inşa ederken, `libc++` yerine kullanılır `libstdc++` ve hata ayıklama modu ile oluştururken, hata ayıklama sürümü `libc++` çalışma zamanında daha fazla hata yakalamak için izin verir kullanılır. + +## Dezenfektanlar {#sanitizers} + +**Adres dezenfektanı**. +Biz başına taahhüt bazında ASan altında fonksiyonel ve entegrasyon testleri çalıştırın. + +**Valgrind (Memcheck)**. +Bir gecede valgrind altında fonksiyonel testler yapıyoruz. Birden fazla saat sürer. Şu anda bilinen bir yanlış pozitif var `re2` kütüphane, bkz [bu makale](https://research.swtch.com/sparse). + +**Tanımsız davranış dezenfektanı.** +Biz başına taahhüt bazında ASan altında fonksiyonel ve entegrasyon testleri çalıştırın. + +**İplik dezenfektanı**. +Biz başına taahhüt bazında tsan altında fonksiyonel testler çalıştırın. Tsan altında hala taahhüt bazında entegrasyon testleri yapmıyoruz. + +**Bellek temizleyici**. +Şu anda hala MSan kullanmıyoruz. + +**Hata ayıklama ayırıcısı.** +Hata ayıklama sürümü `jemalloc` hata ayıklama oluşturmak için kullanılır. + +## Fuzzing {#fuzzing} + +Rastgele SQL sorguları oluşturmak ve sunucunun ölmediğini kontrol etmek için basit fuzz testi kullanıyoruz. Fuzz testi Adres dezenfektanı ile yapılır. İçinde bulabilirsiniz `00746_sql_fuzzy.pl`. Bu test sürekli olarak (gece ve daha uzun) çalıştırılmalıdır. + +Aralık 2018 itibariyle, hala kütüphane kodunun izole fuzz testini kullanmıyoruz. + +## Güvenlik Denetimi {#security-audit} + +Yandex Bulut departmanından insanlar, güvenlik açısından ClickHouse yeteneklerine bazı temel genel bakışlar yaparlar. + +## Statik Analizörler {#static-analyzers} + +Koş weuyoruz `PVS-Studio` taahhüt bazında. Değerlendir havedik `clang-tidy`, `Coverity`, `cppcheck`, `PVS-Studio`, `tscancode`. Sen kullanım talimatları bulacaksınız `tests/instructions/` dizin. Ayrıca okuyabilirsiniz [Rusça makale](https://habr.com/company/yandex/blog/342018/). + +Kullanıyorsanız `CLion` bir IDE olarak, bazı kaldıraç `clang-tidy` kutudan kontrol eder. + +## Sertleşme {#hardening} + +`FORTIFY_SOURCE` varsayılan olarak kullanılır. Neredeyse işe yaramaz, ancak nadir durumlarda hala mantıklı ve bunu devre dışı bırakmıyoruz. + +## Kod Stili {#code-style} + +Kod stili kuralları açıklanmıştır [burada](https://clickhouse.tech/docs/en/development/style/). + +Bazı ortak stil ihlallerini kontrol etmek için şunları kullanabilirsiniz `utils/check-style` komut. + +Kodunuzun uygun stilini zorlamak için şunları kullanabilirsiniz `clang-format`. Dosya `.clang-format` kaynak rootlarında yer almaktadır. Çoğunlukla gerçek kod stilimizle karşılık gelir. Ancak uygulanması tavsiye edilmez `clang-format` varolan dosyalara biçimlendirmeyi daha da kötüleştirdiği için. Kullanabilirsiniz `clang-format-diff` eğer clang kaynak deposunda bulabilirsiniz aracı. + +Alternatif olarak deneyebilirsiniz `uncrustify` kodunuzu yeniden biçimlendirmek için bir araç. Yapılandırma içinde `uncrustify.cfg` kaynaklarda kök. Daha az test edilmiştir `clang-format`. + +`CLion` kod stilimiz için ayarlanması gereken kendi kod biçimlendiricisine sahiptir. + +## Metrica B2B testleri {#metrica-b2b-tests} + +Her ClickHouse sürümü Yandex Metrica ve AppMetrica motorları ile test edilir. Clickhouse'un Test ve kararlı sürümleri Vm'lerde dağıtılır ve Giriş verilerinin sabit örneğini işleyen Metrica motorunun küçük bir kopyasıyla çalışır. Daha sonra Metrica motorunun iki örneğinin sonuçları birlikte karşılaştırılır. + +Bu testler ayrı ekip tarafından otomatikleştirilir. Yüksek sayıda hareketli parça nedeniyle, testler çoğu zaman tamamen ilgisiz nedenlerle başarısız olur, bu da anlaşılması çok zordur. Büyük olasılıkla bu testlerin bizim için negatif değeri var. Bununla birlikte, bu testlerin yüzlerce kişiden yaklaşık bir veya iki kez yararlı olduğu kanıtlanmıştır. + +## Test Kapsamı {#test-coverage} + +Temmuz 2018 itibariyle test kapsamını takip etmiyoruz. + +## Test Otomasyonu {#test-automation} + +Yandex dahili CI ve iş otomasyon sistemi ile testler yapıyoruz “Sandbox”. + +Yapı işleri ve testler, taahhüt bazında sanal alanda çalıştırılır. Ortaya çıkan paketler ve test sonuçları Github'da yayınlanır ve doğrudan bağlantılar tarafından indirilebilir. Eserler sonsuza dek saklanır. Eğer GitHub bir çekme isteği gönderdiğinizde, biz olarak etiketlemek “can be tested” ve bizim CI sistemi sizin için ClickHouse paketleri (yayın, hata ayıklama, Adres dezenfektanı ile, vb) inşa edecek. + +Travis CI, zaman ve hesaplama gücü sınırı nedeniyle kullanmıyoruz. +Jenkins'i kullanmayız. Daha önce kullanıldı ve şimdi Jenkins kullanmadığımız için mutluyuz. + +[Orijinal makale](https://clickhouse.tech/docs/en/development/tests/) diff --git a/docs/tr/engines/database_engines/index.md b/docs/tr/engines/database_engines/index.md new file mode 100644 index 00000000000..c0e0bea8ab5 --- /dev/null +++ b/docs/tr/engines/database_engines/index.md @@ -0,0 +1,21 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "Veritaban\u0131 Motorlar\u0131" +toc_priority: 27 +toc_title: "Giri\u015F" +--- + +# Veritabanı Motorları {#database-engines} + +Veritabanı motorları, tablolarla çalışmanıza izin verir. + +Varsayılan olarak, ClickHouse yapılandırılabilir sağlayan yerel veritabanı altyapısını kullanır [masa motorları](../../engines/table_engines/index.md) ve bir [SQL lehçesi](../../sql_reference/syntax.md). + +Aşağıdaki veritabanı altyapılarını da kullanabilirsiniz: + +- [MySQL](mysql.md) + +- [Tembel](lazy.md) + +[Orijinal makale](https://clickhouse.tech/docs/en/database_engines/) diff --git a/docs/tr/engines/database_engines/lazy.md b/docs/tr/engines/database_engines/lazy.md new file mode 100644 index 00000000000..85436fdc164 --- /dev/null +++ b/docs/tr/engines/database_engines/lazy.md @@ -0,0 +1,18 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 31 +toc_title: Tembel +--- + +# Tembel {#lazy} + +Tabloları yalnızca RAM'de tutar `expiration_time_in_seconds` son erişimden saniyeler sonra. Sadece \* Log tabloları ile kullanılabilir. + +Erişimler arasında uzun bir zaman aralığı olan birçok küçük \* günlük tablosunu saklamak için optimize edilmiştir. + +## Veritabanı oluşturma {#creating-a-database} + + CREATE DATABASE testlazy ENGINE = Lazy(expiration_time_in_seconds); + +[Orijinal makale](https://clickhouse.tech/docs/en/database_engines/lazy/) diff --git a/docs/tr/engines/database_engines/mysql.md b/docs/tr/engines/database_engines/mysql.md new file mode 100644 index 00000000000..974515ab655 --- /dev/null +++ b/docs/tr/engines/database_engines/mysql.md @@ -0,0 +1,135 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 30 +toc_title: MySQL +--- + +# MySQL {#mysql} + +Uzak bir MySQL sunucusunda veritabanlarına bağlanmak ve gerçekleştirmek için izin verir `INSERT` ve `SELECT` ClickHouse ve MySQL arasında veri alışverişi için sorgular. + +Bu `MySQL` veritabanı motoru sorguları MySQL sunucusuna çevirir, böylece aşağıdaki gibi işlemleri gerçekleştirebilirsiniz `SHOW TABLES` veya `SHOW CREATE TABLE`. + +Aşağıdaki sorguları gerçekleştiremiyor: + +- `RENAME` +- `CREATE TABLE` +- `ALTER` + +## Veritabanı oluşturma {#creating-a-database} + +``` sql +CREATE DATABASE [IF NOT EXISTS] db_name [ON CLUSTER cluster] +ENGINE = MySQL('host:port', ['database' | database], 'user', 'password') +``` + +**Motor Parametreleri** + +- `host:port` — MySQL server address. +- `database` — Remote database name. +- `user` — MySQL user. +- `password` — User password. + +## Veri Türleri Desteği {#data_types-support} + +| MySQL | ClickHouse | +|----------------------------------|--------------------------------------------------------------| +| UNSIGNED TINYINT | [Uİnt8](../../sql_reference/data_types/int_uint.md) | +| TINYINT | [Int8](../../sql_reference/data_types/int_uint.md) | +| UNSIGNED SMALLINT | [Uınt16](../../sql_reference/data_types/int_uint.md) | +| SMALLINT | [Int16](../../sql_reference/data_types/int_uint.md) | +| UNSIGNED INT, UNSIGNED MEDIUMINT | [Uİnt32](../../sql_reference/data_types/int_uint.md) | +| INT, MEDIUMINT | [Int32](../../sql_reference/data_types/int_uint.md) | +| UNSIGNED BIGINT | [Uİnt64](../../sql_reference/data_types/int_uint.md) | +| BIGINT | [Int64](../../sql_reference/data_types/int_uint.md) | +| FLOAT | [Float32](../../sql_reference/data_types/float.md) | +| DOUBLE | [Float64](../../sql_reference/data_types/float.md) | +| DATE | [Tarihli](../../sql_reference/data_types/date.md) | +| DATETIME, TIMESTAMP | [DateTime](../../sql_reference/data_types/datetime.md) | +| BINARY | [FixedString](../../sql_reference/data_types/fixedstring.md) | + +Diğer tüm MySQL veri türleri dönüştürülür [Dize](../../sql_reference/data_types/string.md). + +[Nullable](../../sql_reference/data_types/nullable.md) desteklenir. + +## Kullanım Örnekleri {#examples-of-use} + +MySQL tablo: + +``` text +mysql> USE test; +Database changed + +mysql> CREATE TABLE `mysql_table` ( + -> `int_id` INT NOT NULL AUTO_INCREMENT, + -> `float` FLOAT NOT NULL, + -> PRIMARY KEY (`int_id`)); +Query OK, 0 rows affected (0,09 sec) + +mysql> insert into mysql_table (`int_id`, `float`) VALUES (1,2); +Query OK, 1 row affected (0,00 sec) + +mysql> select * from mysql_table; ++------+-----+ +| int_id | value | ++------+-----+ +| 1 | 2 | ++------+-----+ +1 row in set (0,00 sec) +``` + +Clickhouse'daki veritabanı, MySQL sunucusu ile veri alışverişi: + +``` sql +CREATE DATABASE mysql_db ENGINE = MySQL('localhost:3306', 'test', 'my_user', 'user_password') +``` + +``` sql +SHOW DATABASES +``` + +``` text +┌─name─────┐ +│ default │ +│ mysql_db │ +│ system │ +└──────────┘ +``` + +``` sql +SHOW TABLES FROM mysql_db +``` + +``` text +┌─name─────────┐ +│ mysql_table │ +└──────────────┘ +``` + +``` sql +SELECT * FROM mysql_db.mysql_table +``` + +``` text +┌─int_id─┬─value─┐ +│ 1 │ 2 │ +└────────┴───────┘ +``` + +``` sql +INSERT INTO mysql_db.mysql_table VALUES (3,4) +``` + +``` sql +SELECT * FROM mysql_db.mysql_table +``` + +``` text +┌─int_id─┬─value─┐ +│ 1 │ 2 │ +│ 3 │ 4 │ +└────────┴───────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/database_engines/mysql/) diff --git a/docs/tr/engines/index.md b/docs/tr/engines/index.md new file mode 100644 index 00000000000..48004afa1c8 --- /dev/null +++ b/docs/tr/engines/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: Motorlar +toc_priority: 25 +--- + + diff --git a/docs/tr/engines/table_engines/index.md b/docs/tr/engines/table_engines/index.md new file mode 100644 index 00000000000..fad3823453c --- /dev/null +++ b/docs/tr/engines/table_engines/index.md @@ -0,0 +1,85 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "Masa Motorlar\u0131" +toc_priority: 26 +toc_title: "Giri\u015F" +--- + +# Masa Motorları {#table_engines} + +Tablo motoru (tablo türü) belirler: + +- Verilerin nasıl ve nerede depolandığı, nereye yazılacağı ve nereden okunacağı. +- Hangi sorgular desteklenir ve nasıl. +- Eşzamanlı veri erişimi. +- Varsa indeks uselerin kullanımı. +- Çok iş parçacıklı istek yürütme mümkün olup olmadığı. +- Veri çoğaltma parametreleri. + +## Motor Aileleri {#engine-families} + +### MergeTree {#mergetree} + +Yüksek yük görevleri için en evrensel ve fonksiyonel masa motorları. Bu motorlar tarafından paylaşılan özellik, sonraki arka plan veri işleme ile hızlı veri ekleme ' dir. `MergeTree` aile motorları destek veri çoğaltma (ile [Çoğaltıyordu\*](mergetree_family/replication.md) sürümleri), bölümleme ve diğer özellikler diğer motorlarda desteklenmez. + +Ailede motorlar: + +- [MergeTree](mergetree_family/mergetree.md) +- [ReplacingMergeTree](mergetree_family/replacingmergetree.md) +- [SummingMergeTree](mergetree_family/summingmergetree.md) +- [AggregatingMergeTree](mergetree_family/aggregatingmergetree.md) +- [CollapsingMergeTree](mergetree_family/collapsingmergetree.md) +- [VersionedCollapsingMergeTree](mergetree_family/versionedcollapsingmergetree.md) +- [Graphıtemergetree](mergetree_family/graphitemergetree.md) + +### Günlük {#log} + +Hafiflik [motorlar](log_family/index.md) minimum işlevsellik ile. Birçok küçük tabloyu (yaklaşık 1 milyon satıra kadar) hızlı bir şekilde yazmanız ve daha sonra bir bütün olarak okumanız gerektiğinde en etkili olanlardır. + +Ailede motorlar: + +- [TinyLog](log_family/tinylog.md) +- [StripeLog](log_family/stripelog.md) +- [Günlük](log_family/log.md) + +### Entegrasyon Motorları {#integration-engines} + +Diğer veri depolama ve işleme sistemleri ile iletişim kurmak için motorlar. + +Ailede motorlar: + +- [Kafka](integrations/kafka.md) +- [MySQL](integrations/mysql.md) +- [ODBC](integrations/odbc.md) +- [JDBC](integrations/jdbc.md) +- [HDFS](integrations/hdfs.md) + +### Özel Motorlar {#special-engines} + +Ailede motorlar: + +- [Dağılı](special/distributed.md) +- [MaterializedView](special/materializedview.md) +- [Sözlük](special/dictionary.md) +- [Birleştirmek](special/merge.md) +- [Dosya](special/file.md) +- [Boş](special/null.md) +- [Koymak](special/set.md) +- [Katmak](special/join.md) +- [URL](special/url.md) +- [Görünüm](special/view.md) +- [Bellek](special/memory.md) +- [Arabellek](special/buffer.md) + +## Sanal Sütunlar {#table_engines-virtual-columns} + +Sanal sütun, motor kaynak kodunda tanımlanan ayrılmaz bir tablo altyapısı özniteliğidir. + +Sanal sütunları belirtmemelisiniz `CREATE TABLE` sorgula ve onları göremezsin `SHOW CREATE TABLE` ve `DESCRIBE TABLE` sorgu sonuçları. Sanal sütunlar da salt okunur, bu nedenle sanal sütunlara veri ekleyemezsiniz. + +Sanal bir sütundan veri seçmek için, adını `SELECT` sorgu. `SELECT *` sanal sütunlardan değerler döndürmez. + +Tablo sanal sütunlarından biriyle aynı ada sahip bir sütuna sahip bir tablo oluşturursanız, sanal sütuna erişilemez hale gelir. Bunu yapmayı önermiyoruz. Çakışmaları önlemek için, sanal sütun adları genellikle bir alt çizgi ile öneki. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/) diff --git a/docs/tr/engines/table_engines/integrations/hdfs.md b/docs/tr/engines/table_engines/integrations/hdfs.md new file mode 100644 index 00000000000..42e1e31b80f --- /dev/null +++ b/docs/tr/engines/table_engines/integrations/hdfs.md @@ -0,0 +1,123 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 36 +toc_title: HDFS +--- + +# HDFS {#table_engines-hdfs} + +Bu motor ile entegrasyon sağlar [Apache Hadoop](https://en.wikipedia.org/wiki/Apache_Hadoop) üzerinde veri Yönet allowingilmesine izin vererek ekosist dataem [HDFS](https://hadoop.apache.org/docs/current/hadoop-project-dist/hadoop-hdfs/HdfsDesign.html)ClickHouse aracılığıyla. Bu motor benzer +to the [Dosya](../special/file.md) ve [URL](../special/url.md) motorlar, ancak hadoop özgü özellikleri sağlar. + +## Kullanma {#usage} + +``` sql +ENGINE = HDFS(URI, format) +``` + +Bu `URI` parametre, HDFS'DEKİ tüm dosya URI'SIDIR. +Bu `format` parametre kullanılabilir dosya biçimlerinden birini belirtir. Gerçekleştirmek +`SELECT` sorgular, biçim giriş için desteklenmeli ve gerçekleştirmek için +`INSERT` queries – for output. The available formats are listed in the +[Biçimliler](../../../interfaces/formats.md#formats) bölme. +Yol kısmı `URI` globs içerebilir. Bu durumda tablo salt okunur olurdu. + +**Örnek:** + +**1.** Set up the `hdfs_engine_table` Tablo: + +``` sql +CREATE TABLE hdfs_engine_table (name String, value UInt32) ENGINE=HDFS('hdfs://hdfs1:9000/other_storage', 'TSV') +``` + +**2.** Fil filel file: + +``` sql +INSERT INTO hdfs_engine_table VALUES ('one', 1), ('two', 2), ('three', 3) +``` + +**3.** Verileri sorgula: + +``` sql +SELECT * FROM hdfs_engine_table LIMIT 2 +``` + +``` text +┌─name─┬─value─┐ +│ one │ 1 │ +│ two │ 2 │ +└──────┴───────┘ +``` + +## Uygulama Detayları {#implementation-details} + +- Okuma ve yazma paralel olabilir +- Desteklenmiyor: + - `ALTER` ve `SELECT...SAMPLE` harekat. + - Dizinler. + - Çoğalma. + +**Yolda Globs** + +Birden çok yol bileşenleri globs olabilir. İşlenmek için dosya var olmalı ve tüm yol deseniyle eşleşmelidir. Sırasında dosyaların listelen ofmesini belirler `SELECT` (not at `CREATE` an). + +- `*` — Substitutes any number of any characters except `/` boş dize dahil. +- `?` — Substitutes any single character. +- `{some_string,another_string,yet_another_one}` — Substitutes any of strings `'some_string', 'another_string', 'yet_another_one'`. +- `{N..M}` — Substitutes any number in range from N to M including both borders. + +İle yapılar `{}` benzer olan [uzak](../../../sql_reference/table_functions/remote.md) tablo işlevi. + +**Örnek** + +1. HDFS'DE aşağıdaki Urı'lerle TSV formatında birkaç dosyamız olduğunu varsayalım: + +- ‘hdfs://hdfs1:9000/some\_dir/some\_file\_1’ +- ‘hdfs://hdfs1:9000/some\_dir/some\_file\_2’ +- ‘hdfs://hdfs1:9000/some\_dir/some\_file\_3’ +- ‘hdfs://hdfs1:9000/another\_dir/some\_file\_1’ +- ‘hdfs://hdfs1:9000/another\_dir/some\_file\_2’ +- ‘hdfs://hdfs1:9000/another\_dir/some\_file\_3’ + +1. Altı dosyadan oluşan bir tablo oluşturmanın birkaç yolu vardır: + + + +``` sql +CREATE TABLE table_with_range (name String, value UInt32) ENGINE = HDFS('hdfs://hdfs1:9000/{some,another}_dir/some_file_{1..3}', 'TSV') +``` + +Başka bir yol: + +``` sql +CREATE TABLE table_with_question_mark (name String, value UInt32) ENGINE = HDFS('hdfs://hdfs1:9000/{some,another}_dir/some_file_?', 'TSV') +``` + +Tablo, her iki dizindeki tüm dosyalardan oluşur (tüm dosyalar, sorguda açıklanan biçimi ve şemayı karşılamalıdır): + +``` sql +CREATE TABLE table_with_asterisk (name String, value UInt32) ENGINE = HDFS('hdfs://hdfs1:9000/{some,another}_dir/*', 'TSV') +``` + +!!! warning "Uyarıcı" + Dosyaların listelenmesi, önde gelen sıfırlarla sayı aralıkları içeriyorsa, her basamak için parantez içeren yapıyı ayrı ayrı kullanın veya kullanın `?`. + +**Örnek** + +Adlı dosyaları içeren tablo oluşturma `file000`, `file001`, … , `file999`: + +``` sql +CREARE TABLE big_table (name String, value UInt32) ENGINE = HDFS('hdfs://hdfs1:9000/big_dir/file{0..9}{0..9}{0..9}', 'CSV') +``` + +## Sanal Sütunlar {#virtual-columns} + +- `_path` — Path to the file. +- `_file` — Name of the file. + +**Ayrıca Bakınız** + +- [Sanal sütunlar](../index.md#table_engines-virtual_columns) + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/hdfs/) diff --git a/docs/tr/engines/table_engines/integrations/index.md b/docs/tr/engines/table_engines/integrations/index.md new file mode 100644 index 00000000000..608fc900e62 --- /dev/null +++ b/docs/tr/engines/table_engines/integrations/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: Entegrasyonlar +toc_priority: 30 +--- + + diff --git a/docs/tr/engines/table_engines/integrations/jdbc.md b/docs/tr/engines/table_engines/integrations/jdbc.md new file mode 100644 index 00000000000..08196116cf8 --- /dev/null +++ b/docs/tr/engines/table_engines/integrations/jdbc.md @@ -0,0 +1,90 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 34 +toc_title: JDBC +--- + +# JDBC {#table-engine-jdbc} + +ClickHouse üzerinden harici veritabanlarına bağlanmak için izin verir [JDBC](https://en.wikipedia.org/wiki/Java_Database_Connectivity). + +JDBC bağlantısını uygulamak için ClickHouse ayrı programı kullanır [clickhouse-JDBC-köprü](https://github.com/alex-krash/clickhouse-jdbc-bridge) bu bir daemon olarak çalışmalıdır. + +Bu motor destekler [Nullable](../../../sql_reference/data_types/nullable.md) veri türü. + +## Tablo oluşturma {#creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name +( + columns list... +) +ENGINE = JDBC(dbms_uri, external_database, external_table) +``` + +**Motor Parametreleri** + +- `dbms_uri` — URI of an external DBMS. + + Biçimli: `jdbc:://:/?user=&password=`. + MySQL örneği: `jdbc:mysql://localhost:3306/?user=root&password=root`. + +- `external_database` — Database in an external DBMS. + +- `external_table` — Name of the table in `external_database`. + +## Kullanım Örneği {#usage-example} + +Doğrudan konsol istemcisine bağlanarak MySQL sunucusunda bir tablo oluşturma: + +``` text +mysql> CREATE TABLE `test`.`test` ( + -> `int_id` INT NOT NULL AUTO_INCREMENT, + -> `int_nullable` INT NULL DEFAULT NULL, + -> `float` FLOAT NOT NULL, + -> `float_nullable` FLOAT NULL DEFAULT NULL, + -> PRIMARY KEY (`int_id`)); +Query OK, 0 rows affected (0,09 sec) + +mysql> insert into test (`int_id`, `float`) VALUES (1,2); +Query OK, 1 row affected (0,00 sec) + +mysql> select * from test; ++------+----------+-----+----------+ +| int_id | int_nullable | float | float_nullable | ++------+----------+-----+----------+ +| 1 | NULL | 2 | NULL | ++------+----------+-----+----------+ +1 row in set (0,00 sec) +``` + +ClickHouse Server'da bir tablo oluşturma ve ondan veri seçme: + +``` sql +CREATE TABLE jdbc_table +( + `int_id` Int32, + `int_nullable` Nullable(Int32), + `float` Float32, + `float_nullable` Nullable(Float32) +) +ENGINE JDBC('jdbc:mysql://localhost:3306/?user=root&password=root', 'test', 'test') +``` + +``` sql +SELECT * +FROM jdbc_table +``` + +``` text +┌─int_id─┬─int_nullable─┬─float─┬─float_nullable─┐ +│ 1 │ ᴺᵁᴸᴸ │ 2 │ ᴺᵁᴸᴸ │ +└────────┴──────────────┴───────┴────────────────┘ +``` + +## Ayrıca Bakınız {#see-also} + +- [JDBC tablo işlevi](../../../sql_reference/table_functions/jdbc.md). + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/jdbc/) diff --git a/docs/tr/engines/table_engines/integrations/kafka.md b/docs/tr/engines/table_engines/integrations/kafka.md new file mode 100644 index 00000000000..baf0adcd080 --- /dev/null +++ b/docs/tr/engines/table_engines/integrations/kafka.md @@ -0,0 +1,176 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 32 +toc_title: Kafka +--- + +# Kafka {#kafka} + +Bu motor ile çalışır [Apache Kafka](http://kafka.apache.org/). + +Kafka sağlar: + +- Veri akışlarını yayınlayın veya abone olun. +- Hataya dayanıklı depolama düzenlemek. +- Kullanılabilir hale geldikçe akışları işleyin. + +## Tablo oluşturma {#table_engine-kafka-creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE = Kafka() +SETTINGS + kafka_broker_list = 'host:port', + kafka_topic_list = 'topic1,topic2,...', + kafka_group_name = 'group_name', + kafka_format = 'data_format'[,] + [kafka_row_delimiter = 'delimiter_symbol',] + [kafka_schema = '',] + [kafka_num_consumers = N,] + [kafka_skip_broken_messages = N] +``` + +Gerekli parametreler: + +- `kafka_broker_list` – A comma-separated list of brokers (for example, `localhost:9092`). +- `kafka_topic_list` – A list of Kafka topics. +- `kafka_group_name` – A group of Kafka consumers. Reading margins are tracked for each group separately. If you don't want messages to be duplicated in the cluster, use the same group name everywhere. +- `kafka_format` – Message format. Uses the same notation as the SQL `FORMAT` fonksiyon gibi `JSONEachRow`. Daha fazla bilgi için, bkz: [Biçimliler](../../../interfaces/formats.md) bölme. + +İsteğe bağlı parametreler: + +- `kafka_row_delimiter` – Delimiter character, which ends the message. +- `kafka_schema` – Parameter that must be used if the format requires a schema definition. For example, [Cap'n Proto](https://capnproto.org/) şema dosyasının yolunu ve kök adını gerektirir `schema.capnp:Message` nesne. +- `kafka_num_consumers` – The number of consumers per table. Default: `1`. Bir tüketicinin verimi yetersizse daha fazla tüketici belirtin. Bölüm başına yalnızca bir tüketici atanabileceğinden, toplam tüketici sayısı konudaki bölüm sayısını geçmemelidir. +- `kafka_skip_broken_messages` – Kafka message parser tolerance to schema-incompatible messages per block. Default: `0`. Eğer `kafka_skip_broken_messages = N` sonra motor atlar *N* Ayrıştırılamayan Kafka iletileri (bir ileti bir veri satırına eşittir). + +Örnekler: + +``` sql + CREATE TABLE queue ( + timestamp UInt64, + level String, + message String + ) ENGINE = Kafka('localhost:9092', 'topic', 'group1', 'JSONEachRow'); + + SELECT * FROM queue LIMIT 5; + + CREATE TABLE queue2 ( + timestamp UInt64, + level String, + message String + ) ENGINE = Kafka SETTINGS kafka_broker_list = 'localhost:9092', + kafka_topic_list = 'topic', + kafka_group_name = 'group1', + kafka_format = 'JSONEachRow', + kafka_num_consumers = 4; + + CREATE TABLE queue2 ( + timestamp UInt64, + level String, + message String + ) ENGINE = Kafka('localhost:9092', 'topic', 'group1') + SETTINGS kafka_format = 'JSONEachRow', + kafka_num_consumers = 4; +``` + +
+ +Bir tablo oluşturmak için kullanımdan kaldırılan yöntem + +!!! attention "Dikkat" + Bu yöntemi yeni projelerde kullanmayın. Mümkünse, eski projeleri yukarıda açıklanan yönteme geçin. + +``` sql +Kafka(kafka_broker_list, kafka_topic_list, kafka_group_name, kafka_format + [, kafka_row_delimiter, kafka_schema, kafka_num_consumers, kafka_skip_broken_messages]) +``` + +
+ +## Açıklama {#description} + +Teslim edilen mesajlar otomatik olarak izlenir, bu nedenle bir gruptaki her mesaj yalnızca bir kez sayılır. Verileri iki kez almak istiyorsanız, tablonun başka bir grup adıyla bir kopyasını oluşturun. + +Gruplar esnek ve kümede senkronize edilir. Örneğin, bir kümede 10 konu ve bir tablonun 5 kopyası varsa, her kopya 2 konu alır. Kopya sayısı değişirse, konular kopyalar arasında otomatik olarak yeniden dağıtılır. Bu konuda daha fazla bilgi edinin http://kafka.apache.org/intro. + +`SELECT` mesajları okumak için özellikle yararlı değildir (hata ayıklama hariç), çünkü her mesaj yalnızca bir kez okunabilir. Hayata görünümler kullanarak gerçek zamanlı iş parçacıkları oluşturmak daha pratiktir. Bunu yapmak için : + +1. Bir Kafka tüketici oluşturmak için motoru kullanın ve bir veri akışı düşünün. +2. İstenen yapıya sahip bir tablo oluşturun. +3. Verileri motordan dönüştüren ve daha önce oluşturulmuş bir tabloya koyan materyalleştirilmiş bir görünüm oluşturun. + +Ne zaman `MATERIALIZED VIEW` motora katılır, arka planda veri toplamaya başlar. Bu, kafka'dan sürekli olarak mesaj almanızı ve bunları kullanarak gerekli biçime dönüştürmenizi sağlar `SELECT`. +Bir kafka tablosu istediğiniz kadar materialized görüşe sahip olabilir, kafka tablosundan doğrudan veri okumazlar, ancak yeni kayıtlar (bloklar halinde) alırlar, bu şekilde farklı ayrıntı seviyesine sahip birkaç tabloya yazabilirsiniz (gruplama-toplama ve olmadan). + +Örnek: + +``` sql + CREATE TABLE queue ( + timestamp UInt64, + level String, + message String + ) ENGINE = Kafka('localhost:9092', 'topic', 'group1', 'JSONEachRow'); + + CREATE TABLE daily ( + day Date, + level String, + total UInt64 + ) ENGINE = SummingMergeTree(day, (day, level), 8192); + + CREATE MATERIALIZED VIEW consumer TO daily + AS SELECT toDate(toDateTime(timestamp)) AS day, level, count() as total + FROM queue GROUP BY day, level; + + SELECT level, sum(total) FROM daily GROUP BY level; +``` + +Performansı artırmak için, alınan iletiler bloklar halinde gruplandırılır [max\_ınsert\_block\_size](../../../operations/server_configuration_parameters/settings.md#settings-max_insert_block_size). İçinde blok oluş ifma ifdıysa [stream\_flush\_interval\_ms](../../../operations/server_configuration_parameters/settings.md) milisaniye, veri blok bütünlüğü ne olursa olsun tabloya temizlendi. + +Konu verilerini almayı durdurmak veya dönüşüm mantığını değiştirmek için, hayata geçirilmiş görünümü ayırın: + +``` sql + DETACH TABLE consumer; + ATTACH MATERIALIZED VIEW consumer; +``` + +Kullanarak hedef tabloyu değiştirmek istiyorsanız `ALTER` hedef tablo ile görünümdeki veriler arasındaki tutarsızlıkları önlemek için malzeme görünümünü devre dışı bırakmanızı öneririz. + +## Yapılandırma {#configuration} + +GraphiteMergeTree benzer şekilde, Kafka motoru ClickHouse yapılandırma dosyasını kullanarak genişletilmiş yapılandırmayı destekler. Kullanabileceğiniz iki yapılandırma anahtarı vardır: global (`kafka`) ve konu düzeyinde (`kafka_*`). Genel yapılandırma önce uygulanır ve sonra konu düzeyinde yapılandırma uygulanır (varsa). + +``` xml + + + cgrp + smallest + + + + + 250 + 100000 + +``` + +Olası yapılandırma seçeneklerinin listesi için bkz. [librdkafka yapılandırma referansı](https://github.com/edenhill/librdkafka/blob/master/CONFIGURATION.md). Alt çizgiyi kullan (`_`) ClickHouse yapılandırmasında bir nokta yerine. Mesela, `check.crcs=true` olacak `true`. + +## Sanal Sütunlar {#virtual-columns} + +- `_topic` — Kafka topic. +- `_key` — Key of the message. +- `_offset` — Offset of the message. +- `_timestamp` — Timestamp of the message. +- `_partition` — Partition of Kafka topic. + +**Ayrıca Bakınız** + +- [Sanal sütunlar](../index.md#table_engines-virtual_columns) + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/kafka/) diff --git a/docs/tr/engines/table_engines/integrations/mysql.md b/docs/tr/engines/table_engines/integrations/mysql.md new file mode 100644 index 00000000000..f6c811465e6 --- /dev/null +++ b/docs/tr/engines/table_engines/integrations/mysql.md @@ -0,0 +1,105 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 33 +toc_title: MySQL +--- + +# Mysql {#mysql} + +MySQL motoru gerçekleştirmek için izin verir `SELECT` uzak bir MySQL sunucusunda depolanan veriler üzerinde sorgular. + +## Tablo oluşturma {#creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1] [TTL expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2] [TTL expr2], + ... +) ENGINE = MySQL('host:port', 'database', 'table', 'user', 'password'[, replace_query, 'on_duplicate_clause']); +``` + +Ayrıntılı bir açıklamasını görmek [CREATE TABLE](../../../sql_reference/statements/create.md#create-table-query) sorgu. + +Tablo yapısı orijinal MySQL tablo yapısından farklı olabilir: + +- Sütun adları orijinal MySQL tablosundaki ile aynı olmalıdır, ancak bu sütunların sadece bazılarını ve herhangi bir sırada kullanabilirsiniz. +- Sütun türleri orijinal MySQL tablosundakilerden farklı olabilir. ClickHouse çalışır [döküm](../../../sql_reference/functions/type_conversion_functions.md#type_conversion_function-cast) ClickHouse veri türleri için değerler. + +**Motor Parametreleri** + +- `host:port` — MySQL server address. + +- `database` — Remote database name. + +- `table` — Remote table name. + +- `user` — MySQL user. + +- `password` — User password. + +- `replace_query` — Flag that converts `INSERT INTO` için sorgular `REPLACE INTO`. Eğer `replace_query=1`, sorgu değiştirilir. + +- `on_duplicate_clause` — The `ON DUPLICATE KEY on_duplicate_clause` eklenen ifade `INSERT` sorgu. + + Örnek: `INSERT INTO t (c1,c2) VALUES ('a', 2) ON DUPLICATE KEY UPDATE c2 = c2 + 1`, nere `on_duplicate_clause` oluyor `UPDATE c2 = c2 + 1`. Görmek [MySQL dökü documentationmanları](https://dev.mysql.com/doc/refman/8.0/en/insert-on-duplicate.html) bulmak için hangi `on_duplicate_clause` ile kullanabilirsiniz `ON DUPLICATE KEY` yan. + + Belirtmek `on_duplicate_clause` sen geçmek gerekir `0` to the `replace_query` parametre. Aynı anda geçerseniz `replace_query = 1` ve `on_duplicate_clause`, ClickHouse bir özel durum oluşturur. + +Basit `WHERE` gibi maddeler `=, !=, >, >=, <, <=` MySQL sunucusunda yürütülür. + +Geri kalan şartlar ve `LIMIT` örnekleme kısıtlaması, yalnızca MySQL sorgusu bittikten sonra Clickhouse'da yürütülür. + +## Kullanım Örneği {#usage-example} + +MySQL tablo: + +``` text +mysql> CREATE TABLE `test`.`test` ( + -> `int_id` INT NOT NULL AUTO_INCREMENT, + -> `int_nullable` INT NULL DEFAULT NULL, + -> `float` FLOAT NOT NULL, + -> `float_nullable` FLOAT NULL DEFAULT NULL, + -> PRIMARY KEY (`int_id`)); +Query OK, 0 rows affected (0,09 sec) + +mysql> insert into test (`int_id`, `float`) VALUES (1,2); +Query OK, 1 row affected (0,00 sec) + +mysql> select * from test; ++------+----------+-----+----------+ +| int_id | int_nullable | float | float_nullable | ++------+----------+-----+----------+ +| 1 | NULL | 2 | NULL | ++------+----------+-----+----------+ +1 row in set (0,00 sec) +``` + +Clickhouse'daki tablo, yukarıda oluşturulan MySQL tablosundan veri alma: + +``` sql +CREATE TABLE mysql_table +( + `float_nullable` Nullable(Float32), + `int_id` Int32 +) +ENGINE = MySQL('localhost:3306', 'test', 'test', 'bayonet', '123') +``` + +``` sql +SELECT * FROM mysql_table +``` + +``` text +┌─float_nullable─┬─int_id─┐ +│ ᴺᵁᴸᴸ │ 1 │ +└────────────────┴────────┘ +``` + +## Ayrıca Bakınız {#see-also} + +- [Bu ‘mysql’ tablo fonksiyonu](../../../sql_reference/table_functions/mysql.md) +- [Harici sözlük kaynağı olarak MySQL kullanma](../../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_sources.md#dicts-external_dicts_dict_sources-mysql) + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/mysql/) diff --git a/docs/tr/engines/table_engines/integrations/odbc.md b/docs/tr/engines/table_engines/integrations/odbc.md new file mode 100644 index 00000000000..86ded26587a --- /dev/null +++ b/docs/tr/engines/table_engines/integrations/odbc.md @@ -0,0 +1,132 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 35 +toc_title: ODBC +--- + +# ODBC {#table-engine-odbc} + +ClickHouse üzerinden harici veritabanlarına bağlanmak için izin verir [ODBC](https://en.wikipedia.org/wiki/Open_Database_Connectivity). + +ODBC bağlantılarını güvenli bir şekilde uygulamak için ClickHouse ayrı bir program kullanır `clickhouse-odbc-bridge`. ODBC sürücüsü doğrudan yüklenmişse `clickhouse-server`, sürücü sorunları ClickHouse sunucu çökmesine neden olabilir. ClickHouse otomatik olarak başlar `clickhouse-odbc-bridge` gerekli olduğunda. ODBC Köprüsü programı aynı paketten yüklenir `clickhouse-server`. + +Bu motor destekler [Nullable](../../../sql_reference/data_types/nullable.md) veri türü. + +## Tablo oluşturma {#creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1], + name2 [type2], + ... +) +ENGINE = ODBC(connection_settings, external_database, external_table) +``` + +Ayrıntılı bir açıklamasını görmek [CREATE TABLE](../../../sql_reference/statements/create.md#create-table-query) sorgu. + +Tablo yapısı kaynak tablo yapısından farklı olabilir: + +- Sütun adları kaynak tablodaki ile aynı olmalıdır, ancak yalnızca bu sütunlardan bazılarını ve herhangi bir sırada kullanabilirsiniz. +- Sütun türleri kaynak tablodakilerden farklı olabilir. ClickHouse çalışır [döküm](../../../sql_reference/functions/type_conversion_functions.md#type_conversion_function-cast) ClickHouse veri türleri için değerler. + +**Motor Parametreleri** + +- `connection_settings` — Name of the section with connection settings in the `odbc.ini` Dosya. +- `external_database` — Name of a database in an external DBMS. +- `external_table` — Name of a table in the `external_database`. + +## Kullanım Örneği {#usage-example} + +**ODBC üzerinden yerel MySQL kurulumundan veri alma** + +Bu örnek Ubuntu Linux 18.04 ve MySQL server 5.7 için kontrol edilir. + +UnixODBC ve MySQL Connector yüklü olduğundan emin olun. + +Varsayılan olarak (paketlerden yüklüyse), ClickHouse kullanıcı olarak başlar `clickhouse`. Bu nedenle, bu kullanıcıyı MySQL sunucusunda oluşturmanız ve yapılandırmanız gerekir. + +``` bash +$ sudo mysql +``` + +``` sql +mysql> CREATE USER 'clickhouse'@'localhost' IDENTIFIED BY 'clickhouse'; +mysql> GRANT ALL PRIVILEGES ON *.* TO 'clickhouse'@'clickhouse' WITH GRANT OPTION; +``` + +Sonra bağlantıyı yapılandırın `/etc/odbc.ini`. + +``` bash +$ cat /etc/odbc.ini +[mysqlconn] +DRIVER = /usr/local/lib/libmyodbc5w.so +SERVER = 127.0.0.1 +PORT = 3306 +DATABASE = test +USERNAME = clickhouse +PASSWORD = clickhouse +``` + +Kullanarak bağlantıyı kontrol edebilirsiniz `isql` unixodbc yüklemesinden yardımcı program. + +``` bash +$ isql -v mysqlconn ++-------------------------+ +| Connected! | +| | +... +``` + +MySQL tablo: + +``` text +mysql> CREATE TABLE `test`.`test` ( + -> `int_id` INT NOT NULL AUTO_INCREMENT, + -> `int_nullable` INT NULL DEFAULT NULL, + -> `float` FLOAT NOT NULL, + -> `float_nullable` FLOAT NULL DEFAULT NULL, + -> PRIMARY KEY (`int_id`)); +Query OK, 0 rows affected (0,09 sec) + +mysql> insert into test (`int_id`, `float`) VALUES (1,2); +Query OK, 1 row affected (0,00 sec) + +mysql> select * from test; ++------+----------+-----+----------+ +| int_id | int_nullable | float | float_nullable | ++------+----------+-----+----------+ +| 1 | NULL | 2 | NULL | ++------+----------+-----+----------+ +1 row in set (0,00 sec) +``` + +Clickhouse'daki tablo, MySQL tablosundan veri alma: + +``` sql +CREATE TABLE odbc_t +( + `int_id` Int32, + `float_nullable` Nullable(Float32) +) +ENGINE = ODBC('DSN=mysqlconn', 'test', 'test') +``` + +``` sql +SELECT * FROM odbc_t +``` + +``` text +┌─int_id─┬─float_nullable─┐ +│ 1 │ ᴺᵁᴸᴸ │ +└────────┴────────────────┘ +``` + +## Ayrıca Bakınız {#see-also} + +- [ODBC harici sözlükler](../../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_sources.md#dicts-external_dicts_dict_sources-odbc) +- [ODBC tablo işlevi](../../../sql_reference/table_functions/odbc.md) + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/odbc/) diff --git a/docs/tr/engines/table_engines/log_family/index.md b/docs/tr/engines/table_engines/log_family/index.md new file mode 100644 index 00000000000..062087a5874 --- /dev/null +++ b/docs/tr/engines/table_engines/log_family/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "G\xFCnl\xFCk Aile" +toc_priority: 29 +--- + + diff --git a/docs/tr/engines/table_engines/log_family/log.md b/docs/tr/engines/table_engines/log_family/log.md new file mode 100644 index 00000000000..ca1f8c4c1f4 --- /dev/null +++ b/docs/tr/engines/table_engines/log_family/log.md @@ -0,0 +1,16 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 33 +toc_title: "G\xFCnl\xFCk" +--- + +# Günlük {#log} + +Motor günlük motorları ailesine aittir. Günlük motorlarının ortak özelliklerini ve farklılıklarını görün [Log Engine Ailesi](log_family.md) makale. + +Log differsar differsit fromma [TinyLog](tinylog.md) bu küçük bir dosyada “marks” sütun dosyaları ile bulunur. Bu işaretler her veri bloğuna yazılır ve belirtilen satır sayısını atlamak için dosyayı okumaya nereden başlayacağınızı gösteren uzaklıklar içerir. Bu, tablo verilerini birden çok iş parçacığında okumayı mümkün kılar. +Eşzamanlı veri erişimi için, okuma işlemleri aynı anda gerçekleştirilebilirken, yazma işlemleri okur ve birbirlerini engeller. +Günlük altyapısı dizinleri desteklemez. Benzer şekilde, bir tabloya yazma başarısız olursa, tablo bozulur ve Okuma bir hata döndürür. Günlük altyapısı, geçici veriler, bir kez yazma tabloları ve sınama veya gösteri amaçları için uygundur. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/log/) diff --git a/docs/tr/engines/table_engines/log_family/log_family.md b/docs/tr/engines/table_engines/log_family/log_family.md new file mode 100644 index 00000000000..2a954c60def --- /dev/null +++ b/docs/tr/engines/table_engines/log_family/log_family.md @@ -0,0 +1,46 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 31 +toc_title: "Giri\u015F" +--- + +# Log Engine Ailesi {#log-engine-family} + +Bu motorlar, birçok küçük tabloyu (yaklaşık 1 milyon satıra kadar) hızlı bir şekilde yazmanız ve daha sonra bir bütün olarak okumanız gerektiğinde senaryolar için geliştirilmiştir. + +Ailenin motorları: + +- [StripeLog](stripelog.md) +- [Günlük](log.md) +- [TinyLog](tinylog.md) + +## Ortak Özellikler {#common-properties} + +Motorlar: + +- Verileri bir diskte saklayın. + +- Yazarken dosyanın sonuna veri ekleyin. + +- Eşzamanlı veri erişimi için destek kilitleri. + + Sırasında `INSERT` sorgular, tablo kilitlenir ve veri okumak ve yazmak için diğer sorgular hem tablonun kilidini açmak için bekler. Veri yazma sorguları varsa, herhangi bir sayıda veri okuma sorguları aynı anda gerçekleştirilebilir. + +- Destek yok [mutasyon](../../../sql_reference/statements/alter.md#alter-mutations) harekat. + +- Dizinleri desteklemez. + + Bu demektir ki `SELECT` veri aralıkları için sorgular verimli değildir. + +- Atomik veri yazmayın. + + Bir şey yazma işlemini bozarsa, örneğin anormal sunucu kapatma gibi bozuk verilerle bir tablo alabilirsiniz. + +## Farklılıklar {#differences} + +Bu `TinyLog` motor, ailenin en basitidir ve en fakir işlevselliği ve en düşük verimliliği sağlar. Bu `TinyLog` motor, birkaç iş parçacığı tarafından paralel veri okumayı desteklemez. Paralel okumayı destekleyen ailedeki diğer motorlardan daha yavaş veri okur ve neredeyse birçok tanımlayıcı kullanır `Log` motor, her sütunu ayrı bir dosyada sakladığı için. Basit düşük yük senaryolarında kullanın. + +Bu `Log` ve `StripeLog` motorlar paralel veri okumayı destekler. Veri okurken, ClickHouse birden çok iş parçacığı kullanır. Her iş parçacığı ayrı bir veri bloğu işler. Bu `Log` engine, tablonun her sütunu için ayrı bir dosya kullanır. `StripeLog` tüm verileri tek bir dosyada saklar. Sonuç olarak, `StripeLog` motor işletim sisteminde daha az tanımlayıcı kullanır, ancak `Log` motor veri okurken daha yüksek verimlilik sağlar. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/log_family/) diff --git a/docs/tr/engines/table_engines/log_family/stripelog.md b/docs/tr/engines/table_engines/log_family/stripelog.md new file mode 100644 index 00000000000..1ff251c3ee0 --- /dev/null +++ b/docs/tr/engines/table_engines/log_family/stripelog.md @@ -0,0 +1,95 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 32 +toc_title: StripeLog +--- + +# Stripelog {#stripelog} + +Bu motor günlük motor ailesine aittir. Günlük motorlarının ortak özelliklerini ve farklılıklarını görün [Log Engine Ailesi](log_family.md) makale. + +Az miktarda veri içeren (1 milyondan az satır) birçok tablo yazmanız gerektiğinde, bu altyapıyı senaryolarda kullanın. + +## Tablo oluşturma {#table_engines-stripelog-creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + column1_name [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + column2_name [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE = StripeLog +``` + +Ayrıntılı açıklamasına bakın [CREATE TABLE](../../../sql_reference/statements/create.md#create-table-query) sorgu. + +## Veri yazma {#table_engines-stripelog-writing-the-data} + +Bu `StripeLog` motor tüm sütunları tek bir dosyada saklar. Her biri için `INSERT` sorgu, ClickHouse veri bloğunu bir tablo dosyasının sonuna ekler, sütunları tek tek yazar. + +Her tablo için ClickHouse dosyaları yazar: + +- `data.bin` — Data file. +- `index.mrk` — File with marks. Marks contain offsets for each column of each data block inserted. + +Bu `StripeLog` motor desteklemiyor `ALTER UPDATE` ve `ALTER DELETE` harekat. + +## Verileri okuma {#table_engines-stripelog-reading-the-data} + +İşaretli dosya, Clickhouse'un verilerin okunmasını paralelleştirmesine izin verir. Bu demektir `SELECT` sorgu satırları öngörülemeyen bir sırayla döndürür. Kullan... `ORDER BY` satırları sıralamak için yan tümce. + +## Kullanım Örneği {#table_engines-stripelog-example-of-use} + +Tablo oluşturma: + +``` sql +CREATE TABLE stripe_log_table +( + timestamp DateTime, + message_type String, + message String +) +ENGINE = StripeLog +``` + +Veri ekleme: + +``` sql +INSERT INTO stripe_log_table VALUES (now(),'REGULAR','The first regular message') +INSERT INTO stripe_log_table VALUES (now(),'REGULAR','The second regular message'),(now(),'WARNING','The first warning message') +``` + +İki kullandık `INSERT` içinde iki veri bloğu oluşturmak için sorgular `data.bin` Dosya. + +ClickHouse veri seçerken birden çok iş parçacığı kullanır. Her iş parçacığı ayrı bir veri bloğu okur ve sonuç olarak satırları bağımsız olarak döndürür. Sonuç olarak, çıktıdaki satır bloklarının sırası, çoğu durumda girişteki aynı blokların sırasına uymuyor. Mesela: + +``` sql +SELECT * FROM stripe_log_table +``` + +``` text +┌───────────timestamp─┬─message_type─┬─message────────────────────┐ +│ 2019-01-18 14:27:32 │ REGULAR │ The second regular message │ +│ 2019-01-18 14:34:53 │ WARNING │ The first warning message │ +└─────────────────────┴──────────────┴────────────────────────────┘ +┌───────────timestamp─┬─message_type─┬─message───────────────────┐ +│ 2019-01-18 14:23:43 │ REGULAR │ The first regular message │ +└─────────────────────┴──────────────┴───────────────────────────┘ +``` + +Sonuçları sıralama (varsayılan olarak artan sipariş): + +``` sql +SELECT * FROM stripe_log_table ORDER BY timestamp +``` + +``` text +┌───────────timestamp─┬─message_type─┬─message────────────────────┐ +│ 2019-01-18 14:23:43 │ REGULAR │ The first regular message │ +│ 2019-01-18 14:27:32 │ REGULAR │ The second regular message │ +│ 2019-01-18 14:34:53 │ WARNING │ The first warning message │ +└─────────────────────┴──────────────┴────────────────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/stripelog/) diff --git a/docs/tr/engines/table_engines/log_family/tinylog.md b/docs/tr/engines/table_engines/log_family/tinylog.md new file mode 100644 index 00000000000..e4eccf220b1 --- /dev/null +++ b/docs/tr/engines/table_engines/log_family/tinylog.md @@ -0,0 +1,16 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 34 +toc_title: TinyLog +--- + +# TinyLog {#tinylog} + +Motor log engine ailesine aittir. Görmek [Log Engine Ailesi](log_family.md) günlük motorlarının ortak özellikleri ve farklılıkları için. + +Bu tablo motoru genellikle write-once yöntemi ile kullanılır: verileri bir kez yazın, ardından gerektiği kadar okuyun. Örneğin, kullanabilirsiniz `TinyLog`- küçük gruplar halinde işlenen Ara veriler için tablolar yazın. Çok sayıda küçük tabloda veri depolamanın verimsiz olduğunu unutmayın. + +Sorgular tek bir akışta yürütülür. Başka bir deyişle, bu motor nispeten küçük tablolar için tasarlanmıştır (yaklaşık 1.000.000 satıra kadar). Çok sayıda küçük tablonuz varsa, bu tablo motorunu kullanmak mantıklıdır, çünkü [Günlük](log.md) motor (daha az dosya açılması gerekir). + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/tinylog/) diff --git a/docs/tr/engines/table_engines/mergetree_family/aggregatingmergetree.md b/docs/tr/engines/table_engines/mergetree_family/aggregatingmergetree.md new file mode 100644 index 00000000000..8034be02969 --- /dev/null +++ b/docs/tr/engines/table_engines/mergetree_family/aggregatingmergetree.md @@ -0,0 +1,102 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 35 +toc_title: AggregatingMergeTree +--- + +# Aggregatingmergetree {#aggregatingmergetree} + +Motor devralır [MergeTree](mergetree.md#table_engines-mergetree), veri parçaları birleştirme mantığı değiştirme. ClickHouse, tüm satırları aynı birincil anahtarla değiştirir (veya daha doğru olarak, aynı [sıralama anahtarı](mergetree.md)) tek bir satırla (bir veri parçası içinde), toplama işlevlerinin durumlarının bir kombinasyonunu saklar. + +Kullanabilirsiniz `AggregatingMergeTree` artımlı veri toplama, toplanan materialized görünümleri de dahil olmak üzere tablolar. + +Motor tüm sütunları ile işler [AggregateFunction](../../../sql_reference/data_types/aggregatefunction.md) tür. + +Kullanmak uygundur `AggregatingMergeTree` siparişlere göre satır sayısını azaltırsa. + +## Tablo oluşturma {#creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE = AggregatingMergeTree() +[PARTITION BY expr] +[ORDER BY expr] +[SAMPLE BY expr] +[TTL expr] +[SETTINGS name=value, ...] +``` + +İstek parametrelerinin açıklaması için bkz. [istek açıklaması](../../../sql_reference/statements/create.md). + +**Sorgu yan tümceleri** + +Oluştururken bir `AggregatingMergeTree` tablo aynı [yanlar](mergetree.md) oluşturul ,urken olduğu gibi gerekli `MergeTree` Tablo. + +
+ +Bir tablo oluşturmak için kullanımdan kaldırılan yöntem + +!!! attention "Dikkat" + Bu yöntemi yeni projelerde kullanmayın ve mümkünse eski projeleri yukarıda açıklanan yönteme geçin. + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE [=] AggregatingMergeTree(date-column [, sampling_expression], (primary, key), index_granularity) +``` + +Tüm parametreler, aşağıdaki gibi aynı anlama sahiptir `MergeTree`. +
+ +## Seç ve Ekle {#select-and-insert} + +Veri eklemek için şunları kullanın [INSERT SELECT](../../../sql_reference/statements/insert_into.md) agrega-Devlet-fonksiyonları ile sorgu. +Veri seçerken `AggregatingMergeTree` tablo kullanın `GROUP BY` yan tümce ve veri eklerken aynı toplama işlevleri, ancak kullanarak `-Merge` sonek. + +Sonuç inlarında `SELECT` sorgu, değerleri `AggregateFunction` türü, Tüm ClickHouse çıktı biçimleri için uygulamaya özgü ikili gösterime sahiptir. Örneğin, veri dökümü, `TabSeparated` ile format `SELECT` sorgu daha sonra bu dökümü kullanarak geri yüklenebilir `INSERT` sorgu. + +## Toplu bir Somutlaştırılmış Görünüm örneği {#example-of-an-aggregated-materialized-view} + +`AggregatingMergeTree` saatler hayata görünüm `test.visits` Tablo: + +``` sql +CREATE MATERIALIZED VIEW test.basic +ENGINE = AggregatingMergeTree() PARTITION BY toYYYYMM(StartDate) ORDER BY (CounterID, StartDate) +AS SELECT + CounterID, + StartDate, + sumState(Sign) AS Visits, + uniqState(UserID) AS Users +FROM test.visits +GROUP BY CounterID, StartDate; +``` + +Veri ekleme `test.visits` Tablo. + +``` sql +INSERT INTO test.visits ... +``` + +Veriler hem tablo hem de görünümde eklenir `test.basic` toplama işlemini gerçekleştir .ecektir. + +Toplanan verileri almak için, aşağıdaki gibi bir sorgu yürütmemiz gerekir `SELECT ... GROUP BY ...` görünüm fromden `test.basic`: + +``` sql +SELECT + StartDate, + sumMerge(Visits) AS Visits, + uniqMerge(Users) AS Users +FROM test.basic +GROUP BY StartDate +ORDER BY StartDate; +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/aggregatingmergetree/) diff --git a/docs/tr/engines/table_engines/mergetree_family/collapsingmergetree.md b/docs/tr/engines/table_engines/mergetree_family/collapsingmergetree.md new file mode 100644 index 00000000000..3ef53846f32 --- /dev/null +++ b/docs/tr/engines/table_engines/mergetree_family/collapsingmergetree.md @@ -0,0 +1,309 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 36 +toc_title: CollapsingMergeTree +--- + +# CollapsingMergeTree {#table_engine-collapsingmergetree} + +Motor devralır [MergeTree](mergetree.md) ve veri parçaları birleştirme algoritmasına çöken satırların mantığını ekler. + +`CollapsingMergeTree` sıralama anahtarındaki tüm alanlar zaman uyumsuz olarak siler (daraltır) satır çiftleri (`ORDER BY`) belirli alan hariç eşdeğerdir `Sign` hangi olabilir `1` ve `-1` değerler. Çift olmayan satırlar tutulur. Daha fazla bilgi için bkz: [Çökme](#table_engine-collapsingmergetree-collapsing) belgenin bölümü. + +Motor depolama hacmini önemli ölçüde azaltabilir ve `SELECT` sonuç olarak sorgu. + +## Tablo oluşturma {#creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE = CollapsingMergeTree(sign) +[PARTITION BY expr] +[ORDER BY expr] +[SAMPLE BY expr] +[SETTINGS name=value, ...] +``` + +Sorgu parametrelerinin açıklaması için bkz. [sorgu açıklaması](../../../sql_reference/statements/create.md). + +**CollapsingMergeTree Parametreleri** + +- `sign` — Name of the column with the type of row: `1` is a “state” satır, `-1` is a “cancel” satır. + + Column data type — `Int8`. + +**Sorgu yan tümceleri** + +Oluştururken bir `CollapsingMergeTree` tablo, aynı [sorgu yan tümceleri](mergetree.md#table_engine-mergetree-creating-a-table) oluşturul ,urken olduğu gibi gerekli `MergeTree` Tablo. + +
+ +Bir tablo oluşturmak için kullanımdan kaldırılan yöntem + +!!! attention "Dikkat" + Bu yöntemi yeni projelerde kullanmayın ve mümkünse eski projeleri yukarıda açıklanan yönteme geçin. + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE [=] CollapsingMergeTree(date-column [, sampling_expression], (primary, key), index_granularity, sign) +``` + +Hariç tüm parametreler `sign` içinde olduğu gibi aynı anlama sahip `MergeTree`. + +- `sign` — Name of the column with the type of row: `1` — “state” satır, `-1` — “cancel” satır. + + Column Data Type — `Int8`. + +
+ +## Çökme {#table_engine-collapsingmergetree-collapsing} + +### Veriler {#data} + +Bazı nesneler için sürekli değişen verileri kaydetmeniz gereken durumu düşünün. Bir nesne için bir satıra sahip olmak ve herhangi bir değişiklikte güncellemek mantıklı geliyor, ancak güncelleme işlemi dbms için pahalı ve yavaş çünkü depolama alanındaki verilerin yeniden yazılmasını gerektiriyor. Verileri hızlı bir şekilde yazmanız gerekiyorsa, güncelleme kabul edilemez, ancak bir nesnenin değişikliklerini sırayla aşağıdaki gibi yazabilirsiniz. + +Belirli sütunu kullanın `Sign`. Eğer `Sign = 1` bu, satırın bir nesnenin durumu olduğu anlamına gelir, diyelim ki “state” satır. Eğer `Sign = -1` aynı özelliklere sahip bir nesnenin durumunun iptali anlamına gelir, diyelim ki “cancel” satır. + +Örneğin, kullanıcıların bazı sitelerde ne kadar sayfa kontrol ettiğini ve ne kadar süre orada olduklarını hesaplamak istiyoruz. Bir anda kullanıcı etkinliği durumu ile aşağıdaki satırı yazıyoruz: + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐ +│ 4324182021466249494 │ 5 │ 146 │ 1 │ +└─────────────────────┴───────────┴──────────┴──────┘ +``` + +Bir an sonra kullanıcı aktivitesinin değişikliğini kaydedip aşağıdaki iki satırla yazıyoruz. + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐ +│ 4324182021466249494 │ 5 │ 146 │ -1 │ +│ 4324182021466249494 │ 6 │ 185 │ 1 │ +└─────────────────────┴───────────┴──────────┴──────┘ +``` + +İlk satır, nesnenin (kullanıcı) önceki durumunu iptal eder. İptal edilen durumun sıralama anahtar alanlarını kopyalamalıdır `Sign`. + +İkinci satır geçerli durumu içerir. + +Sadece kullanıcı etkinliğinin son durumuna ihtiyacımız olduğu için, satırlar + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐ +│ 4324182021466249494 │ 5 │ 146 │ 1 │ +│ 4324182021466249494 │ 5 │ 146 │ -1 │ +└─────────────────────┴───────────┴──────────┴──────┘ +``` + +bir nesnenin geçersiz (eski) durumunu daraltarak silinebilir. `CollapsingMergeTree` veri parçalarının birleştirilmesi sırasında bunu yapar. + +Neden her değişiklik için 2 satıra ihtiyacımız var [Algoritma](#table_engine-collapsingmergetree-collapsing-algorithm) paragraf. + +**Bu yaklaşımın kendine özgü özellikleri** + +1. Verileri yazan program, iptal edebilmek için bir nesnenin durumunu hatırlamalıdır. “Cancel” dize, sıralama anahtar alanlarının kopyalarını içermelidir. “state” dize ve tersi `Sign`. Bu depolama başlangıç boyutunu artırır ama hızlı bir şekilde veri yazmak için izin verir. +2. Sütunlardaki uzun büyüyen diziler, yazma yükü nedeniyle motorun verimliliğini azaltır. Daha basit veriler, verimlilik o kadar yüksek olur. +3. Bu `SELECT` sonuçlara itiraz değişiklikler tarihin tutarlılık bağlıdır. Ekleme için veri hazırlarken doğru olun. Tutarsız verilerde öngörülemeyen sonuçlar elde edebilirsiniz, örneğin, oturum derinliği gibi negatif olmayan metrikler için negatif değerler. + +### Algoritma {#table_engine-collapsingmergetree-collapsing-algorithm} + +ClickHouse veri parçalarını birleştirdiğinde, her ardışık satır grubu aynı sıralama anahtarıyla (`ORDER BY`) en fazla iki satır reduceda indir isgen ,ir, biri `Sign = 1` (“state” satır) ve başka bir `Sign = -1` (“cancel” satır). Başka bir deyişle, girişler çöker. + +Elde edilen her veri parçası için ClickHouse kaydeder: + +1. Birincilik “cancel” ve son “state” satır sayısı ise “state” ve “cancel” satırlar eşleşir ve son satır bir “state” satır. + +2. Son “state” satır, daha varsa “state” satırlar daha “cancel” satırlar. + +3. Birincilik “cancel” satır, daha varsa “cancel” satırlar daha “state” satırlar. + +4. Diğer tüm durumlarda satırların hiçbiri. + +Ayrıca en az 2 tane daha olduğunda “state” satırlar daha “cancel” satırlar veya en az 2 tane daha “cancel” r rowsows th thenen “state” satırlar, birleştirme devam eder, ancak ClickHouse bu durumu mantıksal bir hata olarak değerlendirir ve sunucu günlüğüne kaydeder. Aynı veriler birden çok kez eklendiğinde, bu hata oluşabilir. + +Bu nedenle, çöken istatistik hesaplama sonuçlarını değiştirmemelidir. +Değişiklikler yavaş yavaş çöktü, böylece sonunda hemen hemen her nesnenin sadece son durumu kaldı. + +Bu `Sign` birleştirme algoritması, aynı sıralama anahtarına sahip tüm satırların aynı sonuçtaki veri bölümünde ve hatta aynı fiziksel sunucuda olacağını garanti etmediğinden gereklidir. ClickHouse süreci `SELECT` birden çok iş parçacığına sahip sorgular ve sonuçtaki satırların sırasını tahmin edemez. Tamamen almak için bir ihtiyaç varsa toplama gereklidir “collapsed” veri `CollapsingMergeTree` Tablo. + +Daraltmayı sonuçlandırmak için bir sorgu yazın `GROUP BY` yan tümce ve işareti için hesap toplama işlevleri. Örneğin, miktarı hesaplamak için kullanın `sum(Sign)` yerine `count()`. Bir şeyin toplamını hesaplamak için şunları kullanın `sum(Sign * x)` yerine `sum(x)`, ve böylece, ve ayrıca ekleyin `HAVING sum(Sign) > 0`. + +Toplanan `count`, `sum` ve `avg` bu şekilde hesaplanmış olabilir. Toplanan `uniq` bir nesnenin en az bir durumu çökmüş değilse hesaplanabilir. Toplanan `min` ve `max` hesaplan becauseamadı çünkü `CollapsingMergeTree` daraltılmış durumların değerleri geçmişini kaydetmez. + +Toplama olmadan veri ayıklamanız gerekiyorsa (örneğin, en yeni değerleri belirli koşullarla eşleşen satırların mevcut olup olmadığını kontrol etmek için) `FINAL` değiştirici için `FROM` yan. Bu yaklaşım önemli ölçüde daha az etkilidir. + +## Kullanım Örneği {#example-of-use} + +Örnek veriler: + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐ +│ 4324182021466249494 │ 5 │ 146 │ 1 │ +│ 4324182021466249494 │ 5 │ 146 │ -1 │ +│ 4324182021466249494 │ 6 │ 185 │ 1 │ +└─────────────────────┴───────────┴──────────┴──────┘ +``` + +Tablonun oluşturulması: + +``` sql +CREATE TABLE UAct +( + UserID UInt64, + PageViews UInt8, + Duration UInt8, + Sign Int8 +) +ENGINE = CollapsingMergeTree(Sign) +ORDER BY UserID +``` + +Veri ekleme: + +``` sql +INSERT INTO UAct VALUES (4324182021466249494, 5, 146, 1) +``` + +``` sql +INSERT INTO UAct VALUES (4324182021466249494, 5, 146, -1),(4324182021466249494, 6, 185, 1) +``` + +Biz iki kullanın `INSERT` iki farklı veri parçası oluşturmak için sorgular. Verileri bir sorgu ile eklersek ClickHouse bir veri parçası oluşturur ve hiç bir birleştirme gerçekleştirmez. + +Veri alma: + +``` sql +SELECT * FROM UAct +``` + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐ +│ 4324182021466249494 │ 5 │ 146 │ -1 │ +│ 4324182021466249494 │ 6 │ 185 │ 1 │ +└─────────────────────┴───────────┴──────────┴──────┘ +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐ +│ 4324182021466249494 │ 5 │ 146 │ 1 │ +└─────────────────────┴───────────┴──────────┴──────┘ +``` + +Ne görüyoruz ve nerede çöküyor? + +İki ile `INSERT` sorgular, 2 Veri parçası oluşturduk. Bu `SELECT` sorgu 2 iş parçacığında yapıldı ve rastgele bir satır sırası aldık. Veri parçalarının henüz birleştirilmediği için çökme gerçekleşmedi. ClickHouse biz tahmin edemez bilinmeyen bir anda veri kısmını birleştirir. + +Böylece toplama ihtiyacımız var: + +``` sql +SELECT + UserID, + sum(PageViews * Sign) AS PageViews, + sum(Duration * Sign) AS Duration +FROM UAct +GROUP BY UserID +HAVING sum(Sign) > 0 +``` + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┐ +│ 4324182021466249494 │ 6 │ 185 │ +└─────────────────────┴───────────┴──────────┘ +``` + +Toplamaya ihtiyacımız yoksa ve çökmeyi zorlamak istiyorsak, şunları kullanabiliriz `FINAL` değiştirici için `FROM` yan. + +``` sql +SELECT * FROM UAct FINAL +``` + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐ +│ 4324182021466249494 │ 6 │ 185 │ 1 │ +└─────────────────────┴───────────┴──────────┴──────┘ +``` + +Verileri seçmenin bu yolu çok verimsizdir. Büyük masalar için kullanmayın. + +## Başka Bir Yaklaşım Örneği {#example-of-another-approach} + +Örnek veriler: + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐ +│ 4324182021466249494 │ 5 │ 146 │ 1 │ +│ 4324182021466249494 │ -5 │ -146 │ -1 │ +│ 4324182021466249494 │ 6 │ 185 │ 1 │ +└─────────────────────┴───────────┴──────────┴──────┘ +``` + +Fikir, birleştirmelerin yalnızca anahtar alanları hesaba katmasıdır. Ve içinde “Cancel” satır işareti sütununu kullanmadan toplanırken satırın önceki sürümünü eşitleyen negatif değerleri belirtebiliriz. Bu yaklaşım için veri türünü değiştirmek gerekir `PageViews`,`Duration` uint8 -\> Int16 negatif değerlerini saklamak için. + +``` sql +CREATE TABLE UAct +( + UserID UInt64, + PageViews Int16, + Duration Int16, + Sign Int8 +) +ENGINE = CollapsingMergeTree(Sign) +ORDER BY UserID +``` + +Yaklaşımı test edelim: + +``` sql +insert into UAct values(4324182021466249494, 5, 146, 1); +insert into UAct values(4324182021466249494, -5, -146, -1); +insert into UAct values(4324182021466249494, 6, 185, 1); + +select * from UAct final; // avoid using final in production (just for a test or small tables) +``` + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐ +│ 4324182021466249494 │ 6 │ 185 │ 1 │ +└─────────────────────┴───────────┴──────────┴──────┘ +``` + +``` sql +SELECT + UserID, + sum(PageViews) AS PageViews, + sum(Duration) AS Duration +FROM UAct +GROUP BY UserID +```text +┌──────────────UserID─┬─PageViews─┬─Duration─┐ +│ 4324182021466249494 │ 6 │ 185 │ +└─────────────────────┴───────────┴──────────┘ +``` + +``` sqk +select count() FROM UAct +``` + +``` text +┌─count()─┐ +│ 3 │ +└─────────┘ +``` + +``` sql +optimize table UAct final; + +select * FROM UAct +``` + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐ +│ 4324182021466249494 │ 6 │ 185 │ 1 │ +└─────────────────────┴───────────┴──────────┴──────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/collapsingmergetree/) diff --git a/docs/tr/engines/table_engines/mergetree_family/custom_partitioning_key.md b/docs/tr/engines/table_engines/mergetree_family/custom_partitioning_key.md new file mode 100644 index 00000000000..ba09aa08cbb --- /dev/null +++ b/docs/tr/engines/table_engines/mergetree_family/custom_partitioning_key.md @@ -0,0 +1,127 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 32 +toc_title: "\xD6zel B\xF6l\xFCmleme Anahtar\u0131" +--- + +# Özel Bölümleme Anahtarı {#custom-partitioning-key} + +Bölümleme için kullanılabilir [MergeTree](mergetree.md) aile tabloları (dahil [çoğaltıyordu](replication.md) Tablolar). [Hayata görünümler](../special/materializedview.md) MergeTree tablolarına dayanarak bölümlemeyi de destekler. + +Bir bölüm, bir tablodaki kayıtların belirtilen bir kritere göre mantıksal bir birleşimidir. Bir bölümü, ay, gün veya olay türü gibi rasgele bir ölçütle ayarlayabilirsiniz. Bu verilerin manipülasyonlarını basitleştirmek için her bölüm ayrı ayrı saklanır. Verilere erişirken, ClickHouse mümkün olan en küçük bölüm alt kümesini kullanır. + +Bölüm belirtilen `PARTITION BY expr` fık whenra ne zaman [tablo oluşturma](mergetree.md#table_engine-mergetree-creating-a-table). Bölüm anahtarı tablo sütunlarından herhangi bir ifade olabilir. Örneğin, aya göre bölümleme belirtmek için ifadeyi kullanın `toYYYYMM(date_column)`: + +``` sql +CREATE TABLE visits +( + VisitDate Date, + Hour UInt8, + ClientID UUID +) +ENGINE = MergeTree() +PARTITION BY toYYYYMM(VisitDate) +ORDER BY Hour; +``` + +Bölüm anahtarı ayrıca bir ifade kümesi olabilir ( [birincil anahtar](mergetree.md#primary-keys-and-indexes-in-queries)). Mesela: + +``` sql +ENGINE = ReplicatedCollapsingMergeTree('/clickhouse/tables/name', 'replica1', Sign) +PARTITION BY (toMonday(StartDate), EventType) +ORDER BY (CounterID, StartDate, intHash32(UserID)); +``` + +Bu örnekte, bölümlemeyi geçerli hafta boyunca meydana gelen olay türlerine göre ayarladık. + +Bir tabloya yeni veri eklerken, bu veriler birincil anahtara göre sıralanmış ayrı bir parça (yığın) olarak depolanır. Taktıktan 10-15 dakika sonra, aynı bölümün parçaları tüm parçaya birleştirilir. + +!!! info "Bilgin" + Birleştirme yalnızca bölümleme ifadesi için aynı değere sahip veri parçaları için çalışır. Bu demektir **aşırı granüler bölümler yapmamalısınız** (yaklaşık binden fazla bölüm). Aksi takdirde, `SELECT` sorgu, dosya sistemindeki ve açık dosya tanımlayıcılarındaki makul olmayan sayıda dosya nedeniyle yetersiz performans gösterir. + +Kullan... [sistem.parçalar](../../../operations/system_tables.md#system_tables-parts) tablo tablo parçaları ve bölümleri görüntülemek için. Örneğin, bir var varsayalım `visits` aya göre bölümleme ile tablo. Hadi gerçekleştirelim `SELECT` sorgu için `system.parts` Tablo: + +``` sql +SELECT + partition, + name, + active +FROM system.parts +WHERE table = 'visits' +``` + +``` text +┌─partition─┬─name───────────┬─active─┐ +│ 201901 │ 201901_1_3_1 │ 0 │ +│ 201901 │ 201901_1_9_2 │ 1 │ +│ 201901 │ 201901_8_8_0 │ 0 │ +│ 201901 │ 201901_9_9_0 │ 0 │ +│ 201902 │ 201902_4_6_1 │ 1 │ +│ 201902 │ 201902_10_10_0 │ 1 │ +│ 201902 │ 201902_11_11_0 │ 1 │ +└───────────┴────────────────┴────────┘ +``` + +Bu `partition` sütun bölümlerin adlarını içerir. Bu örnekte iki bölüm vardır: `201901` ve `201902`. Bölüm adını belirtmek için bu sütun değerini kullanabilirsiniz [ALTER … PARTITION](#alter_manipulations-with-partitions) sorgular. + +Bu `name` sütun, bölüm veri parçalarının adlarını içerir. Bölümün adını belirtmek için bu sütunu kullanabilirsiniz. [ALTER ATTACH PART](#alter_attach-partition) sorgu. + +İlk bölümün adını kıralım: `201901_1_3_1`: + +- `201901` bölüm adıdır. +- `1` en az veri bloğu sayısıdır. +- `3` veri bloğunun maksimum sayısıdır. +- `1` yığın düzeyidir (oluşturduğu birleştirme ağacının derinliği). + +!!! info "Bilgin" + Eski tip tabloların parçaları adı vardır: `20190117_20190123_2_2_0` (minimum tarih - maksimum tarih - minimum blok numarası - maksimum blok numarası - seviye). + +Bu `active` sütun, parçanın durumunu gösterir. `1` aktif istir; `0` etkin değil. Etkin olmayan parçalar, örneğin, daha büyük bir parçaya birleştirildikten sonra kalan kaynak parçalarıdır. Bozuk veri parçaları da etkin olarak gösterilir. + +Örnekte gördüğünüz gibi, aynı bölümün birkaç ayrı parçası vardır (örneğin, `201901_1_3_1` ve `201901_1_9_2`). Bu, bu parçaların henüz birleştirilmediği anlamına gelir. ClickHouse, eklendikten yaklaşık 15 dakika sonra eklenen veri parçalarını periyodik olarak birleştirir. Buna ek olarak, kullanarak zamanlanmış olmayan birleştirme gerçekleştirebilirsiniz [OPTIMIZE](../../../sql_reference/statements/misc.md#misc_operations-optimize) sorgu. Örnek: + +``` sql +OPTIMIZE TABLE visits PARTITION 201902; +``` + +``` text +┌─partition─┬─name───────────┬─active─┐ +│ 201901 │ 201901_1_3_1 │ 0 │ +│ 201901 │ 201901_1_9_2 │ 1 │ +│ 201901 │ 201901_8_8_0 │ 0 │ +│ 201901 │ 201901_9_9_0 │ 0 │ +│ 201902 │ 201902_4_6_1 │ 0 │ +│ 201902 │ 201902_4_11_2 │ 1 │ +│ 201902 │ 201902_10_10_0 │ 0 │ +│ 201902 │ 201902_11_11_0 │ 0 │ +└───────────┴────────────────┴────────┘ +``` + +Etkin olmayan parçalar birleştirildikten yaklaşık 10 dakika sonra silinecektir. + +Bir parça ve bölüm kümesini görüntülemenin başka bir yolu da tablonun dizinine gitmektir: `/var/lib/clickhouse/data///`. Mesela: + +``` bash +/var/lib/clickhouse/data/default/visits$ ls -l +total 40 +drwxr-xr-x 2 clickhouse clickhouse 4096 Feb 1 16:48 201901_1_3_1 +drwxr-xr-x 2 clickhouse clickhouse 4096 Feb 5 16:17 201901_1_9_2 +drwxr-xr-x 2 clickhouse clickhouse 4096 Feb 5 15:52 201901_8_8_0 +drwxr-xr-x 2 clickhouse clickhouse 4096 Feb 5 15:52 201901_9_9_0 +drwxr-xr-x 2 clickhouse clickhouse 4096 Feb 5 16:17 201902_10_10_0 +drwxr-xr-x 2 clickhouse clickhouse 4096 Feb 5 16:17 201902_11_11_0 +drwxr-xr-x 2 clickhouse clickhouse 4096 Feb 5 16:19 201902_4_11_2 +drwxr-xr-x 2 clickhouse clickhouse 4096 Feb 5 12:09 201902_4_6_1 +drwxr-xr-x 2 clickhouse clickhouse 4096 Feb 1 16:48 detached +``` + +Klasör ‘201901\_1\_1\_0’, ‘201901\_1\_7\_1’ ve böylece parçaların dizinleri vardır. Her bölüm karşılık gelen bir bölümle ilgilidir ve yalnızca belirli bir ay için veri içerir (Bu örnekteki tabloda aylara göre bölümleme vardır). + +Bu `detached` dizin kullanarak tablodan ayrılmış parçaları içerir [DETACH](#alter_detach-partition) sorgu. Bozuk parçalar da silinmek yerine bu dizine taşınır. Sunucu parçaları kullanmaz `detached` directory. You can add, delete, or modify the data in this directory at any time – the server will not know about this until you run the [ATTACH](../../../sql_reference/statements/alter.md#alter_attach-partition) sorgu. + +İşletim sunucusunda, sunucu bunu bilmediğinden, dosya sistemindeki parça kümesini veya verilerini el ile değiştiremeyeceğinizi unutmayın. Çoğaltılmamış tablolar için, sunucu durdurulduğunda bunu yapabilirsiniz, ancak önerilmez. Çoğaltılmış tablolar için, parça kümesi her durumda değiştirilemez. + +ClickHouse, bölümlerle işlemleri gerçekleştirmenize izin verir: bunları silin, bir tablodan diğerine kopyalayın veya bir yedek oluşturun. Bölümdeki tüm işlemlerin listesine bakın [Bölümler ve parçalar ile manipülasyonlar](../../../sql_reference/statements/alter.md#alter_manipulations-with-partitions). + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/custom_partitioning_key/) diff --git a/docs/tr/engines/table_engines/mergetree_family/graphitemergetree.md b/docs/tr/engines/table_engines/mergetree_family/graphitemergetree.md new file mode 100644 index 00000000000..5d4a349631b --- /dev/null +++ b/docs/tr/engines/table_engines/mergetree_family/graphitemergetree.md @@ -0,0 +1,174 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 38 +toc_title: "Graph\u0131temergetree" +--- + +# Graphıtemergetree {#graphitemergetree} + +Bu motor inceltme ve toplama/ortalama (toplaması) için tasarlanmıştır) [Grafit](http://graphite.readthedocs.io/en/latest/index.html) veriler. Clickhouse'u Grafit için bir veri deposu olarak kullanmak isteyen geliştiriciler için yararlı olabilir. + +Toplamaya ihtiyacınız yoksa Grafit verilerini depolamak için herhangi bir ClickHouse tablo motorunu kullanabilirsiniz, ancak bir toplamaya ihtiyacınız varsa `GraphiteMergeTree`. Motor, depolama hacmini azaltır ve grafitten gelen sorguların verimliliğini arttırır. + +Motor özellikleri devralır [MergeTree](mergetree.md). + +## Tablo oluşturma {#creating-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + Path String, + Time DateTime, + Value , + Version + ... +) ENGINE = GraphiteMergeTree(config_section) +[PARTITION BY expr] +[ORDER BY expr] +[SAMPLE BY expr] +[SETTINGS name=value, ...] +``` + +Ayrıntılı bir açıklamasını görmek [CREATE TABLE](../../../sql_reference/statements/create.md#create-table-query) sorgu. + +Grafit verileri için bir tablo aşağıdaki veriler için aşağıdaki sütunlara sahip olmalıdır: + +- Metrik adı (Grafit sensörü). Veri türü: `String`. + +- Metrik ölçme zamanı. Veri türü: `DateTime`. + +- Metrik değeri. Veri türü: herhangi bir sayısal. + +- Metrik sürümü. Veri türü: herhangi bir sayısal. + + ClickHouse en yüksek sürümü veya sürümleri aynı ise son yazılan satırları kaydeder. Veri parçalarının birleştirilmesi sırasında diğer satırlar silinir. + +Bu sütunların adları toplaması yapılandırmasında ayarlanmalıdır. + +**Graphıtemergetree parametreleri** + +- `config_section` — Name of the section in the configuration file, where are the rules of rollup set. + +**Sorgu yan tümceleri** + +Oluştururken bir `GraphiteMergeTree` tablo, aynı [yanlar](mergetree.md#table_engine-mergetree-creating-a-table) oluşturul ,urken olduğu gibi gerekli `MergeTree` Tablo. + +
+ +Bir tablo oluşturmak için kullanımdan kaldırılan yöntem + +!!! attention "Dikkat" + Bu yöntemi yeni projelerde kullanmayın ve mümkünse eski projeleri yukarıda açıklanan yönteme geçin. + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + EventDate Date, + Path String, + Time DateTime, + Value , + Version + ... +) ENGINE [=] GraphiteMergeTree(date-column [, sampling_expression], (primary, key), index_granularity, config_section) +``` + +Hariç tüm parametreler `config_section` içinde olduğu gibi aynı anlama sahip `MergeTree`. + +- `config_section` — Name of the section in the configuration file, where are the rules of rollup set. + +
+ +## Toplaması Yapılandırması {#rollup-configuration} + +Toplaması için ayarları tarafından tanımlanan [graphite\_rollup](../../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-graphite_rollup) sunucu yapılandırmasında parametre. Parametrenin adı herhangi biri olabilir. Birkaç yapılandırma oluşturabilir ve bunları farklı tablolar için kullanabilirsiniz. + +Toplaması yapılandırma yapısı: + + required-columns + patterns + +### Gerekli Sütunlar {#required-columns} + +- `path_column_name` — The name of the column storing the metric name (Graphite sensor). Default value: `Path`. +- `time_column_name` — The name of the column storing the time of measuring the metric. Default value: `Time`. +- `value_column_name` — The name of the column storing the value of the metric at the time set in `time_column_name`. Varsayılan değer: `Value`. +- `version_column_name` — The name of the column storing the version of the metric. Default value: `Timestamp`. + +### Desenler {#patterns} + +Bu yapı `patterns` bölme: + +``` text +pattern + regexp + function +pattern + regexp + age + precision + ... +pattern + regexp + function + age + precision + ... +pattern + ... +default + function + age + precision + ... +``` + +!!! warning "Dikkat" + Desenler kesinlikle sipariş edilmelidir: + + 1. Patterns without `function` or `retention`. + 1. Patterns with both `function` and `retention`. + 1. Pattern `default`. + +Bir satır işlerken, ClickHouse kuralları denetler `pattern` bölmeler. Tüm `pattern` (içeren `default`) bölümler içerebilir `function` toplama için parametre, `retention` parametreler veya her ikisi. Metrik adı eşleşirse `regexp` gelen kuralları `pattern` bölüm (veya bölümler) uygulanır; aksi takdirde, kurallar `default` bölüm kullanılır. + +Alanlar için `pattern` ve `default` bölmeler: + +- `regexp`– A pattern for the metric name. +- `age` – The minimum age of the data in seconds. +- `precision`– How precisely to define the age of the data in seconds. Should be a divisor for 86400 (seconds in a day). +- `function` – The name of the aggregating function to apply to data whose age falls within the range `[age, age + precision]`. + +### Yapılandırma Örneği {#configuration-example} + +``` xml + + Version + + click_cost + any + + 0 + 5 + + + 86400 + 60 + + + + max + + 0 + 60 + + + 3600 + 300 + + + 86400 + 3600 + + + +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/graphitemergetree/) diff --git a/docs/tr/engines/table_engines/mergetree_family/index.md b/docs/tr/engines/table_engines/mergetree_family/index.md new file mode 100644 index 00000000000..e722564f4dd --- /dev/null +++ b/docs/tr/engines/table_engines/mergetree_family/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: MergeTree Ailesi +toc_priority: 28 +--- + + diff --git a/docs/tr/engines/table_engines/mergetree_family/mergetree.md b/docs/tr/engines/table_engines/mergetree_family/mergetree.md new file mode 100644 index 00000000000..a06aae83e1f --- /dev/null +++ b/docs/tr/engines/table_engines/mergetree_family/mergetree.md @@ -0,0 +1,654 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 30 +toc_title: MergeTree +--- + +# MergeTree {#table_engines-mergetree} + +Bu `MergeTree` bu ailenin motoru ve diğer motorları (`*MergeTree`) en sağlam ClickHouse masa motorlarıdır. + +Motor inlarda `MergeTree` aile, bir tabloya çok büyük miktarda veri eklemek için tasarlanmıştır. Veriler hızlı bir şekilde tabloya kısmen yazılır, daha sonra parçaları arka planda birleştirmek için kurallar uygulanır. Bu yöntem, ınsert sırasında depolama alanındaki verileri sürekli olarak yeniden yazmaktan çok daha etkilidir. + +Ana özellikler: + +- Birincil anahtara göre sıralanmış verileri saklar. + + Bu, verileri daha hızlı bulmanıza yardımcı olan küçük bir seyrek dizin oluşturmanıza olanak sağlar. + +- Bölümler eğer kullanılabilir [bölümleme anahtarı](custom_partitioning_key.md) belirt .ilmektedir. + + ClickHouse, aynı sonuçla aynı veriler üzerindeki genel işlemlerden daha etkili olan bölümlerle belirli işlemleri destekler. ClickHouse, bölümleme anahtarının sorguda belirtildiği bölüm verilerini de otomatik olarak keser. Bu da sorgu performansını artırır. + +- Veri çoğaltma desteği. + + The family of `ReplicatedMergeTree` tablolar veri çoğaltma sağlar. Daha fazla bilgi için, bkz. [Veri çoğaltma](replication.md). + +- Veri örnekleme desteği. + + Gerekirse, tabloda veri örnekleme yöntemini ayarlayabilirsiniz. + +!!! info "Bilgin" + Bu [Birleştirmek](../special/merge.md) motor ait değil `*MergeTree` aile. + +## Tablo oluşturma {#table_engine-mergetree-creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1] [TTL expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2] [TTL expr2], + ... + INDEX index_name1 expr1 TYPE type1(...) GRANULARITY value1, + INDEX index_name2 expr2 TYPE type2(...) GRANULARITY value2 +) ENGINE = MergeTree() +[PARTITION BY expr] +[ORDER BY expr] +[PRIMARY KEY expr] +[SAMPLE BY expr] +[TTL expr [DELETE|TO DISK 'xxx'|TO VOLUME 'xxx'], ...] +[SETTINGS name=value, ...] +``` + +Parametrelerin açıklaması için bkz. [Sorgu açıklaması oluştur](../../../sql_reference/statements/create.md). + +!!! note "Not" + `INDEX` deneysel bir özelliktir, bkz [Veri Atlama Dizinleri](#table_engine-mergetree-data_skipping-indexes). + +### Sorgu Yan Tümceleri {#mergetree-query-clauses} + +- `ENGINE` — Name and parameters of the engine. `ENGINE = MergeTree()`. Bu `MergeTree` motor parametreleri yok. + +- `PARTITION BY` — The [bölümleme anahtarı](custom_partitioning_key.md). + + Aylara göre bölümleme için `toYYYYMM(date_column)` ifade, nerede `date_column` türün tarihi olan bir sütun mu [Tarihli](../../../sql_reference/data_types/date.md). Burada bölüm isimleri var `"YYYYMM"` biçimli. + +- `ORDER BY` — The sorting key. + + Sütun veya keyfi ifadeler bir tuple. Örnek: `ORDER BY (CounterID, EventDate)`. + +- `PRIMARY KEY` — The primary key if it [sıralama anahtarından farklıdır](mergetree.md). + + Varsayılan olarak, birincil anahtar sıralama anahtarıyla aynıdır (bu anahtar tarafından belirtilir). `ORDER BY` yan). Bu nedenle çoğu durumda ayrı bir belirtmek gereksizdir `PRIMARY KEY` yan. + +- `SAMPLE BY` — An expression for sampling. + + Bir örnekleme ifadesi kullanılırsa, birincil anahtar onu içermelidir. Örnek: `SAMPLE BY intHash32(UserID) ORDER BY (CounterID, EventDate, intHash32(UserID))`. + +- `TTL` — A list of rules specifying storage duration of rows and defining logic of automatic parts movement [diskler ve birimler arasında](#table_engine-mergetree-multiple-volumes). + + İfade bir olmalıdır `Date` veya `DateTime` sonuç olarak sütun. Örnek: + `TTL date + INTERVAL 1 DAY` + + Kuralın türü `DELETE|TO DISK 'xxx'|TO VOLUME 'xxx'` ifade tatmin edildiyse (geçerli zamana ulaşırsa) parça ile yapılacak bir eylemi belirtir: süresi dolmuş satırların kaldırılması, bir parçanın (bir parçadaki tüm satırlar için ifade tatmin edildiyse) belirtilen diske taşınması (`TO DISK 'xxx'`) veya hacim (`TO VOLUME 'xxx'`). Kuralın varsayılan türü kaldırma (`DELETE`). Birden fazla kural listesi belirtilebilir, ancak birden fazla olmamalıdır `DELETE` kural. + + Daha fazla ayrıntı için bkz. [Sütunlar ve tablolar için TTL](#table_engine-mergetree-ttl) + +- `SETTINGS` — Additional parameters that control the behavior of the `MergeTree`: + + - `index_granularity` — Maximum number of data rows between the marks of an index. Default value: 8192. See [Veri Depolama](#mergetree-data-storage). + - `index_granularity_bytes` — Maximum size of data granules in bytes. Default value: 10Mb. To restrict the granule size only by number of rows, set to 0 (not recommended). See [Veri Depolama](#mergetree-data-storage). + - `enable_mixed_granularity_parts` — Enables or disables transitioning to control the granule size with the `index_granularity_bytes` ayar. 19.11 sürümünden önce, sadece `index_granularity` granül boyutunu kısıtlamak için ayar. Bu `index_granularity_bytes` büyük satırlar (onlarca ve megabayt yüzlerce) ile tablolardan veri seçerken ayarı ClickHouse performansını artırır. Büyük satırlara sahip tablolarınız varsa, tabloların verimliliğini artırmak için bu ayarı etkinleştirebilirsiniz. `SELECT` sorgular. + - `use_minimalistic_part_header_in_zookeeper` — Storage method of the data parts headers in ZooKeeper. If `use_minimalistic_part_header_in_zookeeper=1`, daha sonra ZooKeeper daha az veri depolar. Daha fazla bilgi için, bkz: [ayar açıklaması](../../../operations/server_configuration_parameters/settings.md#server-settings-use_minimalistic_part_header_in_zookeeper) içinde “Server configuration parameters”. + - `min_merge_bytes_to_use_direct_io` — The minimum data volume for merge operation that is required for using direct I/O access to the storage disk. When merging data parts, ClickHouse calculates the total storage volume of all the data to be merged. If the volume exceeds `min_merge_bytes_to_use_direct_io` bayt, ClickHouse okur ve doğrudan I/O arabirimi kullanarak depolama diskine veri yazar (`O_DIRECT` seçenek). Eğer `min_merge_bytes_to_use_direct_io = 0`, sonra doğrudan g / Ç devre dışı bırakılır. Varsayılan değer: `10 * 1024 * 1024 * 1024` baytlar. + + - `merge_with_ttl_timeout` — Minimum delay in seconds before repeating a merge with TTL. Default value: 86400 (1 day). + - `write_final_mark` — Enables or disables writing the final index mark at the end of data part (after the last byte). Default value: 1. Don't turn it off. + - `merge_max_block_size` — Maximum number of rows in block for merge operations. Default value: 8192. + - `storage_policy` — Storage policy. See [Veri depolama için birden fazla blok cihazı kullanma](#table_engine-mergetree-multiple-volumes). + +**Bölüm ayarı örneği** + +``` sql +ENGINE MergeTree() PARTITION BY toYYYYMM(EventDate) ORDER BY (CounterID, EventDate, intHash32(UserID)) SAMPLE BY intHash32(UserID) SETTINGS index_granularity=8192 +``` + +Örnekte, aylara göre bölümleme ayarladık. + +Biz de kullanıcı kimliği ile karma olarak örnekleme için bir ifade ayarlayın. Bu, her biri için tablodaki verileri pseudorandomize etmenizi sağlar `CounterID` ve `EventDate`. Tanım yoularsanız bir [SAMPLE](../../../sql_reference/statements/select.md#select-sample-clause) yan tümcesi verileri seçerken, ClickHouse kullanıcıların bir alt kümesi için eşit pseudorandom veri örneği döndürür. + +Bu `index_granularity` 8192 varsayılan değer olduğundan ayarı atlanabilir. + +
+ +Bir tablo oluşturmak için kullanımdan kaldırılan yöntem + +!!! attention "Dikkat" + Bu yöntemi yeni projelerde kullanmayın. Mümkünse, eski projeleri yukarıda açıklanan yönteme geçin. + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE [=] MergeTree(date-column [, sampling_expression], (primary, key), index_granularity) +``` + +**MergeTree () Parametreleri** + +- `date-column` — The name of a column of the [Tarihli](../../../sql_reference/data_types/date.md) tür. ClickHouse otomatik olarak bu sütuna göre ay bölümleri oluşturur. Bölüm adları `"YYYYMM"` biçimli. +- `sampling_expression` — An expression for sampling. +- `(primary, key)` — Primary key. Type: [Demet()](../../../sql_reference/data_types/tuple.md) +- `index_granularity` — The granularity of an index. The number of data rows between the “marks” bir dizinin. 8192 değeri çoğu görev için uygundur. + +**Örnek** + +``` sql +MergeTree(EventDate, intHash32(UserID), (CounterID, EventDate, intHash32(UserID)), 8192) +``` + +Bu `MergeTree` motor, Ana motor yapılandırma yöntemi için yukarıdaki örnekte olduğu gibi yapılandırılır. +
+ +## Veri Depolama {#mergetree-data-storage} + +Bir tabloda birincil anahtar tarafından sıralanmış verileri bölümden oluşmaktadır. + +Veri bir tabloya eklendiğinde, ayrı veri parçaları oluşturulur ve bunların her biri birincil anahtara göre lexicographically sıralanır. Örneğin, birincil anahtar `(CounterID, Date)`, parçadaki veriler şu şekilde sıralanır `CounterID` ve içinde her `CounterID` tarafından sipariş edilir `Date`. + +Farklı bölümlere ait veriler farklı parçalara ayrılır. Arka planda, ClickHouse daha verimli depolama için veri parçalarını birleştirir. Farklı bölümlere ait parçalar birleştirilmez. Birleştirme mekanizması, aynı birincil anahtara sahip tüm satırların aynı veri bölümünde olacağını garanti etmez. + +Her veri parçası mantıksal olarak granüllere ayrılmıştır. Bir granül, Clickhouse'un veri seçerken okuduğu en küçük bölünmez veri kümesidir. ClickHouse satırları veya değerleri bölmez, bu nedenle her granül her zaman bir tamsayı satır içerir. Bir granülün ilk satırı, satır için birincil anahtarın değeri ile işaretlenir. Her veri bölümü için ClickHouse işaretleri depolayan bir dizin dosyası oluşturur. Her sütun için, birincil anahtarda olsun ya da olmasın, ClickHouse aynı işaretleri de saklar. Bu işaretler, verileri doğrudan sütun dosyalarında bulmanızı sağlar. + +Granül boyutu ile sınırlıdır `index_granularity` ve `index_granularity_bytes` tablo motorunun ayarları. Bir granüldeki satır sayısı `[1, index_granularity]` Aralık, satırların boyutuna bağlı olarak. Bir granülün boyutu aşabilir `index_granularity_bytes` tek bir satırın boyutu ayarın değerinden büyükse. Bu durumda, granülün boyutu satırın boyutuna eşittir. + +## Sorgularda birincil anahtarlar ve dizinler {#primary-keys-and-indexes-in-queries} + +Tak thee the `(CounterID, Date)` örnek olarak birincil anahtar. Bu durumda, sıralama ve dizin aşağıdaki gibi gösterilebilir: + + Whole data: [---------------------------------------------] + CounterID: [aaaaaaaaaaaaaaaaaabbbbcdeeeeeeeeeeeeefgggggggghhhhhhhhhiiiiiiiiikllllllll] + Date: [1111111222222233331233211111222222333211111112122222223111112223311122333] + Marks: | | | | | | | | | | | + a,1 a,2 a,3 b,3 e,2 e,3 g,1 h,2 i,1 i,3 l,3 + Marks numbers: 0 1 2 3 4 5 6 7 8 9 10 + +Veri sorgusu belirtirse: + +- `CounterID in ('a', 'h')`, sunucu işaretleri aralıklarında verileri okur `[0, 3)` ve `[6, 8)`. +- `CounterID IN ('a', 'h') AND Date = 3`, sunucu işaretleri aralıklarında verileri okur `[1, 3)` ve `[7, 8)`. +- `Date = 3`, sunucu işaretleri aralığında veri okur `[1, 10]`. + +Yukarıdaki örnekler, her zaman bir dizin tam taramadan daha etkili olduğunu göstermektedir. + +Seyrek bir dizin, ekstra verilerin okunmasına izin verir. Birincil anahtarın tek bir aralığını okurken, `index_granularity * 2` her veri bloğundaki ekstra satırlar okunabilir. + +Seyrek dizinler, çok sayıda tablo satırı ile çalışmanıza izin verir, çünkü çoğu durumda, bu tür dizinler bilgisayarın RAM'İNE sığar. + +ClickHouse benzersiz bir birincil anahtar gerektirmez. Aynı birincil anahtar ile birden çok satır ekleyebilirsiniz. + +### Birincil anahtar seçme {#selecting-the-primary-key} + +Birincil anahtardaki sütun sayısı açıkça sınırlı değildir. Veri yapısına bağlı olarak, birincil anahtara daha fazla veya daha az sütun ekleyebilirsiniz. Bu Mayıs: + +- Bir dizin performansını artırın. + + Birincil anahtar ise `(a, b)`, sonra başka bir sütun ekleyerek `c` aşağıdaki koşullar yerine getirilirse performansı artıracaktır: + + - Sütun üzerinde bir koşulu olan sorgular var `c`. + - Uzun veri aralıkları (birkaç kat daha uzun `index_granularity`) için aynı değer withlerle `(a, b)` yaygındır. Başka bir deyişle, başka bir sütun eklerken oldukça uzun veri aralıklarını atlamanıza izin verir. + +- Veri sıkıştırmasını geliştirin. + + ClickHouse verileri birincil anahtarla sıralar, bu nedenle tutarlılık ne kadar yüksek olursa sıkıştırma o kadar iyi olur. + +- Veri parçalarını birleştirirken ek mantık sağlayın [CollapsingMergeTree](collapsingmergetree.md#table_engine-collapsingmergetree) ve [SummingMergeTree](summingmergetree.md) motorlar. + + Bu durumda belirtmek mantıklı *sıralama anahtarı* bu birincil anahtardan farklıdır. + +Uzun bir birincil anahtar, ekleme performansını ve bellek tüketimini olumsuz yönde etkiler, ancak birincil anahtardaki ek sütunlar, ClickHouse performansını etkilemez `SELECT` sorgular. + +### Sıralama anahtarından farklı bir birincil anahtar seçme {#choosing-a-primary-key-that-differs-from-the-sorting-key} + +Sıralama anahtarından (veri bölümlerindeki satırları sıralamak için bir ifade) farklı bir birincil anahtar (her işaret için dizin dosyasında yazılan değerlere sahip bir ifade) belirtmek mümkündür. Bu durumda, birincil anahtar ifadesi tuple, sıralama anahtarı ifadesi tuple'ın bir öneki olmalıdır. + +Bu özellik kullanırken yararlıdır [SummingMergeTree](summingmergetree.md) ve +[AggregatingMergeTree](aggregatingmergetree.md) masa motorları. Bu motorları kullanırken yaygın bir durumda, tablonun iki tür sütunu vardır: *boyutlular* ve *ölçümler*. Tipik sorgular, rasgele ölçü sütunlarının değerlerini toplar `GROUP BY` ve boyutlara göre filtreleme. Çünkü SummingMergeTree ve AggregatingMergeTree sıralama anahtarının aynı değere sahip satırları toplamak, tüm boyutları eklemek doğaldır. Sonuç olarak, anahtar ifadesi uzun bir sütun listesinden oluşur ve bu liste yeni eklenen boyutlarla sık sık güncelleştirilmelidir. + +Bu durumda, birincil anahtarda verimli Aralık taramaları sağlayacak ve kalan boyut sütunlarını sıralama anahtarı kümesine ekleyecek yalnızca birkaç sütun bırakmak mantıklıdır. + +[ALTER](../../../sql_reference/statements/alter.md) yeni bir sütun aynı anda tabloya ve sıralama anahtarı eklendiğinde, varolan veri parçaları değiştirilmesi gerekmez, çünkü sıralama anahtarının hafif bir işlemdir. Eski sıralama anahtarı yeni sıralama anahtarının bir öneki olduğundan ve yeni eklenen sütunda veri olmadığından, veriler tablo değişikliği anında hem eski hem de yeni sıralama anahtarlarına göre sıralanır. + +### Sorgularda dizin ve bölümlerin kullanımı {#use-of-indexes-and-partitions-in-queries} + +İçin `SELECT` sorgular, ClickHouse bir dizin kullanılabilir olup olmadığını analiz eder. Eğer bir dizin kullanılabilir `WHERE/PREWHERE` yan tümce, bir eşitlik veya eşitsizlik karşılaştırma işlemini temsil eden bir ifadeye (bağlantı öğelerinden biri olarak veya tamamen) sahiptir veya varsa `IN` veya `LIKE` sütun veya birincil anahtar veya bölümleme anahtar veya bu sütunların belirli kısmen tekrarlayan işlevleri veya bu ifadelerin mantıksal ilişkileri olan ifadeler üzerinde sabit bir önek ile. + +Bu nedenle, birincil anahtarın bir veya daha fazla aralığındaki sorguları hızlı bir şekilde çalıştırmak mümkündür. Bu örnekte, belirli bir izleme etiketi, belirli bir etiket ve tarih aralığı, belirli bir etiket ve tarih için, tarih aralığına sahip birden çok etiket için vb. çalıştırıldığında sorgular hızlı olacaktır. + +Aşağıdaki gibi yapılandırılmış motora bakalım: + + ENGINE MergeTree() PARTITION BY toYYYYMM(EventDate) ORDER BY (CounterID, EventDate) SETTINGS index_granularity=8192 + +Bu durumda, sorgularda: + +``` sql +SELECT count() FROM table WHERE EventDate = toDate(now()) AND CounterID = 34 +SELECT count() FROM table WHERE EventDate = toDate(now()) AND (CounterID = 34 OR CounterID = 42) +SELECT count() FROM table WHERE ((EventDate >= toDate('2014-01-01') AND EventDate <= toDate('2014-01-31')) OR EventDate = toDate('2014-05-01')) AND CounterID IN (101500, 731962, 160656) AND (CounterID = 101500 OR EventDate != toDate('2014-05-01')) +``` + +ClickHouse, uygun olmayan verileri kırpmak için birincil anahtar dizinini ve uygun olmayan tarih aralıklarındaki bölümleri kırpmak için aylık bölümleme anahtarını kullanır. + +Yukarıdaki sorgular, dizinin karmaşık ifadeler için bile kullanıldığını göstermektedir. Tablodan okuma, dizini kullanarak tam taramadan daha yavaş olamayacak şekilde düzenlenmiştir. + +Aşağıdaki örnekte, dizin kullanılamaz. + +``` sql +SELECT count() FROM table WHERE CounterID = 34 OR URL LIKE '%upyachka%' +``` + +Clickhouse'un bir sorgu çalıştırırken dizini kullanıp kullanamayacağını kontrol etmek için ayarları kullanın [force\_index\_by\_date](../../../operations/settings/settings.md#settings-force_index_by_date) ve [force\_primary\_key](../../../operations/settings/settings.md). + +Aylara göre bölümleme anahtarı, yalnızca uygun aralıktaki tarihleri içeren veri bloklarını okumanıza izin verir. Bu durumda, veri bloğu birçok tarih için veri içerebilir (bir aya kadar). Bir blok içinde veriler, ilk sütun olarak tarihi içermeyen birincil anahtara göre sıralanır. Bu nedenle, birincil anahtar önekini belirtmeyen yalnızca bir tarih koşulu ile bir sorgu kullanarak tek bir tarih için okunacak daha fazla veri neden olur. + +### Kısmen monotonik birincil anahtarlar için Endeks kullanımı {#use-of-index-for-partially-monotonic-primary-keys} + +Örneğin, Ayın günlerini düşünün. Onlar formu bir [monotonik dizisi](https://en.wikipedia.org/wiki/Monotonic_function) bir ay boyunca, ancak daha uzun süreler için monotonik değil. Bu kısmen monotonik bir dizidir. Bir kullanıcı kısmen monoton birincil anahtar ile tablo oluşturursa, ClickHouse her zamanki gibi seyrek bir dizin oluşturur. Bir kullanıcı bu tür bir tablodan veri seçtiğinde, ClickHouse sorgu koşullarını analiz eder. Kullanıcı, dizinin iki işareti arasında veri almak isterse ve bu işaretlerin her ikisi de bir ay içinde düşerse, ClickHouse bu özel durumda dizini kullanabilir, çünkü sorgu parametreleri ile dizin işaretleri arasındaki mesafeyi hesaplayabilir. + +Sorgu parametresi aralığındaki birincil anahtarın değerleri monotonik bir sırayı temsil etmiyorsa, ClickHouse bir dizin kullanamaz. Bu durumda, ClickHouse Tam Tarama yöntemini kullanır. + +ClickHouse bu mantığı yalnızca ay dizilerinin günleri için değil, kısmen monotonik bir diziyi temsil eden herhangi bir birincil anahtar için kullanır. + +### Veri atlama indeksleri (deneysel) {#table_engine-mergetree-data_skipping-indexes} + +Dizin bildirimi sütunlar bölümünde `CREATE` sorgu. + +``` sql +INDEX index_name expr TYPE type(...) GRANULARITY granularity_value +``` + +Tablolar için `*MergeTree` aile, veri atlama endeksleri belirtilebilir. + +Bu endeksler, bloklarda belirtilen ifade hakkında bazı bilgileri toplar ve bunlardan oluşur `granularity_value` granüller (granül boyutu kullanılarak belirtilir `index_granularity` tablo motoru ayarı). Daha sonra bu agregalar `SELECT` büyük veri bloklarını atlayarak diskten okunacak veri miktarını azaltmak için sorgular `where` sorgu tatmin edilemez. + +**Örnek** + +``` sql +CREATE TABLE table_name +( + u64 UInt64, + i32 Int32, + s String, + ... + INDEX a (u64 * i32, s) TYPE minmax GRANULARITY 3, + INDEX b (u64 * length(s)) TYPE set(1000) GRANULARITY 4 +) ENGINE = MergeTree() +... +``` + +Örneğin endeksleri aşağıdaki sorgularda diskten okunacak veri miktarını azaltmak için ClickHouse tarafından kullanılabilir: + +``` sql +SELECT count() FROM table WHERE s < 'z' +SELECT count() FROM table WHERE u64 * i32 == 10 AND u64 * length(s) >= 1234 +``` + +#### Mevcut Endeks Türleri {#available-types-of-indices} + +- `minmax` + + Belirtilen ifad (eyi saklar (ifad (enin `tuple`, sonra her eleman için aşırı depolar `tuple`), birincil anahtar gibi veri bloklarını atlamak için saklanan bilgileri kullanır. + +- `set(max_rows)` + + Belirtilen ifadenin benzersiz değerlerini depolar (en fazla `max_rows` satırlar, `max_rows=0` anlama “no limits”). Kontrol etmek için değerleri kullanır `WHERE` ifade, bir veri bloğu üzerinde tatmin edilemez değildir. + +- `ngrambf_v1(n, size_of_bloom_filter_in_bytes, number_of_hash_functions, random_seed)` + + Mağazalar a [Blo filterom filtre](https://en.wikipedia.org/wiki/Bloom_filter) bu, bir veri bloğundaki tüm ngramları içerir. Sadece dizeleri ile çalışır. Optimizasyonu için kullanılabilir `equals`, `like` ve `in` ifadeler. + + - `n` — ngram size, + - `size_of_bloom_filter_in_bytes` — Bloom filter size in bytes (you can use large values here, for example, 256 or 512, because it can be compressed well). + - `number_of_hash_functions` — The number of hash functions used in the Bloom filter. + - `random_seed` — The seed for Bloom filter hash functions. + +- `tokenbf_v1(size_of_bloom_filter_in_bytes, number_of_hash_functions, random_seed)` + + Olarak aynı `ngrambf_v1`, ancak ngrams yerine simgeleri saklar. Belirteçler alfasayısal olmayan karakterlerle ayrılmış dizilerdir. + +- `bloom_filter([false_positive])` — Stores a [Blo filterom filtre](https://en.wikipedia.org/wiki/Bloom_filter) belirtilen sütunlar için. + + Opsiyonel `false_positive` parametre, filtreden yanlış pozitif yanıt alma olasılığıdır. Olası değerler: (0, 1). Varsayılan değer: 0.025. + + Desteklenen veri türleri: `Int*`, `UInt*`, `Float*`, `Enum`, `Date`, `DateTime`, `String`, `FixedString`, `Array`, `LowCardinality`, `Nullable`. + + Aşağıdaki işlevleri kullanabilirsiniz: [eşitlikler](../../../sql_reference/functions/comparison_functions.md), [notEquals](../../../sql_reference/functions/comparison_functions.md), [içinde](../../../sql_reference/functions/in_functions.md), [notİn](../../../sql_reference/functions/in_functions.md), [var](../../../sql_reference/functions/array_functions.md). + + + +``` sql +INDEX sample_index (u64 * length(s)) TYPE minmax GRANULARITY 4 +INDEX sample_index2 (u64 * length(str), i32 + f64 * 100, date, str) TYPE set(100) GRANULARITY 4 +INDEX sample_index3 (lower(str), str) TYPE ngrambf_v1(3, 256, 2, 0) GRANULARITY 4 +``` + +#### Fonksiyonları Destek {#functions-support} + +Koşulları `WHERE` yan tümcesi, sütunlarla çalışan işlevlerin çağrılarını içerir. Sütun bir dizinin bir parçasıysa, ClickHouse işlevleri gerçekleştirirken bu dizini kullanmaya çalışır. ClickHouse, dizinleri kullanmak için farklı işlev alt kümelerini destekler. + +Bu `set` dizin tüm fonksiyonları ile kullanılabilir. Diğer dizinler için işlev alt kümeleri aşağıdaki tabloda gösterilmiştir. + +| Fonksiyon (operatör) / dizin | birincil anahtar | minmax | ngrambf\_v1 | tokenbf\_v1 | bloom\_filter | +|------------------------------------------------------------------------------------------------------------|------------------|--------|-------------|-------------|---------------| +| [eşitlikler (=, ==)](../../../sql_reference/functions/comparison_functions.md#function-equals) | ✔ | ✔ | ✔ | ✔ | ✔ | +| [notEquals(!=, \<\>)](../../../sql_reference/functions/comparison_functions.md#function-notequals) | ✔ | ✔ | ✔ | ✔ | ✔ | +| [hoşlanmak](../../../sql_reference/functions/string_search_functions.md#function-like) | ✔ | ✔ | ✔ | ✗ | ✗ | +| [notLike](../../../sql_reference/functions/string_search_functions.md#function-notlike) | ✔ | ✔ | ✔ | ✗ | ✗ | +| [startsWith](../../../sql_reference/functions/string_functions.md#startswith) | ✔ | ✔ | ✔ | ✔ | ✗ | +| [endsWith](../../../sql_reference/functions/string_functions.md#endswith) | ✗ | ✗ | ✔ | ✔ | ✗ | +| [multiSearchAny](../../../sql_reference/functions/string_search_functions.md#function-multisearchany) | ✗ | ✗ | ✔ | ✗ | ✗ | +| [içinde](../../../sql_reference/functions/in_functions.md#in-functions) | ✔ | ✔ | ✔ | ✔ | ✔ | +| [notİn](../../../sql_reference/functions/in_functions.md#in-functions) | ✔ | ✔ | ✔ | ✔ | ✔ | +| [daha az (\<)](../../../sql_reference/functions/comparison_functions.md#function-less) | ✔ | ✔ | ✗ | ✗ | ✗ | +| [büyük (\>)](../../../sql_reference/functions/comparison_functions.md#function-greater) | ✔ | ✔ | ✗ | ✗ | ✗ | +| [lessOrEquals (\<=)](../../../sql_reference/functions/comparison_functions.md#function-lessorequals) | ✔ | ✔ | ✗ | ✗ | ✗ | +| [greaterOrEquals (\>=)](../../../sql_reference/functions/comparison_functions.md#function-greaterorequals) | ✔ | ✔ | ✗ | ✗ | ✗ | +| [boş](../../../sql_reference/functions/array_functions.md#function-empty) | ✔ | ✔ | ✗ | ✗ | ✗ | +| [notEmpty](../../../sql_reference/functions/array_functions.md#function-notempty) | ✔ | ✔ | ✗ | ✗ | ✗ | +| hasToken | ✗ | ✗ | ✗ | ✔ | ✗ | + +Ngram boyutundan daha az olan sabit bir argümana sahip işlevler tarafından kullanılamaz `ngrambf_v1` sorgu optimizasyonu için. + +Bloom filtreleri yanlış pozitif eşleşmelere sahip olabilir, bu yüzden `ngrambf_v1`, `tokenbf_v1`, ve `bloom_filter` dizinler, örneğin bir işlevin sonucunun false olması beklenen sorguları en iyi duruma getirmek için kullanılamaz: + +- Optimize edilebilir: + - `s LIKE '%test%'` + - `NOT s NOT LIKE '%test%'` + - `s = 1` + - `NOT s != 1` + - `startsWith(s, 'test')` +- Optimize edilemez: + - `NOT s LIKE '%test%'` + - `s NOT LIKE '%test%'` + - `NOT s = 1` + - `s != 1` + - `NOT startsWith(s, 'test')` + +## Eşzamanlı Veri Erişimi {#concurrent-data-access} + +Eşzamanlı tablo erişimi için çoklu sürüm kullanıyoruz. Başka bir deyişle, bir tablo aynı anda okunup güncelleştirildiğinde, sorgu sırasında geçerli olan bir parça kümesinden veri okunur. Uzun kilitler yok. Ekler okuma işlemlerinin yoluna girmez. + +Bir tablodan okuma otomatik olarak paralelleştirilir. + +## Sütunlar ve tablolar için TTL {#table_engine-mergetree-ttl} + +Değerlerin ömrünü belirler. + +Bu `TTL` yan tümcesi tüm tablo ve her sütun için ayarlanabilir. Tablo düzeyinde TTL ayrıca diskler ve birimler arasında otomatik veri taşıma mantığını belirtebilirsiniz. + +İfadeleri değerlendirmek gerekir [Tarihli](../../../sql_reference/data_types/date.md) veya [DateTime](../../../sql_reference/data_types/datetime.md) veri türü. + +Örnek: + +``` sql +TTL time_column +TTL time_column + interval +``` + +Tanımlamak `interval`, kullanma [zaman aralığı](../../../sql_reference/operators.md#operators-datetime) operatörler. + +``` sql +TTL date_time + INTERVAL 1 MONTH +TTL date_time + INTERVAL 15 HOUR +``` + +### Sütun TTL {#mergetree-column-ttl} + +Sütundaki değerler sona erdiğinde, ClickHouse bunları sütun veri türü için varsayılan değerlerle değiştirir. Veri bölümündeki tüm sütun değerleri sona ererse, ClickHouse bu sütunu bir dosya sistemindeki veri bölümünden siler. + +Bu `TTL` yan tümcesi anahtar sütunlar için kullanılamaz. + +Örnekler: + +TTL ile tablo oluşturma + +``` sql +CREATE TABLE example_table +( + d DateTime, + a Int TTL d + INTERVAL 1 MONTH, + b Int TTL d + INTERVAL 1 MONTH, + c String +) +ENGINE = MergeTree +PARTITION BY toYYYYMM(d) +ORDER BY d; +``` + +Varolan bir tablonun sütununa TTL ekleme + +``` sql +ALTER TABLE example_table + MODIFY COLUMN + c String TTL d + INTERVAL 1 DAY; +``` + +Sütun TTL değiştirme + +``` sql +ALTER TABLE example_table + MODIFY COLUMN + c String TTL d + INTERVAL 1 MONTH; +``` + +### Tablo TTL {#mergetree-table-ttl} + +Tablo, süresi dolmuş satırların kaldırılması için bir ifadeye ve parçaların arasında otomatik olarak taşınması için birden fazla ifadeye sahip olabilir [diskler veya birimler](#table_engine-mergetree-multiple-volumes). Tablodaki satırların süresi dolduğunda, ClickHouse ilgili tüm satırları siler. Parça taşıma özelliği için, bir parçanın tüm satırları hareket ifadesi ölçütlerini karşılaması gerekir. + +``` sql +TTL expr [DELETE|TO DISK 'aaa'|TO VOLUME 'bbb'], ... +``` + +TTL kuralı türü her TTL ifadesini takip edebilir. İfade tatmin edildikten sonra yapılacak bir eylemi etkiler (şimdiki zamana ulaşır): + +- `DELETE` - süresi dolmuş satırları sil (varsayılan eylem); +- `TO DISK 'aaa'` - parçayı diske taşı `aaa`; +- `TO VOLUME 'bbb'` - parçayı diske taşı `bbb`. + +Örnekler: + +TTL ile tablo oluşturma + +``` sql +CREATE TABLE example_table +( + d DateTime, + a Int +) +ENGINE = MergeTree +PARTITION BY toYYYYMM(d) +ORDER BY d +TTL d + INTERVAL 1 MONTH [DELETE], + d + INTERVAL 1 WEEK TO VOLUME 'aaa', + d + INTERVAL 2 WEEK TO DISK 'bbb'; +``` + +Tablonun TTL değiştirme + +``` sql +ALTER TABLE example_table + MODIFY TTL d + INTERVAL 1 DAY; +``` + +**Verileri Kaldırma** + +ClickHouse veri parçalarını birleştirdiğinde süresi dolmuş bir TTL ile veri kaldırılır. + +ClickHouse, verilerin süresi dolduğunu gördüğünde, zamanlama dışı bir birleştirme gerçekleştirir. Bu tür birleştirmelerin sıklığını kontrol etmek için şunları ayarlayabilirsiniz [merge\_with\_ttl\_timeout](#mergetree_setting-merge_with_ttl_timeout). Değer çok düşükse, çok fazla kaynak tüketebilecek birçok zamanlama dışı birleştirme gerçekleştirir. + +Gerçekleştir theirseniz `SELECT` birleştirme arasında sorgu, süresi dolmuş veri alabilirsiniz. Bunu önlemek için, [OPTIMIZE](../../../sql_reference/statements/misc.md#misc_operations-optimize) önce sorgu `SELECT`. + +## Veri Depolama İçin Birden Fazla Blok Cihazı Kullanma {#table_engine-mergetree-multiple-volumes} + +### Giriş {#introduction} + +`MergeTree` aile tablo motorları birden fazla blok cihazlarda veri saklayabilirsiniz. Örneğin, belirli bir tablonun verileri örtük olarak bölündüğünde yararlı olabilir “hot” ve “cold”. En son veriler düzenli olarak talep edilir, ancak yalnızca az miktarda alan gerektirir. Aksine, yağ kuyruklu tarihsel veriler nadiren talep edilir. Birkaç disk varsa, “hot” veriler hızlı disklerde (örneğin, NVMe SSD'ler veya bellekte) bulunabilir; “cold” veri-nispeten yavaş olanlar (örneğin, HDD). + +Veri kısmı için minimum hareketli birimdir `MergeTree`- motor masaları. Bir parçaya ait veriler bir diskte saklanır. Veri parçaları arka planda diskler arasında (kullanıcı ayarlarına göre) ve aynı zamanda [ALTER](../../../sql_reference/statements/alter.md#alter_move-partition) sorgular. + +### Şartlar {#terms} + +- Disk — Block device mounted to the filesystem. +- Default disk — Disk that stores the path specified in the [yol](../../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-path) sunucu ayarı. +- Volume — Ordered set of equal disks (similar to [JBOD](https://en.wikipedia.org/wiki/Non-RAID_drive_architectures)). +- Storage policy — Set of volumes and the rules for moving data between them. + +Açıklanan varlıklara verilen isimler sistem tablolarında bulunabilir, [sistem.storage\_policies](../../../operations/system_tables.md#system_tables-storage_policies) ve [sistem.diskler](../../../operations/system_tables.md#system_tables-disks). Bir tablo için yapılandırılmış depolama ilkelerinden birini uygulamak için `storage_policy` ayarı `MergeTree`- motor aile tabloları. + +### Yapılandırma {#table_engine-mergetree-multiple-volumes-configure} + +Diskler, birimler ve depolama politikaları içinde bildirilmelidir `` ana dosyada ya etiket `config.xml` veya farklı bir dosyada `config.d` dizin. + +Yapılandırma yapısı: + +``` xml + + + + /mnt/fast_ssd/clickhouse + + + /mnt/hdd1/clickhouse + 10485760 + + + /mnt/hdd2/clickhouse + 10485760 + + + ... + + + ... + +``` + +Etiketler: + +- `` — Disk name. Names must be different for all disks. +- `path` — path under which a server will store data (`data` ve `shadow` klasörler) ile Sonlandır shouldılmalıdır ‘/’. +- `keep_free_space_bytes` — the amount of free disk space to be reserved. + +Disk tanımının sırası önemli değildir. + +Depolama ilkeleri yapılandırma biçimlendirme: + +``` xml + + ... + + + + + disk_name_from_disks_configuration + 1073741824 + + + + + + + 0.2 + + + + + + + + ... + +``` + +Etiketler: + +- `policy_name_N` — Policy name. Policy names must be unique. +- `volume_name_N` — Volume name. Volume names must be unique. +- `disk` — a disk within a volume. +- `max_data_part_size_bytes` — the maximum size of a part that can be stored on any of the volume's disks. +- `move_factor` — when the amount of available space gets lower than this factor, data automatically start to move on the next volume if any (by default, 0.1). + +Cofiguration örnekleri: + +``` xml + + ... + + + + + disk1 + disk2 + + + + + + + + fast_ssd + 1073741824 + + + disk1 + + + 0.2 + + + ... + +``` + +Verilen örnekte, `hdd_in_order` politika uygular [Ro -und-robin](https://en.wikipedia.org/wiki/Round-robin_scheduling) yaklaşma. Böylece bu politika yalnızca bir birim tanımlar (`single`), veri parçaları tüm disklerinde dairesel sırayla saklanır. Bu tür bir politika, sisteme birkaç benzer disk takılıysa, ancak RAID yapılandırılmamışsa oldukça yararlı olabilir. Her bir disk sürücüsünün güvenilir olmadığını ve bunu 3 veya daha fazla çoğaltma faktörü ile telafi etmek isteyebileceğinizi unutmayın. + +Sistemde farklı türde diskler varsa, `moving_from_ssd_to_hdd` politika yerine kullanılabilir. Birim `hot` bir SSD disk oluşur (`fast_ssd`) ve bu birimde saklanabilecek bir parçanın maksimum boyutu 1GB. Tüm parçaları ile boyutu daha büyük 1 GB üzerinde doğrudan saklanır `cold` bir HDD diski içeren birim `disk1`. +Ayrıca, bir kez disk `fast_ssd` 80'den fazla % tarafından doldurulur, veri transfer edilecektir `disk1` bir arka plan işlemi ile. + +Depolama ilkesi içindeki birim numaralandırma sırası önemlidir. Bir birim aşırı doldurulduktan sonra, veriler bir sonrakine taşınır. Disk numaralandırma sırası da önemlidir, çünkü veriler sırayla depolanır. + +Bir tablo oluştururken, yapılandırılmış depolama ilkelerinden birini ona uygulayabilirsiniz: + +``` sql +CREATE TABLE table_with_non_default_policy ( + EventDate Date, + OrderID UInt64, + BannerID UInt64, + SearchPhrase String +) ENGINE = MergeTree +ORDER BY (OrderID, BannerID) +PARTITION BY toYYYYMM(EventDate) +SETTINGS storage_policy = 'moving_from_ssd_to_hdd' +``` + +Bu `default` depolama ilkesi, Yalnızca verilen bir diskten oluşan yalnızca bir birim kullanmayı ima eder ``. Bir tablo oluşturulduktan sonra, depolama ilkesi değiştirilemez. + +### Ayrıntı {#details} + +Bu durumda `MergeTree` tablolar, veriler diske farklı şekillerde giriyor: + +- Bir ekleme sonucunda (`INSERT` sorgu). +- Arka plan birleştirmeleri sırasında ve [mutasyonlar](../../../sql_reference/statements/alter.md#alter-mutations). +- Başka bir kopyadan indirirken. +- Bölüm Don ofması sonucu [ALTER TABLE … FREEZE PARTITION](../../../sql_reference/statements/alter.md#alter_freeze-partition). + +Mutasyonlar ve bölüm dondurma hariç tüm bu durumlarda, bir parça verilen depolama politikasına göre bir birim ve bir diskte saklanır: + +1. Bir parçayı depolamak için yeterli disk alanına sahip olan ilk birim (tanım sırasına göre) (`unreserved_space > current_part_size`) ve belirli bir boyuttaki parçaların saklanmasına izin verir (`max_data_part_size_bytes > current_part_size`) seçilir. +2. Bu birimde, önceki veri yığınını depolamak için kullanılan ve parça boyutundan daha fazla boş alana sahip olan diski izleyen disk seçilir (`unreserved_space - keep_free_space_bytes > current_part_size`). + +Kap hoodut underun altında, [sabit linkler](https://en.wikipedia.org/wiki/Hard_link). Farklı diskler arasındaki sabit bağlantılar desteklenmez, bu nedenle bu gibi durumlarda ortaya çıkan parçalar ilk disklerle aynı disklerde saklanır. + +Arka planda, parçalar boş alan miktarına göre hacimler arasında taşınır (`move_factor` parametre) sırasına göre birimler yapılandırma dosyasında beyan edilir. +Veriler asla sonuncudan ve birincisine aktarılmaz. Bir sistem tabloları kullanabilirsiniz [sistem.part\_log](../../../operations/system_tables.md#system_tables-part-log) (alan `type = MOVE_PART`) ve [sistem.parçalar](../../../operations/system_tables.md#system_tables-parts) (alanlar `path` ve `disk`) arka plan hareketlerini izlemek için. Ayrıca, ayrıntılı bilgi sunucu günlüklerinde bulunabilir. + +Kullanıcı, sorguyu kullanarak bir bölümü veya bölümü bir birimden diğerine taşımaya zorlayabilir [ALTER TABLE … MOVE PART\|PARTITION … TO VOLUME\|DISK …](../../../sql_reference/statements/alter.md#alter_move-partition), arka plan işlemleri için tüm kısıtlamalar dikkate alınır. Sorgu, kendi başına bir hareket başlatır ve tamamlanması için arka plan işlemleri beklemez. Yeterli boş alan yoksa veya gerekli koşullardan herhangi biri karşılanmazsa kullanıcı bir hata mesajı alır. + +Veri taşıma veri çoğaltma ile müdahale etmez. Bu nedenle, farklı depolama ilkeleri aynı tablo için farklı yinelemeler üzerinde belirtilebilir. + +Arka plan birleşimlerinin ve mutasyonlarının tamamlanmasından sonra, eski parçalar yalnızca belirli bir süre sonra çıkarılır (`old_parts_lifetime`). +Bu süre zarfında, diğer birimlere veya disklere taşınmazlar. Bu nedenle, parçalar nihayet çıkarılıncaya kadar, işgal edilen disk alanının değerlendirilmesi için hala dikkate alınır. + +[Orijinal makale](https://clickhouse.tech/docs/ru/operations/table_engines/mergetree/) diff --git a/docs/tr/engines/table_engines/mergetree_family/replacingmergetree.md b/docs/tr/engines/table_engines/mergetree_family/replacingmergetree.md new file mode 100644 index 00000000000..baf2fc98b07 --- /dev/null +++ b/docs/tr/engines/table_engines/mergetree_family/replacingmergetree.md @@ -0,0 +1,69 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 33 +toc_title: ReplacingMergeTree +--- + +# ReplacingMergeTree {#replacingmergetree} + +Motor farklıdır [MergeTree](mergetree.md#table_engines-mergetree) aynı birincil anahtar değerine sahip yinelenen girdileri kaldırır (veya daha doğru bir şekilde, aynı [sıralama anahtarı](mergetree.md) değer). + +Veri tekilleştirme yalnızca birleştirme sırasında oluşur. Birleştirme, arka planda bilinmeyen bir zamanda gerçekleşir, bu nedenle bunu planlayamazsınız. Bazı veriler işlenmemiş kalabilir. Kullanarak programsız bir birleştirme çalıştırabilirsiniz, ancak `OPTIMIZE` sorgu, kullanmaya güvenmeyin, çünkü `OPTIMIZE` sorgu büyük miktarda veri okuyacak ve yazacaktır. + +Böyle, `ReplacingMergeTree` yerden tasarruf etmek için arka planda yinelenen verileri temizlemek için uygundur, ancak kopyaların yokluğunu garanti etmez. + +## Tablo oluşturma {#creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE = ReplacingMergeTree([ver]) +[PARTITION BY expr] +[ORDER BY expr] +[PRIMARY KEY expr] +[SAMPLE BY expr] +[SETTINGS name=value, ...] +``` + +İstek parametrelerinin açıklaması için bkz. [istek açıklaması](../../../sql_reference/statements/create.md). + +**ReplacingMergeTree Parametreleri** + +- `ver` — column with version. Type `UInt*`, `Date` veya `DateTime`. İsteğe bağlı parametre. + + Birleş whenirken, `ReplacingMergeTree` aynı birincil anahtara sahip tüm satırlardan sadece bir tane bırakır: + + - Seç inimde son, eğer `ver` set değil. + - Maksimum sürümü ile, eğer `ver` belirtilen. + +**Sorgu yan tümceleri** + +Oluştururken bir `ReplacingMergeTree` tablo aynı [yanlar](mergetree.md) oluşturul ,urken olduğu gibi gerekli `MergeTree` Tablo. + +
+ +Bir tablo oluşturmak için kullanımdan kaldırılan yöntem + +!!! attention "Dikkat" + Bu yöntemi yeni projelerde kullanmayın ve mümkünse eski projeleri yukarıda açıklanan yönteme geçin. + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE [=] ReplacingMergeTree(date-column [, sampling_expression], (primary, key), index_granularity, [ver]) +``` + +Hariç tüm parametreler `ver` içinde olduğu gibi aynı anlama sahip `MergeTree`. + +- `ver` - sürümü ile sütun. İsteğe bağlı parametre. Bir açıklama için yukarıdaki metne bakın. + +
+ +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/replacingmergetree/) diff --git a/docs/tr/engines/table_engines/mergetree_family/replication.md b/docs/tr/engines/table_engines/mergetree_family/replication.md new file mode 100644 index 00000000000..e9890c2652f --- /dev/null +++ b/docs/tr/engines/table_engines/mergetree_family/replication.md @@ -0,0 +1,218 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 31 +toc_title: "Veri \xC7o\u011Faltma" +--- + +# Veri Çoğaltma {#table_engines-replication} + +Çoğaltma yalnızca mergetree ailesindeki tablolar için desteklenir: + +- ReplicatedMergeTree +- ReplicatedSummingMergeTree +- ReplicatedReplacingMergeTree +- ReplicatedAggregatingMergeTree +- ReplicatedCollapsingMergeTree +- ReplicatedVersionedCollapsingMergetree +- ReplicatedGraphiteMergeTree + +Çoğaltma, tüm sunucu değil, tek bir tablo düzeyinde çalışır. Bir sunucu hem çoğaltılmış hem de çoğaltılmamış tabloları aynı anda depolayabilir. + +Çoğaltma, parçaya bağlı değildir. Her parçanın kendi bağımsız çoğaltması vardır. + +İçin sıkıştırılmış veri `INSERT` ve `ALTER` sorgular çoğaltılır (daha fazla bilgi için bkz. [ALTER](../../../sql_reference/statements/alter.md#query_language_queries_alter)). + +`CREATE`, `DROP`, `ATTACH`, `DETACH` ve `RENAME` sorgular tek bir sunucuda yürütülür ve çoğaltılmaz: + +- Bu `CREATE TABLE` sorgu sorgu çalıştırıldığı sunucuda yeni bir replicatable tablo oluşturur. Bu tablo diğer sunucularda zaten varsa, yeni bir yineleme ekler. +- Bu `DROP TABLE` sorgu, sorgunun çalıştırıldığı sunucuda bulunan yinelemeyi siler. +- Bu `RENAME` sorgu yinelemeler birinde tabloyu yeniden adlandırır. Başka bir deyişle, çoğaltılmış tablolar farklı yinelemeler üzerinde farklı adlara sahip olabilir. + +ClickHouse kullanır [Apache ZooKeeper](https://zookeeper.apache.org) kopyaları meta bilgilerini saklamak için. ZooKeeper sürüm 3.4.5 veya daha yeni kullanın. + +Çoğaltma kullanmak için, parametreleri [zookeeper](../../../operations/server_configuration_parameters/settings.md#server-settings_zookeeper) sunucu yapılandırma bölümü. + +!!! attention "Dikkat" + Güvenlik ayarını ihmal etmeyin. ClickHouse destekler `digest` [ACLL şeması](https://zookeeper.apache.org/doc/current/zookeeperProgrammers.html#sc_ZooKeeperAccessControl) ZooKeeper Güvenlik alt sisteminin. + +ZooKeeper kümesinin adreslerini ayarlama örneği: + +``` xml + + + example1 + 2181 + + + example2 + 2181 + + + example3 + 2181 + + +``` + +Varolan herhangi bir ZooKeeper kümesini belirtebilirsiniz ve sistem kendi verileri için bir dizin kullanır (replicatable tablo oluştururken dizin belirtilir). + +Zookeeper yapılandırma dosyasında ayarlanmamışsa, çoğaltılmış tablolar oluşturamazsınız ve varolan çoğaltılmış tablolar salt okunur olacaktır. + +ZooKeeper kullanılmaz `SELECT` çoğaltma performansını etkilemez çünkü sorgular `SELECT` ve sorgular, çoğaltılmamış tablolar için yaptıkları kadar hızlı çalışır. Dağıtılmış çoğaltılmış tabloları sorgularken, ClickHouse davranışı ayarlar tarafından denetlenir [max\_replica\_delay\_for\_distributed\_queries](../../../operations/settings/settings.md#settings-max_replica_delay_for_distributed_queries) ve [fallback\_to\_stale\_replicas\_for\_distributed\_queries](../../../operations/settings/settings.md#settings-fallback_to_stale_replicas_for_distributed_queries). + +Her biri için `INSERT` sorgu, yaklaşık on girişleri zookeeper birkaç işlemler aracılığıyla eklenir. (Daha kesin olmak gerekirse, bu eklenen her veri bloğu içindir; bir ekleme sorgusu her bir blok veya bir blok içerir `max_insert_block_size = 1048576` satırlar.) Bu, biraz daha uzun gecikmelere yol açar `INSERT` çoğaltılmamış tablolarla karşılaştırıldığında. Ancak, birden fazla olmayan gruplar halinde veri eklemek için önerileri izlerseniz `INSERT` saniyede, herhangi bir sorun yaratmaz. Bir ZooKeeper kümesini koordine etmek için kullanılan tüm ClickHouse kümesinin toplam birkaç yüzü vardır `INSERTs` saniyede. Veri eklerindeki verim (saniyede satır sayısı), çoğaltılmamış veriler için olduğu kadar yüksektir. + +Çok büyük kümeler için, farklı kırıklar için farklı ZooKeeper kümelerini kullanabilirsiniz. Ancak, bu Yandex'de gerekli değildir.Metrica küme (yaklaşık 300 sunucu). + +Çoğaltma zaman uyumsuz ve çok ana. `INSERT` sorgular (yanı sıra `ALTER`) mevcut herhangi bir sunucuya gönderilebilir. Veri sorgu çalıştırıldığı sunucuda eklenir ve sonra diğer sunuculara kopyalanır. Zaman uyumsuz olduğundan, son eklenen veriler bazı gecikme ile diğer yinelemeler görünür. Yinelemelerin bir kısmı mevcut değilse, veriler kullanılabilir olduklarında yazılır. Bir çoğaltma varsa, gecikme, sıkıştırılmış veri bloğunu ağ üzerinden aktarmak için gereken süredir. + +Varsayılan olarak, bir INSERT sorgusu yalnızca bir yinelemeden veri yazma onayı bekler. Verileri başarıyla yalnızca bir yineleme için yazılmıştır ve bu yineleme ile sunucu varolmaya sona erer, depolanan veriler kaybolur. Birden çok yinelemeden veri yazma onayını almayı etkinleştirmek için `insert_quorum` seçenek. + +Her veri bloğu atomik olarak yazılır. Ekle sorgusu kadar bloklara ayrılmıştır `max_insert_block_size = 1048576` satırlar. Diğer bir deyişle, `INSERT` sorgu 1048576 satırdan daha az, atomik olarak yapılır. + +Veri blokları tekilleştirilmiştir. Aynı veri bloğunun (aynı sırayla aynı satırları içeren aynı boyuttaki veri blokları) birden fazla yazımı için, blok yalnızca bir kez yazılır. Bunun nedeni, istemci uygulaması verilerin DB'YE yazılıp yazılmadığını bilmediğinde ağ arızaları durumunda, `INSERT` sorgu sadece tekrar edilebilir. Hangi çoğaltma eklerinin aynı verilerle gönderildiği önemli değildir. `INSERTs` idempotent vardır. Tekilleştirme parametreleri tarafından kontrol edilir [merge\_tree](../../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-merge_tree) sunucu ayarları. + +Çoğaltma sırasında, yalnızca eklenecek kaynak veriler ağ üzerinden aktarılır. Daha fazla veri dönüşümü (birleştirme), tüm kopyalarda aynı şekilde koordine edilir ve gerçekleştirilir. Bu, ağ kullanımını en aza indirir; bu, çoğaltmaların farklı veri merkezlerinde bulunduğu zaman çoğaltmanın iyi çalıştığı anlamına gelir. (Farklı veri merkezlerinde çoğaltmanın çoğaltmanın ana hedefi olduğunu unutmayın .) + +Aynı verilerin çoğaltmaları herhangi bir sayıda olabilir. Üye.Metrica üretimde çift çoğaltma kullanır. Her sunucu, bazı durumlarda RAID-5 veya RAID-6 ve RAID-10 kullanır. Bu nispeten güvenilir ve kullanışlı bir çözümdür. + +Sistem, yinelemelerdeki veri senkronizasyonunu izler ve bir hatadan sonra kurtarabilir. Yük devretme otomatik (verilerde küçük farklılıklar için) veya yarı otomatik (veriler çok fazla farklılık gösterdiğinde, bu da bir yapılandırma hatasını gösterebilir). + +## Çoğaltılmış Tablolar Oluşturma {#creating-replicated-tables} + +Bu `Replicated` önek tablo motoru adına eklenir. Mesela:`ReplicatedMergeTree`. + +**Çoğaltılan \* MergeTree parametreleri** + +- `zoo_path` — The path to the table in ZooKeeper. +- `replica_name` — The replica name in ZooKeeper. + +Örnek: + +``` sql +CREATE TABLE table_name +( + EventDate DateTime, + CounterID UInt32, + UserID UInt32 +) ENGINE = ReplicatedMergeTree('/clickhouse/tables/{layer}-{shard}/table_name', '{replica}') +PARTITION BY toYYYYMM(EventDate) +ORDER BY (CounterID, EventDate, intHash32(UserID)) +SAMPLE BY intHash32(UserID) +``` + +
+ +Kullanımdan kaldırılmış sözdizimi örneği + +``` sql +CREATE TABLE table_name +( + EventDate DateTime, + CounterID UInt32, + UserID UInt32 +) ENGINE = ReplicatedMergeTree('/clickhouse/tables/{layer}-{shard}/table_name', '{replica}', EventDate, intHash32(UserID), (CounterID, EventDate, intHash32(UserID), EventTime), 8192) +``` + +
+ +Örnekte gösterildiği gibi, bu parametreler kıvırcık köşeli ayraçlarda ikameler içerebilir. İkame edilen değerler ‘macros’ yapılandırma dosyasının bölümü. Örnek: + +``` xml + + 05 + 02 + example05-02-1.yandex.ru + +``` + +Zookeeper tablonun yolunu her çoğaltılmış tablo için benzersiz olmalıdır. Farklı parçalardaki tabloların farklı yolları olmalıdır. +Bu durumda, yol aşağıdaki parçalardan oluşur: + +`/clickhouse/tables/` ortak önek. Tam olarak bunu kullanmanızı öneririz. + +`{layer}-{shard}` shard tanımlayıcısıdır. Bu örnekte Yandex'den beri iki bölümden oluşmaktadır.Metrica küme iki seviyeli sharding kullanır. Çoğu görev için, yalnızca shard tanımlayıcısına genişletilecek olan {shard} ikamesini bırakabilirsiniz. + +`table_name` ZooKeeper tablo için düğüm adıdır. Tablo adı ile aynı yapmak için iyi bir fikirdir. Açıkça tanımlanır, çünkü tablo adının aksine, bir yeniden adlandırma sorgusundan sonra değişmez. +*HINT*: önüne bir veritabanı adı ekleyebilirsiniz `table_name` yanında. E. g. `db_name.table_name` + +Çoğaltma adı, aynı tablonun farklı yinelemelerini tanımlar. Örnekte olduğu gibi bunun için sunucu adını kullanabilirsiniz. Adın sadece her parça içinde benzersiz olması gerekir. + +Değiştirmeleri kullanmak yerine parametreleri açıkça tanımlayabilirsiniz. Bu, test etmek ve küçük kümeleri yapılandırmak için uygun olabilir. Ancak, dağıtılmış DDL sorguları kullanamazsınız (`ON CLUSTER` bu durumda). + +Büyük kümelerle çalışırken, hata olasılığını azalttıkları için değiştirmeleri kullanmanızı öneririz. + +Run the `CREATE TABLE` her yineleme üzerinde sorgu. Bu sorgu, yeni bir çoğaltılmış tablo oluşturur veya varolan bir yeni bir yineleme ekler. + +Tablo zaten diğer yinelemeler üzerinde bazı veriler içerdikten sonra yeni bir yineleme eklerseniz, verileri diğer yinelemeler için yeni bir sorgu çalıştırdıktan sonra kopyalanır. Başka bir deyişle, yeni çoğaltma kendisini diğerleriyle eşitler. + +Bir yineleme silmek için çalıştırın `DROP TABLE`. However, only one replica is deleted – the one that resides on the server where you run the query. + +## Arızalardan Sonra Kurtarma {#recovery-after-failures} + +Bir sunucu başlatıldığında ZooKeeper kullanılamıyorsa, çoğaltılmış tablolar salt okunur moda geçer. Sistem periyodik olarak ZooKeeper bağlanmaya çalışır. + +ZooKeeper sırasında kullanılamıyorsa bir `INSERT`, veya ZooKeeper ile etkileşimde bulunurken bir hata oluşur, bir istisna atılır. + +ZooKeeper bağlandıktan sonra, sistem yerel dosya sistemindeki veri kümesinin beklenen veri kümesiyle eşleşip eşleşmediğini kontrol eder (ZooKeeper bu bilgileri saklar). Küçük tutarsızlıklar varsa, sistem verileri kopyalarla senkronize ederek bunları çözer. + +Sistem bozuk veri parçalarını (yanlış dosya boyutu ile) veya tanınmayan parçaları (dosya sistemine yazılmış ancak Zookeeper'da kaydedilmemiş parçalar) tespit ederse, bunları `detached` alt dizin (silinmez). Eksik parçalar kopyalardan kopyalanır. + +Clickhouse'un büyük miktarda veriyi otomatik olarak silme gibi yıkıcı eylemler gerçekleştirmediğini unutmayın. + +Sunucu başlatıldığında (veya ZooKeeper ile yeni bir oturum kurduğunda), yalnızca tüm dosyaların miktarını ve boyutlarını kontrol eder. Dosya boyutları eşleşirse, ancak bayt ortasında bir yerde değiştirilmişse, bu hemen algılanmaz, ancak yalnızca bir dosya için verileri okumaya çalışırken algılanmaz. `SELECT` sorgu. Sorgu, eşleşen olmayan bir sağlama toplamı veya sıkıştırılmış bir bloğun boyutu hakkında bir özel durum atar. Bu durumda, veri parçaları doğrulama kuyruğuna eklenir ve gerekirse kopyalardan kopyalanır. + +Yerel veri kümesi beklenenden çok fazla farklıysa, bir güvenlik mekanizması tetiklenir. Sunucu bunu günlüğe girer ve başlatmayı reddeder. Bunun nedeni, bu durumda, bir parçadaki bir kopya yanlışlıkla farklı bir parçadaki bir kopya gibi yapılandırılmışsa gibi bir yapılandırma hatası gösterebilir. Ancak, bu mekanizma için eşikleri oldukça düşük ayarlanır ve bu durum normal hata kurtarma sırasında ortaya çıkabilir. Bu durumda, veriler yarı otomatik olarak geri yüklenir “pushing a button”. + +Kurtarma işlemini başlatmak için düğümü oluşturun `/path_to_table/replica_name/flags/force_restore_data` herhangi bir içerik ile ZooKeeper veya tüm çoğaltılmış tabloları geri yüklemek için komutu çalıştırın: + +``` bash +sudo -u clickhouse touch /var/lib/clickhouse/flags/force_restore_data +``` + +Sunucuyu yeniden başlatın. Başlangıçta, sunucu bu bayrakları siler ve kurtarma işlemini başlatır. + +## Tam Veri Kaybından Sonra Kurtarma {#recovery-after-complete-data-loss} + +Tüm veriler ve meta veriler sunuculardan birinden kaybolduysa, kurtarma için şu adımları izleyin: + +1. Clickhouse'u sunucuya yükleyin. Bunları kullanırsanız, shard tanımlayıcısı ve yinelemeleri içeren yapılandırma dosyasında doğru değiştirmelerin tanımlayın. +2. Sunucularda el ile çoğaltılması gereken yinelenmemiş tablolar varsa, verilerini bir kopyadan kopyalayın (dizinde `/var/lib/clickhouse/data/db_name/table_name/`). +3. Bulunan tablo tanım copylarını kopyala `/var/lib/clickhouse/metadata/` bir kopyadan. Tablo tanımlarında bir parça veya çoğaltma tanımlayıcısı açıkça tanımlanmışsa, bu kopyaya karşılık gelecek şekilde düzeltin. (Alternatif olarak, sunucuyu başlatın ve tüm `ATTACH TABLE` içinde olması gereken sorgular .sql dosyaları `/var/lib/clickhouse/metadata/`.) +4. Kurtarma işlemini başlatmak için ZooKeeper düğümünü oluşturun `/path_to_table/replica_name/flags/force_restore_data` herhangi bir içerikle veya tüm çoğaltılmış tabloları geri yüklemek için komutu çalıştırın: `sudo -u clickhouse touch /var/lib/clickhouse/flags/force_restore_data` + +Ardından sunucuyu başlatın (zaten çalışıyorsa yeniden başlatın). Veriler kopyalardan indirilecektir. + +Alternatif bir kurtarma seçeneği zookeeper kayıp yineleme hakkında bilgi silmektir (`/path_to_table/replica_name`), daha sonra açıklandığı gibi yinelemeyi tekrar oluşturun “[Çoğaltılmış tablolar oluşturma](#creating-replicated-tables)”. + +Kurtarma sırasında ağ bant genişliği üzerinde herhangi bir kısıtlama yoktur. Aynı anda birçok yinelemeyi geri yüklüyorsanız bunu aklınızda bulundurun. + +## Mergetree'den Replicatedmergetree'ye Dönüştürme {#converting-from-mergetree-to-replicatedmergetree} + +Terimi kullanıyoruz `MergeTree` tüm tablo motorlarına başvurmak için `MergeTree family` için aynı `ReplicatedMergeTree`. + +Eğer olsaydı bir `MergeTree` el ile çoğaltılmış tablo, çoğaltılmış bir tabloya dönüştürebilirsiniz. Zaten büyük miktarda veri topladıysanız bunu yapmanız gerekebilir. `MergeTree` tablo ve şimdi çoğaltmayı etkinleştirmek istiyorsunuz. + +Veriler çeşitli yinelemelerde farklılık gösteriyorsa, önce onu eşitleyin veya bu verileri biri dışındaki tüm yinelemelerde silin. + +Varolan MergeTree tablosunu yeniden adlandırın, sonra bir `ReplicatedMergeTree` eski adı olan tablo. +Eski tablodan veri taşıma `detached` yeni tablo verileri ile dizin içindeki alt dizin (`/var/lib/clickhouse/data/db_name/table_name/`). +Sonra koş `ALTER TABLE ATTACH PARTITION` bu veri parçalarını çalışma kümesine eklemek için yinelemelerden birinde. + +## Replicatedmergetree'den Mergetree'ye Dönüştürme {#converting-from-replicatedmergetree-to-mergetree} + +Farklı bir adla bir MergeTree tablosu oluşturun. İle dizinden tüm verileri taşıyın `ReplicatedMergeTree` yeni tablonun veri dizinine tablo verileri. Sonra Sil `ReplicatedMergeTree` tablo ve sunucuyu yeniden başlatın. + +Eğer bir kurtulmak istiyorsanız `ReplicatedMergeTree` sunucu başlatmadan tablo: + +- İlgili sil `.sql` meta veri dizinindeki dosya (`/var/lib/clickhouse/metadata/`). +- ZooKeeper ilgili yolu silin (`/path_to_table/replica_name`). + +Bundan sonra, sunucuyu başlatabilir, bir `MergeTree` tablo, verileri kendi dizinine taşıyın ve sonra sunucuyu yeniden başlatın. + +## Zookeeper kümesindeki meta veriler kaybolduğunda veya zarar gördüğünde kurtarma {#recovery-when-metadata-in-the-zookeeper-cluster-is-lost-or-damaged} + +ZooKeeper içindeki veriler kaybolduysa veya hasar gördüyse, verileri yukarıda açıklandığı gibi yinelenmemiş bir tabloya taşıyarak kaydedebilirsiniz. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/replication/) diff --git a/docs/tr/engines/table_engines/mergetree_family/summingmergetree.md b/docs/tr/engines/table_engines/mergetree_family/summingmergetree.md new file mode 100644 index 00000000000..15a58064ab4 --- /dev/null +++ b/docs/tr/engines/table_engines/mergetree_family/summingmergetree.md @@ -0,0 +1,141 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 34 +toc_title: SummingMergeTree +--- + +# SummingMergeTree {#summingmergetree} + +Motor devralır [MergeTree](mergetree.md#table_engines-mergetree). Fark, veri parçalarını birleştirirken `SummingMergeTree` tablolar ClickHouse tüm satırları aynı birincil anahtarla değiştirir (veya daha doğru olarak, aynı [sıralama anahtarı](mergetree.md)) sayısal veri türüne sahip sütunlar için özetlenen değerleri içeren bir satır ile. Sıralama anahtarı, tek bir anahtar değeri çok sayıda satıra karşılık gelecek şekilde oluşturulursa, bu, depolama birimini önemli ölçüde azaltır ve veri seçimini hızlandırır. + +Motoru birlikte kullanmanızı öneririz `MergeTree`. Mağaza tam veri `MergeTree` tablo ve kullanım `SummingMergeTree` örneğin, rapor hazırlarken toplu veri depolamak için. Böyle bir yaklaşım, yanlış oluşturulmuş bir birincil anahtar nedeniyle değerli verileri kaybetmenizi önleyecektir. + +## Tablo oluşturma {#creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE = SummingMergeTree([columns]) +[PARTITION BY expr] +[ORDER BY expr] +[SAMPLE BY expr] +[SETTINGS name=value, ...] +``` + +İstek parametrelerinin açıklaması için bkz. [istek açıklaması](../../../sql_reference/statements/create.md). + +**SummingMergeTree parametreleri** + +- `columns` - değerlerin özetleneceği sütunların adlarına sahip bir tuple. İsteğe bağlı parametre. + Sütunlar sayısal tipte olmalı ve birincil anahtarda olmamalıdır. + + Eğer `columns` belirtilmemiş, ClickHouse birincil anahtarda olmayan bir sayısal veri türü ile tüm sütunlardaki değerleri özetler. + +**Sorgu yan tümceleri** + +Oluştururken bir `SummingMergeTree` tablo aynı [yanlar](mergetree.md) oluşturul ,urken olduğu gibi gerekli `MergeTree` Tablo. + +
+ +Bir tablo oluşturmak için kullanımdan kaldırılan yöntem + +!!! attention "Dikkat" + Bu yöntemi yeni projelerde kullanmayın ve mümkünse eski projeleri yukarıda açıklanan yönteme geçin. + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE [=] SummingMergeTree(date-column [, sampling_expression], (primary, key), index_granularity, [columns]) +``` + +Hariç tüm parametreler `columns` içinde olduğu gibi aynı anlama sahip `MergeTree`. + +- `columns` — tuple with names of columns values of which will be summarized. Optional parameter. For a description, see the text above. + +
+ +## Kullanım Örneği {#usage-example} + +Aşağıdaki tabloyu düşünün: + +``` sql +CREATE TABLE summtt +( + key UInt32, + value UInt32 +) +ENGINE = SummingMergeTree() +ORDER BY key +``` + +Veri Ekle: + +``` sql +INSERT INTO summtt Values(1,1),(1,2),(2,1) +``` + +ClickHouse tüm satırları tamamen toplayabilir ([aşağıya bakın](#data-processing)), bu yüzden bir toplama işlevi kullanıyoruz `sum` ve `GROUP BY` sorguda yan tümcesi. + +``` sql +SELECT key, sum(value) FROM summtt GROUP BY key +``` + +``` text +┌─key─┬─sum(value)─┐ +│ 2 │ 1 │ +│ 1 │ 3 │ +└─────┴────────────┘ +``` + +## Veri İşleme {#data-processing} + +Veriler bir tabloya eklendiğinde, bunlar olduğu gibi kaydedilir. ClickHouse, verilerin eklenen bölümlerini periyodik olarak birleştirir ve bu, aynı birincil anahtara sahip satırların toplandığı ve sonuçta elde edilen her veri parçası için bir tane ile değiştirildiği zamandır. + +ClickHouse can merge the data parts so that different resulting parts of data cat consist rows with the same primary key, i.e. the summation will be incomplete. Therefore (`SELECT`) bir toplama fonksiyonu [toplam()](../../../sql_reference/aggregate_functions/reference.md#agg_function-sum) ve `GROUP BY` yukarıdaki örnekte açıklandığı gibi yan tümcesi bir sorguda kullanılmalıdır. + +### Toplama İçin Ortak Kurallar {#common-rules-for-summation} + +Sayısal veri türüne sahip sütunlardaki değerler özetlenir. Sütun kümesi parametre tarafından tanımlanır `columns`. + +Değerler toplamı için tüm sütunlarda 0 ise, satır silinir. + +Sütun birincil anahtarda değilse ve özetlenmezse, mevcut olanlardan rasgele bir değer seçilir. + +Değerler, birincil anahtardaki sütunlar için özetlenmez. + +### Aggregatefunction Sütunlarındaki toplama {#the-summation-in-the-aggregatefunction-columns} + +Sütunlar için [AggregateFunction türü](../../../sql_reference/data_types/aggregatefunction.md) ClickHouse olarak davranır [AggregatingMergeTree](aggregatingmergetree.md) işleve göre motor toplama. + +### İç İçe Yapılar {#nested-structures} + +Tablo, özel bir şekilde işlenen iç içe geçmiş veri yapılarına sahip olabilir. + +İç içe geçmiş bir tablonun adı ile bitiyorsa `Map` ve aşağıdaki kriterleri karşılayan en az iki sütun içerir: + +- ilk sütun sayısal `(*Int*, Date, DateTime)` veya bir dize `(String, FixedString)` hadi diyelim `key`, +- diğer sütunlar aritmetik `(*Int*, Float32/64)` hadi diyelim `(values...)`, + +sonra bu iç içe geçmiş tablo bir eşleme olarak yorumlanır `key => (values...)` ve satırlarını birleştirirken, iki veri kümesinin öğeleri şu şekilde birleştirilir `key` karşılık gelen bir toplamı ile `(values...)`. + +Örnekler: + +``` text +[(1, 100)] + [(2, 150)] -> [(1, 100), (2, 150)] +[(1, 100)] + [(1, 150)] -> [(1, 250)] +[(1, 100)] + [(1, 150), (2, 150)] -> [(1, 250), (2, 150)] +[(1, 100), (2, 150)] + [(1, -100)] -> [(2, 150)] +``` + +Veri isterken, [sumMap (anahtar, değer)](../../../sql_reference/aggregate_functions/reference.md) toplama fonksiyonu `Map`. + +İç içe geçmiş veri yapısı için, sütunlarının toplamı için sütun kümesinde belirtmeniz gerekmez. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/summingmergetree/) diff --git a/docs/tr/engines/table_engines/mergetree_family/versionedcollapsingmergetree.md b/docs/tr/engines/table_engines/mergetree_family/versionedcollapsingmergetree.md new file mode 100644 index 00000000000..b9adb381783 --- /dev/null +++ b/docs/tr/engines/table_engines/mergetree_family/versionedcollapsingmergetree.md @@ -0,0 +1,238 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 37 +toc_title: VersionedCollapsingMergeTree +--- + +# VersionedCollapsingMergeTree {#versionedcollapsingmergetree} + +Bu motor: + +- Sürekli değişen nesne durumlarının hızlı yazılmasını sağlar. +- Arka planda eski nesne durumlarını siler. Bu, depolama hacmini önemli ölçüde azaltır. + +Bölümüne bakınız [Çökme](#table_engines_versionedcollapsingmergetree) ayrıntılar için. + +Motor devralır [MergeTree](mergetree.md#table_engines-mergetree) ve veri parçalarını birleştirmek için algoritmaya satırları daraltmak için mantığı ekler. `VersionedCollapsingMergeTree` aynı amaca hizmet eder [CollapsingMergeTree](collapsingmergetree.md) ancak, verilerin birden çok iş parçacığıyla herhangi bir sıraya yerleştirilmesine izin veren farklı bir çökme algoritması kullanır. Özellikle, `Version` sütun, yanlış sıraya yerleştirilmiş olsalar bile satırları düzgün bir şekilde daraltmaya yardımcı olur. Tersine, `CollapsingMergeTree` sadece kesinlikle ardışık ekleme sağlar. + +## Tablo oluşturma {#creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE = VersionedCollapsingMergeTree(sign, version) +[PARTITION BY expr] +[ORDER BY expr] +[SAMPLE BY expr] +[SETTINGS name=value, ...] +``` + +Sorgu parametrelerinin açıklaması için bkz: [sorgu açıklaması](../../../sql_reference/statements/create.md). + +**Motor Parametreleri** + +``` sql +VersionedCollapsingMergeTree(sign, version) +``` + +- `sign` — Name of the column with the type of row: `1` is a “state” satır, `-1` is a “cancel” satır. + + Sütun veri türü olmalıdır `Int8`. + +- `version` — Name of the column with the version of the object state. + + Sütun veri türü olmalıdır `UInt*`. + +**Sorgu Yan Tümceleri** + +Oluştururken bir `VersionedCollapsingMergeTree` tablo, aynı [yanlar](mergetree.md) oluşturul aurken gerekli `MergeTree` Tablo. + +
+ +Bir tablo oluşturmak için kullanımdan kaldırılan yöntem + +!!! attention "Dikkat" + Bu yöntemi yeni projelerde kullanmayın. Mümkünse, eski projeleri yukarıda açıklanan yönteme geçin. + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) ENGINE [=] VersionedCollapsingMergeTree(date-column [, sampling_expression], (primary, key), index_granularity, sign, version) +``` + +Dışındaki tüm parametreler `sign` ve `version` içinde olduğu gibi aynı anlama sahip `MergeTree`. + +- `sign` — Name of the column with the type of row: `1` is a “state” satır, `-1` is a “cancel” satır. + + Column Data Type — `Int8`. + +- `version` — Name of the column with the version of the object state. + + Sütun veri türü olmalıdır `UInt*`. + +
+ +## Çökme {#table_engines-versionedcollapsingmergetree} + +### Veriler {#data} + +Bazı nesneler için sürekli değişen verileri kaydetmeniz gereken bir durumu düşünün. Bir nesne için bir satıra sahip olmak ve değişiklikler olduğunda satırı güncellemek mantıklıdır. Ancak, depolama alanındaki verileri yeniden yazmayı gerektirdiğinden, güncelleştirme işlemi bir DBMS için pahalı ve yavaştır. Verileri hızlı bir şekilde yazmanız gerekiyorsa güncelleştirme kabul edilemez, ancak değişiklikleri bir nesneye sırayla aşağıdaki gibi yazabilirsiniz. + +Kullan... `Sign` satır yazarken sütun. Eğer `Sign = 1` bu, satırın bir nesnenin durumu olduğu anlamına gelir (diyelim “state” satır). Eğer `Sign = -1` aynı özelliklere sahip bir nesnenin durumunun iptal edildiğini gösterir (buna “cancel” satır). Ayrıca kullanın `Version` bir nesnenin her durumunu ayrı bir sayı ile tanımlaması gereken sütun. + +Örneğin, kullanıcıların bazı sitede kaç sayfa ziyaret ettiğini ve ne kadar süre orada olduklarını hesaplamak istiyoruz. Bir noktada, kullanıcı etkinliği durumu ile aşağıdaki satırı yazıyoruz: + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┬─Version─┐ +│ 4324182021466249494 │ 5 │ 146 │ 1 │ 1 | +└─────────────────────┴───────────┴──────────┴──────┴─────────┘ +``` + +Bir noktada daha sonra kullanıcı aktivitesinin değişikliğini kaydediyoruz ve aşağıdaki iki satırla yazıyoruz. + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┬─Version─┐ +│ 4324182021466249494 │ 5 │ 146 │ -1 │ 1 | +│ 4324182021466249494 │ 6 │ 185 │ 1 │ 2 | +└─────────────────────┴───────────┴──────────┴──────┴─────────┘ +``` + +İlk satır, nesnenin (kullanıcı) önceki durumunu iptal eder. Dışında iptal edilen Devletin tüm alanlarını kopya shouldlama shouldlıdır `Sign`. + +İkinci satır geçerli durumu içerir. + +Sadece kullanıcı etkinliğinin son durumuna ihtiyacımız olduğundan, satırlar + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┬─Version─┐ +│ 4324182021466249494 │ 5 │ 146 │ 1 │ 1 | +│ 4324182021466249494 │ 5 │ 146 │ -1 │ 1 | +└─────────────────────┴───────────┴──────────┴──────┴─────────┘ +``` + +nesnenin geçersiz (eski) durumunu daraltarak silinebilir. `VersionedCollapsingMergeTree` veri parçalarını birleştirirken bunu yapar. + +Her değişiklik için neden iki satıra ihtiyacımız olduğunu bulmak için bkz. [Algoritma](#table_engines-versionedcollapsingmergetree-algorithm). + +**Kullanımı ile ilgili notlar** + +1. Verileri yazan program, iptal etmek için bir nesnenin durumunu hatırlamalıdır. Bu “cancel” dize bir kopyası olmalıdır “state” tersi ile dize `Sign`. Bu, ilk depolama boyutunu arttırır, ancak verileri hızlı bir şekilde yazmanıza izin verir. +2. Sütunlardaki uzun büyüyen diziler, yazma yükü nedeniyle motorun verimliliğini azaltır. Daha basit veri, daha iyi verim. +3. `SELECT` sonuçlara itiraz değişiklikleri tarihinin tutarlılık bağlıdır. Ekleme için veri hazırlarken doğru olun. Oturum derinliği gibi negatif olmayan metrikler için negatif değerler gibi tutarsız verilerle öngörülemeyen sonuçlar alabilirsiniz. + +### Algoritma {#table_engines-versionedcollapsingmergetree-algorithm} + +ClickHouse veri parçalarını birleştirdiğinde, aynı birincil anahtar ve sürüm ve farklı olan her satır çiftini siler `Sign`. Satırların sırası önemli değil. + +ClickHouse veri eklediğinde, satırları birincil anahtarla sipariş eder. Eğer... `Version` sütun birincil anahtarda değil, ClickHouse onu birincil anahtara örtük olarak son alan olarak ekler ve sipariş vermek için kullanır. + +## Veri Seçme {#selecting-data} + +ClickHouse, aynı birincil anahtara sahip tüm satırların aynı sonuçtaki veri bölümünde veya hatta aynı fiziksel sunucuda olacağını garanti etmez. Bu, hem verileri yazmak hem de veri parçalarının daha sonra birleştirilmesi için geçerlidir. Ayrıca, ClickHouse süreçleri `SELECT` birden çok iş parçacıklarıyla sorgular ve sonuçtaki satırların sırasını tahmin edemez. Bu tamamen almak için bir ihtiyaç varsa toplama gerekli olduğu anlamına gelir “collapsed” bir veri `VersionedCollapsingMergeTree` Tablo. + +Daraltmayı sonuçlandırmak için, bir sorgu ile bir sorgu yazın `GROUP BY` yan tümce ve işareti için hesap toplama işlevleri. Örneğin, miktarı hesaplamak için kullanın `sum(Sign)` yerine `count()`. Bir şeyin toplamını hesaplamak için şunları kullanın `sum(Sign * x)` yerine `sum(x)` ve Ekle `HAVING sum(Sign) > 0`. + +Toplanan `count`, `sum` ve `avg` bu şekilde hesaplanabilir. Toplanan `uniq` bir nesnenin en az bir daraltılmamış durumu varsa hesaplanabilir. Toplanan `min` ve `max` hesaplan becauseamaz çünkü `VersionedCollapsingMergeTree` çökmüş durumların değerlerinin geçmişini kaydetmez. + +İle verileri ayıklamak gerekiyorsa “collapsing” ancak toplama olmadan (örneğin, en yeni değerleri belirli koşullarla eşleşen satırların mevcut olup olmadığını kontrol etmek için) `FINAL` değiştirici için `FROM` yan. Bu yaklaşım verimsizdir ve büyük tablolarla kullanılmamalıdır. + +## Kullanım Örneği {#example-of-use} + +Örnek veriler: + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┬─Version─┐ +│ 4324182021466249494 │ 5 │ 146 │ 1 │ 1 | +│ 4324182021466249494 │ 5 │ 146 │ -1 │ 1 | +│ 4324182021466249494 │ 6 │ 185 │ 1 │ 2 | +└─────────────────────┴───────────┴──────────┴──────┴─────────┘ +``` + +Tablo oluşturma: + +``` sql +CREATE TABLE UAct +( + UserID UInt64, + PageViews UInt8, + Duration UInt8, + Sign Int8, + Version UInt8 +) +ENGINE = VersionedCollapsingMergeTree(Sign, Version) +ORDER BY UserID +``` + +Veri ekleme: + +``` sql +INSERT INTO UAct VALUES (4324182021466249494, 5, 146, 1, 1) +``` + +``` sql +INSERT INTO UAct VALUES (4324182021466249494, 5, 146, -1, 1),(4324182021466249494, 6, 185, 1, 2) +``` + +Biz iki kullanın `INSERT` iki farklı veri parçası oluşturmak için sorgular. Verileri tek bir sorgu ile eklersek, ClickHouse bir veri parçası oluşturur ve hiçbir zaman birleştirme gerçekleştirmez. + +Veri alma: + +``` sql +SELECT * FROM UAct +``` + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┬─Version─┐ +│ 4324182021466249494 │ 5 │ 146 │ 1 │ 1 │ +└─────────────────────┴───────────┴──────────┴──────┴─────────┘ +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┬─Version─┐ +│ 4324182021466249494 │ 5 │ 146 │ -1 │ 1 │ +│ 4324182021466249494 │ 6 │ 185 │ 1 │ 2 │ +└─────────────────────┴───────────┴──────────┴──────┴─────────┘ +``` + +Burada ne görüyoruz ve çökmüş parçalar nerede? +İki veri parçasını iki kullanarak oluşturduk `INSERT` sorgular. Bu `SELECT` sorgu iki iş parçacığında gerçekleştirildi ve sonuç rastgele bir satır sırasıdır. +Veri bölümleri henüz birleştirilmediği için çökme gerçekleşmedi. ClickHouse biz tahmin edemez zaman içinde bilinmeyen bir noktada veri parçalarını birleştirir. + +Bu yüzden toplamaya ihtiyacımız var: + +``` sql +SELECT + UserID, + sum(PageViews * Sign) AS PageViews, + sum(Duration * Sign) AS Duration, + Version +FROM UAct +GROUP BY UserID, Version +HAVING sum(Sign) > 0 +``` + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Version─┐ +│ 4324182021466249494 │ 6 │ 185 │ 2 │ +└─────────────────────┴───────────┴──────────┴─────────┘ +``` + +Toplamaya ihtiyacımız yoksa ve çökmeyi zorlamak istiyorsak, `FINAL` değiştirici için `FROM` yan. + +``` sql +SELECT * FROM UAct FINAL +``` + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┬─Version─┐ +│ 4324182021466249494 │ 6 │ 185 │ 1 │ 2 │ +└─────────────────────┴───────────┴──────────┴──────┴─────────┘ +``` + +Bu, verileri seçmek için çok verimsiz bir yoldur. Büyük tablolar için kullanmayın. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/versionedcollapsingmergetree/) diff --git a/docs/tr/engines/table_engines/special/buffer.md b/docs/tr/engines/table_engines/special/buffer.md new file mode 100644 index 00000000000..fa53822ab2b --- /dev/null +++ b/docs/tr/engines/table_engines/special/buffer.md @@ -0,0 +1,71 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 45 +toc_title: Arabellek +--- + +# Arabellek {#buffer} + +RAM'de yazmak için verileri tamponlar, periyodik olarak başka bir tabloya temizler. Okuma işlemi sırasında veri arabellekten ve diğer tablodan aynı anda okunur. + +``` sql +Buffer(database, table, num_layers, min_time, max_time, min_rows, max_rows, min_bytes, max_bytes) +``` + +Motor parametreleri: + +- `database` – Database name. Instead of the database name, you can use a constant expression that returns a string. +- `table` – Table to flush data to. +- `num_layers` – Parallelism layer. Physically, the table will be represented as `num_layers` bağımsız tamponların. Önerilen değer: 16. +- `min_time`, `max_time`, `min_rows`, `max_rows`, `min_bytes`, ve `max_bytes` – Conditions for flushing data from the buffer. + +Veri arabellekten temizlendi ve hedef tabloya yazılır eğer tüm `min*` koşulları veya en az bir `max*` koşul karşı arelanır. + +- `min_time`, `max_time` – Condition for the time in seconds from the moment of the first write to the buffer. +- `min_rows`, `max_rows` – Condition for the number of rows in the buffer. +- `min_bytes`, `max_bytes` – Condition for the number of bytes in the buffer. + +Yazma işlemi sırasında veri bir `num_layers` rastgele tampon sayısı. Veya, eklenecek veri kısmı yeterince büyükse (daha büyük `max_rows` veya `max_bytes`), arabelleği atlayarak doğrudan hedef tabloya yazılır. + +Verilerin yıkanması için koşullar, her biri için ayrı ayrı hesaplanır. `num_layers` arabellekler. Örneğin, `num_layers = 16` ve `max_bytes = 100000000`, maksimum RAM tüketimi 1,6 GB'DİR. + +Örnek: + +``` sql +CREATE TABLE merge.hits_buffer AS merge.hits ENGINE = Buffer(merge, hits, 16, 10, 100, 10000, 1000000, 10000000, 100000000) +``` + +Oluşturma Bir ‘merge.hits\_buffer’ ile aynı yapıya sahip tablo ‘merge.hits’ ve Tampon motorunu kullanarak. Bu tabloya yazarken, veriler RAM'de arabelleğe alınır ve daha sonra ‘merge.hits’ Tablo. 16 tamponlar oluşturulur. 100 saniye geçti veya bir milyon satır yazılmış veya 100 MB veri yazılmıştır; ya da aynı anda 10 saniye geçti ve 10.000 satır ve 10 MB veri yazılmıştır, bunların her veri temizlendi. Örneğin, sadece bir satır yazılmışsa, 100 saniye sonra ne olursa olsun, yıkanacaktır. Ancak, birçok satır yazılmışsa, veriler daha erken temizlenecektir. + +Sunucu DROP TABLE veya DETACH TABLE ile durdurulduğunda, arabellek verileri de hedef tabloya temizlendi. + +Veritabanı ve tablo adı için tek tırnak içinde boş dizeleri ayarlayabilirsiniz. Bu, bir hedef tablonun yokluğunu gösterir. Bu durumda, Veri Temizleme koşullarına ulaşıldığında, arabellek basitçe temizlenir. Bu, bir veri penceresini bellekte tutmak için yararlı olabilir. + +Bir arabellek tablosundan okurken, veriler hem arabellekten hem de hedef tablodan (varsa) işlenir. +Arabellek tabloları bir dizin desteklemediğini unutmayın. Başka bir deyişle, arabellekteki veriler tamamen taranır, bu da büyük arabellekler için yavaş olabilir. (Alt tablodaki veriler için, desteklediği dizin kullanılacaktır.) + +Arabellek tablosundaki sütun kümesi, alt tablodaki sütun kümesiyle eşleşmiyorsa, her iki tabloda da bulunan sütunların bir alt kümesi eklenir. + +Türleri arabellek tablo ve alt tablo sütunlarından biri için eşleşmiyorsa, sunucu günlüğüne bir hata iletisi girilir ve arabellek temizlenir. +Arabellek temizlendiğinde alt tablo yoksa aynı şey olur. + +Eğer bağımlı bir tablo ve Tampon tablo için ALTER çalıştırmak gerekiyorsa, ilk Tampon tablo silme, alt tablo için ALTER çalışan, sonra tekrar Tampon tablo oluşturma öneririz. + +Sunucu anormal şekilde yeniden başlatılırsa, arabellekteki veriler kaybolur. + +Son ve örnek arabellek tabloları için düzgün çalışmıyor. Bu koşullar hedef tabloya geçirilir, ancak arabellekte veri işlemek için kullanılmaz. Bu özellikler gerekiyorsa, hedef tablodan okurken yalnızca yazma için arabellek tablosunu kullanmanızı öneririz. + +Bir arabelleğe veri eklerken, arabelleklerden biri kilitlenir. Bir okuma işlemi aynı anda tablodan gerçekleştiriliyor, bu gecikmelere neden olur. + +Bir arabellek tablosuna eklenen veriler, alt tabloda farklı bir sırada ve farklı bloklarda sonuçlanabilir. Bu nedenle, bir arabellek tablo CollapsingMergeTree doğru yazmak için kullanmak zordur. Sorunları önlemek için şunları ayarlayabilirsiniz ‘num\_layers’ 1'e. + +Hedef tablo yinelenirse, bir arabellek tablosuna yazarken yinelenmiş tabloların bazı beklenen özellikleri kaybolur. Satır ve veri parçaları boyutlarda sipariş için rasgele değişiklikler veri çoğaltma güvenilir olması mümkün olmadığını ifade eden çalışma, kapanmasına neden ‘exactly once’ çoğaltılan tablolara yazın. + +Bu dezavantajlardan dolayı, nadir durumlarda yalnızca bir arabellek tablosu kullanmanızı önerebiliriz. + +Bir arabellek tablosu, bir zaman birimi üzerinden çok sayıda sunucudan çok fazla ekleme alındığında kullanılır ve ekleme işleminden önce veri arabelleğe alınamaz, bu da eklerin yeterince hızlı çalışamayacağı anlamına gelir. + +Arabellek tabloları için bile, her seferinde bir satır veri eklemek mantıklı olmadığını unutmayın. Bu, yalnızca saniyede birkaç bin satırlık bir hız üretirken, daha büyük veri blokları eklemek saniyede bir milyondan fazla satır üretebilir (bölüme bakın “Performance”). + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/buffer/) diff --git a/docs/tr/engines/table_engines/special/dictionary.md b/docs/tr/engines/table_engines/special/dictionary.md new file mode 100644 index 00000000000..ce02429a31f --- /dev/null +++ b/docs/tr/engines/table_engines/special/dictionary.md @@ -0,0 +1,97 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 35 +toc_title: "S\xF6zl\xFCk" +--- + +# Sözlük {#dictionary} + +Bu `Dictionary` motor görüntüler [sözlük](../../../sql_reference/dictionaries/external_dictionaries/external_dicts.md) bir ClickHouse tablo olarak veri. + +Örnek olarak, bir sözlük düşünün `products` aşağıdaki yapılandırma ile: + +``` xml + + + products + + +
products
+ DSN=some-db-server + + + + 300 + 360 + + + + + + + product_id + + + title + String + + + + + +``` + +Sözlük verilerini sorgula: + +``` sql +SELECT + name, + type, + key, + attribute.names, + attribute.types, + bytes_allocated, + element_count, + source +FROM system.dictionaries +WHERE name = 'products' +``` + +``` text +┌─name─────┬─type─┬─key────┬─attribute.names─┬─attribute.types─┬─bytes_allocated─┬─element_count─┬─source──────────┐ +│ products │ Flat │ UInt64 │ ['title'] │ ['String'] │ 23065376 │ 175032 │ ODBC: .products │ +└──────────┴──────┴────────┴─────────────────┴─────────────────┴─────────────────┴───────────────┴─────────────────┘ +``` + +Kullanabilirsiniz [dictGet\*](../../../sql_reference/functions/ext_dict_functions.md#ext_dict_functions) sözlük verilerini bu formatta almak için işlev. + +Bu görünüm, ham veri almanız gerektiğinde veya bir `JOIN` işleyiş. Bu durumlar için şunları kullanabilirsiniz `Dictionary` bir tabloda sözlük verilerini görüntüleyen motor. + +Sözdizimi: + +``` sql +CREATE TABLE %table_name% (%fields%) engine = Dictionary(%dictionary_name%)` +``` + +Kullanım örneği: + +``` sql +create table products (product_id UInt64, title String) Engine = Dictionary(products); +``` + + Ok + +Masada ne olduğuna bir bak. + +``` sql +select * from products limit 1; +``` + +``` text +┌────product_id─┬─title───────────┐ +│ 152689 │ Some item │ +└───────────────┴─────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/dictionary/) diff --git a/docs/tr/engines/table_engines/special/distributed.md b/docs/tr/engines/table_engines/special/distributed.md new file mode 100644 index 00000000000..28cb0e0855d --- /dev/null +++ b/docs/tr/engines/table_engines/special/distributed.md @@ -0,0 +1,152 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 33 +toc_title: "Da\u011F\u0131l\u0131" +--- + +# Dağılı {#distributed} + +**Dağıtılmış altyapısı olan tablolar kendileri tarafından herhangi bir veri depolamaz**, ancak birden çok sunucuda dağıtılmış sorgu işleme izin verir. +Okuma otomatik olarak paralelleştirilir. Bir okuma sırasında, varsa uzak sunucularda tablo dizinleri kullanılır. + +Dağıtılmış motor parametreleri kabul eder: + +- sunucunun yapılandırma dosyasındaki küme adı + +- uzak veritabanı adı + +- uzak bir tablonun adı + +- (isteğe bağlı olarak) sharding anahtarı + +- (isteğe bağlı olarak) ilke adı, zaman uyumsuz göndermek için geçici dosyaları depolamak için kullanılacaktır + + Ayrıca bakınız: + + - `insert_distributed_sync` ayar + - [MergeTree](../mergetree_family/mergetree.md#table_engine-mergetree-multiple-volumes) örnekler için + +Örnek: + +``` sql +Distributed(logs, default, hits[, sharding_key[, policy_name]]) +``` + +Veri tüm sunuculardan okunacak ‘logs’ küme, varsayılan değerden.kümedeki her sunucuda bulunan hits tablosu. +Veriler yalnızca okunmakla kalmaz, aynı zamanda uzak sunucularda kısmen işlenir (bunun mümkün olduğu ölçüde). +Örneğin, GROUP BY ile bir sorgu için uzak sunucularda veri toplanır ve toplama işlevlerinin Ara durumları istek sahibi sunucuya gönderilir. Daha sonra veriler daha fazla toplanacaktır. + +Veritabanı adı yerine, bir dize döndüren sabit bir ifade kullanabilirsiniz. Örneğin: currentDatabase (). + +logs – The cluster name in the server's config file. + +Kümeler şöyle ayarlanır: + +``` xml + + + + + 1 + + false + + example01-01-1 + 9000 + + + example01-01-2 + 9000 + + + + 2 + false + + example01-02-1 + 9000 + + + example01-02-2 + 1 + 9440 + + + + +``` + +Burada bir küme adı ile tanımlanır ‘logs’ bu, her biri iki kopya içeren iki parçadan oluşur. +Kırıklar, verilerin farklı bölümlerini içeren sunuculara başvurur (tüm verileri okumak için tüm kırıklara erişmeniz gerekir). +Yinelemeler sunucuları çoğaltılıyor (tüm verileri okumak için, yinelemelerden herhangi birinde verilere erişebilirsiniz). + +Küme adları nokta içermemelidir. + +Parametre `host`, `port` ve isteğe bağlı olarak `user`, `password`, `secure`, `compression` her sunucu için belirtilir: +- `host` – The address of the remote server. You can use either the domain or the IPv4 or IPv6 address. If you specify the domain, the server makes a DNS request when it starts, and the result is stored as long as the server is running. If the DNS request fails, the server doesn't start. If you change the DNS record, restart the server. +- `port` – The TCP port for messenger activity (‘tcp\_port’ yapılandırmada, genellikle 9000 olarak ayarlanır). Http\_port ile karıştırmayın. +- `user` – Name of the user for connecting to a remote server. Default value: default. This user must have access to connect to the specified server. Access is configured in the users.xml file. For more information, see the section [Erişim hakları](../../../operations/access_rights.md). +- `password` – The password for connecting to a remote server (not masked). Default value: empty string. +- `secure` - Bağlantı için ssl kullanın, genellikle de tanımlamanız gerekir `port` = 9440. Sunucu dinlem shouldeli 9440 ve doğru sertifikalara sahip. +- `compression` - Kullanım veri sıkıştırma. Varsayılan değer: true. + +When specifying replicas, one of the available replicas will be selected for each of the shards when reading. You can configure the algorithm for load balancing (the preference for which replica to access) – see the [dengeleme](../../../operations/settings/settings.md#settings-load_balancing) ayar. +Sunucu ile bağlantı kurulmamışsa, kısa bir zaman aşımı ile bağlanma girişimi olacaktır. Bağlantı başarısız olursa, sonraki yineleme seçilir ve benzeri tüm yinelemeler için. Bağlantı girişimi tüm yinelemeler için başarısız olursa, girişimi aynı şekilde, birkaç kez tekrarlanır. +Bu esneklik lehine çalışır, ancak tam hataya dayanıklılık sağlamaz: uzak bir sunucu bağlantıyı kabul edebilir, ancak çalışmayabilir veya kötü çalışabilir. + +Parçalardan yalnızca birini belirtebilirsiniz (bu durumda, sorgu işleme dağıtılmış yerine uzak olarak adlandırılmalıdır) veya herhangi bir sayıda parçaya kadar. Her parçada, bir ila herhangi bir sayıda yinelemeyi belirtebilirsiniz. Her parça için farklı sayıda çoğaltma belirtebilirsiniz. + +Yapılandırmada istediğiniz kadar küme belirtebilirsiniz. + +Kümelerinizi görüntülemek için ‘system.clusters’ Tablo. + +Dağıtılmış motor, yerel bir sunucu gibi bir küme ile çalışmaya izin verir. Ancak, küme uzatılamaz: yapılandırmasını sunucu yapılandırma dosyasına yazmanız gerekir (tüm kümenin sunucuları için daha da iyisi). + +The Distributed engine requires writing clusters to the config file. Clusters from the config file are updated on the fly, without restarting the server. If you need to send a query to an unknown set of shards and replicas each time, you don't need to create a Distributed table – use the ‘remote’ bunun yerine tablo işlevi. Bölümüne bakınız [Tablo fonksiyonları](../../../sql_reference/table_functions/index.md). + +Bir kümeye veri yazmak için iki yöntem vardır: + +İlk olarak, hangi sunucuların hangi verileri yazacağını ve her bir parçaya doğrudan yazmayı gerçekleştireceğini tanımlayabilirsiniz. Başka bir deyişle, dağıtılmış tablo içinde INSERT gerçekleştirmek “looks at”. Bu, konu alanının gereklilikleri nedeniyle önemsiz olmayan herhangi bir sharding şemasını kullanabileceğiniz için en esnek çözümdür. Bu aynı zamanda en uygun çözümdür, çünkü veriler farklı parçalara tamamen bağımsız olarak yazılabilir. + +İkinci olarak, dağıtılmış bir tabloda ekleme gerçekleştirebilirsiniz. Bu durumda, tablo eklenen verileri sunucuların kendisine dağıtacaktır. Dağıtılmış bir tabloya yazmak için, bir sharding anahtar kümesi (son parametre) olmalıdır. Ek olarak, yalnızca bir parça varsa, yazma işlemi sharding anahtarını belirtmeden çalışır, çünkü bu durumda hiçbir şey ifade etmez. + +Her parça yapılandırma dosyasında tanımlanan bir ağırlığa sahip olabilir. Varsayılan olarak, ağırlık bir eşittir. Veriler, parça ağırlığı ile orantılı miktarda parçalara dağıtılır. Örneğin, iki parça varsa ve birincisi 9'luk bir ağırlığa sahipse, ikincisi 10'luk bir ağırlığa sahipse, ilk satırların 9 / 19 parçası gönderilir ve ikincisi 10 / 19 gönderilir. + +Her shard olabilir ‘internal\_replication’ yapılandırma dosyasında tanımlanan parametre. + +Bu parametre şu şekilde ayarlanırsa ‘true’, yazma işlemi ilk sağlıklı yinelemeyi seçer ve ona veri yazar. Dağıtılmış tablo ise bu alternatifi kullanın “looks at” çoğaltılan tablolar. Başka bir deyişle, verilerin yazılacağı tablo kendilerini çoğaltacaktır. + +Olarak ayarlan ifmışsa ‘false’ (varsayılan), veriler tüm kopyalara yazılır. Özünde, bu, dağıtılmış tablonun verilerin kendisini çoğalttığı anlamına gelir. Bu, çoğaltılmış tabloları kullanmaktan daha kötüdür, çünkü kopyaların tutarlılığı denetlenmez ve zamanla biraz farklı veriler içerirler. + +Bir veri satırının gönderildiği parçayı seçmek için, parçalama ifadesi analiz edilir ve kalan kısmı, parçaların toplam ağırlığına bölünmesinden alınır. Satır, kalanların yarı aralığına karşılık gelen parçaya gönderilir. ‘prev\_weight’ -e doğru ‘prev\_weights + weight’, nere ‘prev\_weights’ en küçük sayıya sahip parçaların toplam ağırlığı ve ‘weight’ bu parçanın ağırlığı. Örneğin, iki parça varsa ve birincisi 9'luk bir ağırlığa sahipse, ikincisi 10'luk bir ağırlığa sahipse, satır \[0, 9) aralığından kalanlar için ilk parçaya ve ikincisine \[9, 19) aralığından kalanlar için gönderilecektir. + +Sharding ifadesi, bir tamsayı döndüren sabitler ve tablo sütunlarından herhangi bir ifade olabilir. Örneğin, ifadeyi kullanabilirsiniz ‘rand()’ verilerin rastgele dağılımı için veya ‘UserID’ kullanıcının kimliğinin bölünmesinden kalanın dağıtımı için (daha sonra tek bir kullanıcının verileri, kullanıcılar tarafından çalışmayı ve katılmayı basitleştiren tek bir parçada bulunur). Sütunlardan biri yeterince eşit olarak dağıtılmazsa, onu bir karma işleve sarabilirsiniz: ınthash64(Userıd). + +Bölüm'den basit bir hatırlatma, sharding için sınırlı bir çözümdür ve her zaman uygun değildir. Orta ve büyük hacimlerde veri (düzinelerce sunucu) için çalışır, ancak çok büyük hacimlerde veri (yüzlerce sunucu veya daha fazla) için değildir. İkinci durumda, dağıtılmış tablolarda girdileri kullanmak yerine konu alanı tarafından gerekli olan sharding şemasını kullanın. + +SELECT queries are sent to all the shards and work regardless of how data is distributed across the shards (they can be distributed completely randomly). When you add a new shard, you don't have to transfer the old data to it. You can write new data with a heavier weight – the data will be distributed slightly unevenly, but queries will work correctly and efficiently. + +Aşağıdaki durumlarda sharding şeması hakkında endişelenmelisiniz: + +- Belirli bir anahtar tarafından veri (veya birleştirme) birleştirme gerektiren sorgular kullanılır. Veriler bu anahtar tarafından parçalanırsa, GLOBAL IN veya GLOBAL JOİN yerine local IN veya JOİN kullanabilirsiniz, bu da çok daha etkilidir. +- Çok sayıda küçük Sorgu ile çok sayıda sunucu (yüzlerce veya daha fazla) kullanılır (bireysel müşterilerin sorguları - web siteleri, reklamverenler veya ortaklar). Küçük sorguların tüm kümeyi etkilememesi için, tek bir istemci için tek bir parça üzerinde veri bulmak mantıklıdır. Alternatif olarak, Yandex'te yaptığımız gibi.Metrica, iki seviyeli sharding kurabilirsiniz: tüm kümeyi bölün “layers”, bir katmanın birden fazla parçadan oluşabileceği yer. Tek bir istemci için veriler tek bir katmanda bulunur, ancak kırıklar gerektiğinde bir katmana eklenebilir ve veriler rastgele dağıtılır. Her katman için dağıtılmış tablolar oluşturulur ve genel sorgular için tek bir paylaşılan dağıtılmış tablo oluşturulur. + +Veriler zaman uyumsuz olarak yazılır. Tabloya eklendiğinde, veri bloğu sadece yerel dosya sistemine yazılır. Veriler en kısa sürede arka planda uzak sunuculara gönderilir. Veri gönderme süresi tarafından yönetilir [distributed\_directory\_monitor\_sleep\_time\_ms](../../../operations/settings/settings.md#distributed_directory_monitor_sleep_time_ms) ve [distributed\_directory\_monitor\_max\_sleep\_time\_ms](../../../operations/settings/settings.md#distributed_directory_monitor_max_sleep_time_ms) ayarlar. Bu `Distributed` motor ayrı ayrı eklenen verilerle her dosyayı gönderir, ancak toplu dosya gönderme etkinleştirebilirsiniz [distributed\_directory\_monitor\_batch\_ınserts](../../../operations/settings/settings.md#distributed_directory_monitor_batch_inserts) ayar. Bu ayar, yerel sunucu ve ağ kaynaklarını daha iyi kullanarak küme performansını artırır. Tablo dizinindeki dosyaların listesini (gönderilmeyi bekleyen veriler) kontrol ederek verilerin başarıyla gönderilip gönderilmediğini kontrol etmelisiniz: `/var/lib/clickhouse/data/database/table/`. + +Sunucu varlığını durdurdu veya (örneğin, bir aygıt arızasından sonra) dağıtılmış bir tabloya bir ekleme sonra kaba bir yeniden başlatma vardı, eklenen veriler kaybolabilir. Tablo dizininde bozuk bir veri parçası tespit edilirse, ‘broken’ alt dizin ve artık kullanılmıyor. + +Max\_parallel\_replicas seçeneği etkinleştirildiğinde, sorgu işleme tek bir parça içindeki tüm yinelemeler arasında paralelleştirilir. Daha fazla bilgi için bölüme bakın [max\_parallel\_replicas](../../../operations/settings/settings.md#settings-max_parallel_replicas). + +## Sanal Sütunlar {#virtual-columns} + +- `_shard_num` — Contains the `shard_num` (itibaren `system.clusters`). Tür: [Uİnt32](../../../sql_reference/data_types/int_uint.md). + +!!! note "Not" + Beri [`remote`](../../../sql_reference/table_functions/remote.md)/`cluster` tablo işlevleri DAHİLİ olarak aynı dağıtılmış altyapının geçici örneğini oluşturur, `_shard_num` de kullanılabilir. + +**Ayrıca Bakınız** + +- [Sanal sütunlar](index.md#table_engines-virtual_columns) + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/distributed/) diff --git a/docs/tr/engines/table_engines/special/external_data.md b/docs/tr/engines/table_engines/special/external_data.md new file mode 100644 index 00000000000..123b2dbdf0e --- /dev/null +++ b/docs/tr/engines/table_engines/special/external_data.md @@ -0,0 +1,68 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 34 +toc_title: "D\u0131\u015F veri" +--- + +# Sorgu işleme için harici veriler {#external-data-for-query-processing} + +ClickHouse bir sunucu bir SELECT sorgusu ile birlikte bir sorgu işlemek için gerekli olan verileri gönderme sağlar. Bu veriler geçici bir tabloya konur (bölüme bakın “Temporary tables”) ve sorguda kullanılabilir (örneğin, işleçlerde). + +Örneğin, önemli kullanıcı tanımlayıcılarına sahip bir metin dosyanız varsa, bu listeyi süzme kullanan bir sorgu ile birlikte sunucuya yükleyebilirsiniz. + +Büyük hacimli dış verilerle birden fazla sorgu çalıştırmanız gerekiyorsa, bu özelliği kullanmayın. Verileri vaktinden önce DB'YE yüklemek daha iyidir. + +Harici veriler komut satırı istemcisi (etkileşimli olmayan modda) veya HTTP arabirimi kullanılarak yüklenebilir. + +Komut satırı istemcisinde, formatta bir parametreler bölümü belirtebilirsiniz + +``` bash +--external --file=... [--name=...] [--format=...] [--types=...|--structure=...] +``` + +İletilen tablo sayısı için bunun gibi birden çok bölümünüz olabilir. + +**–external** – Marks the beginning of a clause. +**–file** – Path to the file with the table dump, or -, which refers to stdin. +Stdın'den yalnızca tek bir tablo alınabilir. + +Aşağıdaki parametreler isteğe bağlıdır: **–name**– Name of the table. If omitted, \_data is used. +**–format** – Data format in the file. If omitted, TabSeparated is used. + +Aşağıdaki parametrelerden biri gereklidir:**–types** – A list of comma-separated column types. For example: `UInt64,String`. The columns will be named \_1, \_2, … +**–structure**– The table structure in the format`UserID UInt64`, `URL String`. Sütun adlarını ve türlerini tanımlar. + +Belirtilen dosyalar ‘file’ belirtilen biçimde ayrıştırılır ‘format’, belirtilen veri türlerini kullanarak ‘types’ veya ‘structure’. Tablo sunucuya yüklenecek ve orada adı ile geçici bir tablo olarak erişilebilir ‘name’. + +Örnekler: + +``` bash +$ echo -ne "1\n2\n3\n" | clickhouse-client --query="SELECT count() FROM test.visits WHERE TraficSourceID IN _data" --external --file=- --types=Int8 +849897 +$ cat /etc/passwd | sed 's/:/\t/g' | clickhouse-client --query="SELECT shell, count() AS c FROM passwd GROUP BY shell ORDER BY c DESC" --external --file=- --name=passwd --structure='login String, unused String, uid UInt16, gid UInt16, comment String, home String, shell String' +/bin/sh 20 +/bin/false 5 +/bin/bash 4 +/usr/sbin/nologin 1 +/bin/sync 1 +``` + +HTTP arabirimini kullanırken, dış veriler çok parçalı/form veri biçiminde geçirilir. Her tablo ayrı bir dosya olarak iletilir. Tablo adı dosya adından alınır. Bu ‘query\_string’ parametreleri geçirilir ‘name\_format’, ‘name\_types’, ve ‘name\_structure’, nere ‘name’ bu parametreler karşılık gelen tablonun adıdır. Parametrelerin anlamı, komut satırı istemcisini kullanırken olduğu gibi aynıdır. + +Örnek: + +``` bash +$ cat /etc/passwd | sed 's/:/\t/g' > passwd.tsv + +$ curl -F 'passwd=@passwd.tsv;' 'http://localhost:8123/?query=SELECT+shell,+count()+AS+c+FROM+passwd+GROUP+BY+shell+ORDER+BY+c+DESC&passwd_structure=login+String,+unused+String,+uid+UInt16,+gid+UInt16,+comment+String,+home+String,+shell+String' +/bin/sh 20 +/bin/false 5 +/bin/bash 4 +/usr/sbin/nologin 1 +/bin/sync 1 +``` + +Dağıtılmış sorgu işleme için geçici tablolar tüm uzak sunuculara gönderilir. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/external_data/) diff --git a/docs/tr/engines/table_engines/special/file.md b/docs/tr/engines/table_engines/special/file.md new file mode 100644 index 00000000000..c132d1dd5a4 --- /dev/null +++ b/docs/tr/engines/table_engines/special/file.md @@ -0,0 +1,90 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 37 +toc_title: Dosya +--- + +# Dosya {#table_engines-file} + +Dosya tablosu altyapısı, verileri desteklenen dosyalardan birinde tutar [Dosya +biçimliler](../../../interfaces/formats.md#formats) (TabSeparated, yerli, vb.). + +Kullanım örnekleri: + +- Clickhouse'dan dosyaya veri aktarımı. +- Verileri bir biçimden diğerine dönüştürün. +- Bir diskte bir dosya düzenleme yoluyla ClickHouse veri güncelleme. + +## ClickHouse Sunucusunda Kullanım {#usage-in-clickhouse-server} + +``` sql +File(Format) +``` + +Bu `Format` parametre kullanılabilir dosya biçimlerinden birini belirtir. Gerçekleştirmek +`SELECT` sorgular, biçim giriş için desteklenmeli ve gerçekleştirmek için +`INSERT` queries – for output. The available formats are listed in the +[Biçimliler](../../../interfaces/formats.md#formats) bölme. + +ClickHouse dosya sistemi yolunu belirtmek için izin vermiyor`File`. Tarafından tanımlanan klasörü kullan willacaktır [yol](../../../operations/server_configuration_parameters/settings.md) sunucu yapılandırmasında ayarlama. + +Kullanarak tablo oluştururken `File(Format)` bu klasörde boş bir alt dizin oluşturur. Veri o tabloya yazıldığında, içine konur `data.Format` bu alt dizinde dosya. + +Bu alt klasörü ve dosyayı sunucu dosya sisteminde el ile oluşturabilir ve sonra [ATTACH](../../../sql_reference/statements/misc.md) eşleşen ada sahip tablo bilgilerine, böylece bu dosyadan veri sorgulayabilirsiniz. + +!!! warning "Uyarıcı" + Bu işlevselliğe dikkat edin, çünkü ClickHouse bu tür dosyalarda harici değişiklikleri izlemez. ClickHouse ve ClickHouse dışında eşzamanlı yazma sonucu tanımsızdır. + +**Örnek:** + +**1.** Set up the `file_engine_table` Tablo: + +``` sql +CREATE TABLE file_engine_table (name String, value UInt32) ENGINE=File(TabSeparated) +``` + +Varsayılan olarak ClickHouse klasör oluşturur `/var/lib/clickhouse/data/default/file_engine_table`. + +**2.** El ile oluştur `/var/lib/clickhouse/data/default/file_engine_table/data.TabSeparated` içerme: + +``` bash +$ cat data.TabSeparated +one 1 +two 2 +``` + +**3.** Verileri sorgula: + +``` sql +SELECT * FROM file_engine_table +``` + +``` text +┌─name─┬─value─┐ +│ one │ 1 │ +│ two │ 2 │ +└──────┴───────┘ +``` + +## Clickhouse'da kullanım-yerel {#usage-in-clickhouse-local} + +İçinde [clickhouse-yerel](../../../operations/utilities/clickhouse-local.md) Dosya motoru ek olarak dosya yolunu kabul eder `Format`. Varsayılan giriş / çıkış akışları gibi sayısal veya insan tarafından okunabilir isimler kullanılarak belirtilebilir `0` veya `stdin`, `1` veya `stdout`. +**Örnek:** + +``` bash +$ echo -e "1,2\n3,4" | clickhouse-local -q "CREATE TABLE table (a Int64, b Int64) ENGINE = File(CSV, stdin); SELECT a, b FROM table; DROP TABLE table" +``` + +## Uygulama Detayları {#details-of-implementation} + +- Çoklu `SELECT` sorgular aynı anda yapılabilir, ancak `INSERT` sorgular birbirini bekler. +- Tarafından yeni dosya oluşturma desteklenen `INSERT` sorgu. +- Dosya varsa, `INSERT` içinde yeni değerler ekler. +- Desteklenmiyor: + - `ALTER` + - `SELECT ... SAMPLE` + - Dizinler + - Çoğalma + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/file/) diff --git a/docs/tr/engines/table_engines/special/generate.md b/docs/tr/engines/table_engines/special/generate.md new file mode 100644 index 00000000000..01d2534441e --- /dev/null +++ b/docs/tr/engines/table_engines/special/generate.md @@ -0,0 +1,61 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 46 +toc_title: GenerateRandom +--- + +# Generaterandom {#table_engines-generate} + +GenerateRandom tablo motoru, verilen tablo şeması için rasgele veri üretir. + +Kullanım örnekleri: + +- Tekrarlanabilir büyük tabloyu doldurmak için testte kullanın. +- Fuzzing testleri için rastgele girdi oluşturun. + +## ClickHouse Sunucusunda Kullanım {#usage-in-clickhouse-server} + +``` sql +ENGINE = GenerateRandom(random_seed, max_string_length, max_array_length) +``` + +Bu `max_array_length` ve `max_string_length` parametreler tüm maksimum uzunluğu belirtin +oluşturulan verilerde dizi sütunları ve dizeleri. + +Tablo motoru oluşturmak yalnızca destekler `SELECT` sorgular. + +Tüm destekler [Veri türleri](../../../sql_reference/data_types/index.md) dışında bir tabloda saklanabilir `LowCardinality` ve `AggregateFunction`. + +**Örnek:** + +**1.** Set up the `generate_engine_table` Tablo: + +``` sql +CREATE TABLE generate_engine_table (name String, value UInt32) ENGINE = GenerateRandom(1, 5, 3) +``` + +**2.** Verileri sorgula: + +``` sql +SELECT * FROM generate_engine_table LIMIT 3 +``` + +``` text +┌─name─┬──────value─┐ +│ c4xJ │ 1412771199 │ +│ r │ 1791099446 │ +│ 7#$ │ 124312908 │ +└──────┴────────────┘ +``` + +## Uygulama Detayları {#details-of-implementation} + +- Desteklenmiyor: + - `ALTER` + - `SELECT ... SAMPLE` + - `INSERT` + - Dizinler + - Çoğalma + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/generate/) diff --git a/docs/tr/engines/table_engines/special/index.md b/docs/tr/engines/table_engines/special/index.md new file mode 100644 index 00000000000..2e754a86bc8 --- /dev/null +++ b/docs/tr/engines/table_engines/special/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "\xD6zellikli" +toc_priority: 31 +--- + + diff --git a/docs/tr/engines/table_engines/special/join.md b/docs/tr/engines/table_engines/special/join.md new file mode 100644 index 00000000000..2fa786148e0 --- /dev/null +++ b/docs/tr/engines/table_engines/special/join.md @@ -0,0 +1,111 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 40 +toc_title: Katmak +--- + +# Katmak {#join} + +Kullanılmak üzere hazırlanmış veri yapısı [JOIN](../../../sql_reference/statements/select.md#select-join) harekat. + +## Tablo oluşturma {#creating-a-table} + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1] [TTL expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2] [TTL expr2], +) ENGINE = Join(join_strictness, join_type, k1[, k2, ...]) +``` + +Ayrıntılı açıklamasına bakın [CREATE TABLE](../../../sql_reference/statements/create.md#create-table-query) sorgu. + +**Motor Parametreleri** + +- `join_strictness` – [Katılık katılın](../../../sql_reference/statements/select.md#select-join-strictness). +- `join_type` – [Birleştirme türü](../../../sql_reference/statements/select.md#select-join-types). +- `k1[, k2, ...]` – Key columns from the `USING` fık thera: `JOIN` işlemi yapılmamaktadır. + +Girmek `join_strictness` ve `join_type` tırnak işaretleri olmadan parametreler, örneğin, `Join(ANY, LEFT, col1)`. Onlar eşleşmelidir `JOIN` tablo için kullanılacak işlem. Parametreler eşleşmezse, ClickHouse bir istisna atmaz ve yanlış veri döndürebilir. + +## Tablo Kullanımı {#table-usage} + +### Örnek {#example} + +Sol taraftaki tablo oluşturma: + +``` sql +CREATE TABLE id_val(`id` UInt32, `val` UInt32) ENGINE = TinyLog +``` + +``` sql +INSERT INTO id_val VALUES (1,11)(2,12)(3,13) +``` + +Sağ tarafı oluşturma `Join` Tablo: + +``` sql +CREATE TABLE id_val_join(`id` UInt32, `val` UInt8) ENGINE = Join(ANY, LEFT, id) +``` + +``` sql +INSERT INTO id_val_join VALUES (1,21)(1,22)(3,23) +``` + +Tabloları birleştirme: + +``` sql +SELECT * FROM id_val ANY LEFT JOIN id_val_join USING (id) SETTINGS join_use_nulls = 1 +``` + +``` text +┌─id─┬─val─┬─id_val_join.val─┐ +│ 1 │ 11 │ 21 │ +│ 2 │ 12 │ ᴺᵁᴸᴸ │ +│ 3 │ 13 │ 23 │ +└────┴─────┴─────────────────┘ +``` + +Alternatif olarak, veri alabilirsiniz `Join` tablo, birleştirme anahtarı değerini belirterek: + +``` sql +SELECT joinGet('id_val_join', 'val', toUInt32(1)) +``` + +``` text +┌─joinGet('id_val_join', 'val', toUInt32(1))─┐ +│ 21 │ +└────────────────────────────────────────────┘ +``` + +### Veri seçme ve ekleme {#selecting-and-inserting-data} + +Kullanabilirsiniz `INSERT` veri eklemek için sorgular `Join`- motor masaları. Tablo ile oluşturulmuş ise `ANY` katılık, yinelenen anahtarlar için veriler göz ardı edilir. İle... `ALL` katılık, tüm satırlar eklenir. + +Gerçekleştir aemezsiniz `SELECT` doğrudan tablodan sorgulayın. Bunun yerine, aşağıdaki yöntemlerden birini kullanın: + +- Tabloyu sağ tarafa yerleştirin. `JOIN` yan. +- Call the [joinGet](../../../sql_reference/functions/other_functions.md#joinget) tablodan bir sözlükten aynı şekilde veri ayıklamanızı sağlayan işlev. + +### Sınırlamalar ve Ayarlar {#join-limitations-and-settings} + +Bir tablo oluştururken aşağıdaki ayarlar uygulanır: + +- [join\_use\_nulls](../../../operations/settings/settings.md#join_use_nulls) +- [max\_rows\_in\_join](../../../operations/settings/query_complexity.md#settings-max_rows_in_join) +- [max\_bytes\_in\_join](../../../operations/settings/query_complexity.md#settings-max_bytes_in_join) +- [join\_overflow\_mode](../../../operations/settings/query_complexity.md#settings-join_overflow_mode) +- [join\_any\_take\_last\_row](../../../operations/settings/settings.md#settings-join_any_take_last_row) + +Bu `Join`- motor tabloları kullanılamaz `GLOBAL JOIN` harekat. + +Bu `Join`- motor kullanımına izin verir [join\_use\_nulls](../../../operations/settings/settings.md#join_use_nulls) ayarı `CREATE TABLE` deyim. Ve [SELECT](../../../sql_reference/statements/select.md) sorgu kullanımına izin verir `join_use_nulls` çok. Eğer farklı varsa `join_use_nulls` ayarlar, tablo birleştirme bir hata alabilirsiniz. Bu katılmak türüne bağlıdır. Kullandığınızda [joinGet](../../../sql_reference/functions/other_functions.md#joinget) fonksiyonu, aynı kullanmak zorunda `join_use_nulls` ayarı `CRATE TABLE` ve `SELECT` deyimler. + +## Veri Depolama {#data-storage} + +`Join` tablo verileri her zaman RAM'de bulunur. Bir tabloya satır eklerken, sunucu yeniden başlatıldığında geri yüklenebilir, böylece ClickHouse disk üzerindeki dizine veri bloklarını yazar. + +Sunucu yanlış yeniden başlatılırsa, diskteki veri bloğu kaybolabilir veya zarar görebilir. Bu durumda, dosyayı hasarlı verilerle el ile silmeniz gerekebilir. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/join/) diff --git a/docs/tr/engines/table_engines/special/materializedview.md b/docs/tr/engines/table_engines/special/materializedview.md new file mode 100644 index 00000000000..23e7d3122eb --- /dev/null +++ b/docs/tr/engines/table_engines/special/materializedview.md @@ -0,0 +1,12 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 43 +toc_title: MaterializedView +--- + +# Materializedview {#materializedview} + +Somut görünümler uygulamak için kullanılır (Daha fazla bilgi için bkz . [CREATE TABLE](../../../sql_reference/statements/create.md)). Verileri depolamak için, görünümü oluştururken belirtilen farklı bir motor kullanır. Bir tablodan okurken, sadece bu motoru kullanır. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/materializedview/) diff --git a/docs/tr/engines/table_engines/special/memory.md b/docs/tr/engines/table_engines/special/memory.md new file mode 100644 index 00000000000..a5f985ff5e2 --- /dev/null +++ b/docs/tr/engines/table_engines/special/memory.md @@ -0,0 +1,19 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 44 +toc_title: Bellek +--- + +# Bellek {#memory} + +Bellek altyapısı verileri RAM, sıkıştırılmamış biçimde depolar. Veri okunduğunda alınan tam olarak aynı biçimde saklanır. Başka bir deyişle, bu tablodan okuma tamamen ücretsizdir. +Eşzamanlı veri erişimi senkronize edilir. Kilitler kısa: okuma ve yazma işlemleri birbirini engellemez. +Dizinler desteklenmiyor. Okuma paralelleştirilmiştir. +Basit sorgularda maksimum üretkenliğe (10 GB/sn'den fazla) ulaşılır, çünkü diskten okuma, açma veya veri serisini kaldırma yoktur. (Birçok durumda MergeTree motorunun verimliliğinin neredeyse yüksek olduğunu unutmamalıyız.) +Bir sunucu yeniden başlatılırken, veri tablodan kaybolur ve tablo boş olur. +Normalde, bu tablo motorunu kullanmak haklı değildir. Bununla birlikte, testler ve nispeten az sayıda satırda (yaklaşık 100.000.000'a kadar) maksimum hızın gerekli olduğu görevler için kullanılabilir. + +Bellek motoru, harici sorgu verilerine sahip geçici tablolar için sistem tarafından kullanılır (bkz. “External data for processing a query”) ve GLOBAL In uygulanması için (bkz. “IN operators”). + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/memory/) diff --git a/docs/tr/engines/table_engines/special/merge.md b/docs/tr/engines/table_engines/special/merge.md new file mode 100644 index 00000000000..bd4150e1afb --- /dev/null +++ b/docs/tr/engines/table_engines/special/merge.md @@ -0,0 +1,70 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 36 +toc_title: "Birle\u015Ftirmek" +--- + +# Birleştirmek {#merge} + +Bu `Merge` motor (ile karıştırılmamalıdır `MergeTree`) verileri kendisi saklamaz, ancak aynı anda herhangi bir sayıda başka tablodan okumaya izin verir. +Okuma otomatik olarak paralelleştirilir. Bir tabloya yazma desteklenmiyor. Okurken, gerçekten okunmakta olan tabloların dizinleri varsa kullanılır. +Bu `Merge` motor parametreleri kabul eder: veritabanı adı ve tablolar için düzenli ifade. + +Örnek: + +``` sql +Merge(hits, '^WatchLog') +``` + +Veri tablolardan okunacak `hits` düzenli ifadeyle eşleşen adlara sahip veritabanı ‘`^WatchLog`’. + +Veritabanı adı yerine, bir dize döndüren sabit bir ifade kullanabilirsiniz. Mesela, `currentDatabase()`. + +Regular expressions — [re2](https://github.com/google/re2) (pcre bir alt kümesini destekler), büyük / küçük harf duyarlı. +Düzenli ifadelerde kaçan sembollerle ilgili notlara bakın “match” bölme. + +Okumak için tabloları seçerken, `Merge` regex ile eşleşse bile tablonun kendisi seçilmeyecektir. Bu döngülerden kaçınmaktır. +İki tane oluşturmak mümkündür `Merge` sonsuza kadar birbirlerinin verilerini okumaya çalışacak tablolar, ancak bu iyi bir fikir değil. + +Kullanmak için tipik bir yol `Merge` motor çok sayıda çalışma içindir `TinyLog` tablolar tek bir tablo ile sanki. + +Örnek 2: + +Diyelim ki eski bir tablonuz (WatchLog\_old) var ve verileri yeni bir tabloya (WatchLog\_new) taşımadan bölümlemeyi değiştirmeye karar verdiniz ve her iki tablodaki verileri görmeniz gerekiyor. + +``` sql +CREATE TABLE WatchLog_old(date Date, UserId Int64, EventType String, Cnt UInt64) +ENGINE=MergeTree(date, (UserId, EventType), 8192); +INSERT INTO WatchLog_old VALUES ('2018-01-01', 1, 'hit', 3); + +CREATE TABLE WatchLog_new(date Date, UserId Int64, EventType String, Cnt UInt64) +ENGINE=MergeTree PARTITION BY date ORDER BY (UserId, EventType) SETTINGS index_granularity=8192; +INSERT INTO WatchLog_new VALUES ('2018-01-02', 2, 'hit', 3); + +CREATE TABLE WatchLog as WatchLog_old ENGINE=Merge(currentDatabase(), '^WatchLog'); + +SELECT * +FROM WatchLog +``` + +``` text +┌───────date─┬─UserId─┬─EventType─┬─Cnt─┐ +│ 2018-01-01 │ 1 │ hit │ 3 │ +└────────────┴────────┴───────────┴─────┘ +┌───────date─┬─UserId─┬─EventType─┬─Cnt─┐ +│ 2018-01-02 │ 2 │ hit │ 3 │ +└────────────┴────────┴───────────┴─────┘ +``` + +## Sanal Sütunlar {#virtual-columns} + +- `_table` — Contains the name of the table from which data was read. Type: [Dize](../../../sql_reference/data_types/string.md). + + Sabit koşulları ayarlayabilirsiniz `_table` in the `WHERE/PREWHERE` fıkra (sı (örneğin, `WHERE _table='xyz'`). Bu durumda, okuma işlemi yalnızca koşulun açık olduğu tablolar için gerçekleştirilir `_table` memnun olduğunu, bu yüzden `_table` sütun bir dizin görevi görür. + +**Ayrıca Bakınız** + +- [Sanal sütunlar](index.md#table_engines-virtual_columns) + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/merge/) diff --git a/docs/tr/engines/table_engines/special/null.md b/docs/tr/engines/table_engines/special/null.md new file mode 100644 index 00000000000..19d518f415f --- /dev/null +++ b/docs/tr/engines/table_engines/special/null.md @@ -0,0 +1,14 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 38 +toc_title: "Bo\u015F" +--- + +# Boş {#null} + +Boş bir tabloya yazarken, veri yoksayılır. Boş bir tablodan okurken, yanıt boştur. + +Ancak, boş bir tablo üzerinde materialized bir görünüm oluşturabilirsiniz. Böylece tabloya yazılan veriler görünümde sona erecek. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/null/) diff --git a/docs/tr/engines/table_engines/special/set.md b/docs/tr/engines/table_engines/special/set.md new file mode 100644 index 00000000000..af94ada6e12 --- /dev/null +++ b/docs/tr/engines/table_engines/special/set.md @@ -0,0 +1,19 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 39 +toc_title: Koymak +--- + +# Koymak {#set} + +Her zaman RAM olan bir veri kümesi. In operatörünün sağ tarafında kullanılmak üzere tasarlanmıştır (bölüme bakın “IN operators”). + +Tabloya veri eklemek için INSERT kullanabilirsiniz. Veri kümesine yeni öğeler eklenirken, yinelenenler göz ardı edilir. +Ancak tablodan seçim yapamazsınız. Verileri almak için tek yol, IN operatörünün sağ yarısında kullanmaktır. + +Veri her zaman RAM yer almaktadır. INSERT için, eklenen veri blokları da diskteki tabloların dizinine yazılır. Sunucuyu başlatırken, bu veriler RAM'e yüklenir. Başka bir deyişle, yeniden başlattıktan sonra veriler yerinde kalır. + +Kaba bir sunucu yeniden başlatma için diskteki veri bloğu kaybolabilir veya zarar görebilir. İkinci durumda, dosyayı hasarlı verilerle el ile silmeniz gerekebilir. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/set/) diff --git a/docs/tr/engines/table_engines/special/url.md b/docs/tr/engines/table_engines/special/url.md new file mode 100644 index 00000000000..51657248e75 --- /dev/null +++ b/docs/tr/engines/table_engines/special/url.md @@ -0,0 +1,82 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 41 +toc_title: URL +--- + +# URL (URL, Biçim) {#table_engines-url} + +Uzak bir HTTP/HTTPS sunucusundaki verileri yönetir. Bu motor benzer +to the [Dosya](file.md) motor. + +## ClickHouse sunucusunda motoru kullanma {#using-the-engine-in-the-clickhouse-server} + +Bu `format` Clickhouse'un kullanabileceği bir tane olmalı +`SELECT` sorgular ve gerekirse `INSERTs`. Desteklenen formatların tam listesi için bkz. +[Biçimliler](../../../interfaces/formats.md#formats). + +Bu `URL` tekdüzen bir kaynak Bulucu yapısına uygun olmalıdır. Belirtilen URL bir sunucuya işaret etmelidir +bu HTTP veya HTTPS kullanır. Bu herhangi bir gerektirmez +sunucudan yanıt almak için ek başlıklar. + +`INSERT` ve `SELECT` sorgular dönüştürülür `POST` ve `GET` istemler, +sırasıyla. İşleme için `POST` istekleri, uzak sunucu desteklemesi gerekir +[Yığınlı aktarım kodlaması](https://en.wikipedia.org/wiki/Chunked_transfer_encoding). + +Kullanarak HTTP get yönlendirme şerbetçiotu sayısını sınırlayabilirsiniz [max\_http\_get\_redirects](../../../operations/settings/settings.md#setting-max_http_get_redirects) ayar. + +**Örnek:** + +**1.** Create a `url_engine_table` sunucuda tablo : + +``` sql +CREATE TABLE url_engine_table (word String, value UInt64) +ENGINE=URL('http://127.0.0.1:12345/', CSV) +``` + +**2.** Standart Python 3 araçlarını kullanarak temel bir HTTP Sunucusu oluşturun ve +Başlat: + +``` python3 +from http.server import BaseHTTPRequestHandler, HTTPServer + +class CSVHTTPServer(BaseHTTPRequestHandler): + def do_GET(self): + self.send_response(200) + self.send_header('Content-type', 'text/csv') + self.end_headers() + + self.wfile.write(bytes('Hello,1\nWorld,2\n', "utf-8")) + +if __name__ == "__main__": + server_address = ('127.0.0.1', 12345) + HTTPServer(server_address, CSVHTTPServer).serve_forever() +``` + +``` bash +$ python3 server.py +``` + +**3.** Veri iste: + +``` sql +SELECT * FROM url_engine_table +``` + +``` text +┌─word──┬─value─┐ +│ Hello │ 1 │ +│ World │ 2 │ +└───────┴───────┘ +``` + +## Uygulama Detayları {#details-of-implementation} + +- Okuma ve yazma paralel olabilir +- Desteklenmiyor: + - `ALTER` ve `SELECT...SAMPLE` harekat. + - Dizinler. + - Çoğalma. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/url/) diff --git a/docs/tr/engines/table_engines/special/view.md b/docs/tr/engines/table_engines/special/view.md new file mode 100644 index 00000000000..e3b46a7b926 --- /dev/null +++ b/docs/tr/engines/table_engines/special/view.md @@ -0,0 +1,12 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 42 +toc_title: "G\xF6r\xFCn\xFCm" +--- + +# Görünüm {#table_engines-view} + +Görünümler uygulamak için kullanılır (Daha fazla bilgi için bkz. `CREATE VIEW query`). Verileri saklamaz, ancak yalnızca belirtilen `SELECT` sorgu. Bir tablodan okurken, bu sorguyu çalıştırır (ve gereksiz tüm sütunları sorgudan siler). + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/table_engines/view/) diff --git a/docs/tr/faq/general.md b/docs/tr/faq/general.md new file mode 100644 index 00000000000..05779e132a9 --- /dev/null +++ b/docs/tr/faq/general.md @@ -0,0 +1,60 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 78 +toc_title: Genel Sorular +--- + +# Genel Sorular {#general-questions} + +## Neden MapReduce Gibi Bir Şey Kullanmıyorsun? {#why-not-use-something-like-mapreduce} + +Mapreduce gibi sistemlere, azaltma işleminin dağıtılmış sıralamaya dayandığı dağıtılmış bilgi işlem sistemleri olarak başvurabiliriz. Bu sınıftaki en yaygın açık kaynak çözümü [Apache Hadoop](http://hadoop.apache.org). Yandex, şirket içi çözümünü, YT'Yİ kullanıyor. + +Bu sistemler, yüksek gecikme süreleri nedeniyle çevrimiçi sorgular için uygun değildir. Başka bir deyişle, bir web arayüzü için arka uç olarak kullanılamazlar. Bu tür sistemler gerçek zamanlı veri güncellemeleri için yararlı değildir. Dağıtılmış sıralama, işlemin sonucu ve tüm ara sonuçlar (varsa) tek bir sunucunun RAM'İNDE bulunuyorsa, genellikle çevrimiçi sorgular için geçerli olan işlemleri azaltmanın en iyi yolu değildir. Böyle bir durumda, bir karma tablo azaltma işlemlerini gerçekleştirmek için en uygun yoldur. Harita azaltma görevlerini optimize etmek için ortak bir yaklaşım, RAM'de bir karma tablo kullanarak ön toplama (kısmi azaltma) ' dir. Kullanıcı bu optimizasyonu manuel olarak gerçekleştirir. Dağıtılmış sıralama, basit harita azaltma görevlerini çalıştırırken düşük performansın ana nedenlerinden biridir. + +Çoğu MapReduce uygulaması, bir kümede rasgele kod çalıştırmanıza izin verir. Ancak bildirimsel bir sorgu dili, deneyleri hızlı bir şekilde çalıştırmak için OLAP için daha uygundur. Örneğin, Hadoop kovanı ve domuz vardır. Ayrıca Spark için Cloudera Impala veya Shark'ı (modası geçmiş) ve Spark SQL, Presto ve Apache Drill'i de düşünün. Bu tür görevleri çalıştırırken performans, özel sistemlere kıyasla oldukça düşük bir seviyededir, ancak nispeten yüksek gecikme, bu sistemleri bir web arayüzü için arka uç olarak kullanmayı gerçekçi kılmaktadır. + +## Oracle aracılığıyla ODBC kullanırken Kodlamalarla ilgili bir sorunum varsa ne olur? {#oracle-odbc-encodings} + +Oracle ODBC sürücüsü aracılığıyla dış sözlükler kaynağı olarak kullanırsanız, doğru değeri ayarlamanız gerekir. `NLS_LANG` ortam değişkeni `/etc/default/clickhouse`. Daha fazla bilgi için, bkz: [Oracle NLS\_LANG SSS](https://www.oracle.com/technetwork/products/globalization/nls-lang-099431.html). + +**Örnek** + +``` sql +NLS_LANG=RUSSIAN_RUSSIA.UTF8 +``` + +## Clickhouse'dan bir dosyaya verileri nasıl dışa aktarırım? {#how-to-export-to-file} + +### INTO OUTFİLE yan tümcesini kullanma {#using-into-outfile-clause} + +Add an [INTO OUTFILE](../sql_reference/statements/select.md#into-outfile-clause) sorgunuza yan tümce. + +Mesela: + +``` sql +SELECT * FROM table INTO OUTFILE 'file' +``` + +Varsayılan olarak, ClickHouse kullanır [TabSeparated](../interfaces/formats.md#tabseparated) çıktı verileri için Biçim. Seçmek için [Veri formatı](../interfaces/formats.md), use the [FORMAT CLA clauseuse](../sql_reference/statements/select.md#format-clause). + +Mesela: + +``` sql +SELECT * FROM table INTO OUTFILE 'file' FORMAT CSV +``` + +### Dosya altyapısı tablosu kullanma {#using-a-file-engine-table} + +Görmek [Dosya](../engines/table_engines/special/file.md). + +### Komut Satırı Yeniden Yönlendirmesini Kullanma {#using-command-line-redirection} + +``` sql +$ clickhouse-client --query "SELECT * from table" --format FormatName > result.txt +``` + +Görmek [clickhouse-müşteri](../interfaces/cli.md). + +{## [Orijinal makale](https://clickhouse.tech/docs/en/faq/general/) ##} diff --git a/docs/tr/faq/index.md b/docs/tr/faq/index.md new file mode 100644 index 00000000000..591011fb66d --- /dev/null +++ b/docs/tr/faq/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: F.A.Q. +toc_priority: 76 +--- + + diff --git a/docs/tr/getting_started/example_datasets/amplab_benchmark.md b/docs/tr/getting_started/example_datasets/amplab_benchmark.md new file mode 100644 index 00000000000..e6f95df68b8 --- /dev/null +++ b/docs/tr/getting_started/example_datasets/amplab_benchmark.md @@ -0,0 +1,129 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 17 +toc_title: "AMPLab B\xFCy\xFCk Veri Benchmark" +--- + +# AMPLab Büyük Veri Benchmark {#amplab-big-data-benchmark} + +Bkz. https://amplab.cs.berkeley.edu/benchmark/ + +Ücretsiz bir hesap için kaydolun https://aws.amazon.com. bir kredi kartı, e-posta ve telefon numarası gerektirir. Yeni bir erişim anahtarı alın https://console.aws.amazon.com/iam/home?nc2=h\_m\_sc\#security\_credential + +Konsolda aşağıdakileri çalıştırın: + +``` bash +$ sudo apt-get install s3cmd +$ mkdir tiny; cd tiny; +$ s3cmd sync s3://big-data-benchmark/pavlo/text-deflate/tiny/ . +$ cd .. +$ mkdir 1node; cd 1node; +$ s3cmd sync s3://big-data-benchmark/pavlo/text-deflate/1node/ . +$ cd .. +$ mkdir 5nodes; cd 5nodes; +$ s3cmd sync s3://big-data-benchmark/pavlo/text-deflate/5nodes/ . +$ cd .. +``` + +Aşağıdaki ClickHouse sorguları çalıştırın: + +``` sql +CREATE TABLE rankings_tiny +( + pageURL String, + pageRank UInt32, + avgDuration UInt32 +) ENGINE = Log; + +CREATE TABLE uservisits_tiny +( + sourceIP String, + destinationURL String, + visitDate Date, + adRevenue Float32, + UserAgent String, + cCode FixedString(3), + lCode FixedString(6), + searchWord String, + duration UInt32 +) ENGINE = MergeTree(visitDate, visitDate, 8192); + +CREATE TABLE rankings_1node +( + pageURL String, + pageRank UInt32, + avgDuration UInt32 +) ENGINE = Log; + +CREATE TABLE uservisits_1node +( + sourceIP String, + destinationURL String, + visitDate Date, + adRevenue Float32, + UserAgent String, + cCode FixedString(3), + lCode FixedString(6), + searchWord String, + duration UInt32 +) ENGINE = MergeTree(visitDate, visitDate, 8192); + +CREATE TABLE rankings_5nodes_on_single +( + pageURL String, + pageRank UInt32, + avgDuration UInt32 +) ENGINE = Log; + +CREATE TABLE uservisits_5nodes_on_single +( + sourceIP String, + destinationURL String, + visitDate Date, + adRevenue Float32, + UserAgent String, + cCode FixedString(3), + lCode FixedString(6), + searchWord String, + duration UInt32 +) ENGINE = MergeTree(visitDate, visitDate, 8192); +``` + +Konsola geri dön: + +``` bash +$ for i in tiny/rankings/*.deflate; do echo $i; zlib-flate -uncompress < $i | clickhouse-client --host=example-perftest01j --query="INSERT INTO rankings_tiny FORMAT CSV"; done +$ for i in tiny/uservisits/*.deflate; do echo $i; zlib-flate -uncompress < $i | clickhouse-client --host=example-perftest01j --query="INSERT INTO uservisits_tiny FORMAT CSV"; done +$ for i in 1node/rankings/*.deflate; do echo $i; zlib-flate -uncompress < $i | clickhouse-client --host=example-perftest01j --query="INSERT INTO rankings_1node FORMAT CSV"; done +$ for i in 1node/uservisits/*.deflate; do echo $i; zlib-flate -uncompress < $i | clickhouse-client --host=example-perftest01j --query="INSERT INTO uservisits_1node FORMAT CSV"; done +$ for i in 5nodes/rankings/*.deflate; do echo $i; zlib-flate -uncompress < $i | clickhouse-client --host=example-perftest01j --query="INSERT INTO rankings_5nodes_on_single FORMAT CSV"; done +$ for i in 5nodes/uservisits/*.deflate; do echo $i; zlib-flate -uncompress < $i | clickhouse-client --host=example-perftest01j --query="INSERT INTO uservisits_5nodes_on_single FORMAT CSV"; done +``` + +Veri örnekleri almak için sorgular: + +``` sql +SELECT pageURL, pageRank FROM rankings_1node WHERE pageRank > 1000 + +SELECT substring(sourceIP, 1, 8), sum(adRevenue) FROM uservisits_1node GROUP BY substring(sourceIP, 1, 8) + +SELECT + sourceIP, + sum(adRevenue) AS totalRevenue, + avg(pageRank) AS pageRank +FROM rankings_1node ALL INNER JOIN +( + SELECT + sourceIP, + destinationURL AS pageURL, + adRevenue + FROM uservisits_1node + WHERE (visitDate > '1980-01-01') AND (visitDate < '1980-04-01') +) USING pageURL +GROUP BY sourceIP +ORDER BY totalRevenue DESC +LIMIT 1 +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/getting_started/example_datasets/amplab_benchmark/) diff --git a/docs/tr/getting_started/example_datasets/criteo.md b/docs/tr/getting_started/example_datasets/criteo.md new file mode 100644 index 00000000000..37cb2d2b0e6 --- /dev/null +++ b/docs/tr/getting_started/example_datasets/criteo.md @@ -0,0 +1,81 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 19 +toc_title: "Criteo'dan Terabyte t\u0131klama g\xFCnl\xFCkleri" +--- + +# Criteo'dan tıklama günlüklerinin terabayt {#terabyte-of-click-logs-from-criteo} + +Verileri indirin http://labs.criteo.com/downloads/download-terabyte-click-logs/ + +Günlük almak için bir tablo oluşturun: + +``` sql +CREATE TABLE criteo_log (date Date, clicked UInt8, int1 Int32, int2 Int32, int3 Int32, int4 Int32, int5 Int32, int6 Int32, int7 Int32, int8 Int32, int9 Int32, int10 Int32, int11 Int32, int12 Int32, int13 Int32, cat1 String, cat2 String, cat3 String, cat4 String, cat5 String, cat6 String, cat7 String, cat8 String, cat9 String, cat10 String, cat11 String, cat12 String, cat13 String, cat14 String, cat15 String, cat16 String, cat17 String, cat18 String, cat19 String, cat20 String, cat21 String, cat22 String, cat23 String, cat24 String, cat25 String, cat26 String) ENGINE = Log +``` + +Verileri indirin: + +``` bash +$ for i in {00..23}; do echo $i; zcat datasets/criteo/day_${i#0}.gz | sed -r 's/^/2000-01-'${i/00/24}'\t/' | clickhouse-client --host=example-perftest01j --query="INSERT INTO criteo_log FORMAT TabSeparated"; done +``` + +Dönüştürülen veriler için bir tablo oluşturma: + +``` sql +CREATE TABLE criteo +( + date Date, + clicked UInt8, + int1 Int32, + int2 Int32, + int3 Int32, + int4 Int32, + int5 Int32, + int6 Int32, + int7 Int32, + int8 Int32, + int9 Int32, + int10 Int32, + int11 Int32, + int12 Int32, + int13 Int32, + icat1 UInt32, + icat2 UInt32, + icat3 UInt32, + icat4 UInt32, + icat5 UInt32, + icat6 UInt32, + icat7 UInt32, + icat8 UInt32, + icat9 UInt32, + icat10 UInt32, + icat11 UInt32, + icat12 UInt32, + icat13 UInt32, + icat14 UInt32, + icat15 UInt32, + icat16 UInt32, + icat17 UInt32, + icat18 UInt32, + icat19 UInt32, + icat20 UInt32, + icat21 UInt32, + icat22 UInt32, + icat23 UInt32, + icat24 UInt32, + icat25 UInt32, + icat26 UInt32 +) ENGINE = MergeTree(date, intHash32(icat1), (date, intHash32(icat1)), 8192) +``` + +Verileri ham günlüğünden dönüştürün ve ikinci tabloya koyun: + +``` sql +INSERT INTO criteo SELECT date, clicked, int1, int2, int3, int4, int5, int6, int7, int8, int9, int10, int11, int12, int13, reinterpretAsUInt32(unhex(cat1)) AS icat1, reinterpretAsUInt32(unhex(cat2)) AS icat2, reinterpretAsUInt32(unhex(cat3)) AS icat3, reinterpretAsUInt32(unhex(cat4)) AS icat4, reinterpretAsUInt32(unhex(cat5)) AS icat5, reinterpretAsUInt32(unhex(cat6)) AS icat6, reinterpretAsUInt32(unhex(cat7)) AS icat7, reinterpretAsUInt32(unhex(cat8)) AS icat8, reinterpretAsUInt32(unhex(cat9)) AS icat9, reinterpretAsUInt32(unhex(cat10)) AS icat10, reinterpretAsUInt32(unhex(cat11)) AS icat11, reinterpretAsUInt32(unhex(cat12)) AS icat12, reinterpretAsUInt32(unhex(cat13)) AS icat13, reinterpretAsUInt32(unhex(cat14)) AS icat14, reinterpretAsUInt32(unhex(cat15)) AS icat15, reinterpretAsUInt32(unhex(cat16)) AS icat16, reinterpretAsUInt32(unhex(cat17)) AS icat17, reinterpretAsUInt32(unhex(cat18)) AS icat18, reinterpretAsUInt32(unhex(cat19)) AS icat19, reinterpretAsUInt32(unhex(cat20)) AS icat20, reinterpretAsUInt32(unhex(cat21)) AS icat21, reinterpretAsUInt32(unhex(cat22)) AS icat22, reinterpretAsUInt32(unhex(cat23)) AS icat23, reinterpretAsUInt32(unhex(cat24)) AS icat24, reinterpretAsUInt32(unhex(cat25)) AS icat25, reinterpretAsUInt32(unhex(cat26)) AS icat26 FROM criteo_log; + +DROP TABLE criteo_log; +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/getting_started/example_datasets/criteo/) diff --git a/docs/tr/getting_started/example_datasets/index.md b/docs/tr/getting_started/example_datasets/index.md new file mode 100644 index 00000000000..fecb39f219f --- /dev/null +++ b/docs/tr/getting_started/example_datasets/index.md @@ -0,0 +1,22 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "\xD6rnek Veri K\xFCmeleri" +toc_priority: 12 +toc_title: "Giri\u015F" +--- + +# Örnek Veri Kümeleri {#example-datasets} + +Bu bölümde, örnek veri kümelerinin nasıl elde edileceği ve bunları Clickhouse'a nasıl içe aktarılacağı açıklanmaktadır. +Bazı veri kümeleri için örnek sorgular da mevcuttur. + +- [Anonim Yandex.Metrica Veri Kümesi](metrica.md) +- [Yıldız Şema Ben Benchmarkch Benchmarkmark](star_schema.md) +- [WikiStat](wikistat.md) +- [Criteo'dan tıklama günlüklerinin terabayt](criteo.md) +- [AMPLab Büyük Veri Benchmark](amplab_benchmark.md) +- [New York Taksi Verileri](nyc_taxi.md) +- [OnTime](ontime.md) + +[Orijinal makale](https://clickhouse.tech/docs/en/getting_started/example_datasets) diff --git a/docs/tr/getting_started/example_datasets/metrica.md b/docs/tr/getting_started/example_datasets/metrica.md new file mode 100644 index 00000000000..a9d3d6743ee --- /dev/null +++ b/docs/tr/getting_started/example_datasets/metrica.md @@ -0,0 +1,70 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 21 +toc_title: "\xDCye.Metrica Verileri" +--- + +# Anonim Yandex.Metrica Verileri {#anonymized-yandex-metrica-data} + +Veri kümesi, isabetlerle ilgili anonimleştirilmiş verileri içeren iki tablodan oluşur (`hits_v1`) ve ziyaret visitsler (`visits_v1`(kayıt olmak için).Metrica. Yandex hakkında daha fazla bilgi edinebilirsiniz.Metrica içinde [ClickHouse geçmişi](../../introduction/history.md) bölme. + +Veri kümesi iki tablodan oluşur, bunlardan biri sıkıştırılmış olarak indirilebilir `tsv.xz` dosya veya hazırlanmış bölümler olarak. Buna ek olarak, genişletilmiş bir sürümü `hits` 100 milyon satır içeren tablo TSV olarak mevcuttur https://clickhouse-datasets.s3.yandex.net/hits/tsv/hits\_100m\_obfuscated\_v1.tsv.xz ve hazırlanan bölümler olarak https://clickhouse-datasets.s3.yandex.net/hits/partitions/hits\_100m\_obfuscated\_v1.tar.xz. + +## Hazırlanan bölümlerden tablolar elde etme {#obtaining-tables-from-prepared-partitions} + +İndirme ve ithalat tablo hits: + +``` bash +curl -O https://clickhouse-datasets.s3.yandex.net/hits/partitions/hits_v1.tar +tar xvf hits_v1.tar -C /var/lib/clickhouse # path to ClickHouse data directory +# check permissions on unpacked data, fix if required +sudo service clickhouse-server restart +clickhouse-client --query "SELECT COUNT(*) FROM datasets.hits_v1" +``` + +İndirme ve ithalat ziyaretleri: + +``` bash +curl -O https://clickhouse-datasets.s3.yandex.net/visits/partitions/visits_v1.tar +tar xvf visits_v1.tar -C /var/lib/clickhouse # path to ClickHouse data directory +# check permissions on unpacked data, fix if required +sudo service clickhouse-server restart +clickhouse-client --query "SELECT COUNT(*) FROM datasets.visits_v1" +``` + +## Sıkıştırılmış TSV dosyasından Tablo alma {#obtaining-tables-from-compressed-tsv-file} + +Sıkıştırılmış TSV dosyasından indir ve İçe Aktar: + +``` bash +curl https://clickhouse-datasets.s3.yandex.net/hits/tsv/hits_v1.tsv.xz | unxz --threads=`nproc` > hits_v1.tsv +# now create table +clickhouse-client --query "CREATE DATABASE IF NOT EXISTS datasets" +clickhouse-client --query "CREATE TABLE datasets.hits_v1 ( WatchID UInt64, JavaEnable UInt8, Title String, GoodEvent Int16, EventTime DateTime, EventDate Date, CounterID UInt32, ClientIP UInt32, ClientIP6 FixedString(16), RegionID UInt32, UserID UInt64, CounterClass Int8, OS UInt8, UserAgent UInt8, URL String, Referer String, URLDomain String, RefererDomain String, Refresh UInt8, IsRobot UInt8, RefererCategories Array(UInt16), URLCategories Array(UInt16), URLRegions Array(UInt32), RefererRegions Array(UInt32), ResolutionWidth UInt16, ResolutionHeight UInt16, ResolutionDepth UInt8, FlashMajor UInt8, FlashMinor UInt8, FlashMinor2 String, NetMajor UInt8, NetMinor UInt8, UserAgentMajor UInt16, UserAgentMinor FixedString(2), CookieEnable UInt8, JavascriptEnable UInt8, IsMobile UInt8, MobilePhone UInt8, MobilePhoneModel String, Params String, IPNetworkID UInt32, TraficSourceID Int8, SearchEngineID UInt16, SearchPhrase String, AdvEngineID UInt8, IsArtifical UInt8, WindowClientWidth UInt16, WindowClientHeight UInt16, ClientTimeZone Int16, ClientEventTime DateTime, SilverlightVersion1 UInt8, SilverlightVersion2 UInt8, SilverlightVersion3 UInt32, SilverlightVersion4 UInt16, PageCharset String, CodeVersion UInt32, IsLink UInt8, IsDownload UInt8, IsNotBounce UInt8, FUniqID UInt64, HID UInt32, IsOldCounter UInt8, IsEvent UInt8, IsParameter UInt8, DontCountHits UInt8, WithHash UInt8, HitColor FixedString(1), UTCEventTime DateTime, Age UInt8, Sex UInt8, Income UInt8, Interests UInt16, Robotness UInt8, GeneralInterests Array(UInt16), RemoteIP UInt32, RemoteIP6 FixedString(16), WindowName Int32, OpenerName Int32, HistoryLength Int16, BrowserLanguage FixedString(2), BrowserCountry FixedString(2), SocialNetwork String, SocialAction String, HTTPError UInt16, SendTiming Int32, DNSTiming Int32, ConnectTiming Int32, ResponseStartTiming Int32, ResponseEndTiming Int32, FetchTiming Int32, RedirectTiming Int32, DOMInteractiveTiming Int32, DOMContentLoadedTiming Int32, DOMCompleteTiming Int32, LoadEventStartTiming Int32, LoadEventEndTiming Int32, NSToDOMContentLoadedTiming Int32, FirstPaintTiming Int32, RedirectCount Int8, SocialSourceNetworkID UInt8, SocialSourcePage String, ParamPrice Int64, ParamOrderID String, ParamCurrency FixedString(3), ParamCurrencyID UInt16, GoalsReached Array(UInt32), OpenstatServiceName String, OpenstatCampaignID String, OpenstatAdID String, OpenstatSourceID String, UTMSource String, UTMMedium String, UTMCampaign String, UTMContent String, UTMTerm String, FromTag String, HasGCLID UInt8, RefererHash UInt64, URLHash UInt64, CLID UInt32, YCLID UInt64, ShareService String, ShareURL String, ShareTitle String, ParsedParams Nested(Key1 String, Key2 String, Key3 String, Key4 String, Key5 String, ValueDouble Float64), IslandID FixedString(16), RequestNum UInt32, RequestTry UInt8) ENGINE = MergeTree() PARTITION BY toYYYYMM(EventDate) ORDER BY (CounterID, EventDate, intHash32(UserID)) SAMPLE BY intHash32(UserID) SETTINGS index_granularity = 8192" +# import data +cat hits_v1.tsv | clickhouse-client --query "INSERT INTO datasets.hits_v1 FORMAT TSV" --max_insert_block_size=100000 +# optionally you can optimize table +clickhouse-client --query "OPTIMIZE TABLE datasets.hits_v1 FINAL" +clickhouse-client --query "SELECT COUNT(*) FROM datasets.hits_v1" +``` + +Sıkıştırılmış tsv dosyasından ziyaretleri indirin ve içe aktarın: + +``` bash +curl https://clickhouse-datasets.s3.yandex.net/visits/tsv/visits_v1.tsv.xz | unxz --threads=`nproc` > visits_v1.tsv +# now create table +clickhouse-client --query "CREATE DATABASE IF NOT EXISTS datasets" +clickhouse-client --query "CREATE TABLE datasets.visits_v1 ( CounterID UInt32, StartDate Date, Sign Int8, IsNew UInt8, VisitID UInt64, UserID UInt64, StartTime DateTime, Duration UInt32, UTCStartTime DateTime, PageViews Int32, Hits Int32, IsBounce UInt8, Referer String, StartURL String, RefererDomain String, StartURLDomain String, EndURL String, LinkURL String, IsDownload UInt8, TraficSourceID Int8, SearchEngineID UInt16, SearchPhrase String, AdvEngineID UInt8, PlaceID Int32, RefererCategories Array(UInt16), URLCategories Array(UInt16), URLRegions Array(UInt32), RefererRegions Array(UInt32), IsYandex UInt8, GoalReachesDepth Int32, GoalReachesURL Int32, GoalReachesAny Int32, SocialSourceNetworkID UInt8, SocialSourcePage String, MobilePhoneModel String, ClientEventTime DateTime, RegionID UInt32, ClientIP UInt32, ClientIP6 FixedString(16), RemoteIP UInt32, RemoteIP6 FixedString(16), IPNetworkID UInt32, SilverlightVersion3 UInt32, CodeVersion UInt32, ResolutionWidth UInt16, ResolutionHeight UInt16, UserAgentMajor UInt16, UserAgentMinor UInt16, WindowClientWidth UInt16, WindowClientHeight UInt16, SilverlightVersion2 UInt8, SilverlightVersion4 UInt16, FlashVersion3 UInt16, FlashVersion4 UInt16, ClientTimeZone Int16, OS UInt8, UserAgent UInt8, ResolutionDepth UInt8, FlashMajor UInt8, FlashMinor UInt8, NetMajor UInt8, NetMinor UInt8, MobilePhone UInt8, SilverlightVersion1 UInt8, Age UInt8, Sex UInt8, Income UInt8, JavaEnable UInt8, CookieEnable UInt8, JavascriptEnable UInt8, IsMobile UInt8, BrowserLanguage UInt16, BrowserCountry UInt16, Interests UInt16, Robotness UInt8, GeneralInterests Array(UInt16), Params Array(String), Goals Nested(ID UInt32, Serial UInt32, EventTime DateTime, Price Int64, OrderID String, CurrencyID UInt32), WatchIDs Array(UInt64), ParamSumPrice Int64, ParamCurrency FixedString(3), ParamCurrencyID UInt16, ClickLogID UInt64, ClickEventID Int32, ClickGoodEvent Int32, ClickEventTime DateTime, ClickPriorityID Int32, ClickPhraseID Int32, ClickPageID Int32, ClickPlaceID Int32, ClickTypeID Int32, ClickResourceID Int32, ClickCost UInt32, ClickClientIP UInt32, ClickDomainID UInt32, ClickURL String, ClickAttempt UInt8, ClickOrderID UInt32, ClickBannerID UInt32, ClickMarketCategoryID UInt32, ClickMarketPP UInt32, ClickMarketCategoryName String, ClickMarketPPName String, ClickAWAPSCampaignName String, ClickPageName String, ClickTargetType UInt16, ClickTargetPhraseID UInt64, ClickContextType UInt8, ClickSelectType Int8, ClickOptions String, ClickGroupBannerID Int32, OpenstatServiceName String, OpenstatCampaignID String, OpenstatAdID String, OpenstatSourceID String, UTMSource String, UTMMedium String, UTMCampaign String, UTMContent String, UTMTerm String, FromTag String, HasGCLID UInt8, FirstVisit DateTime, PredLastVisit Date, LastVisit Date, TotalVisits UInt32, TraficSource Nested(ID Int8, SearchEngineID UInt16, AdvEngineID UInt8, PlaceID UInt16, SocialSourceNetworkID UInt8, Domain String, SearchPhrase String, SocialSourcePage String), Attendance FixedString(16), CLID UInt32, YCLID UInt64, NormalizedRefererHash UInt64, SearchPhraseHash UInt64, RefererDomainHash UInt64, NormalizedStartURLHash UInt64, StartURLDomainHash UInt64, NormalizedEndURLHash UInt64, TopLevelDomain UInt64, URLScheme UInt64, OpenstatServiceNameHash UInt64, OpenstatCampaignIDHash UInt64, OpenstatAdIDHash UInt64, OpenstatSourceIDHash UInt64, UTMSourceHash UInt64, UTMMediumHash UInt64, UTMCampaignHash UInt64, UTMContentHash UInt64, UTMTermHash UInt64, FromHash UInt64, WebVisorEnabled UInt8, WebVisorActivity UInt32, ParsedParams Nested(Key1 String, Key2 String, Key3 String, Key4 String, Key5 String, ValueDouble Float64), Market Nested(Type UInt8, GoalID UInt32, OrderID String, OrderPrice Int64, PP UInt32, DirectPlaceID UInt32, DirectOrderID UInt32, DirectBannerID UInt32, GoodID String, GoodName String, GoodQuantity Int32, GoodPrice Int64), IslandID FixedString(16)) ENGINE = CollapsingMergeTree(Sign) PARTITION BY toYYYYMM(StartDate) ORDER BY (CounterID, StartDate, intHash32(UserID), VisitID) SAMPLE BY intHash32(UserID) SETTINGS index_granularity = 8192" +# import data +cat visits_v1.tsv | clickhouse-client --query "INSERT INTO datasets.visits_v1 FORMAT TSV" --max_insert_block_size=100000 +# optionally you can optimize table +clickhouse-client --query "OPTIMIZE TABLE datasets.visits_v1 FINAL" +clickhouse-client --query "SELECT COUNT(*) FROM datasets.visits_v1" +``` + +## Örnek Sorgular {#example-queries} + +[ClickHouse eğitimi](../../getting_started/tutorial.md) Yandex dayanmaktadır.Metrica veri kümesi ve bu veri kümesine başlamak için önerilen yol sadece öğreticiden geçmektir. + +Bu tablolara ek sorgu örnekleri arasında bulunabilir [durum bilgisi testleri](https://github.com/ClickHouse/ClickHouse/tree/master/tests/queries/1_stateful) ClickHouse of (onlar adlandırılır `test.hists` ve `test.visits` oralarda). diff --git a/docs/tr/getting_started/example_datasets/nyc_taxi.md b/docs/tr/getting_started/example_datasets/nyc_taxi.md new file mode 100644 index 00000000000..218a7f06f7a --- /dev/null +++ b/docs/tr/getting_started/example_datasets/nyc_taxi.md @@ -0,0 +1,390 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 16 +toc_title: New York Taksi Verileri +--- + +# New York Taksi Verileri {#new-york-taxi-data} + +Bu veri kümesi iki şekilde elde edilebilir: + +- ham verilerden içe aktarma +- hazırlanan bölüm downloadlerin indir downloadilmesi + +## Ham veri nasıl alınır {#how-to-import-the-raw-data} + +Bkz. https://github.com/toddwschneider/nyc-taxi-data ve http://tech.marksblogg.com/billion-nyc-taxi-rides-redshift.html bir veri kümesinin açıklaması ve indirme talimatları için. + +İndirme, CSV dosyalarında yaklaşık 227 GB sıkıştırılmamış veri ile sonuçlanacaktır. İndirme, 1 Gbit bağlantısı üzerinden yaklaşık bir saat sürer (paralel indirme s3.amazonaws.com 1 Gbit kanalın en az yarısını kurtarır). +Bazı dosyalar tam olarak indirilmeyebilir. Dosya boyutlarını kontrol edin ve şüpheli görünen herhangi birini yeniden indirin. + +Bazı dosyalar geçersiz satırlar içerebilir. Bunları aşağıdaki gibi düzeltebilirsiniz: + +``` bash +sed -E '/(.*,){18,}/d' data/yellow_tripdata_2010-02.csv > data/yellow_tripdata_2010-02.csv_ +sed -E '/(.*,){18,}/d' data/yellow_tripdata_2010-03.csv > data/yellow_tripdata_2010-03.csv_ +mv data/yellow_tripdata_2010-02.csv_ data/yellow_tripdata_2010-02.csv +mv data/yellow_tripdata_2010-03.csv_ data/yellow_tripdata_2010-03.csv +``` + +Daha sonra veriler Postgresql'de önceden işlenmelidir. Bu, çokgenlerdeki noktaların seçimlerini oluşturacaktır (Haritadaki noktaları New York şehrinin ilçeleriyle eşleştirmek için) ve tüm verileri bir birleştirme kullanarak tek bir denormalize düz tabloda birleştirecektir. Bunu yapmak için Postgresql'i Postgıs desteği ile yüklemeniz gerekir. + +Çalışırken dikkatli olun `initialize_database.sh` ve tüm tabloların doğru şekilde oluşturulduğunu manuel olarak yeniden kontrol edin. + +Postgresql'deki her ayın verilerini işlemek yaklaşık 20-30 dakika sürer, toplam yaklaşık 48 saat sürer. + +İndirilen satır sayısını aşağıdaki gibi kontrol edebilirsiniz: + +``` bash +$ time psql nyc-taxi-data -c "SELECT count(*) FROM trips;" +## Count + 1298979494 +(1 row) + +real 7m9.164s +``` + +(Bu, Mark Litwintschik tarafından bir dizi blog gönderisinde bildirilen 1.1 milyar satırdan biraz daha fazladır .) + +Postgresql'deki veriler 370 GB alan kullanıyor. + +PostgreSQL veri verme: + +``` sql +COPY +( + SELECT trips.id, + trips.vendor_id, + trips.pickup_datetime, + trips.dropoff_datetime, + trips.store_and_fwd_flag, + trips.rate_code_id, + trips.pickup_longitude, + trips.pickup_latitude, + trips.dropoff_longitude, + trips.dropoff_latitude, + trips.passenger_count, + trips.trip_distance, + trips.fare_amount, + trips.extra, + trips.mta_tax, + trips.tip_amount, + trips.tolls_amount, + trips.ehail_fee, + trips.improvement_surcharge, + trips.total_amount, + trips.payment_type, + trips.trip_type, + trips.pickup, + trips.dropoff, + + cab_types.type cab_type, + + weather.precipitation_tenths_of_mm rain, + weather.snow_depth_mm, + weather.snowfall_mm, + weather.max_temperature_tenths_degrees_celsius max_temp, + weather.min_temperature_tenths_degrees_celsius min_temp, + weather.average_wind_speed_tenths_of_meters_per_second wind, + + pick_up.gid pickup_nyct2010_gid, + pick_up.ctlabel pickup_ctlabel, + pick_up.borocode pickup_borocode, + pick_up.boroname pickup_boroname, + pick_up.ct2010 pickup_ct2010, + pick_up.boroct2010 pickup_boroct2010, + pick_up.cdeligibil pickup_cdeligibil, + pick_up.ntacode pickup_ntacode, + pick_up.ntaname pickup_ntaname, + pick_up.puma pickup_puma, + + drop_off.gid dropoff_nyct2010_gid, + drop_off.ctlabel dropoff_ctlabel, + drop_off.borocode dropoff_borocode, + drop_off.boroname dropoff_boroname, + drop_off.ct2010 dropoff_ct2010, + drop_off.boroct2010 dropoff_boroct2010, + drop_off.cdeligibil dropoff_cdeligibil, + drop_off.ntacode dropoff_ntacode, + drop_off.ntaname dropoff_ntaname, + drop_off.puma dropoff_puma + FROM trips + LEFT JOIN cab_types + ON trips.cab_type_id = cab_types.id + LEFT JOIN central_park_weather_observations_raw weather + ON weather.date = trips.pickup_datetime::date + LEFT JOIN nyct2010 pick_up + ON pick_up.gid = trips.pickup_nyct2010_gid + LEFT JOIN nyct2010 drop_off + ON drop_off.gid = trips.dropoff_nyct2010_gid +) TO '/opt/milovidov/nyc-taxi-data/trips.tsv'; +``` + +Veri anlık görüntüsü saniyede yaklaşık 50 MB hızında oluşturulur. Anlık görüntü oluştururken, PostgreSQL diskten saniyede yaklaşık 28 MB hızında okur. +Bu yaklaşık 5 saat sürer. Elde edilen TSV dosyası 590612904969 bayttır. + +Clickhouse'da geçici bir tablo oluşturma: + +``` sql +CREATE TABLE trips +( +trip_id UInt32, +vendor_id String, +pickup_datetime DateTime, +dropoff_datetime Nullable(DateTime), +store_and_fwd_flag Nullable(FixedString(1)), +rate_code_id Nullable(UInt8), +pickup_longitude Nullable(Float64), +pickup_latitude Nullable(Float64), +dropoff_longitude Nullable(Float64), +dropoff_latitude Nullable(Float64), +passenger_count Nullable(UInt8), +trip_distance Nullable(Float64), +fare_amount Nullable(Float32), +extra Nullable(Float32), +mta_tax Nullable(Float32), +tip_amount Nullable(Float32), +tolls_amount Nullable(Float32), +ehail_fee Nullable(Float32), +improvement_surcharge Nullable(Float32), +total_amount Nullable(Float32), +payment_type Nullable(String), +trip_type Nullable(UInt8), +pickup Nullable(String), +dropoff Nullable(String), +cab_type Nullable(String), +precipitation Nullable(UInt8), +snow_depth Nullable(UInt8), +snowfall Nullable(UInt8), +max_temperature Nullable(UInt8), +min_temperature Nullable(UInt8), +average_wind_speed Nullable(UInt8), +pickup_nyct2010_gid Nullable(UInt8), +pickup_ctlabel Nullable(String), +pickup_borocode Nullable(UInt8), +pickup_boroname Nullable(String), +pickup_ct2010 Nullable(String), +pickup_boroct2010 Nullable(String), +pickup_cdeligibil Nullable(FixedString(1)), +pickup_ntacode Nullable(String), +pickup_ntaname Nullable(String), +pickup_puma Nullable(String), +dropoff_nyct2010_gid Nullable(UInt8), +dropoff_ctlabel Nullable(String), +dropoff_borocode Nullable(UInt8), +dropoff_boroname Nullable(String), +dropoff_ct2010 Nullable(String), +dropoff_boroct2010 Nullable(String), +dropoff_cdeligibil Nullable(String), +dropoff_ntacode Nullable(String), +dropoff_ntaname Nullable(String), +dropoff_puma Nullable(String) +) ENGINE = Log; +``` + +Alanları daha doğru veri türlerine dönüştürmek ve mümkünse Boşları ortadan kaldırmak için gereklidir. + +``` bash +$ time clickhouse-client --query="INSERT INTO trips FORMAT TabSeparated" < trips.tsv + +real 75m56.214s +``` + +Veri 112-140 Mb/saniye hızında okunur. +Bir akışta bir günlük türü tablosuna veri yükleme 76 dakika sürdü. +Bu tablodaki veriler 142 GB kullanır. + +(Verileri doğrudan Postgres'ten içe aktarmak da mümkündür `COPY ... TO PROGRAM`.) + +Unfortunately, all the fields associated with the weather (precipitation…average\_wind\_speed) were filled with NULL. Because of this, we will remove them from the final data set. + +Başlamak için, tek bir sunucuda bir tablo oluşturacağız. Daha sonra tabloyu dağıtacağız. + +Özet Tablo oluşturma ve doldurma: + +``` sql +CREATE TABLE trips_mergetree +ENGINE = MergeTree(pickup_date, pickup_datetime, 8192) +AS SELECT + +trip_id, +CAST(vendor_id AS Enum8('1' = 1, '2' = 2, 'CMT' = 3, 'VTS' = 4, 'DDS' = 5, 'B02512' = 10, 'B02598' = 11, 'B02617' = 12, 'B02682' = 13, 'B02764' = 14)) AS vendor_id, +toDate(pickup_datetime) AS pickup_date, +ifNull(pickup_datetime, toDateTime(0)) AS pickup_datetime, +toDate(dropoff_datetime) AS dropoff_date, +ifNull(dropoff_datetime, toDateTime(0)) AS dropoff_datetime, +assumeNotNull(store_and_fwd_flag) IN ('Y', '1', '2') AS store_and_fwd_flag, +assumeNotNull(rate_code_id) AS rate_code_id, +assumeNotNull(pickup_longitude) AS pickup_longitude, +assumeNotNull(pickup_latitude) AS pickup_latitude, +assumeNotNull(dropoff_longitude) AS dropoff_longitude, +assumeNotNull(dropoff_latitude) AS dropoff_latitude, +assumeNotNull(passenger_count) AS passenger_count, +assumeNotNull(trip_distance) AS trip_distance, +assumeNotNull(fare_amount) AS fare_amount, +assumeNotNull(extra) AS extra, +assumeNotNull(mta_tax) AS mta_tax, +assumeNotNull(tip_amount) AS tip_amount, +assumeNotNull(tolls_amount) AS tolls_amount, +assumeNotNull(ehail_fee) AS ehail_fee, +assumeNotNull(improvement_surcharge) AS improvement_surcharge, +assumeNotNull(total_amount) AS total_amount, +CAST((assumeNotNull(payment_type) AS pt) IN ('CSH', 'CASH', 'Cash', 'CAS', 'Cas', '1') ? 'CSH' : (pt IN ('CRD', 'Credit', 'Cre', 'CRE', 'CREDIT', '2') ? 'CRE' : (pt IN ('NOC', 'No Charge', 'No', '3') ? 'NOC' : (pt IN ('DIS', 'Dispute', 'Dis', '4') ? 'DIS' : 'UNK'))) AS Enum8('CSH' = 1, 'CRE' = 2, 'UNK' = 0, 'NOC' = 3, 'DIS' = 4)) AS payment_type_, +assumeNotNull(trip_type) AS trip_type, +ifNull(toFixedString(unhex(pickup), 25), toFixedString('', 25)) AS pickup, +ifNull(toFixedString(unhex(dropoff), 25), toFixedString('', 25)) AS dropoff, +CAST(assumeNotNull(cab_type) AS Enum8('yellow' = 1, 'green' = 2, 'uber' = 3)) AS cab_type, + +assumeNotNull(pickup_nyct2010_gid) AS pickup_nyct2010_gid, +toFloat32(ifNull(pickup_ctlabel, '0')) AS pickup_ctlabel, +assumeNotNull(pickup_borocode) AS pickup_borocode, +CAST(assumeNotNull(pickup_boroname) AS Enum8('Manhattan' = 1, 'Queens' = 4, 'Brooklyn' = 3, '' = 0, 'Bronx' = 2, 'Staten Island' = 5)) AS pickup_boroname, +toFixedString(ifNull(pickup_ct2010, '000000'), 6) AS pickup_ct2010, +toFixedString(ifNull(pickup_boroct2010, '0000000'), 7) AS pickup_boroct2010, +CAST(assumeNotNull(ifNull(pickup_cdeligibil, ' ')) AS Enum8(' ' = 0, 'E' = 1, 'I' = 2)) AS pickup_cdeligibil, +toFixedString(ifNull(pickup_ntacode, '0000'), 4) AS pickup_ntacode, + +CAST(assumeNotNull(pickup_ntaname) AS Enum16('' = 0, 'Airport' = 1, 'Allerton-Pelham Gardens' = 2, 'Annadale-Huguenot-Prince\'s Bay-Eltingville' = 3, 'Arden Heights' = 4, 'Astoria' = 5, 'Auburndale' = 6, 'Baisley Park' = 7, 'Bath Beach' = 8, 'Battery Park City-Lower Manhattan' = 9, 'Bay Ridge' = 10, 'Bayside-Bayside Hills' = 11, 'Bedford' = 12, 'Bedford Park-Fordham North' = 13, 'Bellerose' = 14, 'Belmont' = 15, 'Bensonhurst East' = 16, 'Bensonhurst West' = 17, 'Borough Park' = 18, 'Breezy Point-Belle Harbor-Rockaway Park-Broad Channel' = 19, 'Briarwood-Jamaica Hills' = 20, 'Brighton Beach' = 21, 'Bronxdale' = 22, 'Brooklyn Heights-Cobble Hill' = 23, 'Brownsville' = 24, 'Bushwick North' = 25, 'Bushwick South' = 26, 'Cambria Heights' = 27, 'Canarsie' = 28, 'Carroll Gardens-Columbia Street-Red Hook' = 29, 'Central Harlem North-Polo Grounds' = 30, 'Central Harlem South' = 31, 'Charleston-Richmond Valley-Tottenville' = 32, 'Chinatown' = 33, 'Claremont-Bathgate' = 34, 'Clinton' = 35, 'Clinton Hill' = 36, 'Co-op City' = 37, 'College Point' = 38, 'Corona' = 39, 'Crotona Park East' = 40, 'Crown Heights North' = 41, 'Crown Heights South' = 42, 'Cypress Hills-City Line' = 43, 'DUMBO-Vinegar Hill-Downtown Brooklyn-Boerum Hill' = 44, 'Douglas Manor-Douglaston-Little Neck' = 45, 'Dyker Heights' = 46, 'East Concourse-Concourse Village' = 47, 'East Elmhurst' = 48, 'East Flatbush-Farragut' = 49, 'East Flushing' = 50, 'East Harlem North' = 51, 'East Harlem South' = 52, 'East New York' = 53, 'East New York (Pennsylvania Ave)' = 54, 'East Tremont' = 55, 'East Village' = 56, 'East Williamsburg' = 57, 'Eastchester-Edenwald-Baychester' = 58, 'Elmhurst' = 59, 'Elmhurst-Maspeth' = 60, 'Erasmus' = 61, 'Far Rockaway-Bayswater' = 62, 'Flatbush' = 63, 'Flatlands' = 64, 'Flushing' = 65, 'Fordham South' = 66, 'Forest Hills' = 67, 'Fort Greene' = 68, 'Fresh Meadows-Utopia' = 69, 'Ft. Totten-Bay Terrace-Clearview' = 70, 'Georgetown-Marine Park-Bergen Beach-Mill Basin' = 71, 'Glen Oaks-Floral Park-New Hyde Park' = 72, 'Glendale' = 73, 'Gramercy' = 74, 'Grasmere-Arrochar-Ft. Wadsworth' = 75, 'Gravesend' = 76, 'Great Kills' = 77, 'Greenpoint' = 78, 'Grymes Hill-Clifton-Fox Hills' = 79, 'Hamilton Heights' = 80, 'Hammels-Arverne-Edgemere' = 81, 'Highbridge' = 82, 'Hollis' = 83, 'Homecrest' = 84, 'Hudson Yards-Chelsea-Flatiron-Union Square' = 85, 'Hunters Point-Sunnyside-West Maspeth' = 86, 'Hunts Point' = 87, 'Jackson Heights' = 88, 'Jamaica' = 89, 'Jamaica Estates-Holliswood' = 90, 'Kensington-Ocean Parkway' = 91, 'Kew Gardens' = 92, 'Kew Gardens Hills' = 93, 'Kingsbridge Heights' = 94, 'Laurelton' = 95, 'Lenox Hill-Roosevelt Island' = 96, 'Lincoln Square' = 97, 'Lindenwood-Howard Beach' = 98, 'Longwood' = 99, 'Lower East Side' = 100, 'Madison' = 101, 'Manhattanville' = 102, 'Marble Hill-Inwood' = 103, 'Mariner\'s Harbor-Arlington-Port Ivory-Graniteville' = 104, 'Maspeth' = 105, 'Melrose South-Mott Haven North' = 106, 'Middle Village' = 107, 'Midtown-Midtown South' = 108, 'Midwood' = 109, 'Morningside Heights' = 110, 'Morrisania-Melrose' = 111, 'Mott Haven-Port Morris' = 112, 'Mount Hope' = 113, 'Murray Hill' = 114, 'Murray Hill-Kips Bay' = 115, 'New Brighton-Silver Lake' = 116, 'New Dorp-Midland Beach' = 117, 'New Springville-Bloomfield-Travis' = 118, 'North Corona' = 119, 'North Riverdale-Fieldston-Riverdale' = 120, 'North Side-South Side' = 121, 'Norwood' = 122, 'Oakland Gardens' = 123, 'Oakwood-Oakwood Beach' = 124, 'Ocean Hill' = 125, 'Ocean Parkway South' = 126, 'Old Astoria' = 127, 'Old Town-Dongan Hills-South Beach' = 128, 'Ozone Park' = 129, 'Park Slope-Gowanus' = 130, 'Parkchester' = 131, 'Pelham Bay-Country Club-City Island' = 132, 'Pelham Parkway' = 133, 'Pomonok-Flushing Heights-Hillcrest' = 134, 'Port Richmond' = 135, 'Prospect Heights' = 136, 'Prospect Lefferts Gardens-Wingate' = 137, 'Queens Village' = 138, 'Queensboro Hill' = 139, 'Queensbridge-Ravenswood-Long Island City' = 140, 'Rego Park' = 141, 'Richmond Hill' = 142, 'Ridgewood' = 143, 'Rikers Island' = 144, 'Rosedale' = 145, 'Rossville-Woodrow' = 146, 'Rugby-Remsen Village' = 147, 'Schuylerville-Throgs Neck-Edgewater Park' = 148, 'Seagate-Coney Island' = 149, 'Sheepshead Bay-Gerritsen Beach-Manhattan Beach' = 150, 'SoHo-TriBeCa-Civic Center-Little Italy' = 151, 'Soundview-Bruckner' = 152, 'Soundview-Castle Hill-Clason Point-Harding Park' = 153, 'South Jamaica' = 154, 'South Ozone Park' = 155, 'Springfield Gardens North' = 156, 'Springfield Gardens South-Brookville' = 157, 'Spuyten Duyvil-Kingsbridge' = 158, 'St. Albans' = 159, 'Stapleton-Rosebank' = 160, 'Starrett City' = 161, 'Steinway' = 162, 'Stuyvesant Heights' = 163, 'Stuyvesant Town-Cooper Village' = 164, 'Sunset Park East' = 165, 'Sunset Park West' = 166, 'Todt Hill-Emerson Hill-Heartland Village-Lighthouse Hill' = 167, 'Turtle Bay-East Midtown' = 168, 'University Heights-Morris Heights' = 169, 'Upper East Side-Carnegie Hill' = 170, 'Upper West Side' = 171, 'Van Cortlandt Village' = 172, 'Van Nest-Morris Park-Westchester Square' = 173, 'Washington Heights North' = 174, 'Washington Heights South' = 175, 'West Brighton' = 176, 'West Concourse' = 177, 'West Farms-Bronx River' = 178, 'West New Brighton-New Brighton-St. George' = 179, 'West Village' = 180, 'Westchester-Unionport' = 181, 'Westerleigh' = 182, 'Whitestone' = 183, 'Williamsbridge-Olinville' = 184, 'Williamsburg' = 185, 'Windsor Terrace' = 186, 'Woodhaven' = 187, 'Woodlawn-Wakefield' = 188, 'Woodside' = 189, 'Yorkville' = 190, 'park-cemetery-etc-Bronx' = 191, 'park-cemetery-etc-Brooklyn' = 192, 'park-cemetery-etc-Manhattan' = 193, 'park-cemetery-etc-Queens' = 194, 'park-cemetery-etc-Staten Island' = 195)) AS pickup_ntaname, + +toUInt16(ifNull(pickup_puma, '0')) AS pickup_puma, + +assumeNotNull(dropoff_nyct2010_gid) AS dropoff_nyct2010_gid, +toFloat32(ifNull(dropoff_ctlabel, '0')) AS dropoff_ctlabel, +assumeNotNull(dropoff_borocode) AS dropoff_borocode, +CAST(assumeNotNull(dropoff_boroname) AS Enum8('Manhattan' = 1, 'Queens' = 4, 'Brooklyn' = 3, '' = 0, 'Bronx' = 2, 'Staten Island' = 5)) AS dropoff_boroname, +toFixedString(ifNull(dropoff_ct2010, '000000'), 6) AS dropoff_ct2010, +toFixedString(ifNull(dropoff_boroct2010, '0000000'), 7) AS dropoff_boroct2010, +CAST(assumeNotNull(ifNull(dropoff_cdeligibil, ' ')) AS Enum8(' ' = 0, 'E' = 1, 'I' = 2)) AS dropoff_cdeligibil, +toFixedString(ifNull(dropoff_ntacode, '0000'), 4) AS dropoff_ntacode, + +CAST(assumeNotNull(dropoff_ntaname) AS Enum16('' = 0, 'Airport' = 1, 'Allerton-Pelham Gardens' = 2, 'Annadale-Huguenot-Prince\'s Bay-Eltingville' = 3, 'Arden Heights' = 4, 'Astoria' = 5, 'Auburndale' = 6, 'Baisley Park' = 7, 'Bath Beach' = 8, 'Battery Park City-Lower Manhattan' = 9, 'Bay Ridge' = 10, 'Bayside-Bayside Hills' = 11, 'Bedford' = 12, 'Bedford Park-Fordham North' = 13, 'Bellerose' = 14, 'Belmont' = 15, 'Bensonhurst East' = 16, 'Bensonhurst West' = 17, 'Borough Park' = 18, 'Breezy Point-Belle Harbor-Rockaway Park-Broad Channel' = 19, 'Briarwood-Jamaica Hills' = 20, 'Brighton Beach' = 21, 'Bronxdale' = 22, 'Brooklyn Heights-Cobble Hill' = 23, 'Brownsville' = 24, 'Bushwick North' = 25, 'Bushwick South' = 26, 'Cambria Heights' = 27, 'Canarsie' = 28, 'Carroll Gardens-Columbia Street-Red Hook' = 29, 'Central Harlem North-Polo Grounds' = 30, 'Central Harlem South' = 31, 'Charleston-Richmond Valley-Tottenville' = 32, 'Chinatown' = 33, 'Claremont-Bathgate' = 34, 'Clinton' = 35, 'Clinton Hill' = 36, 'Co-op City' = 37, 'College Point' = 38, 'Corona' = 39, 'Crotona Park East' = 40, 'Crown Heights North' = 41, 'Crown Heights South' = 42, 'Cypress Hills-City Line' = 43, 'DUMBO-Vinegar Hill-Downtown Brooklyn-Boerum Hill' = 44, 'Douglas Manor-Douglaston-Little Neck' = 45, 'Dyker Heights' = 46, 'East Concourse-Concourse Village' = 47, 'East Elmhurst' = 48, 'East Flatbush-Farragut' = 49, 'East Flushing' = 50, 'East Harlem North' = 51, 'East Harlem South' = 52, 'East New York' = 53, 'East New York (Pennsylvania Ave)' = 54, 'East Tremont' = 55, 'East Village' = 56, 'East Williamsburg' = 57, 'Eastchester-Edenwald-Baychester' = 58, 'Elmhurst' = 59, 'Elmhurst-Maspeth' = 60, 'Erasmus' = 61, 'Far Rockaway-Bayswater' = 62, 'Flatbush' = 63, 'Flatlands' = 64, 'Flushing' = 65, 'Fordham South' = 66, 'Forest Hills' = 67, 'Fort Greene' = 68, 'Fresh Meadows-Utopia' = 69, 'Ft. Totten-Bay Terrace-Clearview' = 70, 'Georgetown-Marine Park-Bergen Beach-Mill Basin' = 71, 'Glen Oaks-Floral Park-New Hyde Park' = 72, 'Glendale' = 73, 'Gramercy' = 74, 'Grasmere-Arrochar-Ft. Wadsworth' = 75, 'Gravesend' = 76, 'Great Kills' = 77, 'Greenpoint' = 78, 'Grymes Hill-Clifton-Fox Hills' = 79, 'Hamilton Heights' = 80, 'Hammels-Arverne-Edgemere' = 81, 'Highbridge' = 82, 'Hollis' = 83, 'Homecrest' = 84, 'Hudson Yards-Chelsea-Flatiron-Union Square' = 85, 'Hunters Point-Sunnyside-West Maspeth' = 86, 'Hunts Point' = 87, 'Jackson Heights' = 88, 'Jamaica' = 89, 'Jamaica Estates-Holliswood' = 90, 'Kensington-Ocean Parkway' = 91, 'Kew Gardens' = 92, 'Kew Gardens Hills' = 93, 'Kingsbridge Heights' = 94, 'Laurelton' = 95, 'Lenox Hill-Roosevelt Island' = 96, 'Lincoln Square' = 97, 'Lindenwood-Howard Beach' = 98, 'Longwood' = 99, 'Lower East Side' = 100, 'Madison' = 101, 'Manhattanville' = 102, 'Marble Hill-Inwood' = 103, 'Mariner\'s Harbor-Arlington-Port Ivory-Graniteville' = 104, 'Maspeth' = 105, 'Melrose South-Mott Haven North' = 106, 'Middle Village' = 107, 'Midtown-Midtown South' = 108, 'Midwood' = 109, 'Morningside Heights' = 110, 'Morrisania-Melrose' = 111, 'Mott Haven-Port Morris' = 112, 'Mount Hope' = 113, 'Murray Hill' = 114, 'Murray Hill-Kips Bay' = 115, 'New Brighton-Silver Lake' = 116, 'New Dorp-Midland Beach' = 117, 'New Springville-Bloomfield-Travis' = 118, 'North Corona' = 119, 'North Riverdale-Fieldston-Riverdale' = 120, 'North Side-South Side' = 121, 'Norwood' = 122, 'Oakland Gardens' = 123, 'Oakwood-Oakwood Beach' = 124, 'Ocean Hill' = 125, 'Ocean Parkway South' = 126, 'Old Astoria' = 127, 'Old Town-Dongan Hills-South Beach' = 128, 'Ozone Park' = 129, 'Park Slope-Gowanus' = 130, 'Parkchester' = 131, 'Pelham Bay-Country Club-City Island' = 132, 'Pelham Parkway' = 133, 'Pomonok-Flushing Heights-Hillcrest' = 134, 'Port Richmond' = 135, 'Prospect Heights' = 136, 'Prospect Lefferts Gardens-Wingate' = 137, 'Queens Village' = 138, 'Queensboro Hill' = 139, 'Queensbridge-Ravenswood-Long Island City' = 140, 'Rego Park' = 141, 'Richmond Hill' = 142, 'Ridgewood' = 143, 'Rikers Island' = 144, 'Rosedale' = 145, 'Rossville-Woodrow' = 146, 'Rugby-Remsen Village' = 147, 'Schuylerville-Throgs Neck-Edgewater Park' = 148, 'Seagate-Coney Island' = 149, 'Sheepshead Bay-Gerritsen Beach-Manhattan Beach' = 150, 'SoHo-TriBeCa-Civic Center-Little Italy' = 151, 'Soundview-Bruckner' = 152, 'Soundview-Castle Hill-Clason Point-Harding Park' = 153, 'South Jamaica' = 154, 'South Ozone Park' = 155, 'Springfield Gardens North' = 156, 'Springfield Gardens South-Brookville' = 157, 'Spuyten Duyvil-Kingsbridge' = 158, 'St. Albans' = 159, 'Stapleton-Rosebank' = 160, 'Starrett City' = 161, 'Steinway' = 162, 'Stuyvesant Heights' = 163, 'Stuyvesant Town-Cooper Village' = 164, 'Sunset Park East' = 165, 'Sunset Park West' = 166, 'Todt Hill-Emerson Hill-Heartland Village-Lighthouse Hill' = 167, 'Turtle Bay-East Midtown' = 168, 'University Heights-Morris Heights' = 169, 'Upper East Side-Carnegie Hill' = 170, 'Upper West Side' = 171, 'Van Cortlandt Village' = 172, 'Van Nest-Morris Park-Westchester Square' = 173, 'Washington Heights North' = 174, 'Washington Heights South' = 175, 'West Brighton' = 176, 'West Concourse' = 177, 'West Farms-Bronx River' = 178, 'West New Brighton-New Brighton-St. George' = 179, 'West Village' = 180, 'Westchester-Unionport' = 181, 'Westerleigh' = 182, 'Whitestone' = 183, 'Williamsbridge-Olinville' = 184, 'Williamsburg' = 185, 'Windsor Terrace' = 186, 'Woodhaven' = 187, 'Woodlawn-Wakefield' = 188, 'Woodside' = 189, 'Yorkville' = 190, 'park-cemetery-etc-Bronx' = 191, 'park-cemetery-etc-Brooklyn' = 192, 'park-cemetery-etc-Manhattan' = 193, 'park-cemetery-etc-Queens' = 194, 'park-cemetery-etc-Staten Island' = 195)) AS dropoff_ntaname, + +toUInt16(ifNull(dropoff_puma, '0')) AS dropoff_puma + +FROM trips +``` + +Bu, saniyede yaklaşık 428.000 satırlık bir hızda 3030 saniye sürer. +Daha hızlı yüklemek için, tablo ile oluşturabilirsiniz `Log` motor yerine `MergeTree`. Bu durumda, indirme 200 saniyeden daha hızlı çalışır. + +Tablo 126 GB disk alanı kullanır. + +``` sql +SELECT formatReadableSize(sum(bytes)) FROM system.parts WHERE table = 'trips_mergetree' AND active +``` + +``` text +┌─formatReadableSize(sum(bytes))─┐ +│ 126.18 GiB │ +└────────────────────────────────┘ +``` + +Diğer şeylerin yanı sıra, MERGETREE üzerinde en iyi duruma getirme sorgusunu çalıştırabilirsiniz. Ama her şey onsuz iyi olacak çünkü gerekli değildir. + +## Hazırlanan Bölüm downloadlerin indir downloadilmesi {#download-of-prepared-partitions} + +``` bash +$ curl -O https://clickhouse-datasets.s3.yandex.net/trips_mergetree/partitions/trips_mergetree.tar +$ tar xvf trips_mergetree.tar -C /var/lib/clickhouse # path to ClickHouse data directory +$ # check permissions of unpacked data, fix if required +$ sudo service clickhouse-server restart +$ clickhouse-client --query "select count(*) from datasets.trips_mergetree" +``` + +!!! info "Bilgin" + Aşağıda açıklanan sorguları çalıştıracaksanız, tam tablo adını kullanmanız gerekir, `datasets.trips_mergetree`. + +## Tek Server ile ilgili sonuçlar {#results-on-single-server} + +Q1: + +``` sql +SELECT cab_type, count(*) FROM trips_mergetree GROUP BY cab_type +``` + +0.490 saniye. + +Q2: + +``` sql +SELECT passenger_count, avg(total_amount) FROM trips_mergetree GROUP BY passenger_count +``` + +1.224 saniye. + +Q3: + +``` sql +SELECT passenger_count, toYear(pickup_date) AS year, count(*) FROM trips_mergetree GROUP BY passenger_count, year +``` + +2.104 saniye. + +Q4: + +``` sql +SELECT passenger_count, toYear(pickup_date) AS year, round(trip_distance) AS distance, count(*) +FROM trips_mergetree +GROUP BY passenger_count, year, distance +ORDER BY year, count(*) DESC +``` + +3.593 saniye. + +Aşağıdaki sunucu kullanıldı: + +İki Intel(R) Xeon(R) CPU E5-2650 v2 @ 2.60 GHz, 16 fiziksel çekirdekler toplam,128 GiB RAM,8x6 TB HD donanım RAID-5 + +Yürütme süresi üç koşunun en iyisidir. Ancak ikinci çalıştırmadan başlayarak, sorgular dosya sistemi önbelleğinden verileri okur. Başka önbelleğe alma oluşur: veri okundu ve her vadede işlenir. + +Üç sunucuda tablo oluşturma: + +Her sunucuda: + +``` sql +CREATE TABLE default.trips_mergetree_third ( trip_id UInt32, vendor_id Enum8('1' = 1, '2' = 2, 'CMT' = 3, 'VTS' = 4, 'DDS' = 5, 'B02512' = 10, 'B02598' = 11, 'B02617' = 12, 'B02682' = 13, 'B02764' = 14), pickup_date Date, pickup_datetime DateTime, dropoff_date Date, dropoff_datetime DateTime, store_and_fwd_flag UInt8, rate_code_id UInt8, pickup_longitude Float64, pickup_latitude Float64, dropoff_longitude Float64, dropoff_latitude Float64, passenger_count UInt8, trip_distance Float64, fare_amount Float32, extra Float32, mta_tax Float32, tip_amount Float32, tolls_amount Float32, ehail_fee Float32, improvement_surcharge Float32, total_amount Float32, payment_type_ Enum8('UNK' = 0, 'CSH' = 1, 'CRE' = 2, 'NOC' = 3, 'DIS' = 4), trip_type UInt8, pickup FixedString(25), dropoff FixedString(25), cab_type Enum8('yellow' = 1, 'green' = 2, 'uber' = 3), pickup_nyct2010_gid UInt8, pickup_ctlabel Float32, pickup_borocode UInt8, pickup_boroname Enum8('' = 0, 'Manhattan' = 1, 'Bronx' = 2, 'Brooklyn' = 3, 'Queens' = 4, 'Staten Island' = 5), pickup_ct2010 FixedString(6), pickup_boroct2010 FixedString(7), pickup_cdeligibil Enum8(' ' = 0, 'E' = 1, 'I' = 2), pickup_ntacode FixedString(4), pickup_ntaname Enum16('' = 0, 'Airport' = 1, 'Allerton-Pelham Gardens' = 2, 'Annadale-Huguenot-Prince\'s Bay-Eltingville' = 3, 'Arden Heights' = 4, 'Astoria' = 5, 'Auburndale' = 6, 'Baisley Park' = 7, 'Bath Beach' = 8, 'Battery Park City-Lower Manhattan' = 9, 'Bay Ridge' = 10, 'Bayside-Bayside Hills' = 11, 'Bedford' = 12, 'Bedford Park-Fordham North' = 13, 'Bellerose' = 14, 'Belmont' = 15, 'Bensonhurst East' = 16, 'Bensonhurst West' = 17, 'Borough Park' = 18, 'Breezy Point-Belle Harbor-Rockaway Park-Broad Channel' = 19, 'Briarwood-Jamaica Hills' = 20, 'Brighton Beach' = 21, 'Bronxdale' = 22, 'Brooklyn Heights-Cobble Hill' = 23, 'Brownsville' = 24, 'Bushwick North' = 25, 'Bushwick South' = 26, 'Cambria Heights' = 27, 'Canarsie' = 28, 'Carroll Gardens-Columbia Street-Red Hook' = 29, 'Central Harlem North-Polo Grounds' = 30, 'Central Harlem South' = 31, 'Charleston-Richmond Valley-Tottenville' = 32, 'Chinatown' = 33, 'Claremont-Bathgate' = 34, 'Clinton' = 35, 'Clinton Hill' = 36, 'Co-op City' = 37, 'College Point' = 38, 'Corona' = 39, 'Crotona Park East' = 40, 'Crown Heights North' = 41, 'Crown Heights South' = 42, 'Cypress Hills-City Line' = 43, 'DUMBO-Vinegar Hill-Downtown Brooklyn-Boerum Hill' = 44, 'Douglas Manor-Douglaston-Little Neck' = 45, 'Dyker Heights' = 46, 'East Concourse-Concourse Village' = 47, 'East Elmhurst' = 48, 'East Flatbush-Farragut' = 49, 'East Flushing' = 50, 'East Harlem North' = 51, 'East Harlem South' = 52, 'East New York' = 53, 'East New York (Pennsylvania Ave)' = 54, 'East Tremont' = 55, 'East Village' = 56, 'East Williamsburg' = 57, 'Eastchester-Edenwald-Baychester' = 58, 'Elmhurst' = 59, 'Elmhurst-Maspeth' = 60, 'Erasmus' = 61, 'Far Rockaway-Bayswater' = 62, 'Flatbush' = 63, 'Flatlands' = 64, 'Flushing' = 65, 'Fordham South' = 66, 'Forest Hills' = 67, 'Fort Greene' = 68, 'Fresh Meadows-Utopia' = 69, 'Ft. Totten-Bay Terrace-Clearview' = 70, 'Georgetown-Marine Park-Bergen Beach-Mill Basin' = 71, 'Glen Oaks-Floral Park-New Hyde Park' = 72, 'Glendale' = 73, 'Gramercy' = 74, 'Grasmere-Arrochar-Ft. Wadsworth' = 75, 'Gravesend' = 76, 'Great Kills' = 77, 'Greenpoint' = 78, 'Grymes Hill-Clifton-Fox Hills' = 79, 'Hamilton Heights' = 80, 'Hammels-Arverne-Edgemere' = 81, 'Highbridge' = 82, 'Hollis' = 83, 'Homecrest' = 84, 'Hudson Yards-Chelsea-Flatiron-Union Square' = 85, 'Hunters Point-Sunnyside-West Maspeth' = 86, 'Hunts Point' = 87, 'Jackson Heights' = 88, 'Jamaica' = 89, 'Jamaica Estates-Holliswood' = 90, 'Kensington-Ocean Parkway' = 91, 'Kew Gardens' = 92, 'Kew Gardens Hills' = 93, 'Kingsbridge Heights' = 94, 'Laurelton' = 95, 'Lenox Hill-Roosevelt Island' = 96, 'Lincoln Square' = 97, 'Lindenwood-Howard Beach' = 98, 'Longwood' = 99, 'Lower East Side' = 100, 'Madison' = 101, 'Manhattanville' = 102, 'Marble Hill-Inwood' = 103, 'Mariner\'s Harbor-Arlington-Port Ivory-Graniteville' = 104, 'Maspeth' = 105, 'Melrose South-Mott Haven North' = 106, 'Middle Village' = 107, 'Midtown-Midtown South' = 108, 'Midwood' = 109, 'Morningside Heights' = 110, 'Morrisania-Melrose' = 111, 'Mott Haven-Port Morris' = 112, 'Mount Hope' = 113, 'Murray Hill' = 114, 'Murray Hill-Kips Bay' = 115, 'New Brighton-Silver Lake' = 116, 'New Dorp-Midland Beach' = 117, 'New Springville-Bloomfield-Travis' = 118, 'North Corona' = 119, 'North Riverdale-Fieldston-Riverdale' = 120, 'North Side-South Side' = 121, 'Norwood' = 122, 'Oakland Gardens' = 123, 'Oakwood-Oakwood Beach' = 124, 'Ocean Hill' = 125, 'Ocean Parkway South' = 126, 'Old Astoria' = 127, 'Old Town-Dongan Hills-South Beach' = 128, 'Ozone Park' = 129, 'Park Slope-Gowanus' = 130, 'Parkchester' = 131, 'Pelham Bay-Country Club-City Island' = 132, 'Pelham Parkway' = 133, 'Pomonok-Flushing Heights-Hillcrest' = 134, 'Port Richmond' = 135, 'Prospect Heights' = 136, 'Prospect Lefferts Gardens-Wingate' = 137, 'Queens Village' = 138, 'Queensboro Hill' = 139, 'Queensbridge-Ravenswood-Long Island City' = 140, 'Rego Park' = 141, 'Richmond Hill' = 142, 'Ridgewood' = 143, 'Rikers Island' = 144, 'Rosedale' = 145, 'Rossville-Woodrow' = 146, 'Rugby-Remsen Village' = 147, 'Schuylerville-Throgs Neck-Edgewater Park' = 148, 'Seagate-Coney Island' = 149, 'Sheepshead Bay-Gerritsen Beach-Manhattan Beach' = 150, 'SoHo-TriBeCa-Civic Center-Little Italy' = 151, 'Soundview-Bruckner' = 152, 'Soundview-Castle Hill-Clason Point-Harding Park' = 153, 'South Jamaica' = 154, 'South Ozone Park' = 155, 'Springfield Gardens North' = 156, 'Springfield Gardens South-Brookville' = 157, 'Spuyten Duyvil-Kingsbridge' = 158, 'St. Albans' = 159, 'Stapleton-Rosebank' = 160, 'Starrett City' = 161, 'Steinway' = 162, 'Stuyvesant Heights' = 163, 'Stuyvesant Town-Cooper Village' = 164, 'Sunset Park East' = 165, 'Sunset Park West' = 166, 'Todt Hill-Emerson Hill-Heartland Village-Lighthouse Hill' = 167, 'Turtle Bay-East Midtown' = 168, 'University Heights-Morris Heights' = 169, 'Upper East Side-Carnegie Hill' = 170, 'Upper West Side' = 171, 'Van Cortlandt Village' = 172, 'Van Nest-Morris Park-Westchester Square' = 173, 'Washington Heights North' = 174, 'Washington Heights South' = 175, 'West Brighton' = 176, 'West Concourse' = 177, 'West Farms-Bronx River' = 178, 'West New Brighton-New Brighton-St. George' = 179, 'West Village' = 180, 'Westchester-Unionport' = 181, 'Westerleigh' = 182, 'Whitestone' = 183, 'Williamsbridge-Olinville' = 184, 'Williamsburg' = 185, 'Windsor Terrace' = 186, 'Woodhaven' = 187, 'Woodlawn-Wakefield' = 188, 'Woodside' = 189, 'Yorkville' = 190, 'park-cemetery-etc-Bronx' = 191, 'park-cemetery-etc-Brooklyn' = 192, 'park-cemetery-etc-Manhattan' = 193, 'park-cemetery-etc-Queens' = 194, 'park-cemetery-etc-Staten Island' = 195), pickup_puma UInt16, dropoff_nyct2010_gid UInt8, dropoff_ctlabel Float32, dropoff_borocode UInt8, dropoff_boroname Enum8('' = 0, 'Manhattan' = 1, 'Bronx' = 2, 'Brooklyn' = 3, 'Queens' = 4, 'Staten Island' = 5), dropoff_ct2010 FixedString(6), dropoff_boroct2010 FixedString(7), dropoff_cdeligibil Enum8(' ' = 0, 'E' = 1, 'I' = 2), dropoff_ntacode FixedString(4), dropoff_ntaname Enum16('' = 0, 'Airport' = 1, 'Allerton-Pelham Gardens' = 2, 'Annadale-Huguenot-Prince\'s Bay-Eltingville' = 3, 'Arden Heights' = 4, 'Astoria' = 5, 'Auburndale' = 6, 'Baisley Park' = 7, 'Bath Beach' = 8, 'Battery Park City-Lower Manhattan' = 9, 'Bay Ridge' = 10, 'Bayside-Bayside Hills' = 11, 'Bedford' = 12, 'Bedford Park-Fordham North' = 13, 'Bellerose' = 14, 'Belmont' = 15, 'Bensonhurst East' = 16, 'Bensonhurst West' = 17, 'Borough Park' = 18, 'Breezy Point-Belle Harbor-Rockaway Park-Broad Channel' = 19, 'Briarwood-Jamaica Hills' = 20, 'Brighton Beach' = 21, 'Bronxdale' = 22, 'Brooklyn Heights-Cobble Hill' = 23, 'Brownsville' = 24, 'Bushwick North' = 25, 'Bushwick South' = 26, 'Cambria Heights' = 27, 'Canarsie' = 28, 'Carroll Gardens-Columbia Street-Red Hook' = 29, 'Central Harlem North-Polo Grounds' = 30, 'Central Harlem South' = 31, 'Charleston-Richmond Valley-Tottenville' = 32, 'Chinatown' = 33, 'Claremont-Bathgate' = 34, 'Clinton' = 35, 'Clinton Hill' = 36, 'Co-op City' = 37, 'College Point' = 38, 'Corona' = 39, 'Crotona Park East' = 40, 'Crown Heights North' = 41, 'Crown Heights South' = 42, 'Cypress Hills-City Line' = 43, 'DUMBO-Vinegar Hill-Downtown Brooklyn-Boerum Hill' = 44, 'Douglas Manor-Douglaston-Little Neck' = 45, 'Dyker Heights' = 46, 'East Concourse-Concourse Village' = 47, 'East Elmhurst' = 48, 'East Flatbush-Farragut' = 49, 'East Flushing' = 50, 'East Harlem North' = 51, 'East Harlem South' = 52, 'East New York' = 53, 'East New York (Pennsylvania Ave)' = 54, 'East Tremont' = 55, 'East Village' = 56, 'East Williamsburg' = 57, 'Eastchester-Edenwald-Baychester' = 58, 'Elmhurst' = 59, 'Elmhurst-Maspeth' = 60, 'Erasmus' = 61, 'Far Rockaway-Bayswater' = 62, 'Flatbush' = 63, 'Flatlands' = 64, 'Flushing' = 65, 'Fordham South' = 66, 'Forest Hills' = 67, 'Fort Greene' = 68, 'Fresh Meadows-Utopia' = 69, 'Ft. Totten-Bay Terrace-Clearview' = 70, 'Georgetown-Marine Park-Bergen Beach-Mill Basin' = 71, 'Glen Oaks-Floral Park-New Hyde Park' = 72, 'Glendale' = 73, 'Gramercy' = 74, 'Grasmere-Arrochar-Ft. Wadsworth' = 75, 'Gravesend' = 76, 'Great Kills' = 77, 'Greenpoint' = 78, 'Grymes Hill-Clifton-Fox Hills' = 79, 'Hamilton Heights' = 80, 'Hammels-Arverne-Edgemere' = 81, 'Highbridge' = 82, 'Hollis' = 83, 'Homecrest' = 84, 'Hudson Yards-Chelsea-Flatiron-Union Square' = 85, 'Hunters Point-Sunnyside-West Maspeth' = 86, 'Hunts Point' = 87, 'Jackson Heights' = 88, 'Jamaica' = 89, 'Jamaica Estates-Holliswood' = 90, 'Kensington-Ocean Parkway' = 91, 'Kew Gardens' = 92, 'Kew Gardens Hills' = 93, 'Kingsbridge Heights' = 94, 'Laurelton' = 95, 'Lenox Hill-Roosevelt Island' = 96, 'Lincoln Square' = 97, 'Lindenwood-Howard Beach' = 98, 'Longwood' = 99, 'Lower East Side' = 100, 'Madison' = 101, 'Manhattanville' = 102, 'Marble Hill-Inwood' = 103, 'Mariner\'s Harbor-Arlington-Port Ivory-Graniteville' = 104, 'Maspeth' = 105, 'Melrose South-Mott Haven North' = 106, 'Middle Village' = 107, 'Midtown-Midtown South' = 108, 'Midwood' = 109, 'Morningside Heights' = 110, 'Morrisania-Melrose' = 111, 'Mott Haven-Port Morris' = 112, 'Mount Hope' = 113, 'Murray Hill' = 114, 'Murray Hill-Kips Bay' = 115, 'New Brighton-Silver Lake' = 116, 'New Dorp-Midland Beach' = 117, 'New Springville-Bloomfield-Travis' = 118, 'North Corona' = 119, 'North Riverdale-Fieldston-Riverdale' = 120, 'North Side-South Side' = 121, 'Norwood' = 122, 'Oakland Gardens' = 123, 'Oakwood-Oakwood Beach' = 124, 'Ocean Hill' = 125, 'Ocean Parkway South' = 126, 'Old Astoria' = 127, 'Old Town-Dongan Hills-South Beach' = 128, 'Ozone Park' = 129, 'Park Slope-Gowanus' = 130, 'Parkchester' = 131, 'Pelham Bay-Country Club-City Island' = 132, 'Pelham Parkway' = 133, 'Pomonok-Flushing Heights-Hillcrest' = 134, 'Port Richmond' = 135, 'Prospect Heights' = 136, 'Prospect Lefferts Gardens-Wingate' = 137, 'Queens Village' = 138, 'Queensboro Hill' = 139, 'Queensbridge-Ravenswood-Long Island City' = 140, 'Rego Park' = 141, 'Richmond Hill' = 142, 'Ridgewood' = 143, 'Rikers Island' = 144, 'Rosedale' = 145, 'Rossville-Woodrow' = 146, 'Rugby-Remsen Village' = 147, 'Schuylerville-Throgs Neck-Edgewater Park' = 148, 'Seagate-Coney Island' = 149, 'Sheepshead Bay-Gerritsen Beach-Manhattan Beach' = 150, 'SoHo-TriBeCa-Civic Center-Little Italy' = 151, 'Soundview-Bruckner' = 152, 'Soundview-Castle Hill-Clason Point-Harding Park' = 153, 'South Jamaica' = 154, 'South Ozone Park' = 155, 'Springfield Gardens North' = 156, 'Springfield Gardens South-Brookville' = 157, 'Spuyten Duyvil-Kingsbridge' = 158, 'St. Albans' = 159, 'Stapleton-Rosebank' = 160, 'Starrett City' = 161, 'Steinway' = 162, 'Stuyvesant Heights' = 163, 'Stuyvesant Town-Cooper Village' = 164, 'Sunset Park East' = 165, 'Sunset Park West' = 166, 'Todt Hill-Emerson Hill-Heartland Village-Lighthouse Hill' = 167, 'Turtle Bay-East Midtown' = 168, 'University Heights-Morris Heights' = 169, 'Upper East Side-Carnegie Hill' = 170, 'Upper West Side' = 171, 'Van Cortlandt Village' = 172, 'Van Nest-Morris Park-Westchester Square' = 173, 'Washington Heights North' = 174, 'Washington Heights South' = 175, 'West Brighton' = 176, 'West Concourse' = 177, 'West Farms-Bronx River' = 178, 'West New Brighton-New Brighton-St. George' = 179, 'West Village' = 180, 'Westchester-Unionport' = 181, 'Westerleigh' = 182, 'Whitestone' = 183, 'Williamsbridge-Olinville' = 184, 'Williamsburg' = 185, 'Windsor Terrace' = 186, 'Woodhaven' = 187, 'Woodlawn-Wakefield' = 188, 'Woodside' = 189, 'Yorkville' = 190, 'park-cemetery-etc-Bronx' = 191, 'park-cemetery-etc-Brooklyn' = 192, 'park-cemetery-etc-Manhattan' = 193, 'park-cemetery-etc-Queens' = 194, 'park-cemetery-etc-Staten Island' = 195), dropoff_puma UInt16) ENGINE = MergeTree(pickup_date, pickup_datetime, 8192) +``` + +Kaynak sunucuda: + +``` sql +CREATE TABLE trips_mergetree_x3 AS trips_mergetree_third ENGINE = Distributed(perftest, default, trips_mergetree_third, rand()) +``` + +Aşağıdaki sorgu verileri yeniden dağıtır: + +``` sql +INSERT INTO trips_mergetree_x3 SELECT * FROM trips_mergetree +``` + +Bu 2454 saniye sürer. + +Üç sunucuda: + +Q1: 0.212 saniye. +Q2: 0.438 saniye. +Q3: 0.733 saniye. +Q4: 1.241 saniye. + +Sorgular doğrusal olarak ölçeklendiğinden, burada sürpriz yok. + +Ayrıca 140 sunucu kümesinden elde edilen sonuçlara sahibiz: + +Q1: 0.028 sn. +Q2: 0.043 sn. +Q3: 0.051 sn. +Q4: 0.072 sn. + +Bu durumda, sorgu işleme süresi her şeyden önce ağ gecikmesi ile belirlenir. +Finlandiya'daki bir Yandex veri merkezinde bulunan ve Rusya'daki bir kümede bulunan ve yaklaşık 20 ms gecikme süresi ekleyen bir istemci kullanarak sorgular çalıştırdık. + +## Özet {#summary} + +| hizmetçiler | Q1 | Q2 | Q3 | Q4 | +|-------------|-------|-------|-------|-------| +| 1 | 0.490 | 1.224 | 2.104 | 3.593 | +| 3 | 0.212 | 0.438 | 0.733 | 1.241 | +| 140 | 0.028 | 0.043 | 0.051 | 0.072 | + +[Orijinal makale](https://clickhouse.tech/docs/en/getting_started/example_datasets/nyc_taxi/) diff --git a/docs/tr/getting_started/example_datasets/ontime.md b/docs/tr/getting_started/example_datasets/ontime.md new file mode 100644 index 00000000000..dc06b86189f --- /dev/null +++ b/docs/tr/getting_started/example_datasets/ontime.md @@ -0,0 +1,412 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 15 +toc_title: OnTime +--- + +# OnTime {#ontime} + +Bu veri kümesi iki şekilde elde edilebilir: + +- ham verilerden içe aktarma +- hazırlanan bölüm downloadlerin indir downloadilmesi + +## Ham Verilerden İçe Aktarma {#import-from-raw-data} + +Veri indirme: + +``` bash +for s in `seq 1987 2018` +do +for m in `seq 1 12` +do +wget https://transtats.bts.gov/PREZIP/On_Time_Reporting_Carrier_On_Time_Performance_1987_present_${s}_${m}.zip +done +done +``` + +(from https://github.com/Percona-Lab/ontime-airline-performance/blob/master/download.sh ) + +Tablo oluşturma: + +``` sql +CREATE TABLE `ontime` ( + `Year` UInt16, + `Quarter` UInt8, + `Month` UInt8, + `DayofMonth` UInt8, + `DayOfWeek` UInt8, + `FlightDate` Date, + `UniqueCarrier` FixedString(7), + `AirlineID` Int32, + `Carrier` FixedString(2), + `TailNum` String, + `FlightNum` String, + `OriginAirportID` Int32, + `OriginAirportSeqID` Int32, + `OriginCityMarketID` Int32, + `Origin` FixedString(5), + `OriginCityName` String, + `OriginState` FixedString(2), + `OriginStateFips` String, + `OriginStateName` String, + `OriginWac` Int32, + `DestAirportID` Int32, + `DestAirportSeqID` Int32, + `DestCityMarketID` Int32, + `Dest` FixedString(5), + `DestCityName` String, + `DestState` FixedString(2), + `DestStateFips` String, + `DestStateName` String, + `DestWac` Int32, + `CRSDepTime` Int32, + `DepTime` Int32, + `DepDelay` Int32, + `DepDelayMinutes` Int32, + `DepDel15` Int32, + `DepartureDelayGroups` String, + `DepTimeBlk` String, + `TaxiOut` Int32, + `WheelsOff` Int32, + `WheelsOn` Int32, + `TaxiIn` Int32, + `CRSArrTime` Int32, + `ArrTime` Int32, + `ArrDelay` Int32, + `ArrDelayMinutes` Int32, + `ArrDel15` Int32, + `ArrivalDelayGroups` Int32, + `ArrTimeBlk` String, + `Cancelled` UInt8, + `CancellationCode` FixedString(1), + `Diverted` UInt8, + `CRSElapsedTime` Int32, + `ActualElapsedTime` Int32, + `AirTime` Int32, + `Flights` Int32, + `Distance` Int32, + `DistanceGroup` UInt8, + `CarrierDelay` Int32, + `WeatherDelay` Int32, + `NASDelay` Int32, + `SecurityDelay` Int32, + `LateAircraftDelay` Int32, + `FirstDepTime` String, + `TotalAddGTime` String, + `LongestAddGTime` String, + `DivAirportLandings` String, + `DivReachedDest` String, + `DivActualElapsedTime` String, + `DivArrDelay` String, + `DivDistance` String, + `Div1Airport` String, + `Div1AirportID` Int32, + `Div1AirportSeqID` Int32, + `Div1WheelsOn` String, + `Div1TotalGTime` String, + `Div1LongestGTime` String, + `Div1WheelsOff` String, + `Div1TailNum` String, + `Div2Airport` String, + `Div2AirportID` Int32, + `Div2AirportSeqID` Int32, + `Div2WheelsOn` String, + `Div2TotalGTime` String, + `Div2LongestGTime` String, + `Div2WheelsOff` String, + `Div2TailNum` String, + `Div3Airport` String, + `Div3AirportID` Int32, + `Div3AirportSeqID` Int32, + `Div3WheelsOn` String, + `Div3TotalGTime` String, + `Div3LongestGTime` String, + `Div3WheelsOff` String, + `Div3TailNum` String, + `Div4Airport` String, + `Div4AirportID` Int32, + `Div4AirportSeqID` Int32, + `Div4WheelsOn` String, + `Div4TotalGTime` String, + `Div4LongestGTime` String, + `Div4WheelsOff` String, + `Div4TailNum` String, + `Div5Airport` String, + `Div5AirportID` Int32, + `Div5AirportSeqID` Int32, + `Div5WheelsOn` String, + `Div5TotalGTime` String, + `Div5LongestGTime` String, + `Div5WheelsOff` String, + `Div5TailNum` String +) ENGINE = MergeTree +PARTITION BY Year +ORDER BY (Carrier, FlightDate) +SETTINGS index_granularity = 8192; +``` + +Veri yükleme: + +``` bash +$ for i in *.zip; do echo $i; unzip -cq $i '*.csv' | sed 's/\.00//g' | clickhouse-client --host=example-perftest01j --query="INSERT INTO ontime FORMAT CSVWithNames"; done +``` + +## Hazırlanan Bölüm downloadlerin indir downloadilmesi {#download-of-prepared-partitions} + +``` bash +$ curl -O https://clickhouse-datasets.s3.yandex.net/ontime/partitions/ontime.tar +$ tar xvf ontime.tar -C /var/lib/clickhouse # path to ClickHouse data directory +$ # check permissions of unpacked data, fix if required +$ sudo service clickhouse-server restart +$ clickhouse-client --query "select count(*) from datasets.ontime" +``` + +!!! info "Bilgin" + Aşağıda açıklanan sorguları çalıştıracaksanız, tam tablo adını kullanmanız gerekir, `datasets.ontime`. + +## Sorgular {#queries} + +Q0. + +``` sql +SELECT avg(c1) +FROM +( + SELECT Year, Month, count(*) AS c1 + FROM ontime + GROUP BY Year, Month +); +``` + +Q1. 2000 yılından 2008 yılına kadar günlük uçuş sayısı + +``` sql +SELECT DayOfWeek, count(*) AS c +FROM ontime +WHERE Year>=2000 AND Year<=2008 +GROUP BY DayOfWeek +ORDER BY c DESC; +``` + +S2. 2000-2008 için haftanın gününe göre gruplandırılmış 10 dakikadan fazla geciken uçuş sayısı + +``` sql +SELECT DayOfWeek, count(*) AS c +FROM ontime +WHERE DepDelay>10 AND Year>=2000 AND Year<=2008 +GROUP BY DayOfWeek +ORDER BY c DESC; +``` + +Q3. 2000-2008 için havaalanı tarafından gecikme sayısı + +``` sql +SELECT Origin, count(*) AS c +FROM ontime +WHERE DepDelay>10 AND Year>=2000 AND Year<=2008 +GROUP BY Origin +ORDER BY c DESC +LIMIT 10; +``` + +S4. 2007 yılı için taşıyıcı tarafından gecikme sayısı + +``` sql +SELECT Carrier, count(*) +FROM ontime +WHERE DepDelay>10 AND Year=2007 +GROUP BY Carrier +ORDER BY count(*) DESC; +``` + +Q5. 2007 yılı için taşıyıcı tarafından gecikme yüzdesi + +``` sql +SELECT Carrier, c, c2, c*100/c2 as c3 +FROM +( + SELECT + Carrier, + count(*) AS c + FROM ontime + WHERE DepDelay>10 + AND Year=2007 + GROUP BY Carrier +) +JOIN +( + SELECT + Carrier, + count(*) AS c2 + FROM ontime + WHERE Year=2007 + GROUP BY Carrier +) USING Carrier +ORDER BY c3 DESC; +``` + +Aynı sorgunun daha iyi sürümü: + +``` sql +SELECT Carrier, avg(DepDelay>10)*100 AS c3 +FROM ontime +WHERE Year=2007 +GROUP BY Carrier +ORDER BY c3 DESC +``` + +S6. Daha geniş bir yıl aralığı için önceki talep, 2000-2008 + +``` sql +SELECT Carrier, c, c2, c*100/c2 as c3 +FROM +( + SELECT + Carrier, + count(*) AS c + FROM ontime + WHERE DepDelay>10 + AND Year>=2000 AND Year<=2008 + GROUP BY Carrier +) +JOIN +( + SELECT + Carrier, + count(*) AS c2 + FROM ontime + WHERE Year>=2000 AND Year<=2008 + GROUP BY Carrier +) USING Carrier +ORDER BY c3 DESC; +``` + +Aynı sorgunun daha iyi sürümü: + +``` sql +SELECT Carrier, avg(DepDelay>10)*100 AS c3 +FROM ontime +WHERE Year>=2000 AND Year<=2008 +GROUP BY Carrier +ORDER BY c3 DESC; +``` + +Q7. Yıla göre 10 dakikadan fazla gecikmeli uçuş yüzdesi + +``` sql +SELECT Year, c1/c2 +FROM +( + select + Year, + count(*)*100 as c1 + from ontime + WHERE DepDelay>10 + GROUP BY Year +) +JOIN +( + select + Year, + count(*) as c2 + from ontime + GROUP BY Year +) USING (Year) +ORDER BY Year; +``` + +Aynı sorgunun daha iyi sürümü: + +``` sql +SELECT Year, avg(DepDelay>10)*100 +FROM ontime +GROUP BY Year +ORDER BY Year; +``` + +S8. Çeşitli yıl aralıkları için doğrudan bağlı şehirlerin sayısına göre en popüler yerler + +``` sql +SELECT DestCityName, uniqExact(OriginCityName) AS u +FROM ontime +WHERE Year >= 2000 and Year <= 2010 +GROUP BY DestCityName +ORDER BY u DESC LIMIT 10; +``` + +Q9. + +``` sql +SELECT Year, count(*) AS c1 +FROM ontime +GROUP BY Year; +``` + +Q10. + +``` sql +SELECT + min(Year), max(Year), Carrier, count(*) AS cnt, + sum(ArrDelayMinutes>30) AS flights_delayed, + round(sum(ArrDelayMinutes>30)/count(*),2) AS rate +FROM ontime +WHERE + DayOfWeek NOT IN (6,7) AND OriginState NOT IN ('AK', 'HI', 'PR', 'VI') + AND DestState NOT IN ('AK', 'HI', 'PR', 'VI') + AND FlightDate < '2010-01-01' +GROUP by Carrier +HAVING cnt>100000 and max(Year)>1990 +ORDER by rate DESC +LIMIT 1000; +``` + +Bonus: + +``` sql +SELECT avg(cnt) +FROM +( + SELECT Year,Month,count(*) AS cnt + FROM ontime + WHERE DepDel15=1 + GROUP BY Year,Month +); + +SELECT avg(c1) FROM +( + SELECT Year,Month,count(*) AS c1 + FROM ontime + GROUP BY Year,Month +); + +SELECT DestCityName, uniqExact(OriginCityName) AS u +FROM ontime +GROUP BY DestCityName +ORDER BY u DESC +LIMIT 10; + +SELECT OriginCityName, DestCityName, count() AS c +FROM ontime +GROUP BY OriginCityName, DestCityName +ORDER BY c DESC +LIMIT 10; + +SELECT OriginCityName, count() AS c +FROM ontime +GROUP BY OriginCityName +ORDER BY c DESC +LIMIT 10; +``` + +Bu performans testi Vadim Tkachenko tarafından oluşturuldu. Görmek: + +- https://www.percona.com/blog/2009/10/02/analyzing-air-traffic-performance-with-infobright-and-monetdb/ +- https://www.percona.com/blog/2009/10/26/air-traffic-queries-in-luciddb/ +- https://www.percona.com/blog/2009/11/02/air-traffic-queries-in-infinidb-early-alpha/ +- https://www.percona.com/blog/2014/04/21/using-apache-hadoop-and-impala-together-with-mysql-for-data-analysis/ +- https://www.percona.com/blog/2016/01/07/apache-spark-with-air-ontime-performance-data/ +- http://nickmakos.blogspot.ru/2012/08/analyzing-air-traffic-performance-with.html + +[Orijinal makale](https://clickhouse.tech/docs/en/getting_started/example_datasets/ontime/) diff --git a/docs/tr/getting_started/example_datasets/star_schema.md b/docs/tr/getting_started/example_datasets/star_schema.md new file mode 100644 index 00000000000..1326aab7ab2 --- /dev/null +++ b/docs/tr/getting_started/example_datasets/star_schema.md @@ -0,0 +1,370 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 20 +toc_title: "Y\u0131ld\u0131z \u015Eema Ben Benchmarkch Benchmarkmark" +--- + +# Yıldız Şema Ben Benchmarkch Benchmarkmark {#star-schema-benchmark} + +Dbgen derleme: + +``` bash +$ git clone git@github.com:vadimtk/ssb-dbgen.git +$ cd ssb-dbgen +$ make +``` + +Veri oluşturma: + +!!! warning "Dikkat" + İle `-s 100` dbgen, 600 milyon satır (67 GB) üretir `-s 1000` 6 milyar satır üretir (bu çok zaman alır) + +``` bash +$ ./dbgen -s 1000 -T c +$ ./dbgen -s 1000 -T l +$ ./dbgen -s 1000 -T p +$ ./dbgen -s 1000 -T s +$ ./dbgen -s 1000 -T d +``` + +Clickhouse'da tablolar oluşturma: + +``` sql +CREATE TABLE customer +( + C_CUSTKEY UInt32, + C_NAME String, + C_ADDRESS String, + C_CITY LowCardinality(String), + C_NATION LowCardinality(String), + C_REGION LowCardinality(String), + C_PHONE String, + C_MKTSEGMENT LowCardinality(String) +) +ENGINE = MergeTree ORDER BY (C_CUSTKEY); + +CREATE TABLE lineorder +( + LO_ORDERKEY UInt32, + LO_LINENUMBER UInt8, + LO_CUSTKEY UInt32, + LO_PARTKEY UInt32, + LO_SUPPKEY UInt32, + LO_ORDERDATE Date, + LO_ORDERPRIORITY LowCardinality(String), + LO_SHIPPRIORITY UInt8, + LO_QUANTITY UInt8, + LO_EXTENDEDPRICE UInt32, + LO_ORDTOTALPRICE UInt32, + LO_DISCOUNT UInt8, + LO_REVENUE UInt32, + LO_SUPPLYCOST UInt32, + LO_TAX UInt8, + LO_COMMITDATE Date, + LO_SHIPMODE LowCardinality(String) +) +ENGINE = MergeTree PARTITION BY toYear(LO_ORDERDATE) ORDER BY (LO_ORDERDATE, LO_ORDERKEY); + +CREATE TABLE part +( + P_PARTKEY UInt32, + P_NAME String, + P_MFGR LowCardinality(String), + P_CATEGORY LowCardinality(String), + P_BRAND LowCardinality(String), + P_COLOR LowCardinality(String), + P_TYPE LowCardinality(String), + P_SIZE UInt8, + P_CONTAINER LowCardinality(String) +) +ENGINE = MergeTree ORDER BY P_PARTKEY; + +CREATE TABLE supplier +( + S_SUPPKEY UInt32, + S_NAME String, + S_ADDRESS String, + S_CITY LowCardinality(String), + S_NATION LowCardinality(String), + S_REGION LowCardinality(String), + S_PHONE String +) +ENGINE = MergeTree ORDER BY S_SUPPKEY; +``` + +Veri ekleme: + +``` bash +$ clickhouse-client --query "INSERT INTO customer FORMAT CSV" < customer.tbl +$ clickhouse-client --query "INSERT INTO part FORMAT CSV" < part.tbl +$ clickhouse-client --query "INSERT INTO supplier FORMAT CSV" < supplier.tbl +$ clickhouse-client --query "INSERT INTO lineorder FORMAT CSV" < lineorder.tbl +``` + +Dönüşüm “star schema” denormalized için “flat schema”: + +``` sql +SET max_memory_usage = 20000000000; + +CREATE TABLE lineorder_flat +ENGINE = MergeTree +PARTITION BY toYear(LO_ORDERDATE) +ORDER BY (LO_ORDERDATE, LO_ORDERKEY) AS +SELECT + l.LO_ORDERKEY AS LO_ORDERKEY, + l.LO_LINENUMBER AS LO_LINENUMBER, + l.LO_CUSTKEY AS LO_CUSTKEY, + l.LO_PARTKEY AS LO_PARTKEY, + l.LO_SUPPKEY AS LO_SUPPKEY, + l.LO_ORDERDATE AS LO_ORDERDATE, + l.LO_ORDERPRIORITY AS LO_ORDERPRIORITY, + l.LO_SHIPPRIORITY AS LO_SHIPPRIORITY, + l.LO_QUANTITY AS LO_QUANTITY, + l.LO_EXTENDEDPRICE AS LO_EXTENDEDPRICE, + l.LO_ORDTOTALPRICE AS LO_ORDTOTALPRICE, + l.LO_DISCOUNT AS LO_DISCOUNT, + l.LO_REVENUE AS LO_REVENUE, + l.LO_SUPPLYCOST AS LO_SUPPLYCOST, + l.LO_TAX AS LO_TAX, + l.LO_COMMITDATE AS LO_COMMITDATE, + l.LO_SHIPMODE AS LO_SHIPMODE, + c.C_NAME AS C_NAME, + c.C_ADDRESS AS C_ADDRESS, + c.C_CITY AS C_CITY, + c.C_NATION AS C_NATION, + c.C_REGION AS C_REGION, + c.C_PHONE AS C_PHONE, + c.C_MKTSEGMENT AS C_MKTSEGMENT, + s.S_NAME AS S_NAME, + s.S_ADDRESS AS S_ADDRESS, + s.S_CITY AS S_CITY, + s.S_NATION AS S_NATION, + s.S_REGION AS S_REGION, + s.S_PHONE AS S_PHONE, + p.P_NAME AS P_NAME, + p.P_MFGR AS P_MFGR, + p.P_CATEGORY AS P_CATEGORY, + p.P_BRAND AS P_BRAND, + p.P_COLOR AS P_COLOR, + p.P_TYPE AS P_TYPE, + p.P_SIZE AS P_SIZE, + p.P_CONTAINER AS P_CONTAINER +FROM lineorder AS l +INNER JOIN customer AS c ON c.C_CUSTKEY = l.LO_CUSTKEY +INNER JOIN supplier AS s ON s.S_SUPPKEY = l.LO_SUPPKEY +INNER JOIN part AS p ON p.P_PARTKEY = l.LO_PARTKEY; +``` + +Sorguları çalıştırma: + +Q1.1 + +``` sql +SELECT sum(LO_EXTENDEDPRICE * LO_DISCOUNT) AS revenue +FROM lineorder_flat +WHERE toYear(LO_ORDERDATE) = 1993 AND LO_DISCOUNT BETWEEN 1 AND 3 AND LO_QUANTITY < 25; +``` + +Q1.2 + +``` sql +SELECT sum(LO_EXTENDEDPRICE * LO_DISCOUNT) AS revenue +FROM lineorder_flat +WHERE toYYYYMM(LO_ORDERDATE) = 199401 AND LO_DISCOUNT BETWEEN 4 AND 6 AND LO_QUANTITY BETWEEN 26 AND 35; +``` + +Q1.3 + +``` sql +SELECT sum(LO_EXTENDEDPRICE * LO_DISCOUNT) AS revenue +FROM lineorder_flat +WHERE toISOWeek(LO_ORDERDATE) = 6 AND toYear(LO_ORDERDATE) = 1994 + AND LO_DISCOUNT BETWEEN 5 AND 7 AND LO_QUANTITY BETWEEN 26 AND 35; +``` + +Q2.1 + +``` sql +SELECT + sum(LO_REVENUE), + toYear(LO_ORDERDATE) AS year, + P_BRAND +FROM lineorder_flat +WHERE P_CATEGORY = 'MFGR#12' AND S_REGION = 'AMERICA' +GROUP BY + year, + P_BRAND +ORDER BY + year, + P_BRAND; +``` + +Q2.2 + +``` sql +SELECT + sum(LO_REVENUE), + toYear(LO_ORDERDATE) AS year, + P_BRAND +FROM lineorder_flat +WHERE P_BRAND >= 'MFGR#2221' AND P_BRAND <= 'MFGR#2228' AND S_REGION = 'ASIA' +GROUP BY + year, + P_BRAND +ORDER BY + year, + P_BRAND; +``` + +Q2.3 + +``` sql +SELECT + sum(LO_REVENUE), + toYear(LO_ORDERDATE) AS year, + P_BRAND +FROM lineorder_flat +WHERE P_BRAND = 'MFGR#2239' AND S_REGION = 'EUROPE' +GROUP BY + year, + P_BRAND +ORDER BY + year, + P_BRAND; +``` + +Q3.1 + +``` sql +SELECT + C_NATION, + S_NATION, + toYear(LO_ORDERDATE) AS year, + sum(LO_REVENUE) AS revenue +FROM lineorder_flat +WHERE C_REGION = 'ASIA' AND S_REGION = 'ASIA' AND year >= 1992 AND year <= 1997 +GROUP BY + C_NATION, + S_NATION, + year +ORDER BY + year ASC, + revenue DESC; +``` + +Q3.2 + +``` sql +SELECT + C_CITY, + S_CITY, + toYear(LO_ORDERDATE) AS year, + sum(LO_REVENUE) AS revenue +FROM lineorder_flat +WHERE C_NATION = 'UNITED STATES' AND S_NATION = 'UNITED STATES' AND year >= 1992 AND year <= 1997 +GROUP BY + C_CITY, + S_CITY, + year +ORDER BY + year ASC, + revenue DESC; +``` + +Q3.3 + +``` sql +SELECT + C_CITY, + S_CITY, + toYear(LO_ORDERDATE) AS year, + sum(LO_REVENUE) AS revenue +FROM lineorder_flat +WHERE (C_CITY = 'UNITED KI1' OR C_CITY = 'UNITED KI5') AND (S_CITY = 'UNITED KI1' OR S_CITY = 'UNITED KI5') AND year >= 1992 AND year <= 1997 +GROUP BY + C_CITY, + S_CITY, + year +ORDER BY + year ASC, + revenue DESC; +``` + +Q3.4 + +``` sql +SELECT + C_CITY, + S_CITY, + toYear(LO_ORDERDATE) AS year, + sum(LO_REVENUE) AS revenue +FROM lineorder_flat +WHERE (C_CITY = 'UNITED KI1' OR C_CITY = 'UNITED KI5') AND (S_CITY = 'UNITED KI1' OR S_CITY = 'UNITED KI5') AND toYYYYMM(LO_ORDERDATE) = 199712 +GROUP BY + C_CITY, + S_CITY, + year +ORDER BY + year ASC, + revenue DESC; +``` + +Q4.1 + +``` sql +SELECT + toYear(LO_ORDERDATE) AS year, + C_NATION, + sum(LO_REVENUE - LO_SUPPLYCOST) AS profit +FROM lineorder_flat +WHERE C_REGION = 'AMERICA' AND S_REGION = 'AMERICA' AND (P_MFGR = 'MFGR#1' OR P_MFGR = 'MFGR#2') +GROUP BY + year, + C_NATION +ORDER BY + year ASC, + C_NATION ASC; +``` + +Q4.2 + +``` sql +SELECT + toYear(LO_ORDERDATE) AS year, + S_NATION, + P_CATEGORY, + sum(LO_REVENUE - LO_SUPPLYCOST) AS profit +FROM lineorder_flat +WHERE C_REGION = 'AMERICA' AND S_REGION = 'AMERICA' AND (year = 1997 OR year = 1998) AND (P_MFGR = 'MFGR#1' OR P_MFGR = 'MFGR#2') +GROUP BY + year, + S_NATION, + P_CATEGORY +ORDER BY + year ASC, + S_NATION ASC, + P_CATEGORY ASC; +``` + +Q4.3 + +``` sql +SELECT + toYear(LO_ORDERDATE) AS year, + S_CITY, + P_BRAND, + sum(LO_REVENUE - LO_SUPPLYCOST) AS profit +FROM lineorder_flat +WHERE S_NATION = 'UNITED STATES' AND (year = 1997 OR year = 1998) AND P_CATEGORY = 'MFGR#14' +GROUP BY + year, + S_CITY, + P_BRAND +ORDER BY + year ASC, + S_CITY ASC, + P_BRAND ASC; +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/getting_started/example_datasets/star_schema/) diff --git a/docs/tr/getting_started/example_datasets/wikistat.md b/docs/tr/getting_started/example_datasets/wikistat.md new file mode 100644 index 00000000000..0fc24dd5bb1 --- /dev/null +++ b/docs/tr/getting_started/example_datasets/wikistat.md @@ -0,0 +1,35 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 18 +toc_title: WikiStat +--- + +# WikiStat {#wikistat} + +Bakınız: http://dumps.wikimedia.org/other/pagecounts-raw/ + +Tablo oluşturma: + +``` sql +CREATE TABLE wikistat +( + date Date, + time DateTime, + project String, + subproject String, + path String, + hits UInt64, + size UInt64 +) ENGINE = MergeTree(date, (path, time), 8192); +``` + +Veri yükleme: + +``` bash +$ for i in {2007..2016}; do for j in {01..12}; do echo $i-$j >&2; curl -sSL "http://dumps.wikimedia.org/other/pagecounts-raw/$i/$i-$j/" | grep -oE 'pagecounts-[0-9]+-[0-9]+\.gz'; done; done | sort | uniq | tee links.txt +$ cat links.txt | while read link; do wget http://dumps.wikimedia.org/other/pagecounts-raw/$(echo $link | sed -r 's/pagecounts-([0-9]{4})([0-9]{2})[0-9]{2}-[0-9]+\.gz/\1/')/$(echo $link | sed -r 's/pagecounts-([0-9]{4})([0-9]{2})[0-9]{2}-[0-9]+\.gz/\1-\2/')/$link; done +$ ls -1 /opt/wikistat/ | grep gz | while read i; do echo $i; gzip -cd /opt/wikistat/$i | ./wikistat-loader --time="$(echo -n $i | sed -r 's/pagecounts-([0-9]{4})([0-9]{2})([0-9]{2})-([0-9]{2})([0-9]{2})([0-9]{2})\.gz/\1-\2-\3 \4-00-00/')" | clickhouse-client --query="INSERT INTO wikistat FORMAT TabSeparated"; done +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/getting_started/example_datasets/wikistat/) diff --git a/docs/tr/getting_started/index.md b/docs/tr/getting_started/index.md new file mode 100644 index 00000000000..e97f9add1f0 --- /dev/null +++ b/docs/tr/getting_started/index.md @@ -0,0 +1,17 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "Ba\u015Flarken" +toc_hidden: true +toc_priority: 8 +toc_title: "gizlenmi\u015F" +--- + +# Başlarken {#getting-started} + +Eğer ClickHouse için yeni ve performans bir hands-on hissi almak istiyorsanız, her şeyden önce, sen [yükleme işlemi](install.md). Bundan sonra şunları yapabilirsiniz: + +- [Ayrıntılı öğretici geçmesi](tutorial.md) +- [Örnek veri kümeleri ile deneme](example_datasets/ontime.md) + +[Orijinal makale](https://clickhouse.tech/docs/en/getting_started/) diff --git a/docs/tr/getting_started/install.md b/docs/tr/getting_started/install.md new file mode 100644 index 00000000000..8597a378fb4 --- /dev/null +++ b/docs/tr/getting_started/install.md @@ -0,0 +1,191 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 11 +toc_title: Kurulum +--- + +# Kurulum {#installation} + +## Sistem Gereksinimleri {#system-requirements} + +ClickHouse, x86\_64, AArch64 veya PowerPC64LE CPU mimarisine sahip herhangi bir Linux, FreeBSD veya Mac OS X üzerinde çalışabilir. + +Resmi önceden oluşturulmuş ikili dosyalar genellikle x86\_64 ve kaldıraç sse 4.2 komut seti için derlenir, bu nedenle destekleyen CPU'nun aksi belirtilmedikçe ek bir sistem gereksinimi haline gelir. Geçerli CPU'nun sse 4.2 desteği olup olmadığını kontrol etmek için komut: + +``` bash +$ grep -q sse4_2 /proc/cpuinfo && echo "SSE 4.2 supported" || echo "SSE 4.2 not supported" +``` + +SSE 4.2'yi desteklemeyen veya AArch64 veya PowerPC64LE mimarisine sahip işlemcilerde Clickhouse'u çalıştırmak için şunları yapmalısınız [kaynaklardan ClickHouse oluşturun](#from-sources) uygun yapılandırma ayarlamaları ile. + +## Mevcut Kurulum Seçenekleri {#available-installation-options} + +### DEB paket fromlerinden {#install-from-deb-packages} + +Resmi önceden derlenmiş kullanılması tavsiye edilir `deb` Debian veya Ubuntu için paketler. + +Resmi paketleri yüklemek için Yandex deposunu ekleyin `/etc/apt/sources.list` veya ayrı bir `/etc/apt/sources.list.d/clickhouse.list` Dosya: + + deb http://repo.clickhouse.tech/deb/stable/ main/ + +En son sürümü kullanmak istiyorsanız, değiştirin `stable` ile `testing` (bu, test ortamlarınız için önerilir). + +Sonra paketleri yüklemek için bu komutları çalıştırın: + +``` bash +sudo apt-get install dirmngr # optional +sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv E0C56BD4 # optional +sudo apt-get update +sudo apt-get install clickhouse-client clickhouse-server +``` + +Paketleri buradan manuel olarak indirebilir ve kurabilirsiniz: https://repo.yandex.ru/clickhouse/deb/stable/main/. + +#### Paketler {#packages} + +- `clickhouse-common-static` — Installs ClickHouse compiled binary files. +- `clickhouse-server` — Creates a symbolic link for `clickhouse-server` ve varsayılan sunucu yapılandırmasını yükler. +- `clickhouse-client` — Creates a symbolic link for `clickhouse-client` ve diğer istemci ile ilgili araçlar. ve istemci yapılandırma dosyalarını yükler. +- `clickhouse-common-static-dbg` — Installs ClickHouse compiled binary files with debug info. + +### RPM paket fromlerinden {#from-rpm-packages} + +Resmi önceden derlenmiş kullanılması tavsiye edilir `rpm` CentOS, RedHat ve diğer tüm rpm tabanlı Linux dağıtımları için paketler. + +İlk olarak, resmi depoyu eklemeniz gerekir: + +``` bash +sudo yum install yum-utils +sudo rpm --import https://repo.clickhouse.tech/CLICKHOUSE-KEY.GPG +sudo yum-config-manager --add-repo https://repo.clickhouse.tech/rpm/stable/x86_64 +``` + +En son sürümü kullanmak istiyorsanız, değiştirin `stable` ile `testing` (bu, test ortamlarınız için önerilir). Bu `prestable` etiket de bazen kullanılabilir. + +Sonra paketleri yüklemek için bu komutları çalıştırın: + +``` bash +sudo yum install clickhouse-server clickhouse-client +``` + +Paketleri buradan manuel olarak indirebilir ve kurabilirsiniz: https://repo.clickhouse.teknoloji / rpm / kararlı / x86\_64. + +### Tgz Arşivlerinden {#from-tgz-archives} + +Resmi önceden derlenmiş kullanılması tavsiye edilir `tgz` Arch ,iv ,es for tüm Linux dağıtım installationları, kurulumu `deb` veya `rpm` paketler mümkün değildir. + +Gerekli sürümü ile indirilebilir `curl` veya `wget` depo fromdan https://repo.yandex.ru/clickhouse/tgz/. +Bundan sonra indirilen arşivler açılmalı ve kurulum komut dosyaları ile kurulmalıdır. En son sürüm için örnek: + +``` bash +export LATEST_VERSION=`curl https://api.github.com/repos/ClickHouse/ClickHouse/tags 2>/dev/null | grep -Eo '[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+' | head -n 1` +curl -O https://repo.clickhouse.tech/tgz/clickhouse-common-static-$LATEST_VERSION.tgz +curl -O https://repo.clickhouse.tech/tgz/clickhouse-common-static-dbg-$LATEST_VERSION.tgz +curl -O https://repo.clickhouse.tech/tgz/clickhouse-server-$LATEST_VERSION.tgz +curl -O https://repo.clickhouse.tech/tgz/clickhouse-client-$LATEST_VERSION.tgz + +tar -xzvf clickhouse-common-static-$LATEST_VERSION.tgz +sudo clickhouse-common-static-$LATEST_VERSION/install/doinst.sh + +tar -xzvf clickhouse-common-static-dbg-$LATEST_VERSION.tgz +sudo clickhouse-common-static-dbg-$LATEST_VERSION/install/doinst.sh + +tar -xzvf clickhouse-server-$LATEST_VERSION.tgz +sudo clickhouse-server-$LATEST_VERSION/install/doinst.sh +sudo /etc/init.d/clickhouse-server start + +tar -xzvf clickhouse-client-$LATEST_VERSION.tgz +sudo clickhouse-client-$LATEST_VERSION/install/doinst.sh +``` + +Üretim ortamları için en son teknolojiyi kullanmanız önerilir `stable`-sürüm. Numarasını GitHub sayfasında bulabilirsiniz https://github.com/ClickHouse/ClickHouse/tags postfix ile `-stable`. + +### Docker Görüntüden {#from-docker-image} + +Docker içinde ClickHouse çalıştırmak için kılavuzu izleyin [Docker Hub](https://hub.docker.com/r/yandex/clickhouse-server/). Bu görüntüler resmi `deb` paketler içinde. + +### Kaynaklardan {#from-sources} + +Clickhouse'u el ile derlemek için aşağıdaki talimatları izleyin [Linux](../development/build.md) veya [Mac OS X](../development/build_osx.md). + +Paketleri derleyebilir ve yükleyebilir veya paketleri yüklemeden programları kullanabilirsiniz. Ayrıca elle inşa ederek SSE 4.2 gereksinimini devre dışı bırakabilir veya AArch64 CPU'lar için oluşturabilirsiniz. + + Client: programs/clickhouse-client + Server: programs/clickhouse-server + +Bir veri ve meta veri klasörleri oluşturmanız gerekir ve `chown` onları istenen kullanıcı için. Yolları sunucu yapılandırmasında değiştirilebilir (src / programlar / sunucu / config.xml), varsayılan olarak: + + /opt/clickhouse/data/default/ + /opt/clickhouse/metadata/default/ + +Gentoo üzerinde, sadece kullanabilirsiniz `emerge clickhouse` Clickhouse'u kaynaklardan yüklemek için. + +## Başlamak {#launch} + +Sunucuyu bir daemon olarak başlatmak için çalıştırın: + +``` bash +$ sudo service clickhouse-server start +``` + +Yok eğer `service` command, run as + +``` bash +$ sudo /etc/init.d/clickhouse-server start +``` + +Günlükleri görmek `/var/log/clickhouse-server/` dizin. + +Sunucu başlatılmazsa, dosyadaki yapılandırmaları kontrol edin `/etc/clickhouse-server/config.xml`. + +Ayrıca sunucuyu konsoldan manuel olarak başlatabilirsiniz: + +``` bash +$ clickhouse-server --config-file=/etc/clickhouse-server/config.xml +``` + +Bu durumda, günlük geliştirme sırasında uygun olan konsola yazdırılacaktır. +Yapılandırma dosyası geçerli dizinde ise, `--config-file` parametre. Varsayılan olarak, kullanır `./config.xml`. + +ClickHouse erişim kısıtlama ayarlarını destekler. Bulun theurlar. `users.xml` dosya (yanındaki `config.xml`). +Varsayılan olarak, erişim için herhangi bir yerden izin verilir `default` Kullanıcı, şifre olmadan. Görmek `user/default/networks`. +Daha fazla bilgi için bölüme bakın [“Configuration Files”](../operations/configuration_files.md). + +Sunucuyu başlattıktan sonra, ona bağlanmak için komut satırı istemcisini kullanabilirsiniz: + +``` bash +$ clickhouse-client +``` + +Varsayılan olarak, bağlanır `localhost:9000` kullanıcı adına `default` şifre olmadan. Kullanarak uzak bir sunucuya bağlanmak için de kullanılabilir `--host` değişken. + +Terminal UTF-8 kodlamasını kullanmalıdır. +Daha fazla bilgi için bölüme bakın [“Command-line client”](../interfaces/cli.md). + +Örnek: + +``` bash +$ ./clickhouse-client +ClickHouse client version 0.0.18749. +Connecting to localhost:9000. +Connected to ClickHouse server version 0.0.18749. + +:) SELECT 1 + +SELECT 1 + +┌─1─┐ +│ 1 │ +└───┘ + +1 rows in set. Elapsed: 0.003 sec. + +:) +``` + +**Tebrikler, sistem çalışıyor!** + +Denemeye devam etmek için, test veri kümelerinden birini indirebilir veya şunları yapabilirsiniz [öğretici](https://clickhouse.tech/tutorial.html). + +[Orijinal makale](https://clickhouse.tech/docs/en/getting_started/install/) diff --git a/docs/tr/getting_started/playground.md b/docs/tr/getting_started/playground.md new file mode 100644 index 00000000000..7c0f3641544 --- /dev/null +++ b/docs/tr/getting_started/playground.md @@ -0,0 +1,48 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 14 +toc_title: "Bah\xE7e" +--- + +# ClickHouse Oyun Alanı {#clickhouse-playground} + +[ClickHouse Oyun Alanı](https://play.clickhouse.tech?file=welcome) kullanıcıların kendi sunucu veya küme kurmadan, anında sorguları çalıştırarak ClickHouse ile deneme sağlar. +Oyun alanında çeşitli örnek veri kümelerinin yanı sıra ClickHouse özelliklerini gösteren örnek sorgular da mevcuttur. + +Sorgular salt okunur bir kullanıcı olarak yürütülür. Bazı sınırlamaları ima eder: + +- DDL sorgularına İzin Verilmiyor +- Sorgu Ekle izin verilmez + +Aşağıdaki ayarlar da uygulanır: +- [`max_result_bytes=10485760`](../operations/settings/query_complexity/#max-result-bytes) +- [`max_result_rows=2000`](../operations/settings/query_complexity/#setting-max_result_rows) +- [`result_overflow_mode=break`](../operations/settings/query_complexity/#result-overflow-mode) +- [`max_execution_time=60000`](../operations/settings/query_complexity/#max-execution-time) + +ClickHouse oyun alanı m2 deneyimini sunar.küçükler +[ClickHouse için yönetilen hizmet](https://cloud.yandex.com/services/managed-clickhouse) +örnek host hosteded in [Üye.Bulut](https://cloud.yandex.com/). +Hakkında daha fazla bilgi [bulut sağlayıcıları](../commercial/cloud.md). + +ClickHouse Playground web arayüzü clickhouse üzerinden istekleri yapar [HTTP API](../interfaces/http.md). +Bahçesi arka uç herhangi bir ek sunucu tarafı uygulaması olmadan sadece bir ClickHouse kümesidir. +ClickHouse HTTPS bitiş noktası da oyun alanının bir parçası olarak kullanılabilir. + +Herhangi bir HTTP istemcisi kullanarak oyun alanına sorgu yapabilirsiniz, örneğin [kıvrılma](https://curl.haxx.se) veya [wget](https://www.gnu.org/software/wget/), veya kullanarak bir bağlantı kurmak [JDBC](../interfaces/jdbc.md) veya [ODBC](../interfaces/odbc.md) sürücüler. +Clickhouse'u destekleyen yazılım ürünleri hakkında daha fazla bilgi mevcuttur [burada](../interfaces/index.md). + +| Parametre | Değer | +|:----------|:----------------------------------------| +| Nokta | https://play-api.clickhouse.teknik:8443 | +| Kullanan | `playground` | +| Şifre | `clickhouse` | + +Bu bitiş noktasının güvenli bir bağlantı gerektirdiğini unutmayın. + +Örnek: + +``` bash +curl "https://play-api.clickhouse.tech:8443/?query=SELECT+'Play+ClickHouse!';&user=playground&password=clickhouse&database=datasets" +``` diff --git a/docs/tr/getting_started/tutorial.md b/docs/tr/getting_started/tutorial.md new file mode 100644 index 00000000000..9d3d31ba898 --- /dev/null +++ b/docs/tr/getting_started/tutorial.md @@ -0,0 +1,671 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 12 +toc_title: "\xD6\u011Fretici" +--- + +# ClickHouse Eğitimi {#clickhouse-tutorial} + +## Bu Öğreticiden ne beklenir? {#what-to-expect-from-this-tutorial} + +Bu öğreticiden geçerek, basit bir ClickHouse kümesinin nasıl kurulacağını öğreneceksiniz. Küçük ama hataya dayanıklı ve ölçeklenebilir olacak. Ardından, verilerle doldurmak ve bazı demo sorguları yürütmek için örnek veri kümelerinden birini kullanacağız. + +## Tek Düğüm Kurulumu {#single-node-setup} + +Dağıtılmış bir ortamın karmaşıklığını ertelemek için, Clickhouse'u tek bir sunucu veya sanal makinede dağıtmaya başlayacağız. ClickHouse genellikle [deb](index.md#install-from-deb-packages) veya [rpm](index.md#from-rpm-packages) paketler, ama var [alternatifler](index.md#from-docker-image) onları desteklemeyen işletim sistemleri için. + +Örneğin, seçtiğiniz `deb` paketler ve yürütülen: + +``` bash +sudo apt-get install dirmngr +sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv E0C56BD4 + +echo "deb http://repo.clickhouse.tech/deb/stable/ main/" | sudo tee /etc/apt/sources.list.d/clickhouse.list +sudo apt-get update + +sudo apt-get install -y clickhouse-server clickhouse-client +``` + +Yüklü olan paketlerde ne var: + +- `clickhouse-client` paket içerir [clickhouse-müşteri](../interfaces/cli.md) uygulama, interaktif ClickHouse konsol istemcisi. +- `clickhouse-common` paket clickhouse yürütülebilir dosya içerir. +- `clickhouse-server` paket bir sunucu olarak ClickHouse çalıştırmak için yapılandırma dosyalarını içerir. + +Sunucu yapılandırma dosyaları bulunur `/etc/clickhouse-server/`. Daha fazla gitmeden önce, fark lütfen `` element in `config.xml`. Path, veri depolama için konumu belirler, bu nedenle büyük disk kapasitesine sahip birimde bulunmalıdır; varsayılan değer `/var/lib/clickhouse/`. Yapılandırmayı ayarlamak istiyorsanız, doğrudan düzenlemek kullanışlı değildir `config.xml` dosya, gelecekteki paket güncellemelerinde yeniden yazılabileceğini düşünüyor. Yapılandırma öğelerini geçersiz kılmak için önerilen yol oluşturmaktır [config dosyaları.d dizin](../operations/configuration_files.md) hizmet olarak “patches” config için.xml. + +Fark etmiş olabileceğiniz gibi, `clickhouse-server` paket kurulumdan sonra otomatik olarak başlatılmaz. Güncellemelerden sonra otomatik olarak yeniden başlatılmaz. Sunucuyu başlatma şekliniz init sisteminize bağlıdır, genellikle: + +``` bash +sudo service clickhouse-server start +``` + +veya + +``` bash +sudo /etc/init.d/clickhouse-server start +``` + +Sunucu günlükleri için varsayılan konum `/var/log/clickhouse-server/`. Sunucu, oturum açtıktan sonra istemci bağlantılarını işlemeye hazırdır. `Ready for connections` ileti. + +Bir kez `clickhouse-server` yukarı ve çalışıyor, biz kullanabilirsiniz `clickhouse-client` sunucuya bağlanmak ve aşağıdaki gibi bazı test sorguları çalıştırmak için `SELECT "Hello, world!";`. + +
+ +Clickhouse-client için hızlı ipuçları +İnteraktif mod: + +``` bash +clickhouse-client +clickhouse-client --host=... --port=... --user=... --password=... +``` + +Çok satırlı sorguları etkinleştirme: + +``` bash +clickhouse-client -m +clickhouse-client --multiline +``` + +Toplu iş modunda sorguları çalıştırma: + +``` bash +clickhouse-client --query='SELECT 1' +echo 'SELECT 1' | clickhouse-client +clickhouse-client <<< 'SELECT 1' +``` + +Belirtilen biçimde bir dosyadan veri ekleme: + +``` bash +clickhouse-client --query='INSERT INTO table VALUES' < data.txt +clickhouse-client --query='INSERT INTO table FORMAT TabSeparated' < data.tsv +``` + +
+ +## Örnek Veri Kümesini İçe Aktar {#import-sample-dataset} + +Şimdi ClickHouse sunucumuzu bazı örnek verilerle doldurmanın zamanı geldi. Bu eğitimde, yandex'in anonim verilerini kullanacağız.Metrica, açık kaynak olmadan önce Clickhouse'u üretim yolunda çalıştıran ilk hizmet (daha fazlası [tarih bölümü](../introduction/history.md)). Var [Yandex'i içe aktarmanın birden fazla yolu.Metrica veri kümesi](example_datasets/metrica.md) ve öğretici uğruna, en gerçekçi olanı ile gideceğiz. + +### Tablo verilerini indirin ve ayıklayın {#download-and-extract-table-data} + +``` bash +curl https://clickhouse-datasets.s3.yandex.net/hits/tsv/hits_v1.tsv.xz | unxz --threads=`nproc` > hits_v1.tsv +curl https://clickhouse-datasets.s3.yandex.net/visits/tsv/visits_v1.tsv.xz | unxz --threads=`nproc` > visits_v1.tsv +``` + +Çıkarılan dosyalar yaklaşık 10GB boyutundadır. + +### Tablo Oluşturma {#create-tables} + +Çoğu veritabanı yönetim sisteminde olduğu gibi, ClickHouse tabloları mantıksal olarak gruplar “databases”. Bir `default` veritabanı, ancak adında yeni bir tane oluşturacağız `tutorial`: + +``` bash +clickhouse-client --query "CREATE DATABASE IF NOT EXISTS tutorial" +``` + +Tablolar oluşturmak için sözdizimi veritabanlarına kıyasla çok daha karmaşıktır (bkz. [başvurma](../sql_reference/statements/create.md). Genelde `CREATE TABLE` deyimi üç önemli şeyi belirtmek zorundadır: + +1. Oluşturulacak tablonun adı. +2. Table schema, i.e. list of columns and their [veri türleri](../sql_reference/data_types/index.md). +3. [Masa motoru](../engines/table_engines/index.md) ve bu tabloya yapılan sorguların fiziksel olarak nasıl yürütüleceği ile ilgili tüm ayrıntıları belirleyen ayarları. + +Üye.Metrica bir web analitiği hizmetidir ve örnek veri kümesi tam işlevselliğini kapsamaz, bu nedenle oluşturmak için sadece iki tablo vardır: + +- `hits` hizmet kapsamındaki tüm web sitelerinde tüm kullanıcılar tarafından yapılan her eylem ile bir tablodur. +- `visits` bireysel eylemler yerine önceden oluşturulmuş oturumlar içeren bir tablodur. + +Bu tablolar için gerçek create table sorgularını görelim ve yürütelim: + +``` sql +CREATE TABLE tutorial.hits_v1 +( + `WatchID` UInt64, + `JavaEnable` UInt8, + `Title` String, + `GoodEvent` Int16, + `EventTime` DateTime, + `EventDate` Date, + `CounterID` UInt32, + `ClientIP` UInt32, + `ClientIP6` FixedString(16), + `RegionID` UInt32, + `UserID` UInt64, + `CounterClass` Int8, + `OS` UInt8, + `UserAgent` UInt8, + `URL` String, + `Referer` String, + `URLDomain` String, + `RefererDomain` String, + `Refresh` UInt8, + `IsRobot` UInt8, + `RefererCategories` Array(UInt16), + `URLCategories` Array(UInt16), + `URLRegions` Array(UInt32), + `RefererRegions` Array(UInt32), + `ResolutionWidth` UInt16, + `ResolutionHeight` UInt16, + `ResolutionDepth` UInt8, + `FlashMajor` UInt8, + `FlashMinor` UInt8, + `FlashMinor2` String, + `NetMajor` UInt8, + `NetMinor` UInt8, + `UserAgentMajor` UInt16, + `UserAgentMinor` FixedString(2), + `CookieEnable` UInt8, + `JavascriptEnable` UInt8, + `IsMobile` UInt8, + `MobilePhone` UInt8, + `MobilePhoneModel` String, + `Params` String, + `IPNetworkID` UInt32, + `TraficSourceID` Int8, + `SearchEngineID` UInt16, + `SearchPhrase` String, + `AdvEngineID` UInt8, + `IsArtifical` UInt8, + `WindowClientWidth` UInt16, + `WindowClientHeight` UInt16, + `ClientTimeZone` Int16, + `ClientEventTime` DateTime, + `SilverlightVersion1` UInt8, + `SilverlightVersion2` UInt8, + `SilverlightVersion3` UInt32, + `SilverlightVersion4` UInt16, + `PageCharset` String, + `CodeVersion` UInt32, + `IsLink` UInt8, + `IsDownload` UInt8, + `IsNotBounce` UInt8, + `FUniqID` UInt64, + `HID` UInt32, + `IsOldCounter` UInt8, + `IsEvent` UInt8, + `IsParameter` UInt8, + `DontCountHits` UInt8, + `WithHash` UInt8, + `HitColor` FixedString(1), + `UTCEventTime` DateTime, + `Age` UInt8, + `Sex` UInt8, + `Income` UInt8, + `Interests` UInt16, + `Robotness` UInt8, + `GeneralInterests` Array(UInt16), + `RemoteIP` UInt32, + `RemoteIP6` FixedString(16), + `WindowName` Int32, + `OpenerName` Int32, + `HistoryLength` Int16, + `BrowserLanguage` FixedString(2), + `BrowserCountry` FixedString(2), + `SocialNetwork` String, + `SocialAction` String, + `HTTPError` UInt16, + `SendTiming` Int32, + `DNSTiming` Int32, + `ConnectTiming` Int32, + `ResponseStartTiming` Int32, + `ResponseEndTiming` Int32, + `FetchTiming` Int32, + `RedirectTiming` Int32, + `DOMInteractiveTiming` Int32, + `DOMContentLoadedTiming` Int32, + `DOMCompleteTiming` Int32, + `LoadEventStartTiming` Int32, + `LoadEventEndTiming` Int32, + `NSToDOMContentLoadedTiming` Int32, + `FirstPaintTiming` Int32, + `RedirectCount` Int8, + `SocialSourceNetworkID` UInt8, + `SocialSourcePage` String, + `ParamPrice` Int64, + `ParamOrderID` String, + `ParamCurrency` FixedString(3), + `ParamCurrencyID` UInt16, + `GoalsReached` Array(UInt32), + `OpenstatServiceName` String, + `OpenstatCampaignID` String, + `OpenstatAdID` String, + `OpenstatSourceID` String, + `UTMSource` String, + `UTMMedium` String, + `UTMCampaign` String, + `UTMContent` String, + `UTMTerm` String, + `FromTag` String, + `HasGCLID` UInt8, + `RefererHash` UInt64, + `URLHash` UInt64, + `CLID` UInt32, + `YCLID` UInt64, + `ShareService` String, + `ShareURL` String, + `ShareTitle` String, + `ParsedParams` Nested( + Key1 String, + Key2 String, + Key3 String, + Key4 String, + Key5 String, + ValueDouble Float64), + `IslandID` FixedString(16), + `RequestNum` UInt32, + `RequestTry` UInt8 +) +ENGINE = MergeTree() +PARTITION BY toYYYYMM(EventDate) +ORDER BY (CounterID, EventDate, intHash32(UserID)) +SAMPLE BY intHash32(UserID) +SETTINGS index_granularity = 8192 +``` + +``` sql +CREATE TABLE tutorial.visits_v1 +( + `CounterID` UInt32, + `StartDate` Date, + `Sign` Int8, + `IsNew` UInt8, + `VisitID` UInt64, + `UserID` UInt64, + `StartTime` DateTime, + `Duration` UInt32, + `UTCStartTime` DateTime, + `PageViews` Int32, + `Hits` Int32, + `IsBounce` UInt8, + `Referer` String, + `StartURL` String, + `RefererDomain` String, + `StartURLDomain` String, + `EndURL` String, + `LinkURL` String, + `IsDownload` UInt8, + `TraficSourceID` Int8, + `SearchEngineID` UInt16, + `SearchPhrase` String, + `AdvEngineID` UInt8, + `PlaceID` Int32, + `RefererCategories` Array(UInt16), + `URLCategories` Array(UInt16), + `URLRegions` Array(UInt32), + `RefererRegions` Array(UInt32), + `IsYandex` UInt8, + `GoalReachesDepth` Int32, + `GoalReachesURL` Int32, + `GoalReachesAny` Int32, + `SocialSourceNetworkID` UInt8, + `SocialSourcePage` String, + `MobilePhoneModel` String, + `ClientEventTime` DateTime, + `RegionID` UInt32, + `ClientIP` UInt32, + `ClientIP6` FixedString(16), + `RemoteIP` UInt32, + `RemoteIP6` FixedString(16), + `IPNetworkID` UInt32, + `SilverlightVersion3` UInt32, + `CodeVersion` UInt32, + `ResolutionWidth` UInt16, + `ResolutionHeight` UInt16, + `UserAgentMajor` UInt16, + `UserAgentMinor` UInt16, + `WindowClientWidth` UInt16, + `WindowClientHeight` UInt16, + `SilverlightVersion2` UInt8, + `SilverlightVersion4` UInt16, + `FlashVersion3` UInt16, + `FlashVersion4` UInt16, + `ClientTimeZone` Int16, + `OS` UInt8, + `UserAgent` UInt8, + `ResolutionDepth` UInt8, + `FlashMajor` UInt8, + `FlashMinor` UInt8, + `NetMajor` UInt8, + `NetMinor` UInt8, + `MobilePhone` UInt8, + `SilverlightVersion1` UInt8, + `Age` UInt8, + `Sex` UInt8, + `Income` UInt8, + `JavaEnable` UInt8, + `CookieEnable` UInt8, + `JavascriptEnable` UInt8, + `IsMobile` UInt8, + `BrowserLanguage` UInt16, + `BrowserCountry` UInt16, + `Interests` UInt16, + `Robotness` UInt8, + `GeneralInterests` Array(UInt16), + `Params` Array(String), + `Goals` Nested( + ID UInt32, + Serial UInt32, + EventTime DateTime, + Price Int64, + OrderID String, + CurrencyID UInt32), + `WatchIDs` Array(UInt64), + `ParamSumPrice` Int64, + `ParamCurrency` FixedString(3), + `ParamCurrencyID` UInt16, + `ClickLogID` UInt64, + `ClickEventID` Int32, + `ClickGoodEvent` Int32, + `ClickEventTime` DateTime, + `ClickPriorityID` Int32, + `ClickPhraseID` Int32, + `ClickPageID` Int32, + `ClickPlaceID` Int32, + `ClickTypeID` Int32, + `ClickResourceID` Int32, + `ClickCost` UInt32, + `ClickClientIP` UInt32, + `ClickDomainID` UInt32, + `ClickURL` String, + `ClickAttempt` UInt8, + `ClickOrderID` UInt32, + `ClickBannerID` UInt32, + `ClickMarketCategoryID` UInt32, + `ClickMarketPP` UInt32, + `ClickMarketCategoryName` String, + `ClickMarketPPName` String, + `ClickAWAPSCampaignName` String, + `ClickPageName` String, + `ClickTargetType` UInt16, + `ClickTargetPhraseID` UInt64, + `ClickContextType` UInt8, + `ClickSelectType` Int8, + `ClickOptions` String, + `ClickGroupBannerID` Int32, + `OpenstatServiceName` String, + `OpenstatCampaignID` String, + `OpenstatAdID` String, + `OpenstatSourceID` String, + `UTMSource` String, + `UTMMedium` String, + `UTMCampaign` String, + `UTMContent` String, + `UTMTerm` String, + `FromTag` String, + `HasGCLID` UInt8, + `FirstVisit` DateTime, + `PredLastVisit` Date, + `LastVisit` Date, + `TotalVisits` UInt32, + `TraficSource` Nested( + ID Int8, + SearchEngineID UInt16, + AdvEngineID UInt8, + PlaceID UInt16, + SocialSourceNetworkID UInt8, + Domain String, + SearchPhrase String, + SocialSourcePage String), + `Attendance` FixedString(16), + `CLID` UInt32, + `YCLID` UInt64, + `NormalizedRefererHash` UInt64, + `SearchPhraseHash` UInt64, + `RefererDomainHash` UInt64, + `NormalizedStartURLHash` UInt64, + `StartURLDomainHash` UInt64, + `NormalizedEndURLHash` UInt64, + `TopLevelDomain` UInt64, + `URLScheme` UInt64, + `OpenstatServiceNameHash` UInt64, + `OpenstatCampaignIDHash` UInt64, + `OpenstatAdIDHash` UInt64, + `OpenstatSourceIDHash` UInt64, + `UTMSourceHash` UInt64, + `UTMMediumHash` UInt64, + `UTMCampaignHash` UInt64, + `UTMContentHash` UInt64, + `UTMTermHash` UInt64, + `FromHash` UInt64, + `WebVisorEnabled` UInt8, + `WebVisorActivity` UInt32, + `ParsedParams` Nested( + Key1 String, + Key2 String, + Key3 String, + Key4 String, + Key5 String, + ValueDouble Float64), + `Market` Nested( + Type UInt8, + GoalID UInt32, + OrderID String, + OrderPrice Int64, + PP UInt32, + DirectPlaceID UInt32, + DirectOrderID UInt32, + DirectBannerID UInt32, + GoodID String, + GoodName String, + GoodQuantity Int32, + GoodPrice Int64), + `IslandID` FixedString(16) +) +ENGINE = CollapsingMergeTree(Sign) +PARTITION BY toYYYYMM(StartDate) +ORDER BY (CounterID, StartDate, intHash32(UserID), VisitID) +SAMPLE BY intHash32(UserID) +SETTINGS index_granularity = 8192 +``` + +Etkileşimli modunu kullanarak bu sorguları yürütebilirsiniz `clickhouse-client` (sadece önceden bir sorgu belirtmeden bir terminalde başlatın) veya bazı deneyin [alternatif arayüz](../interfaces/index.md) Eğer isterseniz. + +Gördüğümüz gibi, `hits_v1` kullanır [temel MergeTree motoru](../engines/table_engines/mergetree_family/mergetree.md), WH whileile the `visits_v1` kullanır [Çökme](../engines/table_engines/mergetree_family/collapsingmergetree.md) varyant. + +### Verileri İçe Aktar {#import-data} + +Clickhouse'a veri aktarımı yapılır [INSERT INTO](../sql_reference/statements/insert_into.md) diğer birçok SQL veritabanlarında olduğu gibi sorgu. Bununla birlikte, veriler genellikle [desteklenen seri hale getirme biçimleri](../interfaces/formats.md) yerine `VALUES` fıkra clausesı (ayrıca desteklenmektedir). + +Onları almak için ne kadar daha önce indirdiğimiz dosyaları sekme ayrılmış biçimde, yani burada konsol istemci ile : + +``` bash +clickhouse-client --query "INSERT INTO tutorial.hits_v1 FORMAT TSV" --max_insert_block_size=100000 < hits_v1.tsv +clickhouse-client --query "INSERT INTO tutorial.visits_v1 FORMAT TSV" --max_insert_block_size=100000 < visits_v1.tsv +``` + +ClickHouse bir yeri vardır [ayarlan settingsacak ayarlar](../operations/settings/index.md) ve bunları konsol istemcisinde belirtmenin bir yolu, görebildiğimiz gibi argümanlar aracılığıyla `--max_insert_block_size`. Hangi ayarların mevcut olduğunu, ne anlama geldiğini ve varsayılanların ne olduğunu anlamanın en kolay yolu `system.settings` Tablo: + +``` sql +SELECT name, value, changed, description +FROM system.settings +WHERE name LIKE '%max_insert_b%' +FORMAT TSV + +max_insert_block_size 1048576 0 "The maximum block size for insertion, if we control the creation of blocks for insertion." +``` + +İsteğe bağlı olarak şunları yapabilirsiniz [OPTIMIZE](../sql_reference/statements/misc.md#misc_operations-optimize) ithalattan sonra tablolar. MergeTree-family'den bir motorla yapılandırılmış tablolar, veri depolamayı en iyi duruma getirmek (veya en azından mantıklı olup olmadığını kontrol etmek) için her zaman arka planda veri parçalarının birleştirilmesini sağlar. Bu sorgular, tablo motorunu bir süre sonra yerine şu anda depolama optimizasyonu yapmaya zorlar: + +``` bash +clickhouse-client --query "OPTIMIZE TABLE tutorial.hits_v1 FINAL" +clickhouse-client --query "OPTIMIZE TABLE tutorial.visits_v1 FINAL" +``` + +Bu sorgular bir G/Ç ve CPU yoğun işlem başlatır, bu nedenle tablo sürekli olarak yeni veriler alırsa, onu yalnız bırakmak ve birleştirmelerin arka planda çalışmasına izin vermek daha iyidir. + +Şimdi tablo ithalatının başarılı olup olmadığını kontrol edebiliriz: + +``` bash +clickhouse-client --query "SELECT COUNT(*) FROM tutorial.hits_v1" +clickhouse-client --query "SELECT COUNT(*) FROM tutorial.visits_v1" +``` + +## Örnek Sorgular {#example-queries} + +``` sql +SELECT + StartURL AS URL, + AVG(Duration) AS AvgDuration +FROM tutorial.visits_v1 +WHERE StartDate BETWEEN '2014-03-23' AND '2014-03-30' +GROUP BY URL +ORDER BY AvgDuration DESC +LIMIT 10 +``` + +``` sql +SELECT + sum(Sign) AS visits, + sumIf(Sign, has(Goals.ID, 1105530)) AS goal_visits, + (100. * goal_visits) / visits AS goal_percent +FROM tutorial.visits_v1 +WHERE (CounterID = 912887) AND (toYYYYMM(StartDate) = 201403) AND (domain(StartURL) = 'yandex.ru') +``` + +## Küme Dağıtımı {#cluster-deployment} + +ClickHouse kümesi homojen bir kümedir. Kurulum adımları: + +1. Kümenin tüm makinelerine ClickHouse Server'ı yükleyin +2. Yapılandırma dosyalarında küme yapılandırmalarını ayarlama +3. Her örnekte yerel tablolar oluşturun +4. Create a [Dağıtılmış tablo](../engines/table_engines/special/distributed.md) + +[Dağıtılmış tablo](../engines/table_engines/special/distributed.md) aslında bir tür “view” ClickHouse kümesinin yerel tablolarına. Dağıtılmış bir tablodan sorgu seçin, tüm kümenin parçalarının kaynaklarını kullanarak yürütür. Birden çok küme için yapılandırmalar belirtebilir ve farklı kümelere görünümler sağlayan birden çok dağıtılmış tablo oluşturabilirsiniz. + +Her biri bir kopya olan üç parçalı bir küme için örnek yapılandırma: + +``` xml + + + + + example-perftest01j.yandex.ru + 9000 + + + + + example-perftest02j.yandex.ru + 9000 + + + + + example-perftest03j.yandex.ru + 9000 + + + + +``` + +Daha fazla gösteri için, aynı ile yeni bir yerel tablo oluşturalım `CREATE TABLE` için kullandığımız sorgu `hits_v1` ama farklı bir tablo adı: + +``` sql +CREATE TABLE tutorial.hits_local (...) ENGINE = MergeTree() ... +``` + +Kümenin yerel tablolarına bir görünüm sağlayan dağıtılmış bir tablo oluşturma: + +``` sql +CREATE TABLE tutorial.hits_all AS tutorial.hits_local +ENGINE = Distributed(perftest_3shards_1replicas, tutorial, hits_local, rand()); +``` + +Yaygın bir uygulama, kümenin tüm makinelerinde benzer dağıtılmış tablolar oluşturmaktır. Kümenin herhangi bir makinesinde dağıtılmış sorguları çalıştırmaya izin verir. Ayrıca, belirli bir SELECT sorgusu için geçici dağıtılmış tablo oluşturmak için alternatif bir seçenek vardır [uzak](../sql_reference/table_functions/remote.md) tablo işlevi. + +Hadi koşalım [INSERT SELECT](../sql_reference/statements/insert_into.md) tabloyu birden çok sunucuya yaymak için dağıtılmış tabloya. + +``` sql +INSERT INTO tutorial.hits_all SELECT * FROM tutorial.hits_v1; +``` + +!!! warning "Bildirim" + Bu yaklaşım büyük tabloların parçalanması için uygun değildir. Ayrı bir araç var [clickhouse-fotokopi makinesi](../operations/utilities/clickhouse-copier.md) bu keyfi büyük tabloları yeniden parçalayabilir. + +Tahmin edebileceğiniz gibi, hesaplamalı olarak ağır sorgular, bir yerine 3 sunucu kullanıyorsa n kat daha hızlı çalışır. + +Bu durumda, 3 parçaya sahip bir küme kullandık ve her biri tek bir kopya içeriyor. + +Bir üretim ortamında esneklik sağlamak için, her bir parçanın birden çok kullanılabilirlik bölgesi veya veri merkezleri (veya en azından raflar) arasında yayılmış 2-3 kopya içermesi önerilir. ClickHouse yinelemeler sınırsız sayıda desteklediğini unutmayın. + +Üç yineleme içeren bir parça kümesi için örnek yapılandırma: + +``` xml + + ... + + + + example-perftest01j.yandex.ru + 9000 + + + example-perftest02j.yandex.ru + 9000 + + + example-perftest03j.yandex.ru + 9000 + + + + +``` + +Yerel çoğaltmayı etkinleştirmek için [ZooKeeper](http://zookeeper.apache.org/) gereklidir. ClickHouse tüm yinelemeler üzerinde veri tutarlılığı ilgilenir ve otomatik olarak hatadan sonra prosedürü geri çalışır. ZooKeeper kümesinin ayrı sunuculara dağıtılması önerilir(ClickHouse dahil başka hiçbir işlem çalışmaz). + +!!! note "Not" + ZooKeeper sıkı bir gereklilik değildir: bazı basit durumlarda, verileri uygulama kodunuzdan tüm kopyalara yazarak çoğaltabilirsiniz. Bu yaklaşım **değil** önerilen, bu durumda, ClickHouse tüm yinelemelerde veri tutarlılığını garanti edemez. Böylece başvurunuzun sorumluluğu haline gelir. + +Zookeeper konumları yapılandırma dosyasında belirtilir: + +``` xml + + + zoo01.yandex.ru + 2181 + + + zoo02.yandex.ru + 2181 + + + zoo03.yandex.ru + 2181 + + +``` + +Ayrıca, tablo oluşturulmasında kullanılan her bir parça ve kopyayı tanımlamak için makrolar ayarlamamız gerekir: + +``` xml + + 01 + 01 + +``` + +Yinelenmiş tablo oluşturma şu anda hiçbir yinelemeler varsa, yeni bir ilk yineleme örneği. Zaten canlı yinelemeler varsa, yeni yineleme varolan verileri klonlar. Önce tüm çoğaltılmış tablolar oluşturmak ve sonra veri eklemek için bir seçeneğiniz vardır. Başka bir seçenek, bazı yinelemeler oluşturmak ve veri ekleme sırasında veya sonrasında diğerlerini eklemektir. + +``` sql +CREATE TABLE tutorial.hits_replica (...) +ENGINE = ReplcatedMergeTree( + '/clickhouse_perftest/tables/{shard}/hits', + '{replica}' +) +... +``` + +Burada kullanıyoruz [ReplicatedMergeTree](../engines/table_engines/mergetree_family/replication.md) masa motoru. Parametrelerde, Shard ve çoğaltma tanımlayıcılarını içeren ZooKeeper yolunu belirtiyoruz. + +``` sql +INSERT INTO tutorial.hits_replica SELECT * FROM tutorial.hits_local; +``` + +Çoğaltma çok ana modda çalışır. Veriler herhangi bir kopyaya yüklenebilir ve sistem daha sonra otomatik olarak diğer örneklerle eşitler. Çoğaltma zaman uyumsuz olduğundan, belirli bir anda, tüm yinelemeler son eklenen verileri içerebilir. Veri alımına izin vermek için en az bir kopya olmalıdır. Diğerleri verileri senkronize eder ve tekrar aktif hale geldiklerinde tutarlılığı onarır. Bu yaklaşımın, yakın zamanda eklenen veri kaybı olasılığının düşük olmasına izin verdiğini unutmayın. + +[Orijinal makale](https://clickhouse.tech/docs/en/getting_started/tutorial/) diff --git a/docs/tr/guides/apply_catboost_model.md b/docs/tr/guides/apply_catboost_model.md new file mode 100644 index 00000000000..92bfac226f2 --- /dev/null +++ b/docs/tr/guides/apply_catboost_model.md @@ -0,0 +1,239 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 41 +toc_title: CatBoost Modellerini Uygulamak +--- + +# Clickhouse'da bir Catboost modeli uygulamak {#applying-catboost-model-in-clickhouse} + +[CatBoost](https://catboost.ai) geliştirilen ücretsiz ve açık kaynak kodlu bir GRA anddi libraryent kütüphan aesidir. [Yandex](https://yandex.com/company/) makine öğrenimi için. + +Bu Talimatla, Sql'den model çıkarımı çalıştırarak Clickhouse'da önceden eğitilmiş modelleri uygulamayı öğreneceksiniz. + +Clickhouse'da bir CatBoost modeli uygulamak için: + +1. [Tablo oluşturma](#create-table). +2. [Verileri tabloya ekleme](#insert-data-to-table). +3. [Catboost'u Clickhouse'a entegre edin](#integrate-catboost-into-clickhouse) (İsteğe bağlı adım). +4. [SQL'DEN Model Çıkarımını çalıştırın](#run-model-inference). + +Eğitim CatBoost modelleri hakkında daha fazla bilgi için bkz [Eğitim ve uygulama modelleri](https://catboost.ai/docs/features/training.html#training). + +## Önkoşullar {#prerequisites} + +Eğer yoksa [Docker](https://docs.docker.com/install/) yine de yükleyin. + +!!! note "Not" + [Docker](https://www.docker.com) sistemin geri kalanından bir CatBoost ve ClickHouse kurulumunu izole eden kaplar oluşturmanıza olanak sağlayan bir yazılım platformudur. + +Bir CatBoost modeli uygulamadan önce: + +**1.** P pullull the [Docker görüntü](https://hub.docker.com/r/yandex/tutorial-catboost-clickhouse) kayıt defter theinden: + +``` bash +$ docker pull yandex/tutorial-catboost-clickhouse +``` + +Kod, çalışma zamanı, kütüphaneler, ortam değişkenleri ve Yapılandırma Dosyaları: bu Docker görüntü catboost ve ClickHouse çalıştırmak için gereken her şeyi içerir. + +**2.** Docker görüntüsünün başarıyla çekildiğinden emin olun: + +``` bash +$ docker image ls +REPOSITORY TAG IMAGE ID CREATED SIZE +yandex/tutorial-catboost-clickhouse latest 622e4d17945b 22 hours ago 1.37GB +``` + +**3.** Bu görüntüye dayalı bir Docker kabı başlatın: + +``` bash +$ docker run -it -p 8888:8888 yandex/tutorial-catboost-clickhouse +``` + +## 1. Tablo oluşturma {#create-table} + +Eğitim örneği için bir ClickHouse tablosu oluşturmak için: + +**1.** Etkileşimli modda ClickHouse konsol istemcisini başlatın: + +``` bash +$ clickhouse client +``` + +!!! note "Not" + Clickhouse sunucusu Docker kapsayıcısı içinde zaten çalışıyor. + +**2.** Komutu kullanarak tablo oluşturun: + +``` sql +:) CREATE TABLE amazon_train +( + date Date MATERIALIZED today(), + ACTION UInt8, + RESOURCE UInt32, + MGR_ID UInt32, + ROLE_ROLLUP_1 UInt32, + ROLE_ROLLUP_2 UInt32, + ROLE_DEPTNAME UInt32, + ROLE_TITLE UInt32, + ROLE_FAMILY_DESC UInt32, + ROLE_FAMILY UInt32, + ROLE_CODE UInt32 +) +ENGINE = MergeTree ORDER BY date +``` + +**3.** ClickHouse konsol istemcisinden çıkış: + +``` sql +:) exit +``` + +## 2. Verileri tabloya ekleme {#insert-data-to-table} + +Verileri eklemek için: + +**1.** Aşağıdaki komutu çalıştırın: + +``` bash +$ clickhouse client --host 127.0.0.1 --query 'INSERT INTO amazon_train FORMAT CSVWithNames' < ~/amazon/train.csv +``` + +**2.** Etkileşimli modda ClickHouse konsol istemcisini başlatın: + +``` bash +$ clickhouse client +``` + +**3.** Verilerin yüklendiğinden emin olun: + +``` sql +:) SELECT count() FROM amazon_train + +SELECT count() +FROM amazon_train + ++-count()-+ +| 65538 | ++-------+ +``` + +## 3. Catboost'u Clickhouse'a entegre edin {#integrate-catboost-into-clickhouse} + +!!! note "Not" + **İsteğe bağlı adım.** Docker görüntü catboost ve ClickHouse çalıştırmak için gereken her şeyi içerir. + +Catboost'u Clickhouse'a entegre etmek için: + +**1.** Değerlendirme kitaplığı oluşturun. + +Bir CatBoost modelini değerlendirmenin en hızlı yolu derlemedir `libcatboostmodel.` kitaplık. Kitaplığın nasıl oluşturulacağı hakkında daha fazla bilgi için bkz. [CatBoost belgeleri](https://catboost.ai/docs/concepts/c-plus-plus-api_dynamic-c-pluplus-wrapper.html). + +**2.** Herhangi bir yerde ve herhangi bir adla yeni bir dizin oluşturun, örneğin, `data` ve oluşturulan kütüphaneyi içine koyun. Docker görüntüsü zaten kütüphaneyi içeriyor `data/libcatboostmodel.so`. + +**3.** Yapılandırma modeli için herhangi bir yerde ve herhangi bir adla yeni bir dizin oluşturun, örneğin, `models`. + +**4.** Örneğin, herhangi bir ada sahip bir model yapılandırma dosyası oluşturun, `models/amazon_model.xml`. + +**5.** Model yapılandırmasını açıklayın: + +``` xml + + + + catboost + + amazon + + /home/catboost/tutorial/catboost_model.bin + + 0 + + +``` + +**6.** Catboost yolunu ve model yapılandırmasını ClickHouse yapılandırmasına ekleyin: + +``` xml + +/home/catboost/data/libcatboostmodel.so +/home/catboost/models/*_model.xml +``` + +## 4. SQL'DEN Model Çıkarımını çalıştırın {#run-model-inference} + +Test modeli için ClickHouse istemcisini çalıştırın `$ clickhouse client`. + +Modelin çalıştığından emin olalım: + +``` sql +:) SELECT + modelEvaluate('amazon', + RESOURCE, + MGR_ID, + ROLE_ROLLUP_1, + ROLE_ROLLUP_2, + ROLE_DEPTNAME, + ROLE_TITLE, + ROLE_FAMILY_DESC, + ROLE_FAMILY, + ROLE_CODE) > 0 AS prediction, + ACTION AS target +FROM amazon_train +LIMIT 10 +``` + +!!! note "Not" + İşlev [modelEvaluate](../sql_reference/functions/other_functions.md#function-modelevaluate) multiclass modelleri için sınıf başına ham tahminleri ile tuple döndürür. + +Olasılığı tahmin edelim: + +``` sql +:) SELECT + modelEvaluate('amazon', + RESOURCE, + MGR_ID, + ROLE_ROLLUP_1, + ROLE_ROLLUP_2, + ROLE_DEPTNAME, + ROLE_TITLE, + ROLE_FAMILY_DESC, + ROLE_FAMILY, + ROLE_CODE) AS prediction, + 1. / (1 + exp(-prediction)) AS probability, + ACTION AS target +FROM amazon_train +LIMIT 10 +``` + +!!! note "Not" + Hakkında daha fazla bilgi [exp()](../sql_reference/functions/math_functions.md) işlev. + +Örnek üzerinde LogLoss hesaplayalım: + +``` sql +:) SELECT -avg(tg * log(prob) + (1 - tg) * log(1 - prob)) AS logloss +FROM +( + SELECT + modelEvaluate('amazon', + RESOURCE, + MGR_ID, + ROLE_ROLLUP_1, + ROLE_ROLLUP_2, + ROLE_DEPTNAME, + ROLE_TITLE, + ROLE_FAMILY_DESC, + ROLE_FAMILY, + ROLE_CODE) AS prediction, + 1. / (1. + exp(-prediction)) AS prob, + ACTION AS tg + FROM amazon_train +) +``` + +!!! note "Not" + Hakkında daha fazla bilgi [avg()](../sql_reference/aggregate_functions/reference.md#agg_function-avg) ve [günlük()](../sql_reference/functions/math_functions.md) işlevler. + +[Orijinal makale](https://clickhouse.tech/docs/en/guides/apply_catboost_model/) diff --git a/docs/tr/guides/index.md b/docs/tr/guides/index.md new file mode 100644 index 00000000000..95ad65443b0 --- /dev/null +++ b/docs/tr/guides/index.md @@ -0,0 +1,16 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "K\u0131lavuzlar" +toc_priority: 38 +toc_title: "Genel bak\u0131\u015F" +--- + +# ClickHouse Kılavuzları {#clickhouse-guides} + +ClickHouse kullanarak çeşitli görevleri çözmeye yardımcı olan ayrıntılı adım adım talimatların listesi: + +- [Basit küme kurulumu eğitimi](../getting_started/tutorial.md) +- [Clickhouse'da bir CatBoost modeli uygulamak](apply_catboost_model.md) + +[Orijinal makale](https://clickhouse.tech/docs/en/guides/) diff --git a/docs/tr/images b/docs/tr/images new file mode 120000 index 00000000000..73937c941ec --- /dev/null +++ b/docs/tr/images @@ -0,0 +1 @@ +../en/images \ No newline at end of file diff --git a/docs/tr/index.md b/docs/tr/index.md new file mode 100644 index 00000000000..0ef0f264b87 --- /dev/null +++ b/docs/tr/index.md @@ -0,0 +1,139 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 0 +toc_title: "Genel bak\u0131\u015F" +--- + +# ClickHouse nedir? {#what-is-clickhouse} + +ClickHouse, sorguların çevrimiçi analitik işlenmesi (OLAP) için sütun odaklı bir veritabanı yönetim sistemidir (DBMS). + +İn a “normal” satır yönelimli DBMS, veri bu sırayla saklanır: + +| Satır | Watchıd | JavaEnable | Başlık | GoodEvent | EventTime | +|-------|-------------|------------|----------------------|-----------|---------------------| +| \#0 | 89354350662 | 1 | Yatırımcı İlişkileri | 1 | 2016-05-18 05:19:20 | +| \#1 | 90329509958 | 0 | Bize ulaşın | 1 | 2016-05-18 08:10:20 | +| \#2 | 89953706054 | 1 | Görev | 1 | 2016-05-18 07:38:00 | +| \#N | … | … | … | … | … | + +Başka bir deyişle, bir satırla ilgili tüm değerler fiziksel olarak yan yana depolanır. + +Satır yönelimli DBMS örnekleri MySQL, Postgres ve MS SQL Server'dır. + +Sütun yönelimli bir DBMS'DE, veriler şu şekilde saklanır: + +| Satır: | \#0 | \#1 | \#2 | \#N | +|-------------|----------------------|---------------------|---------------------|-----| +| Watchıd: | 89354350662 | 90329509958 | 89953706054 | … | +| JavaEnable: | 1 | 0 | 1 | … | +| Başlık: | Yatırımcı İlişkileri | Bize ulaşın | Görev | … | +| GoodEvent: | 1 | 1 | 1 | … | +| EventTime: | 2016-05-18 05:19:20 | 2016-05-18 08:10:20 | 2016-05-18 07:38:00 | … | + +Bu örnekler yalnızca verilerin düzenlendiği sırayı gösterir. Farklı sütunlardaki değerler ayrı olarak depolanır ve aynı sütundaki veriler birlikte depolanır. + +Bir sütun odaklı DBMS örnekleri: Vertica, Paraccel (Actian Matrix ve Amazon Redshift), Sybase IQ, Exasol, Infobright, InfiniDB, MonetDB (VectorWise ve Actian vektör), LucidDB, SAP HANA, Google Dremel, Google PowerDrill, Druid ve kdb+. + +Different orders for storing data are better suited to different scenarios. The data access scenario refers to what queries are made, how often, and in what proportion; how much data is read for each type of query – rows, columns, and bytes; the relationship between reading and updating data; the working size of the data and how locally it is used; whether transactions are used, and how isolated they are; requirements for data replication and logical integrity; requirements for latency and throughput for each type of query, and so on. + +Sistem üzerindeki yük ne kadar yüksek olursa, kullanım senaryosunun gereksinimlerine uyacak şekilde ayarlanmış sistemi özelleştirmek o kadar önemlidir ve bu özelleştirme o kadar ince taneli olur. Önemli ölçüde farklı senaryolara eşit derecede uygun bir sistem yoktur. Bir sistem geniş bir senaryo kümesine uyarlanabilirse, yüksek bir yük altında, sistem tüm senaryoları eşit derecede zayıf bir şekilde ele alır veya olası senaryolardan yalnızca biri veya birkaçı için iyi çalışır. + +## OLAP senaryosunun temel özellikleri {#key-properties-of-olap-scenario} + +- İsteklerin büyük çoğunluğu okuma erişimi içindir. +- Veriler, tek satırlarla değil, oldukça büyük gruplar halinde (\> 1000 satır) güncellenir; veya hiç güncellenmez. +- Veri DB eklenir, ancak değiştirilmez. +- Okumalar için, dB'den oldukça fazla sayıda satır çıkarılır,ancak yalnızca küçük bir sütun alt kümesi. +- Tablolar şunlardır “wide,” çok sayıda sütun içerdikleri anlamına gelir. +- Sorgular nispeten nadirdir (genellikle sunucu başına yüzlerce sorgu veya saniyede daha az). +- Basit sorgular için, 50 ms civarında gecikmelere izin verilir. +- Sütun değerleri oldukça küçüktür: sayılar ve kısa dizeler (örneğin, URL başına 60 bayt). +- Tek bir sorguyu işlerken yüksek verim gerektirir (sunucu başına saniyede milyarlarca satıra kadar). +- İşlemler gerekli değildir. +- Veri tutarlılığı için düşük gereksinimler. +- Sorgu başına bir büyük tablo var. Biri hariç tüm tablolar küçüktür. +- Bir sorgu sonucu, kaynak veriden önemli ölçüde daha küçüktür. Başka bir deyişle, veriler filtrelenir veya toplanır, böylece sonuç tek bir sunucunun RAM'İNE sığar. + +OLAP senaryosunun diğer popüler senaryolardan (OLTP veya anahtar değeri erişimi gibi) çok farklı olduğunu görmek kolaydır. Bu nedenle, iyi bir performans elde etmek istiyorsanız, analitik sorguları işlemek için OLTP veya anahtar değeri DB'Yİ kullanmayı denemek mantıklı değildir. Örneğin, analitik için MongoDB veya Redis kullanmaya çalışırsanız, OLAP veritabanlarına kıyasla çok düşük performans elde edersiniz. + +## Sütun yönelimli veritabanları OLAP senaryosunda neden daha iyi çalışır {#why-column-oriented-databases-work-better-in-the-olap-scenario} + +Sütun yönelimli veritabanları OLAP senaryolarına daha uygundur: çoğu sorgunun işlenmesinde en az 100 kat daha hızlıdır. Nedenleri aşağıda ayrıntılı olarak açıklanmıştır, ancak gerçek görsel olarak göstermek daha kolaydır: + +**Satır yönelimli DBMS** + +![Row-oriented](images/row_oriented.gif#) + +**Sütun yönelimli DBMS** + +![Column-oriented](images/column_oriented.gif#) + +Farkı görüyor musun? + +### Giriş/çıkış {#inputoutput} + +1. Analitik bir sorgu için, yalnızca az sayıda tablo sütununun okunması gerekir. Sütun yönelimli bir veritabanında, yalnızca ihtiyacınız olan verileri okuyabilirsiniz. Örneğin, 100 üzerinden 5 sütun gerekiyorsa, g/Ç'de 20 kat azalma bekleyebilirsiniz. +2. Veri paketler halinde okunduğundan, sıkıştırılması daha kolaydır. Sütunlardaki verilerin sıkıştırılması da daha kolaydır. Bu, G/Ç hacmini daha da azaltır. +3. Azaltılmış G/Ç nedeniyle, sistem önbelleğine daha fazla veri sığar. + +Örneğin, sorgu “count the number of records for each advertising platform” bir okuma gerektirir “advertising platform ID” 1 bayt sıkıştırılmamış kadar alır sütun. Trafiğin çoğu reklam platformlarından değilse, bu sütunun en az 10 kat sıkıştırılmasını bekleyebilirsiniz. Hızlı bir sıkıştırma algoritması kullanırken, saniyede en az birkaç gigabayt sıkıştırılmamış veri hızında veri dekompresyonu mümkündür. Başka bir deyişle, bu sorgu, tek bir sunucuda saniyede yaklaşık birkaç milyar satır hızında işlenebilir. Bu hız aslında pratikte elde edilir. + +
+ +Örnek + +``` bash +$ clickhouse-client +ClickHouse client version 0.0.52053. +Connecting to localhost:9000. +Connected to ClickHouse server version 0.0.52053. +``` + +``` sql +SELECT CounterID, count() FROM hits GROUP BY CounterID ORDER BY count() DESC LIMIT 20 +``` + +``` text +┌─CounterID─┬──count()─┐ +│ 114208 │ 56057344 │ +│ 115080 │ 51619590 │ +│ 3228 │ 44658301 │ +│ 38230 │ 42045932 │ +│ 145263 │ 42042158 │ +│ 91244 │ 38297270 │ +│ 154139 │ 26647572 │ +│ 150748 │ 24112755 │ +│ 242232 │ 21302571 │ +│ 338158 │ 13507087 │ +│ 62180 │ 12229491 │ +│ 82264 │ 12187441 │ +│ 232261 │ 12148031 │ +│ 146272 │ 11438516 │ +│ 168777 │ 11403636 │ +│ 4120072 │ 11227824 │ +│ 10938808 │ 10519739 │ +│ 74088 │ 9047015 │ +│ 115079 │ 8837972 │ +│ 337234 │ 8205961 │ +└───────────┴──────────┘ +``` + +
+ +### CPU {#cpu} + +Bir sorguyu yürütmek çok sayıda satırı işlemeyi gerektirdiğinden, ayrı satırlar yerine tüm vektörler için tüm işlemlerin gönderilmesine veya sorgu motorunun neredeyse hiç gönderim maliyeti olmaması için uygulanmasına yardımcı olur. Bunu yapmazsanız, yarı iyi bir disk alt sistemi ile, sorgu yorumlayıcısı kaçınılmaz olarak CPU'yu durdurur. Hem verileri sütunlarda depolamak hem de mümkün olduğunda sütunlarla işlemek mantıklıdır. + +Bunu yapmanın iki yolu vardır: + +1. Bir vektör motoru. Tüm işlemler ayrı değerler yerine vektörler için yazılır. Bu, işlemleri çok sık aramanıza gerek olmadığı ve sevkiyatın maliyetlerinin ihmal edilebilir olduğu anlamına gelir. İşlem kodu optimize edilmiş bir iç döngü içerir. + +2. Kod üretimi. Sorgu için oluşturulan kod, içindeki tüm dolaylı çağrılara sahiptir. + +Bu yapılmaz “normal” veritabanları, çünkü basit sorguları çalıştırırken mantıklı değil. Ancak, istisnalar vardır. Örneğin, MemSQL SQL sorgularını işlerken gecikmeyi azaltmak için kod oluşturma kullanır. (Karşılaştırma için, analitik Dbms'ler gecikme değil, verim optimizasyonunu gerektirir .) + +CPU verimliliği için sorgu dilinin bildirimsel (SQL veya MDX) veya en az bir vektör (J, K) olması gerektiğini unutmayın. Sorgu yalnızca en iyi duruma getirme için izin veren örtük döngüler içermelidir. + +{## [Orijinal makale](https://clickhouse.tech/docs/en/) ##} diff --git a/docs/tr/interfaces/cli.md b/docs/tr/interfaces/cli.md new file mode 100644 index 00000000000..c526105dfe7 --- /dev/null +++ b/docs/tr/interfaces/cli.md @@ -0,0 +1,149 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 17 +toc_title: "Komut Sat\u0131r\u0131 \u0130stemcisi" +--- + +# Komut satırı istemcisi {#command-line-client} + +ClickHouse yerel bir komut satırı istemcisi sağlar: `clickhouse-client`. İstemci komut satırı seçeneklerini ve yapılandırma dosyalarını destekler. Daha fazla bilgi için, bkz. [Yapılandırma](#interfaces_cli_configuration). + +[Yüklemek](../getting_started/index.md) ıt from the `clickhouse-client` paketleyin ve komutla çalıştırın `clickhouse-client`. + +``` bash +$ clickhouse-client +ClickHouse client version 19.17.1.1579 (official build). +Connecting to localhost:9000 as user default. +Connected to ClickHouse server version 19.17.1 revision 54428. + +:) +``` + +Farklı istemci ve sunucu sürümleri birbiriyle uyumludur, ancak bazı özellikler eski istemcilerde kullanılamayabilir. Biz sunucu uygulaması olarak istemci aynı sürümünü kullanmanızı öneririz. Eski sürümün bir istemcisini kullanmaya çalıştığınızda, daha sonra sunucu, `clickhouse-client` mesajı görüntüler: + + ClickHouse client version is older than ClickHouse server. It may lack support for new features. + +## Kullanma {#cli_usage} + +İstemci etkileşimli ve etkileşimli olmayan (toplu iş) modunda kullanılabilir. Toplu iş modunu kullanmak için ‘query’ parametre veya veri göndermek ‘stdin’ (bunu doğrular ‘stdin’ bir terminal değildir) veya her ikisi de. HTTP arayüzüne benzer, kullanırken ‘query’ parametre ve veri gönderme ‘stdin’, istek bir birleştirme olduğunu ‘query’ parametre, bir satır besleme ve veri ‘stdin’. Bu, büyük ekleme sorguları için uygundur. + +Veri eklemek için istemci kullanma örneği: + +``` bash +$ echo -ne "1, 'some text', '2016-08-14 00:00:00'\n2, 'some more text', '2016-08-14 00:00:01'" | clickhouse-client --database=test --query="INSERT INTO test FORMAT CSV"; + +$ cat <<_EOF | clickhouse-client --database=test --query="INSERT INTO test FORMAT CSV"; +3, 'some text', '2016-08-14 00:00:00' +4, 'some more text', '2016-08-14 00:00:01' +_EOF + +$ cat file.csv | clickhouse-client --database=test --query="INSERT INTO test FORMAT CSV"; +``` + +Toplu iş modunda, varsayılan veri biçimi TabSeparated. Sorgunun biçim yan tümcesinde biçimi ayarlayabilirsiniz. + +Varsayılan olarak, yalnızca tek bir sorguyu toplu iş modunda işleyebilirsiniz. Birden çok sorgu yapmak için bir “script,” kullan... `--multiquery` parametre. Bu, INSERT dışındaki tüm sorgular için çalışır. Sorgu sonuçları, ek ayırıcılar olmadan ardışık olarak çıktılanır. Benzer şekilde, çok sayıda sorgu işlemek için, çalıştırabilirsiniz ‘clickhouse-client’ her sorgu için. Başlatmak için onlarca milisaniye sürebilir unutmayın ‘clickhouse-client’ program. + +Etkileşimli modda, sorguları girebileceğiniz bir komut satırı alırsınız. + +Eğer ‘multiline’ belirtilmemiş (varsayılan): sorguyu çalıştırmak için Enter tuşuna basın. Noktalı virgül, sorgunun sonunda gerekli değildir. Çok satırlı bir sorgu girmek için ters eğik çizgi girin `\` hat beslemeden önce. Enter tuşuna bastıktan sonra, sorgunun sonraki satırını girmeniz istenecektir. + +Çok satırlı belirtilirse: bir sorguyu çalıştırmak için, noktalı virgülle sonlandırın ve Enter tuşuna basın. Noktalı virgül, girilen satırın sonunda atlandıysa, sorgunun bir sonraki satırını girmeniz istenecektir. + +Yalnızca tek bir sorgu çalıştırılır, bu nedenle noktalı virgülden sonra her şey göz ardı edilir. + +Belirtebilirsiniz `\G` noktalı virgül yerine veya sonra. Bu dikey biçimi gösterir. Bu formatta, her değer geniş tablolar için uygun olan ayrı bir satıra yazdırılır. Bu sıradışı özellik MySQL CLI ile uyumluluk için eklendi. + +Komut satırı dayanmaktadır ‘replxx’ (benzer ‘readline’). Başka bir deyişle, tanıdık klavye kısayollarını kullanır ve bir geçmişi tutar. Tarih yazılır `~/.clickhouse-client-history`. + +Varsayılan olarak, kullanılan biçim PrettyCompact. Sorgunun biçim yan tümcesinde veya belirterek biçimi değiştirebilirsiniz `\G` sorgunun sonunda, `--format` veya `--vertical` komut satırında veya istemci yapılandırma dosyasını kullanarak bağımsız değişken. + +İstemciden çıkmak için Ctrl+D (veya Ctrl+C) tuşlarına basın veya bir sorgu yerine aşağıdakilerden birini girin: “exit”, “quit”, “logout”, “exit;”, “quit;”, “logout;”, “q”, “Q”, “:q” + +Bir sorguyu işlerken, istemci şunları gösterir: + +1. Saniyede en fazla 10 kez güncellenen ilerleme (varsayılan olarak). Hızlı sorgular için ilerleme görüntülenecek zaman olmayabilir. +2. Hata ayıklama için ayrıştırmadan sonra biçimlendirilmiş sorgu. +3. Belirtilen biçimde sonuç. +4. Sonuçtaki satır sayısı, geçen süre ve sorgu işlemenin ortalama hızı. + +Ctrl + C tuşlarına basarak uzun bir sorguyu iptal edebilirsiniz. ancak, sunucunun isteği iptal etmesi için biraz beklemeniz gerekir. Belirli aşamalarda bir sorguyu iptal etmek mümkün değildir. Beklemezseniz ve ikinci kez Ctrl + C tuşlarına basarsanız, istemci çıkacaktır. + +Komut satırı istemcisi, sorgulamak için dış verileri (dış geçici tablolar) geçirmenize izin verir. Daha fazla bilgi için bölüme bakın “External data for query processing”. + +### Parametrelerle sorgular {#cli-queries-with-parameters} + +Parametrelerle bir sorgu oluşturabilir ve istemci uygulamasından onlara değerler aktarabilirsiniz. Bu, istemci tarafında belirli dinamik değerlerle biçimlendirme sorgusunu önlemeye izin verir. Mesela: + +``` bash +$ clickhouse-client --param_parName="[1, 2]" -q "SELECT * FROM table WHERE a = {parName:Array(UInt16)}" +``` + +#### Sorgu Sözdizimi {#cli-queries-with-parameters-syntax} + +Bir sorguyu her zamanki gibi biçimlendirin, ardından uygulama parametrelerinden sorguya geçirmek istediğiniz değerleri parantez içinde aşağıdaki biçimde yerleştirin: + +``` sql +{:} +``` + +- `name` — Placeholder identifier. In the console client it should be used in app parameters as `--param_ = value`. +- `data type` — [Veri türü](../sql_reference/data_types/index.md) app parametre değeri. Örneğin, aşağıdaki gibi bir veri yapısı `(integer, ('string', integer))` olabilir var `Tuple(UInt8, Tuple(String, UInt8))` veri türü (başka birini de kullanabilirsiniz [tamsayı](../sql_reference/data_types/int_uint.md) türler). + +#### Örnek {#example} + +``` bash +$ clickhouse-client --param_tuple_in_tuple="(10, ('dt', 10))" -q "SELECT * FROM table WHERE val = {tuple_in_tuple:Tuple(UInt8, Tuple(String, UInt8))}" +``` + +## Yapılandırma {#interfaces_cli_configuration} + +Parametreleri iletebilirsiniz `clickhouse-client` (tüm parametrelerin varsayılan değeri vardır) : + +- Komut satır fromından + + Komut satırı seçenekleri, yapılandırma dosyalarındaki varsayılan değerleri ve ayarları geçersiz kılar. + +- Yapılandırma dosyaları. + + Yapılandırma dosyalarındaki ayarlar varsayılan değerleri geçersiz kılar. + +### Komut Satırı Seçenekleri {#command-line-options} + +- `--host, -h` -– The server name, ‘localhost’ varsayılan olarak. Adı veya IPv4 veya IPv6 adresini kullanabilirsiniz. +- `--port` – The port to connect to. Default value: 9000. Note that the HTTP interface and the native interface use different ports. +- `--user, -u` – The username. Default value: default. +- `--password` – The password. Default value: empty string. +- `--query, -q` – The query to process when using non-interactive mode. +- `--database, -d` – Select the current default database. Default value: the current database from the server settings (‘default’ varsayılan) tarafından. +- `--multiline, -m` – If specified, allow multiline queries (do not send the query on Enter). +- `--multiquery, -n` – If specified, allow processing multiple queries separated by semicolons. +- `--format, -f` – Use the specified default format to output the result. +- `--vertical, -E` – If specified, use the Vertical format by default to output the result. This is the same as ‘–format=Vertical’. Bu biçimde, her bir değer, geniş tabloları görüntülerken yardımcı olan ayrı bir satıra yazdırılır. +- `--time, -t` – If specified, print the query execution time to ‘stderr’ etkileşimli olmayan modda. +- `--stacktrace` – If specified, also print the stack trace if an exception occurs. +- `--config-file` – The name of the configuration file. +- `--secure` – If specified, will connect to server over secure connection. +- `--param_` — Value for a [parametrelerle sorgu](#cli-queries-with-parameters). + +### Yapılandırma Dosyaları {#configuration_files} + +`clickhouse-client` aşağıdaki ilk varolan dosyayı kullanır: + +- Tanımlanan `--config-file` parametre. +- `./clickhouse-client.xml` +- `~/.clickhouse-client/config.xml` +- `/etc/clickhouse-client/config.xml` + +Bir yapılandırma dosyası örneği: + +``` xml + + username + password + False + +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/cli/) diff --git a/docs/tr/interfaces/cpp.md b/docs/tr/interfaces/cpp.md new file mode 100644 index 00000000000..9ebf93286ff --- /dev/null +++ b/docs/tr/interfaces/cpp.md @@ -0,0 +1,12 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 24 +toc_title: "C++ \u0130stemci Kitapl\u0131\u011F\u0131" +--- + +# C++ İstemci Kitaplığı {#c-client-library} + +Bkz. ben READİ READOKU [clickhouse-cpp](https://github.com/ClickHouse/clickhouse-cpp) depo. + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/cpp/) diff --git a/docs/tr/interfaces/formats.md b/docs/tr/interfaces/formats.md new file mode 100644 index 00000000000..f522d697aa1 --- /dev/null +++ b/docs/tr/interfaces/formats.md @@ -0,0 +1,1212 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 21 +toc_title: "Giri\u015F ve \xE7\u0131k\u0131\u015F bi\xE7imleri" +--- + +# Giriş ve çıkış verileri için biçimler {#formats} + +ClickHouse kabul ve çeşitli biçimlerde veri dönebilirsiniz. Giriş için desteklenen bir biçim, sağlanan verileri ayrıştırmak için kullanılabilir `INSERT`s, gerçekleştirmek için `SELECT`s dosya, URL veya HDFS gibi bir dosya destekli tablodan veya harici bir sözlük okumak için. Çıktı için desteklenen bir biçim düzenlemek için kullanılabilir +sonuçları bir `SELECT` ve gerçekleştirmek için `INSERT`s dosya destekli bir tabloya. + +Desteklenen formatlar şunlardır: + +| Biçimli | Girdi | Çıktı | +|-----------------------------------------------------------------|-------|-------| +| [TabSeparated](#tabseparated) | ✔ | ✔ | +| [TabSeparatedRaw](#tabseparatedraw) | ✗ | ✔ | +| [TabSeparatedWithNames](#tabseparatedwithnames) | ✔ | ✔ | +| [TabSeparatedWithNamesAndTypes](#tabseparatedwithnamesandtypes) | ✔ | ✔ | +| [Şablon](#format-template) | ✔ | ✔ | +| [TemplateİgnoreSpaces](#templateignorespaces) | ✔ | ✗ | +| [CSV](#csv) | ✔ | ✔ | +| [CSVWithNames](#csvwithnames) | ✔ | ✔ | +| [CustomSeparated](#format-customseparated) | ✔ | ✔ | +| [Değerler](#data-format-values) | ✔ | ✔ | +| [Dikey](#vertical) | ✗ | ✔ | +| [VerticalRaw](#verticalraw) | ✗ | ✔ | +| [JSON](#json) | ✗ | ✔ | +| [JSONCompact](#jsoncompact) | ✗ | ✔ | +| [JSONEachRow](#jsoneachrow) | ✔ | ✔ | +| [TSKV](#tskv) | ✔ | ✔ | +| [Çok](#pretty) | ✗ | ✔ | +| [PrettyCompact](#prettycompact) | ✗ | ✔ | +| [PrettyCompactMonoBlock](#prettycompactmonoblock) | ✗ | ✔ | +| [PrettyNoEscapes](#prettynoescapes) | ✗ | ✔ | +| [PrettySpace](#prettyspace) | ✗ | ✔ | +| [Protobuf](#protobuf) | ✔ | ✔ | +| [Avro](#data-format-avro) | ✔ | ✔ | +| [AvroConfluent](#data-format-avro-confluent) | ✔ | ✗ | +| [Parke](#data-format-parquet) | ✔ | ✔ | +| [ORC](#data-format-orc) | ✔ | ✗ | +| [RowBinary](#rowbinary) | ✔ | ✔ | +| [Rowbinarywithnames ve türleri](#rowbinarywithnamesandtypes) | ✔ | ✔ | +| [Yerel](#native) | ✔ | ✔ | +| [Boş](#null) | ✗ | ✔ | +| [XML](#xml) | ✗ | ✔ | +| [CapnProto](#capnproto) | ✔ | ✗ | + +ClickHouse ayarları ile bazı biçim işleme parametrelerini kontrol edebilirsiniz. Daha fazla bilgi için okuyun [Ayarlar](../operations/settings/settings.md) bölme. + +## TabSeparated {#tabseparated} + +Sekmede ayrı format, veri satır ile yazılır. Her satır sekmelerle ayrılmış değerler içerir. Her değer, satırdaki son değer dışında bir sekme tarafından takip edilir ve ardından bir satır beslemesi gelir. Kesinlikle Unix hat beslemeleri her yerde kabul edilir. Son satır ayrıca sonunda bir satır beslemesi içermelidir. Değerler metin biçiminde, tırnak işaretleri olmadan yazılır ve özel karakterler kaçtı. + +Bu biçim adı altında da kullanılabilir `TSV`. + +Bu `TabSeparated` format, özel programlar ve komut dosyaları kullanarak verileri işlemek için uygundur. Varsayılan olarak HTTP arabiriminde ve komut satırı istemcisinin toplu iş modunda kullanılır. Bu format aynı zamanda farklı Dbms'ler arasında veri aktarımı sağlar. Örneğin, Mysql'den bir dökümü alabilir ve Clickhouse'a yükleyebilirsiniz veya tam tersi. + +Bu `TabSeparated` biçim, toplam değerleri (TOPLAMLARLA birlikte kullanıldığında) ve aşırı değerleri (ne zaman ‘extremes’ 1 olarak ayarlanır). Bu durumlarda, toplam değerler ve aşırılıklar ana veriden sonra çıkar. Ana sonuç, toplam değerler ve aşırılıklar birbirinden boş bir çizgi ile ayrılır. Örnek: + +``` sql +SELECT EventDate, count() AS c FROM test.hits GROUP BY EventDate WITH TOTALS ORDER BY EventDate FORMAT TabSeparated`` +``` + +``` text +2014-03-17 1406958 +2014-03-18 1383658 +2014-03-19 1405797 +2014-03-20 1353623 +2014-03-21 1245779 +2014-03-22 1031592 +2014-03-23 1046491 + +0000-00-00 8873898 + +2014-03-17 1031592 +2014-03-23 1406958 +``` + +### Veri Biçimlendirme {#data-formatting} + +Tamsayı sayılar ondalık biçimde yazılır. Sayılar ekstra içerebilir “+” başlangıçtaki karakter(ayrıştırma sırasında göz ardı edilir ve biçimlendirme sırasında kaydedilmez). Negatif olmayan sayılar negatif işareti içeremez. Okurken, boş bir dizeyi sıfır olarak veya (imzalı türler için) sıfır olarak sadece eksi işaretinden oluşan bir dizeyi ayrıştırmasına izin verilir. Karşılık gelen veri türüne uymayan sayılar, hata iletisi olmadan farklı bir sayı olarak ayrıştırılabilir. + +Kayan noktalı sayılar ondalık biçimde yazılır. Nokta ondalık ayırıcı olarak kullanılır. Üstel girişler olduğu gibi desteklenir ‘inf’, ‘+inf’, ‘-inf’, ve ‘nan’. Kayan noktalı sayıların bir girişi, ondalık nokta ile başlayabilir veya sona erebilir. +Biçimlendirme sırasında kayan noktalı sayılarda doğruluk kaybolabilir. +Ayrıştırma sırasında, en yakın makine temsil edilebilir numarayı okumak kesinlikle gerekli değildir. + +Tarihler YYYY-AA-DD biçiminde yazılır ve aynı biçimde ayrıştırılır, ancak ayırıcı olarak herhangi bir karakterle ayrıştırılır. +Tarihleri ile saatleri biçiminde yazılır `YYYY-MM-DD hh:mm:ss` ve aynı biçimde ayrıştırılır, ancak ayırıcı olarak herhangi bir karakterle. +Bu, tüm sistem saat diliminde istemci veya sunucu başlatıldığında (hangi veri biçimleri bağlı olarak) oluşur. Saatli tarihler için gün ışığından yararlanma saati belirtilmedi. Bu nedenle, bir dökümü gün ışığından yararlanma saati sırasında kez varsa, dökümü tümden verileri eşleşmiyor ve ayrıştırma iki kez birini seçecektir. +Bir okuma işlemi sırasında, yanlış tarih ve Tarih saatleriyle doğal taşma veya null tarih ve saat, hata iletisi olmadan ayrıştırılabilir. + +Bir istisna olarak, tam 10 ondalık basamaktan oluşuyorsa, tarihlerin zamanlarla ayrıştırılması Unix zaman damgası biçiminde de desteklenir. Sonuç, saat dilimine bağlı değildir. Yyyy-MM-DD ss:mm:ss ve nnnnnnnnnn biçimleri otomatik olarak ayırt edilir. + +Dizeler ters eğik çizgiden kaçan özel karakterlerle çıktılanır. Çıkış için aşağıdaki çıkış dizileri kullanılır: `\b`, `\f`, `\r`, `\n`, `\t`, `\0`, `\'`, `\\`. Ayrıştırma da dizileri destekler `\a`, `\v`, ve `\xHH` (hxex kaçış dizileri) ve herhangi `\c` diz ,iler, nerede `c` herhangi bir karakter (bu diziler dönüştürülür `c`). Böylece, veri okuma, bir satır beslemesinin şu şekilde yazılabileceği formatları destekler `\n` veya `\`, veya bir çizgi besleme olarak. Örneğin, dize `Hello world` boşluk yerine kelimeler arasında bir çizgi beslemesi ile aşağıdaki varyasyonlardan herhangi birinde ayrıştırılabilir: + +``` text +Hello\nworld + +Hello\ +world +``` + +MySQL, sekmeyle ayrılmış dökümleri yazarken kullandığı için ikinci varyant desteklenir. + +Verileri TabSeparated biçiminde geçirirken kaçmanız gereken minimum karakter kümesi: sekme, satır besleme (LF) ve ters eğik çizgi. + +Sadece küçük bir sembol seti kaçtı. Terminalinizin çıktıda mahvedeceği bir dize değerine kolayca rastlayabilirsiniz. + +Diziler köşeli parantez içinde virgülle ayrılmış değerlerin bir listesi olarak yazılır. Dizideki sayı öğeleri normal olarak biçimlendirilir. `Date` ve `DateTime` türleri tek tırnak yazılır. Diz .eler yukarıdaki gibi aynı kural quoteslarla tek tırnak içinde yazılır. + +[NULL](../sql_reference/syntax.md) olarak format islanır `\N`. + +Her eleman [İçiçe](../sql_reference/data_types/nested_data_structures/nested.md) yapılar dizi olarak temsil edilir. + +Mesela: + +``` sql +CREATE TABLE nestedt +( + `id` UInt8, + `aux` Nested( + a UInt8, + b String + ) +) +ENGINE = TinyLog +``` + +``` sql +INSERT INTO nestedt Values ( 1, [1], ['a']) +``` + +``` sql +SELECT * FROM nestedt FORMAT TSV +``` + +``` text +1 [1] ['a'] +``` + +## TabSeparatedRaw {#tabseparatedraw} + +Farklıdır `TabSeparated` satırların kaçmadan yazıldığını biçimlendirin. +Bu biçim yalnızca bir sorgu sonucu çıktısı için uygundur, ancak ayrıştırma için değil (bir tabloya eklemek için veri alma). + +Bu biçim adı altında da kullanılabilir `TSVRaw`. + +## TabSeparatedWithNames {#tabseparatedwithnames} + +Bu farklıdır `TabSeparated` sütun adlarının ilk satırda yazıldığını biçimlendirin. +Ayrıştırma sırasında, ilk satır tamamen göz ardı edilir. Sütun adlarını konumlarını belirlemek veya doğruluğunu kontrol etmek için kullanamazsınız. +(Başlık satırı ayrıştırma desteği gelecekte eklenebilir .) + +Bu biçim adı altında da kullanılabilir `TSVWithNames`. + +## TabSeparatedWithNamesAndTypes {#tabseparatedwithnamesandtypes} + +Bu farklıdır `TabSeparated` sütun türleri ikinci satırda iken, sütun adlarının ilk satıra yazıldığını biçimlendirin. +Ayrıştırma sırasında, birinci ve ikinci satırlar tamamen göz ardı edilir. + +Bu biçim adı altında da kullanılabilir `TSVWithNamesAndTypes`. + +## Şablon {#format-template} + +Bu biçim, belirli bir kaçış kuralına sahip değerler için yer tutucularla özel bir biçim dizesinin belirtilmesine izin verir. + +Ayarları kullanır `format_template_resultset`, `format_template_row`, `format_template_rows_between_delimiter` and some settings of other formats (e.g. `output_format_json_quote_64bit_integers` kullanırken `JSON` kaçmak, daha fazla görmek) + +Ayar `format_template_row` aşağıdaki sözdizimine sahip satırlar için Biçim dizesi içeren dosya yolunu belirtir: + +`delimiter_1${column_1:serializeAs_1}delimiter_2${column_2:serializeAs_2} ... delimiter_N`, + +nerede `delimiter_i` değerler arasında bir sınırlayıcı mı (`$` sembol olarak kaçabilir `$$`), +`column_i` değerleri seçilecek veya eklenecek bir sütunun adı veya dizini (boşsa, sütun atlanır), +`serializeAs_i` sütun değerleri için kaçan bir kuraldır. Aşağıdaki kaçış kuralları desteklenir: + +- `CSV`, `JSON`, `XML` (aynı is theimlerin biçim formatslerine benzer şekilde) +- `Escaped` (aynı şekilde `TSV`) +- `Quoted` (aynı şekilde `Values`) +- `Raw` (kaç withoutmadan, benzer şekilde `TSVRaw`) +- `None` (kaçan kural yok, daha fazla görün) + +Kaçan bir kural atlanırsa, o zaman `None` kullanılacaktır. `XML` ve `Raw` sadece çıkış için uygundur. + +Yani, aşağıdaki biçim dizesi için: + + `Search phrase: ${SearchPhrase:Quoted}, count: ${c:Escaped}, ad price: $$${price:JSON};` + +değerleri `SearchPhrase`, `c` ve `price` olarak kaçır ,ılan sütunlar `Quoted`, `Escaped` ve `JSON` (select için) yazdırılacak veya (ınsert için) arasında beklenecektir `Search phrase:`, `, count:`, `, ad price: $` ve `;` sırasıyla sınırlayıcılar. Mesela: + +`Search phrase: 'bathroom interior design', count: 2166, ad price: $3;` + +Bu `format_template_rows_between_delimiter` ayar, sonuncusu hariç her satırdan sonra yazdırılan (veya beklenen) satırlar arasındaki sınırlayıcıyı belirtir (`\n` varsayılan olarak) + +Ayar `format_template_resultset` resultset için bir biçim dizesi içeren dosya yolunu belirtir. Resultset için Biçim dizesi, satır için bir biçim dizesi ile aynı sözdizimine sahiptir ve bir önek, sonek ve bazı ek bilgileri yazdırmanın bir yolunu belirtmeyi sağlar. Sütun adları yerine aşağıdaki yer tutucuları içerir: + +- `data` veri içeren satırlar mı `format_template_row` biçim, ayrılmış `format_template_rows_between_delimiter`. Bu yer tutucu, biçim dizesindeki ilk yer tutucu olmalıdır. +- `totals` toplam değerleri olan satır `format_template_row` biçim (TOPLAMLARLA birlikte kullanıldığında) +- `min` satır içinde minimum değerlere sahip mi `format_template_row` biçim (1 olarak ayarlandığında) +- `max` maksimum değerleri olan satır `format_template_row` biçim (1 olarak ayarlandığında) +- `rows` çıktı satırlarının toplam sayısıdır +- `rows_before_limit` minimum satır sayısı sınırı olmadan olurdu. Yalnızca sorgu sınırı içeriyorsa çıktı. Sorgu GROUP BY içeriyorsa, ROWS\_BEFORE\_LİMİT\_AT\_LEAST SINIRSIZDI olurdu satır tam sayısıdır. +- `time` istek yürütme süresi saniyeler içinde mi +- `rows_read` satır sayısı okun thedu mu +- `bytes_read` bayt sayısı (sıkıştırılmamış) okundu mu + +Tutucu `data`, `totals`, `min` ve `max` kaç rulema kuralı belirtilm (em (elidir (veya `None` açıkça belirtilen) olmalıdır. Kalan yer tutucuları belirtilen kaçan herhangi bir kural olabilir. +Eğer... `format_template_resultset` ayar boş bir dizedir, `${data}` varsayılan değer olarak kullanılır. +Insert sorguları biçimi için önek veya sonek varsa bazı sütunları veya bazı alanları atlamaya izin verir (örneğe bakın). + +Örnek seç: + +``` sql +SELECT SearchPhrase, count() AS c FROM test.hits GROUP BY SearchPhrase ORDER BY c DESC LIMIT 5 FORMAT Template SETTINGS +format_template_resultset = '/some/path/resultset.format', format_template_row = '/some/path/row.format', format_template_rows_between_delimiter = '\n ' +``` + +`/some/path/resultset.format`: + +``` text + + Search phrases + + + + ${data} +
Search phrases
Search phrase Count
+ + ${max} +
Max
+ Processed ${rows_read:XML} rows in ${time:XML} sec + + +``` + +`/some/path/row.format`: + +``` text + ${0:XML} ${1:XML} +``` + +Sonuç: + +``` html + + Search phrases + + + + + + + + +
Search phrases
Search phrase Count
8267016
bathroom interior design 2166
yandex 1655
spring 2014 fashion 1549
freeform photos 1480
+ + +
Max
8873898
+ Processed 3095973 rows in 0.1569913 sec + + +``` + +Örnek Ekle: + +``` text +Some header +Page views: 5, User id: 4324182021466249494, Useless field: hello, Duration: 146, Sign: -1 +Page views: 6, User id: 4324182021466249494, Useless field: world, Duration: 185, Sign: 1 +Total rows: 2 +``` + +``` sql +INSERT INTO UserActivity FORMAT Template SETTINGS +format_template_resultset = '/some/path/resultset.format', format_template_row = '/some/path/row.format' +``` + +`/some/path/resultset.format`: + +``` text +Some header\n${data}\nTotal rows: ${:CSV}\n +``` + +`/some/path/row.format`: + +``` text +Page views: ${PageViews:CSV}, User id: ${UserID:CSV}, Useless field: ${:CSV}, Duration: ${Duration:CSV}, Sign: ${Sign:CSV} +``` + +`PageViews`, `UserID`, `Duration` ve `Sign` yer tutucular içinde tablodaki sütun adları vardır. Sonra değerler `Useless field` satır ve sonra `\nTotal rows:` sonek olarak göz ardı edilecektir. +Giriş verisindeki tüm sınırlayıcılar, belirtilen biçim dizelerindeki sınırlayıcılara kesinlikle eşit olmalıdır. + +## TemplateİgnoreSpaces {#templateignorespaces} + +Bu format sadece giriş için uygundur. +Benzer `Template`, ancak giriş akışındaki sınırlayıcılar ve değerler arasındaki boşluk karakterlerini atlar. Ancak, biçim dizeleri boşluk karakterleri içeriyorsa, bu karakterler giriş akışında beklenir. Ayrıca boş yer tutucuları belirtmek için izin verir (`${}` veya `${:None}`) aralarındaki boşlukları görmezden gelmek için bazı sınırlayıcıları ayrı parçalara ayırmak. Bu tür yer tutucular yalnızca boşluk karakterlerini atlamak için kullanılır. +Okumak mümkün `JSON` bu biçimi kullanarak, sütun değerleri tüm satırlarda aynı sıraya sahipse. Örneğin, aşağıdaki istek çıktı biçim örneğinden veri eklemek için kullanılabilir [JSON](#json): + +``` sql +INSERT INTO table_name FORMAT TemplateIgnoreSpaces SETTINGS +format_template_resultset = '/some/path/resultset.format', format_template_row = '/some/path/row.format', format_template_rows_between_delimiter = ',' +``` + +`/some/path/resultset.format`: + +``` text +{${}"meta"${}:${:JSON},${}"data"${}:${}[${data}]${},${}"totals"${}:${:JSON},${}"extremes"${}:${:JSON},${}"rows"${}:${:JSON},${}"rows_before_limit_at_least"${}:${:JSON}${}} +``` + +`/some/path/row.format`: + +``` text +{${}"SearchPhrase"${}:${}${phrase:JSON}${},${}"c"${}:${}${cnt:JSON}${}} +``` + +## TSKV {#tskv} + +TabSeparated benzer, ancak name=value biçiminde bir değer çıkarır. Adlar tabseparated biçiminde olduğu gibi kaçtı ve = simgesi de kaçtı. + +``` text +SearchPhrase= count()=8267016 +SearchPhrase=bathroom interior design count()=2166 +SearchPhrase=yandex count()=1655 +SearchPhrase=2014 spring fashion count()=1549 +SearchPhrase=freeform photos count()=1480 +SearchPhrase=angelina jolie count()=1245 +SearchPhrase=omsk count()=1112 +SearchPhrase=photos of dog breeds count()=1091 +SearchPhrase=curtain designs count()=1064 +SearchPhrase=baku count()=1000 +``` + +[NULL](../sql_reference/syntax.md) olarak format islanır `\N`. + +``` sql +SELECT * FROM t_null FORMAT TSKV +``` + +``` text +x=1 y=\N +``` + +Çok sayıda küçük sütun olduğunda, bu biçim etkisizdir ve genellikle kullanmak için hiçbir neden yoktur. Bununla birlikte, verimlilik açısından Jsoneachrow'dan daha kötü değildir. + +Both data output and parsing are supported in this format. For parsing, any order is supported for the values of different columns. It is acceptable for some values to be omitted – they are treated as equal to their default values. In this case, zeros and blank rows are used as default values. Complex values that could be specified in the table are not supported as defaults. + +Ayrıştırma, ek alanın varlığına izin verir `tskv` eşit işareti veya bir değer olmadan. Bu alan yoksayılır. + +## CSV {#csv} + +Virgülle ayrılmış değerler biçimi ([RFC](https://tools.ietf.org/html/rfc4180)). + +Biçimlendirme yaparken, satırlar çift tırnak içine alınır. Bir dizenin içindeki çift alıntı, bir satırda iki çift tırnak olarak çıktılanır. Karakterlerden kaçmak için başka kural yoktur. Tarih ve Tarih-Saat çift tırnak içine alınır. Sayılar tırnak işaretleri olmadan çıktı. Değerler, bir sınırlayıcı karakterle ayrılır; `,` varsayılan olarak. Sınırlayıcı karakteri ayarında tanımlanır [format\_csv\_delimiter](../operations/settings/settings.md#settings-format_csv_delimiter). Satırlar Unıx satır besleme (LF) kullanılarak ayrılır. Diziler CSV'DE aşağıdaki gibi serileştirilir: ilk olarak, dizi TabSeparated biçiminde olduğu gibi bir dizeye serileştirilir ve daha sonra ortaya çıkan dize çift tırnak içinde CSV'YE çıkarılır. CSV biçimindeki Tuples ayrı sütunlar olarak serileştirilir(yani, tuple'daki yuvalanmaları kaybolur). + +``` bash +$ clickhouse-client --format_csv_delimiter="|" --query="INSERT INTO test.csv FORMAT CSV" < data.csv +``` + +\* Varsayılan olarak, sınırlayıcı `,`. Görmek [format\_csv\_delimiter](../operations/settings/settings.md#settings-format_csv_delimiter) daha fazla bilgi için ayarlama. + +Ayrıştırma yaparken, tüm değerler tırnak işaretleri ile veya tırnak işaretleri olmadan ayrıştırılabilir. Hem çift hem de tek tırnak desteklenmektedir. Satırlar tırnak işaretleri olmadan da düzenlenebilir. Bu durumda, sınırlayıcı karaktere veya satır beslemesine (CR veya LF) ayrıştırılır. RFC'Yİ ihlal ederken, satırları tırnak işaretleri olmadan ayrıştırırken, önde gelen ve sondaki boşluklar ve sekmeler göz ardı edilir. Hat beslemesi için Unix (LF), Windows (CR LF) ve Mac OS Classic (CR LF) türleri desteklenir. + +Boş unquoted giriş değerleri, ilgili sütunlar için varsayılan değerlerle değiştirilir +[ınput\_format\_defaults\_for\_omitted\_fields](../operations/settings/settings.md#session_settings-input_format_defaults_for_omitted_fields) +etkindir. + +`NULL` olarak format islanır `\N` veya `NULL` veya boş bir unquoted dize (bkz. ayarlar [ınput\_format\_csv\_unquoted\_null\_literal\_as\_null](../operations/settings/settings.md#settings-input_format_csv_unquoted_null_literal_as_null) ve [ınput\_format\_defaults\_for\_omitted\_fields](../operations/settings/settings.md#session_settings-input_format_defaults_for_omitted_fields)). + +CSV biçimi, toplamların ve aşırılıkların çıktısını aynı şekilde destekler `TabSeparated`. + +## CSVWithNames {#csvwithnames} + +Ayrıca, başlık satırını benzer şekilde yazdırır `TabSeparatedWithNames`. + +## CustomSeparated {#format-customseparated} + +Benzer [Şablon](#format-template), ancak tüm sütunları yazdırır veya okur ve ayardan kaçan kuralı kullanır `format_custom_escaping_rule` ve ayarlardan sınırlayıcılar `format_custom_field_delimiter`, `format_custom_row_before_delimiter`, `format_custom_row_after_delimiter`, `format_custom_row_between_delimiter`, `format_custom_result_before_delimiter` ve `format_custom_result_after_delimiter`, biçim dizelerinden değil. +Ayrıca var `CustomSeparatedIgnoreSpaces` biçim, benzer olan `TemplateIgnoreSpaces`. + +## JSON {#json} + +Verileri json formatında çıkarır. Veri tablolarının yanı sıra, bazı ek bilgilerle birlikte sütun adlarını ve türlerini de çıkarır: çıktı satırlarının toplam sayısı ve bir sınır yoksa çıktı olabilecek satır sayısı. Örnek: + +``` sql +SELECT SearchPhrase, count() AS c FROM test.hits GROUP BY SearchPhrase WITH TOTALS ORDER BY c DESC LIMIT 5 FORMAT JSON +``` + +``` json +{ + "meta": + [ + { + "name": "SearchPhrase", + "type": "String" + }, + { + "name": "c", + "type": "UInt64" + } + ], + + "data": + [ + { + "SearchPhrase": "", + "c": "8267016" + }, + { + "SearchPhrase": "bathroom interior design", + "c": "2166" + }, + { + "SearchPhrase": "yandex", + "c": "1655" + }, + { + "SearchPhrase": "spring 2014 fashion", + "c": "1549" + }, + { + "SearchPhrase": "freeform photos", + "c": "1480" + } + ], + + "totals": + { + "SearchPhrase": "", + "c": "8873898" + }, + + "extremes": + { + "min": + { + "SearchPhrase": "", + "c": "1480" + }, + "max": + { + "SearchPhrase": "", + "c": "8267016" + } + }, + + "rows": 5, + + "rows_before_limit_at_least": 141137 +} +``` + +Json JavaScript ile uyumludur. Bunu sağlamak için, bazı karakterler ek olarak kaçar: eğik çizgi `/` olarak kaç İsar `\/`; alternatif Satır sonları `U+2028` ve `U+2029`, hangi bazı tarayıcılar kırmak, olarak kaçtı `\uXXXX`. ASCII denetim karakterleri kaçtı: backspace, form besleme, satır besleme, satır başı ve yatay sekme ile değiştirilir `\b`, `\f`, `\n`, `\r`, `\t` , 00-1f aralığında kalan baytların yanı sıra `\uXXXX` sequences. Invalid UTF-8 sequences are changed to the replacement character � so the output text will consist of valid UTF-8 sequences. For compatibility with JavaScript, Int64 and UInt64 integers are enclosed in double-quotes by default. To remove the quotes, you can set the configuration parameter [output\_format\_json\_quote\_64bit\_integers](../operations/settings/settings.md#session_settings-output_format_json_quote_64bit_integers) 0'a. + +`rows` – The total number of output rows. + +`rows_before_limit_at_least` Minimum satır sayısı sınırı olmadan olurdu. Yalnızca sorgu sınırı içeriyorsa çıktı. +Sorgu GROUP BY içeriyorsa, ROWS\_BEFORE\_LİMİT\_AT\_LEAST SINIRSIZDI olurdu satır tam sayısıdır. + +`totals` – Total values (when using WITH TOTALS). + +`extremes` – Extreme values (when extremes are set to 1). + +Bu biçim yalnızca bir sorgu sonucu çıktısı için uygundur, ancak ayrıştırma için değil (bir tabloya eklemek için veri alma). + +ClickHouse destekler [NULL](../sql_reference/syntax.md) olarak görüntülenen `null` JSON çıkışında. + +Ayrıca bakınız [JSONEachRow](#jsoneachrow) biçimli. + +## JSONCompact {#jsoncompact} + +Yalnızca veri satırlarında json'dan farklıdır, nesnelerde değil, dizilerde çıktıdır. + +Örnek: + +``` json +{ + "meta": + [ + { + "name": "SearchPhrase", + "type": "String" + }, + { + "name": "c", + "type": "UInt64" + } + ], + + "data": + [ + ["", "8267016"], + ["bathroom interior design", "2166"], + ["yandex", "1655"], + ["fashion trends spring 2014", "1549"], + ["freeform photo", "1480"] + ], + + "totals": ["","8873898"], + + "extremes": + { + "min": ["","1480"], + "max": ["","8267016"] + }, + + "rows": 5, + + "rows_before_limit_at_least": 141137 +} +``` + +Bu biçim yalnızca bir sorgu sonucu çıktısı için uygundur, ancak ayrıştırma için değil (bir tabloya eklemek için veri alma). +Ayrıca bakınız `JSONEachRow` biçimli. + +## JSONEachRow {#jsoneachrow} + +Bu biçimi kullanırken, ClickHouse satırları ayrılmış, yeni satırla ayrılmış JSON nesneleri olarak çıkarır, ancak bir bütün olarak veriler geçerli JSON değildir. + +``` json +{"SearchPhrase":"curtain designs","count()":"1064"} +{"SearchPhrase":"baku","count()":"1000"} +{"SearchPhrase":"","count()":"8267016"} +``` + +Verileri eklerken, her satır için ayrı bir JSON nesnesi sağlamanız gerekir. + +### Veri Ekleme {#inserting-data} + +``` sql +INSERT INTO UserActivity FORMAT JSONEachRow {"PageViews":5, "UserID":"4324182021466249494", "Duration":146,"Sign":-1} {"UserID":"4324182021466249494","PageViews":6,"Duration":185,"Sign":1} +``` + +ClickHouse sağlar: + +- Nesnedeki herhangi bir anahtar-değer çiftleri sırası. +- Bazı değerleri atlama. + +ClickHouse, nesnelerden sonra öğeler ve virgüller arasındaki boşlukları yok sayar. Tüm nesneleri bir satırda geçirebilirsiniz. Onları Satır sonları ile ayırmak zorunda değilsiniz. + +**İhmal edilen değerler işleme** + +ClickHouse, karşılık gelen değerler için varsayılan değerlerle atlanmış değerleri değiştirir [veri türleri](../sql_reference/data_types/index.md). + +Eğer `DEFAULT expr` belirtilen, ClickHouse bağlı olarak farklı ikame kuralları kullanır [ınput\_format\_defaults\_for\_omitted\_fields](../operations/settings/settings.md#session_settings-input_format_defaults_for_omitted_fields) ayar. + +Aşağıdaki tabloyu düşünün: + +``` sql +CREATE TABLE IF NOT EXISTS example_table +( + x UInt32, + a DEFAULT x * 2 +) ENGINE = Memory; +``` + +- Eğer `input_format_defaults_for_omitted_fields = 0`, sonra varsayılan değer için `x` ve `a` eşitlikler `0` (varsayılan değer olarak `UInt32` veri türü). +- Eğer `input_format_defaults_for_omitted_fields = 1`, sonra varsayılan değer için `x` eşitlikler `0`, ancak varsayılan değer `a` eşitlikler `x * 2`. + +!!! note "Uyarıcı" + İle veri ek whenlerken `insert_sample_with_metadata = 1`, ClickHouse, ekleme ile karşılaştırıldığında daha fazla hesaplama kaynağı tüketir `insert_sample_with_metadata = 0`. + +### Veri Seçme {#selecting-data} + +Düşünün `UserActivity` örnek olarak tablo: + +``` text +┌──────────────UserID─┬─PageViews─┬─Duration─┬─Sign─┐ +│ 4324182021466249494 │ 5 │ 146 │ -1 │ +│ 4324182021466249494 │ 6 │ 185 │ 1 │ +└─────────────────────┴───────────┴──────────┴──────┘ +``` + +Sorgu `SELECT * FROM UserActivity FORMAT JSONEachRow` dönüşler: + +``` text +{"UserID":"4324182021466249494","PageViews":5,"Duration":146,"Sign":-1} +{"UserID":"4324182021466249494","PageViews":6,"Duration":185,"Sign":1} +``` + +Aksine [JSON](#json) biçimi, geçersiz UTF-8 dizilerinin hiçbir ikame yoktur. Değerleri için olduğu gibi aynı şekilde kaçtı `JSON`. + +!!! note "Not" + Herhangi bir bayt kümesi dizelerde çıktı olabilir. Kullan... `JSONEachRow` tablodaki verilerin herhangi bir bilgi kaybetmeden JSON olarak biçimlendirilebileceğinden eminseniz biçimlendirin. + +### İç içe yapıların kullanımı {#jsoneachrow-nested} + +İle bir tablo varsa [İçiçe](../sql_reference/data_types/nested_data_structures/nested.md) veri türü sütunları, aynı yapıya sahip json verilerini ekleyebilirsiniz. İle bu özelliği etkinleştirin [ınput\_format\_ımport\_nested\_json](../operations/settings/settings.md#settings-input_format_import_nested_json) ayar. + +Örneğin, aşağıdaki tabloyu göz önünde bulundurun: + +``` sql +CREATE TABLE json_each_row_nested (n Nested (s String, i Int32) ) ENGINE = Memory +``` + +Gibi görmek `Nested` veri türü açıklaması, ClickHouse, iç içe geçmiş yapının her bileşenini ayrı bir sütun olarak ele alır (`n.s` ve `n.i` sof )ram )ız için). Verileri aşağıdaki şekilde ekleyebilirsiniz: + +``` sql +INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n.s": ["abc", "def"], "n.i": [1, 23]} +``` + +Hiyerarşik bir json nesnesi olarak veri eklemek için [input\_format\_import\_nested\_json = 1](../operations/settings/settings.md#settings-input_format_import_nested_json). + +``` json +{ + "n": { + "s": ["abc", "def"], + "i": [1, 23] + } +} +``` + +Bu ayar olmadan, ClickHouse bir özel durum atar. + +``` sql +SELECT name, value FROM system.settings WHERE name = 'input_format_import_nested_json' +``` + +``` text +┌─name────────────────────────────┬─value─┐ +│ input_format_import_nested_json │ 0 │ +└─────────────────────────────────┴───────┘ +``` + +``` sql +INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n": {"s": ["abc", "def"], "i": [1, 23]}} +``` + +``` text +Code: 117. DB::Exception: Unknown field found while parsing JSONEachRow format: n: (at row 1) +``` + +``` sql +SET input_format_import_nested_json=1 +INSERT INTO json_each_row_nested FORMAT JSONEachRow {"n": {"s": ["abc", "def"], "i": [1, 23]}} +SELECT * FROM json_each_row_nested +``` + +``` text +┌─n.s───────────┬─n.i────┐ +│ ['abc','def'] │ [1,23] │ +└───────────────┴────────┘ +``` + +## Yerel {#native} + +En verimli biçim. Veriler ikili formatta bloklar tarafından yazılır ve okunur. Her blok için satır sayısı, sütun sayısı, sütun adları ve türleri ve bu bloktaki sütunların parçaları birbiri ardına kaydedilir. Başka bir deyişle, bu format “columnar” – it doesn't convert columns to rows. This is the format used in the native interface for interaction between servers, for using the command-line client, and for C++ clients. + +Bu biçimi, yalnızca ClickHouse DBMS tarafından okunabilen dökümleri hızlı bir şekilde oluşturmak için kullanabilirsiniz. Bu formatla kendiniz çalışmak mantıklı değil. + +## Boş {#null} + +Hiçbir şey çıktı. Ancak, sorgu işlenir ve komut satırı istemcisini kullanırken, veriler istemciye iletilir. Bu, performans testi de dahil olmak üzere testler için kullanılır. +Açıkçası, bu format yalnızca ayrıştırma için değil, çıktı için uygundur. + +## Çok {#pretty} + +Verileri Unicode-art tabloları olarak çıkarır, ayrıca TERMİNALDEKİ renkleri ayarlamak için ANSI-escape dizileri kullanır. +Tablonun tam bir ızgarası çizilir ve her satır terminalde iki satır kaplar. +Her sonuç bloğu ayrı bir tablo olarak çıktı. Bu, blokların arabelleğe alma sonuçları olmadan çıkabilmesi için gereklidir (tüm değerlerin görünür genişliğini önceden hesaplamak için arabelleğe alma gerekli olacaktır). + +[NULL](../sql_reference/syntax.md) olarak çıktı `ᴺᵁᴸᴸ`. + +Örnek (gösterilen [PrettyCompact](#prettycompact) biçimli): + +``` sql +SELECT * FROM t_null +``` + +``` text +┌─x─┬────y─┐ +│ 1 │ ᴺᵁᴸᴸ │ +└───┴──────┘ +``` + +Satırlar güzel\* biçimlerinde kaçmaz. Örnek için gösterilir [PrettyCompact](#prettycompact) biçimli: + +``` sql +SELECT 'String with \'quotes\' and \t character' AS Escaping_test +``` + +``` text +┌─Escaping_test────────────────────────┐ +│ String with 'quotes' and character │ +└──────────────────────────────────────┘ +``` + +Terminale çok fazla veri boşaltmaktan kaçınmak için yalnızca ilk 10.000 satır yazdırılır. Satır sayısı 10.000'den büyük veya eşitse, ileti “Showed first 10 000” bas .ılmıştır. +Bu biçim yalnızca bir sorgu sonucu çıktısı için uygundur, ancak ayrıştırma için değil (bir tabloya eklemek için veri alma). + +Güzel biçim, toplam değerleri (TOPLAMLARLA birlikte kullanıldığında) ve aşırılıkları (ne zaman ‘extremes’ 1 olarak ayarlanır). Bu durumlarda, toplam değerler ve aşırı değerler ana veriden sonra ayrı tablolarda çıktılanır. Örnek (gösterilen [PrettyCompact](#prettycompact) biçimli): + +``` sql +SELECT EventDate, count() AS c FROM test.hits GROUP BY EventDate WITH TOTALS ORDER BY EventDate FORMAT PrettyCompact +``` + +``` text +┌──EventDate─┬───────c─┐ +│ 2014-03-17 │ 1406958 │ +│ 2014-03-18 │ 1383658 │ +│ 2014-03-19 │ 1405797 │ +│ 2014-03-20 │ 1353623 │ +│ 2014-03-21 │ 1245779 │ +│ 2014-03-22 │ 1031592 │ +│ 2014-03-23 │ 1046491 │ +└────────────┴─────────┘ + +Totals: +┌──EventDate─┬───────c─┐ +│ 0000-00-00 │ 8873898 │ +└────────────┴─────────┘ + +Extremes: +┌──EventDate─┬───────c─┐ +│ 2014-03-17 │ 1031592 │ +│ 2014-03-23 │ 1406958 │ +└────────────┴─────────┘ +``` + +## PrettyCompact {#prettycompact} + +Farklıdır [Çok](#pretty) bu ızgara satırlar arasında çizilir ve sonuç daha kompakttır. +Bu biçim, etkileşimli modda komut satırı istemcisinde varsayılan olarak kullanılır. + +## PrettyCompactMonoBlock {#prettycompactmonoblock} + +Farklıdır [PrettyCompact](#prettycompact) bu kadar 10.000 satır arabelleğe alınır, daha sonra bloklarla değil, tek bir tablo olarak çıktılanır. + +## PrettyNoEscapes {#prettynoescapes} + +ANSİSİ-ESC .ape diz .ilerinin kullanıl .madığı güzel differsden farklıdır. Bu, bu formatı bir tarayıcıda görüntülemek ve aynı zamanda ‘watch’ komut satırı yardımcı programı. + +Örnek: + +``` bash +$ watch -n1 "clickhouse-client --query='SELECT event, value FROM system.events FORMAT PrettyCompactNoEscapes'" +``` + +Tarayıcıda görüntülemek için HTTP arayüzünü kullanabilirsiniz. + +### PrettyCompactNoEscapes {#prettycompactnoescapes} + +Önceki ayar ile aynı. + +### PrettySpaceNoEscapes {#prettyspacenoescapes} + +Önceki ayar ile aynı. + +## PrettySpace {#prettyspace} + +Farklıdır [PrettyCompact](#prettycompact) bu boşluk (boşluk karakterleri) ızgara yerine kullanılır. + +## RowBinary {#rowbinary} + +Biçimleri ve ikili biçimde satır verileri ayrıştırır. Satırlar ve değerler, ayırıcılar olmadan ardışık olarak listelenir. +Bu biçim, satır tabanlı olduğundan yerel biçimden daha az etkilidir. + +Tamsayılar sabit uzunlukta küçük endian temsilini kullanır. Örneğin, uint64 8 bayt kullanır. +DateTime, Unix zaman damgasını değer olarak içeren Uİnt32 olarak temsil edilir. +Tarih değeri olarak 1970-01-01 yılından bu yana gün sayısını içeren bir uint16 nesnesi olarak temsil edilir. +Dize varint uzunluğu (imzasız) olarak temsil edilir [LEB128](https://en.wikipedia.org/wiki/LEB128)), ardından dizenin baytları. +FixedString sadece bir bayt dizisi olarak temsil edilir. + +Dizi varint uzunluğu (imzasız) olarak temsil edilir [LEB128](https://en.wikipedia.org/wiki/LEB128)), ardından dizinin ardışık elemanları. + +İçin [NULL](../sql_reference/syntax.md#null-literal) destek, 1 veya 0 içeren ek bir bayt her önce eklenir [Nullable](../sql_reference/data_types/nullable.md) değer. 1 ise, o zaman değer `NULL` ve bu bayt ayrı bir değer olarak yorumlanır. 0 ise, bayttan sonraki değer değil `NULL`. + +## Rowbinarywithnames ve türleri {#rowbinarywithnamesandtypes} + +Benzer [RowBinary](#rowbinary), ancak eklenen Başlık ile: + +- [LEB128](https://en.wikipedia.org/wiki/LEB128)- kodlanmış sütun sayısı (N) +- N `String`s sütun adlarını belirtme +- N `String`s sütun türlerini belirleme + +## Değerler {#data-format-values} + +Her satırı parantez içinde yazdırır. Satırlar virgülle ayrılır. Son satırdan sonra virgül yok. Parantez içindeki değerler de virgülle ayrılır. Sayılar tırnak işaretleri olmadan ondalık biçimde çıktıdır. Diziler köşeli parantez içinde çıktı. Kat tırnak içinde çıkış dizelerle, tarihleri ve tarihleri. Kaçan kurallar ve ayrıştırma benzer [TabSeparated](#tabseparated) biçimli. Biçimlendirme sırasında fazladan boşluk eklenmez, ancak ayrıştırma sırasında izin verilir ve atlanır (izin verilmeyen dizi değerleri içindeki boşluklar hariç). [NULL](../sql_reference/syntax.md) olarak temsil edilir `NULL`. + +The minimum set of characters that you need to escape when passing data in Values ​​format: single quotes and backslashes. + +Bu, kullanılan formattır `INSERT INTO t VALUES ...`, ancak sorgu sonuçlarını biçimlendirmek için de kullanabilirsiniz. + +Ayrıca bakınız: [ınput\_format\_values\_interpret\_expressions](../operations/settings/settings.md#settings-input_format_values_interpret_expressions) ve [ınput\_format\_values\_deduce\_templates\_of\_expressions](../operations/settings/settings.md#settings-input_format_values_deduce_templates_of_expressions) ayarlar. + +## Dikey {#vertical} + +Her değeri belirtilen sütun adıyla ayrı bir satıra yazdırır. Bu biçim, her satır çok sayıda sütundan oluşuyorsa, yalnızca bir veya birkaç satır yazdırmak için uygundur. + +[NULL](../sql_reference/syntax.md) olarak çıktı `ᴺᵁᴸᴸ`. + +Örnek: + +``` sql +SELECT * FROM t_null FORMAT Vertical +``` + +``` text +Row 1: +────── +x: 1 +y: ᴺᵁᴸᴸ +``` + +Satırlar dikey biçimde kaçmadı: + +``` sql +SELECT 'string with \'quotes\' and \t with some special \n characters' AS test FORMAT Vertical +``` + +``` text +Row 1: +────── +test: string with 'quotes' and with some special + characters +``` + +Bu biçim yalnızca bir sorgu sonucu çıktısı için uygundur, ancak ayrıştırma için değil (bir tabloya eklemek için veri alma). + +## VerticalRaw {#verticalraw} + +Benzer [Dikey](#vertical), ama kaçan engelli ile. Bu biçim, yalnızca ayrıştırma (veri alma ve tabloya ekleme) için değil, sorgu sonuçlarının çıktısı için uygundur. + +## XML {#xml} + +XML biçimi, ayrıştırma için değil, yalnızca çıktı için uygundur. Örnek: + +``` xml + + + + + + SearchPhrase + String + + + count() + UInt64 + + + + + + + 8267016 + + + bathroom interior design + 2166 + + + yandex + 1655 + + + 2014 spring fashion + 1549 + + + freeform photos + 1480 + + + angelina jolie + 1245 + + + omsk + 1112 + + + photos of dog breeds + 1091 + + + curtain designs + 1064 + + + baku + 1000 + + + 10 + 141137 + +``` + +Sütun adı kabul edilebilir bir biçime sahip değilse, sadece ‘field’ eleman adı olarak kullanılır. Genel olarak, XML yapısı JSON yapısını izler. +Just as for JSON, invalid UTF-8 sequences are changed to the replacement character � so the output text will consist of valid UTF-8 sequences. + +Dize değerlerinde, karakterler `<` ve `&` olarak kaç arear `<` ve `&`. + +Diziler olarak çıktı `HelloWorld...`ve tuples olarak `HelloWorld...`. + +## CapnProto {#capnproto} + +Cap'n Proto, Protokol Tamponlarına ve tasarrufuna benzer, ancak JSON veya MessagePack gibi olmayan bir ikili mesaj biçimidir. + +Cap'n Proto mesajları kesinlikle yazılır ve kendi kendini tanımlamaz, yani harici bir şema açıklamasına ihtiyaç duyarlar. Şema anında uygulanır ve her sorgu için önbelleğe alınır. + +``` bash +$ cat capnproto_messages.bin | clickhouse-client --query "INSERT INTO test.hits FORMAT CapnProto SETTINGS format_schema='schema:Message'" +``` + +Nerede `schema.capnp` bu gibi görünüyor: + +``` capnp +struct Message { + SearchPhrase @0 :Text; + c @1 :Uint64; +} +``` + +Serializasyon etkilidir ve genellikle sistem yükünü arttırmaz. + +Ayrıca bakınız [Biçim Şeması](#formatschema). + +## Protobuf {#protobuf} + +Protobuf-bir [Protokol Tamp Buffonları](https://developers.google.com/protocol-buffers/) biçimli. + +Bu biçim, bir dış biçim şeması gerektirir. Şema sorgular arasında önbelleğe alınır. +ClickHouse hem destekler `proto2` ve `proto3` sözdizimiler. Tekrarlanan / isteğe bağlı / gerekli alanlar desteklenir. + +Kullanım örnekleri: + +``` sql +SELECT * FROM test.table FORMAT Protobuf SETTINGS format_schema = 'schemafile:MessageType' +``` + +``` bash +cat protobuf_messages.bin | clickhouse-client --query "INSERT INTO test.table FORMAT Protobuf SETTINGS format_schema='schemafile:MessageType'" +``` + +dosya nerede `schemafile.proto` bu gibi görünüyor: + +``` capnp +syntax = "proto3"; + +message MessageType { + string name = 1; + string surname = 2; + uint32 birthDate = 3; + repeated string phoneNumbers = 4; +}; +``` + +İletişim kuralı arabellekleri' ileti türü Tablo sütunları ve alanları arasındaki yazışmaları bulmak için clickhouse adlarını karşılaştırır. +Bu karşılaştırma büyük / küçük harf duyarsız ve karakterler `_` (alt çizgi) ve `.` (nokta) eşit olarak kabul edilir. +Bir sütun türleri ve protokol arabellekleri ileti alanı farklıysa, gerekli dönüştürme uygulanır. + +İç içe geçmiş mesajlar desteklenir. Örneğin, alan için `z` aşağıdaki ileti türünde + +``` capnp +message MessageType { + message XType { + message YType { + int32 z; + }; + repeated YType y; + }; + XType x; +}; +``` + +ClickHouse adlı bir sütun bulmaya çalışır `x.y.z` (veya `x_y_z` veya `X.y_Z` ve benzeri). +İç içe mesajlar giriş veya çıkış a için uygundur [iç içe veri yapıları](../sql_reference/data_types/nested_data_structures/nested.md). + +Böyle bir protobuf şemasında tanımlanan varsayılan değerler + +``` capnp +syntax = "proto2"; + +message MessageType { + optional int32 result_per_page = 3 [default = 10]; +} +``` + +uygulan ;mamaktadır; [tablo varsayılanları](../sql_reference/statements/create.md#create-default-values) bunların yerine kullanılır. + +ClickHouse girişleri ve çıkışları protobuf mesajları `length-delimited` biçimli. +Bu, her mesajın uzunluğunu bir olarak yazmadan önce anlamına gelir [varint](https://developers.google.com/protocol-buffers/docs/encoding#varints). +Ayrıca bakınız [popüler dillerde uzunlukla ayrılmış protobuf mesajları nasıl okunur / yazılır](https://cwiki.apache.org/confluence/display/GEODE/Delimiting+Protobuf+Messages). + +## Avro {#data-format-avro} + +[Apache Avro](http://avro.apache.org/) Apache'nin Hadoop projesi kapsamında geliştirilen satır odaklı veri serileştirme çerçevesidir. + +ClickHouse Avro biçimi okuma ve yazma destekler [Avro veri dosyaları](http://avro.apache.org/docs/current/spec.html#Object+Container+Files). + +### Veri Türleri Eşleştirme {#data_types-matching} + +Aşağıdaki tablo, desteklenen veri türlerini ve Clickhouse'la nasıl eşleştiğini gösterir [veri türleri](../sql_reference/data_types/index.md) içinde `INSERT` ve `SELECT` sorgular. + +| Avro veri türü `INSERT` | ClickHouse veri türü | Avro veri türü `SELECT` | +|---------------------------------------------|-------------------------------------------------------------------------------------------------------------------|------------------------------| +| `boolean`, `int`, `long`, `float`, `double` | [Int(8/16/32)](../sql_reference/data_types/int_uint.md), [Uİnt(8/16/32)](../sql_reference/data_types/int_uint.md) | `int` | +| `boolean`, `int`, `long`, `float`, `double` | [Int64](../sql_reference/data_types/int_uint.md), [Uİnt64](../sql_reference/data_types/int_uint.md) | `long` | +| `boolean`, `int`, `long`, `float`, `double` | [Float32](../sql_reference/data_types/float.md) | `float` | +| `boolean`, `int`, `long`, `float`, `double` | [Float64](../sql_reference/data_types/float.md) | `double` | +| `bytes`, `string`, `fixed`, `enum` | [Dize](../sql_reference/data_types/string.md) | `bytes` | +| `bytes`, `string`, `fixed` | [FixedString(N)](../sql_reference/data_types/fixedstring.md) | `fixed(N)` | +| `enum` | [Enum (8/16)](../sql_reference/data_types/enum.md) | `enum` | +| `array(T)` | [Dizi(T)](../sql_reference/data_types/array.md) | `array(T)` | +| `union(null, T)`, `union(T, null)` | [Null (T)](../sql_reference/data_types/date.md) | `union(null, T)` | +| `null` | [Null (Hiçbir Şey)](../sql_reference/data_types/special_data_types/nothing.md) | `null` | +| `int (date)` \* | [Tarihli](../sql_reference/data_types/date.md) | `int (date)` \* | +| `long (timestamp-millis)` \* | [DateTime64 (3)](../sql_reference/data_types/datetime.md) | `long (timestamp-millis)` \* | +| `long (timestamp-micros)` \* | [DateTime64 (6)](../sql_reference/data_types/datetime.md) | `long (timestamp-micros)` \* | + +\* [Avro mantıksal türleri](http://avro.apache.org/docs/current/spec.html#Logical+Types) + +Desteklenmeyen Avro veri türleri: `record` (non-root), `map` + +Desteklenmeyen Avro mantıksal veri türleri: `uuid`, `time-millis`, `time-micros`, `duration` + +### Veri Ekleme {#inserting-data-1} + +Bir Avro dosyasından ClickHouse tablosuna veri eklemek için: + +``` bash +$ cat file.avro | clickhouse-client --query="INSERT INTO {some_table} FORMAT Avro" +``` + +Giriş Avro dosyasının kök şeması olmalıdır `record` tür. + +ClickHouse tablo sütunları ve Avro şema alanları arasındaki yazışmaları bulmak için adlarını karşılaştırır. Bu karşılaştırma büyük / küçük harf duyarlıdır. +Kullanılmayan alanlar atlanır. + +ClickHouse tablo sütunlarının veri türleri, eklenen Avro verilerinin karşılık gelen alanlarından farklı olabilir. Veri eklerken, ClickHouse veri türlerini yukarıdaki tabloya göre yorumlar ve sonra [döküm](../sql_reference/functions/type_conversion_functions.md#type_conversion_function-cast) karşılık gelen sütun türüne veri. + +### Veri Seçme {#selecting-data-1} + +ClickHouse tablosundan bir Avro dosyasına veri seçmek için: + +``` bash +$ clickhouse-client --query="SELECT * FROM {some_table} FORMAT Avro" > file.avro +``` + +Sütun adları gerekir: + +- ile başla `[A-Za-z_]` +- daha sonra sadece içerir `[A-Za-z0-9_]` + +Çıkış Avro dosya sıkıştırma ve senkronizasyon aralığı ile yapılandırılabilir [output\_format\_avro\_codec](../operations/settings/settings.md#settings-output_format_avro_codec) ve [output\_format\_avro\_sync\_interval](../operations/settings/settings.md#settings-output_format_avro_sync_interval) sırasıyla. + +## AvroConfluent {#data-format-avro-confluent} + +AvroConfluent yaygın olarak kullanılan tek nesne Avro mesajları çözme destekler [Kafka](https://kafka.apache.org/) ve [Confluent Şema Kayıt](https://docs.confluent.io/current/schema-registry/index.html). + +Her Avro iletisi, şema Kayıt defterinin yardımıyla gerçek şemaya çözülebilen bir şema kimliği gömer. + +Şemalar çözüldükten sonra önbelleğe alınır. + +Şema kayıt defteri URL'si ile yapılandırılır [format\_avro\_schema\_registry\_url](../operations/settings/settings.md#settings-format_avro_schema_registry_url) + +### Veri Türleri Eşleştirme {#data_types-matching-1} + +Aynı olarak [Avro](#data-format-avro) + +### Kullanma {#usage} + +Şema çözünürlüğünü hızlı bir şekilde doğrulamak için şunları kullanabilirsiniz [kafkasat](https://github.com/edenhill/kafkacat) ile [clickhouse-yerel](../operations/utilities/clickhouse-local.md): + +``` bash +$ kafkacat -b kafka-broker -C -t topic1 -o beginning -f '%s' -c 3 | clickhouse-local --input-format AvroConfluent --format_avro_schema_registry_url 'http://schema-registry' -S "field1 Int64, field2 String" -q 'select * from table' +1 a +2 b +3 c +``` + +Kullanmak `AvroConfluent` ile [Kafka](../engines/table_engines/integrations/kafka.md): + +``` sql +CREATE TABLE topic1_stream +( + field1 String, + field2 String +) +ENGINE = Kafka() +SETTINGS +kafka_broker_list = 'kafka-broker', +kafka_topic_list = 'topic1', +kafka_group_name = 'group1', +kafka_format = 'AvroConfluent'; + +SET format_avro_schema_registry_url = 'http://schema-registry'; + +SELECT * FROM topic1_stream; +``` + +!!! note "Uyarıcı" + Ayar `format_avro_schema_registry_url` yapılandırılmış olması gerekiyor `users.xml` yeniden başlattıktan sonra değerini korumak için. + +## Parke {#data-format-parquet} + +[Apache Parke](http://parquet.apache.org/) hadoop ekosisteminde yaygın bir sütunlu depolama biçimidir. ClickHouse, bu format için okuma ve yazma işlemlerini destekler. + +### Veri Türleri Eşleştirme {#data_types-matching-2} + +Aşağıdaki tablo, desteklenen veri türlerini ve Clickhouse'la nasıl eşleştiğini gösterir [veri türleri](../sql_reference/data_types/index.md) içinde `INSERT` ve `SELECT` sorgular. + +| Parke veri türü (`INSERT`) | ClickHouse veri türü | Parke veri türü (`SELECT`) | +|----------------------------|-----------------------------------------------------------|----------------------------| +| `UINT8`, `BOOL` | [Uİnt8](../sql_reference/data_types/int_uint.md) | `UINT8` | +| `INT8` | [Int8](../sql_reference/data_types/int_uint.md) | `INT8` | +| `UINT16` | [Uınt16](../sql_reference/data_types/int_uint.md) | `UINT16` | +| `INT16` | [Int16](../sql_reference/data_types/int_uint.md) | `INT16` | +| `UINT32` | [Uİnt32](../sql_reference/data_types/int_uint.md) | `UINT32` | +| `INT32` | [Int32](../sql_reference/data_types/int_uint.md) | `INT32` | +| `UINT64` | [Uİnt64](../sql_reference/data_types/int_uint.md) | `UINT64` | +| `INT64` | [Int64](../sql_reference/data_types/int_uint.md) | `INT64` | +| `FLOAT`, `HALF_FLOAT` | [Float32](../sql_reference/data_types/float.md) | `FLOAT` | +| `DOUBLE` | [Float64](../sql_reference/data_types/float.md) | `DOUBLE` | +| `DATE32` | [Tarihli](../sql_reference/data_types/date.md) | `UINT16` | +| `DATE64`, `TIMESTAMP` | [DateTime](../sql_reference/data_types/datetime.md) | `UINT32` | +| `STRING`, `BINARY` | [Dize](../sql_reference/data_types/string.md) | `STRING` | +| — | [FixedString](../sql_reference/data_types/fixedstring.md) | `STRING` | +| `DECIMAL` | [Ondalık](../sql_reference/data_types/decimal.md) | `DECIMAL` | + +ClickHouse yapılandırılabilir hassas destekler `Decimal` tür. Bu `INSERT` sorgu parke davranır `DECIMAL` ClickHouse olarak yazın `Decimal128` tür. + +Desteklen datameyen veri türleri: `DATE32`, `TIME32`, `FIXED_SIZE_BINARY`, `JSON`, `UUID`, `ENUM`. + +ClickHouse tablo sütunlarının veri türleri, eklenen parke verilerinin ilgili alanlarından farklı olabilir. Veri eklerken, ClickHouse veri türlerini yukarıdaki tabloya göre yorumlar ve sonra [döküm](../query_language/functions/type_conversion_functions/#type_conversion_function-cast) ClickHouse tablo sütunu için ayarlanmış olan bu veri türüne ait veriler. + +### Veri ekleme ve seçme {#inserting-and-selecting-data} + +Bir dosyadan parke verilerini ClickHouse tablosuna aşağıdaki komutla ekleyebilirsiniz: + +``` bash +$ cat {filename} | clickhouse-client --query="INSERT INTO {some_table} FORMAT Parquet" +``` + +Bir ClickHouse tablosundan veri seçin ve aşağıdaki komutla parke formatında bazı dosyaya kaydedebilirsiniz: + +``` bash +$ clickhouse-client --query="SELECT * FROM {some_table} FORMAT Parquet" > {some_file.pq} +``` + +Hadoop ile veri alışverişi yapmak için şunları kullanabilirsiniz [HDFS tablo motoru](../engines/table_engines/integrations/hdfs.md). + +## ORC {#data-format-orc} + +[Apache ORCC](https://orc.apache.org/) hadoop ekosisteminde yaygın bir sütunlu depolama biçimidir. Bu formatta yalnızca Clickhouse'a veri ekleyebilirsiniz. + +### Veri Türleri Eşleştirme {#data_types-matching-3} + +Aşağıdaki tablo, desteklenen veri türlerini ve Clickhouse'la nasıl eşleştiğini gösterir [veri türleri](../sql_reference/data_types/index.md) içinde `INSERT` sorgular. + +| Orc veri türü (`INSERT`) | ClickHouse veri türü | +|--------------------------|-----------------------------------------------------| +| `UINT8`, `BOOL` | [Uİnt8](../sql_reference/data_types/int_uint.md) | +| `INT8` | [Int8](../sql_reference/data_types/int_uint.md) | +| `UINT16` | [Uınt16](../sql_reference/data_types/int_uint.md) | +| `INT16` | [Int16](../sql_reference/data_types/int_uint.md) | +| `UINT32` | [Uİnt32](../sql_reference/data_types/int_uint.md) | +| `INT32` | [Int32](../sql_reference/data_types/int_uint.md) | +| `UINT64` | [Uİnt64](../sql_reference/data_types/int_uint.md) | +| `INT64` | [Int64](../sql_reference/data_types/int_uint.md) | +| `FLOAT`, `HALF_FLOAT` | [Float32](../sql_reference/data_types/float.md) | +| `DOUBLE` | [Float64](../sql_reference/data_types/float.md) | +| `DATE32` | [Tarihli](../sql_reference/data_types/date.md) | +| `DATE64`, `TIMESTAMP` | [DateTime](../sql_reference/data_types/datetime.md) | +| `STRING`, `BINARY` | [Dize](../sql_reference/data_types/string.md) | +| `DECIMAL` | [Ondalık](../sql_reference/data_types/decimal.md) | + +ClickHouse yapılandırılabilir hassas destekler `Decimal` tür. Bu `INSERT` sorgu Orc davranır `DECIMAL` ClickHouse olarak yazın `Decimal128` tür. + +Desteklenmeyen Orc veri türleri: `DATE32`, `TIME32`, `FIXED_SIZE_BINARY`, `JSON`, `UUID`, `ENUM`. + +ClickHouse tablo sütunlarının veri türlerinin karşılık gelen ORC veri alanları ile eşleşmesi gerekmez. Veri eklerken, ClickHouse veri türlerini yukarıdaki tabloya göre yorumlar ve sonra [döküm](../sql_reference/functions/type_conversion_functions.md#type_conversion_function-cast) veri türü için veri kümesi ClickHouse tablo sütun. + +### Veri Ekleme {#inserting-data-2} + +Bir dosyadan Orc verilerini ClickHouse tablosuna aşağıdaki komutla ekleyebilirsiniz: + +``` bash +$ cat filename.orc | clickhouse-client --query="INSERT INTO some_table FORMAT ORC" +``` + +Hadoop ile veri alışverişi yapmak için şunları kullanabilirsiniz [HDFS tablo motoru](../engines/table_engines/integrations/hdfs.md). + +## Biçim Şeması {#formatschema} + +Biçim şemasını içeren dosya adı, ayar tarafından ayarlanır `format_schema`. +Biçim onelerinden biri kullanıldığında bu ayarı ayarlamak gerekir `Cap'n Proto` ve `Protobuf`. +Biçim şeması, bir dosya adının ve bu dosyadaki bir ileti türünün adının birleşimidir ve iki nokta üst üste ile sınırlandırılmıştır, +e.g. `schemafile.proto:MessageType`. +Dosya, format için standart uzantıya sahipse (örneğin, `.proto` için `Protobuf`), +ihmal edilebilir ve bu durumda, biçim şeması şöyle görünür `schemafile:MessageType`. + +Eğer giriş veya çıkış veri üzerinden [müşteri](../interfaces/cli.md) in the [interaktif mod](../interfaces/cli.md#cli_usage) biçim şe themasında belirtilen dosya adı +mutlak bir yol veya istemci üzerinde geçerli dizine göre bir yol içerebilir. +Eğer istemci kullanıyorsanız [Toplu Modu](../interfaces/cli.md#cli_usage), şemanın yolu güvenlik nedeniyle göreceli olmalıdır. + +Eğer giriş veya çıkış veri üzerinden [HTTP arayüzü](../interfaces/http.md) biçim şemasında belirtilen dosya adı +belirtilen dizinde bulunmalıdır [format\_schema\_path](../operations/server_configuration_parameters/settings.md#server_configuration_parameters-format_schema_path) +sunucu yapılandırmasında. + +## Atlama Hataları {#skippingerrors} + +Gibi bazı format suchlar `CSV`, `TabSeparated`, `TSKV`, `JSONEachRow`, `Template`, `CustomSeparated` ve `Protobuf` ayrıştırma hatası oluşursa kırık satırı atlayabilir ve bir sonraki satırın başından ayrıştırmaya devam edebilir. Görmek [ınput\_format\_allow\_errors\_num](../operations/settings/settings.md#settings-input_format_allow_errors_num) ve +[ınput\_format\_allow\_errors\_ratio](../operations/settings/settings.md#settings-input_format_allow_errors_ratio) ayarlar. +Sınırlamalar: +- Ayrıştırma hatası durumunda `JSONEachRow` yeni satıra (veya EOF) kadar tüm verileri atlar, bu nedenle satırlar AŞAĞIDAKİLERLE sınırlandırılmalıdır `\n` hataları doğru saymak için. +- `Template` ve `CustomSeparated` bir sonraki satırın başlangıcını bulmak için son sütundan sonra sınırlayıcı ve satırlar arasındaki sınırlayıcıyı kullanın, Bu nedenle hataları atlamak yalnızca en az biri boş değilse çalışır. + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/formats/) diff --git a/docs/tr/interfaces/http.md b/docs/tr/interfaces/http.md new file mode 100644 index 00000000000..a30e05418c8 --- /dev/null +++ b/docs/tr/interfaces/http.md @@ -0,0 +1,511 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 19 +toc_title: "HTTP aray\xFCz\xFC" +--- + +# HTTP arayüzü {#http-interface} + +HTTP arayüzü, herhangi bir programlama dilinden herhangi bir platformda Clickhouse'u kullanmanızı sağlar. Java ve Perl'den ve kabuk komut dosyalarından çalışmak için kullanıyoruz. Diğer bölümlerde, HTTP arayüzü Perl, Python ve Go'dan kullanılır. HTTP arabirimi yerel arabirimden daha sınırlıdır, ancak daha iyi uyumluluğa sahiptir. + +Varsayılan olarak, clickhouse-server, 8123 numaralı bağlantı noktasında HTTP dinler (bu, yapılandırmada değiştirilebilir). + +Parametreler olmadan bir GET / request yaparsanız, 200 yanıt kodunu ve tanımlanan dizeyi döndürür [http\_server\_default\_response](../operations/server_configuration_parameters/settings.md#server_configuration_parameters-http_server_default_response) varsayılan değer “Ok.” (sonunda bir çizgi besleme ile) + +``` bash +$ curl 'http://localhost:8123/' +Ok. +``` + +Sağlık kontrol komut GET / ping isteği kullanın. Bu işleyici her zaman döner “Ok.” (sonunda bir çizgi besleme ile). 18.12.13 sürümünden edinilebilir. + +``` bash +$ curl 'http://localhost:8123/ping' +Ok. +``` + +İsteği URL olarak gönder ‘query’ parametre veya bir POST olarak. Veya sorgunun başlangıcını gönder ‘query’ parametre ve postadaki geri kalanı (bunun neden gerekli olduğunu daha sonra açıklayacağız). URL'nin boyutu 16 KB ile sınırlıdır, bu nedenle büyük sorgular gönderirken bunu aklınızda bulundurun. + +Başarılı olursa, 200 yanıt Kodu ve yanıt gövdesinde sonucu alırsınız. +Bir hata oluşursa, 500 yanıt Kodu ve yanıt gövdesinde bir hata açıklaması metni alırsınız. + +GET yöntemini kullanırken, ‘readonly’ ayar .lanmıştır. Başka bir deyişle, verileri değiştiren sorgular için yalnızca POST yöntemini kullanabilirsiniz. Sorgunun kendisini POST gövdesinde veya URL parametresinde gönderebilirsiniz. + +Örnekler: + +``` bash +$ curl 'http://localhost:8123/?query=SELECT%201' +1 + +$ wget -O- -q 'http://localhost:8123/?query=SELECT 1' +1 + +$ echo -ne 'GET /?query=SELECT%201 HTTP/1.0\r\n\r\n' | nc localhost 8123 +HTTP/1.0 200 OK +Date: Wed, 27 Nov 2019 10:30:18 GMT +Connection: Close +Content-Type: text/tab-separated-values; charset=UTF-8 +X-ClickHouse-Server-Display-Name: clickhouse.ru-central1.internal +X-ClickHouse-Query-Id: 5abe861c-239c-467f-b955-8a201abb8b7f +X-ClickHouse-Summary: {"read_rows":"0","read_bytes":"0","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"} + +1 +``` + +Gördüğünüz gibi, curl, boşlukların URL'den kaçması gerektiği konusunda biraz rahatsız edici. +Her ne kadar wget her şeyden kaçsa da, onu kullanmanızı önermiyoruz çünkü keep-alive ve Transfer-Encoding: chunked kullanırken HTTP 1.1 üzerinde iyi çalışmıyor. + +``` bash +$ echo 'SELECT 1' | curl 'http://localhost:8123/' --data-binary @- +1 + +$ echo 'SELECT 1' | curl 'http://localhost:8123/?query=' --data-binary @- +1 + +$ echo '1' | curl 'http://localhost:8123/?query=SELECT' --data-binary @- +1 +``` + +Sorgunun bir parçası parametrede gönderilirse ve gönderinin bir parçası ise, bu iki veri parçası arasına bir satır akışı eklenir. +Örnek (bu işe yaramaz): + +``` bash +$ echo 'ECT 1' | curl 'http://localhost:8123/?query=SEL' --data-binary @- +Code: 59, e.displayText() = DB::Exception: Syntax error: failed at position 0: SEL +ECT 1 +, expected One of: SHOW TABLES, SHOW DATABASES, SELECT, INSERT, CREATE, ATTACH, RENAME, DROP, DETACH, USE, SET, OPTIMIZE., e.what() = DB::Exception +``` + +Varsayılan olarak, veri TabSeparated biçiminde döndürülür (daha fazla bilgi için bkz: “Formats” bölme). +Başka bir biçim istemek için sorgunun biçim yan tümcesi kullanın. + +``` bash +$ echo 'SELECT 1 FORMAT Pretty' | curl 'http://localhost:8123/?' --data-binary @- +┏━━━┓ +┃ 1 ┃ +┡━━━┩ +│ 1 │ +└───┘ +``` + +Ekleme sorguları için veri iletmenin POST yöntemi gereklidir. Bu durumda, URL parametresinde sorgunun başlangıcını yazabilir ve eklemek için verileri iletmek için POST'u kullanabilirsiniz. Eklenecek veriler, örneğin Mysql'den sekmeyle ayrılmış bir döküm olabilir. Bu şekilde, INSERT sorgusu MYSQL'DEN load DATA LOCAL INFİLE'IN yerini alır. + +Örnekler: tablo oluşturma: + +``` bash +$ echo 'CREATE TABLE t (a UInt8) ENGINE = Memory' | curl 'http://localhost:8123/' --data-binary @- +``` + +Veri ekleme için tanıdık ekleme sorgusunu kullanma: + +``` bash +$ echo 'INSERT INTO t VALUES (1),(2),(3)' | curl 'http://localhost:8123/' --data-binary @- +``` + +Veriler sorgudan ayrı olarak gönderilebilir: + +``` bash +$ echo '(4),(5),(6)' | curl 'http://localhost:8123/?query=INSERT%20INTO%20t%20VALUES' --data-binary @- +``` + +Herhangi bir veri biçimini belirtebilirsiniz. Bu ‘Values’ biçim, T değerlerine INSERT yazarken kullanılanla aynıdır: + +``` bash +$ echo '(7),(8),(9)' | curl 'http://localhost:8123/?query=INSERT%20INTO%20t%20FORMAT%20Values' --data-binary @- +``` + +Sekmeyle ayrılmış bir dökümden veri eklemek için ilgili biçimi belirtin: + +``` bash +$ echo -ne '10\n11\n12\n' | curl 'http://localhost:8123/?query=INSERT%20INTO%20t%20FORMAT%20TabSeparated' --data-binary @- +``` + +Tablo içeriğini okuma. Paralel sorgu işleme nedeniyle veriler rastgele sırayla çıktılanır: + +``` bash +$ curl 'http://localhost:8123/?query=SELECT%20a%20FROM%20t' +7 +8 +9 +10 +11 +12 +1 +2 +3 +4 +5 +6 +``` + +Tabloyu silme. + +``` bash +$ echo 'DROP TABLE t' | curl 'http://localhost:8123/' --data-binary @- +``` + +Veri tablosu döndürmeyen başarılı istekler için boş bir yanıt gövdesi döndürülür. + +Veri iletirken dahili ClickHouse sıkıştırma formatını kullanabilirsiniz. Sıkıştırılmış veriler standart olmayan bir biçime sahiptir ve özel `clickhouse-compressor` onunla çalışmak için program (bu ile yüklü `clickhouse-client` paket). Veri ekleme verimliliğini artırmak için, sunucu tarafı sağlama toplamı doğrulamasını kullanarak devre dışı bırakabilirsiniz. [http\_native\_compression\_disable\_checksumming\_on\_decompress](../operations/settings/settings.md#settings-http_native_compression_disable_checksumming_on_decompress) ayar. + +Belirt ift ifiyseniz `compress=1` URL'de, sunucu size gönderdiği verileri sıkıştırır. +Belirt ift ifiyseniz `decompress=1` URL'de, sunucu içinde geçirdiğiniz aynı verileri açar. `POST` yöntem. + +Ayrıca kullanmayı seçebilirsiniz [HTTP sıkıştırma](https://en.wikipedia.org/wiki/HTTP_compression). Sıkıştırılmış bir göndermek için `POST` istek, istek başlığını Ekle `Content-Encoding: compression_method`. Clickhouse'un yanıtı sıkıştırması için şunları eklemelisiniz `Accept-Encoding: compression_method`. ClickHouse destekler `gzip`, `br`, ve `deflate` [sıkıştırma yöntemleri](https://en.wikipedia.org/wiki/HTTP_compression#Content-Encoding_tokens). HTTP sıkıştırmasını etkinleştirmek için Clickhouse'u kullanmanız gerekir [enable\_http\_compression](../operations/settings/settings.md#settings-enable_http_compression) ayar. Veri sıkıştırma düzeyini [http\_zlib\_compression\_level](#settings-http_zlib_compression_level) tüm sıkıştırma yöntemleri için ayarlama. + +Bunu, büyük miktarda veri iletirken ağ trafiğini azaltmak veya hemen sıkıştırılmış dökümler oluşturmak için kullanabilirsiniz. + +Sıkıştırma ile veri gönderme örnekleri: + +``` bash +#Sending data to the server: +$ curl -vsS "http://localhost:8123/?enable_http_compression=1" -d 'SELECT number FROM system.numbers LIMIT 10' -H 'Accept-Encoding: gzip' + +#Sending data to the client: +$ echo "SELECT 1" | gzip -c | curl -sS --data-binary @- -H 'Content-Encoding: gzip' 'http://localhost:8123/' +``` + +!!! note "Not" + Bazı HTTP istemcileri varsayılan olarak sunucudan verileri açabilir ( `gzip` ve `deflate`) ve sıkıştırma ayarlarını doğru kullansanız bile sıkıştırılmış veriler alabilirsiniz. + +Kullanabilirsiniz ‘database’ Varsayılan veritabanını belirtmek için URL parametresi. + +``` bash +$ echo 'SELECT number FROM numbers LIMIT 10' | curl 'http://localhost:8123/?database=system' --data-binary @- +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +``` + +Varsayılan olarak, sunucu ayarlarında kayıtlı veritabanı varsayılan veritabanı olarak kullanılır. Varsayılan olarak, bu veritabanı denir ‘default’. Alternatif olarak, her zaman tablo adından önce bir nokta kullanarak veritabanını belirtebilirsiniz. + +Kullanıcı adı ve şifre üç yoldan biriyle belirtilebilir: + +1. HTTP temel kimlik doğrulamasını kullanma. Örnek: + + + +``` bash +$ echo 'SELECT 1' | curl 'http://user:password@localhost:8123/' -d @- +``` + +1. İn the ‘user’ ve ‘password’ URL parametreleri. Örnek: + + + +``` bash +$ echo 'SELECT 1' | curl 'http://localhost:8123/?user=user&password=password' -d @- +``` + +1. Kullanım ‘X-ClickHouse-User’ ve ‘X-ClickHouse-Key’ üstbilgi. Örnek: + + + +``` bash +$ echo 'SELECT 1' | curl -H 'X-ClickHouse-User: user' -H 'X-ClickHouse-Key: password' 'http://localhost:8123/' -d @- +``` + +Kullanıcı adı belirtilmemişse, `default` adı kullanılır. Parola belirtilmezse, boş parola kullanılır. +Tek bir sorguyu veya ayarların tüm profillerini işlemek için herhangi bir ayar belirtmek için URL parametrelerini de kullanabilirsiniz. Örnek: http: / / localhost: 8123/?profil = web & max\_rows\_to\_read = 1000000000 & query = seç + 1 + +Daha fazla bilgi için, bkz: [Ayarlar](../operations/settings/index.md) bölme. + +``` bash +$ echo 'SELECT number FROM system.numbers LIMIT 10' | curl 'http://localhost:8123/?' --data-binary @- +0 +1 +2 +3 +4 +5 +6 +7 +8 +9 +``` + +Diğer parametreler hakkında bilgi için bölüme bakın “SET”. + +Benzer şekilde, http protokolünde ClickHouse oturumlarını kullanabilirsiniz. Bunu yapmak için şunları eklemeniz gerekir: `session_id` İsteğe parametre alın. Oturum kimliği olarak herhangi bir dize kullanabilirsiniz. Varsayılan olarak, oturum 60 saniye hareketsizlik sonra sonlandırılır. Bu zaman aşımını değiştirmek için, `default_session_timeout` sunucu yapılandırmasında ayarlama veya `session_timeout` İsteğe parametre alın. Oturum durumunu kontrol etmek için `session_check=1` parametre. Bir kerede yalnızca bir sorgu, tek bir oturum içinde çalıştırılabilir. + +Bir sorgunun ilerleme durumu hakkında bilgi alabilirsiniz `X-ClickHouse-Progress` yanıt başlıkları. Bunu yapmak için etkinleştir [send\_progress\_in\_http\_headers](../operations/settings/settings.md#settings-send_progress_in_http_headers). Başlık dizisi örneği: + +``` text +X-ClickHouse-Progress: {"read_rows":"2752512","read_bytes":"240570816","total_rows_to_read":"8880128"} +X-ClickHouse-Progress: {"read_rows":"5439488","read_bytes":"482285394","total_rows_to_read":"8880128"} +X-ClickHouse-Progress: {"read_rows":"8783786","read_bytes":"819092887","total_rows_to_read":"8880128"} +``` + +Olası başlık alanları: + +- `read_rows` — Number of rows read. +- `read_bytes` — Volume of data read in bytes. +- `total_rows_to_read` — Total number of rows to be read. +- `written_rows` — Number of rows written. +- `written_bytes` — Volume of data written in bytes. + +Http bağlantısı kaybolursa çalışan istekler otomatik olarak durmaz. Ayrıştırma ve veri biçimlendirme sunucu tarafında gerçekleştirilir ve ağ kullanarak etkisiz olabilir. +Opsiyonel ‘query\_id’ parametre sorgu kimliği (herhangi bir dize) geçirilebilir. Daha fazla bilgi için bölüme bakın “Settings, replace\_running\_query”. + +Opsiyonel ‘quota\_key’ parametre kota anahtarı (herhangi bir dize) olarak geçirilebilir. Daha fazla bilgi için bölüme bakın “Quotas”. + +HTTP arabirimi, sorgulamak için dış verileri (dış geçici tablolar) geçirmenize izin verir. Daha fazla bilgi için bölüme bakın “External data for query processing”. + +## Yanıt Tamponlama {#response-buffering} + +Sunucu tarafında yanıt arabelleği etkinleştirebilirsiniz. Bu `buffer_size` ve `wait_end_of_query` Bu amaçla URL parametreleri sağlanmıştır. + +`buffer_size` sunucu belleğinde arabellek sonucu bayt sayısını belirler. Sonuç gövdesi bu eşikten büyükse, arabellek HTTP kanalına yazılır ve kalan veriler doğrudan HTTP kanalına gönderilir. + +Tüm yanıtın arabelleğe alındığından emin olmak için `wait_end_of_query=1`. Bu durumda, bellekte depolanan veriler geçici bir sunucu dosyasında arabelleğe alınır. + +Örnek: + +``` bash +$ curl -sS 'http://localhost:8123/?max_result_bytes=4000000&buffer_size=3000000&wait_end_of_query=1' -d 'SELECT toUInt8(number) FROM system.numbers LIMIT 9000000 FORMAT RowBinary' +``` + +Yanıt Kodu ve HTTP üstbilgileri istemciye gönderildikten sonra bir sorgu işleme hatası oluştu durumları önlemek için arabelleğe alma kullanın. Bu durumda, yanıt gövdesinin sonunda bir hata iletisi yazılır ve istemci tarafında hata yalnızca ayrıştırma aşamasında algılanabilir. + +### Parametrelerle sorgular {#cli-queries-with-parameters} + +Parametrelerle bir sorgu oluşturabilir ve karşılık gelen HTTP istek parametrelerinden onlar için değerler geçirebilirsiniz. Daha fazla bilgi için, bkz. [CLI için parametrelerle sorgular](cli.md#cli-queries-with-parameters). + +### Örnek {#example} + +``` bash +$ curl -sS "
?param_id=2¶m_phrase=test" -d "SELECT * FROM table WHERE int_column = {id:UInt8} and string_column = {phrase:String}" +``` + +## Önceden tanımlanmış HTTP arabirimi {#predefined_http_interface} + +ClickHouse HTTP arabirimi üzerinden belirli sorguları destekler. Örneğin, bir tabloya aşağıdaki gibi veri yazabilirsiniz: + +``` bash +$ echo '(4),(5),(6)' | curl 'http://localhost:8123/?query=INSERT%20INTO%20t%20VALUES' --data-binary @- +``` + +ClickHouse ayrıca gibi üçüncü parti araçları ile daha kolay entegrasyon yardımcı olabilir önceden tanımlanmış HTTP arayüzünü destekler [PROMETHEUS ihracatçı](https://github.com/percona-lab/clickhouse_exporter). + +Örnek: + +- Her şeyden önce, bu bölümü sunucu yapılandırma dosyasına ekleyin: + + + +``` xml + + + /metrics + GET + + SELECT * FROM system.metrics LIMIT 5 FORMAT Template SETTINGS format_template_resultset = 'prometheus_template_output_format_resultset', format_template_row = 'prometheus_template_output_format_row', format_template_rows_between_delimiter = '\n' + + + +``` + +- Artık PROMETHEUS formatında veriler için doğrudan url talep edebilirsiniz: + + + +``` bash +curl -vvv 'http://localhost:8123/metrics' +* Trying ::1... +* Connected to localhost (::1) port 8123 (#0) +> GET /metrics HTTP/1.1 +> Host: localhost:8123 +> User-Agent: curl/7.47.0 +> Accept: */* +> +< HTTP/1.1 200 OK +< Date: Wed, 27 Nov 2019 08:54:25 GMT +< Connection: Keep-Alive +< Content-Type: text/plain; charset=UTF-8 +< X-ClickHouse-Server-Display-Name: i-tl62qd0o +< Transfer-Encoding: chunked +< X-ClickHouse-Query-Id: f39235f6-6ed7-488c-ae07-c7ceafb960f6 +< Keep-Alive: timeout=3 +< X-ClickHouse-Summary: {"read_rows":"0","read_bytes":"0","written_rows":"0","written_bytes":"0","total_rows_to_read":"0"} +< +# HELP "Query" "Number of executing queries" +# TYPE "Query" counter +"Query" 1 + +# HELP "Merge" "Number of executing background merges" +# TYPE "Merge" counter +"Merge" 0 + +# HELP "PartMutation" "Number of mutations (ALTER DELETE/UPDATE)" +# TYPE "PartMutation" counter +"PartMutation" 0 + +# HELP "ReplicatedFetch" "Number of data parts being fetched from replica" +# TYPE "ReplicatedFetch" counter +"ReplicatedFetch" 0 + +# HELP "ReplicatedSend" "Number of data parts being sent to replicas" +# TYPE "ReplicatedSend" counter +"ReplicatedSend" 0 + +* Connection #0 to host localhost left intact +``` + +Örnekten görebileceğiniz gibi, Eğer `` yapılandırmada yapılandırılır.XML dosyası, ClickHouse önceden tanımlanmış türüne alınan HTTP istekleri eşleşecek `` Maç başarılı olursa, ClickHouse ilgili önceden tanımlanmış sorgu yürütecektir. + +Şimdi `` Yapılandır configureılabilir ``, ``, ``, `` ve `` . + +## root\_handler {#root_handler} + +`` kök yolu isteği için belirtilen içeriği döndürür. Belirli dönüş içeriği tarafından yapılandırılır `http_server_default_response` config.xml. belirtilmemişse, iade **Tamam.** + +`http_server_default_response` tanımlanmadı ve Clickhouse'a bir HTTP isteği gönderildi. Sonuç aşağıdaki gibidir: + +``` xml + + + +``` + + $ curl 'http://localhost:8123' + Ok. + +`http_server_default_response` tanımlanır ve Clickhouse'a bir HTTP isteği gönderilir. Sonuç aşağıdaki gibidir: + +``` xml +
]]> + + + + +``` + + $ curl 'http://localhost:8123' +
% + +## ping\_handler {#ping_handler} + +`` geçerli ClickHouse sunucusunun durumunu araştırmak için kullanılabilir. ClickHouse HTTP Sunucusu normal olduğunda, Clickhouse'a erişme `` dön willecektir **Tamam.**. + +Örnek: + +``` xml + + /ping + +``` + +``` bash +$ curl 'http://localhost:8123/ping' +Ok. +``` + +## replicas\_status\_handler {#replicas_status_handler} + +`` çoğaltma düğümünün durumunu algılamak ve geri dönmek için kullanılır **Tamam.** çoğaltma düğümünde gecikme yoksa. Bir gecikme varsa, belirli bir gecikmeyi iade edin. Değeri `` özelleştirme destekler. Belirt specifymezseniz ``, ClickHouse varsayılan ayarı `` oluyor **/ replicas\_status**. + +Örnek: + +``` xml + + /replicas_status + +``` + +Hiçbir gecikme durumda: + +``` bash +$ curl 'http://localhost:8123/replicas_status' +Ok. +``` + +Gecikmeli dava: + +``` bash +$ curl 'http://localhost:8123/replicas_status' +db.stats: Absolute delay: 22. Relative delay: 22. +``` + +## predefined\_query\_handler {#predefined_query_handler} + +Yapılandırabilirsiniz ``, ``, `` ve `` içinde ``. + +`` HTTP isteğinin yöntem bölümünü eşleştirmekten sorumludur. `` tam tanımına uygundur [yöntem](https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods) HTTP protokolünde. İsteğe bağlı bir yapılandırmadır. Yapılandırma dosyasında tanımlanmamışsa, HTTP isteğinin yöntem kısmıyla eşleşmez + +`` HTTP isteğinin url bölümünü eşleştirmekten sorumludur. İle uyumludur [RE2](https://github.com/google/re2)'In düzenli ifadeleri. İsteğe bağlı bir yapılandırmadır. Yapılandırma dosyasında tanımlanmamışsa, HTTP isteğinin url kısmıyla eşleşmez + +`` HTTP isteğinin başlık kısmını eşleştirmekten sorumludur. Bu re2 düzenli ifadeler ile uyumludur. İsteğe bağlı bir yapılandırmadır. Yapılandırma dosyasında tanımlanmamışsa, HTTP isteğinin başlık kısmıyla eşleşmez + +`` değer, önceden tanımlanmış bir sorgudur ``, bir HTTP isteği eşleştirildiğinde ve sorgunun sonucu döndürüldüğünde ClickHouse tarafından yürütülür. Bu bir zorunluluktur yapılandırma. + +`` ayar ayarları ve query\_params değerlerini destekler. + +Aşağıdaki örnek değerleri tanımlar `max_threads` ve `max_alter_threads` ayarlar, ardından bu ayarların başarıyla ayarlanıp ayarlanmadığını kontrol etmek için sistem tablosunu sorgular. + +Örnek: + +``` xml + + + GET + + TEST_HEADER_VALUE + [^/]+)(/(?P[^/]+))?]]> + + [^/]+)(/(?P[^/]+))?]]> + + SELECT value FROM system.settings WHERE name = {name_1:String} + SELECT name, value FROM system.settings WHERE name = {name_2:String} + + + +``` + +``` bash +$ curl -H 'XXX:TEST_HEADER_VALUE' -H 'PARAMS_XXX:max_threads' 'http://localhost:8123/query_param_with_url/1/max_threads/max_alter_threads?max_threads=1&max_alter_threads=2' +1 +max_alter_threads 2 +``` + +!!! note "Not" + Birinde ``, biri `` sadece birini destekler `` bir ekleme türü. + +## dynamic\_query\_handler {#dynamic_query_handler} + +`` göre `` artmak `` . + +ClickHouse ayıklar ve karşılık gelen değeri yürütür `` HTTP isteğinin url'sindeki değer. +ClickHouse varsayılan ayarı `` oluyor `/query` . İsteğe bağlı bir yapılandırmadır. Yapılandırma dosyasında tanım yoksa, param iletilmez. + +Bu işlevselliği denemek için örnek max\_threads ve max\_alter\_threads değerlerini tanımlar ve ayarların başarıyla ayarlanıp ayarlanmadığını sorgular. +Fark şu ki ``, sorgu yapılandırma dosyasında yazılır. Ama içinde ``, sorgu HTTP isteğinin param şeklinde yazılır. + +Örnek: + +``` xml + + + + TEST_HEADER_VALUE_DYNAMIC + [^/]+)(/(?P[^/]+))?]]> + + query_param + + +``` + +``` bash +$ curl -H 'XXX:TEST_HEADER_VALUE_DYNAMIC' -H 'PARAMS_XXX:max_threads' 'http://localhost:8123/?query_param=SELECT%20value%20FROM%20system.settings%20where%20name%20=%20%7Bname_1:String%7D%20OR%20name%20=%20%7Bname_2:String%7D&max_threads=1&max_alter_threads=2¶m_name_2=max_alter_threads' +1 +2 +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/http_interface/) diff --git a/docs/tr/interfaces/index.md b/docs/tr/interfaces/index.md new file mode 100644 index 00000000000..6a89d8cce7e --- /dev/null +++ b/docs/tr/interfaces/index.md @@ -0,0 +1,29 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: Arabirimler +toc_priority: 14 +toc_title: "Giri\u015F" +--- + +# Arabirimler {#interfaces} + +ClickHouse iki ağ arabirimi sağlar (Her ikisi de isteğe bağlı olarak ek güvenlik için TLS'YE sarılabilir): + +- [HTTP](http.md), belgelenmiş ve doğrudan kullanımı kolay olan. +- [Yerel TCP](tcp.md) daha az yükü olan. + +Çoğu durumda, doğrudan bunlarla etkileşime girmek yerine uygun araç veya kitaplık kullanılması önerilir. Resmi olarak Yandex tarafından desteklenen şunlardır: + +- [Komut satırı istemcisi](cli.md) +- [JDBC sürücüsü](jdbc.md) +- [ODBC sürücüsü](odbc.md) +- [C++ istemci kitaplığı](cpp.md) + +ClickHouse ile çalışmak için çok çeşitli üçüncü taraf kütüphaneleri de vardır: + +- [İstemci kitaplıkları](third-party/client_libraries.md) +- [Entegrasyonlar](third-party/integrations.md) +- [Görsel arayüzler](third-party/gui.md) + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/) diff --git a/docs/tr/interfaces/jdbc.md b/docs/tr/interfaces/jdbc.md new file mode 100644 index 00000000000..a7e69550c5a --- /dev/null +++ b/docs/tr/interfaces/jdbc.md @@ -0,0 +1,15 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 22 +toc_title: "JDBC s\xFCr\xFCc\xFCs\xFC" +--- + +# JDBC sürücüsü {#jdbc-driver} + +- **[Resmi sürücü](https://github.com/ClickHouse/clickhouse-jdbc)** +- Üçüncü taraf sürücüler: + - [ClickHouse-yerli-JDBC](https://github.com/housepower/ClickHouse-Native-JDBC) + - [clickhouse4j](https://github.com/blynkkk/clickhouse4j) + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/jdbc/) diff --git a/docs/tr/interfaces/mysql.md b/docs/tr/interfaces/mysql.md new file mode 100644 index 00000000000..4e60430f554 --- /dev/null +++ b/docs/tr/interfaces/mysql.md @@ -0,0 +1,49 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 20 +toc_title: "MySQL Aray\xFCz\xFC" +--- + +# MySQL Arayüzü {#mysql-interface} + +ClickHouse MySQL Tel protokolünü destekler. Tarafından etkinleştir canilebilir [mysql\_port](../operations/server_configuration_parameters/settings.md#server_configuration_parameters-mysql_port) yapılandırma dosyasında ayarlama: + +``` xml +9004 +``` + +Komut satırı aracını kullanarak bağlanma örneği `mysql`: + +``` bash +$ mysql --protocol tcp -u default -P 9004 +``` + +Bir bağlantı başarılı olursa çıktı: + +``` text +Welcome to the MySQL monitor. Commands end with ; or \g. +Your MySQL connection id is 4 +Server version: 20.2.1.1-ClickHouse + +Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved. + +Oracle is a registered trademark of Oracle Corporation and/or its +affiliates. Other names may be trademarks of their respective +owners. + +Type 'help;' or '\h' for help. Type '\c' to clear the current input statement. + +mysql> +``` + +Tüm MySQL istemcileri ile uyumluluk için, kullanıcı parolasını belirtmeniz önerilir [çift SHA1](../operations/settings/settings_users.md#password_double_sha1_hex) yapılandırma dosyasında. +Kullanarak kullanıcı şifresi belirt ifilirse [SHA256](../operations/settings/settings_users.md#password_sha256_hex), bazı istemciler (mysqljs ve komut satırı aracı mysql eski sürümleri) kimlik doğrulaması mümkün olmayacaktır. + +Kısıtlama: + +- hazırlanan sorgular desteklenmiyor + +- bazı veri türleri dizeleri olarak gönderilir + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/mysql/) diff --git a/docs/tr/interfaces/odbc.md b/docs/tr/interfaces/odbc.md new file mode 100644 index 00000000000..3cc0cc35700 --- /dev/null +++ b/docs/tr/interfaces/odbc.md @@ -0,0 +1,12 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 23 +toc_title: "ODBC s\xFCr\xFCc\xFCs\xFC" +--- + +# ODBC sürücüsü {#odbc-driver} + +- [Resmi sürücü](https://github.com/ClickHouse/clickhouse-odbc). + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/odbc/) diff --git a/docs/tr/interfaces/tcp.md b/docs/tr/interfaces/tcp.md new file mode 100644 index 00000000000..b1f712efd7d --- /dev/null +++ b/docs/tr/interfaces/tcp.md @@ -0,0 +1,12 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 18 +toc_title: Yerel arabirim (TCP) +--- + +# Yerel arabirim (TCP) {#native-interface-tcp} + +Yerel protokol kullanılır [komut satırı istemcisi](cli.md), dağıtılmış sorgu işleme sırasında ve ayrıca diğer C++ programlarında sunucular arası iletişim için. Ne yazık ki, yerel ClickHouse protokolü henüz resmi bir spesifikasyona sahip değildir, ancak ClickHouse kaynak kodundan ters mühendislik yapılabilir (başlangıç [bu civarda](https://github.com/ClickHouse/ClickHouse/tree/master/src/Client)) ve / veya TCP trafiğini ele alarak ve analiz ederek. + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/tcp/) diff --git a/docs/tr/interfaces/third-party/client_libraries.md b/docs/tr/interfaces/third-party/client_libraries.md new file mode 100644 index 00000000000..2b89b1c4520 --- /dev/null +++ b/docs/tr/interfaces/third-party/client_libraries.md @@ -0,0 +1,59 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 26 +toc_title: "\u0130stemci Kitapl\u0131klar\u0131" +--- + +# Üçüncü taraf geliştiricilerin istemci kitaplıkları {#client-libraries-from-third-party-developers} + +!!! warning "Uyarı" + Yandex yapar **değil** Aşağıda listelenen kütüphaneleri koruyun ve kalitelerini sağlamak için kapsamlı bir test yapmadınız. + +- Piton + - [ınfi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm) + - [clickhouse-sürücü](https://github.com/mymarilyn/clickhouse-driver) + - [clickhouse-müşteri](https://github.com/yurial/clickhouse-client) + - [aiochclient](https://github.com/maximdanilchenko/aiochclient) +- PHP + - [smı2/phpclickhouse](https://packagist.org/packages/smi2/phpClickHouse) + - [8bitov / clickhouse-php-client](https://packagist.org/packages/8bitov/clickhouse-php-client) + - [bozerkins / clickhouse-müşteri](https://packagist.org/packages/bozerkins/clickhouse-client) + - [simpod / clickhouse-müşteri](https://packagist.org/packages/simpod/clickhouse-client) + - [seva-code / php-click-house-client](https://packagist.org/packages/seva-code/php-click-house-client) + - [SeasClick c ++ istemcisi](https://github.com/SeasX/SeasClick) +- Gitmek + - [clickhouse](https://github.com/kshvakov/clickhouse/) + - [git-clickhouse](https://github.com/roistat/go-clickhouse) + - [mailrugo-clickhouse](https://github.com/mailru/go-clickhouse) + - [golang-clickhouse](https://github.com/leprosus/golang-clickhouse) +- NodeJs + - [NodeJs) clickhouse)](https://github.com/TimonKK/clickhouse) + - [düğüm-clickhouse](https://github.com/apla/node-clickhouse) +- Per perll + - [perl-DBD-ClickHouse](https://github.com/elcamlost/perl-DBD-ClickHouse) + - [HTTP-ClickHouse](https://metacpan.org/release/HTTP-ClickHouse) + - [AnyEvent-ClickHouse](https://metacpan.org/release/AnyEvent-ClickHouse) +- Yakut + - [ClickHouse (Ruby)](https://github.com/shlima/click_house) + - [clickhouse-activerecord](https://github.com/PNixx/clickhouse-activerecord) +- R + - [clickhouse-r](https://github.com/hannesmuehleisen/clickhouse-r) + - [RClickHouse](https://github.com/IMSMWU/RClickHouse) +- Java + - [clickhouse-client-java](https://github.com/VirtusAI/clickhouse-client-java) + - [clickhouse-müşteri](https://github.com/Ecwid/clickhouse-client) +- SC scalaala + - [clickhouse-Scala-istemci](https://github.com/crobox/clickhouse-scala-client) +- Kotlin + - [AORM](https://github.com/TanVD/AORM) +- C\# + - [ClickHouse.Gürültü](https://github.com/killwort/ClickHouse-Net) + - [ClickHouse.Müşteri](https://github.com/DarkWanderer/ClickHouse.Client) + - [ClickHouse.Net](https://github.com/ilyabreev/ClickHouse.Net) +- İksir + - [clickhousex](https://github.com/appodeal/clickhousex/) +- Nim + - [nim-clickhouse](https://github.com/leonardoce/nim-clickhouse) + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/third-party/client_libraries/) diff --git a/docs/tr/interfaces/third-party/gui.md b/docs/tr/interfaces/third-party/gui.md new file mode 100644 index 00000000000..cb41103563d --- /dev/null +++ b/docs/tr/interfaces/third-party/gui.md @@ -0,0 +1,152 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 28 +toc_title: "G\xF6rsel Aray\xFCzler" +--- + +# Üçüncü taraf geliştiricilerin görsel arayüzleri {#visual-interfaces-from-third-party-developers} + +## Açık Kaynak {#open-source} + +### Tabix {#tabix} + +ClickHouse için web arayüzü [Tabix](https://github.com/tabixio/tabix) projelendirmek. + +Özellikler: + +- Ek yazılım yüklemeye gerek kalmadan doğrudan tarayıcıdan ClickHouse ile çalışır. +- Sözdizimi vurgulama ile sorgu editörü. +- Komutların otomatik tamamlanması. +- Sorgu yürütme grafik analizi için araçlar. +- Renk düzeni seçenekleri. + +[Tabix belgeleri](https://tabix.io/doc/). + +### HouseOps {#houseops} + +[HouseOps](https://github.com/HouseOps/HouseOps) OSX, Linux ve Windows için bir UI / IDE. + +Özellikler: + +- Sözdizimi vurgulama ile sorgu oluşturucu. Yanıtı bir tablo veya JSON görünümünde görüntüleyin. +- CSV veya JSON olarak ihracat sorgu sonuçları. +- Açıklamaları ile süreçlerin listesi. Yazma modu. Durdurmak için yeteneği (`KILL`) işleyiş. +- Veritabanı grafiği. Tüm tabloları ve sütunlarını ek bilgilerle gösterir. +- Sütun boyutunun hızlı bir görünümü. +- Sunucu yapılandırması. + +Aşağıdaki özellikler geliştirme için planlanmıştır: + +- Veritabanı yönetimi. +- Kullanıcı yönetimi. +- Gerçek zamanlı veri analizi. +- Küme izleme. +- Küme yönetimi. +- Çoğaltılmış ve Kafka tablolarının izlenmesi. + +### Fener {#lighthouse} + +[Fener](https://github.com/VKCOM/lighthouse) ClickHouse için hafif bir web arayüzüdür. + +Özellikler: + +- Filtreleme ve meta veriler içeren tablo listesi. +- Filtreleme ve sıralama ile tablo önizleme. +- Salt okunur sorgu yürütme. + +### Redash {#redash} + +[Redash](https://github.com/getredash/redash) veri görselleştirme için bir platformdur. + +ClickHouse dahil olmak üzere birden fazla veri kaynağı için destekler, Redash bir son veri kümesi içine farklı veri kaynaklarından gelen sorguların sonuçlarını katılabilir. + +Özellikler: + +- Sorguların güçlü editörü. +- Veritabanı Gezgini. +- Verileri farklı formlarda temsil etmenize izin veren görselleştirme araçları. + +### DBeaver {#dbeaver} + +[DBeaver](https://dbeaver.io/) - ClickHouse desteği ile evrensel masaüstü veritabanı istemcisi. + +Özellikler: + +- Sözdizimi vurgulama ve otomatik tamamlama ile sorgu geliştirme. +- Filtreler ve meta arama ile tablo listesi. +- Tablo veri önizleme. +- Tam metin arama. + +### clickhouse-clı {#clickhouse-cli} + +[clickhouse-clı](https://github.com/hatarist/clickhouse-cli) Python 3 ile yazılmış ClickHouse için alternatif bir komut satırı istemcisidir. + +Özellikler: + +- Otomatik tamamlama. +- Sorgular ve veri çıkışı için sözdizimi vurgulama. +- Veri çıkışı için çağrı cihazı desteği. +- Özel PostgreSQL benzeri komutlar. + +### clickhouse-flamegraph {#clickhouse-flamegraph} + +[clickhouse-flamegraph](https://github.com/Slach/clickhouse-flamegraph) görselleştirmek için özel bir araçtır `system.trace_log` olarak [flamegraph](http://www.brendangregg.com/flamegraphs.html). + +## Ticari {#commercial} + +### Datriagrpip {#datagrip} + +[Datriagrpip](https://www.jetbrains.com/datagrip/) ClickHouse için özel destek ile JetBrains bir veritabanı IDE mi. PyCharm, IntelliJ IDEA, GoLand, PhpStorm ve diğerleri: aynı zamanda diğer IntelliJ tabanlı araçlar gömülüdür. + +Özellikler: + +- Çok hızlı kod tamamlama. +- ClickHouse sözdizimi vurgulama. +- Clickhouse'a özgü özellikler için destek, örneğin iç içe geçmiş sütunlar, tablo motorları. +- Veri Editörü. +- Refactorings. +- Arama ve navigasyon. + +### Yandex DataLens {#yandex-datalens} + +[Yandex DataLens](https://cloud.yandex.ru/services/datalens) veri görselleştirme ve analitik bir hizmettir. + +Özellikler: + +- Basit çubuk grafiklerden karmaşık panolara kadar geniş bir yelpazede mevcut görselleştirmeler. +- Panolar kamuya açık hale getirilebilir. +- ClickHouse dahil olmak üzere birden fazla veri kaynağı için destek. +- ClickHouse dayalı hayata veri depolama. + +DataLens olduğunu [ücretsiz olarak kullanılabilir](https://cloud.yandex.com/docs/datalens/pricing) düşük yük projeleri için, ticari kullanım için bile. + +- [DataLens belgeleri](https://cloud.yandex.com/docs/datalens/). +- [Öğretici](https://cloud.yandex.com/docs/solutions/datalens/data-from-ch-visualization) bir ClickHouse veritabanından veri görselleştirme üzerinde. + +### Holistik Yazılım {#holistics-software} + +[Holistik](https://www.holistics.io/) tam yığın veri platformu ve iş zekası aracıdır. + +Özellikler: + +- Otomatik e-posta, bolluk ve raporların Google levha programları. +- Görselleştirmeler, sürüm kontrolü, Otomatik tamamlama, yeniden kullanılabilir sorgu bileşenleri ve dinamik filtreler ile SQL editörü. +- IFRAME aracılığıyla raporların ve gösterge panellerinin gömülü analitiği. +- Veri hazırlama ve ETL yetenekleri. +- Verilerin ilişkisel haritalama için SQL veri modelleme desteği. + +### Looker {#looker} + +[Looker](https://looker.com) ClickHouse dahil 50+ veritabanı lehçeleri desteği ile bir veri platformu ve iş zekası aracıdır. Looker bir SaaS platformu olarak kullanılabilir ve kendi kendine barındırılan. Kullanıcılar, verileri keşfetmek görselleştirme ve panoları, zamanlama raporları oluşturmak ve meslektaşları ile kendi görüşlerini paylaşmak için tarayıcı üzerinden Looker kullanabilirsiniz. Looker, bu özellikleri diğer uygulamalara gömmek için zengin bir araç seti ve bir API sağlar +verileri diğer uygulamalarla entegre etmek. + +Özellikler: + +- Küratörlüğünü destekleyen bir dil olan LookML kullanarak kolay ve çevik geliştirme + [Veri Modelleme](https://looker.com/platform/data-modeling) rapor yazarları ve son kullanıcıları desteklemek. +- Looker ile güçlü iş akışı entegrasyonu [Veri İşlemleri](https://looker.com/platform/actions). + +[Looker içinde ClickHouse nasıl yapılandırılır.](https://docs.looker.com/setup-and-management/database-config/clickhouse) + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/third-party/gui/) diff --git a/docs/tr/interfaces/third-party/index.md b/docs/tr/interfaces/third-party/index.md new file mode 100644 index 00000000000..d8332c00c26 --- /dev/null +++ b/docs/tr/interfaces/third-party/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "\xDC\xE7\xFCnc\xFC Taraf" +toc_priority: 24 +--- + + diff --git a/docs/tr/interfaces/third-party/integrations.md b/docs/tr/interfaces/third-party/integrations.md new file mode 100644 index 00000000000..ecb6662d0e8 --- /dev/null +++ b/docs/tr/interfaces/third-party/integrations.md @@ -0,0 +1,96 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 27 +toc_title: Entegrasyonlar +--- + +# Üçüncü taraf geliştiricilerin entegrasyon kütüphaneleri {#integration-libraries-from-third-party-developers} + +!!! warning "Uyarı" + Yandex yapar **değil** Aşağıda listelenen araçları ve kütüphaneleri koruyun ve kalitelerini sağlamak için kapsamlı bir test yapmadınız. + +## Altyapı Ürünleri {#infrastructure-products} + +- İlişkisel veritabanı yönetim sistemleri + - [MySQL](https://www.mysql.com) + - [ProxySQL](https://github.com/sysown/proxysql/wiki/ClickHouse-Support) + - [clickhouse-mysql-data-reader](https://github.com/Altinity/clickhouse-mysql-data-reader) + - [horgh-çoğaltıcı](https://github.com/larsnovikov/horgh-replicator) + - [PostgreSQL](https://www.postgresql.org) + - [clickhousedb\_fdw](https://github.com/Percona-Lab/clickhousedb_fdw) + - [ınfi.clickhouse\_fdw](https://github.com/Infinidat/infi.clickhouse_fdw) (kullanma [ınfi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) + - [pg2ch](https://github.com/mkabilov/pg2ch) + - [clickhouse\_fdw](https://github.com/adjust/clickhouse_fdw) + - [MSSQL](https://en.wikipedia.org/wiki/Microsoft_SQL_Server) + - [ClickHouseMigrator](https://github.com/zlzforever/ClickHouseMigrator) +- Mesaj kuyrukları + - [Kafka](https://kafka.apache.org) + - [clickhouse\_sinker](https://github.com/housepower/clickhouse_sinker) (kullanma [Go client](https://github.com/kshvakov/clickhouse/)) +- Nesne depoları + - [S3](https://en.wikipedia.org/wiki/Amazon_S3) + - [clickhouse-yedekleme](https://github.com/AlexAkulov/clickhouse-backup) +- Konteyner orkestrasyonu + - [Kubernetes](https://kubernetes.io) + - [clickhouse-operatör](https://github.com/Altinity/clickhouse-operator) +- Yapılandırma yönetimi + - [kuklacı](https://puppet.com) + - [ınnogames / clickhouse](https://forge.puppet.com/innogames/clickhouse) + - [mfedotov/clickhouse](https://forge.puppet.com/mfedotov/clickhouse) +- İzleme + - [Grafit](https://graphiteapp.org) + - [graphouse](https://github.com/yandex/graphouse) + - [karbon-clickhouse](https://github.com/lomik/carbon-clickhouse) + + - [grafit-clickhouse](https://github.com/lomik/graphite-clickhouse) + - [grafit-ch-doktoru](https://github.com/innogames/graphite-ch-optimizer) - staled bölümleri optimize eder [\* Graphıtemergetree](../../engines/table_engines/mergetree_family/graphitemergetree.md#graphitemergetree) eğer kurallar [toplaması yapılandırması](../../engines/table_engines/mergetree_family/graphitemergetree.md#rollup-configuration) uygulanabilir + - [Grafana](https://grafana.com/) + - [clickhouse-grafana](https://github.com/Vertamedia/clickhouse-grafana) + - [Prometheus](https://prometheus.io/) + - [clickhouse\_exporter](https://github.com/f1yegor/clickhouse_exporter) + - [PromHouse](https://github.com/Percona-Lab/PromHouse) + - [clickhouse\_exporter](https://github.com/hot-wifi/clickhouse_exporter) (kullanma [Go client](https://github.com/kshvakov/clickhouse/)) + - [Nagios](https://www.nagios.org/) + - [check\_clickhouse](https://github.com/exogroup/check_clickhouse/) + - [check\_clickhouse.py](https://github.com/innogames/igmonplugins/blob/master/src/check_clickhouse.py) + - [Zabbix](https://www.zabbix.com) + - [clickhouse-zabbix-şablon](https://github.com/Altinity/clickhouse-zabbix-template) + - [Sematext](https://sematext.com/) + - [clickhouse entegrasyonu](https://github.com/sematext/sematext-agent-integrations/tree/master/clickhouse) +- Günlük + - [rsyslog](https://www.rsyslog.com/) + - [omclickhouse](https://www.rsyslog.com/doc/master/configuration/modules/omclickhouse.html) + - [fluentd](https://www.fluentd.org) + - [loghouse](https://github.com/flant/loghouse) (içinde [Kubernetes](https://kubernetes.io)) + - [logagent](https://www.sematext.com/logagent) + - [logagent çıktı-eklenti-clickhouse](https://sematext.com/docs/logagent/output-plugin-clickhouse/) +- G geoeo + - [MaxMind](https://dev.maxmind.com/geoip/) + - [clickhouse-maxmind-geoıp](https://github.com/AlexeyKupershtokh/clickhouse-maxmind-geoip) + +## Programlama Dili {#programming-language-ecosystems} + +- Piton + - [SQLAlchemy](https://www.sqlalchemy.org) + - [sqlalchemy-clickhouse](https://github.com/cloudflare/sqlalchemy-clickhouse) (kullanma [ınfi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) + - [Pandalar](https://pandas.pydata.org) + - [pandahouse](https://github.com/kszucs/pandahouse) +- R + - [dplyr](https://db.rstudio.com/dplyr/) + - [RClickHouse](https://github.com/IMSMWU/RClickHouse) (kullanma [clickhouse-cpp](https://github.com/artpaul/clickhouse-cpp)) +- Java + - [Hadoop](http://hadoop.apache.org) + - [clickhouse-hdfs-loader](https://github.com/jaykelin/clickhouse-hdfs-loader) (kullanma [JDBC](../../sql_reference/table_functions/jdbc.md)) +- SC scalaala + - [Akka](https://akka.io) + - [clickhouse-Scala-istemci](https://github.com/crobox/clickhouse-scala-client) +- C\# + - [ADO.NET](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/ado-net-overview) + - [ClickHouse.Gürültü](https://github.com/killwort/ClickHouse-Net) + - [ClickHouse.Müşteri](https://github.com/DarkWanderer/ClickHouse.Client) + - [ClickHouse.Net](https://github.com/ilyabreev/ClickHouse.Net) + - [ClickHouse. Net. Migrations](https://github.com/ilyabreev/ClickHouse.Net.Migrations) +- İksir + - [Ecto](https://github.com/elixir-ecto/ecto) + - [clickhouse\_ecto](https://github.com/appodeal/clickhouse_ecto) + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/third-party/integrations/) diff --git a/docs/tr/interfaces/third-party/proxy.md b/docs/tr/interfaces/third-party/proxy.md new file mode 100644 index 00000000000..7ff9fc3642f --- /dev/null +++ b/docs/tr/interfaces/third-party/proxy.md @@ -0,0 +1,46 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 29 +toc_title: Vekiller +--- + +# Üçüncü taraf geliştiricilerin Proxy sunucuları {#proxy-servers-from-third-party-developers} + +## chproxy {#chproxy} + +[chproxy](https://github.com/Vertamedia/chproxy), ClickHouse veritabanı için bir HTTP proxy ve yük dengeleyici. + +Özellikler: + +- Kullanıcı başına Yönlendirme ve yanıt önbelleğe alma. +- Esnek sınırlar. +- Otomatik SSL sertifikası yenileme. + +Go uygulanan. + +## KittenHouse {#kittenhouse} + +[KittenHouse](https://github.com/VKCOM/kittenhouse) ClickHouse ve uygulama sunucusu arasında yerel bir proxy olacak şekilde tasarlanmıştır. + +Özellikler: + +- Bellek içi ve diskteki veri arabelleği. +- Tablo başına yönlendirme. +- Yük dengeleme ve sağlık kontrolü. + +Go uygulanan. + +## ClickHouse-Toplu {#clickhouse-bulk} + +[ClickHouse-Toplu](https://github.com/nikepan/clickhouse-bulk) basit bir ClickHouse ekleme toplayıcı. + +Özellikler: + +- Grup istekleri ve eşik veya aralık ile gönderin. +- Birden çok uzak sunucu. +- Temel kimlik doğrulama. + +Go uygulanan. + +[Orijinal makale](https://clickhouse.tech/docs/en/interfaces/third-party/proxy/) diff --git a/docs/tr/introduction/adopters.md b/docs/tr/introduction/adopters.md new file mode 100644 index 00000000000..0e180e161ec --- /dev/null +++ b/docs/tr/introduction/adopters.md @@ -0,0 +1,83 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 8 +toc_title: Benimseyenler +--- + +# ClickHouse Benimseyenler {#clickhouse-adopters} + +!!! warning "Uyarı" + ClickHouse ve onların Başarı Öyküleri kullanarak şirketlerin aşağıdaki liste kamu kaynaklarından monte edilir, böylece mevcut gerçeklikten farklı olabilir. Şirketinizde Clickhouse'u benimseme hikayesini paylaşırsanız memnun oluruz ve [listeye Ekle](https://github.com/ClickHouse/ClickHouse/edit/master/docs/en/introduction/adopters.md), ancak lütfen bunu yaparak herhangi bir NDA sorun yaşamayacağınızdan emin olun. Diğer şirketlerden gelen yayınlarla güncellemeler sağlamak da yararlıdır. + +| Şirket | Sektör | Usecase | Küme Boyutu | (Un) Sıkıştırılmış Veri Boyutu\* | Başvurma | +|----------------------------------------------------------------------------------------------------------|---------------------------------|-----------------------------|------------------------------------------------|------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| [2gıs](https://2gis.ru) | Haritalar | İzleme | — | — | [Rusça konuşun, Temmuz 2019](https://youtu.be/58sPkXfq6nw) | +| [Aloha Tarayıcı](https://alohabrowser.com/) | Mobil Uygulama | Tarayıcı arka ucu | — | — | [Rusça slaytlar, Mayıs 2019](https://github.com/yandex/clickhouse-presentations/blob/master/meetup22/aloha.pdf) | +| [Amadeus](https://amadeus.com/) | Seyahat | Analiz | — | — | [Basın Bülteni, Nisan 2018](https://www.altinity.com/blog/2018/4/5/amadeus-technologies-launches-investment-and-insights-tool-based-on-machine-learning-and-strategy-algorithms) | +| [Appsflyer](https://www.appsflyer.com) | Mobil analitik | Ana ürün | — | — | [Rusça konuşun, Temmuz 2019](https://www.youtube.com/watch?v=M3wbRlcpBbY) | +| [ArenaData](https://arenadata.tech/) | Veri Platformu | Ana ürün | — | — | [Rusça slaytlar, Aralık 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup38/indexes.pdf) | +| [Badoo](https://badoo.com) | Çıkma | Timeseries | — | — | [Rusça slaytlar, Aralık 2019](https://presentations.clickhouse.tech/meetup38/forecast.pdf) | +| [Benocs](https://www.benocs.com/) | Ağ telemetri ve analitik | Ana Ürün | — | — | [İngilizce slaytlar, Ekim 2017](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup9/lpm.pdf) | +| [Bloomberg](https://www.bloomberg.com/) | Finans, Medya | İzleme | 102 sunucular | — | [Slaytlar, Mayıs 2018](https://www.slideshare.net/Altinity/http-analytics-for-6m-requests-per-second-using-clickhouse-by-alexander-bocharov) | +| [Bloxy](https://bloxy.info) | Blockchain | Analiz | — | — | [Rusça slaytlar, Ağustos 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup17/4_bloxy.pptx) | +| `Dataliance/UltraPower` | Telekom | Analiz | — | — | [Çince slaytlar, Ocak 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup12/telecom.pdf) | +| [CARTO](https://carto.com/) | İş Zek Businessası | G geoeo analyt analyticsics | — | — | [ClickHouse ile coğrafi işleme](https://carto.com/blog/geospatial-processing-with-clickhouse/) | +| [CERN](http://public.web.cern.ch/public/) | Araştırma | Deney | — | — | [Basın bülteni, Nisan 2012](https://www.yandex.com/company/press_center/press_releases/2012/2012-04-10/) | +| [Cisco](http://cisco.com/) | Ağ | Trafik analizi | — | — | [Yıldırım konuşması, Ekim 2019](https://youtu.be/-hI1vDR2oPY?t=5057) | +| [Kale Menkul Değerler](https://www.citadelsecurities.com/) | Finansman | — | — | — | [Katkı, Mart 2019](https://github.com/ClickHouse/ClickHouse/pull/4774) | +| [Citymobil](https://city-mobil.ru) | Taksicilik | Analiz | — | — | [Rusça blog yazısı, Mart 2020](https://habr.com/en/company/citymobil/blog/490660/) | +| [ContentSquare](https://contentsquare.com) | Web analyt webics | Ana ürün | — | — | [Fransızca Blog yazısı, Kasım 2018](http://souslecapot.net/2018/11/21/patrick-chatain-vp-engineering-chez-contentsquare-penser-davantage-amelioration-continue-que-revolution-constante/) | +| [Cloudflare](https://cloudflare.com) | CDN | Trafik analizi | 36 sunucu | — | [Blog yazısı, Mayıs 2017](https://blog.cloudflare.com/how-cloudflare-analyzes-1m-dns-queries-per-second/), [Blog yazısı, Mart 2018](https://blog.cloudflare.com/http-analytics-for-6m-requests-per-second-using-clickhouse/) | +| [Corunet](https://coru.net/) | Analiz | Ana ürün | — | — | [İngilizce slaytlar, Nisan 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup21/predictive_models.pdf) | +| [CraiditX 氪信](https://creditx.com) | Finans AI | Analiz | — | — | [İngilizce slaytlar, Kasım 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup33/udf.pptx) | +| [Criteo/Storetail](https://www.criteo.com/) | Perakendecilik | Ana ürün | — | — | [İngilizce slaytlar, Ekim 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup18/3_storetail.pptx) | +| [Deut Banksche Bank](https://db.com) | Finansman | Bİ analitik | — | — | [İngilizce slaytlar, Ekim 2019](https://bigdatadays.ru/wp-content/uploads/2019/10/D2-H3-3_Yakunin-Goihburg.pdf) | +| [Diva-e](https://www.diva-e.com) | Dijital danışmanlık | Ana Ürün | — | — | [İngilizce slaytlar, Eylül 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup29/ClickHouse-MeetUp-Unusual-Applications-sd-2019-09-17.pdf) | +| [Exness](https://www.exness.com) | Ticaret | Metrikler, Günlük Kaydı | — | — | [Rusça konuşun, Mayıs 2019](https://youtu.be/_rpU-TvSfZ8?t=3215) | +| [Geniee](https://geniee.co.jp) | Reklam Ağı | Ana ürün | — | — | [Japonca Blog yazısı, Temmuz 2017](https://tech.geniee.co.jp/entry/2017/07/20/160100) | +| [HUYA](https://www.huya.com/) | Video Akışı | Analiz | — | — | [Çince slaytlar, Ekim 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup19/7.%20ClickHouse万亿数据分析实践%20李本旺(sundy-li)%20虎牙.pdf) | +| [Idealista](https://www.idealista.com) | Emlak | Analiz | — | — | [İngilizce Blog yazısı, Nisan 2019](https://clickhouse.yandex/blog/en/clickhouse-meetup-in-madrid-on-april-2-2019) | +| [Infovista](https://www.infovista.com/) | Ağlar | Analiz | — | — | [İngilizce slaytlar, Ekim 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup30/infovista.pdf) | +| [Innogames](https://www.innogames.com) | Oyun | Metrikler, Günlük Kaydı | — | — | [Rusça slaytlar, Eylül 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup28/graphite_and_clickHouse.pdf) | +| [Integros](https://integros.com) | Video hizmetleri platformu | Analiz | — | — | [Rusça slaytlar, Mayıs 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup22/strategies.pdf) | +| [Kodiak Verileri](https://www.kodiakdata.com/) | Bulutlar | Ana ürün | — | — | [Engish slaytlar, Nisan 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup13/kodiak_data.pdf) | +| [Kontur](https://kontur.ru) | Yazılım Geliştirme | Metrik | — | — | [Rusça konuşma, Kasım 2018](https://www.youtube.com/watch?v=U4u4Bd0FtrY) | +| [LifeStreet](https://lifestreet.com/) | Reklam Ağı | Ana ürün | 75 sunucu (3 kopya) | 5.27 Pıb | [Rusça Blog yazısı, Şubat 2017](https://habr.com/en/post/322620/) | +| [Mail.ru Bulut Çözümleri](https://mcs.mail.ru/) | Bulut hizmetleri | Ana ürün | — | — | [ClickHouse örneğini Rusça olarak çalıştırma](https://mcs.mail.ru/help/db-create/clickhouse#) | +| [MessageBird](https://www.messagebird.com) | Telekomünikasyonlar | İstatistik | — | — | [İngilizce slaytlar, Kasım 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup20/messagebird.pdf) | +| [MGID](https://www.mgid.com/) | Reklam Ağı | Web-analyt -ics | — | — | [Analitik DBMS ClickHouse uygulama deneyimimiz, Rusça](http://gs-studio.com/news-about-it/32777----clickhouse---c) | +| [OneAPM](https://www.oneapm.com/) | İzleme ve veri analizi | Ana ürün | — | — | [Çince slaytlar, Ekim 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup19/8.%20clickhouse在OneAPM的应用%20杜龙.pdf) | +| [Pragma Yenilik](http://www.pragma-innovation.fr/) | Telemetri ve büyük veri analizi | Ana ürün | — | — | [İngilizce slaytlar, Ekim 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup18/4_pragma_innovation.pdf) | +| [QINGCLOUD](https://www.qingcloud.com/) | Bulut hizmetleri | Ana ürün | — | — | [Çince slaytlar, Ekim 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup19/4.%20Cloud%20%2B%20TSDB%20for%20ClickHouse%20张健%20QingCloud.pdf) | +| [Qrator](https://qrator.net) | DDoS koruması | Ana ürün | — | — | [Blog Yazısı, Mart 2019](https://blog.qrator.net/en/clickhouse-ddos-mitigation_37/) | +| [Beijing per PERCENTC İnformationent Information Technology Co., Ltd. Ltd.Şti.](https://www.percent.cn/) | Analiz | Ana Ürün | — | — | [Çince slaytlar, Haziran 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup24/4.%20ClickHouse万亿数据双中心的设计与实践%20.pdf) | +| [Serseri](https://rambler.ru) | İnternet Hizmetleri | Analiz | — | — | [Rusça konuşma, Nisan 2018](https://medium.com/@ramblertop/разработка-api-clickhouse-для-рамблер-топ-100-f4c7e56f3141) | +| [Tencent](https://www.tencent.com) | Mesaj | Günlük | — | — | [Çince konuşun, Kasım 2019](https://youtu.be/T-iVQRuw-QY?t=5050) | +| [Trafik Yıldız Starsları](https://trafficstars.com/) | Reklam Ağı | — | — | — | [Rusça slaytlar, Mayıs 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup15/lightning/ninja.pdf) | +| [S7 Havayolları](https://www.s7.ru) | Havayolular | Metrikler, Günlük Kaydı | — | — | [Rusça konuş, Mart 2019](https://www.youtube.com/watch?v=nwG68klRpPg&t=15s) | +| [SEMrush](https://www.semrush.com/) | Pazarlamacı | Ana ürün | — | — | [Rusça slaytlar, Ağustos 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup17/5_semrush.pdf) | +| [scireum GmbH](https://www.scireum.de/) | e-ticaret | Ana ürün | — | — | [Almanca konuşma, Şubat 2020](https://www.youtube.com/watch?v=7QWAn5RbyR4) | +| [Nöbet](https://sentry.io/) | Yazılımcı | Ürün için arka uç | — | — | [İngilizce Blog yazısı, Mayıs 2019](https://blog.sentry.io/2019/05/16/introducing-snuba-sentrys-new-search-infrastructure) | +| [SGK](http://www.sgk.gov.tr/wps/portal/sgk/tr) | Devlet Sosyal Güvenlik | Analiz | — | — | [İngilizce slaytlar, Kasım 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup35/ClickHouse%20Meetup-Ramazan%20POLAT.pdf) | +| [seo.do](https://seo.do/) | Analiz | Ana ürün | — | — | [İngilizce slaytlar, Kasım 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup35/CH%20Presentation-%20Metehan%20Çetinkaya.pdf) | +| [Sina](http://english.sina.com/index.html) | Haberci | — | — | — | [Çince slaytlar, Ekim 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup19/6.%20ClickHouse最佳实践%20高鹏_新浪.pdf) | +| [SMI2](https://smi2.ru/) | Haberci | Analiz | — | — | [Rusça blog yazısı, Kasım 2017](https://habr.com/ru/company/smi2/blog/314558/) | +| [Splunk](https://www.splunk.com/) | İş Analitiği | Ana ürün | — | — | [İngilizce slaytlar, Ocak 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup12/splunk.pdf) | +| [Spotify](https://www.spotify.com) | Müzik | Deney | — | — | [Slaytlar, Temmuz 2018](https://www.slideshare.net/glebus/using-clickhouse-for-experimentation-104247173) | +| [Tencent](https://www.tencent.com) | Büyük Veri | Veri işleme | — | — | [Çince slaytlar, Ekim 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup19/5.%20ClickHouse大数据集群应用_李俊飞腾讯网媒事业部.pdf) | +| [Uber](https://www.uber.com) | Taksicilik | Günlük | — | — | [Slay ,tlar, Şubat 20 202020](https://presentations.clickhouse.tech/meetup40/uber.pdf) | +| [VKontakte](https://vk.com) | Sosyal Ağ | İstatistik, Günlük | — | — | [Rusça slaytlar, Ağustos 2018](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup17/3_vk.pdf) | +| [Wisebits](https://wisebits.com/) | BT çözümleri | Analiz | — | — | [Rusça slaytlar, Mayıs 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup22/strategies.pdf) | +| [Xiaoxin Tech.](https://www.xiaoheiban.cn/) | Eğitici | Ortak amaç | — | — | [İngilizce slaytlar, Kasım 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup33/sync-clickhouse-with-mysql-mongodb.pptx) | +| [Ximalaya](https://www.ximalaya.com/) | Ses paylaşımı | OLAP | — | — | [İngilizce slaytlar, Kasım 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup33/ximalaya.pdf) | +| [Yandex Bulut](https://cloud.yandex.ru/services/managed-clickhouse) | Genel Bulut | Ana ürün | — | — | [Rusça konuşun, Aralık 2019](https://www.youtube.com/watch?v=pgnak9e_E0o) | +| [Yandex DataLens](https://cloud.yandex.ru/services/datalens) | İş Zek Businessası | Ana ürün | — | — | [Rusça slaytlar, Aralık 2019](https://presentations.clickhouse.tech/meetup38/datalens.pdf) | +| [Yandex Pazarı](https://market.yandex.ru/) | e-ticaret | Metrikler, Günlük Kaydı | — | — | [Rusça konuşma, Ocak 2019](https://youtu.be/_l1qP0DyBcA?t=478) | +| [Yandex Metrica](https://metrica.yandex.com) | Web analyt webics | Ana ürün | Bir kümede 360 sunucu, bir bölümde 1862 sunucu | 66.41 Pıb / 5.68 Pıb | [Slay ,tlar, Şubat 20 202020](https://presentations.clickhouse.tech/meetup40/introduction/#13) | +| [ЦВТ](https://htc-cs.ru/) | Yazılım Geliştirme | Metrikler, Günlük Kaydı | — | — | [Blog yazısı, Mart 2019, Rusça](https://vc.ru/dev/62715-kak-my-stroili-monitoring-na-prometheus-clickhouse-i-elk) | +| [МКБ](https://mkb.ru/) | Banka | Web-sistem izleme | — | — | [Rusça slaytlar, Eylül 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup28/mkb.pdf) | +| [金数据](https://jinshuju.net) | Bİ analitik | Ana ürün | — | — | [Çince slaytlar, Ekim 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup24/3.%20金数据数据架构调整方案Public.pdf) | +| [Instana](https://www.instana.com) | APM Platformu | Ana ürün | — | — | [Twitter mesaj](https://twitter.com/mieldonkers/status/1248884119158882304) | + +[Orijinal makale](https://clickhouse.tech/docs/en/introduction/adopters/) diff --git a/docs/tr/introduction/distinctive_features.md b/docs/tr/introduction/distinctive_features.md new file mode 100644 index 00000000000..3b26dea645c --- /dev/null +++ b/docs/tr/introduction/distinctive_features.md @@ -0,0 +1,77 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 4 +toc_title: "Ay\u0131rt Edici \xD6zellikler" +--- + +# Clickhouse'un ayırt edici özellikleri {#distinctive-features-of-clickhouse} + +## Doğru sütun yönelimli DBMS {#true-column-oriented-dbms} + +Bir gerçek sütun yönelimli DBMS, hiçbir ek veri değerleri ile depolanır. Diğer şeylerin yanı sıra, bu, uzunluklarının saklanmasını önlemek için sabit uzunluk değerlerinin desteklenmesi gerektiği anlamına gelir “number” değerlerin yanında. Örnek olarak, bir milyar Uİnt8 tipi değerler yaklaşık 1 GB sıkıştırılmamış tüketmelidir veya bu CPU kullanımını güçlü bir şekilde etkiler. Verileri kompakt bir şekilde saklamak esastır (herhangi bir “garbage”) sıkıştırılmamış olsa bile, dekompresyon hızı (CPU kullanımı) esas olarak sıkıştırılmamış verilerin hacmine bağlıdır. + +Farklı sütunların değerlerini ayrı ayrı depolayabilen, ancak diğer senaryolar için optimizasyonları nedeniyle analitik sorguları etkili bir şekilde işleyemeyen sistemler olduğu için dikkat çekicidir. Örnekler HBase, BigTable, Cassandra ve HyperTable. Bu sistemlerde, saniyede yüz bin satır civarında verim elde edersiniz, ancak saniyede yüz milyonlarca satır olmaz. + +Clickhouse'un tek bir veritabanı değil, bir veritabanı yönetim sistemi olduğunu da belirtmek gerekir. ClickHouse, çalışma zamanında tablolar ve veritabanları oluşturmak, veri yüklemek ve sunucuyu yeniden yapılandırmadan ve yeniden başlatmadan sorguları çalıştırmaya izin verir. + +## Veri Sıkıştırma {#data-compression} + +Bazı sütun yönelimli DBMSs (InfiniDB CE ve MonetDB) veri sıkıştırma kullanmayın. Bununla birlikte, veri sıkıştırma mükemmel performans elde etmede önemli bir rol oynar. + +## Verilerin Disk Depolama {#disk-storage-of-data} + +Verileri fiziksel olarak birincil anahtara göre sıralamak, belirli değerleri veya değer aralıkları için düşük gecikme süresi ile birkaç düzine milisaniyeden daha az veri ayıklamayı mümkün kılar. Bazı sütun yönelimli Dbms'ler (SAP HANA ve Google PowerDrill gibi) yalnızca RAM'de çalışabilir. Bu yaklaşım, gerçek zamanlı analiz için gerekenden daha büyük bir donanım bütçesinin tahsisini teşvik eder. ClickHouse düzenli sabit diskler üzerinde çalışmak üzere tasarlanmıştır, bu da GB veri depolama başına maliyetin düşük olduğu anlamına gelir, ancak varsa SSD ve ek RAM de tamamen kullanılır. + +## Birden fazla çekirdekte paralel işleme {#parallel-processing-on-multiple-cores} + +Büyük sorgular, geçerli sunucuda bulunan tüm gerekli kaynakları alarak doğal olarak paralelleştirilir. + +## Birden çok sunucuda dağıtılmış işleme {#distributed-processing-on-multiple-servers} + +Yukarıda belirtilen sütunlu Dbms'lerin neredeyse hiçbiri dağıtılmış sorgu işleme desteğine sahip değildir. +Clickhouse'da, veriler farklı parçalarda bulunabilir. Her parça, hata toleransı için kullanılan bir grup kopya olabilir. Tüm kırıklar, kullanıcı için şeffaf olarak paralel bir sorgu çalıştırmak için kullanılır. + +## SQL desteği {#sql-support} + +ClickHouse, çoğu durumda SQL standardına özdeş olan sql'i temel alan bildirime dayalı bir sorgu dilini destekler. +Desteklenen sorgular arasında GROUP BY, ORDER BY, from, ın ve JOIN yan tümceleri ve skaler alt sorgular bulunur. +Bağımlı alt sorgular ve pencere işlevleri desteklenmez. + +## Vektör Motoru {#vector-engine} + +Veriler yalnızca sütunlar tarafından saklanmakla kalmaz, aynı zamanda yüksek CPU verimliliği elde etmeyi sağlayan vektörler (sütunların parçaları) tarafından işlenir. + +## Gerçek zamanlı veri güncellemeleri {#real-time-data-updates} + +ClickHouse, birincil anahtarlı tabloları destekler. Birincil anahtar aralığındaki sorguları hızlı bir şekilde gerçekleştirmek için, veriler birleştirme ağacını kullanarak aşamalı olarak sıralanır. Bu nedenle, veriler sürekli olarak tabloya eklenebilir. Yeni veri Yutulduğunda hiçbir kilit alınır. + +## Dizin {#index} + +Birincil anahtara göre fiziksel olarak sıralanmış bir veriye sahip olmak, belirli değerleri veya değer aralıkları için düşük gecikme süresi ile birkaç düzine milisaniyeden daha az veri çıkarmayı mümkün kılar. + +## Çevrimiçi sorgular için uygundur {#suitable-for-online-queries} + +Düşük gecikme süresi, kullanıcı arayüzü sayfası yüklenirken, sorguların gecikmeden ve önceden bir cevap hazırlamaya çalışmadan işlenebileceği anlamına gelir. Başka bir deyişle, çevrimiçi. + +## Yaklaşık hesaplamalar için destek {#support-for-approximated-calculations} + +ClickHouse performans için doğruluk ticaret için çeşitli yollar sağlar: + +1. Farklı değerler, medyan ve quantiles sayısı yaklaşık hesaplama için toplam işlevleri. +2. Verilerin bir bölümünü (örnek) temel alan bir sorguyu çalıştırmak ve yaklaşık bir sonuç almak. Bu durumda, diskten orantılı olarak daha az veri alınır. +3. Tüm anahtarlar yerine, sınırlı sayıda rastgele anahtar için bir toplama çalıştırma. Verilerde anahtar dağıtımı için belirli koşullar altında, bu daha az kaynak kullanırken makul derecede doğru bir sonuç sağlar. + +## Veri çoğaltma ve Veri Bütünlüğü desteği {#data-replication-and-data-integrity-support} + +ClickHouse zaman uyumsuz çoklu ana çoğaltma kullanır. Kullanılabilir herhangi bir yineleme için yazıldıktan sonra kalan tüm yinelemeler arka planda kendi kopyasını almak. Sistem, farklı yinelemelerde aynı verileri korur. Çoğu arızadan sonra kurtarma, karmaşık durumlarda otomatik olarak veya yarı otomatik olarak gerçekleştirilir. + +Daha fazla bilgi için bölüme bakın [Veri çoğaltma](../engines/table_engines/mergetree_family/replication.md). + +## Dezavantajları olarak kabul edilebilir özellikler {#clickhouse-features-that-can-be-considered-disadvantages} + +1. Tam teşekküllü işlemler yok. +2. Yüksek oranda ve düşük gecikme ile zaten eklenen verileri değiştirme veya silme yeteneği eksikliği. Verileri temizlemek veya değiştirmek için toplu silme ve güncellemeler vardır, örneğin Aşağıdakilere uymak için [GDPR](https://gdpr-info.eu). +3. Seyrek dizin, Clickhouse'u anahtarlarıyla tek satırları almak için nokta sorguları için çok uygun değildir. + +[Orijinal makale](https://clickhouse.tech/docs/en/introduction/distinctive_features/) diff --git a/docs/tr/introduction/history.md b/docs/tr/introduction/history.md new file mode 100644 index 00000000000..cfc18df2981 --- /dev/null +++ b/docs/tr/introduction/history.md @@ -0,0 +1,56 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 7 +toc_title: "Tarih\xE7e" +--- + +# ClickHouse Geçmişi {#clickhouse-history} + +ClickHouse güç başlangıçta geliştirilmiştir [Üye.Metrica](https://metrica.yandex.com/), [dünyanın en büyük ikinci web analiz platformu](http://w3techs.com/technologies/overview/traffic_analysis/all) ve bu sistemin temel bileşeni olmaya devam ediyor. Veritabanında 13 trilyondan fazla kayıt ve günlük 20 milyardan fazla etkinlik ile ClickHouse, doğrudan toplanmamış verilerden anında özel raporlar oluşturmanıza olanak tanır. Bu makale Kısaca Clickhouse'un gelişiminin ilk aşamalarında hedeflerini kapsamaktadır. + +Üye.Metrica kullanıcı tarafından tanımlanan keyfi kesimleri ile, hit ve oturumları dayalı anında özelleştirilmiş raporlar oluşturur. Bunu sık sık yapmak, benzersiz kullanıcı sayısı gibi karmaşık agregalar oluşturmayı gerektirir. Bir rapor oluşturmak için yeni veriler gerçek zamanlı olarak gelir. + +Nisan 2014 itibariyle, Yandex.Metrica, günlük olarak yaklaşık 12 milyar olayı (sayfa görüntüleme ve tıklama) izliyordu. Tüm bu olaylar özel raporlar oluşturmak için saklanmalıdır. Tek bir sorgu, birkaç yüz milisaniye içinde milyonlarca satırı veya sadece birkaç saniye içinde yüz milyonlarca satırı taramayı gerektirebilir. + +## Yandex kullanımı.Metrica ve diğer Yandex Hizmetleri {#usage-in-yandex-metrica-and-other-yandex-services} + +ClickHouse, Yandex'te birden fazla amaca hizmet eder.Metrica. +Ana görevi, toplanmamış verileri kullanarak çevrimiçi modda raporlar oluşturmaktır. Veritabanında 20.3 trilyon satırdan fazla depolayan 374 sunucu kümesi kullanır. Sıkıştırılmış verilerin hacmi, yinelenenleri ve kopyaları hesaba katmadan yaklaşık 2 PB'DİR. Sıkıştırılmamış verilerin hacmi (TSV formatında) Yaklaşık 17 PB olacaktır. + +ClickHouse ayrıca aşağıdaki süreçlerde önemli bir rol oynar: + +- Yandex'den oturum tekrarı için veri saklama.Metrica. +- Ara veri işleme. +- Analitik ile küresel raporlar oluşturma. +- Yandex hata ayıklama için sorguları çalıştırma.Metrica motoru. +- API ve kullanıcı arayüzü günlükleri analiz. + +Günümüzde, diğer Yandex hizmetlerinde ve bölümlerinde birden fazla düzine ClickHouse kurulumu bulunmaktadır: arama dikey, e-ticaret, reklam, iş analitiği, mobil geliştirme, kişisel hizmetler ve diğerleri. + +## Toplanmış ve toplanmamış veriler {#aggregated-and-non-aggregated-data} + +İstatistikleri etkili bir şekilde hesaplamak için, veri hacmini azalttığından verileri toplamanız gerektiğine dair yaygın bir görüş vardır. + +Ancak veri toplama birçok sınırlama ile birlikte gelir: + +- Gerekli raporların önceden tanımlanmış bir listesine sahip olmanız gerekir. +- Kullanıcı özel raporlar yapamaz. +- Çok sayıda farklı anahtar üzerinde toplanırken, veri hacmi zorlukla azaltılır, bu nedenle toplama işe yaramaz. +- Çok sayıda rapor için çok fazla toplama varyasyonu vardır (kombinatoryal patlama). +- Anahtarları yüksek önemlilik (URL'ler gibi) ile toplarken, veri hacmi çok fazla azaltılmaz (iki kattan daha az). +- Bu nedenle, toplama ile veri hacmi küçültmek yerine büyüyebilir. +- Kullanıcılar onlar için oluşturduğumuz tüm raporları görüntülemez. Bu hesaplamaların büyük bir kısmı işe yaramaz. +- Verilerin mantıksal bütünlüğü, çeşitli toplamalar için ihlal edilebilir. + +Hiçbir şeyi toplamazsak ve toplanmamış verilerle çalışırsak, bu hesaplamaların hacmini azaltabilir. + +Bununla birlikte, toplama ile, çalışmanın önemli bir kısmı çevrimdışı olarak alınır ve nispeten sakin bir şekilde tamamlanır. Buna karşılık, çevrimiçi hesaplamalar, kullanıcı sonucu beklediğinden mümkün olduğunca hızlı hesaplamayı gerektirir. + +Üye.Metrica, raporların çoğunluğu için kullanılan Metrage adı verilen verileri toplamak için özel bir sisteme sahiptir. +2009'dan itibaren Yandex.Metrica, daha önce Rapor Oluşturucusu için kullanılan OLAPServer adlı toplanmamış veriler için özel bir OLAP veritabanı da kullandı. +OLAPServer, toplanmamış veriler için iyi çalıştı, ancak tüm raporlar için istenildiği gibi kullanılmasına izin vermeyen birçok kısıtlamaya sahipti. Bunlar, veri türleri için destek eksikliği (yalnızca sayılar) ve verileri gerçek zamanlı olarak aşamalı olarak güncelleyememe (yalnızca verileri günlük olarak yeniden yazarak yapılabilir) içeriyordu. OLAPServer bir DBMS değil, özel bir dB'dir. + +ClickHouse için ilk hedef OLAPServer sınırlamaları kaldırmak ve tüm raporlar için toplanmamış verilerle çalışma sorunu çözmek oldu, ama yıllar içinde, analitik görevler geniş bir yelpazede için uygun bir genel amaçlı veritabanı yönetim sistemi haline gelmiştir. + +[Orijinal makale](https://clickhouse.tech/docs/en/introduction/history/) diff --git a/docs/tr/introduction/index.md b/docs/tr/introduction/index.md new file mode 100644 index 00000000000..9691671aefa --- /dev/null +++ b/docs/tr/introduction/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "Giri\u015F" +toc_priority: 1 +--- + + diff --git a/docs/tr/introduction/performance.md b/docs/tr/introduction/performance.md new file mode 100644 index 00000000000..c07614ba71e --- /dev/null +++ b/docs/tr/introduction/performance.md @@ -0,0 +1,32 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 6 +toc_title: Performans +--- + +# Performans {#performance} + +Yandex'deki dahili test sonuçlarına göre, ClickHouse, test için mevcut olan sınıfının sistemleri arasında karşılaştırılabilir işletim senaryoları için en iyi performansı (hem uzun sorgular için en yüksek verim hem de kısa sorgularda en düşük gecikme süresi) gösterir. Test sonuçlarını bir [ayrı sayfa](https://clickhouse.tech/benchmark.html). + +Çok sayıda bağımsız kriterler benzer sonuçlara geldi. Bir internet araması kullanarak bulmak zor değildir veya görebilirsiniz [ilgili bağlantı ourlardan oluşan küçük koleksiyon collectionumuz](https://clickhouse.tech/#independent-benchmarks). + +## Tek bir büyük sorgu için çıktı {#throughput-for-a-single-large-query} + +Verim, saniyede satır veya saniyede megabayt olarak ölçülebilir. Veriler sayfa önbelleğine yerleştirilirse, çok karmaşık olmayan bir sorgu, modern donanım üzerinde tek bir sunucuda yaklaşık 2-10 GB/s sıkıştırılmamış veri hızında işlenir (en basit durumlar için, hız 30 GB/s'ye ulaşabilir). Veri sayfa önbelleğine yerleştirilmezse, hız disk alt sistemine ve veri sıkıştırma hızına bağlıdır. Örneğin, disk alt sistemi 400 MB/s veri okuma izin verir ve veri sıkıştırma hızı 3 ise, hız 1.2 GB / s civarında olması bekleniyor. saniyede satır hızı elde etmek için hızı saniyede bayt cinsinden sorguda kullanılan sütunların toplam boyutuna bölün. Örneğin, 10 bayt sütun ayıklanırsa, hızın saniyede yaklaşık 100-200 milyon satır olması beklenir. + +İşlem hızı, dağıtılmış işlem için neredeyse doğrusal olarak artar, ancak yalnızca toplama veya sıralamadan kaynaklanan satır sayısı çok büyük değilse. + +## Kısa Sorguları İşlerken Gecikme Süresi {#latency-when-processing-short-queries} + +Bir sorgu birincil anahtar kullanır ve çok fazla sütun ve satır (yüzbinlerce) işlemek için seçmez, veri sayfa önbelleğine yerleştirilirse, 50 milisaniyeden daha az gecikme süresi (en iyi durumda milisaniye tek basamak) bekleyebilirsiniz. Aksi takdirde, gecikme çoğunlukla arama sayısı tarafından hakimdir. Aşırı yüklenmemiş bir sistem için dönen disk sürücüleri kullanırsanız, gecikme bu formülle tahmin edilebilir: `seek time (10 ms) * count of columns queried * count of data parts`. + +## Büyük miktarda kısa sorgu işlerken verim {#throughput-when-processing-a-large-quantity-of-short-queries} + +Aynı koşullar altında, ClickHouse tek bir sunucuda saniyede birkaç yüz sorgu işleyebilir (en iyi durumda birkaç bine kadar). Bu senaryo analitik DBMSs için tipik olmadığından, saniyede en fazla 100 sorgu beklemenizi öneririz. + +## Veri Eklerken Performans {#performance-when-inserting-data} + +Verileri en az 1000 satırlık paketlere veya saniyede tek bir istekten daha fazla olmayan paketlere eklemenizi öneririz. Sekmeyle ayrılmış bir dökümden MergeTree tablosuna eklerken, ekleme hızı 50 ila 200 MB/s arasında olabilir. eklenen satırlar yaklaşık 1 Kb boyutundaysa, hız saniyede 50.000 ila 200.000 satır olacaktır. Satırlar küçükse, performans saniyede satırlarda daha yüksek olabilir (Banner sistem verileri üzerinde -`>` Saniyede 500 rows.000 satır; Graf ;it ver ;ilerinde -`>` Saniyede 1.000.000 satır). Performansı artırmak için, paralel olarak doğrusal olarak ölçeklenen birden çok ekleme sorgusu yapabilirsiniz. + +[Orijinal makale](https://clickhouse.tech/docs/en/introduction/performance/) diff --git a/docs/tr/operations/access_rights.md b/docs/tr/operations/access_rights.md new file mode 100644 index 00000000000..b270c0ecbed --- /dev/null +++ b/docs/tr/operations/access_rights.md @@ -0,0 +1,113 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 48 +toc_title: "Eri\u015Fim Haklar\u0131" +--- + +# Erişim Hakları {#access-rights} + +Kullanıcılar ve erişim hakları kullanıcı yapılandırmasında ayarlanır. Bu genellikle `users.xml`. + +Kullanıcılar kaydedilir `users` bölme. İşte bir parçası `users.xml` Dosya: + +``` xml + + + + + + + + + + + + default + + + default + + + + + + + web + default + + test + + + test + + + +``` + +İki kullanıcıdan bir bildirim görebilirsiniz: `default`ve`web`. Ek weledik `web` kullanıcı ayrı ayrı. + +Bu `default` kullanıcı adı geçilmez durumlarda kullanıcı seçilir. Bu `default` kullanıcı, sunucu veya kümenin yapılandırması, sunucu veya kümenin yapılandırılmasını belirtmezse, dağıtılmış sorgu işleme için de kullanılır. `user` ve `password` (on bölümüne bakın [Dağılı](../engines/table_engines/special/distributed.md) motor). + +The user that is used for exchanging information between servers combined in a cluster must not have substantial restrictions or quotas – otherwise, distributed queries will fail. + +Parola, açık metin (önerilmez) veya SHA-256'da belirtilir. Haşhaş tuzlu değil. Bu bağlamda, bu şifreleri potansiyel kötü amaçlı saldırılara karşı güvenlik sağlamak olarak düşünmemelisiniz. Aksine, çalışanlardan korunmak için gereklidir. + +Erişime izin verilen ağların listesi belirtilir. Bu örnekte, her iki kullanıcı için ağ listesi ayrı bir dosyadan yüklenir (`/etc/metrika.xml`) içeren `networks` ikame. İşte bunun bir parçası: + +``` xml + + ... + + ::/64 + 203.0.113.0/24 + 2001:DB8::/32 + ... + + +``` + +Bu ağ listesini doğrudan tanımlayabilirsiniz `users.xml` veya bir dosyada `users.d` dizin (daha fazla bilgi için bölüme bakın “[Yapılandırma dosyaları](configuration_files.md#configuration_files)”). + +Yapılandırma, her yerden erişimin nasıl açılacağını açıklayan yorumları içerir. + +Üretimde kullanım için, sadece belirtin `ip` elemanları (IP adresleri ve maskeleri), kullanıl ,dığından beri `host` ve `hoost_regexp` ekstra gecikmeye neden olabilir. + +Daha sonra kullanıcı ayarları profili belirtilir (bölüme bakın “[Ayarlar profilleri](settings/settings_profiles.md)”. Varsayılan profili belirtebilirsiniz, `default'`. Profilin herhangi bir adı olabilir. Farklı kullanıcılar için aynı profili belirtebilirsiniz. Ayarlar profilinde yazabileceğiniz en önemli şey `readonly=1` sağlar okumak-sadece erişim. Ardından kullanılacak kotayı belirtin (bölüme bakın “[Kotalar](quotas.md#quotas)”). Varsayılan kotayı belirtebilirsiniz: `default`. It is set in the config by default to only count resource usage, without restricting it. The quota can have any name. You can specify the same quota for different users – in this case, resource usage is calculated for each user individually. + +İsteğe bağlı `` bölümünde, kullanıcının erişebileceği veritabanlarının bir listesini de belirtebilirsiniz. Varsayılan olarak, tüm veritabanları kullanıcı tarafından kullanılabilir. Belirtebilirsiniz `default` veritabanı. Bu durumda, kullanıcı varsayılan olarak veritabanına erişim alır. + +İsteğe bağlı `` bölümünde, kullanıcının erişebileceği sözlüklerin bir listesini de belirtebilirsiniz. Varsayılan olarak, tüm sözlükler kullanıcı tarafından kullanılabilir. + +Erişim `system` veritabanı her zaman izin verilir (bu veritabanı sorguları işlemek için kullanıldığından). + +Kullanıcı kullanarak onları tüm veritabanları ve tabloların bir listesini alabilirsiniz `SHOW` tek tek veritabanlarına erişime izin verilmese bile, sorgular veya sistem tabloları. + +Veritabanı erişimi ile ilgili değildir [readonly](settings/permissions_for_queries.md#settings_readonly) ayar. Bir veritabanına tam erişim izni veremezsiniz ve `readonly` başka birine erişim. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/access_rights/) diff --git a/docs/tr/operations/backup.md b/docs/tr/operations/backup.md new file mode 100644 index 00000000000..5d1d806e5dd --- /dev/null +++ b/docs/tr/operations/backup.md @@ -0,0 +1,41 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 49 +toc_title: Veri Yedekleme +--- + +# Veri Yedekleme {#data-backup} + +Karşın [çoğalma](../engines/table_engines/mergetree_family/replication.md) provides protection from hardware failures, it does not protect against human errors: accidental deletion of data, deletion of the wrong table or a table on the wrong cluster, and software bugs that result in incorrect data processing or data corruption. In many cases mistakes like these will affect all replicas. ClickHouse has built-in safeguards to prevent some types of mistakes — for example, by default [50 GB'den fazla veri içeren MergeTree benzeri bir motorla tabloları bırakamazsınız](https://github.com/ClickHouse/ClickHouse/blob/v18.14.18-stable/programs/server/config.xml#L322-L330). Ancak, bu önlemler olası tüm davaları kapsamaz ve atlatılabilir. + +Olası insan hatalarını etkili bir şekilde azaltmak için, verilerinizi yedeklemek ve geri yüklemek için dikkatli bir şekilde bir strateji hazırlamanız gerekir **önceden**. + +Her şirketin farklı kaynakları ve iş gereksinimleri vardır, bu nedenle her duruma uyacak ClickHouse yedeklemeleri ve geri yüklemeleri için evrensel bir çözüm yoktur. Bir gigabayt veri için ne işe yarar, muhtemelen onlarca petabayt için çalışmaz. Aşağıda tartışılacak olan kendi artıları ve eksileri ile çeşitli Olası yaklaşımlar vardır. Çeşitli eksikliklerini telafi etmek için sadece bir tane yerine birkaç yaklaşım kullanmak iyi bir fikirdir. + +!!! note "Not" + Bir şeyi yedeklediyseniz ve geri yüklemeyi hiç denemediyseniz, aslında ihtiyacınız olduğunda Geri Yüklemenin düzgün çalışmayacağını (veya en azından işin tahammül edebileceğinden daha uzun süreceğini) unutmayın. Bu nedenle, seçtiğiniz yedekleme yaklaşımı ne olursa olsun, geri yükleme işlemini de otomatikleştirdiğinizden emin olun ve düzenli olarak yedek bir ClickHouse kümesinde uygulayın. + +## Kaynak Verileri Başka Bir Yerde Çoğaltma {#duplicating-source-data-somewhere-else} + +Genellikle Clickhouse'a alınan veriler, aşağıdaki gibi bir tür kalıcı sıra yoluyla teslim edilir [Apache Kafka](https://kafka.apache.org). Bu durumda, Clickhouse'a yazılırken aynı veri akışını okuyacak ve bir yerde soğuk depoda depolayacak ek bir abone kümesi yapılandırmak mümkündür. Çoğu şirket zaten bir nesne deposu veya dağıtılmış bir dosya sistemi gibi olabilecek bazı varsayılan önerilen soğuk depolamaya sahiptir [HDFS](https://hadoop.apache.org/docs/stable/hadoop-project-dist/hadoop-hdfs/HdfsDesign.html). + +## Dosya Sistemi Anlık Görüntüleri {#filesystem-snapshots} + +Bazı yerel dosya sistemleri anlık görüntü işlevselliği sağlar (örneğin, [ZFS](https://en.wikipedia.org/wiki/ZFS)), ancak canlı sorguları sunmak için en iyi seçenek olmayabilir. Olası bir çözüm, bu tür dosya sistemi ile ek kopyalar oluşturmak ve bunları [Dağılı](../engines/table_engines/special/distributed.md) için kullanılan tablolar `SELECT` sorgular. Bu tür yinelemelerdeki anlık görüntüler, verileri değiştiren sorguların erişemeyeceği bir yerde olacaktır. Bonus olarak, bu yinelemeler, sunucu başına daha fazla disk eklenmiş özel donanım yapılandırmalarına sahip olabilir ve bu da uygun maliyetli olabilir. + +## clickhouse-fotokopi makinesi {#clickhouse-copier} + +[clickhouse-fotokopi makinesi](utilities/clickhouse-copier.md) başlangıçta yeniden shard petabyte boyutlu tablolar için oluşturulan çok yönlü bir araçtır. Ayrıca yedekleme için kullanılan ve güvenilir clickhouse tablolar ve kümeler arasında veri kopyalar çünkü amaçlar geri olabilir. + +Daha küçük veri hacimleri için, basit bir `INSERT INTO ... SELECT ...` uzak tablolara da çalışabilir. + +## Parçalar ile manipülasyonlar {#manipulations-with-parts} + +ClickHouse kullanarak sağlar `ALTER TABLE ... FREEZE PARTITION ...` tablo bölümleri yerel bir kopyasını oluşturmak için sorgu. Bu hardlinks kullanarak uygulanır `/var/lib/clickhouse/shadow/` klasör, bu yüzden genellikle eski veriler için ekstra disk alanı tüketmez. Oluşturulan dosyaların kopyaları ClickHouse server tarafından işlenmez, bu yüzden onları orada bırakabilirsiniz: herhangi bir ek harici sistem gerektirmeyen basit bir yedeklemeniz olacak, ancak yine de donanım sorunlarına eğilimli olacaktır. Bu nedenle, bunları uzaktan başka bir konuma kopyalamak ve ardından yerel kopyaları kaldırmak daha iyidir. Dağıtılmış dosya sistemleri ve nesne depoları bunun için hala iyi bir seçenektir, ancak yeterince büyük kapasiteye sahip normal ekli dosya sunucuları da işe yarayabilir (bu durumda aktarım ağ dosya sistemi veya belki de [rsync](https://en.wikipedia.org/wiki/Rsync)). + +Bölüm işlemleriyle ilgili sorgular hakkında daha fazla bilgi için bkz. [ALTER belgeleri](../sql_reference/statements/alter.md#alter_manipulations-with-partitions). + +Bu yaklaşımı otomatikleştirmek için üçüncü taraf bir araç kullanılabilir: [clickhouse-yedekleme](https://github.com/AlexAkulov/clickhouse-backup). + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/backup/) diff --git a/docs/tr/operations/configuration_files.md b/docs/tr/operations/configuration_files.md new file mode 100644 index 00000000000..fda72e6ba21 --- /dev/null +++ b/docs/tr/operations/configuration_files.md @@ -0,0 +1,57 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 50 +toc_title: "Yap\u0131land\u0131rma Dosyalar\u0131" +--- + +# Yapılandırma Dosyaları {#configuration_files} + +ClickHouse Çoklu dosya yapılandırma yönetimini destekler. Ana sunucu yapılandırma dosyası `/etc/clickhouse-server/config.xml`. Diğer dosyalar içinde olmalıdır `/etc/clickhouse-server/config.d` dizin. + +!!! note "Not" + Tüm yapılandırma dosyaları XML biçiminde olmalıdır. Ayrıca, genellikle aynı kök öğeye sahip olmalıdırlar ``. + +Ana yapılandırma dosyasında belirtilen bazı ayarlar diğer yapılandırma dosyalarında geçersiz kılınabilir. Bu `replace` veya `remove` bu yapılandırma dosyalarının öğeleri için öznitelikler belirtilebilir. + +Her ikisi de belirtilmezse, yinelenen çocukların değerlerini değiştirerek öğelerin içeriğini yinelemeli olarak birleştirir. + +Eğer `replace` belirtilen, tüm öğeyi belirtilen ile değiştirir. + +Eğer `remove` belirt .ilirse, öğeyi siler. + +Yapılandırma ayrıca tanımlayabilir “substitutions”. Bir öğe varsa `incl` öznitelik, dosyadan karşılık gelen ikame değeri olarak kullanılacaktır. Varsayılan olarak, değiştirmeler ile dosyanın yolu `/etc/metrika.xml`. Bu değiştirilebilir [include\_from](server_configuration_parameters/settings.md#server_configuration_parameters-include_from) sunucu yapılandırmasında öğe. İkame değerleri belirtilen `/yandex/substitution_name` bu dosyadaki öğeler. Belirtilen bir ika Ame halinde `incl` yok, günlüğe kaydedilir. Clickhouse'un eksik değiştirmelerin günlüğe kaydedilmesini önlemek için `optional="true"` öznitelik (örneğin, ayarlar [makrolar](server_configuration_parameters/settings.md)). + +İkame da ZooKeeper yapılabilir. Bunu yapmak için özniteliği belirtin `from_zk = "/path/to/node"`. Eleman değeri, düğümün içeriği ile değiştirilir `/path/to/node` ZooKeeper. Ayrıca ZooKeeper düğümünde bir XML alt ağacının tamamını koyabilirsiniz ve kaynak öğeye tamamen eklenecektir. + +Bu `config.xml` dosya kullanıcı ayarları, profiller ve kotalar ile ayrı bir yapılandırma belirtebilirsiniz. Bu yapılandırmanın göreli yolu, `users_config` öğe. Varsayılan olarak, bu `users.xml`. Eğer `users_config` atlanır, kullanıcı ayarları, profiller ve kotalar doğrudan belirtilir `config.xml`. + +Kullanıcılar yapılandırma benzer ayrı dosyaları içine bölünmüş olabilir `config.xml` ve `config.d/`. +Dizin adı olarak tanımlanır `users_config` olmadan ayarı `.xml` postfix ile birleştirilmiş `.d`. +Dizin `users.d` varsayılan olarak kullanılır, gibi `users_config` varsayılan olarak `users.xml`. +Örneğin, bu gibi her kullanıcı için ayrı yapılandırma dosyasına sahip olabilirsiniz: + +``` bash +$ cat /etc/clickhouse-server/users.d/alice.xml +``` + +``` xml + + + + analytics + + ::/0 + + ... + analytics + + + +``` + +Her yapılandırma dosyası için sunucu da üretir `file-preprocessed.xml` başlatırken dosyalar. Bu dosyalar, tamamlanmış tüm değiştirmeleri ve geçersiz kılmaları içerir ve bunlar bilgi amaçlı kullanım içindir. Zookeeper değiştirmelerin yapılandırma dosyalarında kullanılan ancak ZooKeeper sunucu başlangıcında kullanılabilir değilse, sunucu yapılandırmayı önceden işlenmiş dosyadan yükler. + +Sunucu, yapılandırma dosyalarındaki değişikliklerin yanı sıra, değiştirmeleri ve geçersiz kılmaları gerçekleştirirken kullanılan dosya ve ZooKeeper düğümlerini izler ve anında kullanıcılar ve kümeler için ayarları yeniden yükler. Bu, sunucuyu yeniden başlatmadan kümeyi, kullanıcıları ve ayarlarını değiştirebileceğiniz anlamına gelir. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/configuration_files/) diff --git a/docs/tr/operations/index.md b/docs/tr/operations/index.md new file mode 100644 index 00000000000..e20eefc1ab0 --- /dev/null +++ b/docs/tr/operations/index.md @@ -0,0 +1,28 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: Harekat +toc_priority: 41 +toc_title: "Giri\u015F" +--- + +# Harekat {#operations} + +ClickHouse işlemleri kılavuzu aşağıdaki ana bölümlerden oluşur: + +- [Gereksinimler](requirements.md) +- [İzleme](monitoring.md) +- [Arıza](troubleshooting.md) +- [Kullanım Önerileri](tips.md) +- [Güncelleme Prosedürü](update.md) +- [Erişim Hakları](access_rights.md) +- [Veri Yedekleme](backup.md) +- [Yapılandırma Dosyaları](configuration_files.md) +- [Kotalar](quotas.md) +- [Sistem Tabloları](system_tables.md) +- [Sunucu Yapılandırma Parametreleri](server_configuration_parameters/index.md) +- [Donanımınızı ClickHouse İle Test Etme](performance_test.md) +- [Ayarlar](settings/index.md) +- [Programlar](utilities/index.md) + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/) diff --git a/docs/tr/operations/monitoring.md b/docs/tr/operations/monitoring.md new file mode 100644 index 00000000000..eb5b7bd6dc8 --- /dev/null +++ b/docs/tr/operations/monitoring.md @@ -0,0 +1,46 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 45 +toc_title: "\u0130zleme" +--- + +# İzleme {#monitoring} + +İzleyebilirsiniz: + +- Donanım kaynaklarının kullanımı. +- ClickHouse sunucu metrikleri. + +## Kaynak Kullanımı {#resource-utilization} + +ClickHouse, donanım kaynaklarının durumunu tek başına izlemez. + +İzleme ayarlamak için önerilir : + +- İşlemcilerde yük ve sıcaklık. + + Kullanabilirsiniz [dmesg](https://en.wikipedia.org/wiki/Dmesg), [turbostat](https://www.linux.org/docs/man8/turbostat.html) ya da diğer aletler. + +- Depolama sistemi, RAM ve ağ kullanımı. + +## ClickHouse Sunucu Metrikleri {#clickhouse-server-metrics} + +ClickHouse sunucu kendini devlet izleme için araçlar gömülü vardır. + +Sunucu olaylarını izlemek için sunucu günlüklerini kullanın. Görmek [kaydedici](server_configuration_parameters/settings.md#server_configuration_parameters-logger) yapılandırma dosyasının bölümü. + +ClickHouse toplar: + +- Sunucunun hesaplama kaynaklarını nasıl kullandığına dair farklı metrikler. +- Sorgu işleme ile ilgili ortak istatistikler. + +Metrikleri şu adreste bulabilirsiniz: [sistem.metrik](../operations/system_tables.md#system_tables-metrics), [sistem.etkinlik](../operations/system_tables.md#system_tables-events), ve [sistem.asynchronous\_metrics](../operations/system_tables.md#system_tables-asynchronous_metrics) Tablolar. + +Clickhouse'u metrikleri dışa aktaracak şekilde yapılandırabilirsiniz [Grafit](https://github.com/graphite-project). Görmek [Graf sectionit bölümü](server_configuration_parameters/settings.md#server_configuration_parameters-graphite) ClickHouse sunucu yapılandırma dosyasında. Metriklerin dışa aktarımını yapılandırmadan önce, grafit'i resmi olarak takip ederek ayarlamanız gerekir [kılavuz](https://graphite.readthedocs.io/en/latest/install.html). + +Clickhouse'u metrikleri dışa aktaracak şekilde yapılandırabilirsiniz [Prometheus](https://prometheus.io). Görmek [Prometheus bölümü](server_configuration_parameters/settings.md#server_configuration_parameters-prometheus) ClickHouse sunucu yapılandırma dosyasında. Metriklerin dışa aktarılmasını yapılandırmadan önce, prometheus'u yetkililerini takip ederek ayarlamanız gerekir [kılavuz](https://prometheus.io/docs/prometheus/latest/installation/). + +Ayrıca, http API aracılığıyla sunucu kullanılabilirliğini izleyebilirsiniz. Sen sendd the `HTTP GET` istek için `/ping`. Sunucu mevcutsa, yanıt verir `200 OK`. + +Bir küme yapılandırmasındaki sunucuları izlemek için [max\_replica\_delay\_for\_distributed\_queries](settings/settings.md#settings-max_replica_delay_for_distributed_queries) parametre ve HTTP kaynağını kullanın `/replicas_status`. Bir istek için `/replicas_status` dönüşler `200 OK` çoğaltma kullanılabilir ve diğer yinelemeler gecikmiş değil. Bir çoğaltma gecikirse, döndürür `503 HTTP_SERVICE_UNAVAILABLE` boşluk hakkında bilgi ile. diff --git a/docs/tr/operations/optimizing_performance/index.md b/docs/tr/operations/optimizing_performance/index.md new file mode 100644 index 00000000000..9d39c082a98 --- /dev/null +++ b/docs/tr/operations/optimizing_performance/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "Performans\u0131 Optimize Etme" +toc_priority: 52 +--- + + diff --git a/docs/tr/operations/optimizing_performance/sampling_query_profiler.md b/docs/tr/operations/optimizing_performance/sampling_query_profiler.md new file mode 100644 index 00000000000..0d86dfad5ef --- /dev/null +++ b/docs/tr/operations/optimizing_performance/sampling_query_profiler.md @@ -0,0 +1,64 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 54 +toc_title: "Sorgu Profili Olu\u015Fturma" +--- + +# Örnekleme Sorgusu Profiler {#sampling-query-profiler} + +ClickHouse, sorgu yürütülmesini analiz etmeyi sağlayan örnekleme profiler'i çalıştırır. Profiler kullanarak sorgu yürütme sırasında en sık kullanılan kaynak kodu yordamları bulabilirsiniz. Boşta kalma süresi de dahil olmak üzere harcanan CPU zamanını ve duvar saati zamanını izleyebilirsiniz. + +Profiler kullanmak için: + +- Kurulum [trace\_log](../server_configuration_parameters/settings.md#server_configuration_parameters-trace_log) sunucu yapılandırması bölümü. + + Bu bölüm yapılandırır [trace\_log](../../operations/system_tables.md#system_tables-trace_log) profiler işleyişinin sonuçlarını içeren sistem tablosu. Varsayılan olarak yapılandırılmıştır. Bu tablodaki verilerin yalnızca çalışan bir sunucu için geçerli olduğunu unutmayın. Sunucu yeniden başlatıldıktan sonra ClickHouse tabloyu temizlemez ve depolanan tüm sanal bellek adresi geçersiz hale gelebilir. + +- Kurulum [query\_profiler\_cpu\_time\_period\_ns](../settings/settings.md#query_profiler_cpu_time_period_ns) veya [query\_profiler\_real\_time\_period\_ns](../settings/settings.md#query_profiler_real_time_period_ns) ayarlar. Her iki ayar da aynı anda kullanılabilir. + + Bu ayarlar, profiler zamanlayıcılarını yapılandırmanıza izin verir. Bunlar oturum ayarları olduğundan, tüm sunucu, bireysel kullanıcılar veya kullanıcı profilleri, etkileşimli oturumunuz ve her bir sorgu için farklı örnekleme sıklığı elde edebilirsiniz. + +Varsayılan örnekleme frekansı saniyede bir örnektir ve hem CPU hem de gerçek zamanlayıcılar etkindir. Bu frekans, ClickHouse kümesi hakkında yeterli bilgi toplamaya izin verir. Aynı zamanda, bu sıklıkla çalışan profiler, ClickHouse sunucusunun performansını etkilemez. Her bir sorguyu profillemeniz gerekiyorsa, daha yüksek örnekleme frekansı kullanmayı deneyin. + +Analiz etmek `trace_log` sistem tablosu: + +- Yüklemek `clickhouse-common-static-dbg` paket. Görmek [DEB paketlerinden yükleyin](../../getting_started/install.md#install-from-deb-packages). + +- Tarafından iç gözlem işlevlerine izin ver [allow\_introspection\_functions](../settings/settings.md#settings-allow_introspection_functions) ayar. + + Güvenlik nedenleriyle, iç gözlem işlevleri varsayılan olarak devre dışı bırakılır. + +- Kullan... `addressToLine`, `addressToSymbol` ve `demangle` [iç gözlem fonksiyonları](../../sql_reference/functions/introspection.md) ClickHouse kodu işlev adları ve konumlarını almak için. Bazı sorgu için bir profil almak için, `trace_log` Tablo. Bireysel fonksiyonları bütün yığın izleri ya da veri toplama yapabilirsiniz. + +Görselleştirmeniz gerekiyorsa `trace_log` bilgi, deneyin [flamegraph](../../interfaces/third-party/gui/#clickhouse-flamegraph) ve [speedscope](https://github.com/laplab/clickhouse-speedscope). + +## Örnek {#example} + +Bu örnekte biz: + +- Filtre `trace_log` bir sorgu tanımlayıcısı ve geçerli tarihe göre veri. + +- Yığın izleme ile toplama. + +- İç gözlem işlevlerini kullanarak, bir rapor alacağız: + + - Sembollerin isimleri ve karşılık gelen kaynak kodu işlevleri. + - Bu işlevlerin kaynak kodu konumları. + + + +``` sql +SELECT + count(), + arrayStringConcat(arrayMap(x -> concat(demangle(addressToSymbol(x)), '\n ', addressToLine(x)), trace), '\n') AS sym +FROM system.trace_log +WHERE (query_id = 'ebca3574-ad0a-400a-9cbc-dca382f5998c') AND (event_date = today()) +GROUP BY trace +ORDER BY count() DESC +LIMIT 10 +``` + +``` text +{% include "operations/performance/sampling_query_profiler_example_result.txt" %} +``` diff --git a/docs/tr/operations/performance/sampling_query_profiler_example_result.txt b/docs/tr/operations/performance/sampling_query_profiler_example_result.txt new file mode 120000 index 00000000000..58c5abe7122 --- /dev/null +++ b/docs/tr/operations/performance/sampling_query_profiler_example_result.txt @@ -0,0 +1 @@ +../../../en/operations/performance/sampling_query_profiler_example_result.txt \ No newline at end of file diff --git a/docs/tr/operations/performance_test.md b/docs/tr/operations/performance_test.md new file mode 100644 index 00000000000..dbfbc39998d --- /dev/null +++ b/docs/tr/operations/performance_test.md @@ -0,0 +1,82 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 54 +toc_title: "Donan\u0131m Test" +--- + +# Donanımınızı ClickHouse ile Test etme {#how-to-test-your-hardware-with-clickhouse} + +Bu talimat ile ClickHouse paketlerinin kurulumu olmadan herhangi bir sunucuda temel ClickHouse performans testi çalıştırabilirsiniz. + +1. Gitmek “commits” sayfa: https://github.com/ClickHouse/ClickHouse/commits/master + +2. Yeşil ile ilk yeşil onay işareti veya kırmızı Haç tıklayın “ClickHouse Build Check” ve tıklayın “Details” link yakın “ClickHouse Build Check”. Bazı taahhütlerde böyle bir bağlantı yoktur, örneğin belgelerle taahhüt eder. Bu durumda, bu bağlantıya sahip en yakın taahhüt seçin. + +3. Bağlantıyı kopyala “clickhouse” amd64 veya aarch64 için ikili. + +4. sunucuya ssh ve wget ile indirin: + + + + # For amd64: + wget https://clickhouse-builds.s3.yandex.net/0/00ba767f5d2a929394ea3be193b1f79074a1c4bc/1578163263_binary/clickhouse + # For aarch64: + wget https://clickhouse-builds.s3.yandex.net/0/00ba767f5d2a929394ea3be193b1f79074a1c4bc/1578161264_binary/clickhouse + # Then do: + chmod a+x clickhouse + +1. İndir yapılandırmaları: + + + + wget https://raw.githubusercontent.com/ClickHouse/ClickHouse/master/programs/server/config.xml + wget https://raw.githubusercontent.com/ClickHouse/ClickHouse/master/programs/server/users.xml + mkdir config.d + wget https://raw.githubusercontent.com/ClickHouse/ClickHouse/master/programs/server/config.d/path.xml -O config.d/path.xml + wget https://raw.githubusercontent.com/ClickHouse/ClickHouse/master/programs/server/config.d/log_to_console.xml -O config.d/log_to_console.xml + +1. Ben benchmarkch filesmark dosyaları indir: + + + + wget https://raw.githubusercontent.com/ClickHouse/ClickHouse/master/benchmark/clickhouse/benchmark-new.sh + chmod a+x benchmark-new.sh + wget https://raw.githubusercontent.com/ClickHouse/ClickHouse/master/benchmark/clickhouse/queries.sql + +1. İndir göre test verileri [Üye.Metrica veri kümesi](../getting_started/example_datasets/metrica.md) talimat (“hits” 100 milyon satır içeren tablo). + + + + wget https://clickhouse-datasets.s3.yandex.net/hits/partitions/hits_100m_obfuscated_v1.tar.xz + tar xvf hits_100m_obfuscated_v1.tar.xz -C . + mv hits_100m_obfuscated_v1/* . + +1. Sunucuyu Çalıştır: + + + + ./clickhouse server + +1. Verileri kontrol edin: başka bir terminaldeki sunucuya ssh + + + + ./clickhouse client --query "SELECT count() FROM hits_100m_obfuscated" + 100000000 + +1. Edit the benchmark-new.sh, değişim `clickhouse-client` -e doğru `./clickhouse client` ve Ekle `–-max_memory_usage 100000000000` parametre. + + + + mcedit benchmark-new.sh + +1. Ben benchmarkch runmark Çalıştır: + + + + ./benchmark-new.sh hits_100m_obfuscated + +1. Donanım yapılandırmanız hakkındaki numaraları ve bilgileri şu adrese gönderin clickhouse-feedback@yandex-team.com + +Tüm sonuçlar burada yayınlanmaktadır: https://clickhouse.teknoloji / benchmark\_hardware.html diff --git a/docs/tr/operations/quotas.md b/docs/tr/operations/quotas.md new file mode 100644 index 00000000000..e6b1de2b7f8 --- /dev/null +++ b/docs/tr/operations/quotas.md @@ -0,0 +1,112 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 51 +toc_title: Kotalar +--- + +# Kotalar {#quotas} + +Kotalar, belirli bir süre boyunca kaynak kullanımını sınırlamanıza veya kaynak kullanımını izlemenize izin verir. +Kotalar genellikle kullanıcı yapılandırmasında ayarlanır ‘users.xml’. + +Sistem ayrıca tek bir sorgunun karmaşıklığını sınırlamak için bir özelliğe sahiptir. Bölümüne bakınız “Restrictions on query complexity”). + +Sorgu karmaşıklığı kısıtlamalarının aksine, kotalar: + +- Tek bir sorguyu sınırlamak yerine, belirli bir süre boyunca çalıştırılabilen sorgu kümesine kısıtlamalar yerleştirin. +- Dağıtılmış sorgu işleme için tüm uzak sunucularda harcanan kaynaklar için hesap. + +Bölümüne bakalım ‘users.xml’ kotaları tanımlayan dosya. + +``` xml + + + + + + + + 3600 + + + 0 + 0 + 0 + 0 + 0 + + +``` + +Varsayılan olarak, kota, kullanımı sınırlamadan her saat için kaynak tüketimini izler. +Her aralık için hesaplanan kaynak tüketimi, her istekten sonra sunucu günlüğüne çıktıdır. + +``` xml + + + + + 3600 + + 1000 + 100 + 1000000000 + 100000000000 + 900 + + + + 86400 + + 10000 + 1000 + 5000000000 + 500000000000 + 7200 + + +``` + +İçin ‘statbox’ kota, kısıtlamalar her saat ve her 24 saat (86.400 saniye) için ayarlanır. Aralık saydım, bir uygulama başlangıç zamanı tamir anda tanımlanmış. Başka bir deyişle, 24 saatlik Aralık mutlaka gece yarısı başlamaz. + +Aralık sona erdiğinde, toplanan tüm değerler temizlenir. Bir sonraki saat için kota Hesaplaması başlar. + +İşte kısıt amountslan theabilecek miktar amountslar: + +`queries` – The total number of requests. + +`errors` – The number of queries that threw an exception. + +`result_rows` – The total number of rows given as a result. + +`read_rows` – The total number of source rows read from tables for running the query on all remote servers. + +`execution_time` – The total query execution time, in seconds (wall time). + +En az bir zaman aralığı için sınır aşılırsa, hangi kısıtlamanın aşıldığı, hangi aralık için ve yeni Aralık başladığında (sorgular yeniden gönderildiğinde) bir metin ile bir istisna atılır. + +Kota kullanabilirsiniz “quota key” birden fazla anahtar için kaynakları bağımsız olarak rapor etme özelliği. İşte bunun bir örneği: + +``` xml + + + + +``` + +Kota kullanıcılara atanır ‘users’ yapılandırma bölümü. Bölümüne bakınız “Access rights”. + +Dağıtılmış sorgu işleme için birikmiş tutarları istekte bulunan sunucuda depolanır. Yani kullanıcı başka bir sunucuya giderse, oradaki kota “start over”. + +Sunucu yeniden başlatıldığında, kotalar sıfırlanır. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/quotas/) diff --git a/docs/tr/operations/requirements.md b/docs/tr/operations/requirements.md new file mode 100644 index 00000000000..c77159d11d7 --- /dev/null +++ b/docs/tr/operations/requirements.md @@ -0,0 +1,61 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 44 +toc_title: Gereksinimler +--- + +# Gereksinimler {#requirements} + +## CPU {#cpu} + +Önceden oluşturulmuş deb paketlerinden kurulum için, x86\_64 mimarisine sahip bir CPU kullanın ve sse 4.2 yönergelerini destekleyin. Clickhouse'u SSE 4.2'yi desteklemeyen veya AArch64 veya PowerPC64LE mimarisine sahip işlemcilerle çalıştırmak için, kaynaklardan Clickhouse'u oluşturmanız gerekir. + +ClickHouse paralel veri işleme uygular ve mevcut tüm donanım kaynaklarını kullanır. Bir işlemci seçerken, Clickhouse'un çok sayıda çekirdeğe sahip konfigürasyonlarda daha verimli çalıştığını, ancak daha az çekirdeğe ve daha yüksek bir saat hızına sahip konfigürasyonlardan daha düşük bir saat hızına sahip olduğunu göz önünde bulundurun. Örneğin, 2600 MHz'lik 16 çekirdek, 3600 MHz'lik 8 çekirdeğe tercih edilir. + +Kullanılması tavsiye edilir **Turbo Bo Boostost** ve **hyper-thre -ading** teknolojiler. Tipik bir iş yükü ile performansı önemli ölçüde artırır. + +## RAM {#ram} + +Önemsiz olmayan sorgular gerçekleştirmek için en az 4GB RAM kullanmanızı öneririz. ClickHouse sunucusu çok daha az miktarda RAM ile çalışabilir, ancak sorguları işlemek için bellek gerektirir. + +Gerekli RAM hacmi Aşağıdakilere bağlıdır: + +- Sorguların karmaşıklığı. +- Sorgularda işlenen veri miktarı. + +Gerekli RAM hacmini hesaplamak için, aşağıdakiler için geçici verilerin boyutunu tahmin etmelisiniz [GROUP BY](../sql_reference/statements/select.md#select-group-by-clause), [DISTINCT](../sql_reference/statements/select.md#select-distinct), [JOIN](../sql_reference/statements/select.md#select-join) ve kullandığınız diğer işlemler. + +ClickHouse geçici veriler için harici bellek kullanabilirsiniz. Görmek [Harici bellekte grupla](../sql_reference/statements/select.md#select-group-by-in-external-memory) ayrıntılar için. + +## Takas Dosyası {#swap-file} + +Üretim ortamları için takas dosyasını devre dışı bırakın. + +## Depolama Alt Sistemi {#storage-subsystem} + +Clickhouse'u yüklemek için 2GB Boş disk alanına sahip olmanız gerekir. + +Verileriniz için gereken depolama hacmi ayrı ayrı hesaplanmalıdır. Değerlendirme şunları içermelidir: + +- Veri hacminin tahmini. + + Verilerin bir örneğini alabilir ve ondan bir satırın ortalama boyutunu alabilirsiniz. Ardından değeri, depolamayı planladığınız satır sayısıyla çarpın. + +- Veri sıkıştırma katsayısı. + + Veri sıkıştırma katsayısını tahmin etmek için, verilerinizin bir örneğini Clickhouse'a yükleyin ve verilerin gerçek boyutunu depolanan tablonun boyutuyla karşılaştırın. Örneğin, clickstream verileri genellikle 6-10 kez sıkıştırılır. + +Saklanacak verilerin son hacmini hesaplamak için, sıkıştırma katsayısını tahmini veri hacmine uygulayın. Verileri birkaç yinelemede depolamayı planlıyorsanız, tahmini birimi yinelemelerin sayısıyla çarpın. + +## Ağ {#network} + +Mümkünse, 10g veya daha yüksek sınıftaki ağları kullanın. + +Ağ bant genişliği, büyük miktarda Ara veriyle dağıtılmış sorguları işlemek için kritik öneme sahiptir. Ayrıca, ağ hızı çoğaltma işlemlerini etkiler. + +## Yazılım {#software} + +ClickHouse öncelikle Linux işletim sistemleri ailesi için geliştirilmiştir. Önerilen Linux dağıtımı Ubuntu'dur. Bu `tzdata` paket sisteme kurulmalıdır. + +ClickHouse diğer işletim sistemi ailelerinde de çalışabilir. Ayrıntıları görün [Başlarken](../getting_started/index.md) belgelerin bölümü. diff --git a/docs/tr/operations/server_configuration_parameters/index.md b/docs/tr/operations/server_configuration_parameters/index.md new file mode 100644 index 00000000000..f1a20b924f0 --- /dev/null +++ b/docs/tr/operations/server_configuration_parameters/index.md @@ -0,0 +1,19 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "Sunucu Yap\u0131land\u0131rma Parametreleri" +toc_priority: 54 +toc_title: "Giri\u015F" +--- + +# Sunucu yapılandırma parametreleri {#server-settings} + +Bu bölüm, oturum veya sorgu düzeyinde değiştirilemeyen sunucu ayarlarının açıklamalarını içerir. + +Bu ayarlar saklanır `config.xml` ClickHouse sunucusunda dosya. + +Diğer ayarlar aşağıda açıklanmıştır “[Ayarlar](../settings/index.md#settings)” bölme. + +Ayarları incelemeden önce, [Yapılandırma dosyaları](../configuration_files.md#configuration_files) bölüm ve ikame kullanımı (not `incl` ve `optional` öznitelik). + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/server_configuration_parameters/) diff --git a/docs/tr/operations/server_configuration_parameters/settings.md b/docs/tr/operations/server_configuration_parameters/settings.md new file mode 100644 index 00000000000..bc0a464c511 --- /dev/null +++ b/docs/tr/operations/server_configuration_parameters/settings.md @@ -0,0 +1,896 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 57 +toc_title: "Sunucu Ayarlar\u0131" +--- + +# Sunucu Ayarları {#server-settings} + +## buıltın\_dıctıonarıes\_reload\_ınterval {#builtin-dictionaries-reload-interval} + +Dahili sözlükleri yeniden yüklemeden önce saniye cinsinden Aralık. + +ClickHouse, her x saniyede bir yerleşik sözlükleri yeniden yükler. Bu, sözlükleri düzenlemeyi mümkün kılar “on the fly” sunucuyu yeniden başlatmadan. + +Varsayılan değer: 3600. + +**Örnek** + +``` xml +3600 +``` + +## sıkıştırma {#server-settings-compression} + +İçin veri sıkıştırma ayarları [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md)- motor masaları. + +!!! warning "Uyarıcı" + Sadece ClickHouse kullanmaya başladıysanız kullanmayın. + +Yapılandırma şablonu: + +``` xml + + + ... + ... + ... + + ... + +``` + +`` alanlar: + +- `min_part_size` – The minimum size of a data part. +- `min_part_size_ratio` – The ratio of the data part size to the table size. +- `method` – Compression method. Acceptable values: `lz4` veya `zstd`. + +Birden fazla yapılandırabilirsiniz `` bölmeler. + +Koşullar yerine getirildiğinde eylemler: + +- Bir veri parçası bir koşul kümesiyle eşleşirse, ClickHouse belirtilen sıkıştırma yöntemini kullanır. +- Bir veri parçası birden çok koşul kümesiyle eşleşirse, ClickHouse ilk eşleşen koşul kümesini kullanır. + +Bir veri bölümü için herhangi bir koşul karşılanmazsa, ClickHouse `lz4` sıkıştırma. + +**Örnek** + +``` xml + + + 10000000000 + 0.01 + zstd + + +``` + +## default\_database {#default-database} + +Varsayılan veritabanı. + +Veritabanlarının bir listesini almak için [SHOW DATABASES](../../sql_reference/statements/show.md#show-databases) sorgu. + +**Örnek** + +``` xml +default +``` + +## default\_profile {#default-profile} + +Varsayılan ayarlar profili. + +Ayarlar profilleri parametrede belirtilen dosyada bulunur `user_config`. + +**Örnek** + +``` xml +default +``` + +## dictionaries\_config {#server_configuration_parameters-dictionaries_config} + +Dış sözlükler için yapılandırma dosyasının yolu. + +Yol: + +- Mutlak yolu veya sunucu yapılandırma dosyasına göre yolu belirtin. +- Yol joker karakterler içerebilir \* ve ?. + +Ayrıca bakınız “[Dış söz dictionarieslükler](../../sql_reference/dictionaries/external_dictionaries/external_dicts.md)”. + +**Örnek** + +``` xml +*_dictionary.xml +``` + +## dictionaries\_lazy\_load {#server_configuration_parameters-dictionaries_lazy_load} + +Sözlüklerin tembel yüklenmesi. + +Eğer `true`, sonra her sözlük ilk kullanımda oluşturulur. Sözlük oluşturma başarısız olursa, sözlüğü kullanan işlev bir özel durum atar. + +Eğer `false`, sunucu başladığında tüm sözlükler oluşturulur ve bir hata varsa, sunucu kapanır. + +Varsayılan değer `true`. + +**Örnek** + +``` xml +true +``` + +## format\_schema\_path {#server_configuration_parameters-format_schema_path} + +Dizin için şemalar gibi giriş verileri için şemaları ile yolu [CapnProto](../../interfaces/formats.md#capnproto) biçimli. + +**Örnek** + +``` xml + + format_schemas/ +``` + +## grafit {#server_configuration_parameters-graphite} + +Veri gönderme [Grafit](https://github.com/graphite-project). + +Ayarlar: + +- host – The Graphite server. +- port – The port on the Graphite server. +- interval – The interval for sending, in seconds. +- timeout – The timeout for sending data, in seconds. +- root\_path – Prefix for keys. +- metrics – Sending data from the [sistem.metrik](../../operations/system_tables.md#system_tables-metrics) Tablo. +- events – Sending deltas data accumulated for the time period from the [sistem.etkinlik](../../operations/system_tables.md#system_tables-events) Tablo. +- events\_cumulative – Sending cumulative data from the [sistem.etkinlik](../../operations/system_tables.md#system_tables-events) Tablo. +- asynchronous\_metrics – Sending data from the [sistem.asynchronous\_metrics](../../operations/system_tables.md#system_tables-asynchronous_metrics) Tablo. + +Birden fazla yapılandırabilirsiniz `` yanlar. Örneğin, bunu farklı aralıklarla farklı veri göndermek için kullanabilirsiniz. + +**Örnek** + +``` xml + + localhost + 42000 + 0.1 + 60 + one_min + true + true + false + true + +``` + +## graphite\_rollup {#server_configuration_parameters-graphite-rollup} + +Grafit için inceltme verileri için ayarlar. + +Daha fazla ayrıntı için bkz. [Graphıtemergetree](../../engines/table_engines/mergetree_family/graphitemergetree.md). + +**Örnek** + +``` xml + + + max + + 0 + 60 + + + 3600 + 300 + + + 86400 + 3600 + + + +``` + +## http\_port/https\_port {#http-porthttps-port} + +Http(ler) üzerinden sunucuya bağlanmak için bağlantı noktası. + +Eğer `https_port` belirtilen, [openSSL](#server_configuration_parameters-openssl) yapılandırılmalıdır. + +Eğer `http_port` belirtilmişse, OpenSSL yapılandırması ayarlanmış olsa bile göz ardı edilir. + +**Örnek** + +``` xml +0000 +``` + +## http\_server\_default\_response {#server_configuration_parameters-http_server_default_response} + +ClickHouse HTTP (s) sunucusuna eriştiğinizde varsayılan olarak gösterilen sayfa. +Varsayılan değer “Ok.” (sonunda bir çizgi besleme ile) + +**Örnek** + +Açıyor `https://tabix.io/` eriş whenirken `http://localhost: http_port`. + +``` xml + +
]]> + +``` + +## include\_from {#server_configuration_parameters-include_from} + +Değiştirmeleri ile dosyanın yolu. + +Daha fazla bilgi için bölüme bakın “[Yapılandırma dosyaları](../configuration_files.md#configuration_files)”. + +**Örnek** + +``` xml +/etc/metrica.xml +``` + +## ınterserver\_http\_port {#interserver-http-port} + +ClickHouse sunucuları arasında veri alışverişi için bağlantı noktası. + +**Örnek** + +``` xml +9009 +``` + +## ınterserver\_http\_host {#interserver-http-host} + +Bu sunucuya erişmek için diğer sunucular tarafından kullanılabilecek ana bilgisayar adı. + +Eğer ihmal edilirse, aynı şekilde tanımlanır `hostname-f` komut. + +Belirli bir ağ arayüzünden kopmak için kullanışlıdır. + +**Örnek** + +``` xml +example.yandex.ru +``` + +## ınterserver\_http\_credentials {#server-settings-interserver-http-credentials} + +Sırasında kimlik doğrulaması için kullanılan kullanıcı adı ve şifre [çoğalma](../../engines/table_engines/mergetree_family/replication.md) çoğaltılan \* motorlarla. Bu kimlik bilgileri yalnızca yinelemeler arasındaki iletişim için kullanılır ve ClickHouse istemcileri için kimlik bilgileri ile ilgisizdir. Sunucu, yinelemeleri bağlamak için bu kimlik bilgilerini denetliyor ve diğer yinelemelere bağlanırken aynı kimlik bilgilerini kullanıyor. Bu nedenle, bu kimlik bilgileri kümedeki tüm yinelemeler için aynı şekilde ayarlanmalıdır. +Varsayılan olarak, kimlik doğrulama kullanılmaz. + +Bu bölüm aşağıdaki parametreleri içerir: + +- `user` — username. +- `password` — password. + +**Örnek** + +``` xml + + admin + 222 + +``` + +## keep\_alive\_timeout {#keep-alive-timeout} + +ClickHouse bağlantıyı kapatmadan önce gelen istekleri bekler saniye sayısı. Varsayılan 3 saniye. + +**Örnek** + +``` xml +3 +``` + +## listen\_host {#server_configuration_parameters-listen_host} + +İsteklerin gelebileceği ana bilgisayarlarda kısıtlama. Sunucunun hepsini yanıtlamasını istiyorsanız, belirtin `::`. + +Örnekler: + +``` xml +::1 +127.0.0.1 +``` + +## kaydedici {#server_configuration_parameters-logger} + +Günlük ayarları. + +Anahtarlar: + +- level – Logging level. Acceptable values: `trace`, `debug`, `information`, `warning`, `error`. +- log – The log file. Contains all the entries according to `level`. +- errorlog – Error log file. +- size – Size of the file. Applies to `log`ve`errorlog`. Dosya ulaştıktan sonra `size`, ClickHouse arşivleri ve yeniden adlandırır ve onun yerine yeni bir günlük dosyası oluşturur. +- count – The number of archived log files that ClickHouse stores. + +**Örnek** + +``` xml + + trace + /var/log/clickhouse-server/clickhouse-server.log + /var/log/clickhouse-server/clickhouse-server.err.log + 1000M + 10 + +``` + +Syslog yazma da desteklenmektedir. Yapılandırma örneği: + +``` xml + + 1 + +
syslog.remote:10514
+ myhost.local + LOG_LOCAL6 + syslog + + +``` + +Anahtarlar: + +- use\_syslog — Required setting if you want to write to the syslog. +- address — The host\[:port\] of syslogd. If omitted, the local daemon is used. +- hostname — Optional. The name of the host that logs are sent from. +- facility — [Syslog tesisi anahtar sözcüğü](https://en.wikipedia.org/wiki/Syslog#Facility) ile büyük harf inlerle “LOG\_” önek: (`LOG_USER`, `LOG_DAEMON`, `LOG_LOCAL3` vb.). + Varsayılan değer: `LOG_USER` eğer `address` belirtilen, `LOG_DAEMON otherwise.` +- format – Message format. Possible values: `bsd` ve `syslog.` + +## makrolar {#macros} + +Çoğaltılmış tablolar için parametre değiştirmeleri. + +Çoğaltılmış tablolar kullanılmazsa atlanabilir. + +Daha fazla bilgi için bölüme bakın “[Çoğaltılmış tablolar oluşturma](../../engines/table_engines/mergetree_family/replication.md)”. + +**Örnek** + +``` xml + +``` + +## mark\_cache\_size {#server-mark-cache-size} + +Tablo motorları tarafından kullanılan işaretlerin önbelleğinin yaklaşık boyutu (bayt cinsinden) [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md) aile. + +Önbellek sunucu için paylaşılır ve bellek gerektiği gibi ayrılır. Önbellek boyutu en az 5368709120 olmalıdır. + +**Örnek** + +``` xml +5368709120 +``` + +## max\_concurrent\_queries {#max-concurrent-queries} + +Aynı anda işlenen isteklerin maksimum sayısı. + +**Örnek** + +``` xml +100 +``` + +## max\_connections {#max-connections} + +En fazla gelen bağlantı sayısı. + +**Örnek** + +``` xml +4096 +``` + +## max\_open\_files {#max-open-files} + +Maksimum açık dosya sayısı. + +Varsayılan olarak: `maximum`. + +Biz beri Mac OS X bu seçeneği kullanmanızı öneririz `getrlimit()` işlev yanlış bir değer döndürür. + +**Örnek** + +``` xml +262144 +``` + +## max\_table\_size\_to\_drop {#max-table-size-to-drop} + +Tabloları silme konusunda kısıtlama. + +Eğer bir boyutu [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md) tablo aşıyor `max_table_size_to_drop` (bayt cinsinden), bir bırakma sorgusu kullanarak silemezsiniz. + +ClickHouse sunucusunu yeniden başlatmadan tabloyu silmeniz gerekiyorsa, `/flags/force_drop_table` dosya ve bırakma sorgusunu çalıştırın. + +Varsayılan değer: 50 GB. + +0 değeri, herhangi bir kısıtlama olmaksızın tüm tabloları silebileceğiniz anlamına gelir. + +**Örnek** + +``` xml +0 +``` + +## merge\_tree {#server_configuration_parameters-merge_tree} + +Tablolar için ince ayar [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md). + +Daha fazla bilgi için bkz: MergeTreeSettings.h başlık dosyası. + +**Örnek** + +``` xml + + 5 + +``` + +## openSSL {#server_configuration_parameters-openssl} + +SSL istemci / sunucu yapılandırması. + +SSL desteği tarafından sağlanmaktadır `libpoco` kitaplık. Arayüz dosyada açıklanmıştır [SSLManager.sa](https://github.com/ClickHouse-Extras/poco/blob/master/NetSSL_OpenSSL/include/Poco/Net/SSLManager.h) + +Sunucu/istemci ayarları için tuşlar: + +- privateKeyFile – The path to the file with the secret key of the PEM certificate. The file may contain a key and certificate at the same time. +- certificateFile – The path to the client/server certificate file in PEM format. You can omit it if `privateKeyFile` sertifika içerir. +- caConfig – The path to the file or directory that contains trusted root certificates. +- verificationMode – The method for checking the node's certificates. Details are in the description of the [Bağlama](https://github.com/ClickHouse-Extras/poco/blob/master/NetSSL_OpenSSL/include/Poco/Net/Context.h) sınıf. Olası değerler: `none`, `relaxed`, `strict`, `once`. +- verificationDepth – The maximum length of the verification chain. Verification will fail if the certificate chain length exceeds the set value. +- loadDefaultCAFile – Indicates that built-in CA certificates for OpenSSL will be used. Acceptable values: `true`, `false`. \| +- cipherList – Supported OpenSSL encryptions. For example: `ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH`. +- cacheSessions – Enables or disables caching sessions. Must be used in combination with `sessionIdContext`. Kabul edilebilir değerler: `true`, `false`. +- sessionIdContext – A unique set of random characters that the server appends to each generated identifier. The length of the string must not exceed `SSL_MAX_SSL_SESSION_ID_LENGTH`. Bu parametre her zaman sunucu oturumu önbelleğe alır ve istemci önbellekleme istedi, sorunları önlemek yardımcı olduğundan önerilir. Varsayılan değer: `${application.name}`. +- sessionCacheSize – The maximum number of sessions that the server caches. Default value: 1024\*20. 0 – Unlimited sessions. +- sessionTimeout – Time for caching the session on the server. +- extendedVerification – Automatically extended verification of certificates after the session ends. Acceptable values: `true`, `false`. +- requireTLSv1 – Require a TLSv1 connection. Acceptable values: `true`, `false`. +- requireTLSv1\_1 – Require a TLSv1.1 connection. Acceptable values: `true`, `false`. +- requireTLSv1 – Require a TLSv1.2 connection. Acceptable values: `true`, `false`. +- fips – Activates OpenSSL FIPS mode. Supported if the library's OpenSSL version supports FIPS. +- privateKeyPassphraseHandler – Class (PrivateKeyPassphraseHandler subclass) that requests the passphrase for accessing the private key. For example: ``, `KeyFileHandler`, `test`, ``. +- invalidCertificateHandler – Class (a subclass of CertificateHandler) for verifying invalid certificates. For example: ` ConsoleCertificateHandler ` . +- disableProtocols – Protocols that are not allowed to use. +- preferServerCiphers – Preferred server ciphers on the client. + +**Ayarlar örneği:** + +``` xml + + + + /etc/clickhouse-server/server.crt + /etc/clickhouse-server/server.key + + /etc/clickhouse-server/dhparam.pem + none + true + true + sslv2,sslv3 + true + + + true + true + sslv2,sslv3 + true + + + + RejectCertificateHandler + + + +``` + +## part\_log {#server_configuration_parameters-part-log} + +İlişkili olayları günlüğe kaydetme [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md). Örneğin, veri ekleme veya birleştirme. Birleştirme algoritmalarını simüle etmek ve özelliklerini karşılaştırmak için günlüğü kullanabilirsiniz. Birleştirme işlemini görselleştirebilirsiniz. + +Sorgular günlüğe kaydedilir [sistem.part\_log](../../operations/system_tables.md#system_tables-part-log) tablo, ayrı bir dosyada değil. Bu tablonun adını aşağıdaki tabloda yapılandırabilirsiniz: `table` parametre (aşağıya bakınız). + +Günlüğü yapılandırmak için aşağıdaki parametreleri kullanın: + +- `database` – Name of the database. +- `table` – Name of the system table. +- `partition_by` – Sets a [özel bölümleme anahtarı](../../engines/table_engines/mergetree_family/custom_partitioning_key.md). +- `flush_interval_milliseconds` – Interval for flushing data from the buffer in memory to the table. + +**Örnek** + +``` xml + + system + part_log
+ toMonday(event_date) + 7500 + +``` + +## yol {#server_configuration_parameters-path} + +Veri içeren dizinin yolu. + +!!! note "Not" + Sondaki eğik çizgi zorunludur. + +**Örnek** + +``` xml +/var/lib/clickhouse/ +``` + +## prometheus {#server_configuration_parameters-prometheus} + +Kazıma için metrik verilerini açığa çıkarma [Prometheus](https://prometheus.io). + +Ayarlar: + +- `endpoint` – HTTP endpoint for scraping metrics by prometheus server. Start from ‘/’. +- `port` – Port for `endpoint`. +- `metrics` – Flag that sets to expose metrics from the [sistem.metrik](../system_tables.md#system_tables-metrics) Tablo. +- `events` – Flag that sets to expose metrics from the [sistem.etkinlik](../system_tables.md#system_tables-events) Tablo. +- `asynchronous_metrics` – Flag that sets to expose current metrics values from the [sistem.asynchronous\_metrics](../system_tables.md#system_tables-asynchronous_metrics) Tablo. + +**Örnek** + +``` xml + + /metrics + 8001 + true + true + true + +``` + +## query\_log {#server_configuration_parameters-query-log} + +İle alınan günlük sorgu settinglarının ayarlanması [log\_queries = 1](../settings/settings.md) ayar. + +Sorgular günlüğe kaydedilir [sistem.query\_log](../../operations/system_tables.md#system_tables-query_log) tablo, ayrı bir dosyada değil. Tablonun adını değiştirebilirsiniz. `table` parametre (aşağıya bakınız). + +Günlüğü yapılandırmak için aşağıdaki parametreleri kullanın: + +- `database` – Name of the database. +- `table` – Name of the system table the queries will be logged in. +- `partition_by` – Sets a [özel bölümleme anahtarı](../../engines/table_engines/mergetree_family/custom_partitioning_key.md) bir masa için. +- `flush_interval_milliseconds` – Interval for flushing data from the buffer in memory to the table. + +Tablo yoksa, ClickHouse bunu oluşturur. ClickHouse sunucusu güncelleştirildiğinde sorgu günlüğünün yapısı değiştiyse, eski yapıya sahip tablo yeniden adlandırılır ve otomatik olarak yeni bir tablo oluşturulur. + +**Örnek** + +``` xml + + system + query_log
+ toMonday(event_date) + 7500 + +``` + +## query\_thread\_log {#server_configuration_parameters-query-thread-log} + +İle alınan sorguların günlük iş parçacıklarının ayarlanması [log\_query\_threads = 1](../settings/settings.md#settings-log-query-threads) ayar. + +Sorgular günlüğe kaydedilir [sistem.query\_thread\_log](../../operations/system_tables.md#system_tables-query-thread-log) tablo, ayrı bir dosyada değil. Tablonun adını değiştirebilirsiniz. `table` parametre (aşağıya bakınız). + +Günlüğü yapılandırmak için aşağıdaki parametreleri kullanın: + +- `database` – Name of the database. +- `table` – Name of the system table the queries will be logged in. +- `partition_by` – Sets a [özel bölümleme anahtarı](../../engines/table_engines/mergetree_family/custom_partitioning_key.md) bir sistem tablosu için. +- `flush_interval_milliseconds` – Interval for flushing data from the buffer in memory to the table. + +Tablo yoksa, ClickHouse bunu oluşturur. Sorgu iş parçacığı günlüğü yapısını değiştirdiyseniz ClickHouse sunucu güncelleştirildi, tablo eski yapısı ile yeniden adlandırılır ve yeni bir tablo otomatik olarak oluşturulur. + +**Örnek** + +``` xml + + system + query_thread_log
+ toMonday(event_date) + 7500 + +``` + +## trace\_log {#server_configuration_parameters-trace_log} + +İçin ayarlar [trace\_log](../../operations/system_tables.md#system_tables-trace_log) sistem tablosu çalışması. + +Parametre: + +- `database` — Database for storing a table. +- `table` — Table name. +- `partition_by` — [Özel bölümleme anahtarı](../../engines/table_engines/mergetree_family/custom_partitioning_key.md) bir sistem tablosu için. +- `flush_interval_milliseconds` — Interval for flushing data from the buffer in memory to the table. + +Varsayılan sunucu yapılandırma dosyası `config.xml` aşağıdaki ayarlar bölümünü içerir: + +``` xml + + system + trace_log
+ toYYYYMM(event_date) + 7500 + +``` + +## query\_masking\_rules {#query-masking-rules} + +Regexp tabanlı kurallar, sorgulara ve tüm günlük iletilerine sunucu günlüklerinde depolamadan önce uygulanacak, +`system.query_log`, `system.text_log`, `system.processes` tablo ve istemciye gönderilen günlüklerde. Önlem allowseyi sağlayan +SQL sorgularından hassas veri sızıntısı (isimler, e-postalar, kişisel +kimlik veya kredi kartı numaraları) günlükleri için. + +**Örnek** + +``` xml + + + hide SSN + (^|\D)\d{3}-\d{2}-\d{4}($|\D) + 000-00-0000 + + +``` + +Config alanları: +- `name` - kuralın adı (isteğe bağlı) +- `regexp` - Re2 uyumlu düzenli ifade (zorunlu) +- `replace` - hassas veriler için ikame dizesi (isteğe bağlı, varsayılan olarak-altı Yıldız İşareti) + +Maskeleme kuralları tüm sorguya uygulanır (hatalı biçimlendirilmiş / ayrıştırılamayan sorgulardan hassas verilerin sızıntılarını önlemek için). + +`system.events` tablo sayacı var `QueryMaskingRulesMatch` hangi sorgu maskeleme kuralları maçları genel bir numarası var. + +Dağıtılmış sorgular için her sunucu ayrı ayrı yapılandırılmalıdır, aksi takdirde alt sorgular diğerine iletilir +düğümler maskeleme olmadan saklanır. + +## remote\_servers {#server-settings-remote-servers} + +Tarafından kullanılan küm ofelerin yapılandırması [Dağılı](../../engines/table_engines/special/distributed.md) tablo motoru ve `cluster` tablo işlevi. + +**Örnek** + +``` xml + +``` + +Değeri için `incl` öznitelik, bölümüne bakın “[Yapılandırma dosyaları](../configuration_files.md#configuration_files)”. + +**Ayrıca Bakınız** + +- [skip\_unavailable\_shards](../settings/settings.md#settings-skip_unavailable_shards) + +## saat dilimi {#server_configuration_parameters-timezone} + +Sunucunun saat dilimi. + +UTC saat dilimi veya coğrafi konum (örneğin, Afrika / Abidjan) için bir IANA tanımlayıcısı olarak belirtilir. + +Saat dilimi, datetime alanları metin biçimine (ekranda veya dosyada yazdırıldığında) çıktığında ve datetime'ı bir dizeden alırken dize ve DateTime biçimleri arasındaki dönüşümler için gereklidir. Ayrıca, saat dilimi, giriş parametrelerinde saat dilimini almadıkları takdirde saat ve tarih ile çalışan işlevlerde kullanılır. + +**Örnek** + +``` xml +Europe/Moscow +``` + +## tcp\_port {#server_configuration_parameters-tcp_port} + +TCP protokolü üzerinden istemcilerle iletişim kurmak için bağlantı noktası. + +**Örnek** + +``` xml +9000 +``` + +## tcp\_port\_secure {#server_configuration_parameters-tcp_port-secure} + +İstemcilerle güvenli iletişim için TCP bağlantı noktası. İle kullanın [OpenSSL](#server_configuration_parameters-openssl) ayarlar. + +**Olası değerler** + +Pozitif tamsayı. + +**Varsayılan değer** + +``` xml +9440 +``` + +## mysql\_port {#server_configuration_parameters-mysql_port} + +MySQL protokolü üzerinden istemcilerle iletişim kurmak için bağlantı noktası. + +**Olası değerler** + +Pozitif tamsayı. + +Örnek + +``` xml +9004 +``` + +## tmp\_path {#server-settings-tmp_path} + +Büyük sorguları işlemek için geçici veri yolu. + +!!! note "Not" + Sondaki eğik çizgi zorunludur. + +**Örnek** + +``` xml +/var/lib/clickhouse/tmp/ +``` + +## tmp\_policy {#server-settings-tmp-policy} + +Politika dan [`storage_configuration`](../../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-multiple-volumes) geçici dosyaları saklamak için. +Set değilse [`tmp_path`](#server-settings-tmp_path) kullanılır, aksi takdirde göz ardı edilir. + +!!! note "Not" + - `move_factor` göz ardı edilir +- `keep_free_space_bytes` göz ardı edilir +- `max_data_part_size_bytes` göz ardı edilir +- bu Politikada tam olarak bir cilt olmalı + +## uncompressed\_cache\_size {#server-settings-uncompressed_cache_size} + +Tablo motorları tarafından kullanılan sıkıştırılmamış veriler için önbellek boyutu (bayt cinsinden) [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md). + +Sunucu için bir paylaşılan önbellek var. Bellek talep üzerine tahsis edilir. Seçenek varsa önbellek kullanılır [use\_uncompressed\_cache](../settings/settings.md#setting-use_uncompressed_cache) etkindir. + +Sıkıştırılmamış önbellek, tek tek durumlarda çok kısa sorgular için avantajlıdır. + +**Örnek** + +``` xml +8589934592 +``` + +## user\_files\_path {#server_configuration_parameters-user_files_path} + +Kullanıcı dosyaları ile dizin. Tablo işlevinde kullanılır [Dosya()](../../sql_reference/table_functions/file.md). + +**Örnek** + +``` xml +/var/lib/clickhouse/user_files/ +``` + +## users\_config {#users-config} + +İçeren dosyanın yolu: + +- Kullanıcı yapılandırmaları. +- Erişim hakları. +- Ayarlar profilleri. +- Kota ayarları. + +**Örnek** + +``` xml +users.xml +``` + +## zookeeper {#server-settings_zookeeper} + +ClickHouse ile etkileşim sağlayan ayarları içerir [ZooKeeper](http://zookeeper.apache.org/) küme. + +ClickHouse, çoğaltılmış tabloları kullanırken kopyaların meta verilerini depolamak için ZooKeeper kullanır. Çoğaltılmış tablolar kullanılmazsa, parametrelerin bu bölümü atlanabilir. + +Bu bölüm aşağıdaki parametreleri içerir: + +- `node` — ZooKeeper endpoint. You can set multiple endpoints. + + Mesela: + + + +``` xml + + example_host + 2181 + +``` + + The `index` attribute specifies the node order when trying to connect to the ZooKeeper cluster. + +- `session_timeout` — Maximum timeout for the client session in milliseconds. +- `root` — The [znode](http://zookeeper.apache.org/doc/r3.5.5/zookeeperOver.html#Nodes+and+ephemeral+nodes) bu, ClickHouse sunucusu tarafından kullanılan znodes için kök olarak kullanılır. İsteğe bağlı. +- `identity` — User and password, that can be required by ZooKeeper to give access to requested znodes. Optional. + +**Örnek yapılandırma** + +``` xml + + + example1 + 2181 + + + example2 + 2181 + + 30000 + 10000 + + /path/to/zookeeper/node + + user:password + +``` + +**Ayrıca Bakınız** + +- [Çoğalma](../../engines/table_engines/mergetree_family/replication.md) +- [ZooKeeper programcı Kılavuzu](http://zookeeper.apache.org/doc/current/zookeeperProgrammers.html) + +## use\_minimalistic\_part\_header\_in\_zookeeper {#server-settings-use_minimalistic_part_header_in_zookeeper} + +ZooKeeper veri parçası başlıkları için depolama yöntemi. + +Bu ayar yalnızca `MergeTree` aile. Belirt specifiedilebilir: + +- Küresel olarak [merge\_tree](#server_configuration_parameters-merge_tree) bu bölüm `config.xml` Dosya. + + ClickHouse sunucudaki tüm tablolar için ayarı kullanır. Ayarı istediğiniz zaman değiştirebilirsiniz. Mevcut tablolar, ayar değiştiğinde davranışlarını değiştirir. + +- Her tablo için. + + Bir tablo oluştururken, karşılık gelen [motor ayarı](../../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-creating-a-table). Genel ayar değişse bile, bu ayara sahip varolan bir tablonun davranışı değişmez. + +**Olası değerler** + +- 0 — Functionality is turned off. +- 1 — Functionality is turned on. + +Eğer `use_minimalistic_part_header_in_zookeeper = 1`, sonraları [çoğaltıyordu](../../engines/table_engines/mergetree_family/replication.md) tablolar, veri parçalarının başlıklarını tek bir `znode`. Tablo çok sayıda sütun içeriyorsa, bu depolama yöntemi Zookeeper'da depolanan verilerin hacmini önemli ölçüde azaltır. + +!!! attention "Dikkat" + Uyguladıktan sonra `use_minimalistic_part_header_in_zookeeper = 1`, ClickHouse sunucusunu bu ayarı desteklemeyen bir sürüme düşüremezsiniz. Bir kümedeki sunucularda ClickHouse yükseltirken dikkatli olun. Tüm sunucuları bir kerede yükseltmeyin. Clickhouse'un yeni sürümlerini bir test ortamında veya bir kümenin yalnızca birkaç sunucusunda test etmek daha güvenlidir. + + Data part headers already stored with this setting can't be restored to their previous (non-compact) representation. + +**Varsayılan değer:** 0. + +## disable\_internal\_dns\_cache {#server-settings-disable-internal-dns-cache} + +İç DNS önbelleğini devre dışı bırakır. Sistemlerinde ClickHouse işletim için tavsiye +Kubernetes gibi sık sık değişen altyapı ile. + +**Varsayılan değer:** 0. + +## dns\_cache\_update\_period {#server-settings-dns-cache-update-period} + +ClickHouse iç DNS önbelleğinde saklanan IP adreslerini güncelleme süresi (saniye cinsinden). +Güncelleştirme, ayrı bir sistem iş parçacığında zaman uyumsuz olarak gerçekleştirilir. + +**Varsayılan değer**: 15. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/server_configuration_parameters/settings/) diff --git a/docs/tr/operations/settings/constraints_on_settings.md b/docs/tr/operations/settings/constraints_on_settings.md new file mode 100644 index 00000000000..a9319c2df69 --- /dev/null +++ b/docs/tr/operations/settings/constraints_on_settings.md @@ -0,0 +1,75 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 62 +toc_title: "Ayarlardaki k\u0131s\u0131tlamalar" +--- + +# Ayarlardaki kısıtlamalar {#constraints-on-settings} + +Ayarlardaki kısıtlamalar, `profiles` bu bölüm `user.xml` yapılandırma dosyası ve kullanıcıların bazı ayarları değiştirmelerini yasakla `SET` sorgu. +Kısıtlamalar aşağıdaki gibi tanımlanır: + +``` xml + + + + + lower_boundary + + + upper_boundary + + + lower_boundary + upper_boundary + + + + + + + +``` + +Kullanıcı kısıtlamaları ihlal etmeye çalışırsa, bir istisna atılır ve ayar değiştirilmez. +Desteklenen üç tür kısıtlama vardır: `min`, `max`, `readonly`. Bu `min` ve `max` kısıtlamalar, sayısal bir ayar için üst ve alt sınırları belirtir ve birlikte kullanılabilir. Bu `readonly` kısıtlama, kullanıcının karşılık gelen ayarı hiç değiştiremeyeceğini belirtir. + +**Örnek:** İzin vermek `users.xml` hatları içerir: + +``` xml + + + 10000000000 + 0 + ... + + + 5000000000 + 20000000000 + + + + + + + +``` + +Aşağıdaki sorgular tüm atma istisnaları: + +``` sql +SET max_memory_usage=20000000001; +SET max_memory_usage=4999999999; +SET force_index_by_date=1; +``` + +``` text +Code: 452, e.displayText() = DB::Exception: Setting max_memory_usage should not be greater than 20000000000. +Code: 452, e.displayText() = DB::Exception: Setting max_memory_usage should not be less than 5000000000. +Code: 452, e.displayText() = DB::Exception: Setting force_index_by_date should not be changed. +``` + +**Not:** bu `default` profil özel işleme sahiptir: tüm kısıtlamalar için tanımlanan `default` profil varsayılan kısıtlamalar haline gelir, bu nedenle bu kullanıcılar için açıkça geçersiz kılınana kadar tüm kullanıcıları kısıtlarlar. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/settings/constraints_on_settings/) diff --git a/docs/tr/operations/settings/index.md b/docs/tr/operations/settings/index.md new file mode 100644 index 00000000000..72270b8a397 --- /dev/null +++ b/docs/tr/operations/settings/index.md @@ -0,0 +1,32 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: Ayarlar +toc_priority: 55 +toc_title: "Giri\u015F" +--- + +# Ayarlar {#settings} + +Aşağıda açıklanan tüm ayarları yapmanın birden çok yolu vardır. +Ayarlar katmanlar halinde yapılandırılır, böylece sonraki her katman önceki ayarları yeniden tanımlar. + +Öncelik sırasına göre ayarları yapılandırma yolları: + +- Ayarlar `users.xml` sunucu yapılandırma dosyası. + + Eleman setında Set ``. + +- Oturum ayarları. + + Göndermek `SET setting=value` etkileşimli modda ClickHouse konsol istemcisinden. + Benzer şekilde, http protokolünde ClickHouse oturumlarını kullanabilirsiniz. Bunu yapmak için şunları belirtmeniz gerekir `session_id` HTTP parametresi. + +- Sorgu ayarları. + + - ClickHouse konsol istemcisini etkileşimli olmayan modda başlatırken, başlangıç parametresini ayarlayın `--setting=value`. + - HTTP API'sini kullanırken, CGI parametrelerini geçirin (`URL?setting_1=value&setting_2=value...`). + +Yalnızca sunucu yapılandırma dosyasında yapılabilecek ayarlar bu bölümde yer almaz. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/settings/) diff --git a/docs/tr/operations/settings/permissions_for_queries.md b/docs/tr/operations/settings/permissions_for_queries.md new file mode 100644 index 00000000000..2f65630604c --- /dev/null +++ b/docs/tr/operations/settings/permissions_for_queries.md @@ -0,0 +1,61 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 58 +toc_title: "Sorgular i\xE7in izinler" +--- + +# Sorgular için izinler {#permissions_for_queries} + +Clickhouse'daki sorgular birkaç türe ayrılabilir: + +1. Veri sorgularını oku: `SELECT`, `SHOW`, `DESCRIBE`, `EXISTS`. +2. Veri sorgularını yaz: `INSERT`, `OPTIMIZE`. +3. Ayarları değiştir sorgu: `SET`, `USE`. +4. [DDL](https://en.wikipedia.org/wiki/Data_definition_language) sorgular: `CREATE`, `ALTER`, `RENAME`, `ATTACH`, `DETACH`, `DROP` `TRUNCATE`. +5. `KILL QUERY`. + +Aşağıdaki ayarlar, kullanıcı izinlerini sorgu Türüne göre düzenler: + +- [readonly](#settings_readonly) — Restricts permissions for all types of queries except DDL queries. +- [allow\_ddl](#settings_allow_ddl) — Restricts permissions for DDL queries. + +`KILL QUERY` herhangi bir ayar ile yapılabilir. + +## readonly {#settings_readonly} + +Veri okuma, veri yazma ve ayar sorgularını değiştirme izinlerini kısıtlar. + +Sorguların türlere nasıl ayrıldığını görün [üzerinde](#permissions_for_queries). + +Olası değerler: + +- 0 — All queries are allowed. +- 1 — Only read data queries are allowed. +- 2 — Read data and change settings queries are allowed. + +Sonra ayarı `readonly = 1`, kullanıcı değiştir canemez `readonly` ve `allow_ddl` geçerli oturumda ayarlar. + +Kullanırken `GET` metho thed in the [HTTP arayüzü](../../interfaces/http.md), `readonly = 1` otomatik olarak ayarlanır. Değiştirmek için veri kullanın `POST` yöntem. + +Ayar `readonly = 1` kullanıcının tüm ayarları değiştirmesini yasaklayın. Kullanıcıyı yasaklamanın bir yolu var +sadece belirli ayarları değiştirmekten, ayrıntılar için bkz [ayarlardaki kısıtlamalar](constraints_on_settings.md). + +Varsayılan değer: 0 + +## allow\_ddl {#settings_allow_ddl} + +İzin verir veya reddeder [DDL](https://en.wikipedia.org/wiki/Data_definition_language) sorgular. + +Sorguların türlere nasıl ayrıldığını görün [üzerinde](#permissions_for_queries). + +Olası değerler: + +- 0 — DDL queries are not allowed. +- 1 — DDL queries are allowed. + +Yürüt canemezsiniz `SET allow_ddl = 1` eğer `allow_ddl = 0` geçerli oturum için. + +Varsayılan değer: 1 + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/settings/permissions_for_queries/) diff --git a/docs/tr/operations/settings/query_complexity.md b/docs/tr/operations/settings/query_complexity.md new file mode 100644 index 00000000000..54958b786ab --- /dev/null +++ b/docs/tr/operations/settings/query_complexity.md @@ -0,0 +1,302 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 59 +toc_title: "Sorgu karma\u015F\u0131kl\u0131\u011F\u0131 \xFCzerindeki k\u0131s\u0131\ + tlamalar" +--- + +# Sorgu Karmaşıklığı Üzerindeki Kısıtlamalar {#restrictions-on-query-complexity} + +Sorgu karmaşıklığı üzerindeki kısıtlamalar ayarların bir parçasıdır. +Kullanıcı arabiriminden daha güvenli yürütme sağlamak için kullanılırlar. +Hemen hemen tüm kısıtlamalar sadece aşağıdakiler için geçerlidir `SELECT`. Dağıtılmış sorgu işleme için kısıtlamalar her sunucuda ayrı ayrı uygulanır. + +ClickHouse, her satır için değil, veri bölümleri için kısıtlamaları denetler. Bu, veri parçasının boyutu ile kısıtlama değerini aşabileceğiniz anlamına gelir. + +Üzerindeki kısıtlamalar “maximum amount of something” 0 değerini alabilir, yani “unrestricted”. +Çoğu kısıtlama da bir ‘overflow\_mode’ ayar, sınır aşıldığında ne yapılması gerektiği anlamına gelir. +İki değerden birini alabilir: `throw` veya `break`. Toplama (group\_by\_overflow\_mode) üzerindeki kısıtlamalar da değere sahiptir `any`. + +`throw` – Throw an exception (default). + +`break` – Stop executing the query and return the partial result, as if the source data ran out. + +`any (only for group_by_overflow_mode)` – Continuing aggregation for the keys that got into the set, but don't add new keys to the set. + +## max\_memory\_usage {#settings_max_memory_usage} + +Tek bir sunucuda bir sorgu çalıştırmak için kullanılacak en fazla RAM miktarı. + +Varsayılan yapılandırma dosyasında maksimum 10 GB'DİR. + +Bu ayar, kullanılabilir belleğin hacmini veya makinedeki toplam bellek hacmini dikkate almaz. +Kısıtlama, tek bir sunucu içindeki tek bir sorgu için geçerlidir. +Kullanabilirsiniz `SHOW PROCESSLIST` her sorgu için geçerli bellek tüketimini görmek için. +Ayrıca, en yüksek bellek tüketimi her sorgu için izlenir ve günlüğe yazılır. + +Bellek kullanımı, belirli toplama işlevlerinin durumları için izlenmez. + +Toplam işlevlerin durumları için bellek kullanımı tam olarak izlenmiyor `min`, `max`, `any`, `anyLast`, `argMin`, `argMax` itibaren `String` ve `Array` değişkenler. + +Bellek tüketimi de parametrelerle sınırlıdır `max_memory_usage_for_user` ve `max_memory_usage_for_all_queries`. + +## max\_memory\_usage\_for\_user {#max-memory-usage-for-user} + +Tek bir sunucuda bir kullanıcının sorguları çalıştırmak için kullanılacak en fazla RAM miktarı. + +Varsayılan değerler [Ayarlar.sa](https://github.com/ClickHouse/ClickHouse/blob/master/src/Core/Settings.h#L288). Varsayılan olarak, tutar sınırlı değildir (`max_memory_usage_for_user = 0`). + +Ayrıca açıklamasına bakın [max\_memory\_usage](#settings_max_memory_usage). + +## max\_memory\_usage\_for\_all\_queries {#max-memory-usage-for-all-queries} + +Tek bir sunucuda tüm sorguları çalıştırmak için kullanılacak en fazla RAM miktarı. + +Varsayılan değerler [Ayarlar.sa](https://github.com/ClickHouse/ClickHouse/blob/master/src/Core/Settings.h#L289). Varsayılan olarak, tutar sınırlı değildir (`max_memory_usage_for_all_queries = 0`). + +Ayrıca açıklamasına bakın [max\_memory\_usage](#settings_max_memory_usage). + +## max\_rows\_to\_read {#max-rows-to-read} + +Aşağıdaki kısıtlamalar her blokta kontrol edilebilir (her satır yerine). Yani, kısıtlamalar biraz kırılabilir. +Birden çok iş parçacığında bir sorgu çalıştırırken, aşağıdaki kısıtlamalar her iş parçacığı için ayrı ayrı uygulanır. + +Bir sorgu çalıştırırken bir tablodan okunabilen satır sayısı. + +## max\_bytes\_to\_read {#max-bytes-to-read} + +Bir sorgu çalıştırırken bir tablodan okunabilen bayt sayısı (sıkıştırılmamış veri). + +## read\_overflow\_mode {#read-overflow-mode} + +Okunan veri hacmi sınırlardan birini aştığında ne yapmalı: ‘throw’ veya ‘break’. Varsayılan olarak, atın. + +## max\_rows\_to\_group\_by {#settings-max-rows-to-group-by} + +Toplama alınan benzersiz anahtarların maksimum sayısı. Bu ayar, toplama sırasında bellek tüketimini sınırlamanızı sağlar. + +## group\_by\_overflow\_mode {#group-by-overflow-mode} + +Toplama için benzersiz anahtarların sayısı sınırı aştığında ne yapmalı: ‘throw’, ‘break’, veya ‘any’. Varsayılan olarak, atın. +Kullanarak ‘any’ değer, GROUP BY'NİN bir yaklaşımını çalıştırmanızı sağlar. Bu yaklaşımın kalitesi, verilerin istatistiksel niteliğine bağlıdır. + +## max\_bytes\_before\_external\_group\_by {#settings-max_bytes_before_external_group_by} + +Çalıştırmayı etkinleştirir veya devre dışı bırakır `GROUP BY` harici bellekte yan tümceleri. Görmek [Harici bellekte grupla](../../sql_reference/statements/select.md#select-group-by-in-external-memory). + +Olası değerler: + +- Tek tarafından kullanılabilecek maksimum RAM hacmi (bayt cinsinden) [GROUP BY](../../sql_reference/statements/select.md#select-group-by-clause) işleyiş. +- 0 — `GROUP BY` harici bellekte devre dışı. + +Varsayılan değer: 0. + +## max\_rows\_to\_sort {#max-rows-to-sort} + +Sıralamadan önce en fazla satır sayısı. Bu, sıralama yaparken bellek tüketimini sınırlamanıza izin verir. + +## max\_bytes\_to\_sort {#max-bytes-to-sort} + +Sıralamadan önce en fazla bayt sayısı. + +## sort\_overflow\_mode {#sort-overflow-mode} + +Sıralamadan önce alınan satır sayısı sınırlardan birini aşarsa ne yapmalı: ‘throw’ veya ‘break’. Varsayılan olarak, atın. + +## max\_result\_rows {#setting-max_result_rows} + +Sonuçtaki satır sayısını sınırlayın. Ayrıca, dağıtılmış bir sorgunun parçalarını çalıştırırken alt sorgular ve uzak sunucularda da kontrol edildi. + +## max\_result\_bytes {#max-result-bytes} + +Sonuçtaki bayt sayısını sınırlayın. Önceki ayar ile aynı. + +## result\_overflow\_mode {#result-overflow-mode} + +Sonucun hacmi sınırlardan birini aşarsa ne yapmalı: ‘throw’ veya ‘break’. Varsayılan olarak, atın. + +Kullanım ‘break’ LİMİT kullanmaya benzer. `Break` yürütmeyi yalnızca blok düzeyinde keser. Bu, döndürülen satırların miktarının daha büyük olduğu anlamına gelir [max\_result\_rows](#setting-max_result_rows) birden çok [max\_block\_size](settings.md#setting-max_block_size) ve bağlıdır [max\_threads](settings.md#settings-max_threads). + +Örnek: + +``` sql +SET max_threads = 3, max_block_size = 3333; +SET max_result_rows = 3334, result_overflow_mode = 'break'; + +SELECT * +FROM numbers_mt(100000) +FORMAT Null; +``` + +Sonuç: + +``` text +6666 rows in set. ... +``` + +## max\_execution\_time {#max-execution-time} + +Saniye cinsinden maksimum sorgu yürütme süresi. +Şu anda, sıralama aşamalarından biri için veya toplama işlevlerini birleştirirken ve sonlandırırken kontrol edilmez. + +## timeout\_overflow\_mode {#timeout-overflow-mode} + +Sorgu daha uzun çalıştırılırsa ne yapmalı ‘max\_execution\_time’: ‘throw’ veya ‘break’. Varsayılan olarak, atın. + +## min\_execution\_speed {#min-execution-speed} + +Saniyede satırlarda minimum yürütme hızı. Her veri bloğunda ne zaman kontrol edildi ‘timeout\_before\_checking\_execution\_speed’ doluyor. Yürütme hızı düşükse, bir istisna atılır. + +## min\_execution\_speed\_bytes {#min-execution-speed-bytes} + +Saniyede en az yürütme bayt sayısı. Her veri bloğunda ne zaman kontrol edildi ‘timeout\_before\_checking\_execution\_speed’ doluyor. Yürütme hızı düşükse, bir istisna atılır. + +## max\_execution\_speed {#max-execution-speed} + +Saniyede en fazla yürütme satırı sayısı. Her veri bloğunda ne zaman kontrol edildi ‘timeout\_before\_checking\_execution\_speed’ doluyor. Yürütme hızı yüksekse, yürütme hızı azaltılır. + +## max\_execution\_speed\_bytes {#max-execution-speed-bytes} + +Saniyede en fazla yürütme bayt sayısı. Her veri bloğunda ne zaman kontrol edildi ‘timeout\_before\_checking\_execution\_speed’ doluyor. Yürütme hızı yüksekse, yürütme hızı azaltılır. + +## timeout\_before\_checking\_execution\_speed {#timeout-before-checking-execution-speed} + +Yürütme hızının çok yavaş olmadığını kontrol eder (en az ‘min\_execution\_speed’), saniye içinde belirtilen süre dolduktan sonra. + +## max\_columns\_to\_read {#max-columns-to-read} + +Tek bir sorguda bir tablodan okunabilen sütun sayısı. Bir sorgu daha fazla sayıda sütun okuma gerektiriyorsa, bir özel durum atar. + +## max\_temporary\_columns {#max-temporary-columns} + +Sabit sütunlar da dahil olmak üzere bir sorgu çalıştırırken aynı anda RAM'de tutulması gereken geçici sütun sayısı. Bundan daha fazla geçici sütun varsa, bir istisna atar. + +## max\_temporary\_non\_const\_columns {#max-temporary-non-const-columns} + +Aynı şey ‘max\_temporary\_columns’, ancak sabit sütunları saymadan. +Bir sorgu çalıştırırken sabit sütunların oldukça sık oluşturulduğunu, ancak yaklaşık sıfır bilgi işlem kaynağı gerektirdiğini unutmayın. + +## max\_subquery\_depth {#max-subquery-depth} + +Alt sorguların maksimum yuvalama derinliği. Alt sorgular daha derinse, bir istisna atılır. Varsayılan olarak, 100. + +## max\_pipeline\_depth {#max-pipeline-depth} + +Maksimum boru hattı derinliği. Sorgu işleme sırasında her veri bloğunun geçtiği dönüşümlerin sayısına karşılık gelir. Tek bir sunucunun sınırları içinde sayılır. Boru hattı derinliği büyükse, bir istisna atılır. Varsayılan olarak, 1000. + +## max\_ast\_depth {#max-ast-depth} + +Sorgu sözdizimsel ağacının en fazla yuvalama derinliği. Aşılırsa, bir istisna atılır. +Şu anda, ayrıştırma sırasında değil, yalnızca sorguyu ayrıştırdıktan sonra kontrol edilir. Yani, ayrıştırma sırasında çok derin bir sözdizimsel ağaç oluşturulabilir, ancak sorgu başarısız olur. Varsayılan olarak, 1000. + +## max\_ast\_elements {#max-ast-elements} + +Sorgu sözdizimsel ağacındaki en fazla öğe sayısı. Aşılırsa, bir istisna atılır. +Önceki ayarla aynı şekilde, yalnızca sorguyu ayrıştırdıktan sonra kontrol edilir. Varsayılan olarak, 50.000. + +## max\_rows\_in\_set {#max-rows-in-set} + +Bir alt sorgudan oluşturulan In yan tümcesinde bir veri kümesi için satır sayısı. + +## max\_bytes\_in\_set {#max-bytes-in-set} + +Bir alt sorgudan oluşturulan In yan tümcesinde bir set tarafından kullanılan en fazla bayt sayısı (sıkıştırılmamış veri). + +## set\_overflow\_mode {#set-overflow-mode} + +Veri miktarı sınırlardan birini aştığında ne yapmalı: ‘throw’ veya ‘break’. Varsayılan olarak, atın. + +## max\_rows\_ın\_distinct {#max-rows-in-distinct} + +DISTINCT kullanırken en fazla sayıda farklı satır. + +## max\_bytes\_ın\_distinct {#max-bytes-in-distinct} + +DISTINCT kullanırken bir karma tablo tarafından kullanılan bayt sayısı. + +## distinct\_overflow\_mode {#distinct-overflow-mode} + +Veri miktarı sınırlardan birini aştığında ne yapmalı: ‘throw’ veya ‘break’. Varsayılan olarak, atın. + +## max\_rows\_to\_transfer {#max-rows-to-transfer} + +Uzak bir sunucuya geçirilen veya GLOBAL In kullanırken geçici bir tabloya kaydedilen satır sayısı. + +## max\_bytes\_to\_transfer {#max-bytes-to-transfer} + +Uzak bir sunucuya geçirilen veya GLOBAL In kullanırken geçici bir tabloya kaydedilen bayt sayısı (sıkıştırılmamış veri). + +## transfer\_overflow\_mode {#transfer-overflow-mode} + +Veri miktarı sınırlardan birini aştığında ne yapmalı: ‘throw’ veya ‘break’. Varsayılan olarak, atın. + +## max\_rows\_in\_join {#settings-max_rows_in_join} + +Tabloları birleştirirken kullanılan karma tablodaki satır sayısını sınırlar. + +Bu ayarlar aşağıdakiler için geçerlidir [SELECT … JOIN](../../sql_reference/statements/select.md#select-join) işlemleri ve [Katmak](../../engines/table_engines/special/join.md) masa motoru. + +Bir sorgu birden çok birleşim içeriyorsa, ClickHouse her Ara sonuç için bu ayarı denetler. + +Limit ulaşıldığında ClickHouse farklı eylemlerle devam edebilirsiniz. Kullan... [join\_overflow\_mode](#settings-join_overflow_mode) eylemi seçmek için ayarlama. + +Olası değerler: + +- Pozitif tamsayı. +- 0 — Unlimited number of rows. + +Varsayılan değer: 0. + +## max\_bytes\_in\_join {#settings-max_bytes_in_join} + +Tabloları birleştirirken kullanılan karma tablonun bayt cinsinden boyutunu sınırlar. + +Bu ayarlar aşağıdakiler için geçerlidir [SELECT … JOIN](../../sql_reference/statements/select.md#select-join) işlemleri ve [Jo tablein table engine](../../engines/table_engines/special/join.md). + +Sorgu birleşimler içeriyorsa, ClickHouse her Ara sonuç için bu ayarı denetler. + +Limit ulaşıldığında ClickHouse farklı eylemlerle devam edebilirsiniz. Kullanmak [join\_overflow\_mode](#settings-join_overflow_mode) eylemi seçmek için ayarlar. + +Olası değerler: + +- Pozitif tamsayı. +- 0 — Memory control is disabled. + +Varsayılan değer: 0. + +## join\_overflow\_mode {#settings-join_overflow_mode} + +Tanımlar katılın aşağıdaki sınırlar her zaman eylem ClickHouse gerçekleştirdiği ulaştı: + +- [max\_bytes\_in\_join](#settings-max_bytes_in_join) +- [max\_rows\_in\_join](#settings-max_rows_in_join) + +Olası değerler: + +- `THROW` — ClickHouse throws an exception and breaks operation. +- `BREAK` — ClickHouse breaks operation and doesn't throw an exception. + +Varsayılan değer: `THROW`. + +**Ayrıca Bakınız** + +- [Jo](../../sql_reference/statements/select.md#select-join) +- [Jo tablein table engine](../../engines/table_engines/special/join.md) + +## max\_partitions\_per\_ınsert\_block {#max-partitions-per-insert-block} + +Eklenen tek bir bloktaki en fazla bölüm sayısını sınırlar. + +- Pozitif tamsayı. +- 0 — Unlimited number of partitions. + +Varsayılan değer: 100. + +**Ayrıntı** + +Veri eklerken, ClickHouse eklenen bloktaki bölüm sayısını hesaplar. Bölüm sayısı fazla ise `max_partitions_per_insert_block`, ClickHouse aşağıdaki metinle bir özel durum atar: + +> “Too many partitions for single INSERT block (more than” + toString (max\_parts) + “). The limit is controlled by ‘max\_partitions\_per\_insert\_block’ setting. A large number of partitions is a common misconception. It will lead to severe negative performance impact, including slow server startup, slow INSERT queries and slow SELECT queries. Recommended total number of partitions for a table is under 1000..10000. Please note, that partitioning is not intended to speed up SELECT queries (ORDER BY key is sufficient to make range queries fast). Partitions are intended for data manipulation (DROP PARTITION, etc).” + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/settings/query_complexity/) diff --git a/docs/tr/operations/settings/settings.md b/docs/tr/operations/settings/settings.md new file mode 100644 index 00000000000..48e48ca00a6 --- /dev/null +++ b/docs/tr/operations/settings/settings.md @@ -0,0 +1,1235 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 60 +toc_title: Ayarlar +--- + +# Ayarlar {#settings} + +## distributed\_product\_mode {#distributed-product-mode} + +Davranışını değiştirir [dağıtılmış alt sorgular](../../sql_reference/statements/select.md). + +ClickHouse applies this setting when the query contains the product of distributed tables, i.e. when the query for a distributed table contains a non-GLOBAL subquery for the distributed table. + +Kısıtlama: + +- Yalnızca ın ve JOIN alt sorguları için uygulanır. +- Yalnızca FROM bölümü birden fazla parça içeren dağıtılmış bir tablo kullanıyorsa. +- Alt sorgu birden fazla parça içeren dağıtılmış bir tablo ile ilgiliyse. +- Bir tablo için kullanılmaz-değerli [uzak](../../sql_reference/table_functions/remote.md) işlev. + +Olası değerler: + +- `deny` — Default value. Prohibits using these types of subqueries (returns the “Double-distributed in/JOIN subqueries is denied” özel). +- `local` — Replaces the database and table in the subquery with local ones for the destination server (shard), leaving the normal `IN`/`JOIN.` +- `global` — Replaces the `IN`/`JOIN` ile sorgu `GLOBAL IN`/`GLOBAL JOIN.` +- `allow` — Allows the use of these types of subqueries. + +## enable\_optimize\_predicate\_expression {#enable-optimize-predicate-expression} + +Yüklemi pushdown açar `SELECT` sorgular. + +Yüklemi pushdown, dağıtılmış sorgular için ağ trafiğini önemli ölçüde azaltabilir. + +Olası değerler: + +- 0 — Disabled. +- 1 — Enabled. + +Varsayılan değer: 1. + +Kullanma + +Aşağıdaki sorguları düşünün: + +1. `SELECT count() FROM test_table WHERE date = '2018-10-10'` +2. `SELECT count() FROM (SELECT * FROM test_table) WHERE date = '2018-10-10'` + +Eğer `enable_optimize_predicate_expression = 1`, daha sonra bu sorguların yürütme süresi eşittir çünkü ClickHouse geçerlidir `WHERE` işlerken alt sorguya. + +Eğer `enable_optimize_predicate_expression = 0`, daha sonra ikinci sorgunun yürütme süresi çok daha uzundur, çünkü `WHERE` yan tümcesi alt sorgu tamamlandıktan sonra tüm veriler için geçerlidir. + +## fallback\_to\_stale\_replicas\_for\_distributed\_queries {#settings-fallback_to_stale_replicas_for_distributed_queries} + +Güncelleştirilmiş veriler mevcut değilse, bir sorgu için güncel olmayan bir yineleme zorlar. Görmek [Çoğalma](../../engines/table_engines/mergetree_family/replication.md). + +ClickHouse, tablonun eski kopyalarından en alakalı olanı seçer. + +Yaparken kullanılır `SELECT` çoğaltılmış tablolara işaret eden dağıtılmış bir tablodan. + +Varsayılan olarak, 1 (etkin). + +## force\_index\_by\_date {#settings-force_index_by_date} + +Dizin tarihe göre kullanılamıyorsa, sorgu yürütülmesini devre dışı bırakır. + +MergeTree ailesindeki tablolarla çalışır. + +Eğer `force_index_by_date=1`, ClickHouse sorgunun veri aralıklarını kısıtlamak için kullanılabilecek bir tarih anahtarı koşulu olup olmadığını denetler. Uygun bir koşul yoksa, bir istisna atar. Ancak, koşul okumak için veri miktarını azaltır olup olmadığını denetlemez. Örneğin, durum `Date != ' 2000-01-01 '` tablodaki tüm verilerle eşleştiğinde bile kabul edilebilir (yani, sorguyu çalıştırmak tam bir tarama gerektirir). MergeTree tablolarındaki veri aralıkları hakkında daha fazla bilgi için bkz. [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md). + +## force\_primary\_key {#force-primary-key} + +Birincil anahtar tarafından dizin oluşturma mümkün değilse, sorgu yürütülmesini devre dışı bırakır. + +MergeTree ailesindeki tablolarla çalışır. + +Eğer `force_primary_key=1`, ClickHouse, sorgunun veri aralıklarını kısıtlamak için kullanılabilecek bir birincil anahtar koşulu olup olmadığını denetler. Uygun bir koşul yoksa, bir istisna atar. Ancak, koşul okumak için veri miktarını azaltır olup olmadığını denetlemez. MergeTree tablolarındaki veri aralıkları hakkında daha fazla bilgi için bkz. [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md). + +## format\_schema {#format-schema} + +Bu parametre, aşağıdaki gibi bir şema tanımı gerektiren biçimler kullanırken kullanışlıdır [Cap'n Proto](https://capnproto.org/) veya [Protobuf](https://developers.google.com/protocol-buffers/). Değer biçime bağlıdır. + +## fsync\_metadata {#fsync-metadata} + +Etkinleştirir veya devre dışı bırakır [fsync](http://pubs.opengroup.org/onlinepubs/9699919799/functions/fsync.html) yazarken `.sql` eğe. Varsayılan olarak etkin. + +Sunucu, sürekli olarak oluşturulan ve yok edilen milyonlarca küçük tabloya sahipse, onu devre dışı bırakmak mantıklıdır. + +## enable\_http\_compression {#settings-enable_http_compression} + +Bir HTTP isteğine yanıt olarak veri sıkıştırmasını etkinleştirir veya devre dışı bırakır. + +Daha fazla bilgi için, okuyun [HTTP arayüzü açıklaması](../../interfaces/http.md). + +Olası değerler: + +- 0 — Disabled. +- 1 — Enabled. + +Varsayılan değer: 0. + +## http\_zlib\_compression\_level {#settings-http_zlib_compression_level} + +Eğer bir HTTP isteğine yanıt veri sıkıştırma düzeyini ayarlar [enable\_http\_compression = 1](#settings-enable_http_compression). + +Olası değerler: 1'den 9'a kadar olan sayılar. + +Varsayılan değer: 3. + +## http\_native\_compression\_disable\_checksumming\_on\_decompress {#settings-http_native_compression_disable_checksumming_on_decompress} + +İstemciden HTTP POST verilerini açarken sağlama toplamı doğrulamasını etkinleştirir veya devre dışı bırakır. Sadece ClickHouse yerel sıkıştırma formatı için kullanılır (ile kullanılmaz `gzip` veya `deflate`). + +Daha fazla bilgi için, okuyun [HTTP arayüzü açıklaması](../../interfaces/http.md). + +Olası değerler: + +- 0 — Disabled. +- 1 — Enabled. + +Varsayılan değer: 0. + +## send\_progress\_in\_http\_headers {#settings-send_progress_in_http_headers} + +Etkinleştirir veya devre dışı bırakır `X-ClickHouse-Progress` HTTP yanıt başlıkları `clickhouse-server` yanıtlar. + +Daha fazla bilgi için, okuyun [HTTP arayüzü açıklaması](../../interfaces/http.md). + +Olası değerler: + +- 0 — Disabled. +- 1 — Enabled. + +Varsayılan değer: 0. + +## max\_http\_get\_redirects {#setting-max_http_get_redirects} + +Maksimum http get yönlendirme atlama sayısını sınırlar [URL](../../engines/table_engines/special/url.md)- motor masaları. Ayarı tablolar iki tür tarafından oluşturulan bu geçerlidir: [CREATE TABLE](../../sql_reference/statements/create.md#create-table-query) sorgu ve [url](../../sql_reference/table_functions/url.md) tablo işlevi. + +Olası değerler: + +- Herhangi bir pozitif tamsayı şerbetçiotu sayısı. +- 0 — No hops allowed. + +Varsayılan değer: 0. + +## ınput\_format\_allow\_errors\_num {#settings-input_format_allow_errors_num} + +Metin biçimlerinden (CSV, TSV, vb.) okurken kabul edilebilir hataların maksimum sayısını ayarlar.). + +Varsayılan değer 0'dır. + +Her zaman ile eşleştirmek `input_format_allow_errors_ratio`. + +Satırları okurken bir hata oluştu, ancak hata sayacı hala daha az `input_format_allow_errors_num`, ClickHouse satırı yok sayar ve bir sonrakine geçer. + +Eğer her ikisi de `input_format_allow_errors_num` ve `input_format_allow_errors_ratio` aşıldı, ClickHouse bir istisna atar. + +## ınput\_format\_allow\_errors\_ratio {#settings-input_format_allow_errors_ratio} + +Metin biçimlerinden (CSV, TSV, vb.) okurken izin verilen maksimum hata yüzdesini ayarlar.). +Hataların yüzdesi 0 ile 1 arasında kayan nokta sayısı olarak ayarlanır. + +Varsayılan değer 0'dır. + +Her zaman ile eşleştirmek `input_format_allow_errors_num`. + +Satırları okurken bir hata oluştu, ancak hata sayacı hala daha az `input_format_allow_errors_ratio`, ClickHouse satırı yok sayar ve bir sonrakine geçer. + +Eğer her ikisi de `input_format_allow_errors_num` ve `input_format_allow_errors_ratio` aşıldı, ClickHouse bir istisna atar. + +## ınput\_format\_values\_interpret\_expressions {#settings-input_format_values_interpret_expressions} + +Hızlı akış ayrıştırıcısı verileri ayrıştıramazsa, tam SQL ayrıştırıcısını etkinleştirir veya devre dışı bırakır. Bu ayar yalnızca için kullanılır [Değerler](../../interfaces/formats.md#data-format-values) veri ekleme sırasında biçimlendirin. Sözdizimi ayrıştırma hakkında daha fazla bilgi için bkz: [Sözdizimi](../../sql_reference/syntax.md) bölme. + +Olası değerler: + +- 0 — Disabled. + + Bu durumda, biçimlendirilmiş veri sağlamanız gerekir. Görmek [Biçimliler](../../interfaces/formats.md) bölme. + +- 1 — Enabled. + + Bu durumda, bir SQL ifadesini bir değer olarak kullanabilirsiniz, ancak veri ekleme bu şekilde çok daha yavaştır. Yalnızca biçimlendirilmiş veri eklerseniz, ClickHouse ayar değeri 0 gibi davranır. + +Varsayılan değer: 1. + +Kullanım örneği + +Ekle [DateTime](../../sql_reference/data_types/datetime.md) farklı ayarlarla değer yazın. + +``` sql +SET input_format_values_interpret_expressions = 0; +INSERT INTO datetime_t VALUES (now()) +``` + +``` text +Exception on client: +Code: 27. DB::Exception: Cannot parse input: expected ) before: now()): (at row 1) +``` + +``` sql +SET input_format_values_interpret_expressions = 1; +INSERT INTO datetime_t VALUES (now()) +``` + +``` text +Ok. +``` + +Son sorgu Aşağıdakilere eşdeğerdir: + +``` sql +SET input_format_values_interpret_expressions = 0; +INSERT INTO datetime_t SELECT now() +``` + +``` text +Ok. +``` + +## ınput\_format\_values\_deduce\_templates\_of\_expressions {#settings-input_format_values_deduce_templates_of_expressions} + +SQL deyimleri için şablon kesintisini etkinleştirir veya devre dışı bırakır [Değerler](../../interfaces/formats.md#data-format-values) biçimli. Bu ayrıştırma ve ifadeleri yorumlama sağlar `Values` ardışık satırlardaki ifadeler aynı yapıya sahipse çok daha hızlı. ClickHouse, bir ifadenin şablonunu çıkarmaya, bu şablonu kullanarak aşağıdaki satırları ayrıştırmaya ve ifadeyi başarılı bir şekilde ayrıştırılmış satırların bir yığınında değerlendirmeye çalışır. + +Olası değerler: + +- 0 — Disabled. +- 1 — Enabled. + +Varsayılan değer: 1. + +Aşağıdaki sorgu için: + +``` sql +INSERT INTO test VALUES (lower('Hello')), (lower('world')), (lower('INSERT')), (upper('Values')), ... +``` + +- Eğer `input_format_values_interpret_expressions=1` ve `format_values_deduce_templates_of_expressions=0`, ifadeler her satır için ayrı ayrı yorumlanır (bu çok sayıda satır için çok yavaştır). +- Eğer `input_format_values_interpret_expressions=0` ve `format_values_deduce_templates_of_expressions=1`, birinci, ikinci ve üçüncü satırlardaki ifadeler şablon kullanılarak ayrıştırılır `lower(String)` ve birlikte yorumlanır, ileri satırdaki ifade başka bir şablonla ayrıştırılır (`upper(String)`). +- Eğer `input_format_values_interpret_expressions=1` ve `format_values_deduce_templates_of_expressions=1`, önceki durumda olduğu gibi aynı, ama aynı zamanda şablon anlamak mümkün değilse ayrı ayrı ifadeleri yorumlama geri dönüş sağlar. + +## ınput\_format\_values\_accurate\_types\_of\_literals {#settings-input-format-values-accurate-types-of-literals} + +Bu ayar yalnızca şu durumlarda kullanılır `input_format_values_deduce_templates_of_expressions = 1`. Bu, bazı sütunların ifadelerinin aynı yapıya sahip olması, ancak farklı türlerde sayısal değişmezler içermesi olabilir, örneğin + +``` sql +(..., abs(0), ...), -- UInt64 literal +(..., abs(3.141592654), ...), -- Float64 literal +(..., abs(-1), ...), -- Int64 literal +``` + +Olası değerler: + +- 0 — Disabled. + + In this case, ClickHouse may use a more general type for some literals (e.g., `Float64` veya `Int64` yerine `UInt64` için `42`), ancak taşma ve hassasiyet sorunlarına neden olabilir. + +- 1 — Enabled. + + Bu durumda, ClickHouse gerçek literal türünü denetler ve karşılık gelen türde bir ifade şablonu kullanır. Bazı durumlarda, ifade değerlendirmesini önemli ölçüde yavaşlatabilir `Values`. + +Varsayılan değer: 1. + +## ınput\_format\_defaults\_for\_omitted\_fields {#session_settings-input_format_defaults_for_omitted_fields} + +Yaparken `INSERT` sorgular, atlanmış giriş sütun değerlerini ilgili sütunların varsayılan değerleriyle değiştirin. Bu seçenek yalnızca aşağıdakiler için geçerlidir [JSONEachRow](../../interfaces/formats.md#jsoneachrow), [CSV](../../interfaces/formats.md#csv) ve [TabSeparated](../../interfaces/formats.md#tabseparated) biçimliler. + +!!! note "Not" + Bu seçenek etkinleştirildiğinde, genişletilmiş tablo meta verileri sunucudan istemciye gönderilir. Sunucuda ek bilgi işlem kaynakları tüketir ve performansı azaltabilir. + +Olası değerler: + +- 0 — Disabled. +- 1 — Enabled. + +Varsayılan değer: 1. + +## ınput\_format\_tsv\_empty\_as\_default {#settings-input-format-tsv-empty-as-default} + +Etkinleştirildiğinde, TSV'DEKİ boş giriş alanlarını varsayılan değerlerle değiştirin. Karmaşık varsayılan ifadeler için `input_format_defaults_for_omitted_fields` de etkin olmalıdır. + +Varsayılan olarak devre dışı. + +## ınput\_format\_null\_as\_default {#settings-input-format-null-as-default} + +Giriş verileri içeriyorsa, varsayılan değerleri kullanarak etkinleştirir veya devre dışı bırakır `NULL`, ancak ilgili sütunun veri türü değil `Nullable(T)` (Metin Giriş biçimleri için). + +## ınput\_format\_skip\_unknown\_fields {#settings-input-format-skip-unknown-fields} + +Etkinleştirir veya ek veri ekleme atlama devre dışı bırakır. + +Veri yazarken, giriş verileri hedef tabloda bulunmayan sütunlar içeriyorsa, ClickHouse bir özel durum atar. Atlama etkinleştirilirse, ClickHouse ek veri eklemez ve bir istisna atmaz. + +Desteklenen formatlar: + +- [JSONEachRow](../../interfaces/formats.md#jsoneachrow) +- [CSVWithNames](../../interfaces/formats.md#csvwithnames) +- [TabSeparatedWithNames](../../interfaces/formats.md#tabseparatedwithnames) +- [TSKV](../../interfaces/formats.md#tskv) + +Olası değerler: + +- 0 — Disabled. +- 1 — Enabled. + +Varsayılan değer: 0. + +## ınput\_format\_ımport\_nested\_json {#settings-input_format_import_nested_json} + +Json verilerinin iç içe nesnelerle eklenmesini etkinleştirir veya devre dışı bırakır. + +Desteklenen formatlar: + +- [JSONEachRow](../../interfaces/formats.md#jsoneachrow) + +Olası değerler: + +- 0 — Disabled. +- 1 — Enabled. + +Varsayılan değer: 0. + +Ayrıca bakınız: + +- [İç içe yapıların kullanımı](../../interfaces/formats.md#jsoneachrow-nested) ile... `JSONEachRow` biçimli. + +## ınput\_format\_with\_names\_use\_header {#settings-input-format-with-names-use-header} + +Veri eklerken sütun sırasını denetlemeyi etkinleştirir veya devre dışı bırakır. + +Ekleme performansını artırmak için, giriş verilerinin sütun sırasının hedef tablodaki ile aynı olduğundan eminseniz, bu denetimi devre dışı bırakmanızı öneririz. + +Desteklenen formatlar: + +- [CSVWithNames](../../interfaces/formats.md#csvwithnames) +- [TabSeparatedWithNames](../../interfaces/formats.md#tabseparatedwithnames) + +Olası değerler: + +- 0 — Disabled. +- 1 — Enabled. + +Varsayılan değer: 1. + +## date\_time\_input\_format {#settings-date_time_input_format} + +Tarih ve saat metin gösterimi bir ayrıştırıcı seçme sağlar. + +Ayar için geçerli değildir [tarih ve saat fonksiyonları](../../sql_reference/functions/date_time_functions.md). + +Olası değerler: + +- `'best_effort'` — Enables extended parsing. + + ClickHouse temel ayrıştırmak `YYYY-MM-DD HH:MM:SS` format ve tüm [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601) tarih ve saat biçimleri. Mesela, `'2018-06-08T01:02:03.000Z'`. + +- `'basic'` — Use basic parser. + + ClickHouse sadece temel ayrıştırmak `YYYY-MM-DD HH:MM:SS` biçimli. Mesela, `'2019-08-20 10:18:56'`. + +Varsayılan değer: `'basic'`. + +Ayrıca bakınız: + +- [DateTime veri türü.](../../sql_reference/data_types/datetime.md) +- [Tarihler ve saatler ile çalışmak için fonksiyonlar.](../../sql_reference/functions/date_time_functions.md) + +## join\_default\_strictness {#settings-join_default_strictness} + +Ayarlar varsayılan strictness için [Maddeleri KATILIN ](../../sql_reference/statements/select.md#select-join). + +Olası değerler: + +- `ALL` — If the right table has several matching rows, ClickHouse creates a [Kartezyen ürün](https://en.wikipedia.org/wiki/Cartesian_product) eşleşen satırlardan. Bu normaldir `JOIN` standart SQL'DEN davranış. +- `ANY` — If the right table has several matching rows, only the first one found is joined. If the right table has only one matching row, the results of `ANY` ve `ALL` aynı. +- `ASOF` — For joining sequences with an uncertain match. +- `Empty string` — If `ALL` veya `ANY` sorguda belirtilmezse, ClickHouse bir özel durum atar. + +Varsayılan değer: `ALL`. + +## join\_any\_take\_last\_row {#settings-join_any_take_last_row} + +İle birleştirme işlemlerinin davranışını değiştirir `ANY` katılık. + +!!! warning "Dikkat" + Bu ayar yalnızca aşağıdakiler için geçerlidir `JOIN` ile işlemler [Katmak](../../engines/table_engines/special/join.md) motor tabloları. + +Olası değerler: + +- 0 — If the right table has more than one matching row, only the first one found is joined. +- 1 — If the right table has more than one matching row, only the last one found is joined. + +Varsayılan değer: 0. + +Ayrıca bakınız: + +- [Jo](../../sql_reference/statements/select.md#select-join) +- [Jo tablein table engine](../../engines/table_engines/special/join.md) +- [join\_default\_strictness](#settings-join_default_strictness) + +## join\_use\_nulls {#join_use_nulls} + +Türünü ayarlar [JOIN](../../sql_reference/statements/select.md) davranış. Tabloları birleştirirken boş hücreler görünebilir. ClickHouse bu ayara göre onları farklı şekilde doldurur. + +Olası değerler: + +- 0 — The empty cells are filled with the default value of the corresponding field type. +- 1 — `JOIN` standart SQL ile aynı şekilde davranır. Karşılık gelen alanın türü dönüştürülür [Nullable](../../sql_reference/data_types/nullable.md#data_type-nullable) ve boş hücreler ile doldurulur [NULL](../../sql_reference/syntax.md). + +Varsayılan değer: 0. + +## max\_block\_size {#setting-max_block_size} + +Clickhouse'da, veriler bloklarla (sütun parçaları kümeleri) işlenir. Tek bir blok için dahili işlem döngüleri yeterince verimlidir, ancak her blokta gözle görülür harcamalar vardır. Bu `max_block_size` ayar, blokun boyutunun (satır sayımında) tablolardan yükleneceği bir öneridir. Blok boyutu çok küçük olmamalı, böylece her bloktaki harcamalar hala fark edilebilir, ancak çok büyük olmamalı, böylece ilk blok hızla işlendikten sonra tamamlanan limitli sorgu çok büyük olmamalıdır. Amaç, birden çok iş parçacığında çok sayıda sütun ayıklarken çok fazla bellek tüketmekten kaçınmak ve en azından bazı önbellek konumlarını korumaktır. + +Varsayılan değer: 65,536. + +Blok boyutu `max_block_size` her zaman tablodan yüklenmez. Daha az verinin alınması gerektiği açıksa, daha küçük bir blok işlenir. + +## preferred\_block\_size\_bytes {#preferred-block-size-bytes} + +Olarak aynı amaç için kullanılır `max_block_size`, ancak önerilen blok boyutunu bayt cinsinden, bloktaki satır sayısına uyarlayarak ayarlar. +Ancak, blok boyutu daha fazla olamaz `max_block_size` satırlar. +Varsayılan olarak: 1.000.000. Sadece MergeTree motorlarından okurken çalışır. + +## merge\_tree\_mın\_rows\_for\_concurrent\_read {#setting-merge-tree-min-rows-for-concurrent-read} + +Bir dosyadan okunacak satır sayısı ise [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md) tablo aşıyor `merge_tree_min_rows_for_concurrent_read` daha sonra ClickHouse, bu dosyadan birkaç iş parçacığı üzerinde eşzamanlı bir okuma gerçekleştirmeye çalışır. + +Olası değerler: + +- Herhangi bir pozitif tamsayı. + +Varsayılan değer: 163840. + +## merge\_tree\_min\_bytes\_for\_concurrent\_read {#setting-merge-tree-min-bytes-for-concurrent-read} + +Eğer bir dosyadan okunacak bayt sayısı [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md)- motor tablosu `merge_tree_min_bytes_for_concurrent_read`, daha sonra ClickHouse, bu dosyadan aynı anda birkaç iş parçacığında okumaya çalışır. + +Olası değer: + +- Herhangi bir pozitif tamsayı. + +Varsayılan değer: 251658240. + +## merge\_tree\_mın\_rows\_for\_seek {#setting-merge-tree-min-rows-for-seek} + +Bir dosyada okunacak iki veri bloğu arasındaki mesafe daha az ise `merge_tree_min_rows_for_seek` satırlar, daha sonra ClickHouse dosyayı aramaz, ancak verileri sırayla okur. + +Olası değerler: + +- Herhangi bir pozitif tamsayı. + +Varsayılan değer: 0. + +## merge\_tree\_min\_bytes\_for\_seek {#setting-merge-tree-min-bytes-for-seek} + +Bir dosyada okunacak iki veri bloğu arasındaki mesafe daha az ise `merge_tree_min_bytes_for_seek` bayt, daha sonra ClickHouse sırayla böylece ekstra arama kaçınarak, her iki blok içeren bir dosya aralığını okur. + +Olası değerler: + +- Herhangi bir pozitif tamsayı. + +Varsayılan değer: 0. + +## merge\_tree\_coarse\_index\_granularity {#setting-merge-tree-coarse-index-granularity} + +Veri ararken, ClickHouse dizin dosyasındaki veri işaretlerini denetler. ClickHouse gerekli tuşların bazı aralıklarda olduğunu bulursa, bu aralığı `merge_tree_coarse_index_granularity` subranges ve gerekli anahtarları orada yinelemeli olarak arar. + +Olası değerler: + +- Herhangi bir pozitif bile tamsayı. + +Varsayılan değer: 8. + +## merge\_tree\_max\_rows\_to\_use\_cache {#setting-merge-tree-max-rows-to-use-cache} + +ClickHouse daha fazla okumak gerekiyorsa `merge_tree_max_rows_to_use_cache` bir sorgudaki satırlar, sıkıştırılmamış blokların önbelleğini kullanmaz. + +Sıkıştırılmamış blokların önbelleği, sorgular için ayıklanan verileri depolar. ClickHouse, tekrarlanan küçük sorgulara verilen yanıtları hızlandırmak için bu önbelleği kullanır. Bu ayar, önbelleğin büyük miktarda veri okuyan sorgularla çöpe atmasını önler. Bu [uncompressed\_cache\_size](../server_configuration_parameters/settings.md#server-settings-uncompressed_cache_size) sunucu ayarı, sıkıştırılmamış blokların önbelleğinin boyutunu tanımlar. + +Olası değerler: + +- Herhangi bir pozitif tamsayı. + +Default value: 128 ✕ 8192. + +## merge\_tree\_max\_bytes\_to\_use\_cache {#setting-merge-tree-max-bytes-to-use-cache} + +ClickHouse daha fazla okumak gerekiyorsa `merge_tree_max_bytes_to_use_cache` bir sorguda bayt, sıkıştırılmamış blokların önbelleğini kullanmaz. + +Sıkıştırılmamış blokların önbelleği, sorgular için ayıklanan verileri depolar. ClickHouse, tekrarlanan küçük sorgulara verilen yanıtları hızlandırmak için bu önbelleği kullanır. Bu ayar, önbelleğin büyük miktarda veri okuyan sorgularla çöpe atmasını önler. Bu [uncompressed\_cache\_size](../server_configuration_parameters/settings.md#server-settings-uncompressed_cache_size) sunucu ayarı, sıkıştırılmamış blokların önbelleğinin boyutunu tanımlar. + +Olası değer: + +- Herhangi bir pozitif tamsayı. + +Varsayılan değer: 2013265920. + +## min\_bytes\_to\_use\_direct\_io {#settings-min-bytes-to-use-direct-io} + +Depolama diskine Doğrudan G/Ç erişimi kullanmak için gereken minimum veri hacmi. + +ClickHouse, tablolardan veri okurken bu ayarı kullanır. Okunacak tüm verilerin toplam depolama hacmi aşarsa `min_bytes_to_use_direct_io` bayt, daha sonra ClickHouse ile depolama diskinden veri okur `O_DIRECT` seçenek. + +Olası değerler: + +- 0 — Direct I/O is disabled. +- Pozitif tamsayı. + +Varsayılan değer: 0. + +## log\_queries {#settings-log-queries} + +Sorgu günlüğü ayarlama. + +Bu kurulum ile Clickhouse'a gönderilen sorgular, [query\_log](../server_configuration_parameters/settings.md#server_configuration_parameters-query-log) sunucu yapılandırma parametresi. + +Örnek: + +``` text +log_queries=1 +``` + +## log\_queries\_min\_type {#settings-log-queries-min-type} + +`query_log` giriş yapmak için en az tür. + +Olası değerler: +- `QUERY_START` (`=1`) +- `QUERY_FINISH` (`=2`) +- `EXCEPTION_BEFORE_START` (`=3`) +- `EXCEPTION_WHILE_PROCESSING` (`=4`) + +Varsayılan değer: `QUERY_START`. + +Entiries gider hangi sınırlamak için kullanılabilir `query_log`, sadece hatalarda ilginç olduğunuzu söyleyin, o zaman kullanabilirsiniz `EXCEPTION_WHILE_PROCESSING`: + +``` text +log_queries_min_type='EXCEPTION_WHILE_PROCESSING' +``` + +## log\_query\_threads {#settings-log-query-threads} + +Sorgu iş parçacığı günlüğü ayarlama. + +Bu kurulum ile ClickHouse tarafından çalıştırılan sorguların konuları, [query\_thread\_log](../server_configuration_parameters/settings.md#server_configuration_parameters-query-thread-log) sunucu yapılandırma parametresi. + +Örnek: + +``` text +log_query_threads=1 +``` + +## max\_ınsert\_block\_size {#settings-max_insert_block_size} + +Bir tabloya eklemek için oluşturulacak blokların boyutu. +Bu ayar yalnızca sunucu blokları oluşturduğu durumlarda geçerlidir. +Örneğin, HTTP arabirimi üzerinden bir ekleme için sunucu veri biçimini ayrıştırır ve belirtilen boyuttaki blokları oluşturur. +Ancak, clickhouse-client kullanırken, istemci verileri kendisi ayrıştırır ve ‘max\_insert\_block\_size’ sunucudaki ayar, eklenen blokların boyutunu etkilemez. +Veri SELECT sonra oluşturulan aynı blokları kullanarak eklendiğinden, INSERT SELECT kullanırken ayarı da bir amacı yoktur. + +Varsayılan değer: 1.048,576. + +Varsayılan biraz daha fazla `max_block_size`. Bunun nedeni, bazı tablo motorlarının (`*MergeTree`) oldukça büyük bir varlık olan eklenen her blok için diskte bir veri parçası oluşturun. Benzer bir şekilde, `*MergeTree` tablolar ekleme sırasında verileri sıralar ve yeterince büyük bir blok boyutu RAM'de daha fazla veriyi sıralamaya izin verir. + +## max\_replica\_delay\_for\_distributed\_queries {#settings-max_replica_delay_for_distributed_queries} + +Dağıtılmış sorgular için gecikmeli yinelemeleri devre dışı bırakır. Görmek [Çoğalma](../../engines/table_engines/mergetree_family/replication.md). + +Saati saniye olarak ayarlar. Bir çoğaltma ayarlanan değerden daha fazla kalıyorsa, Bu çoğaltma kullanılmaz. + +Varsayılan değer: 300. + +Yaparken kullanılır `SELECT` çoğaltılmış tablolara işaret eden dağıtılmış bir tablodan. + +## max\_threads {#settings-max_threads} + +Uzak sunuculardan veri almak için iş parçacıkları hariç olmak üzere sorgu işleme iş parçacıklarının maksimum sayısı (bkz. ‘max\_distributed\_connections’ parametre). + +Bu parametre, paralel olarak sorgu işleme ardışık düzeninin aynı aşamalarını gerçekleştiren iş parçacıkları için geçerlidir. +Örneğin, bir tablodan okurken, ifadeleri işlevlerle değerlendirmek mümkün ise, en azından paralel olarak grup için where ve pre-aggregate ile filtreleyin ‘max\_threads’ konu sayısı, daha sonra ‘max\_threads’ kullanılır. + +Varsayılan değer: fiziksel CPU çekirdeği sayısı. + +Bir kerede bir sunucuda normal olarak birden az SELECT sorgusu çalıştırılırsa, bu parametreyi gerçek işlemci çekirdeği sayısından biraz daha küçük bir değere ayarlayın. + +Bir sınır nedeniyle hızlı bir şekilde tamamlanan sorgular için, daha düşük bir ‘max\_threads’. Örneğin, gerekli sayıda giriş her blokta ve max\_threads = 8'de bulunuyorsa, sadece bir tane okumak için yeterli olsa da, 8 blok alınır. + +Daha küçük `max_threads` değer, daha az bellek tüketilir. + +## max\_ınsert\_threads {#settings-max-insert-threads} + +Çalıştırılacak maksimum iş parçacığı sayısı `INSERT SELECT` sorgu. + +Olası değerler: + +- 0 (or 1) — `INSERT SELECT` paralel infaz yok. +- Pozitif tamsayı. 1'den büyük. + +Varsayılan değer: 0. + +Paralellik `INSERT SELECT` etkisi vardır sadece eğer `SELECT` bölüm paralel olarak yürütülür, bkz [max\_threads](#settings-max_threads) ayar. +Daha yüksek değerler daha yüksek bellek kullanımına yol açacaktır. + +## max\_compress\_block\_size {#max-compress-block-size} + +Bir tabloya yazmak için sıkıştırmadan önce sıkıştırılmamış veri bloklarının en büyük boyutu. Varsayılan olarak, 1.048.576 (1 MiB). Boyut azaltılırsa, sıkıştırma oranı önemli ölçüde azalır, önbellek konumu nedeniyle sıkıştırma ve dekompresyon hızı biraz artar ve bellek tüketimi azalır. Bu ayarı değiştirmek için genellikle herhangi bir neden yoktur. + +Sıkıştırma için blokları (bayttan oluşan bir bellek yığını) sorgu işleme için bloklarla (bir tablodan satır kümesi) karıştırmayın. + +## min\_compress\_block\_size {#min-compress-block-size} + +İçin [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md)" Tablolar. Sorguları işlerken gecikmeyi azaltmak için, boyutu en az bir sonraki işareti yazarken bir blok sıkıştırılır ‘min\_compress\_block\_size’. Varsayılan olarak, 65.536. + +Sıkıştırılmamış veriler daha az ise, bloğun gerçek boyutu ‘max\_compress\_block\_size’, bu değerden daha az değildir ve bir işaret için veri hacminden daha az değildir. + +Bir örneğe bakalım. Varsaymak ‘index\_granularity’ tablo oluşturma sırasında 8192 olarak ayarlandı. + +Bir uint32 tipi sütun yazıyoruz (değer başına 4 bayt). 8192 satır yazarken, toplam 32 KB veri olacaktır. Min\_compress\_block\_size = 65.536 olduğundan, her iki işaret için sıkıştırılmış bir blok oluşturulacaktır. + +Dize türüne sahip bir URL sütunu yazıyoruz (değer başına ortalama 60 bayt boyutu). 8192 satır yazarken, ortalama 500 KB veri biraz daha az olacaktır. Bu 65,536'dan fazla olduğu için, her işaret için sıkıştırılmış bir blok oluşturulacaktır. Bu durumda, diskteki verileri tek bir işaret aralığında okurken, ekstra veriler sıkıştırılmaz. + +Bu ayarı değiştirmek için genellikle herhangi bir neden yoktur. + +## max\_query\_size {#settings-max_query_size} + +SQL ayrıştırıcısı ile ayrıştırmak için RAM'e alınabilecek bir sorgunun en büyük kısmı. +INSERT sorgusu, bu kısıtlamaya dahil olmayan ayrı bir akış ayrıştırıcısı (o(1) RAM tüketir) tarafından işlenen INSERT için veri de içerir. + +Varsayılan değer: 256 KiB. + +## ınteractive\_delay {#interactive-delay} + +İstek yürütülmesinin iptal edilip edilmediğini kontrol etmek ve ilerlemeyi göndermek için mikrosaniye cinsinden Aralık. + +Varsayılan değer: 100.000 (iptal için denetler ve ilerleme saniyede on kez gönderir). + +## connect\_timeout, receıve\_tımeout, send\_timeout {#connect-timeout-receive-timeout-send-timeout} + +İstemci ile iletişim kurmak için kullanılan sokette saniye cinsinden zaman aşımları. + +Varsayılan değer: 10, 300, 300. + +## cancel\_http\_readonly\_queries\_on\_client\_close {#cancel-http-readonly-queries-on-client-close} + +Cancels HTTP read-only queries (e.g. SELECT) when a client closes the connection without waiting for the response. + +Varsayılan değer: 0 + +## poll\_interval {#poll-interval} + +Belirtilen saniye sayısı için bir bekleme döngüsünde kilitleyin. + +Varsayılan değer: 10. + +## max\_distributed\_connections {#max-distributed-connections} + +Tek bir dağıtılmış tabloya tek bir sorgunun dağıtılmış işlenmesi için uzak sunucularla eşzamanlı bağlantı sayısı. Kümedeki sunucu sayısından daha az bir değer ayarlamanızı öneririz. + +Varsayılan değer: 1024. + +Aşağıdaki parametreler yalnızca dağıtılmış tablolar oluştururken (ve bir sunucu başlatırken) kullanılır, bu nedenle bunları çalışma zamanında değiştirmek için hiçbir neden yoktur. + +## distributed\_connections\_pool\_size {#distributed-connections-pool-size} + +Tüm sorguların tek bir dağıtılmış tabloya dağıtılmış işlenmesi için uzak sunucularla eşzamanlı bağlantıların maksimum sayısı. Kümedeki sunucu sayısından daha az bir değer ayarlamanızı öneririz. + +Varsayılan değer: 1024. + +## connect\_timeout\_with\_failover\_ms {#connect-timeout-with-failover-ms} + +Dağıtılmış bir tablo altyapısı için uzak bir sunucuya bağlanmak için milisaniye cinsinden zaman aşımı ‘shard’ ve ‘replica’ bölümler küme tanımında kullanılır. +Başarısız olursa, çeşitli yinelemelere bağlanmak için birkaç deneme yapılır. + +Varsayılan değer: 50. + +## connections\_with\_failover\_max\_tries {#connections-with-failover-max-tries} + +Dağıtılmış tablo altyapısı için her yineleme ile bağlantı girişimi sayısı. + +Varsayılan değer: 3. + +## çıkmaz {#extremes} + +Aşırı değerleri (bir sorgu sonucunun sütunlarındaki minimum ve maksimum değerler) saymak ister. 0 veya 1 kabul eder. Varsayılan olarak, 0 (devre dışı). +Daha fazla bilgi için bölüme bakın “Extreme values”. + +## use\_uncompressed\_cache {#setting-use_uncompressed_cache} + +Sıkıştırılmamış blokların önbelleğinin kullanılıp kullanılmayacağı. 0 veya 1 kabul eder. Varsayılan olarak, 0 (devre dışı). +Sıkıştırılmamış önbelleği (yalnızca mergetree ailesindeki tablolar için) kullanmak, çok sayıda kısa Sorgu ile çalışırken gecikmeyi önemli ölçüde azaltabilir ve verimi artırabilir. Sık sık kısa istek Gönderen kullanıcılar için bu ayarı etkinleştirin. Ayrıca dikkat [uncompressed\_cache\_size](../server_configuration_parameters/settings.md#server-settings-uncompressed_cache_size) configuration parameter (only set in the config file) – the size of uncompressed cache blocks. By default, it is 8 GiB. The uncompressed cache is filled in as needed and the least-used data is automatically deleted. + +En azından biraz büyük bir veri hacmi (bir milyon satır veya daha fazla) okuyan sorgular için sıkıştırılmamış önbellek, gerçekten küçük sorgular için yer kazanmak için otomatik olarak devre dışı bırakılır. Bu tutmak anlamına gelir ‘use\_uncompressed\_cache’ ayar her zaman 1 olarak ayarlanır. + +## replace\_running\_query {#replace-running-query} + +HTTP arayüzünü kullanırken, ‘query\_id’ parametre geçirilebilir. Bu, sorgu tanımlayıcısı olarak hizmet veren herhangi bir dizedir. +Aynı kullanıcıdan aynı sorgu varsa ‘query\_id’ zaten şu anda var, davranış bağlıdır ‘replace\_running\_query’ parametre. + +`0` (default) – Throw an exception (don't allow the query to run if a query with the same ‘query\_id’ zaten çalışan) var. + +`1` – Cancel the old query and start running the new one. + +Üye.Metrica, segmentasyon koşulları için öneriler uygulamak için 1 olarak ayarlanmış bu parametreyi kullanır. Bir sonraki karakteri girdikten sonra, eski sorgu henüz tamamlanmamışsa, iptal edilmelidir. + +## stream\_flush\_interval\_ms {#stream-flush-interval-ms} + +Bir zaman aşımı durumunda akışlı tablolar için çalışır veya bir iş parçacığı oluşturduğunda [max\_ınsert\_block\_size](#settings-max_insert_block_size) satırlar. + +Varsayılan değer 7500'dür. + +Küçük değer, daha sık veri tablosuna temizlendi. Değeri çok düşük ayarlamak, düşük performansa yol açar. + +## dengeleme {#settings-load_balancing} + +Dağıtılmış sorgu işleme için kullanılan yinelemeler seçimi algoritmasını belirtir. + +ClickHouse kopyaları seçme aşağıdaki algoritmaları destekler: + +- [Rastgele](#load_balancing-random) (varsayılan olarak) +- [En yakın hostnamename](#load_balancing-nearest_hostname) +- [Sıralı](#load_balancing-in_order) +- [İlk veya rastgele](#load_balancing-first_or_random) + +### Rastgele (varsayılan olarak) {#load_balancing-random} + +``` sql +load_balancing = random +``` + +Her yineleme için hata sayısı sayılır. Sorgu, en az hata ile çoğaltmaya gönderilir ve bunlardan birkaçı varsa, bunlardan herhangi birine gönderilir. +Dezavantajları: sunucu yakınlık hesaba değil; kopyaları farklı veri varsa, aynı zamanda farklı veri alırsınız. + +### En Yakın Hostnamename {#load_balancing-nearest_hostname} + +``` sql +load_balancing = nearest_hostname +``` + +The number of errors is counted for each replica. Every 5 minutes, the number of errors is integrally divided by 2. Thus, the number of errors is calculated for a recent time with exponential smoothing. If there is one replica with a minimal number of errors (i.e. errors occurred recently on the other replicas), the query is sent to it. If there are multiple replicas with the same minimal number of errors, the query is sent to the replica with a hostname that is most similar to the server's hostname in the config file (for the number of different characters in identical positions, up to the minimum length of both hostnames). + +Örneğin, example01-01-1 ve example01-01-2.yandex.ru bir pozisyonda farklıdır, örneği01-01-1 ve örneği01-02-2 iki yerde farklılık gösterir. +Bu yöntem ilkel görünebilir, ancak ağ topolojisi hakkında harici veri gerektirmez ve IPv6 adreslerimiz için karmaşık olan IP adreslerini karşılaştırmaz. + +Bu nedenle, eşdeğer yinelemeler varsa, isme göre en yakın olanı tercih edilir. +Aynı sunucuya bir sorgu gönderirken, arızaların yokluğunda, dağıtılmış bir sorgunun da aynı sunuculara gideceğini varsayabiliriz. Bu nedenle, yinelemelere farklı veriler yerleştirilse bile, sorgu çoğunlukla aynı sonuçları döndürür. + +### Sıralı {#load_balancing-in_order} + +``` sql +load_balancing = in_order +``` + +Yapılandırmada belirtilen hataları aynı sayıda yinelemeler aynı sırayla erişilir. +Bu yöntem, tam olarak hangi kopyanın tercih edildiğini bildiğinizde uygundur. + +### İlk veya rastgele {#load_balancing-first_or_random} + +``` sql +load_balancing = first_or_random +``` + +İlk kullanılamaz, bu algoritma kümesindeki ilk yineleme veya rasgele bir yineleme seçer. Çapraz çoğaltma topolojisi kurulumlarında etkilidir, ancak diğer yapılandırmalarda işe yaramaz. + +Bu `first_or_random` algoritma sorunu çözer `in_order` algoritma. İle `in_order`, bir çoğaltma aşağı giderse, kalan yinelemeler normal trafik miktarını işlerken bir sonraki bir çift yük alır. Kullanırken `first_or_random` algoritma, yük hala mevcut olan kopyalar arasında eşit olarak dağıtılır. + +## prefer\_localhost\_replica {#settings-prefer-localhost-replica} + +Etkinleştirir / devre dışı bırakır tercih kullanarak localhost çoğaltma dağıtılmış sorguları işlerken. + +Olası değerler: + +- 1 — ClickHouse always sends a query to the localhost replica if it exists. +- 0 — ClickHouse uses the balancing strategy specified by the [dengeleme](#settings-load_balancing) ayar. + +Varsayılan değer: 1. + +!!! warning "Uyarıcı" + Kullanıyorsanız bu ayarı devre dışı bırakın [max\_parallel\_replicas](#settings-max_parallel_replicas). + +## totals\_mode {#totals-mode} + +MAX\_ROWS\_TO\_GROUP\_BY ve group\_by\_overflow\_mode = ‘any’ Bulunmak. +Bölümüne bakınız “WITH TOTALS modifier”. + +## totals\_auto\_threshold {#totals-auto-threshold} + +İçin eşik `totals_mode = 'auto'`. +Bölümüne bakınız “WITH TOTALS modifier”. + +## max\_parallel\_replicas {#settings-max_parallel_replicas} + +Bir sorgu yürütülürken her parça için en fazla yineleme sayısı. +Tutarlılık için (aynı veri bölünmesinin farklı bölümlerini elde etmek için), bu seçenek yalnızca örnekleme anahtarı ayarlandığında çalışır. +Çoğaltma gecikme denetlenmez. + +## derlemek {#compile} + +Sorguların derlenmesini etkinleştirin. Varsayılan olarak, 0 (devre dışı). + +Derleme yalnızca sorgu işleme boru hattının bir parçası için kullanılır: toplamanın ilk aşaması için (GROUP BY). +Potansiyel hattın bu bölümü derlenmişse, sorgu, kısa döngüleri ve inlining toplu işlev çağrılarının dağıtımı nedeniyle daha hızlı çalışabilir. Birden çok basit toplama işlevine sahip sorgular için maksimum performans artışı (nadir durumlarda dört kata kadar daha hızlı) görülür. Tipik olarak, performans kazancı önemsİzdİr. Çok nadir durumlarda, sorgu yürütülmesini yavaşlatabilir. + +## min\_count\_to\_compile {#min-count-to-compile} + +Derleme çalıştırmadan önce derlenmiş bir kod yığını potansiyel olarak kaç kez kullanılır. Varsayılan olarak, 3. +For testing, the value can be set to 0: compilation runs synchronously and the query waits for the end of the compilation process before continuing execution. For all other cases, use values ​​starting with 1. Compilation normally takes about 5-10 seconds. +Değer 1 veya daha fazla ise, derleme zaman uyumsuz olarak ayrı bir iş parçacığında oluşur. Sonuç, şu anda çalışmakta olan sorgular da dahil olmak üzere hazır olduğu anda kullanılacaktır. + +Derlenmiş kod, sorguda kullanılan toplama işlevlerinin her farklı birleşimi ve GROUP BY yan tümcesindeki anahtarların türü için gereklidir. +The results of the compilation are saved in the build directory in the form of .so files. There is no restriction on the number of compilation results since they don't use very much space. Old results will be used after server restarts, except in the case of a server upgrade – in this case, the old results are deleted. + +## output\_format\_json\_quote\_64bit\_integers {#session_settings-output_format_json_quote_64bit_integers} + +Değer doğruysa, json\* Int64 ve Uİnt64 formatlarını kullanırken tamsayılar tırnak içinde görünür (çoğu JavaScript uygulamasıyla uyumluluk için); aksi takdirde, tamsayılar tırnak işaretleri olmadan çıktılanır. + +## format\_csv\_delimiter {#settings-format_csv_delimiter} + +Karakter CSV verilerinde bir sınırlayıcı olarak yorumlanır. Varsayılan olarak, sınırlayıcı `,`. + +## ınput\_format\_csv\_unquoted\_null\_literal\_as\_null {#settings-input_format_csv_unquoted_null_literal_as_null} + +CSV giriş biçimi sağlar veya unquoted ayrıştırma devre dışı bırakır için `NULL` literal olarak (eşanlamlı `\N`). + +## output\_format\_csv\_crlf\_end\_of\_line {#settings-output-format-csv-crlf-end-of-line} + +Unix stili (LF) yerine CSV'DE DOS/Windows stili çizgi ayırıcı (CRLF) kullanın. + +## output\_format\_tsv\_crlf\_end\_of\_line {#settings-output-format-tsv-crlf-end-of-line} + +Unıx stili (LF) yerine TSV'DE DOC/Windows stili çizgi ayırıcı (CRLF) kullanın. + +## insert\_quorum {#settings-insert_quorum} + +Çekirdek yazma sağlar. + +- Eğer `insert_quorum < 2`, çekirdek yazma devre dışı bırakılır. +- Eğer `insert_quorum >= 2`, çekirdek yazma etkin. + +Varsayılan değer: 0. + +Nis writesap yazar + +`INSERT` yalnızca ClickHouse verileri doğru bir şekilde yazmayı başardığında başarılı olur. `insert_quorum` sırasında kopya ofların `insert_quorum_timeout`. Herhangi bir nedenle başarılı yazma ile kopya sayısı ulaşmazsa `insert_quorum`, yazma başarısız olarak kabul edilir ve ClickHouse, verilerin zaten yazıldığı tüm kopyalardan eklenen bloğu siler. + +Nisaptaki tüm kopyalar tutarlıdır, yani önceki tüm verileri içerir `INSERT` sorgular. Bu `INSERT` sıra doğrusallaştırılmıştır. + +Yazılan verileri okurken `insert_quorum` olabilir kullanın [select\_sequential\_consistency](#settings-select_sequential_consistency) seçenek. + +ClickHouse bir istisna oluşturur + +- Sorgu sırasında kullanılabilir yinelemelerin sayısı daha az ise `insert_quorum`. +- Önceki blok henüz eklenmemiş olduğunda veri yazma girişiminde `insert_quorum` kopyaların. Bu durum, bir kullanıcı gerçekleştirmeye çalışırsa oluşabilir. `INSERT` ile bir öncekinden önce `insert_quorum` Tamam islanmıştır. + +Ayrıca bakınız: + +- [ınsert\_quorum\_timeout](#settings-insert_quorum_timeout) +- [select\_sequential\_consistency](#settings-select_sequential_consistency) + +## ınsert\_quorum\_timeout {#settings-insert_quorum-timeout} + +Çekirdek zaman aşımına saniyeler içinde yazın. Zaman aşımı geçti ve yazma henüz gerçekleşmedi, ClickHouse bir özel durum oluşturur ve istemci aynı bloğu aynı veya başka bir yineleme yazmak için sorguyu yinelemeniz gerekir. + +Varsayılan değer: 60 saniye. + +Ayrıca bakınız: + +- [insert\_quorum](#settings-insert_quorum) +- [select\_sequential\_consistency](#settings-select_sequential_consistency) + +## select\_sequential\_consistency {#settings-select_sequential_consistency} + +İçin sıralı tutarlılığı etkinleştirir veya devre dışı bırakır `SELECT` sorgular: + +Olası değerler: + +- 0 — Disabled. +- 1 — Enabled. + +Varsayılan değer: 0. + +Kullanma + +Sıralı tutarlılık etkinleştirildiğinde, clickhouse istemci çalıştırmak sağlar `SELECT` yalnızca önceki tüm verileri içeren yinelemeler için sorgu `INSERT` ile yürütülen sorgular `insert_quorum`. Istemci kısmi bir yineleme başvurursa, ClickHouse bir özel durum oluşturur. SELECT sorgusu yinelemeler çekirdek için henüz yazılmamış verileri içermez. + +Ayrıca bakınız: + +- [insert\_quorum](#settings-insert_quorum) +- [ınsert\_quorum\_timeout](#settings-insert_quorum_timeout) + +## ınsert\_deduplicate {#settings-insert-deduplicate} + +Blok tekilleştirmesini etkinleştirir veya devre dışı bırakır `INSERT` (çoğaltılmış \* tablolar için). + +Olası değerler: + +- 0 — Disabled. +- 1 — Enabled. + +Varsayılan değer: 1. + +Varsayılan olarak, çoğaltılmış tablolara eklenen bloklar `INSERT` deyim tekilleştirilir (bkz. \[Data Replication\] (../engines/table\_engines/mergetree\_family/replication.md). + +## deduplicate\_blocks\_ın\_dependent\_materialized\_views {#settings-deduplicate-blocks-in-dependent-materialized-views} + +Yinelenmiş\* tablolardan veri alan materialized görünümler için tekilleştirme denetimini etkinleştirir veya devre dışı bırakır. + +Olası değerler: + + 0 — Disabled. + 1 — Enabled. + +Varsayılan değer: 0. + +Kullanma + +Varsayılan olarak, tekilleştirme materialized görünümler için gerçekleştirilmez, ancak kaynak tabloda, Yukarı akış yapılır. +Eklenen bir blok, kaynak tablodaki tekilleştirme nedeniyle atlanırsa, ekli materialized görünümlerine ekleme olmaz. Bu davranış, eklenen blokların materialized görünüm toplamasından sonra aynı olduğu, ancak kaynak tabloya farklı eklerden türetildiği durumlar için, yüksek oranda toplanmış verilerin materialized görünümlere eklenmesini sağlamak için vardır. +Aynı zamanda, bu davranış “breaks” `INSERT` idempotency. Eğer bir `INSERT` ana tabloya başarılı oldu ve `INSERT` into a materialized view failed (e.g. because of communication failure with Zookeeper) a client will get an error and can retry the operation. However, the materialized view won't receive the second insert because it will be discarded by deduplication in the main (source) table. The setting `deduplicate_blocks_in_dependent_materialized_views` bu davranışı değiştirmeye izin verir. Yeniden denemede, somutlaştırılmış bir görünüm tekrar ekleme işlemini alacak ve tekilleştirme kontrolünü kendi başına gerçekleştirecektir, +kaynak tablo için onay sonucunu yoksayar ve ilk hata nedeniyle kaybedilen satırları ekler. + +## max\_network\_bytes {#settings-max-network-bytes} + +Alınan veya bir sorgu yürütülürken ağ üzerinden iletilen veri birimi (bayt cinsinden) sınırlar. Bu ayar, her bir sorgu için geçerlidir. + +Olası değerler: + +- Pozitif tamsayı. +- 0 — Data volume control is disabled. + +Varsayılan değer: 0. + +## max\_network\_bandwidth {#settings-max-network-bandwidth} + +Ağ üzerinden veri alışverişinin hızını saniyede bayt cinsinden sınırlar. Bu ayar her sorgu için geçerlidir. + +Olası değerler: + +- Pozitif tamsayı. +- 0 — Bandwidth control is disabled. + +Varsayılan değer: 0. + +## max\_network\_bandwidth\_for\_user {#settings-max-network-bandwidth-for-user} + +Ağ üzerinden veri alışverişinin hızını saniyede bayt cinsinden sınırlar. Bu ayar, tek bir kullanıcı tarafından gerçekleştirilen tüm aynı anda çalışan sorgular için geçerlidir. + +Olası değerler: + +- Pozitif tamsayı. +- 0 — Control of the data speed is disabled. + +Varsayılan değer: 0. + +## max\_network\_bandwidth\_for\_all\_users {#settings-max-network-bandwidth-for-all-users} + +Verilerin ağ üzerinden saniyede bayt olarak değiştirildiği hızı sınırlar. Bu ayar, sunucuda aynı anda çalışan tüm sorgular için geçerlidir. + +Olası değerler: + +- Pozitif tamsayı. +- 0 — Control of the data speed is disabled. + +Varsayılan değer: 0. + +## count\_distinct\_implementation {#settings-count_distinct_implementation} + +Aşağıdakilerden hang theisinin `uniq*` işlevleri gerçekleştirmek için kullanılmalıdır [COUNT(DISTINCT …)](../../sql_reference/aggregate_functions/reference.md#agg_function-count) yapma. + +Olası değerler: + +- [uniq](../../sql_reference/aggregate_functions/reference.md#agg_function-uniq) +- [uniqCombined](../../sql_reference/aggregate_functions/reference.md#agg_function-uniqcombined) +- [uniqCombined64](../../sql_reference/aggregate_functions/reference.md#agg_function-uniqcombined64) +- [uniqHLL12](../../sql_reference/aggregate_functions/reference.md#agg_function-uniqhll12) +- [uniqExact](../../sql_reference/aggregate_functions/reference.md#agg_function-uniqexact) + +Varsayılan değer: `uniqExact`. + +## skip\_unavailable\_shards {#settings-skip_unavailable_shards} + +Etkinleştirir veya sessizce kullanılamaz kırıkları atlama devre dışı bırakır. + +Tüm kopyaları kullanılamıyorsa, Shard kullanılamaz olarak kabul edilir. Aşağıdaki durumlarda bir yineleme kullanılamaz: + +- ClickHouse herhangi bir nedenle kopya bağlanamıyor. + + Bir kopyaya bağlanırken, ClickHouse birkaç deneme gerçekleştirir. Tüm bu girişimler başarısız olursa, çoğaltma kullanılamaz kabul edilir. + +- Çoğaltma DNS üzerinden çözülemez. + + Çoğaltmanın ana bilgisayar adı DNS aracılığıyla çözümlenemezse, aşağıdaki durumları gösterebilir: + + - Çoğaltma ana bilgisayar DNS kaydı yok. Dinamik DNS'YE sahip sistemlerde oluşabilir, örneğin, [Kubernetes](https://kubernetes.io), burada düğümler kesinti sırasında çözülmez olabilir ve bu bir hata değildir. + + - Yapılandırma hatası. ClickHouse yapılandırma dosyası yanlış bir ana bilgisayar adı içerir. + +Olası değerler: + +- 1 — skipping enabled. + + Bir parça kullanılamıyorsa, ClickHouse kısmi verilere dayalı bir sonuç döndürür ve düğüm kullanılabilirliği sorunlarını bildirmez. + +- 0 — skipping disabled. + + Bir shard kullanılamıyorsa, ClickHouse bir özel durum atar. + +Varsayılan değer: 0. + +## optimize\_skip\_unused\_shards {#settings-optimize_skip_unused_shards} + +Prewhere/WHERE (verilerin sharding anahtarı tarafından dağıtıldığını varsayar, aksi takdirde hiçbir şey yapmaz). + +Varsayılan değer: 0 + +## force\_optimize\_skip\_unused\_shards {#settings-force_optimize_skip_unused_shards} + +Sorgu yürütülmesini etkinleştirir veya devre dışı bırakır [`optimize_skip_unused_shards`](#settings-optimize_skip_unused_shards) etkin ve kullanılmayan kırıkları atlama mümkün değildir. Atlama mümkün değilse ve ayar etkinse özel durum atılır. + +Olası değerler: + +- 0-Devre Dışı (at notmayın) +- 1-sorgu yürütülmesini yalnızca tablonun sharding anahtarı varsa devre dışı bırakın +- 2-devre dışı sorgu yürütme ne olursa olsun sharding anahtar tablo için tanımlanır + +Varsayılan değer: 0 + +## force\_optimize\_skip\_unused\_shards\_no\_nested {#settings-force_optimize_skip_unused_shards_no_nested} + +Sıfırlamak [`optimize_skip_unused_shards`](#settings-force_optimize_skip_unused_shards) iç içe geçmiş için `Distributed` Tablo + +Olası değerler: + +- 1 — Enabled. +- 0 — Disabled. + +Varsayılan değer: 0. + +## optimize\_throw\_if\_noop {#setting-optimize_throw_if_noop} + +Bir özel durum atmayı etkinleştirir veya devre dışı bırakır. [OPTIMIZE](../../sql_reference/statements/misc.md#misc_operations-optimize) sorgu birleştirme gerçekleştirmedi. + +Varsayılan olarak, `OPTIMIZE` eğer hiç bir şey yapmamış olsa bile, başarılı bir şekilde verir. Bu ayar, bu durumları ayırt etmenizi ve bir özel durum iletisinde nedeni almanızı sağlar. + +Olası değerler: + +- 1 — Throwing an exception is enabled. +- 0 — Throwing an exception is disabled. + +Varsayılan değer: 0. + +## distributed\_replica\_error\_half\_life {#settings-distributed_replica_error_half_life} + +- Türü: saniye +- Varsayılan değer: 60 saniye + +Dağıtılmış tablolardaki hataların ne kadar hızlı sıfırlandığını denetler. Bir yineleme bir süre için kullanılamıyorsa, 5 hataları biriktirir ve distributed\_replica\_error\_half\_lıfe 1 saniye olarak ayarlanır, sonra yineleme son hatadan sonra normal 3 saniye olarak kabul edilir. + +Ayrıca bakınız: + +- [Masa motoru Dağıt Distributedıldı](../../engines/table_engines/special/distributed.md) +- [distributed\_replica\_error\_cap](#settings-distributed_replica_error_cap) + +## distributed\_replica\_error\_cap {#settings-distributed_replica_error_cap} + +- Tür: imzasız int +- Varsayılan değer: 1000 + +Her yineleme hata sayısı çok fazla hata biriken tek bir yineleme engelleyerek, bu değerle kaplıdır. + +Ayrıca bakınız: + +- [Masa motoru Dağıt Distributedıldı](../../engines/table_engines/special/distributed.md) +- [distributed\_replica\_error\_half\_life](#settings-distributed_replica_error_half_life) + +## distributed\_directory\_monitor\_sleep\_time\_ms {#distributed_directory_monitor_sleep_time_ms} + +İçin taban aralığı [Dağılı](../../engines/table_engines/special/distributed.md) veri göndermek için tablo motoru. Gerçek Aralık, hatalar durumunda katlanarak büyür. + +Olası değerler: + +- Milisaniye pozitif tamsayı sayısı. + +Varsayılan değer: 100 milisaniye. + +## distributed\_directory\_monitor\_max\_sleep\_time\_ms {#distributed_directory_monitor_max_sleep_time_ms} + +İçin Maksimum Aralık [Dağılı](../../engines/table_engines/special/distributed.md) veri göndermek için tablo motoru. Sınırları içinde belirlenen Aralık üstel büyüme [distributed\_directory\_monitor\_sleep\_time\_ms](#distributed_directory_monitor_sleep_time_ms) ayar. + +Olası değerler: + +- Milisaniye pozitif tamsayı sayısı. + +Varsayılan değer: 30000 milisaniye (30 saniye). + +## distributed\_directory\_monitor\_batch\_ınserts {#distributed_directory_monitor_batch_inserts} + +Eklenen verilerin toplu olarak gönderilmesini etkinleştirir / devre dışı bırakır. + +Toplu gönderme etkinleştirildiğinde, [Dağılı](../../engines/table_engines/special/distributed.md) table engine, eklenen verilerin birden çok dosyasını ayrı ayrı göndermek yerine tek bir işlemde göndermeye çalışır. Toplu gönderme, sunucu ve ağ kaynaklarını daha iyi kullanarak küme performansını artırır. + +Olası değerler: + +- 1 — Enabled. +- 0 — Disabled. + +Varsayılan değer: 0. + +## os\_thread\_priority {#setting-os-thread-priority} + +Önceliği ayarlar ([güzel](https://en.wikipedia.org/wiki/Nice_(Unix))) sorguları yürüten iş parçacıkları için. İşletim sistemi Zamanlayıcısı, kullanılabilir her CPU çekirdeğinde çalışacak bir sonraki iş parçacığını seçerken bu önceliği dikkate alır. + +!!! warning "Uyarıcı" + Bu ayarı kullanmak için, `CAP_SYS_NICE` özellik. Bu `clickhouse-server` paket kurulum sırasında kurar. Bazı sanal ortamlar ayarlamanıza izin vermez `CAP_SYS_NICE` özellik. Bu durumda, `clickhouse-server` Başlangıçta bu konuda bir mesaj gösterir. + +Olası değerler: + +- Aralıktaki değerleri ayarlayabilirsiniz `[-20, 19]`. + +Daha düşük değerler daha yüksek öncelik anlamına gelir. Düşük olan iplikler `nice` öncelik değerleri, yüksek değerlere sahip iş parçacıklarından daha sık yürütülür. Yüksek değerler, uzun süren etkileşimli olmayan sorgular için tercih edilir, çünkü geldiklerinde kısa etkileşimli sorgular lehine kaynakları hızlı bir şekilde bırakmalarına izin verir. + +Varsayılan değer: 0. + +## query\_profiler\_real\_time\_period\_ns {#query_profiler_real_time_period_ns} + +Gerçek bir saat zamanlayıcı için süreyi ayarlar [sorgu profiler](../../operations/optimizing_performance/sampling_query_profiler.md). Gerçek saat zamanlayıcı duvar saati zaman sayar. + +Olası değerler: + +- Nanosaniye cinsinden pozitif tam sayı. + + Önerilen değerler: + + - 10000000 (100 times a second) nanoseconds and less for single queries. + - 1000000000 (once a second) for cluster-wide profiling. + +- Zamanlayıcıyı kapatmak için 0. + +Tür: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +Varsayılan değer: 1000000000 nanosaniye (saniyede bir kez). + +Ayrıca bakınız: + +- Sistem tablosu [trace\_log](../../operations/system_tables.md#system_tables-trace_log) + +## query\_profiler\_cpu\_time\_period\_ns {#query_profiler_cpu_time_period_ns} + +Bir CPU saat süreölçerinin dönemini ayarlar. [sorgu profiler](../../operations/optimizing_performance/sampling_query_profiler.md). Bu zamanlayıcı sadece CPU süresini sayar. + +Olası değerler: + +- Nanosaniye pozitif tamsayı sayısı. + + Önerilen değerler: + + - 10000000 (100 times a second) nanoseconds and more for single queries. + - 1000000000 (once a second) for cluster-wide profiling. + +- Zamanlayıcıyı kapatmak için 0. + +Tür: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +Varsayılan değer: 1000000000 nanosaniye. + +Ayrıca bakınız: + +- Sistem tablosu [trace\_log](../../operations/system_tables.md#system_tables-trace_log) + +## allow\_introspection\_functions {#settings-allow_introspection_functions} + +Devre dışı bırakmayı etkinleştirir [ıntrospections fonksiyonları](../../sql_reference/functions/introspection.md) sorgu profilleme için. + +Olası değerler: + +- 1 — Introspection functions enabled. +- 0 — Introspection functions disabled. + +Varsayılan değer: 0. + +**Ayrıca Bakınız** + +- [Örnekleme Sorgusu Profiler](../optimizing_performance/sampling_query_profiler.md) +- Sistem tablosu [trace\_log](../../operations/system_tables.md#system_tables-trace_log) + +## ınput\_format\_parallel\_parsing {#input-format-parallel-parsing} + +- Tipi: bool +- Varsayılan değer: True + +Veri biçimlerinin paralel ayrıştırma sırasını koruyarak etkinleştirin. Sadece TSV, TKSV, CSV ve JSONEachRow formatları için desteklenir. + +## min\_chunk\_bytes\_for\_parallel\_parsing {#min-chunk-bytes-for-parallel-parsing} + +- Tür: imzasız int +- Varsayılan değer: 1 MiB + +Her iş parçacığının paralel olarak ayrıştırılacağı bayt cinsinden minimum yığın boyutu. + +## output\_format\_avro\_codec {#settings-output_format_avro_codec} + +Çıkış Avro dosyası için kullanılan sıkıştırma codec ayarlar. + +Tipi: dize + +Olası değerler: + +- `null` — No compression +- `deflate` — Compress with Deflate (zlib) +- `snappy` — Compress with [Çabuk](https://google.github.io/snappy/) + +Varsayılan değer: `snappy` (varsa) veya `deflate`. + +## output\_format\_avro\_sync\_interval {#settings-output_format_avro_sync_interval} + +Çıkış Avro dosyası için senkronizasyon işaretçileri arasında minimum veri boyutunu (bayt cinsinden) ayarlar. + +Tür: imzasız int + +Olası değerler: 32 (32 bayt) - 1073741824 (1 GiB) + +Varsayılan değer: 32768 (32 KiB) + +## format\_avro\_schema\_registry\_url {#settings-format_avro_schema_registry_url} + +Sets Confluent Schema Registry URL to use with [AvroConfluent](../../interfaces/formats.md#data-format-avro-confluent) biçimli + +Type: URL + +Varsayılan değer: boş + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/settings/settings/) diff --git a/docs/tr/operations/settings/settings_profiles.md b/docs/tr/operations/settings/settings_profiles.md new file mode 100644 index 00000000000..318276ab6c8 --- /dev/null +++ b/docs/tr/operations/settings/settings_profiles.md @@ -0,0 +1,71 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 61 +toc_title: Ayarlar Profilleri +--- + +# Ayarlar Profilleri {#settings-profiles} + +Ayarlar profili, aynı ad altında gruplandırılmış ayarlar topluluğudur. Her ClickHouse kullanıcısının bir profili vardır. +Bir profildeki tüm ayarları uygulamak için `profile` ayar. + +Örnek: + +Yüklemek `web` profilli. + +``` sql +SET profile = 'web' +``` + +Ayarlar profilleri kullanıcı yapılandırma dosyasında bildirilir. Bu genellikle `users.xml`. + +Örnek: + +``` xml + + + + + + 8 + + + + + 1000000000 + 100000000000 + + 1000000 + any + + 1000000 + 1000000000 + + 100000 + 100000000 + break + + 600 + 1000000 + 15 + + 25 + 100 + 50 + + 2 + 25 + 50 + 100 + + 1 + + +``` + +Örnek iki profili belirtir: `default` ve `web`. Bu `default` profilin özel bir amacı vardır: her zaman mevcut olmalı ve sunucuyu başlatırken uygulanır. Diğer bir deyişle, `default` profil varsayılan ayarları içerir. Bu `web` profil kullanılarak ayarlanabilir düzenli bir profil `SET` sorgu veya bir HTTP sorgusunda bir URL parametresi kullanma. + +Ayarlar profilleri birbirinden miras alabilir. Kalıtım kullanmak için, bir veya birden fazla belirtiniz `profile` ayarlar profilde listelenen diğer ayarlardan önce. Farklı profillerde bir ayar tanımlandığında, en son tanımlı kullanılır. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/settings/settings_profiles/) diff --git a/docs/tr/operations/settings/settings_users.md b/docs/tr/operations/settings/settings_users.md new file mode 100644 index 00000000000..0bc2b5ac1a5 --- /dev/null +++ b/docs/tr/operations/settings/settings_users.md @@ -0,0 +1,148 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 63 +toc_title: "Kullan\u0131c\u0131 Ayarlar\u0131" +--- + +# Kullanıcı Ayarları {#user-settings} + +Bu `users` bu bölüm `user.xml` yapılandırma dosyası kullanıcı ayarlarını içerir. + +Bu yapı `users` bölme: + +``` xml + + + + + + + + + + + profile_name + + default + + + + + expression + + + + + + +``` + +### home/şifre {#user-namepassword} + +Şifre düz metin veya SHA256 (hex formatında) belirtilebilir. + +- Düz metin içinde bir şifre atamak için (**tavsiye edilmez**bir koyun `password` öğe. + + Mesela, `qwerty`. Şifre boş bırakılabilir. + + + +- SHA256 karmasını kullanarak bir şifre atamak için, bir `password_sha256_hex` öğe. + + Mesela, `65e84be33532fb784c48129675f9eff3a682b27168c0ea744b2cf58ee02337c5`. + + Kabuktan bir parola oluşturma örneği: + + PASSWORD=$(base64 < /dev/urandom | head -c8); echo "$PASSWORD"; echo -n "$PASSWORD" | sha256sum | tr -d '-' + + Sonucun ilk satırı şifredir. İkinci satır karşılık gelen SHA256 karmasıdır. + + + +- MySQL istemcileri ile uyumluluk için, şifre çift SHA1 karma belirtilebilir. İçine yerleştirin `password_double_sha1_hex` öğe. + + Mesela, `08b4a0f1de6ad37da17359e592c8d74788a83eb0`. + + Kabuktan bir parola oluşturma örneği: + + PASSWORD=$(base64 < /dev/urandom | head -c8); echo "$PASSWORD"; echo -n "$PASSWORD" | sha1sum | tr -d '-' | xxd -r -p | sha1sum | tr -d '-' + + Sonucun ilk satırı şifredir. İkinci satır karşılık gelen çift SHA1 karmasıdır. + +### kullanıcı\_adı / ağlar {#user-namenetworks} + +Kullanıcının ClickHouse sunucusuna bağlanabileceği ağların listesi. + +Listenin her öğesi aşağıdaki formlardan birine sahip olabilir: + +- `` — IP address or network mask. + + Örnekler: `213.180.204.3`, `10.0.0.1/8`, `10.0.0.1/255.255.255.0`, `2a02:6b8::3`, `2a02:6b8::3/64`, `2a02:6b8::3/ffff:ffff:ffff:ffff::`. + +- `` — Hostname. + + Örnek: `example01.host.ru`. + + Erişimi denetlemek için bir DNS sorgusu gerçekleştirilir ve döndürülen tüm IP adresleri eş adresiyle karşılaştırılır. + +- `` — Regular expression for hostnames. + + Örnek, `^example\d\d-\d\d-\d\.host\.ru$` + + Erişimi kontrol etmek için, bir [DNS ptr sorgusu](https://en.wikipedia.org/wiki/Reverse_DNS_lookup) eş adresi için gerçekleştirilir ve sonra belirtilen regexp uygulanır. Daha sonra PTR sorgusunun sonuçları için başka bir DNS sorgusu gerçekleştirilir ve alınan tüm adresler eş adresine karşılaştırılır. Regexp'nin $ile bitmesini şiddetle tavsiye ederiz. + +Sunucu yeniden başlatılıncaya kadar DNS isteklerinin tüm sonuçları önbelleğe alınır. + +**Örnekler** + +Herhangi bir ağdan kullanıcı için erişimi açmak için şunları belirtin: + +``` xml +::/0 +``` + +!!! warning "Uyarıcı" + Düzgün yapılandırılmış bir güvenlik duvarınız yoksa veya sunucu doğrudan internete bağlı değilse, herhangi bir ağdan erişimi açmak güvensizdir. + +Erişimi yalnızca localhost'tan açmak için şunları belirtin: + +``` xml +::1 +127.0.0.1 +``` + +### kullanıcı\_adı / profil {#user-nameprofile} + +Kullanıcı için bir ayarlar profili atayabilirsiniz. Ayarlar profilleri ayrı bir bölümde yapılandırılır `users.xml` Dosya. Daha fazla bilgi için, bkz. [Ayarların profilleri](settings_profiles.md). + +### user\_name / kota {#user-namequota} + +Kotalar, belirli bir süre boyunca kaynak kullanımını izlemenize veya sınırlamanıza izin verir. Kotalar yapılandırılır `quotas` +bu bölüm `users.xml` yapılandırma dosyası. + +Kullanıcı için ayarlanmış bir kotalar atayabilirsiniz. Kotalar yapılandırmasının ayrıntılı bir açıklaması için bkz. [Kotalar](../quotas.md#quotas). + +### user\_name / veritabanları {#user-namedatabases} + +Bu bölümde, ClickHouse tarafından döndürülen satırları sınırlayabilirsiniz `SELECT` geçerli kullanıcı tarafından yapılan sorgular, böylece temel satır düzeyinde güvenlik uygular. + +**Örnek** + +Aşağıdaki yapılandırma bu kullanıcıyı zorlar `user1` sadece satırları görebilirsiniz `table1` sonucu olarak `SELECT` sorgular, burada değeri `id` alan 1000'dir. + +``` xml + + + + + id = 1000 + + + + +``` + +Bu `filter` bir sonuç veren herhangi bir ifade olabilir [Uİnt8](../../sql_reference/data_types/int_uint.md)- tip değeri. Genellikle karşılaştırmalar ve mantıksal operatörler içerir. Satır fromlardan `database_name.table1` burada filtre sonuçları 0 için bu kullanıcı için döndürülür. Filtreleme ile uyumsuz `PREWHERE` işlemler ve devre dışı bırakır `WHERE→PREWHERE` optimizasyon. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/settings/settings_users/) diff --git a/docs/tr/operations/system_tables.md b/docs/tr/operations/system_tables.md new file mode 100644 index 00000000000..17fd176cc58 --- /dev/null +++ b/docs/tr/operations/system_tables.md @@ -0,0 +1,1166 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 52 +toc_title: "Sistem Tablolar\u0131" +--- + +# Sistem Tabloları {#system-tables} + +Sistem tabloları, sistemin işlevselliğinin bir kısmını uygulamak ve sistemin nasıl çalıştığı hakkında bilgilere erişim sağlamak için kullanılır. +Bir sistem tablosunu silemezsiniz (ancak ayırma işlemini gerçekleştirebilirsiniz). +Sistem tablolarında diskte veri bulunan dosyalar veya meta verilere sahip dosyalar yoktur. Sunucu, başlatıldığında tüm sistem tablolarını oluşturur. +Sistem tabloları salt okunur. +Bulun theurlar. ‘system’ veritabanı. + +## sistem.asynchronous\_metrics {#system_tables-asynchronous_metrics} + +Arka planda periyodik olarak hesaplanan metrikleri içerir. Örneğin, kullanılan RAM miktarı. + +Sütun: + +- `metric` ([Dize](../sql_reference/data_types/string.md)) — Metric name. +- `value` ([Float64](../sql_reference/data_types/float.md)) — Metric value. + +**Örnek** + +``` sql +SELECT * FROM system.asynchronous_metrics LIMIT 10 +``` + +``` text +┌─metric──────────────────────────────────┬──────value─┐ +│ jemalloc.background_thread.run_interval │ 0 │ +│ jemalloc.background_thread.num_runs │ 0 │ +│ jemalloc.background_thread.num_threads │ 0 │ +│ jemalloc.retained │ 422551552 │ +│ jemalloc.mapped │ 1682989056 │ +│ jemalloc.resident │ 1656446976 │ +│ jemalloc.metadata_thp │ 0 │ +│ jemalloc.metadata │ 10226856 │ +│ UncompressedCacheCells │ 0 │ +│ MarkCacheFiles │ 0 │ +└─────────────────────────────────────────┴────────────┘ +``` + +**Ayrıca Bakınız** + +- [İzleme](monitoring.md) — Base concepts of ClickHouse monitoring. +- [sistem.metrik](#system_tables-metrics) — Contains instantly calculated metrics. +- [sistem.etkinlik](#system_tables-events) — Contains a number of events that have occurred. +- [sistem.metric\_log](#system_tables-metric_log) — Contains a history of metrics values from tables `system.metrics` и `system.events`. + +## sistem.kümeler {#system-clusters} + +Yapılandırma dosyasında bulunan kümeler ve içindeki sunucular hakkında bilgi içerir. + +Sütun: + +- `cluster` (String) — The cluster name. +- `shard_num` (UInt32) — The shard number in the cluster, starting from 1. +- `shard_weight` (UInt32) — The relative weight of the shard when writing data. +- `replica_num` (UInt32) — The replica number in the shard, starting from 1. +- `host_name` (String) — The host name, as specified in the config. +- `host_address` (String) — The host IP address obtained from DNS. +- `port` (UInt16) — The port to use for connecting to the server. +- `user` (String) — The name of the user for connecting to the server. +- `errors_count` (Uİnt32) - bu ana bilgisayarın çoğaltma ulaşamadı sayısı. +- `estimated_recovery_time` (Uİnt32) - çoğaltma hata sayısı sıfırlanana kadar saniye kaldı ve normale döndü olarak kabul edilir. + +Lütfen unutmayın `errors_count` küme için sorgu başına bir kez güncelleştirilir, ancak `estimated_recovery_time` isteğe bağlı olarak yeniden hesaplanır. Yani sıfır olmayan bir durum olabilir `errors_count` ve sıfır `estimated_recovery_time`, sonraki sorgu sıfır olacak `errors_count` ve hiçbir hata yokmuş gibi çoğaltma kullanmayı deneyin. + +**Ayrıca bakınız** + +- [Masa motoru Dağıt Distributedıldı](../engines/table_engines/special/distributed.md) +- [distributed\_replica\_error\_cap ayarı](settings/settings.md#settings-distributed_replica_error_cap) +- [distributed\_replica\_error\_half\_life ayarı](settings/settings.md#settings-distributed_replica_error_half_life) + +## sistem.sütun {#system-columns} + +Tüm tablolardaki sütunlar hakkında bilgi içerir. + +Benzer bilgileri almak için bu tabloyu kullanabilirsiniz [DESCRIBE TABLE](../sql_reference/statements/misc.md#misc-describe-table) sorgu, ancak aynı anda birden çok tablo için. + +Bu `system.columns` tablo aşağıdaki sütunları içerir (sütun türü parantez içinde gösterilir): + +- `database` (String) — Database name. +- `table` (String) — Table name. +- `name` (String) — Column name. +- `type` (String) — Column type. +- `default_kind` (String) — Expression type (`DEFAULT`, `MATERIALIZED`, `ALIAS`) varsayılan değer veya tanımlanmamışsa boş bir dize için. +- `default_expression` (String) — Expression for the default value, or an empty string if it is not defined. +- `data_compressed_bytes` (UInt64) — The size of compressed data, in bytes. +- `data_uncompressed_bytes` (UInt64) — The size of decompressed data, in bytes. +- `marks_bytes` (UInt64) — The size of marks, in bytes. +- `comment` (String) — Comment on the column, or an empty string if it is not defined. +- `is_in_partition_key` (UInt8) — Flag that indicates whether the column is in the partition expression. +- `is_in_sorting_key` (UInt8) — Flag that indicates whether the column is in the sorting key expression. +- `is_in_primary_key` (UInt8) — Flag that indicates whether the column is in the primary key expression. +- `is_in_sampling_key` (UInt8) — Flag that indicates whether the column is in the sampling key expression. + +## sistem.katılımcılar {#system-contributors} + +Katkıda bulunanlar hakkında bilgi içerir. Rastgele sırayla tüm constributors. Sipariş, sorgu yürütme zamanında rasgele olur. + +Sütun: + +- `name` (String) — Contributor (author) name from git log. + +**Örnek** + +``` sql +SELECT * FROM system.contributors LIMIT 10 +``` + +``` text +┌─name─────────────┐ +│ Olga Khvostikova │ +│ Max Vetrov │ +│ LiuYangkuan │ +│ svladykin │ +│ zamulla │ +│ Šimon Podlipský │ +│ BayoNet │ +│ Ilya Khomutov │ +│ Amy Krishnevsky │ +│ Loud_Scream │ +└──────────────────┘ +``` + +Tabloda kendinizi bulmak için bir sorgu kullanın: + +``` sql +SELECT * FROM system.contributors WHERE name='Olga Khvostikova' +``` + +``` text +┌─name─────────────┐ +│ Olga Khvostikova │ +└──────────────────┘ +``` + +## sistem.veritabanılar {#system-databases} + +Bu tablo, adı verilen tek bir dize sütunu içerir ‘name’ – the name of a database. +Sunucunun bildiği her veritabanı, tabloda karşılık gelen bir girdiye sahiptir. +Bu sistem tablosu uygulamak için kullanılır `SHOW DATABASES` sorgu. + +## sistem.detached\_parts {#system_tables-detached_parts} + +Müstakil parçaları hakkında bilgiler içerir [MergeTree](../engines/table_engines/mergetree_family/mergetree.md) Tablolar. Bu `reason` sütun, parçanın neden ayrıldığını belirtir. Kullanıcı tarafından ayrılmış parçalar için sebep boştur. Bu tür parçalar ile eklenebilir [ALTER TABLE ATTACH PARTITION\|PART](../sql_reference/statements/alter.md#alter_attach-partition) komut. Diğer sütunların açıklaması için bkz. [sistem.parçalar](#system_tables-parts). Bölüm adı geçersiz ise, bazı sütunların değerleri olabilir `NULL`. Bu tür parçalar ile silinebilir [ALTER TABLE DROP DETACHED PART](../sql_reference/statements/alter.md#alter_drop-detached). + +## sistem.sözlükler {#system_tables-dictionaries} + +Hakkında bilgi içerir [dış söz dictionarieslükler](../sql_reference/dictionaries/external_dictionaries/external_dicts.md). + +Sütun: + +- `database` ([Dize](../sql_reference/data_types/string.md)) — Name of the database containing the dictionary created by DDL query. Empty string for other dictionaries. +- `name` ([Dize](../sql_reference/data_types/string.md)) — [Sözlük adı](../sql_reference/dictionaries/external_dictionaries/external_dicts_dict.md). +- `status` ([Enum8](../sql_reference/data_types/enum.md)) — Dictionary status. Possible values: + - `NOT_LOADED` — Dictionary was not loaded because it was not used. + - `LOADED` — Dictionary loaded successfully. + - `FAILED` — Unable to load the dictionary as a result of an error. + - `LOADING` — Dictionary is loading now. + - `LOADED_AND_RELOADING` — Dictionary is loaded successfully, and is being reloaded right now (frequent reasons: [SYSTEM RELOAD DICTIONARY](../sql_reference/statements/system.md#query_language-system-reload-dictionary) sorgu, zaman aşımı, sözlük yapılandırması değişti). + - `FAILED_AND_RELOADING` — Could not load the dictionary as a result of an error and is loading now. +- `origin` ([Dize](../sql_reference/data_types/string.md)) — Path to the configuration file that describes the dictionary. +- `type` ([Dize](../sql_reference/data_types/string.md)) — Type of a dictionary allocation. [Sözlükleri bellekte saklama](../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_layout.md). +- `key` — [Anahtar tipi](../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_structure.md#ext_dict_structure-key): Sayısal Tuş ([Uİnt64](../sql_reference/data_types/int_uint.md#uint-ranges)) or Сomposite key ([Dize](../sql_reference/data_types/string.md)) — form “(type 1, type 2, …, type n)”. +- `attribute.names` ([Dizi](../sql_reference/data_types/array.md)([Dize](../sql_reference/data_types/string.md))) — Array of [öznitelik adları](../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_structure.md#ext_dict_structure-attributes) sözlük tarafından sağlanmıştır. +- `attribute.types` ([Dizi](../sql_reference/data_types/array.md)([Dize](../sql_reference/data_types/string.md))) — Corresponding array of [öznitelik türleri](../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_structure.md#ext_dict_structure-attributes) sözlük tarafından sağlanmaktadır. +- `bytes_allocated` ([Uİnt64](../sql_reference/data_types/int_uint.md#uint-ranges)) — Amount of RAM allocated for the dictionary. +- `query_count` ([Uİnt64](../sql_reference/data_types/int_uint.md#uint-ranges)) — Number of queries since the dictionary was loaded or since the last successful reboot. +- `hit_rate` ([Float64](../sql_reference/data_types/float.md)) — For cache dictionaries, the percentage of uses for which the value was in the cache. +- `element_count` ([Uİnt64](../sql_reference/data_types/int_uint.md#uint-ranges)) — Number of items stored in the dictionary. +- `load_factor` ([Float64](../sql_reference/data_types/float.md)) — Percentage filled in the dictionary (for a hashed dictionary, the percentage filled in the hash table). +- `source` ([Dize](../sql_reference/data_types/string.md)) — Text describing the [veri kaynağı](../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_sources.md) sözlük için. +- `lifetime_min` ([Uİnt64](../sql_reference/data_types/int_uint.md#uint-ranges)) — Minimum [ömür](../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_lifetime.md) bellekteki sözlüğün ardından ClickHouse sözlüğü yeniden yüklemeye çalışır (eğer `invalidate_query` ayarlanır, daha sonra sadece değiştiyse). Saniyeler içinde ayarlayın. +- `lifetime_max` ([Uİnt64](../sql_reference/data_types/int_uint.md#uint-ranges)) — Maximum [ömür](../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_lifetime.md) bellekteki sözlüğün ardından ClickHouse sözlüğü yeniden yüklemeye çalışır (eğer `invalidate_query` ayarlanır, daha sonra sadece değiştiyse). Saniyeler içinde ayarlayın. +- `loading_start_time` ([DateTime](../sql_reference/data_types/datetime.md)) — Start time for loading the dictionary. +- `last_successful_update_time` ([DateTime](../sql_reference/data_types/datetime.md)) — End time for loading or updating the dictionary. Helps to monitor some troubles with external sources and investigate causes. +- `loading_duration` ([Float32](../sql_reference/data_types/float.md)) — Duration of a dictionary loading. +- `last_exception` ([Dize](../sql_reference/data_types/string.md)) — Text of the error that occurs when creating or reloading the dictionary if the dictionary couldn't be created. + +**Örnek** + +Sözlüğü yapılandırın. + +``` sql +CREATE DICTIONARY dictdb.dict +( + `key` Int64 DEFAULT -1, + `value_default` String DEFAULT 'world', + `value_expression` String DEFAULT 'xxx' EXPRESSION 'toString(127 * 172)' +) +PRIMARY KEY key +SOURCE(CLICKHOUSE(HOST 'localhost' PORT 9000 USER 'default' TABLE 'dicttbl' DB 'dictdb')) +LIFETIME(MIN 0 MAX 1) +LAYOUT(FLAT()) +``` + +Sözlüğün yüklendiğinden emin olun. + +``` sql +SELECT * FROM system.dictionaries +``` + +``` text +┌─database─┬─name─┬─status─┬─origin──────┬─type─┬─key────┬─attribute.names──────────────────────┬─attribute.types─────┬─bytes_allocated─┬─query_count─┬─hit_rate─┬─element_count─┬───────────load_factor─┬─source─────────────────────┬─lifetime_min─┬─lifetime_max─┬──loading_start_time─┌──last_successful_update_time─┬──────loading_duration─┬─last_exception─┐ +│ dictdb │ dict │ LOADED │ dictdb.dict │ Flat │ UInt64 │ ['value_default','value_expression'] │ ['String','String'] │ 74032 │ 0 │ 1 │ 1 │ 0.0004887585532746823 │ ClickHouse: dictdb.dicttbl │ 0 │ 1 │ 2020-03-04 04:17:34 │ 2020-03-04 04:30:34 │ 0.002 │ │ +└──────────┴──────┴────────┴─────────────┴──────┴────────┴──────────────────────────────────────┴─────────────────────┴─────────────────┴─────────────┴──────────┴───────────────┴───────────────────────┴────────────────────────────┴──────────────┴──────────────┴─────────────────────┴──────────────────────────────┘───────────────────────┴────────────────┘ +``` + +## sistem.etkinlik {#system_tables-events} + +Sistemde meydana gelen olayların sayısı hakkında bilgi içerir. Örneğin, tabloda kaç tane bulabilirsiniz `SELECT` ClickHouse sunucusu başladığından beri sorgular işlendi. + +Sütun: + +- `event` ([Dize](../sql_reference/data_types/string.md)) — Event name. +- `value` ([Uİnt64](../sql_reference/data_types/int_uint.md)) — Number of events occurred. +- `description` ([Dize](../sql_reference/data_types/string.md)) — Event description. + +**Örnek** + +``` sql +SELECT * FROM system.events LIMIT 5 +``` + +``` text +┌─event─────────────────────────────────┬─value─┬─description────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ +│ Query │ 12 │ Number of queries to be interpreted and potentially executed. Does not include queries that failed to parse or were rejected due to AST size limits, quota limits or limits on the number of simultaneously running queries. May include internal queries initiated by ClickHouse itself. Does not count subqueries. │ +│ SelectQuery │ 8 │ Same as Query, but only for SELECT queries. │ +│ FileOpen │ 73 │ Number of files opened. │ +│ ReadBufferFromFileDescriptorRead │ 155 │ Number of reads (read/pread) from a file descriptor. Does not include sockets. │ +│ ReadBufferFromFileDescriptorReadBytes │ 9931 │ Number of bytes read from file descriptors. If the file is compressed, this will show the compressed data size. │ +└───────────────────────────────────────┴───────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [sistem.asynchronous\_metrics](#system_tables-asynchronous_metrics) — Contains periodically calculated metrics. +- [sistem.metrik](#system_tables-metrics) — Contains instantly calculated metrics. +- [sistem.metric\_log](#system_tables-metric_log) — Contains a history of metrics values from tables `system.metrics` и `system.events`. +- [İzleme](monitoring.md) — Base concepts of ClickHouse monitoring. + +## sistem.işlevler {#system-functions} + +Normal ve toplama işlevleri hakkında bilgi içerir. + +Sütun: + +- `name`(`String`) – The name of the function. +- `is_aggregate`(`UInt8`) — Whether the function is aggregate. + +## sistem.graphite\_retentions {#system-graphite-retentions} + +Parametreleri hakkında bilgi içerir [graphite\_rollup](server_configuration_parameters/settings.md#server_configuration_parameters-graphite_rollup) tablo usedlarında kullanılan [\* Graphıtemergetree](../engines/table_engines/mergetree_family/graphitemergetree.md) motorlar. + +Sütun: + +- `config_name` (Dize) - `graphite_rollup` parametre adı. +- `regexp` (String) - metrik adı için bir desen. +- `function` (String) - toplama işlevinin adı. +- `age` (Uint64) - saniye cinsinden verilerin minimum yaş. +- `precision` (Uİnt64) - verilerin yaşını saniyeler içinde tam olarak tanımlamak için. +- `priority` (Uİnt16) - desen önceliği. +- `is_default` (Uİnt8) - desenin varsayılan olup olmadığı. +- `Tables.database` (Array (String)) - kullanılan veritabanı tablolarının adlarının dizisi `config_name` parametre. +- `Tables.table` (Array (String)) - kullanılan tablo adları dizisi `config_name` parametre. + +## sistem.birleştiriyor {#system-merges} + +Mergetree ailesindeki tablolar için şu anda işlemde olan birleştirme ve parça mutasyonları hakkında bilgi içerir. + +Sütun: + +- `database` (String) — The name of the database the table is in. +- `table` (String) — Table name. +- `elapsed` (Float64) — The time elapsed (in seconds) since the merge started. +- `progress` (Float64) — The percentage of completed work from 0 to 1. +- `num_parts` (UInt64) — The number of pieces to be merged. +- `result_part_name` (String) — The name of the part that will be formed as the result of merging. +- `is_mutation` (Uİnt8 ) - 1 Bu işlem bir parça mutasyonu ise. +- `total_size_bytes_compressed` (UInt64) — The total size of the compressed data in the merged chunks. +- `total_size_marks` (UInt64) — The total number of marks in the merged parts. +- `bytes_read_uncompressed` (UInt64) — Number of bytes read, uncompressed. +- `rows_read` (UInt64) — Number of rows read. +- `bytes_written_uncompressed` (UInt64) — Number of bytes written, uncompressed. +- `rows_written` (UInt64) — Number of rows written. + +## sistem.metrik {#system_tables-metrics} + +Anında hesaplanan veya geçerli bir değere sahip olabilir metrikleri içerir. Örneğin, aynı anda işlenen sorguların sayısı veya geçerli yineleme gecikmesi. Bu tablo her zaman güncel. + +Sütun: + +- `metric` ([Dize](../sql_reference/data_types/string.md)) — Metric name. +- `value` ([Int64](../sql_reference/data_types/int_uint.md)) — Metric value. +- `description` ([Dize](../sql_reference/data_types/string.md)) — Metric description. + +Desteklenen metriklerin listesi [src / ortak / CurrentMetrics.cpp](https://github.com/ClickHouse/ClickHouse/blob/master/src/Common/CurrentMetrics.cpp) ClickHouse kaynak dosyası. + +**Örnek** + +``` sql +SELECT * FROM system.metrics LIMIT 10 +``` + +``` text +┌─metric─────────────────────┬─value─┬─description──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ +│ Query │ 1 │ Number of executing queries │ +│ Merge │ 0 │ Number of executing background merges │ +│ PartMutation │ 0 │ Number of mutations (ALTER DELETE/UPDATE) │ +│ ReplicatedFetch │ 0 │ Number of data parts being fetched from replicas │ +│ ReplicatedSend │ 0 │ Number of data parts being sent to replicas │ +│ ReplicatedChecks │ 0 │ Number of data parts checking for consistency │ +│ BackgroundPoolTask │ 0 │ Number of active tasks in BackgroundProcessingPool (merges, mutations, fetches, or replication queue bookkeeping) │ +│ BackgroundSchedulePoolTask │ 0 │ Number of active tasks in BackgroundSchedulePool. This pool is used for periodic ReplicatedMergeTree tasks, like cleaning old data parts, altering data parts, replica re-initialization, etc. │ +│ DiskSpaceReservedForMerge │ 0 │ Disk space reserved for currently running background merges. It is slightly more than the total size of currently merging parts. │ +│ DistributedSend │ 0 │ Number of connections to remote servers sending data that was INSERTed into Distributed tables. Both synchronous and asynchronous mode. │ +└────────────────────────────┴───────┴──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [sistem.asynchronous\_metrics](#system_tables-asynchronous_metrics) — Contains periodically calculated metrics. +- [sistem.etkinlik](#system_tables-events) — Contains a number of events that occurred. +- [sistem.metric\_log](#system_tables-metric_log) — Contains a history of metrics values from tables `system.metrics` и `system.events`. +- [İzleme](monitoring.md) — Base concepts of ClickHouse monitoring. + +## sistem.metric\_log {#system_tables-metric_log} + +Tablolardan metrik değerlerinin geçmişini içerir `system.metrics` ve `system.events`, periyodik olarak diske boşaltılır. +Metrik geçmişi koleksiyonunu açmak için `system.metric_log`, oluşturmak `/etc/clickhouse-server/config.d/metric_log.xml` aşağıdaki içerik ile: + +``` xml + + + system + metric_log
+ 7500 + 1000 + + +``` + +**Örnek** + +``` sql +SELECT * FROM system.metric_log LIMIT 1 FORMAT Vertical; +``` + +``` text +Row 1: +────── +event_date: 2020-02-18 +event_time: 2020-02-18 07:15:33 +milliseconds: 554 +ProfileEvent_Query: 0 +ProfileEvent_SelectQuery: 0 +ProfileEvent_InsertQuery: 0 +ProfileEvent_FileOpen: 0 +ProfileEvent_Seek: 0 +ProfileEvent_ReadBufferFromFileDescriptorRead: 1 +ProfileEvent_ReadBufferFromFileDescriptorReadFailed: 0 +ProfileEvent_ReadBufferFromFileDescriptorReadBytes: 0 +ProfileEvent_WriteBufferFromFileDescriptorWrite: 1 +ProfileEvent_WriteBufferFromFileDescriptorWriteFailed: 0 +ProfileEvent_WriteBufferFromFileDescriptorWriteBytes: 56 +... +CurrentMetric_Query: 0 +CurrentMetric_Merge: 0 +CurrentMetric_PartMutation: 0 +CurrentMetric_ReplicatedFetch: 0 +CurrentMetric_ReplicatedSend: 0 +CurrentMetric_ReplicatedChecks: 0 +... +``` + +**Ayrıca bakınız** + +- [sistem.asynchronous\_metrics](#system_tables-asynchronous_metrics) — Contains periodically calculated metrics. +- [sistem.etkinlik](#system_tables-events) — Contains a number of events that occurred. +- [sistem.metrik](#system_tables-metrics) — Contains instantly calculated metrics. +- [İzleme](monitoring.md) — Base concepts of ClickHouse monitoring. + +## sistem.şiir {#system-numbers} + +Bu tablo adında tek bir uint64 sütunu içerir ‘number’ bu sıfırdan başlayarak hemen hemen tüm doğal sayıları içerir. +Bu tabloyu testler için veya kaba kuvvet araması yapmanız gerekiyorsa kullanabilirsiniz. +Bu tablodan okumalar parallelized değil. + +## sistem.numbers\_mt {#system-numbers-mt} + +Olarak aynı ‘system.numbers’ ancak okumalar paralelleştirilmiştir. Sayılar herhangi bir sırayla iade edilebilir. +Testler için kullanılır. + +## sistem.bir {#system-one} + +Bu tablo, tek bir satır içeren tek bir satır içerir ‘dummy’ 0 değerini içeren uint8 sütunu. +SELECT sorgusu FROM yan tümcesi belirtmezse, bu tablo kullanılır. +Bu, diğer Dbms'lerde bulunan ikili tabloya benzer. + +## sistem.parçalar {#system_tables-parts} + +Bölümleri hakkında bilgi içerir [MergeTree](../engines/table_engines/mergetree_family/mergetree.md) Tablolar. + +Her satır bir veri bölümünü açıklar. + +Sütun: + +- `partition` (String) – The partition name. To learn what a partition is, see the description of the [ALTER](../sql_reference/statements/alter.md#query_language_queries_alter) sorgu. + + Biçimliler: + + - `YYYYMM` ay otomatik bölümleme için. + - `any_string` el ile bölümleme yaparken. + +- `name` (`String`) – Name of the data part. + +- `active` (`UInt8`) – Flag that indicates whether the data part is active. If a data part is active, it's used in a table. Otherwise, it's deleted. Inactive data parts remain after merging. + +- `marks` (`UInt64`) – The number of marks. To get the approximate number of rows in a data part, multiply `marks` dizin ayrıntısına göre (genellikle 8192) (bu ipucu uyarlanabilir ayrıntı için çalışmaz). + +- `rows` (`UInt64`) – The number of rows. + +- `bytes_on_disk` (`UInt64`) – Total size of all the data part files in bytes. + +- `data_compressed_bytes` (`UInt64`) – Total size of compressed data in the data part. All the auxiliary files (for example, files with marks) are not included. + +- `data_uncompressed_bytes` (`UInt64`) – Total size of uncompressed data in the data part. All the auxiliary files (for example, files with marks) are not included. + +- `marks_bytes` (`UInt64`) – The size of the file with marks. + +- `modification_time` (`DateTime`) – The time the directory with the data part was modified. This usually corresponds to the time of data part creation.\| + +- `remove_time` (`DateTime`) – The time when the data part became inactive. + +- `refcount` (`UInt32`) – The number of places where the data part is used. A value greater than 2 indicates that the data part is used in queries or merges. + +- `min_date` (`Date`) – The minimum value of the date key in the data part. + +- `max_date` (`Date`) – The maximum value of the date key in the data part. + +- `min_time` (`DateTime`) – The minimum value of the date and time key in the data part. + +- `max_time`(`DateTime`) – The maximum value of the date and time key in the data part. + +- `partition_id` (`String`) – ID of the partition. + +- `min_block_number` (`UInt64`) – The minimum number of data parts that make up the current part after merging. + +- `max_block_number` (`UInt64`) – The maximum number of data parts that make up the current part after merging. + +- `level` (`UInt32`) – Depth of the merge tree. Zero means that the current part was created by insert rather than by merging other parts. + +- `data_version` (`UInt64`) – Number that is used to determine which mutations should be applied to the data part (mutations with a version higher than `data_version`). + +- `primary_key_bytes_in_memory` (`UInt64`) – The amount of memory (in bytes) used by primary key values. + +- `primary_key_bytes_in_memory_allocated` (`UInt64`) – The amount of memory (in bytes) reserved for primary key values. + +- `is_frozen` (`UInt8`) – Flag that shows that a partition data backup exists. 1, the backup exists. 0, the backup doesn't exist. For more details, see [FREEZE PARTITION](../sql_reference/statements/alter.md#alter_freeze-partition) + +- `database` (`String`) – Name of the database. + +- `table` (`String`) – Name of the table. + +- `engine` (`String`) – Name of the table engine without parameters. + +- `path` (`String`) – Absolute path to the folder with data part files. + +- `disk` (`String`) – Name of a disk that stores the data part. + +- `hash_of_all_files` (`String`) – [sifash128](../sql_reference/functions/hash_functions.md#hash_functions-siphash128) sıkıştırılmış dosyaların. + +- `hash_of_uncompressed_files` (`String`) – [sifash128](../sql_reference/functions/hash_functions.md#hash_functions-siphash128) sıkıştırılmamış dosyaların (işaretli dosyalar, dizin dosyası vb.)). + +- `uncompressed_hash_of_compressed_files` (`String`) – [sifash128](../sql_reference/functions/hash_functions.md#hash_functions-siphash128) sıkıştırılmış dosyalardaki verilerin sıkıştırılmamış gibi. + +- `bytes` (`UInt64`) – Alias for `bytes_on_disk`. + +- `marks_size` (`UInt64`) – Alias for `marks_bytes`. + +## sistem.part\_log {#system_tables-part-log} + +Bu `system.part_log` tablo yalnızca aşağıdaki durumlarda oluşturulur: [part\_log](server_configuration_parameters/settings.md#server_configuration_parameters-part-log) sunucu ayarı belirtilir. + +Bu tablo ile oluşan olaylar hakkında bilgi içerir [veri parçaları](../engines/table_engines/mergetree_family/custom_partitioning_key.md) in the [MergeTree](../engines/table_engines/mergetree_family/mergetree.md) veri ekleme veya birleştirme gibi aile tabloları. + +Bu `system.part_log` tablo aşağıdaki sütunları içerir: + +- `event_type` (Enum) — Type of the event that occurred with the data part. Can have one of the following values: + - `NEW_PART` — Inserting of a new data part. + - `MERGE_PARTS` — Merging of data parts. + - `DOWNLOAD_PART` — Downloading a data part. + - `REMOVE_PART` — Removing or detaching a data part using [DETACH PARTITION](../sql_reference/statements/alter.md#alter_detach-partition). + - `MUTATE_PART` — Mutating of a data part. + - `MOVE_PART` — Moving the data part from the one disk to another one. +- `event_date` (Date) — Event date. +- `event_time` (DateTime) — Event time. +- `duration_ms` (UInt64) — Duration. +- `database` (String) — Name of the database the data part is in. +- `table` (String) — Name of the table the data part is in. +- `part_name` (String) — Name of the data part. +- `partition_id` (String) — ID of the partition that the data part was inserted to. The column takes the ‘all’ bölümleme tarafından ise değer `tuple()`. +- `rows` (UInt64) — The number of rows in the data part. +- `size_in_bytes` (UInt64) — Size of the data part in bytes. +- `merged_from` (Array(String)) — An array of names of the parts which the current part was made up from (after the merge). +- `bytes_uncompressed` (UInt64) — Size of uncompressed bytes. +- `read_rows` (UInt64) — The number of rows was read during the merge. +- `read_bytes` (UInt64) — The number of bytes was read during the merge. +- `error` (UInt16) — The code number of the occurred error. +- `exception` (String) — Text message of the occurred error. + +Bu `system.part_log` tablo ilk veri ekleme sonra oluşturulur `MergeTree` Tablo. + +## sistem.işleyişler {#system_tables-processes} + +Bu sistem tablosu uygulamak için kullanılır `SHOW PROCESSLIST` sorgu. + +Sütun: + +- `user` (String) – The user who made the query. Keep in mind that for distributed processing, queries are sent to remote servers under the `default` kullanan. Alan, bu sorgunun başlattığı bir sorgu için değil, belirli bir sorgunun kullanıcı adını içerir. +- `address` (String) – The IP address the request was made from. The same for distributed processing. To track where a distributed query was originally made from, look at `system.processes` sorgu istek sahibi sunucuda. +- `elapsed` (Float64) – The time in seconds since request execution started. +- `rows_read` (UInt64) – The number of rows read from the table. For distributed processing, on the requestor server, this is the total for all remote servers. +- `bytes_read` (UInt64) – The number of uncompressed bytes read from the table. For distributed processing, on the requestor server, this is the total for all remote servers. +- `total_rows_approx` (UInt64) – The approximation of the total number of rows that should be read. For distributed processing, on the requestor server, this is the total for all remote servers. It can be updated during request processing, when new sources to process become known. +- `memory_usage` (UInt64) – Amount of RAM the request uses. It might not include some types of dedicated memory. See the [max\_memory\_usage](../operations/settings/query_complexity.md#settings_max_memory_usage) ayar. +- `query` (String) – The query text. For `INSERT`, eklemek için veri içermez. +- `query_id` (String) – Query ID, if defined. + +## sistem.text\_log {#system-tables-text-log} + +Günlük girişleri içerir. Bu tabloya giden günlük seviyesi ile sınırlı olabilir `text_log.level` sunucu ayarı. + +Sütun: + +- `event_date` (`Date`)- Giriş tarihi. +- `event_time` (`DateTime`)- Giriş zamanı. +- `microseconds` (`UInt32`)- Girişin mikrosaniye. +- `thread_name` (String) — Name of the thread from which the logging was done. +- `thread_id` (UInt64) — OS thread ID. +- `level` (`Enum8`)- Giriş seviyesi. + - `'Fatal' = 1` + - `'Critical' = 2` + - `'Error' = 3` + - `'Warning' = 4` + - `'Notice' = 5` + - `'Information' = 6` + - `'Debug' = 7` + - `'Trace' = 8` +- `query_id` (`String`)- Sorgunun kimliği. +- `logger_name` (`LowCardinality(String)`) - Name of the logger (i.e. `DDLWorker`) +- `message` (`String`)- Mesajın kendisi . +- `revision` (`UInt32`)- ClickHouse revizyon. +- `source_file` (`LowCardinality(String)`)- Günlüğü yapıldığı kaynak dosya. +- `source_line` (`UInt64`)- Kaynak satır hangi günlüğü yapıldı. + +## sistem.query\_log {#system_tables-query_log} + +Sorguların yürütülmesi hakkında bilgi içerir. Her sorgu için, işlem başlangıç saatini, işlem süresini, hata mesajlarını ve diğer bilgileri görebilirsiniz. + +!!! note "Not" + Tablo için giriş verileri içermiyor `INSERT` sorgular. + +ClickHouse bu tabloyu yalnızca [query\_log](server_configuration_parameters/settings.md#server_configuration_parameters-query-log) sunucu parametresi belirtilir. Bu parametre, günlük aralığı veya sorguların oturum açacağı tablonun adı gibi günlük kurallarını ayarlar. + +Sorgu günlüğünü etkinleştirmek için, [log\_queries](settings/settings.md#settings-log-queries) parametre 1. Ayrıntılar için, bkz. [Ayarlar](settings/settings.md) bölme. + +Bu `system.query_log` tablo iki tür sorgu kaydeder: + +1. Doğrudan istemci tarafından çalıştırılan ilk sorgular. +2. Diğer sorgular tarafından başlatılan alt sorgular (dağıtılmış sorgu yürütme için). Bu tür sorgular için, üst sorgular hakkında bilgi `initial_*` sütun. + +Sütun: + +- `type` (`Enum8`) — Type of event that occurred when executing the query. Values: + - `'QueryStart' = 1` — Successful start of query execution. + - `'QueryFinish' = 2` — Successful end of query execution. + - `'ExceptionBeforeStart' = 3` — Exception before the start of query execution. + - `'ExceptionWhileProcessing' = 4` — Exception during the query execution. +- `event_date` (Date) — Query starting date. +- `event_time` (DateTime) — Query starting time. +- `query_start_time` (DateTime) — Start time of query execution. +- `query_duration_ms` (UInt64) — Duration of query execution. +- `read_rows` (UInt64) — Number of read rows. +- `read_bytes` (UInt64) — Number of read bytes. +- `written_rows` (UInt64) — For `INSERT` sorgular, yazılı satır sayısı. Diğer sorgular için sütun değeri 0'dır. +- `written_bytes` (UInt64) — For `INSERT` sorgular, yazılı bayt sayısı. Diğer sorgular için sütun değeri 0'dır. +- `result_rows` (UInt64) — Number of rows in the result. +- `result_bytes` (UInt64) — Number of bytes in the result. +- `memory_usage` (UInt64) — Memory consumption by the query. +- `query` (String) — Query string. +- `exception` (String) — Exception message. +- `stack_trace` (String) — Stack trace (a list of methods called before the error occurred). An empty string, if the query is completed successfully. +- `is_initial_query` (UInt8) — Query type. Possible values: + - 1 — Query was initiated by the client. + - 0 — Query was initiated by another query for distributed query execution. +- `user` (String) — Name of the user who initiated the current query. +- `query_id` (String) — ID of the query. +- `address` (IPv6) — IP address that was used to make the query. +- `port` (UInt16) — The client port that was used to make the query. +- `initial_user` (String) — Name of the user who ran the initial query (for distributed query execution). +- `initial_query_id` (String) — ID of the initial query (for distributed query execution). +- `initial_address` (IPv6) — IP address that the parent query was launched from. +- `initial_port` (UInt16) — The client port that was used to make the parent query. +- `interface` (UInt8) — Interface that the query was initiated from. Possible values: + - 1 — TCP. + - 2 — HTTP. +- `os_user` (String) — OS's username who runs [clickhouse-müşteri](../interfaces/cli.md). +- `client_hostname` (String) — Hostname of the client machine where the [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemcisi çalıştırılır. +- `client_name` (String) — The [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemci adı. +- `client_revision` (UInt32) — Revision of the [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemcisi. +- `client_version_major` (UInt32) — Major version of the [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemcisi. +- `client_version_minor` (UInt32) — Minor version of the [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemcisi. +- `client_version_patch` (UInt32) — Patch component of the [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemci sürümü. +- `http_method` (UInt8) — HTTP method that initiated the query. Possible values: + - 0 — The query was launched from the TCP interface. + - 1 — `GET` yöntem kullanılmıştır. + - 2 — `POST` yöntem kullanılmıştır. +- `http_user_agent` (String) — The `UserAgent` başlık http isteğinde geçti. +- `quota_key` (String) — The “quota key” belirtilen [kotalar](quotas.md) ayarı (bakınız `keyed`). +- `revision` (UInt32) — ClickHouse revision. +- `thread_numbers` (Array(UInt32)) — Number of threads that are participating in query execution. +- `ProfileEvents.Names` (Array(String)) — Counters that measure different metrics. The description of them could be found in the table [sistem.etkinlik](#system_tables-events) +- `ProfileEvents.Values` (Array(UInt64)) — Values of metrics that are listed in the `ProfileEvents.Names` sütun. +- `Settings.Names` (Array(String)) — Names of settings that were changed when the client ran the query. To enable logging changes to settings, set the `log_query_settings` parametre 1. +- `Settings.Values` (Array(String)) — Values of settings that are listed in the `Settings.Names` sütun. + +Her sorgu bir veya iki satır oluşturur `query_log` tablo, sorgunun durumuna bağlı olarak: + +1. Sorgu yürütme başarılı olursa, tip 1 ve 2 ile iki olay oluşturulur (bkz. `type` sütun). +2. Sorgu işleme sırasında bir hata oluştu, iki olay türleri 1 ve 4 oluşturulur. +3. Sorguyu başlatmadan önce bir hata oluşmuşsa, 3 tipi olan tek bir olay oluşturulur. + +Varsayılan olarak, günlükleri 7.5 saniye aralıklarla tabloya eklenir. Bu aralığı ayarlayabilirsiniz [query\_log](server_configuration_parameters/settings.md#server_configuration_parameters-query-log) sunucu ayarı (bkz. `flush_interval_milliseconds` parametre). Günlükleri zorla bellek arabelleğinden tabloya temizlemek için `SYSTEM FLUSH LOGS` sorgu. + +Tablo elle silindiğinde, otomatik olarak anında oluşturulur. Önceki tüm günlüklerin silineceğini unutmayın. + +!!! note "Not" + Günlüklerin depolama süresi sınırsızdır. Günlükler tablodan otomatik olarak silinmez. Eski günlüklerin kaldırılmasını kendiniz düzenlemeniz gerekir. + +İçin keyfi bir bölümleme anahtarı belirtebilirsiniz `system.query_log` tablo içinde [query\_log](server_configuration_parameters/settings.md#server_configuration_parameters-query-log) sunucu ayarı (bkz. `partition_by` parametre). + +## sistem.query\_thread\_log {#system_tables-query-thread-log} + +Tablo, her sorgu yürütme iş parçacığı hakkında bilgi içerir. + +ClickHouse bu tabloyu yalnızca [query\_thread\_log](server_configuration_parameters/settings.md#server_configuration_parameters-query-thread-log) sunucu parametresi belirtilir. Bu parametre, günlük aralığı veya sorguların oturum açacağı tablonun adı gibi günlük kurallarını ayarlar. + +Sorgu günlüğünü etkinleştirmek için, [log\_query\_threads](settings/settings.md#settings-log-query-threads) parametre 1. Ayrıntılar için, bkz. [Ayarlar](settings/settings.md) bölme. + +Sütun: + +- `event_date` (Date) — the date when the thread has finished execution of the query. +- `event_time` (DateTime) — the date and time when the thread has finished execution of the query. +- `query_start_time` (DateTime) — Start time of query execution. +- `query_duration_ms` (UInt64) — Duration of query execution. +- `read_rows` (UInt64) — Number of read rows. +- `read_bytes` (UInt64) — Number of read bytes. +- `written_rows` (UInt64) — For `INSERT` sorgular, yazılı satır sayısı. Diğer sorgular için sütun değeri 0'dır. +- `written_bytes` (UInt64) — For `INSERT` sorgular, yazılı bayt sayısı. Diğer sorgular için sütun değeri 0'dır. +- `memory_usage` (Int64) — The difference between the amount of allocated and freed memory in context of this thread. +- `peak_memory_usage` (Int64) — The maximum difference between the amount of allocated and freed memory in context of this thread. +- `thread_name` (String) — Name of the thread. +- `thread_number` (UInt32) — Internal thread ID. +- `os_thread_id` (Int32) — OS thread ID. +- `master_thread_id` (UInt64) — OS initial ID of initial thread. +- `query` (String) — Query string. +- `is_initial_query` (UInt8) — Query type. Possible values: + - 1 — Query was initiated by the client. + - 0 — Query was initiated by another query for distributed query execution. +- `user` (String) — Name of the user who initiated the current query. +- `query_id` (String) — ID of the query. +- `address` (IPv6) — IP address that was used to make the query. +- `port` (UInt16) — The client port that was used to make the query. +- `initial_user` (String) — Name of the user who ran the initial query (for distributed query execution). +- `initial_query_id` (String) — ID of the initial query (for distributed query execution). +- `initial_address` (IPv6) — IP address that the parent query was launched from. +- `initial_port` (UInt16) — The client port that was used to make the parent query. +- `interface` (UInt8) — Interface that the query was initiated from. Possible values: + - 1 — TCP. + - 2 — HTTP. +- `os_user` (String) — OS's username who runs [clickhouse-müşteri](../interfaces/cli.md). +- `client_hostname` (String) — Hostname of the client machine where the [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemcisi çalıştırılır. +- `client_name` (String) — The [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemci adı. +- `client_revision` (UInt32) — Revision of the [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemcisi. +- `client_version_major` (UInt32) — Major version of the [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemcisi. +- `client_version_minor` (UInt32) — Minor version of the [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemcisi. +- `client_version_patch` (UInt32) — Patch component of the [clickhouse-müşteri](../interfaces/cli.md) veya başka bir TCP istemci sürümü. +- `http_method` (UInt8) — HTTP method that initiated the query. Possible values: + - 0 — The query was launched from the TCP interface. + - 1 — `GET` yöntem kullanılmıştır. + - 2 — `POST` yöntem kullanılmıştır. +- `http_user_agent` (String) — The `UserAgent` başlık http isteğinde geçti. +- `quota_key` (String) — The “quota key” belirtilen [kotalar](quotas.md) ayarı (bakınız `keyed`). +- `revision` (UInt32) — ClickHouse revision. +- `ProfileEvents.Names` (Array(String)) — Counters that measure different metrics for this thread. The description of them could be found in the table [sistem.etkinlik](#system_tables-events) +- `ProfileEvents.Values` (Array(UInt64)) — Values of metrics for this thread that are listed in the `ProfileEvents.Names` sütun. + +Varsayılan olarak, günlükleri 7.5 saniye aralıklarla tabloya eklenir. Bu aralığı ayarlayabilirsiniz [query\_thread\_log](server_configuration_parameters/settings.md#server_configuration_parameters-query-thread-log) sunucu ayarı (bkz. `flush_interval_milliseconds` parametre). Günlükleri zorla bellek arabelleğinden tabloya temizlemek için `SYSTEM FLUSH LOGS` sorgu. + +Tablo elle silindiğinde, otomatik olarak anında oluşturulur. Önceki tüm günlüklerin silineceğini unutmayın. + +!!! note "Not" + Günlüklerin depolama süresi sınırsızdır. Günlükler tablodan otomatik olarak silinmez. Eski günlüklerin kaldırılmasını kendiniz düzenlemeniz gerekir. + +İçin keyfi bir bölümleme anahtarı belirtebilirsiniz `system.query_thread_log` tablo içinde [query\_thread\_log](server_configuration_parameters/settings.md#server_configuration_parameters-query-thread-log) sunucu ayarı (bkz. `partition_by` parametre). + +## sistem.trace\_log {#system_tables-trace_log} + +Örnekleme sorgusu profiler tarafından toplanan yığın izlemeleri içerir. + +ClickHouse bu tabloyu oluşturduğunda [trace\_log](server_configuration_parameters/settings.md#server_configuration_parameters-trace_log) sunucu yapılandırma bölümü ayarlanır. Ayrıca [query\_profiler\_real\_time\_period\_ns](settings/settings.md#query_profiler_real_time_period_ns) ve [query\_profiler\_cpu\_time\_period\_ns](settings/settings.md#query_profiler_cpu_time_period_ns) ayarlar ayarlan .malıdır. + +Günlükleri analiz etmek için `addressToLine`, `addressToSymbol` ve `demangle` iç gözlem fonksiyonları. + +Sütun: + +- `event_date`([Tarihli](../sql_reference/data_types/date.md)) — Date of sampling moment. + +- `event_time`([DateTime](../sql_reference/data_types/datetime.md)) — Timestamp of sampling moment. + +- `revision`([Uİnt32](../sql_reference/data_types/int_uint.md)) — ClickHouse server build revision. + + Tarafından sunucuya Bağlan byırken `clickhouse-client`, benzer diz theg seeeyi görüyorsunuz `Connected to ClickHouse server version 19.18.1 revision 54429.`. Bu alan şunları içerir `revision` ama `version` bir sunucunun. + +- `timer_type`([Enum8](../sql_reference/data_types/enum.md)) — Timer type: + + - `Real` duvar saati zamanını temsil eder. + - `CPU` CPU süresini temsil eder. + +- `thread_number`([Uİnt32](../sql_reference/data_types/int_uint.md)) — Thread identifier. + +- `query_id`([Dize](../sql_reference/data_types/string.md)) — Query identifier that can be used to get details about a query that was running from the [query\_log](#system_tables-query_log) sistem tablosu. + +- `trace`([Dizi (Uİnt64)](../sql_reference/data_types/array.md)) — Stack trace at the moment of sampling. Each element is a virtual memory address inside ClickHouse server process. + +**Örnek** + +``` sql +SELECT * FROM system.trace_log LIMIT 1 \G +``` + +``` text +Row 1: +────── +event_date: 2019-11-15 +event_time: 2019-11-15 15:09:38 +revision: 54428 +timer_type: Real +thread_number: 48 +query_id: acc4d61f-5bd1-4a3e-bc91-2180be37c915 +trace: [94222141367858,94222152240175,94222152325351,94222152329944,94222152330796,94222151449980,94222144088167,94222151682763,94222144088167,94222151682763,94222144088167,94222144058283,94222144059248,94222091840750,94222091842302,94222091831228,94222189631488,140509950166747,140509942945935] +``` + +## sistem.yinelemeler {#system_tables-replicas} + +Yerel sunucuda bulunan çoğaltılmış tablolar için bilgi ve durum içerir. +Bu tablo izleme için kullanılabilir. Tablo, her çoğaltılmış \* tablo için bir satır içerir. + +Örnek: + +``` sql +SELECT * +FROM system.replicas +WHERE table = 'visits' +FORMAT Vertical +``` + +``` text +Row 1: +────── +database: merge +table: visits +engine: ReplicatedCollapsingMergeTree +is_leader: 1 +can_become_leader: 1 +is_readonly: 0 +is_session_expired: 0 +future_parts: 1 +parts_to_check: 0 +zookeeper_path: /clickhouse/tables/01-06/visits +replica_name: example01-06-1.yandex.ru +replica_path: /clickhouse/tables/01-06/visits/replicas/example01-06-1.yandex.ru +columns_version: 9 +queue_size: 1 +inserts_in_queue: 0 +merges_in_queue: 1 +part_mutations_in_queue: 0 +queue_oldest_time: 2020-02-20 08:34:30 +inserts_oldest_time: 0000-00-00 00:00:00 +merges_oldest_time: 2020-02-20 08:34:30 +part_mutations_oldest_time: 0000-00-00 00:00:00 +oldest_part_to_get: +oldest_part_to_merge_to: 20200220_20284_20840_7 +oldest_part_to_mutate_to: +log_max_index: 596273 +log_pointer: 596274 +last_queue_update: 2020-02-20 08:34:32 +absolute_delay: 0 +total_replicas: 2 +active_replicas: 2 +``` + +Sütun: + +- `database` (`String`)- Veritabanı adı +- `table` (`String`)- Tablo adı +- `engine` (`String`)- Tablo motor adı +- `is_leader` (`UInt8`)- Kopya lider olup olmadığı. + Bir seferde sadece bir kopya lider olabilir. Lider, gerçekleştirmek için arka plan birleştirmelerini seçmekten sorumludur. + Yazma kullanılabilir ve bir oturum ZK, bir lider olup olmadığına bakılmaksızın olan herhangi bir yineleme için gerçekleştirilebilir unutmayın. +- `can_become_leader` (`UInt8`)- Rep .lik leaderanın lider olarak seçil .ip seçil .emeyeceği. +- `is_readonly` (`UInt8`)- Yinelemenin salt okunur modda olup olmadığı. + Yapılandırmanın ZooKeeper ile bölümleri yoksa, zookeeper'daki oturumları yeniden başlatırken ve Zookeeper'daki oturum yeniden başlatılırken bilinmeyen bir hata oluşmuşsa bu mod açılır. +- `is_session_expired` (`UInt8`)- ZooKeeper ile oturum süresi doldu. Temelde aynı `is_readonly`. +- `future_parts` (`UInt32`)- Henüz yapılmamış ekler veya birleştirmelerin sonucu olarak görünecek veri parçalarının sayısı. +- `parts_to_check` (`UInt32`)- Doğrulama için kuyruktaki veri parçalarının sayısı. Hasar görebileceğinden şüphe varsa, bir parça doğrulama kuyruğuna konur. +- `zookeeper_path` (`String`)- ZooKeeper tablo verilerine yolu. +- `replica_name` (`String`)- Zookeeper çoğaltma adı. Aynı tablonun farklı kopyaları farklı adlara sahiptir. +- `replica_path` (`String`)- ZooKeeper çoğaltma veri yolu. Birleştirme ile aynı ‘zookeeper\_path/replicas/replica\_path’. +- `columns_version` (`Int32`)- Tablo yapısının sürüm numarası. ALTER kaç kez gerçekleştirildiğini gösterir. Kopyaların farklı sürümleri varsa, bazı kopyaların tüm değişiklikleri henüz yapmadığı anlamına gelir. +- `queue_size` (`UInt32`)- Yapılması beklenen işlemler için sıranın büyüklüğü. İşlemler, veri bloklarını, birleştirmeleri ve diğer bazı eylemleri eklemeyi içerir. Genellikle ile çakışmaktadır `future_parts`. +- `inserts_in_queue` (`UInt32`)- Yapılması gereken veri bloklarının eklerinin sayısı. Eklemeler genellikle oldukça hızlı bir şekilde çoğaltılır. Bu sayı büyükse, bir şeylerin yanlış olduğu anlamına gelir. +- `merges_in_queue` (`UInt32`)- Yapılmasını bekleyen birleştirme sayısı. Bazen birleştirmeler uzundur, bu nedenle bu değer uzun süre sıfırdan büyük olabilir. +- `part_mutations_in_queue` (`UInt32`)- Yapılması beklenen Mut numberasyon sayısı. +- `queue_oldest_time` (`DateTime`) - Eğer `queue_size` daha büyük 0, en eski işlem sıraya eklendiğinde gösterir. +- `inserts_oldest_time` (`DateTime`) - Görmek `queue_oldest_time` +- `merges_oldest_time` (`DateTime`) - Görmek `queue_oldest_time` +- `part_mutations_oldest_time` (`DateTime`) - Görmek `queue_oldest_time` + +Sonraki 4 sütun, yalnızca ZK ile aktif bir oturumun olduğu sıfır olmayan bir değere sahiptir. + +- `log_max_index` (`UInt64`)- Genel faaliyet günlüğüne maksimum giriş numarası. +- `log_pointer` (`UInt64`)- Çoğaltma yürütme kuyruğuna kopyalanan genel faaliyet günlüğüne maksimum giriş numarası, artı bir. Eğer `log_pointer` daha küçük `log_max_index` yanlış bir şey olduğunu. +- `last_queue_update` (`DateTime`)- Kuyruk son kez güncellendiğinde. +- `absolute_delay` (`UInt64`)- Geçerli kopyanın saniyeler içinde ne kadar büyük gecikme var. +- `total_replicas` (`UInt8`)- Bu tablonun bilinen kopyalarının toplam sayısı. +- `active_replicas` (`UInt8`)- ZooKeeper bir oturum var bu tablonun kopyaları sayısı (yani, işleyen kopyaları sayısı). + +Tüm sütunları talep ederseniz, Tablo biraz yavaş çalışabilir, çünkü ZooKeeper birkaç okuma her satır için yapılır. +Son 4 sütun (log\_max\_ındex, log\_pointer, total\_replicas, active\_replicas) istemiyorsanız, tablo hızlı bir şekilde çalışır. + +Örneğin, her şeyin böyle düzgün çalıştığını kontrol edebilirsiniz: + +``` sql +SELECT + database, + table, + is_leader, + is_readonly, + is_session_expired, + future_parts, + parts_to_check, + columns_version, + queue_size, + inserts_in_queue, + merges_in_queue, + log_max_index, + log_pointer, + total_replicas, + active_replicas +FROM system.replicas +WHERE + is_readonly + OR is_session_expired + OR future_parts > 20 + OR parts_to_check > 10 + OR queue_size > 20 + OR inserts_in_queue > 10 + OR log_max_index - log_pointer > 10 + OR total_replicas < 2 + OR active_replicas < total_replicas +``` + +Bu sorgu hiçbir şey döndürmezse, her şeyin yolunda olduğu anlamına gelir. + +## sistem.ayarlar {#system-tables-system-settings} + +Geçerli kullanıcı için oturum ayarları hakkında bilgi içerir. + +Sütun: + +- `name` ([Dize](../sql_reference/data_types/string.md)) — Setting name. +- `value` ([Dize](../sql_reference/data_types/string.md)) — Setting value. +- `changed` ([Uİnt8](../sql_reference/data_types/int_uint.md#uint-ranges)) — Shows whether a setting is changed from its default value. +- `description` ([Dize](../sql_reference/data_types/string.md)) — Short setting description. +- `min` ([Nullable](../sql_reference/data_types/nullable.md)([Dize](../sql_reference/data_types/string.md))) — Minimum value of the setting, if any is set via [kısıtlamalar](settings/constraints_on_settings.md#constraints-on-settings). Ayarın minimum değeri yoksa, şunları içerir [NULL](../sql_reference/syntax.md#null-literal). +- `max` ([Nullable](../sql_reference/data_types/nullable.md)([Dize](../sql_reference/data_types/string.md))) — Maximum value of the setting, if any is set via [kısıtlamalar](settings/constraints_on_settings.md#constraints-on-settings). Ayarın maksimum değeri yoksa, şunları içerir [NULL](../sql_reference/syntax.md#null-literal). +- `readonly` ([Uİnt8](../sql_reference/data_types/int_uint.md#uint-ranges)) — Shows whether the current user can change the setting: + - `0` — Current user can change the setting. + - `1` — Current user can't change the setting. + +**Örnek** + +Aşağıdaki örnek, adı içeren ayarlar hakkında bilgi almak gösterilmiştir `min_i`. + +``` sql +SELECT * +FROM system.settings +WHERE name LIKE '%min_i%' +``` + +``` text +┌─name────────────────────────────────────────┬─value─────┬─changed─┬─description───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┬─min──┬─max──┬─readonly─┐ +│ min_insert_block_size_rows │ 1048576 │ 0 │ Squash blocks passed to INSERT query to specified size in rows, if blocks are not big enough. │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ 0 │ +│ min_insert_block_size_bytes │ 268435456 │ 0 │ Squash blocks passed to INSERT query to specified size in bytes, if blocks are not big enough. │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ 0 │ +│ read_backoff_min_interval_between_events_ms │ 1000 │ 0 │ Settings to reduce the number of threads in case of slow reads. Do not pay attention to the event, if the previous one has passed less than a certain amount of time. │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ 0 │ +└─────────────────────────────────────────────┴───────────┴─────────┴───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┴──────┴──────┴──────────┘ +``` + +Kullanımı `WHERE changed` örneğin, kontrol etmek istediğinizde yararlı olabilir: + +- Olsun yapılandırma dosyaları, ayarları doğru şekilde yüklenmiş ve kullanımdadır. +- Geçerli oturumda değişen ayarlar. + + + +``` sql +SELECT * FROM system.settings WHERE changed AND name='load_balancing' +``` + +**Ayrıca bakınız** + +- [Ayarlar](settings/index.md#settings) +- [Sorgular için izinler](settings/permissions_for_queries.md#settings_readonly) +- [Ayarlardaki kısıtlamalar](settings/constraints_on_settings.md) + +## sistem.table\_engines {#system.table_engines} + +``` text +┌─name───────────────────┬─value───────┐ +│ max_threads │ 8 │ +│ use_uncompressed_cache │ 0 │ +│ load_balancing │ random │ +│ max_memory_usage │ 10000000000 │ +└────────────────────────┴─────────────┘ +``` + +## sistem.merge\_tree\_settings {#system-merge_tree_settings} + +İçin ayarlar hakkında bilgi içerir `MergeTree` Tablolar. + +Sütun: + +- `name` (String) — Setting name. +- `value` (String) — Setting value. +- `description` (String) — Setting description. +- `type` (String) — Setting type (implementation specific string value). +- `changed` (UInt8) — Whether the setting was explicitly defined in the config or explicitly changed. + +## sistem.table\_engines {#system-table-engines} + +Sunucu tarafından desteklenen tablo motorlarının açıklamasını ve özellik destek bilgilerini içerir. + +Bu tablo aşağıdaki sütunları içerir (sütun türü parantez içinde gösterilir): + +- `name` (String) — The name of table engine. +- `supports_settings` (UInt8) — Flag that indicates if table engine supports `SETTINGS` yan. +- `supports_skipping_indices` (UInt8) — Flag that indicates if table engine supports [endeksleri atlama](../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-data_skipping-indexes). +- `supports_ttl` (UInt8) — Flag that indicates if table engine supports [TTL](../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-ttl). +- `supports_sort_order` (UInt8) — Flag that indicates if table engine supports clauses `PARTITION_BY`, `PRIMARY_KEY`, `ORDER_BY` ve `SAMPLE_BY`. +- `supports_replication` (UInt8) — Flag that indicates if table engine supports [veri çoğaltma](../engines/table_engines/mergetree_family/replication.md). +- `supports_duduplication` (UInt8) — Flag that indicates if table engine supports data deduplication. + +Örnek: + +``` sql +SELECT * +FROM system.table_engines +WHERE name in ('Kafka', 'MergeTree', 'ReplicatedCollapsingMergeTree') +``` + +``` text +┌─name──────────────────────────┬─supports_settings─┬─supports_skipping_indices─┬─supports_sort_order─┬─supports_ttl─┬─supports_replication─┬─supports_deduplication─┐ +│ Kafka │ 1 │ 0 │ 0 │ 0 │ 0 │ 0 │ +│ MergeTree │ 1 │ 1 │ 1 │ 1 │ 0 │ 0 │ +│ ReplicatedCollapsingMergeTree │ 1 │ 1 │ 1 │ 1 │ 1 │ 1 │ +└───────────────────────────────┴───────────────────┴───────────────────────────┴─────────────────────┴──────────────┴──────────────────────┴────────────────────────┘ +``` + +**Ayrıca bakınız** + +- MergeTree ailesi [sorgu yan tümceleri](../engines/table_engines/mergetree_family/mergetree.md#mergetree-query-clauses) +- Kafka [ayarlar](../engines/table_engines/integrations/kafka.md#table_engine-kafka-creating-a-table) +- Katmak [ayarlar](../engines/table_engines/special/join.md#join-limitations-and-settings) + +## sistem.Tablolar {#system-tables} + +Sunucunun bildiği her tablonun meta verilerini içerir. Müstakil tablolar gösterilmez `system.tables`. + +Bu tablo aşağıdaki sütunları içerir (sütun türü parantez içinde gösterilir): + +- `database` (String) — The name of the database the table is in. + +- `name` (String) — Table name. + +- `engine` (String) — Table engine name (without parameters). + +- `is_temporary` (Uİnt8) - tablonun geçici olup olmadığını gösteren bayrak. + +- `data_path` (String) - dosya sistemindeki tablo verilerinin yolu. + +- `metadata_path` (String) - dosya sistemindeki tablo Meta Veri Yolu. + +- `metadata_modification_time` (DateTime) - tablo meta son değişiklik zamanı. + +- `dependencies_database` (Array (String)) - veritabanı bağımlılıkları. + +- `dependencies_table` (Array (String)) - Tablo bağımlılıkları ([MaterializedView](../engines/table_engines/special/materializedview.md) geçerli tabloya dayalı tablolar). + +- `create_table_query` (String) - tablo oluşturmak için kullanılan sorgu. + +- `engine_full` (String) - tablo motorunun parametreleri. + +- `partition_key` (String) - tabloda belirtilen bölüm anahtarı ifadesi. + +- `sorting_key` (String) - tabloda belirtilen sıralama anahtarı ifadesi. + +- `primary_key` (String) - tabloda belirtilen birincil anahtar ifadesi. + +- `sampling_key` (String) - tabloda belirtilen örnekleme anahtar ifadesi. + +- `storage_policy` (String) - depolama politikası: + + - [MergeTree](../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-multiple-volumes) + - [Dağılı](../engines/table_engines/special/distributed.md#distributed) + +- `total_rows` (Nullable (Uİnt64)) - tablodaki tam satır sayısını hızlı bir şekilde belirlemek mümkün ise, toplam satır sayısı `Null` (underying dahil `Buffer` Tablo). + +- `total_bytes` (Nullable (Uİnt64)) - toplam bayt sayısı, eğer depolama alanındaki tablo için tam bayt sayısını hızlı bir şekilde belirlemek mümkün ise, aksi takdirde `Null` (**do Notes not** herhangi bir temel depolama içerir). + + - If the table stores data on disk, returns used space on disk (i.e. compressed). + - Tablo verileri bellekte depolarsa, bellekte kullanılan bayt sayısını yaklaşık olarak döndürür. + +Bu `system.tables` tablo kullanılır `SHOW TABLES` sorgu uygulaması. + +## sistem.zookeeper {#system-zookeeper} + +ZooKeeper yapılandırılmamışsa, tablo yok. Yapılandırmada tanımlanan ZooKeeper kümesinden veri okumayı sağlar. +Sorgu bir olmalıdır ‘path’ WH .ere madd .esindeki eşitlik koşulu. Bu veri almak istediğiniz çocuklar için ZooKeeper yoludur. + +Sorgu `SELECT * FROM system.zookeeper WHERE path = '/clickhouse'` tüm çocuklar için veri çıkışı `/clickhouse` düğümlü. +Tüm kök düğümler için veri çıkışı yapmak için, path = yazın ‘/’. +Belirtilen yol ise ‘path’ yok, bir istisna atılır. + +Sütun: + +- `name` (String) — The name of the node. +- `path` (String) — The path to the node. +- `value` (String) — Node value. +- `dataLength` (Int32) — Size of the value. +- `numChildren` (Int32) — Number of descendants. +- `czxid` (Int64) — ID of the transaction that created the node. +- `mzxid` (Int64) — ID of the transaction that last changed the node. +- `pzxid` (Int64) — ID of the transaction that last deleted or added descendants. +- `ctime` (DateTime) — Time of node creation. +- `mtime` (DateTime) — Time of the last modification of the node. +- `version` (Int32) — Node version: the number of times the node was changed. +- `cversion` (Int32) — Number of added or removed descendants. +- `aversion` (Int32) — Number of changes to the ACL. +- `ephemeralOwner` (Int64) — For ephemeral nodes, the ID of the session that owns this node. + +Örnek: + +``` sql +SELECT * +FROM system.zookeeper +WHERE path = '/clickhouse/tables/01-08/visits/replicas' +FORMAT Vertical +``` + +``` text +Row 1: +────── +name: example01-08-1.yandex.ru +value: +czxid: 932998691229 +mzxid: 932998691229 +ctime: 2015-03-27 16:49:51 +mtime: 2015-03-27 16:49:51 +version: 0 +cversion: 47 +aversion: 0 +ephemeralOwner: 0 +dataLength: 0 +numChildren: 7 +pzxid: 987021031383 +path: /clickhouse/tables/01-08/visits/replicas + +Row 2: +────── +name: example01-08-2.yandex.ru +value: +czxid: 933002738135 +mzxid: 933002738135 +ctime: 2015-03-27 16:57:01 +mtime: 2015-03-27 16:57:01 +version: 0 +cversion: 37 +aversion: 0 +ephemeralOwner: 0 +dataLength: 0 +numChildren: 7 +pzxid: 987021252247 +path: /clickhouse/tables/01-08/visits/replicas +``` + +## sistem.mutasyonlar {#system_tables-mutations} + +Tablo hakkında bilgi içerir [mutasyonlar](../sql_reference/statements/alter.md#alter-mutations) MergeTree tabloları ve bunların ilerleme. Her mutasyon komutu tek bir satırla temsil edilir. Tablo aşağıdaki sütunlara sahiptir: + +**veritabanı**, **Tablo** - Mutasyonun uygulandığı veritabanı ve tablonun adı. + +**mutation\_id** - Mutasyonun kimliği. Çoğaltılmış tablolar için bu kimlikler znode adlarına karşılık gelir `/mutations/` ZooKeeper dizin. Yinelenmemiş tablolar için kimlikler, tablonun veri dizinindeki dosya adlarına karşılık gelir. + +**komut** - Mut commandasyon komut diz (gesi (sorgu afterdan sonra `ALTER TABLE [db.]table`). + +**create\_time** - Bu mutasyon komutu idam için sunulduğunda. + +**block\_numbers.partition\_id**, **block\_numbers.numara** - İç içe geçmiş bir sütun. Çoğaltılmış tabloların mutasyonları için, her bölüm için bir kayıt içerir: bölüm kimliği ve mutasyon tarafından elde edilen blok numarası (her bölümde, yalnızca bu bölümdeki mutasyon tarafından elde edilen blok sayısından daha az sayıda blok içeren parçalar mutasyona uğrayacaktır). Çoğaltılmamış tablolarda, tüm bölümlerdeki blok numaraları tek bir sıra oluşturur. Bu, çoğaltılmamış tabloların mutasyonları için, sütunun mutasyon tarafından elde edilen tek bir blok numarasına sahip bir kayıt içereceği anlamına gelir. + +**parts\_to\_do** - Mutasyonun bitmesi için mutasyona uğraması gereken veri parçalarının sayısı. + +**is\_done** - Mutasyon bitti mi? Not bile `parts_to_do = 0` çoğaltılmış bir tablonun mutasyonu, mutasyona uğraması gereken yeni bir veri parçası yaratacak uzun süren bir ekleme nedeniyle henüz yapılmamıştır. + +Bazı bölümleri mutasyon ile ilgili sorunlar varsa, aşağıdaki sütunlar ek bilgi içerir: + +**latest\_failed\_part** - Mutasyona uğramayan en son bölümün adı. + +**latest\_fail\_time** - En son bölüm mutasyon başarısızlığı zamanı. + +**latest\_fail\_reason** - En son bölüm mutasyon başarısızlığına neden olan istisna mesajı. + +## sistem.diskler {#system_tables-disks} + +İçinde tanımlanan diskler hakkında bilgi içerir [sunucu yapılandırması](../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-multiple-volumes_configure). + +Sütun: + +- `name` ([Dize](../sql_reference/data_types/string.md)) — Name of a disk in the server configuration. +- `path` ([Dize](../sql_reference/data_types/string.md)) — Path to the mount point in the file system. +- `free_space` ([Uİnt64](../sql_reference/data_types/int_uint.md)) — Free space on disk in bytes. +- `total_space` ([Uİnt64](../sql_reference/data_types/int_uint.md)) — Disk volume in bytes. +- `keep_free_space` ([Uİnt64](../sql_reference/data_types/int_uint.md)) — Amount of disk space that should stay free on disk in bytes. Defined in the `keep_free_space_bytes` disk yapılandırması parametresi. + +## sistem.storage\_policies {#system_tables-storage_policies} + +Depolama ilkeleri ve birimlerinde tanımlanan bilgiler içerir. [sunucu yapılandırması](../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-multiple-volumes_configure). + +Sütun: + +- `policy_name` ([Dize](../sql_reference/data_types/string.md)) — Name of the storage policy. +- `volume_name` ([Dize](../sql_reference/data_types/string.md)) — Volume name defined in the storage policy. +- `volume_priority` ([Uİnt64](../sql_reference/data_types/int_uint.md)) — Volume order number in the configuration. +- `disks` ([Ar Arrayray (String)](../sql_reference/data_types/array.md)) — Disk names, defined in the storage policy. +- `max_data_part_size` ([Uİnt64](../sql_reference/data_types/int_uint.md)) — Maximum size of a data part that can be stored on volume disks (0 — no limit). +- `move_factor` ([Float64](../sql_reference/data_types/float.md)) — Ratio of free disk space. When the ratio exceeds the value of configuration parameter, ClickHouse start to move data to the next volume in order. + +Depolama ilkesi birden fazla birim içeriyorsa, her birim için bilgiler tablonun tek tek satırında saklanır. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/system_tables/) diff --git a/docs/tr/operations/tips.md b/docs/tr/operations/tips.md new file mode 100644 index 00000000000..e6b02a239c5 --- /dev/null +++ b/docs/tr/operations/tips.md @@ -0,0 +1,251 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 58 +toc_title: "Kullan\u0131m \xD6nerileri" +--- + +# Kullanım Önerileri {#usage-recommendations} + +## CPU Ölçekleme Vali {#cpu-scaling-governor} + +Her zaman kullanın `performance` Ölçekleme Valisi. Bu `on-demand` ölçeklendirme Valisi sürekli yüksek talep ile çok daha kötü çalışır. + +``` bash +$ echo 'performance' | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor +``` + +## CPU sınırlamaları {#cpu-limitations} + +İşlemciler aşırı ısınabilir. Kullanmak `dmesg` aşırı ısınma nedeniyle CPU'nun saat hızının sınırlı olup olmadığını görmek için. +Kısıtlama, veri merkezi düzeyinde harici olarak da ayarlanabilir. Kullanabilirsiniz `turbostat` bir yük altında izlemek için. + +## RAM {#ram} + +Küçük miktarlarda veri için (~200 GB'a kadar sıkıştırılmış), veri hacmi kadar bellek kullanmak en iyisidir. +Büyük miktarda veri için ve etkileşimli (çevrimiçi) sorguları işlerken, sıcak veri alt kümesi sayfaların önbelleğine sığacak şekilde makul miktarda RAM (128 GB veya daha fazla) kullanmalısınız. +Sunucu başına ~50 TB veri hacimleri için bile, 128 GB RAM kullanmak, 64 GB'ye kıyasla sorgu performansını önemli ölçüde artırır. + +Overcommit devre dışı bırakmayın. Değer `cat /proc/sys/vm/overcommit_memory` 0 veya 1 olmalıdır. Koşmak + +``` bash +$ echo 0 | sudo tee /proc/sys/vm/overcommit_memory +``` + +## Büyük Sayfalar {#huge-pages} + +Her zaman şeffaf büyük sayfaları devre dışı bırakın. Önemli performans düşmesine neden olan bellek yöneticileri, engel oluyor. + +``` bash +$ echo 'never' | sudo tee /sys/kernel/mm/transparent_hugepage/enabled +``` + +Kullanmak `perf top` bellek yönetimi için çekirdekte harcanan zamanı izlemek için. +Kalıcı büyük sayfaların da tahsis edilmesine gerek yoktur. + +## Depolama Alt Sistemi {#storage-subsystem} + +Bütçeniz SSD kullanmanıza izin veriyorsa, SSD kullanın. +Eğer değilse, sabit disk kullanın. SATA HDD'ler 7200 RPM yapacak. + +Bağlı disk raflarına sahip daha az sayıda sunucu üzerinde yerel sabit disklere sahip birçok sunucuyu tercih edin. +Ancak nadir sorguları olan arşivleri saklamak için raflar çalışacaktır. + +## RAID {#raid} + +HDD kullanırken, RAID-10, RAID-5, RAID-6 veya RAID-50'yi birleştirebilirsiniz. +Linux için, yazılım RAID daha iyidir (ile `mdadm`). LVM'Yİ kullanmanızı önermiyoruz. +RAID-10 oluştururken, `far` düzen. +Bütçeniz izin veriyorsa, RAID-10'u seçin. + +4'ten fazla diskiniz varsa, RAID-5 yerine RAID-6 (tercih edilen) veya RAID-50 kullanın. +RAID-5, RAID-6 veya RAID-50 kullanırken, varsayılan değer genellikle en iyi seçenek olmadığından daima stripe\_cache\_size değerini artırın. + +``` bash +$ echo 4096 | sudo tee /sys/block/md2/md/stripe_cache_size +``` + +Formülü kullanarak cihaz sayısından ve blok boyutundan tam sayıyı hesaplayın: `2 * num_devices * chunk_size_in_bytes / 4096`. + +Tüm RAID yapılandırmaları için 1024 KB blok boyutu yeterlidir. +Blok boyutunu asla çok küçük veya çok büyük ayarlamayın. + +SSD'DE RAID-0 kullanabilirsiniz. +RAID kullanımı ne olursa olsun, her zaman veri güvenliği için çoğaltma kullanın. + +Uzun bir kuyruk ile NCQ etkinleştirin. HDD için CFQ zamanlayıcısını seçin ve SSD için noop'u seçin. Azalt themayın ‘readahead’ ayar. +HDD için yazma önbelleğini etkinleştirin. + +## Dosya Sistemi {#file-system} + +Ext4 en güvenilir seçenektir. Bağlama seçeneklerini ayarlama `noatime, nobarrier`. +XFS de uygundur, ancak ClickHouse ile iyice test edilmemiştir. +Diğer çoğu dosya sistemi de iyi çalışmalıdır. Gecikmeli tahsisli dosya sistemleri daha iyi çalışır. + +## Linux Çekirdeği {#linux-kernel} + +Eski bir Linux çekirdeği kullanmayın. + +## Ağ {#network} + +IPv6 kullanıyorsanız, rota önbelleğinin boyutunu artırın. +3.2 öncesinde Linux çekirdeği IPv6 uygulaması ile ilgili sorunlar çok sayıda vardı. + +Mümkünse en az 10 GB ağ kullanın. 1 Gb de çalışacak, ancak onlarca terabayt veri içeren kopyaları yamalamak veya büyük miktarda Ara veriyle dağıtılmış sorguları işlemek için çok daha kötü olacaktır. + +## ZooKeeper {#zookeeper} + +Muhtemelen zaten başka amaçlar için ZooKeeper kullanıyor. Zaten aşırı değilse, aynı ZooKeeper kurulumunu kullanabilirsiniz. + +It's best to use a fresh version of ZooKeeper – 3.4.9 or later. The version in stable Linux distributions may be outdated. + +Sonuç sıralı düğümler için yanlış olacağından, farklı ZooKeeper kümeleri arasında veri aktarmak için el ile yazılmış komut dosyalarını asla kullanmamalısınız. Asla kullanmayın “zkcopy” aynı nedenle yardımcı program: https://github.com/ksprojects/zkcopy/issues/15 + +Varolan bir ZooKeeper kümesini ikiye bölmek istiyorsanız, doğru yol, yinelemelerinin sayısını artırmak ve sonra iki bağımsız küme olarak yeniden yapılandırmaktır. + +Zookeeper ClickHouse aynı sunucularda çalıştırmayın. ZooKeeper gecikme için çok hassas olduğundan ve ClickHouse mevcut tüm sistem kaynaklarını kullanabilir. + +Varsayılan ayarlarla, ZooKeeper bir saatli bomba: + +> ZooKeeper sunucusu, varsayılan yapılandırmayı kullanırken eski anlık görüntülerden ve günlüklerden dosyaları silmez (bkz.autopurge) ve bu operatörün sorumluluğundadır. + +Bu bomba etkisiz hale getirilmeli. + +Aşağıdaki ZooKeeper (3.5.1) yapılandırması Yandex'te kullanılmaktadır.20 Mayıs 2017 tarihi itibariyle Metrica üretim ortamı: + +hayvanat bahçesi.cfg: + +``` bash +# http://hadoop.apache.org/zookeeper/docs/current/zookeeperAdmin.html + +# The number of milliseconds of each tick +tickTime=2000 +# The number of ticks that the initial +# synchronization phase can take +initLimit=30000 +# The number of ticks that can pass between +# sending a request and getting an acknowledgement +syncLimit=10 + +maxClientCnxns=2000 + +maxSessionTimeout=60000000 +# the directory where the snapshot is stored. +dataDir=/opt/zookeeper/{{ '{{' }} cluster['name'] {{ '}}' }}/data +# Place the dataLogDir to a separate physical disc for better performance +dataLogDir=/opt/zookeeper/{{ '{{' }} cluster['name'] {{ '}}' }}/logs + +autopurge.snapRetainCount=10 +autopurge.purgeInterval=1 + + +# To avoid seeks ZooKeeper allocates space in the transaction log file in +# blocks of preAllocSize kilobytes. The default block size is 64M. One reason +# for changing the size of the blocks is to reduce the block size if snapshots +# are taken more often. (Also, see snapCount). +preAllocSize=131072 + +# Clients can submit requests faster than ZooKeeper can process them, +# especially if there are a lot of clients. To prevent ZooKeeper from running +# out of memory due to queued requests, ZooKeeper will throttle clients so that +# there is no more than globalOutstandingLimit outstanding requests in the +# system. The default limit is 1,000.ZooKeeper logs transactions to a +# transaction log. After snapCount transactions are written to a log file a +# snapshot is started and a new transaction log file is started. The default +# snapCount is 10,000. +snapCount=3000000 + +# If this option is defined, requests will be will logged to a trace file named +# traceFile.year.month.day. +#traceFile= + +# Leader accepts client connections. Default value is "yes". The leader machine +# coordinates updates. For higher update throughput at thes slight expense of +# read throughput the leader can be configured to not accept clients and focus +# on coordination. +leaderServes=yes + +standaloneEnabled=false +dynamicConfigFile=/etc/zookeeper-{{ '{{' }} cluster['name'] {{ '}}' }}/conf/zoo.cfg.dynamic +``` + +Java sürümü: + +``` text +Java(TM) SE Runtime Environment (build 1.8.0_25-b17) +Java HotSpot(TM) 64-Bit Server VM (build 25.25-b02, mixed mode) +``` + +JVM parametreleri: + +``` bash +NAME=zookeeper-{{ '{{' }} cluster['name'] {{ '}}' }} +ZOOCFGDIR=/etc/$NAME/conf + +# TODO this is really ugly +# How to find out, which jars are needed? +# seems, that log4j requires the log4j.properties file to be in the classpath +CLASSPATH="$ZOOCFGDIR:/usr/build/classes:/usr/build/lib/*.jar:/usr/share/zookeeper/zookeeper-3.5.1-metrika.jar:/usr/share/zookeeper/slf4j-log4j12-1.7.5.jar:/usr/share/zookeeper/slf4j-api-1.7.5.jar:/usr/share/zookeeper/servlet-api-2.5-20081211.jar:/usr/share/zookeeper/netty-3.7.0.Final.jar:/usr/share/zookeeper/log4j-1.2.16.jar:/usr/share/zookeeper/jline-2.11.jar:/usr/share/zookeeper/jetty-util-6.1.26.jar:/usr/share/zookeeper/jetty-6.1.26.jar:/usr/share/zookeeper/javacc.jar:/usr/share/zookeeper/jackson-mapper-asl-1.9.11.jar:/usr/share/zookeeper/jackson-core-asl-1.9.11.jar:/usr/share/zookeeper/commons-cli-1.2.jar:/usr/src/java/lib/*.jar:/usr/etc/zookeeper" + +ZOOCFG="$ZOOCFGDIR/zoo.cfg" +ZOO_LOG_DIR=/var/log/$NAME +USER=zookeeper +GROUP=zookeeper +PIDDIR=/var/run/$NAME +PIDFILE=$PIDDIR/$NAME.pid +SCRIPTNAME=/etc/init.d/$NAME +JAVA=/usr/bin/java +ZOOMAIN="org.apache.zookeeper.server.quorum.QuorumPeerMain" +ZOO_LOG4J_PROP="INFO,ROLLINGFILE" +JMXLOCALONLY=false +JAVA_OPTS="-Xms{{ '{{' }} cluster.get('xms','128M') {{ '}}' }} \ + -Xmx{{ '{{' }} cluster.get('xmx','1G') {{ '}}' }} \ + -Xloggc:/var/log/$NAME/zookeeper-gc.log \ + -XX:+UseGCLogFileRotation \ + -XX:NumberOfGCLogFiles=16 \ + -XX:GCLogFileSize=16M \ + -verbose:gc \ + -XX:+PrintGCTimeStamps \ + -XX:+PrintGCDateStamps \ + -XX:+PrintGCDetails + -XX:+PrintTenuringDistribution \ + -XX:+PrintGCApplicationStoppedTime \ + -XX:+PrintGCApplicationConcurrentTime \ + -XX:+PrintSafepointStatistics \ + -XX:+UseParNewGC \ + -XX:+UseConcMarkSweepGC \ +-XX:+CMSParallelRemarkEnabled" +``` + +Tuz ve Karab saltiber: + +``` text +description "zookeeper-{{ '{{' }} cluster['name'] {{ '}}' }} centralized coordination service" + +start on runlevel [2345] +stop on runlevel [!2345] + +respawn + +limit nofile 8192 8192 + +pre-start script + [ -r "/etc/zookeeper-{{ '{{' }} cluster['name'] {{ '}}' }}/conf/environment" ] || exit 0 + . /etc/zookeeper-{{ '{{' }} cluster['name'] {{ '}}' }}/conf/environment + [ -d $ZOO_LOG_DIR ] || mkdir -p $ZOO_LOG_DIR + chown $USER:$GROUP $ZOO_LOG_DIR +end script + +script + . /etc/zookeeper-{{ '{{' }} cluster['name'] {{ '}}' }}/conf/environment + [ -r /etc/default/zookeeper ] && . /etc/default/zookeeper + if [ -z "$JMXDISABLE" ]; then + JAVA_OPTS="$JAVA_OPTS -Dcom.sun.management.jmxremote -Dcom.sun.management.jmxremote.local.only=$JMXLOCALONLY" + fi + exec start-stop-daemon --start -c $USER --exec $JAVA --name zookeeper-{{ '{{' }} cluster['name'] {{ '}}' }} \ + -- -cp $CLASSPATH $JAVA_OPTS -Dzookeeper.log.dir=${ZOO_LOG_DIR} \ + -Dzookeeper.root.logger=${ZOO_LOG4J_PROP} $ZOOMAIN $ZOOCFG +end script +``` + +{## [Orijinal makale](https://clickhouse.tech/docs/en/operations/tips/) ##} diff --git a/docs/tr/operations/troubleshooting.md b/docs/tr/operations/troubleshooting.md new file mode 100644 index 00000000000..f16a59767d6 --- /dev/null +++ b/docs/tr/operations/troubleshooting.md @@ -0,0 +1,146 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 46 +toc_title: "Ar\u0131za" +--- + +# Arıza {#troubleshooting} + +- [Kurulum](#troubleshooting-installation-errors) +- [Sunucuya bağlanma](#troubleshooting-accepts-no-connections) +- [Sorgu işleme](#troubleshooting-does-not-process-queries) +- [Sorgu işleme verimliliği](#troubleshooting-too-slow) + +## Kurulum {#troubleshooting-installation-errors} + +### Apt-get ile ClickHouse deposundan Deb paketleri alınamıyor {#you-cannot-get-deb-packages-from-clickhouse-repository-with-apt-get} + +- Güvenlik Duvarı ayarlarını kontrol edin. +- Depoya herhangi bir nedenle erişemiyorsanız, paketleri aşağıda açıklandığı gibi indirin [Başlarken](../getting_started/index.md) makale ve bunları kullanarak manuel olarak yükleyin `sudo dpkg -i ` komut. Ayrıca ihtiyacınız olacak `tzdata` paket. + +## Sunucuya bağlanma {#troubleshooting-accepts-no-connections} + +Olası sorunlar: + +- Sunucu çalışmıyor. +- Beklenmeyen veya yanlış yapılandırma parametreleri. + +### Sunucu Çalışmıyor {#server-is-not-running} + +**Sunucu runnnig olup olmadığını kontrol edin** + +Komut: + +``` bash +$ sudo service clickhouse-server status +``` + +Sunucu çalışmıyorsa, komutla başlatın: + +``` bash +$ sudo service clickhouse-server start +``` + +**Günlükleri kontrol et** + +Ana günlüğü `clickhouse-server` içinde `/var/log/clickhouse-server/clickhouse-server.log` varsayılan olarak. + +Sunucu başarıyla başlatıldıysa, dizeleri görmelisiniz: + +- ` Application: starting up.` — Server started. +- ` Application: Ready for connections.` — Server is running and ready for connections. + +Eğer `clickhouse-server` Başlat bir yapılandırma hatası ile başarısız oldu, görmelisiniz `` bir hata açıklaması ile dize. Mesela: + +``` text +2019.01.11 15:23:25.549505 [ 45 ] {} ExternalDictionaries: Failed reloading 'event2id' external dictionary: Poco::Exception. Code: 1000, e.code() = 111, e.displayText() = Connection refused, e.what() = Connection refused +``` + +Dosyanın sonunda bir hata görmüyorsanız, dizeden başlayarak tüm dosyaya bakın: + +``` text + Application: starting up. +``` + +İkinci bir örneğini başlatmaya çalışırsanız `clickhouse-server` sunucuda, aşağıdaki günlük bakın: + +``` text +2019.01.11 15:25:11.151730 [ 1 ] {} : Starting ClickHouse 19.1.0 with revision 54413 +2019.01.11 15:25:11.154578 [ 1 ] {} Application: starting up +2019.01.11 15:25:11.156361 [ 1 ] {} StatusFile: Status file ./status already exists - unclean restart. Contents: +PID: 8510 +Started at: 2019-01-11 15:24:23 +Revision: 54413 + +2019.01.11 15:25:11.156673 [ 1 ] {} Application: DB::Exception: Cannot lock file ./status. Another server instance in same directory is already running. +2019.01.11 15:25:11.156682 [ 1 ] {} Application: shutting down +2019.01.11 15:25:11.156686 [ 1 ] {} Application: Uninitializing subsystem: Logging Subsystem +2019.01.11 15:25:11.156716 [ 2 ] {} BaseDaemon: Stop SignalListener thread +``` + +**Bkz. sistem.d günlükleri** + +Eğer herhangi bir yararlı bilgi bulamazsanız `clickhouse-server` günlükler veya herhangi bir günlük yok, görüntüleyebilirsiniz `system.d` komutu kullanarak günlükleri: + +``` bash +$ sudo journalctl -u clickhouse-server +``` + +**Clickhouse-Server'ı etkileşimli modda Başlat** + +``` bash +$ sudo -u clickhouse /usr/bin/clickhouse-server --config-file /etc/clickhouse-server/config.xml +``` + +Bu komut, sunucuyu otomatik başlatma komut dosyasının standart parametreleriyle etkileşimli bir uygulama olarak başlatır. Bu modda `clickhouse-server` konsoldaki tüm olay iletilerini yazdırır. + +### Yapılandırma Parametreleri {#configuration-parameters} + +Kontrol: + +- Docker ayarları. + + Bir IPv6 ağında Docker'da ClickHouse çalıştırırsanız, `network=host` ayar .lanmıştır. + +- Bitiş noktası ayarları. + + Kontrol [listen\_host](server_configuration_parameters/settings.md#server_configuration_parameters-listen_host) ve [tcp\_port](server_configuration_parameters/settings.md#server_configuration_parameters-tcp_port) ayarlar. + + ClickHouse server, yalnızca varsayılan olarak localhost bağlantılarını kabul eder. + +- HTTP protokolü ayarları. + + HTTP API protokol ayarlarını denetleyin. + +- Güvenli bağlantı ayarları. + + Kontrol: + + - Bu [tcp\_port\_secure](server_configuration_parameters/settings.md#server_configuration_parameters-tcp_port_secure) ayar. + - İçin ayarlar [SSL sertifikaları](server_configuration_parameters/settings.md#server_configuration_parameters-openssl). + + Bağlanırken uygun parametreleri kullanın. Örneğin, kullanın `port_secure` parametre ile `clickhouse_client`. + +- Kullanıcı ayarları. + + Yanlış kullanıcı adı veya parola kullanıyor olabilirsiniz. + +## Sorgu İşleme {#troubleshooting-does-not-process-queries} + +ClickHouse sorguyu işlemek mümkün değilse, istemciye bir hata açıklaması gönderir. İn the `clickhouse-client` konsoldaki hatanın bir açıklamasını alırsınız. Http arabirimini kullanıyorsanız, ClickHouse yanıt gövdesinde hata açıklamasını gönderir. Mesela: + +``` bash +$ curl 'http://localhost:8123/' --data-binary "SELECT a" +Code: 47, e.displayText() = DB::Exception: Unknown identifier: a. Note that there are no tables (FROM clause) in your query, context: required_names: 'a' source_tables: table_aliases: private_aliases: column_aliases: public_columns: 'a' masked_columns: array_join_columns: source_columns: , e.what() = DB::Exception +``` + +Eğer başlarsanız `clickhouse-client` ile... `stack-trace` parametre, ClickHouse bir hata açıklaması ile sunucu yığın izleme döndürür. + +Bozuk bir bağlantı hakkında bir mesaj görebilirsiniz. Bu durumda, sorguyu tekrarlayabilirsiniz. Sorguyu her gerçekleştirdiğinizde bağlantı kesilirse, sunucu günlüklerini hatalar için denetleyin. + +## Sorgu işleme verimliliği {#troubleshooting-too-slow} + +Clickhouse'un çok yavaş çalıştığını görürseniz, sorgularınız için sunucu kaynakları ve ağdaki yükü profillemeniz gerekir. + +Profil sorguları için clickhouse-benchmark yardımcı programını kullanabilirsiniz. Saniyede işlenen sorgu sayısını, saniyede işlenen satır sayısını ve sorgu işleme sürelerinin yüzdelerini gösterir. diff --git a/docs/tr/operations/update.md b/docs/tr/operations/update.md new file mode 100644 index 00000000000..1529729321e --- /dev/null +++ b/docs/tr/operations/update.md @@ -0,0 +1,20 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 47 +toc_title: "ClickHouse G\xFCncelleme" +--- + +# ClickHouse Güncelleme {#clickhouse-update} + +ClickHouse DEB paketlerinden yüklüyse, sunucuda aşağıdaki komutları çalıştırın: + +``` bash +$ sudo apt-get update +$ sudo apt-get install clickhouse-client clickhouse-server +$ sudo service clickhouse-server restart +``` + +Önerilen deb paketleri dışında bir şey kullanarak ClickHouse yüklediyseniz, uygun güncelleştirme yöntemini kullanın. + +ClickHouse dağıtılmış bir güncelleştirmeyi desteklemiyor. İşlem, her ayrı sunucuda ardışık olarak gerçekleştirilmelidir. Bir kümedeki tüm sunucuları aynı anda güncelleştirmeyin veya küme Bir süre kullanılamaz. diff --git a/docs/tr/operations/utilities/clickhouse-benchmark.md b/docs/tr/operations/utilities/clickhouse-benchmark.md new file mode 100644 index 00000000000..952852d880e --- /dev/null +++ b/docs/tr/operations/utilities/clickhouse-benchmark.md @@ -0,0 +1,156 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 61 +toc_title: clickhouse-benchmark +--- + +# clickhouse-benchmark {#clickhouse-benchmark} + +Bir ClickHouse sunucusuna bağlanır ve art arda belirtilen sorguları gönderir. + +Sözdizimi: + +``` bash +$ echo "single query" | clickhouse-benchmark [keys] +``` + +veya + +``` bash +$ clickhouse-benchmark [keys] <<< "single query" +``` + +Bir dizi sorgu göndermek istiyorsanız, Bir metin dosyası oluşturun ve her sorguyu bu dosyadaki tek tek dizeye yerleştirin. Mesela: + +``` sql +SELECT * FROM system.numbers LIMIT 10000000 +SELECT 1 +``` + +Sonra bu dosyayı standart bir girişe geçirin `clickhouse-benchmark`. + +``` bash +clickhouse-benchmark [keys] < queries_file +``` + +## Anahtarlar {#clickhouse-benchmark-keys} + +- `-c N`, `--concurrency=N` — Number of queries that `clickhouse-benchmark` aynı anda gönderir. Varsayılan değer: 1. +- `-d N`, `--delay=N` — Interval in seconds between intermediate reports (set 0 to disable reports). Default value: 1. +- `-h WORD`, `--host=WORD` — Server host. Default value: `localhost`. İçin [karşılaştırma modu](#clickhouse-benchmark-comparison-mode) birden fazla kullanabilirsiniz `-h` anahtarlar. +- `-p N`, `--port=N` — Server port. Default value: 9000. For the [karşılaştırma modu](#clickhouse-benchmark-comparison-mode) birden fazla kullanabilirsiniz `-p` anahtarlar. +- `-i N`, `--iterations=N` — Total number of queries. Default value: 0. +- `-r`, `--randomize` — Random order of queries execution if there is more then one input query. +- `-s`, `--secure` — Using TLS connection. +- `-t N`, `--timelimit=N` — Time limit in seconds. `clickhouse-benchmark` belirtilen zaman sınırına ulaşıldığında sorgu göndermeyi durdurur. Varsayılan değer: 0 (zaman sınırı devre dışı). +- `--confidence=N` — Level of confidence for T-test. Possible values: 0 (80%), 1 (90%), 2 (95%), 3 (98%), 4 (99%), 5 (99.5%). Default value: 5. In the [karşılaştırma modu](#clickhouse-benchmark-comparison-mode) `clickhouse-benchmark` gerçekleştirir [Bağımsız iki örnek öğrencinin t-testi](https://en.wikipedia.org/wiki/Student%27s_t-test#Independent_two-sample_t-test) iki dağıtımın seçilen güven düzeyi ile farklı olup olmadığını belirlemek için sınayın. +- `--cumulative` — Printing cumulative data instead of data per interval. +- `--database=DATABASE_NAME` — ClickHouse database name. Default value: `default`. +- `--json=FILEPATH` — JSON output. When the key is set, `clickhouse-benchmark` belirtilen json dosyasına bir rapor verir. +- `--user=USERNAME` — ClickHouse user name. Default value: `default`. +- `--password=PSWD` — ClickHouse user password. Default value: empty string. +- `--stacktrace` — Stack traces output. When the key is set, `clickhouse-bencmark` çıkışlar özel durumların izlerini yığın. +- `--stage=WORD` — Query processing stage at server. ClickHouse stops query processing and returns answer to `clickhouse-benchmark` belirtilen aşamada. Olası değerler: `complete`, `fetch_columns`, `with_mergeable_state`. Varsayılan değer: `complete`. +- `--help` — Shows the help message. + +Bazı uygulamak istiyorsanız [ayarlar](../../operations/settings/index.md) sorgular için bunları bir anahtar olarak geçirin `--= SETTING_VALUE`. Mesela, `--max_memory_usage=1048576`. + +## Çıktı {#clickhouse-benchmark-output} + +Varsayılan olarak, `clickhouse-benchmark` her biri için raporlar `--delay` aralıklı. + +Rapor örneği: + +``` text +Queries executed: 10. + +localhost:9000, queries 10, QPS: 6.772, RPS: 67904487.440, MiB/s: 518.070, result RPS: 67721584.984, result MiB/s: 516.675. + +0.000% 0.145 sec. +10.000% 0.146 sec. +20.000% 0.146 sec. +30.000% 0.146 sec. +40.000% 0.147 sec. +50.000% 0.148 sec. +60.000% 0.148 sec. +70.000% 0.148 sec. +80.000% 0.149 sec. +90.000% 0.150 sec. +95.000% 0.150 sec. +99.000% 0.150 sec. +99.900% 0.150 sec. +99.990% 0.150 sec. +``` + +Raporda bulabilirsiniz: + +- Sorgu sayısı `Queries executed:` alan. + +- İçeren durum dizesi (sırayla): + + - ClickHouse sunucusunun bitiş noktası. + - İşlenen sorgu sayısı. + - QPS: qps: kaç sorgu sunucusu saniyede belirtilen bir süre boyunca gerçekleştirilen `--delay` değişken. + - RPS: kaç satır sunucu saniyede belirtilen bir süre boyunca okuma `--delay` değişken. + - MıB / s: kaç mebibytes sunucu saniyede belirtilen bir süre boyunca okuma `--delay` değişken. + - sonuç RPS: sunucu tarafından belirtilen bir süre boyunca saniyede bir sorgunun sonucuna kaç satır yerleştirilir `--delay` değişken. + - sonuç MıB / s. kaç mebibytes sunucu tarafından belirtilen bir dönemde saniyede bir sorgu sonucu yerleştirilir `--delay` değişken. + +- Sorgu yürütme süresi yüzdelik. + +## Karşılaştırma modu {#clickhouse-benchmark-comparison-mode} + +`clickhouse-benchmark` iki çalışan ClickHouse sunucuları için performansları karşılaştırabilirsiniz. + +Karşılaştırma modunu kullanmak için, her iki sunucunun bitiş noktalarını iki çift `--host`, `--port` anahtarlar. Anahtarlar argüman listesindeki konuma göre eşleşti, ilk `--host` ilk ile eşleştirilir `--port` ve böyle devam eder. `clickhouse-benchmark` her iki sunucuya da bağlantılar kurar, sonra sorgular gönderir. Her sorgu rastgele seçilen bir sunucuya gönderilir. Sonuçlar her sunucu için ayrı ayrı gösterilir. + +## Örnek {#clickhouse-benchmark-example} + +``` bash +$ echo "SELECT * FROM system.numbers LIMIT 10000000 OFFSET 10000000" | clickhouse-benchmark -i 10 +``` + +``` text +Loaded 1 queries. + +Queries executed: 6. + +localhost:9000, queries 6, QPS: 6.153, RPS: 123398340.957, MiB/s: 941.455, result RPS: 61532982.200, result MiB/s: 469.459. + +0.000% 0.159 sec. +10.000% 0.159 sec. +20.000% 0.159 sec. +30.000% 0.160 sec. +40.000% 0.160 sec. +50.000% 0.162 sec. +60.000% 0.164 sec. +70.000% 0.165 sec. +80.000% 0.166 sec. +90.000% 0.166 sec. +95.000% 0.167 sec. +99.000% 0.167 sec. +99.900% 0.167 sec. +99.990% 0.167 sec. + + + +Queries executed: 10. + +localhost:9000, queries 10, QPS: 6.082, RPS: 121959604.568, MiB/s: 930.478, result RPS: 60815551.642, result MiB/s: 463.986. + +0.000% 0.159 sec. +10.000% 0.159 sec. +20.000% 0.160 sec. +30.000% 0.163 sec. +40.000% 0.164 sec. +50.000% 0.165 sec. +60.000% 0.166 sec. +70.000% 0.166 sec. +80.000% 0.167 sec. +90.000% 0.167 sec. +95.000% 0.170 sec. +99.000% 0.172 sec. +99.900% 0.172 sec. +99.990% 0.172 sec. +``` diff --git a/docs/tr/operations/utilities/clickhouse-copier.md b/docs/tr/operations/utilities/clickhouse-copier.md new file mode 100644 index 00000000000..932519086c1 --- /dev/null +++ b/docs/tr/operations/utilities/clickhouse-copier.md @@ -0,0 +1,176 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 59 +toc_title: clickhouse-fotokopi makinesi +--- + +# clickhouse-fotokopi makinesi {#clickhouse-copier} + +Bir kümedeki tablolardan başka bir (veya aynı) kümedeki tablolara veri kopyalar. + +Birden fazla çalıştırabilirsiniz `clickhouse-copier` aynı işi gerçekleştirmek için farklı sunuculardaki örnekler. ZooKeeper süreçleri senkronize etmek için kullanılır. + +Başladıktan sonra, `clickhouse-copier`: + +- ZooKeeper bağlanır ve alır: + + - Kopyalama işleri. + - Kopyalama işlerinin durumu. + +- İşleri gerçekleştirir. + + Her çalışan işlem seçer “closest” kaynak kümenin parçası ve verileri hedef kümeye kopyalar, gerekirse verileri yeniden şekillendirir. + +`clickhouse-copier` ZooKeeper değişiklikleri izler ve anında uygular. + +Ağ trafiğini azaltmak için çalıştırmanızı öneririz `clickhouse-copier` kaynak verilerin bulunduğu aynı sunucuda. + +## Clickhouse çalışan-fotokopi {#running-clickhouse-copier} + +Yardımcı program el ile çalıştırılmalıdır: + +``` bash +$ clickhouse-copier copier --daemon --config zookeeper.xml --task-path /task/path --base-dir /path/to/dir +``` + +Parametre: + +- `daemon` — Starts `clickhouse-copier` daemon modunda. +- `config` — The path to the `zookeeper.xml` ZooKeeper bağlantı parametreleri ile dosya. +- `task-path` — The path to the ZooKeeper node. This node is used for syncing `clickhouse-copier` süreçleri ve depolama görevleri. Görevler saklanır `$task-path/description`. +- `task-file` — Optional path to file with task configuration for initial upload to ZooKeeper. +- `task-upload-force` — Force upload `task-file` düğüm zaten var olsa bile. +- `base-dir` — The path to logs and auxiliary files. When it starts, `clickhouse-copier` oluşturuyor `clickhouse-copier_YYYYMMHHSS_` içinde alt dizinler `$base-dir`. Bu parametre atlanırsa, dizinler aşağıdaki dizinde oluşturulur `clickhouse-copier` başlatıldı. + +## Zookeeper biçimi.xml {#format-of-zookeeper-xml} + +``` xml + + + trace + 100M + 3 + + + + + 127.0.0.1 + 2181 + + + +``` + +## Kopyalama görevlerinin yapılandırması {#configuration-of-copying-tasks} + +``` xml + + + + + + false + + 127.0.0.1 + 9000 + + + ... + + + + ... + + + + + 2 + + + + 1 + + + + + 0 + + + + + 3 + + 1 + + + + + + + + source_cluster + test + hits + + + destination_cluster + test + hits2 + + + + ENGINE=ReplicatedMergeTree('/clickhouse/tables/{cluster}/{shard}/hits2', '{replica}') + PARTITION BY toMonday(date) + ORDER BY (CounterID, EventDate) + + + + jumpConsistentHash(intHash64(UserID), 2) + + + CounterID != 0 + + + + '2018-02-26' + '2018-03-05' + ... + + + + + + ... + + ... + + +``` + +`clickhouse-copier` değişiklikleri izler `/task/path/description` ve onları anında uygular. Örneğin, değerini değiştirirseniz `max_workers`, görevleri çalıştıran süreçlerin sayısı da değişecektir. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/utils/clickhouse-copier/) diff --git a/docs/tr/operations/utilities/clickhouse-local.md b/docs/tr/operations/utilities/clickhouse-local.md new file mode 100644 index 00000000000..5e47459b670 --- /dev/null +++ b/docs/tr/operations/utilities/clickhouse-local.md @@ -0,0 +1,81 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 60 +toc_title: clickhouse-yerel +--- + +# clickhouse-yerel {#clickhouse-local} + +Bu `clickhouse-local` program, ClickHouse sunucusunu dağıtmak ve yapılandırmak zorunda kalmadan yerel dosyalar üzerinde hızlı işlem yapmanızı sağlar. + +Tabloları temsil eden verileri kabul eder ve bunları kullanarak sorgular [ClickHouse SQL lehçesi](../../sql_reference/index.md). + +`clickhouse-local` ClickHouse server ile aynı çekirdeği kullanır, bu nedenle özelliklerin çoğunu ve aynı format ve tablo motorlarını destekler. + +Varsayılan olarak `clickhouse-local` aynı ana bilgisayarda verilere erişimi yok, ancak kullanarak yükleme sunucu yapılandırmasını destekler `--config-file` değişken. + +!!! warning "Uyarıcı" + İçine üretim sunucusu yapılandırmasını yüklemek için tavsiye edilmez `clickhouse-local` çünkü insan hatası durumunda veriler zarar görebilir. + +## Kullanma {#usage} + +Temel kullanım: + +``` bash +$ clickhouse-local --structure "table_structure" --input-format "format_of_incoming_data" -q "query" +``` + +Değişkenler: + +- `-S`, `--structure` — table structure for input data. +- `-if`, `--input-format` — input format, `TSV` varsayılan olarak. +- `-f`, `--file` — path to data, `stdin` varsayılan olarak. +- `-q` `--query` — queries to execute with `;` delimeter olarak. +- `-N`, `--table` — table name where to put output data, `table` varsayılan olarak. +- `-of`, `--format`, `--output-format` — output format, `TSV` varsayılan olarak. +- `--stacktrace` — whether to dump debug output in case of exception. +- `--verbose` — more details on query execution. +- `-s` — disables `stderr` günlük. +- `--config-file` — path to configuration file in same format as for ClickHouse server, by default the configuration empty. +- `--help` — arguments references for `clickhouse-local`. + +Ayrıca, bunun yerine daha yaygın olarak kullanılan her ClickHouse yapılandırma değişkeni için argümanlar vardır `--config-file`. + +## Örnekler {#examples} + +``` bash +$ echo -e "1,2\n3,4" | clickhouse-local -S "a Int64, b Int64" -if "CSV" -q "SELECT * FROM table" +Read 2 rows, 32.00 B in 0.000 sec., 5182 rows/sec., 80.97 KiB/sec. +1 2 +3 4 +``` + +Önceki örnek aynıdır: + +``` bash +$ echo -e "1,2\n3,4" | clickhouse-local -q "CREATE TABLE table (a Int64, b Int64) ENGINE = File(CSV, stdin); SELECT a, b FROM table; DROP TABLE table" +Read 2 rows, 32.00 B in 0.000 sec., 4987 rows/sec., 77.93 KiB/sec. +1 2 +3 4 +``` + +Şimdi her Unix kullanıcısı için bellek kullanıcısını çıkaralım: + +``` bash +$ ps aux | tail -n +2 | awk '{ printf("%s\t%s\n", $1, $4) }' | clickhouse-local -S "user String, mem Float64" -q "SELECT user, round(sum(mem), 2) as memTotal FROM table GROUP BY user ORDER BY memTotal DESC FORMAT Pretty" +``` + +``` text +Read 186 rows, 4.15 KiB in 0.035 sec., 5302 rows/sec., 118.34 KiB/sec. +┏━━━━━━━━━━┳━━━━━━━━━━┓ +┃ user ┃ memTotal ┃ +┡━━━━━━━━━━╇━━━━━━━━━━┩ +│ bayonet │ 113.5 │ +├──────────┼──────────┤ +│ root │ 8.8 │ +├──────────┼──────────┤ +... +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/utils/clickhouse-local/) diff --git a/docs/tr/operations/utilities/index.md b/docs/tr/operations/utilities/index.md new file mode 100644 index 00000000000..17d3849cc6a --- /dev/null +++ b/docs/tr/operations/utilities/index.md @@ -0,0 +1,15 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: Programlar +toc_priority: 56 +toc_title: "Genel bak\u0131\u015F" +--- + +# ClickHouse Programı {#clickhouse-utility} + +- [clickhouse-yerel](clickhouse-local.md) — Allows running SQL queries on data without stopping the ClickHouse server, similar to how `awk` bunu yapar. +- [clickhouse-fotokopi makinesi](clickhouse-copier.md) — Copies (and reshards) data from one cluster to another cluster. +- [clickhouse-benchmark](clickhouse-benchmark.md) — Loads server with the custom queries and settings. + +[Orijinal makale](https://clickhouse.tech/docs/en/operations/utils/) diff --git a/docs/tr/sql_reference/aggregate_functions/combinators.md b/docs/tr/sql_reference/aggregate_functions/combinators.md new file mode 100644 index 00000000000..693bf5e0348 --- /dev/null +++ b/docs/tr/sql_reference/aggregate_functions/combinators.md @@ -0,0 +1,166 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 37 +toc_title: "Toplama fonksiyonu birle\u015Ftiriciler" +--- + +# Toplama Fonksiyonu Birleştiriciler {#aggregate_functions_combinators} + +Bir toplama işlevinin adı, ona eklenmiş bir sonek olabilir. Bu, toplama işlevinin çalışma şeklini değiştirir. + +## -Eğer {#agg-functions-combinator-if} + +The suffix -If can be appended to the name of any aggregate function. In this case, the aggregate function accepts an extra argument – a condition (Uint8 type). The aggregate function processes only the rows that trigger the condition. If the condition was not triggered even once, it returns a default value (usually zeros or empty strings). + +Örnekler: `sumIf(column, cond)`, `countIf(cond)`, `avgIf(x, cond)`, `quantilesTimingIf(level1, level2)(x, cond)`, `argMinIf(arg, val, cond)` ve böyle devam eder. + +Koşullu toplama işlevleriyle, alt sorgular kullanmadan aynı anda birkaç koşul için toplamları hesaplayabilirsiniz ve `JOIN`s. Örneğin, Üye olarak.Metrica, koşullu toplama işlevleri segment karşılaştırma işlevselliğini uygulamak için kullanılır. + +## -Dizi {#agg-functions-combinator-array} + +\- Array soneki herhangi bir toplama işlevine eklenebilir. Bu durumda, toplama işlevi, ‘Array(T)’ type (ar arraysra )ys) yerine ‘T’ bağımsız değişkenleri yazın. Toplama işlevi birden çok bağımsız değişken kabul ederse, bu eşit uzunlukta diziler olmalıdır. Dizileri işlerken, toplama işlevi tüm dizi öğelerinde orijinal toplama işlevi gibi çalışır. + +Örnek 1: `sumArray(arr)` - Tüm unsurları toplamları ‘arr’ diziler. Bu örnekte, daha basit yazılmış olabilir: `sum(arraySum(arr))`. + +Örnek 2: `uniqArray(arr)` – Counts the number of unique elements in all ‘arr’ diziler. Bu daha kolay bir şekilde yapılabilir: `uniq(arrayJoin(arr))`, ancak eklemek her zaman mümkün değildir ‘arrayJoin’ bir sorguya. + +\- Eğer ve-dizi kombine edilebilir. Ancak, ‘Array’ önce gel mustmeli, sonra ‘If’. Örnekler: `uniqArrayIf(arr, cond)`, `quantilesTimingArrayIf(level1, level2)(arr, cond)`. Nedeniyle bu sipariş için, ‘cond’ argüman bir dizi olmayacak. + +## -Devlet {#agg-functions-combinator-state} + +Bu birleştiriciyi uygularsanız, toplama işlevi elde edilen değeri döndürmez (örneğin, [uniq](reference.md#agg_function-uniq) fonksiyonu), ancak top aggreglamanın bir ara durumu (for `uniq`, bu benzersiz değerlerin sayısını hesaplamak için karma tablodur). Bu bir `AggregateFunction(...)` bu, daha fazla işlem için kullanılabilir veya daha sonra toplanmayı bitirmek için bir tabloda saklanabilir. + +Bu durumlarla çalışmak için şunları kullanın: + +- [AggregatingMergeTree](../../engines/table_engines/mergetree_family/aggregatingmergetree.md) masa motoru. +- [finalizeAggregation](../../sql_reference/functions/other_functions.md#function-finalizeaggregation) işlev. +- [runningAccumulate](../../sql_reference/functions/other_functions.md#function-runningaccumulate) işlev. +- [-Birleştirmek](#aggregate_functions_combinators_merge) birleştirici. +- [- MergeState](#aggregate_functions_combinators_mergestate) birleştirici. + +## -Birleştirmek {#aggregate_functions_combinators-merge} + +Bu birleştiriciyi uygularsanız, toplama işlevi Ara toplama durumunu bağımsız değişken olarak alır, toplama işlemini tamamlamak için durumları birleştirir ve elde edilen değeri döndürür. + +## - MergeState {#aggregate_functions_combinators-mergestate} + +Ara toplama durumlarını-birleştirme Birleştiricisi ile aynı şekilde birleştirir. Bununla birlikte, elde edilen değeri döndürmez, ancak-State combinator'a benzer bir ara toplama durumu döndürür. + +## - ForEach {#agg-functions-combinator-foreach} + +Tablolar için bir toplama işlevi, karşılık gelen dizi öğelerini toplayan ve bir dizi sonuç döndüren diziler için bir toplama işlevine dönüştürür. Mesela, `sumForEach` diz theiler için `[1, 2]`, `[3, 4, 5]`ve`[6, 7]`sonucu döndürür `[10, 13, 5]` karşılık gelen dizi öğelerini bir araya getirdikten sonra. + +## - OrDefault {#agg-functions-combinator-ordefault} + +Toplamak için hiçbir şey yoksa, toplama işlevinin dönüş türünün Varsayılan değerini doldurur. + +``` sql +SELECT avg(number), avgOrDefault(number) FROM numbers(0) +``` + +``` text +┌─avg(number)─┬─avgOrDefault(number)─┐ +│ nan │ 0 │ +└─────────────┴──────────────────────┘ +``` + +## - OrNull {#agg-functions-combinator-ornull} + +Doldurmalar `null` toplamak için hiçbir şey varsa. Dönüş sütun null olur. + +``` sql +SELECT avg(number), avgOrNull(number) FROM numbers(0) +``` + +``` text +┌─avg(number)─┬─avgOrNull(number)─┐ +│ nan │ ᴺᵁᴸᴸ │ +└─────────────┴───────────────────┘ +``` + +\- OrDefault ve-OrNull diğer birleştiriciler ile kombine edilebilir. Toplama işlevi boş girişi kabul etmediğinde yararlıdır. + +``` sql +SELECT avgOrNullIf(x, x > 10) +FROM +( + SELECT toDecimal32(1.23, 2) AS x +) +``` + +``` text +┌─avgOrNullIf(x, greater(x, 10))─┐ +│ ᴺᵁᴸᴸ │ +└────────────────────────────────┘ +``` + +## - Resample {#agg-functions-combinator-resample} + +Verileri gruplara ayırmanızı sağlar ve ardından bu gruplardaki verileri ayrı ayrı toplar. Gruplar, değerleri bir sütundan aralıklara bölerek oluşturulur. + +``` sql +Resample(start, end, step)(, resampling_key) +``` + +**Parametre** + +- `start` — Starting value of the whole required interval for `resampling_key` değerler. +- `stop` — Ending value of the whole required interval for `resampling_key` değerler. Tüm Aralık içermez `stop` değer `[start, stop)`. +- `step` — Step for separating the whole interval into subintervals. The `aggFunction` bu alt aralıkların her biri üzerinde bağımsız olarak yürütülür. +- `resampling_key` — Column whose values are used for separating data into intervals. +- `aggFunction_params` — `aggFunction` parametre. + +**Döndürülen değerler** + +- Ar arrayray of `aggFunction` her subinterval için sonuçlar. + +**Örnek** + +Düşünün `people` aşağıdaki verilerle tablo: + +``` text +┌─name───┬─age─┬─wage─┐ +│ John │ 16 │ 10 │ +│ Alice │ 30 │ 15 │ +│ Mary │ 35 │ 8 │ +│ Evelyn │ 48 │ 11.5 │ +│ David │ 62 │ 9.9 │ +│ Brian │ 60 │ 16 │ +└────────┴─────┴──────┘ +``` + +Yaş aralığı içinde olan kişilerin isimlerini alalım `[30,60)` ve `[60,75)`. Yaş için tamsayı temsilini kullandığımızdan, yaşları `[30, 59]` ve `[60,74]` aralıklılar. + +Bir dizideki isimleri toplamak için, [groupArray](reference.md#agg_function-grouparray) toplama işlevi. Bir argüman alır. Bizim durumumuzda, bu `name` sütun. Bu `groupArrayResample` fonksiyon kullanmalıdır `age` yaşlara göre isimleri toplamak için sütun. Gerekli aralıkları tanımlamak için `30, 75, 30` argü themanlar içine `groupArrayResample` işlev. + +``` sql +SELECT groupArrayResample(30, 75, 30)(name, age) FROM people +``` + +``` text +┌─groupArrayResample(30, 75, 30)(name, age)─────┐ +│ [['Alice','Mary','Evelyn'],['David','Brian']] │ +└───────────────────────────────────────────────┘ +``` + +Sonuçları düşünün. + +`Jonh` çok genç olduğu için numunenin dışında. Diğer insanlar belirtilen yaş aralıklarına göre dağıtılır. + +Şimdi toplam insan sayısını ve ortalama ücretlerini belirtilen yaş aralıklarında sayalım. + +``` sql +SELECT + countResample(30, 75, 30)(name, age) AS amount, + avgResample(30, 75, 30)(wage, age) AS avg_wage +FROM people +``` + +``` text +┌─amount─┬─avg_wage──────────────────┐ +│ [3,2] │ [11.5,12.949999809265137] │ +└────────┴───────────────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/agg_functions/combinators/) diff --git a/docs/tr/sql_reference/aggregate_functions/index.md b/docs/tr/sql_reference/aggregate_functions/index.md new file mode 100644 index 00000000000..b1699ab5b62 --- /dev/null +++ b/docs/tr/sql_reference/aggregate_functions/index.md @@ -0,0 +1,62 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "Toplama Fonksiyonlar\u0131" +toc_priority: 33 +toc_title: "Giri\u015F" +--- + +# Toplama fonksiyonları {#aggregate-functions} + +Toplama fonksiyonları [normal](http://www.sql-tutorial.com/sql-aggregate-functions-sql-tutorial) veritabanı uzmanları tarafından beklendiği gibi. + +ClickHouse da destekler: + +- [Parametrik agrega fonksiyonları](parametric_functions.md#aggregate_functions_parametric), sütunlara ek olarak diğer parametreleri kabul eder. +- [Birleştiriciler](combinators.md#aggregate_functions_combinators) toplama işlevlerinin davranışını değiştiren. + +## NULL işleme {#null-processing} + +Toplama sırasında, tüm `NULL`s atlanır. + +**Örnekler:** + +Bu tabloyu düşünün: + +``` text +┌─x─┬────y─┐ +│ 1 │ 2 │ +│ 2 │ ᴺᵁᴸᴸ │ +│ 3 │ 2 │ +│ 3 │ 3 │ +│ 3 │ ᴺᵁᴸᴸ │ +└───┴──────┘ +``` + +Diyelim ki değerleri toplamanız gerekiyor `y` sütun: + +``` sql +SELECT sum(y) FROM t_null_big +``` + + ┌─sum(y)─┐ + │ 7 │ + └────────┘ + +Bu `sum` fonksiyon yorumlar `NULL` olarak `0`. Özellikle, bu, işlevin tüm değerlerin bulunduğu bir seçimin girişini aldığı anlamına gelir `NULL`, sonra sonuç olacak `0`, değil `NULL`. + +Şimdi kullanabilirsiniz `groupArray` bir dizi oluşturmak için işlev `y` sütun: + +``` sql +SELECT groupArray(y) FROM t_null_big +``` + +``` text +┌─groupArray(y)─┐ +│ [2,2,3] │ +└───────────────┘ +``` + +`groupArray` içermez `NULL` elde edilen dizi. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/agg_functions/) diff --git a/docs/tr/sql_reference/aggregate_functions/parametric_functions.md b/docs/tr/sql_reference/aggregate_functions/parametric_functions.md new file mode 100644 index 00000000000..557b844ef00 --- /dev/null +++ b/docs/tr/sql_reference/aggregate_functions/parametric_functions.md @@ -0,0 +1,499 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 38 +toc_title: "Parametrik agrega fonksiyonlar\u0131" +--- + +# Parametrik Agrega Fonksiyonları {#aggregate_functions_parametric} + +Some aggregate functions can accept not only argument columns (used for compression), but a set of parameters – constants for initialization. The syntax is two pairs of brackets instead of one. The first is for parameters, and the second is for arguments. + +## çubuk {#histogram} + +Uyarlanabilir bir histogram hesaplar. Kesin sonuçları garanti etmez. + +``` sql +histogram(number_of_bins)(values) +``` + +İşlevleri kullanır [Bir Akış Paralel Karar Ağacı Algoritması](http://jmlr.org/papers/volume11/ben-haim10a/ben-haim10a.pdf). Histogram kutularının sınırları, yeni veriler bir işleve girdiğinde ayarlanır. Ortak durumda, kutu genişlikleri eşit değildir. + +**Parametre** + +`number_of_bins` — Upper limit for the number of bins in the histogram. The function automatically calculates the number of bins. It tries to reach the specified number of bins, but if it fails, it uses fewer bins. +`values` — [İfade](../syntax.md#syntax-expressions) giriş değerleri ile sonuçlanır. + +**Döndürülen değerler** + +- [Dizi](../../sql_reference/data_types/array.md) -den [Demetler](../../sql_reference/data_types/tuple.md) aşağıdaki format oftan: + + ``` + [(lower_1, upper_1, height_1), ... (lower_N, upper_N, height_N)] + ``` + + - `lower` — Lower bound of the bin. + - `upper` — Upper bound of the bin. + - `height` — Calculated height of the bin. + +**Örnek** + +``` sql +SELECT histogram(5)(number + 1) +FROM ( + SELECT * + FROM system.numbers + LIMIT 20 +) +``` + +``` text +┌─histogram(5)(plus(number, 1))───────────────────────────────────────────┐ +│ [(1,4.5,4),(4.5,8.5,4),(8.5,12.75,4.125),(12.75,17,4.625),(17,20,3.25)] │ +└─────────────────────────────────────────────────────────────────────────┘ +``` + +Bir histogram ile görselleştirebilirsiniz [bar](../../sql_reference/functions/other_functions.md#function-bar) fonksiyon, örneğin: + +``` sql +WITH histogram(5)(rand() % 100) AS hist +SELECT + arrayJoin(hist).3 AS height, + bar(height, 0, 6, 5) AS bar +FROM +( + SELECT * + FROM system.numbers + LIMIT 20 +) +``` + +``` text +┌─height─┬─bar───┐ +│ 2.125 │ █▋ │ +│ 3.25 │ ██▌ │ +│ 5.625 │ ████▏ │ +│ 5.625 │ ████▏ │ +│ 3.375 │ ██▌ │ +└────────┴───────┘ +``` + +Bu durumda, histogram kutusu kenarlıklarını bilmediğinizi unutmamalısınız. + +## sequenceMatch(pattern)(timestamp, cond1, cond2, …) {#function-sequencematch} + +Dizinin desenle eşleşen bir olay zinciri içerip içermediğini denetler. + +``` sql +sequenceMatch(pattern)(timestamp, cond1, cond2, ...) +``` + +!!! warning "Uyarıcı" + Aynı saniyede meydana gelen olaylar sonucu etkileyen tanımsız bir sırada sırayla yatıyordu. + +**Parametre** + +- `pattern` — Pattern string. See [Desen sözdizimi](#sequence-function-pattern-syntax). + +- `timestamp` — Column considered to contain time data. Typical data types are `Date` ve `DateTime`. Ayrıca desteklenen herhangi birini kullanabilirsiniz [Uİnt](../../sql_reference/data_types/int_uint.md) veri türleri. + +- `cond1`, `cond2` — Conditions that describe the chain of events. Data type: `UInt8`. En fazla 32 koşul argümanını iletebilirsiniz. İşlev yalnızca bu koşullarda açıklanan olayları dikkate alır. Sıra, bir koşulda açıklanmayan veriler içeriyorsa, işlev bunları atlar. + +**Döndürülen değerler** + +- 1, Eğer desen eşleşti. +- Desen eşleşmezse 0. + +Tür: `UInt8`. + + +**Desen sözdizimi** + +- `(?N)` — Matches the condition argument at position `N`. Şartlar numaralandırılmıştır `[1, 32]` Aralık. Mesela, `(?1)` argü theman thela eşleş their `cond1` parametre. + +- `.*` — Matches any number of events. You don't need conditional arguments to match this element of the pattern. + +- `(?t operator value)` — Sets the time in seconds that should separate two events. For example, pattern `(?1)(?t>1800)(?2)` birbirinden 1800 saniyeden fazla meydana gelen olayları eşleşir. Bu olaylar arasında herhangi bir olayın keyfi bir sayısı olabilir. Kullanabilirsiniz `>=`, `>`, `<`, `<=` operatörler. + +**Örnekler** + +Verileri göz önünde bulundurun `t` Tablo: + +``` text +┌─time─┬─number─┐ +│ 1 │ 1 │ +│ 2 │ 3 │ +│ 3 │ 2 │ +└──────┴────────┘ +``` + +Sorguyu gerçekleştir: + +``` sql +SELECT sequenceMatch('(?1)(?2)')(time, number = 1, number = 2) FROM t +``` + +``` text +┌─sequenceMatch('(?1)(?2)')(time, equals(number, 1), equals(number, 2))─┐ +│ 1 │ +└───────────────────────────────────────────────────────────────────────┘ +``` + +İşlev, 2 numarasının 1 numarayı takip ettiği olay zincirini buldu. Sayı bir olay olarak tanımlanmadığı için aralarında 3 sayısını atladı. Örnekte verilen olay zincirini ararken bu numarayı dikkate almak istiyorsak, bunun için bir koşul oluşturmalıyız. + +``` sql +SELECT sequenceMatch('(?1)(?2)')(time, number = 1, number = 2, number = 3) FROM t +``` + +``` text +┌─sequenceMatch('(?1)(?2)')(time, equals(number, 1), equals(number, 2), equals(number, 3))─┐ +│ 0 │ +└──────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +Bu durumda, işlev desenle eşleşen olay zincirini bulamadı, çünkü 3 numaralı olay 1 ile 2 arasında gerçekleşti. Aynı durumda 4 numaralı koşulu kontrol edersek, sıra desenle eşleşir. + +``` sql +SELECT sequenceMatch('(?1)(?2)')(time, number = 1, number = 2, number = 4) FROM t +``` + +``` text +┌─sequenceMatch('(?1)(?2)')(time, equals(number, 1), equals(number, 2), equals(number, 4))─┐ +│ 1 │ +└──────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [sequenceCount](#function-sequencecount) + +## sequenceCount(pattern)(time, cond1, cond2, …) {#function-sequencecount} + +Desenle eşleşen olay zincirlerinin sayısını sayar. İşlev, çakışmayan olay zincirlerini arar. Geçerli zincir eşleştirildikten sonra bir sonraki zinciri aramaya başlar. + +!!! warning "Uyarıcı" + Aynı saniyede meydana gelen olaylar sonucu etkileyen tanımsız bir sırada sırayla yatıyordu. + +``` sql +sequenceCount(pattern)(timestamp, cond1, cond2, ...) +``` + +**Parametre** + +- `pattern` — Pattern string. See [Desen sözdizimi](#sequence-function-pattern-syntax). + +- `timestamp` — Column considered to contain time data. Typical data types are `Date` ve `DateTime`. Ayrıca desteklenen herhangi birini kullanabilirsiniz [Uİnt](../../sql_reference/data_types/int_uint.md) veri türleri. + +- `cond1`, `cond2` — Conditions that describe the chain of events. Data type: `UInt8`. En fazla 32 koşul argümanını iletebilirsiniz. İşlev yalnızca bu koşullarda açıklanan olayları dikkate alır. Sıra, bir koşulda açıklanmayan veriler içeriyorsa, işlev bunları atlar. + +**Döndürülen değerler** + +- Eşleşen çakışmayan olay zincirlerinin sayısı. + +Tür: `UInt64`. + +**Örnek** + +Verileri göz önünde bulundurun `t` Tablo: + +``` text +┌─time─┬─number─┐ +│ 1 │ 1 │ +│ 2 │ 3 │ +│ 3 │ 2 │ +│ 4 │ 1 │ +│ 5 │ 3 │ +│ 6 │ 2 │ +└──────┴────────┘ +``` + +2 numara aralarında diğer sayıların herhangi bir miktarda 1 numaradan sonra meydana kaç kez Sayın: + +``` sql +SELECT sequenceCount('(?1).*(?2)')(time, number = 1, number = 2) FROM t +``` + +``` text +┌─sequenceCount('(?1).*(?2)')(time, equals(number, 1), equals(number, 2))─┐ +│ 2 │ +└─────────────────────────────────────────────────────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [sequenceMatch](#function-sequencematch) + +## windowFunnel {#windowfunnel} + +Kayan bir zaman penceresinde olay zincirlerini arar ve zincirden meydana gelen en fazla olay sayısını hesaplar. + +Fonksiyon algoritmaya göre çalışır: + +- İşlev, zincirdeki ilk koşulu tetikleyen ve olay sayacını 1'e ayarlayan verileri arar. Sürgülü pencerenin başladığı an budur. + +- Zincirdeki olaylar pencerede sırayla gerçekleşirse, sayaç artırılır. Olayların sırası bozulursa, sayaç artırılmaz. + +- Verilerin çeşitli tamamlanma noktalarında birden çok olay zinciri varsa, işlev yalnızca en uzun zincirin boyutunu çıkarır. + +**Sözdizimi** + +``` sql +windowFunnel(window, [mode])(timestamp, cond1, cond2, ..., condN) +``` + +**Parametre** + +- `window` — Length of the sliding window in seconds. +- `mode` - Bu isteğe bağlı bir argüman. + - `'strict'` - Zaman `'strict'` ayarlanırsa, windowFunnel () yalnızca benzersiz değerler için koşullar uygular. +- `timestamp` — Name of the column containing the timestamp. Data types supported: [Tarihli](../../sql_reference/data_types/date.md), [DateTime](../../sql_reference/data_types/datetime.md#data_type-datetime) ve diğer imzasız tamsayı türleri (timestamp'ın `UInt64` yazın, değeri 2^63 - 1 olan Int64 maksimum değerini aşamaz). +- `cond` — Conditions or data describing the chain of events. [Uİnt8](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değer** + +Sürgülü zaman penceresi içindeki zincirden ardışık tetiklenen koşulların maksimum sayısı. +Seçimdeki tüm zincirler analiz edilir. + +Tür: `Integer`. + +**Örnek** + +Kullanıcının bir telefon seçmesi ve çevrimiçi mağazada iki kez satın alması için belirli bir süre yeterli olup olmadığını belirleyin. + +Aşağıdaki olaylar zincirini ayarlayın: + +1. Mağaz theadaki Hesabına giriş yapan kullanıcı (`eventID = 1003`). +2. Kullanıcı bir telefon arar (`eventID = 1007, product = 'phone'`). +3. Kullanıcı sipariş verdi (`eventID = 1009`). +4. Kullanıcı tekrar sipariş yaptı (`eventID = 1010`). + +Giriş tablosu: + +``` text +┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐ +│ 2019-01-28 │ 1 │ 2019-01-29 10:00:00 │ 1003 │ phone │ +└────────────┴─────────┴─────────────────────┴─────────┴─────────┘ +┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐ +│ 2019-01-31 │ 1 │ 2019-01-31 09:00:00 │ 1007 │ phone │ +└────────────┴─────────┴─────────────────────┴─────────┴─────────┘ +┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐ +│ 2019-01-30 │ 1 │ 2019-01-30 08:00:00 │ 1009 │ phone │ +└────────────┴─────────┴─────────────────────┴─────────┴─────────┘ +┌─event_date─┬─user_id─┬───────────timestamp─┬─eventID─┬─product─┐ +│ 2019-02-01 │ 1 │ 2019-02-01 08:00:00 │ 1010 │ phone │ +└────────────┴─────────┴─────────────────────┴─────────┴─────────┘ +``` + +Kullanıcının ne kadar uzakta olduğunu öğrenin `user_id` 2019 yılının Ocak-Şubat aylarında bir dönemde zincirden geçebilir. + +Sorgu: + +``` sql +SELECT + level, + count() AS c +FROM +( + SELECT + user_id, + windowFunnel(6048000000000000)(timestamp, eventID = 1003, eventID = 1009, eventID = 1007, eventID = 1010) AS level + FROM trend + WHERE (event_date >= '2019-01-01') AND (event_date <= '2019-02-02') + GROUP BY user_id +) +GROUP BY level +ORDER BY level ASC +``` + +Sonuç: + +``` text +┌─level─┬─c─┐ +│ 4 │ 1 │ +└───────┴───┘ +``` + +## saklama {#retention} + +İşlev, bağımsız değişken olarak 1'den 32'ye kadar bir dizi koşul türünü alır `UInt8` bu, etkinlik için belirli bir koşulun karşılanıp karşılanmadığını gösterir. +Herhangi bir koşul bir argüman olarak belirtilebilir (aşağıdaki gibi [WHERE](../../sql_reference/statements/select.md#select-where)). + +İlk hariç, koşullar çiftler halinde geçerlidir: birinci ve ikinci doğruysa, ikincinin sonucu, birinci ve fird doğruysa, üçüncüsü doğru olacaktır. + +**Sözdizimi** + +``` sql +retention(cond1, cond2, ..., cond32); +``` + +**Parametre** + +- `cond` — an expression that returns a `UInt8` sonuç (1 veya 0). + +**Döndürülen değer** + +1 veya 0 dizisi. + +- 1 — condition was met for the event. +- 0 — condition wasn't met for the event. + +Tür: `UInt8`. + +**Örnek** + +Hesaplamanın bir örneğini düşünelim `retention` site trafiğini belirlemek için işlev. + +**1.** Сreate a table to illustrate an example. + +``` sql +CREATE TABLE retention_test(date Date, uid Int32) ENGINE = Memory; + +INSERT INTO retention_test SELECT '2020-01-01', number FROM numbers(5); +INSERT INTO retention_test SELECT '2020-01-02', number FROM numbers(10); +INSERT INTO retention_test SELECT '2020-01-03', number FROM numbers(15); +``` + +Giriş tablosu: + +Sorgu: + +``` sql +SELECT * FROM retention_test +``` + +Sonuç: + +``` text +┌───────date─┬─uid─┐ +│ 2020-01-01 │ 0 │ +│ 2020-01-01 │ 1 │ +│ 2020-01-01 │ 2 │ +│ 2020-01-01 │ 3 │ +│ 2020-01-01 │ 4 │ +└────────────┴─────┘ +┌───────date─┬─uid─┐ +│ 2020-01-02 │ 0 │ +│ 2020-01-02 │ 1 │ +│ 2020-01-02 │ 2 │ +│ 2020-01-02 │ 3 │ +│ 2020-01-02 │ 4 │ +│ 2020-01-02 │ 5 │ +│ 2020-01-02 │ 6 │ +│ 2020-01-02 │ 7 │ +│ 2020-01-02 │ 8 │ +│ 2020-01-02 │ 9 │ +└────────────┴─────┘ +┌───────date─┬─uid─┐ +│ 2020-01-03 │ 0 │ +│ 2020-01-03 │ 1 │ +│ 2020-01-03 │ 2 │ +│ 2020-01-03 │ 3 │ +│ 2020-01-03 │ 4 │ +│ 2020-01-03 │ 5 │ +│ 2020-01-03 │ 6 │ +│ 2020-01-03 │ 7 │ +│ 2020-01-03 │ 8 │ +│ 2020-01-03 │ 9 │ +│ 2020-01-03 │ 10 │ +│ 2020-01-03 │ 11 │ +│ 2020-01-03 │ 12 │ +│ 2020-01-03 │ 13 │ +│ 2020-01-03 │ 14 │ +└────────────┴─────┘ +``` + +**2.** Kullanıcıları benzersiz kimliğe göre grupla `uid` kullanarak `retention` işlev. + +Sorgu: + +``` sql +SELECT + uid, + retention(date = '2020-01-01', date = '2020-01-02', date = '2020-01-03') AS r +FROM retention_test +WHERE date IN ('2020-01-01', '2020-01-02', '2020-01-03') +GROUP BY uid +ORDER BY uid ASC +``` + +Sonuç: + +``` text +┌─uid─┬─r───────┐ +│ 0 │ [1,1,1] │ +│ 1 │ [1,1,1] │ +│ 2 │ [1,1,1] │ +│ 3 │ [1,1,1] │ +│ 4 │ [1,1,1] │ +│ 5 │ [0,0,0] │ +│ 6 │ [0,0,0] │ +│ 7 │ [0,0,0] │ +│ 8 │ [0,0,0] │ +│ 9 │ [0,0,0] │ +│ 10 │ [0,0,0] │ +│ 11 │ [0,0,0] │ +│ 12 │ [0,0,0] │ +│ 13 │ [0,0,0] │ +│ 14 │ [0,0,0] │ +└─────┴─────────┘ +``` + +**3.** Günde toplam site ziyaret sayısını hesaplayın. + +Sorgu: + +``` sql +SELECT + sum(r[1]) AS r1, + sum(r[2]) AS r2, + sum(r[3]) AS r3 +FROM +( + SELECT + uid, + retention(date = '2020-01-01', date = '2020-01-02', date = '2020-01-03') AS r + FROM retention_test + WHERE date IN ('2020-01-01', '2020-01-02', '2020-01-03') + GROUP BY uid +) +``` + +Sonuç: + +``` text +┌─r1─┬─r2─┬─r3─┐ +│ 5 │ 5 │ 5 │ +└────┴────┴────┘ +``` + +Nerede: + +- `r1`- 2020-01-01 sırasında siteyi ziyaret eden tekil ziyaretçi sayısı ( `cond1` koşul). +- `r2`- 2020-01-01 ve 2020-01-02 arasında belirli bir süre boyunca siteyi ziyaret eden tekil ziyaretçi sayısı (`cond1` ve `cond2` şartlar). +- `r3`- 2020-01-01 ve 2020-01-03 arasında belirli bir süre boyunca siteyi ziyaret eden tekil ziyaretçi sayısı (`cond1` ve `cond3` şartlar). + +## uniqUpTo(N) (x) {#uniquptonx} + +Calculates the number of different argument values ​​if it is less than or equal to N. If the number of different argument values is greater than N, it returns N + 1. + +Küçük Ns ile kullanım için tavsiye, kadar 10. N'nin maksimum değeri 100'dür. + +Bir toplama işlevinin durumu için, 1 + n \* bir bayt değerinin boyutuna eşit bellek miktarını kullanır. +Dizeler için, 8 baytlık kriptografik olmayan bir karma saklar. Yani, hesaplama dizeler için yaklaşık olarak hesaplanır. + +İşlev ayrıca birkaç argüman için de çalışır. + +Büyük bir N değeri kullanıldığında ve benzersiz değerlerin sayısı n'den biraz daha az olduğu durumlar dışında mümkün olduğunca hızlı çalışır. + +Kullanım örneği: + +``` text +Problem: Generate a report that shows only keywords that produced at least 5 unique users. +Solution: Write in the GROUP BY query SearchPhrase HAVING uniqUpTo(4)(UserID) >= 5 +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/agg_functions/parametric_functions/) + +## sumMapFiltered (keys\_to\_keep) (anahtarlar, değerler) {#summapfilteredkeys-to-keepkeys-values} + +Aynı davranış [sumMap](reference.md#agg_functions-summap) dışında bir dizi anahtar parametre olarak geçirilir. Bu, özellikle yüksek bir Anahtarlık ile çalışırken yararlı olabilir. diff --git a/docs/tr/sql_reference/aggregate_functions/reference.md b/docs/tr/sql_reference/aggregate_functions/reference.md new file mode 100644 index 00000000000..d52b82be996 --- /dev/null +++ b/docs/tr/sql_reference/aggregate_functions/reference.md @@ -0,0 +1,1878 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 36 +toc_title: "Ba\u015Fvurma" +--- + +# Fonksiyon Referans {#function-reference} + +## sayma {#agg_function-count} + +Satır veya NOT-NULL değerleri sayar. + +ClickHouse için aşağıdaki sözdizimleri destekler `count`: +- `count(expr)` veya `COUNT(DISTINCT expr)`. +- `count()` veya `COUNT(*)`. Bu `count()` sözdizimi ClickHouse özeldir. + +**Parametre** + +Fonksiyon alabilir: + +- Sıfır parametreler. +- Bir [ifade](../syntax.md#syntax-expressions). + +**Döndürülen değer** + +- Fonksiyon parametreleri olmadan çağrılırsa, satır sayısını sayar. +- Eğer... [ifade](../syntax.md#syntax-expressions) geçirilir, daha sonra işlev bu ifadenin kaç kez NOT null döndürdüğünü sayar. İfad aede bir [Nullable](../../sql_reference/data_types/nullable.md)- type değeri, sonra sonucu `count` kalır değil `Nullable`. İfade döndürülürse işlev 0 döndürür `NULL` tüm satırlar için. + +Her iki durumda da döndürülen değerin türü [Uİnt64](../../sql_reference/data_types/int_uint.md). + +**Ayrıntı** + +ClickHouse destekler `COUNT(DISTINCT ...)` sözdizimi. Bu yapının davranışı Aşağıdakilere bağlıdır [count\_distinct\_implementation](../../operations/settings/settings.md#settings-count_distinct_implementation) ayar. Aşağıdakilerden hang theisini tanımlar [uniq\*](#agg_function-uniq) fonksiyonlar işlemi gerçekleştirmek için kullanılır. Varsayılan değer [uniqExact](#agg_function-uniqexact) işlev. + +Bu `SELECT count() FROM table` tablodaki girdi sayısı ayrı olarak depolanmadığı için sorgu en iyi duruma getirilmez. Tablodan küçük bir sütun seçer ve içindeki değerlerin sayısını sayar. + +**Örnekler** + +Örnek 1: + +``` sql +SELECT count() FROM t +``` + +``` text +┌─count()─┐ +│ 5 │ +└─────────┘ +``` + +Örnek 2: + +``` sql +SELECT name, value FROM system.settings WHERE name = 'count_distinct_implementation' +``` + +``` text +┌─name──────────────────────────┬─value─────┐ +│ count_distinct_implementation │ uniqExact │ +└───────────────────────────────┴───────────┘ +``` + +``` sql +SELECT count(DISTINCT num) FROM t +``` + +``` text +┌─uniqExact(num)─┐ +│ 3 │ +└────────────────┘ +``` + +Bu örnek gösteriyor ki `count(DISTINCT num)` tarafından gerçekleştirilir `uniqExact` fonksiyonu göre `count_distinct_implementation` ayar değeri. + +## herhangi(x) {#agg_function-any} + +İlk karşılaşılan değeri seçer. +Sorgu herhangi bir sırada ve hatta her seferinde farklı bir sırada çalıştırılabilir, bu nedenle bu işlevin sonucu belirsizdir. +Belirli bir sonuç elde etmek için ‘min’ veya ‘max’ fonksiyon yerine ‘any’. + +Bazı durumlarda, yürütme sırasına güvenebilirsiniz. Bu, select ORDER BY kullanan bir alt sorgudan geldiğinde durumlar için geçerlidir. + +Ne zaman bir `SELECT` sorgu vardır `GROUP BY` yan tümce veya en az bir toplama işlevi, ClickHouse (Mysql'in aksine), tüm ifadelerin `SELECT`, `HAVING`, ve `ORDER BY` anahtar functionslardan veya toplama işlev .lerinden hesaplan .malıdır. Başka bir deyişle, tablodan seçilen her sütun, anahtarlarda veya toplama işlevlerinde kullanılmalıdır. Mysql'de olduğu gibi davranış elde etmek için, diğer sütunları `any` toplama işlevi. + +## anyHeavy (x) {#anyheavyx} + +Kullanarak sık oluşan bir değer seçer [ağır vurucular](http://www.cs.umd.edu/~samir/498/karp.pdf) algoritma. Sorgunun yürütme iş parçacığı her durumda yarısından fazlasını oluşan bir değer varsa, bu değer döndürülür. Normalde, sonuç belirsizdir. + +``` sql +anyHeavy(column) +``` + +**Değişkenler** + +- `column` – The column name. + +**Örnek** + +Tak thee the [OnTime](../../getting_started/example_datasets/ontime.md) veri kümesi ve herhangi bir sık oluşan değeri seçin `AirlineID` sütun. + +``` sql +SELECT anyHeavy(AirlineID) AS res +FROM ontime +``` + +``` text +┌───res─┐ +│ 19690 │ +└───────┘ +``` + +## anyLast(x) {#anylastx} + +Karşılaşılan son değeri seçer. +Sonuç için olduğu kadar belirsiz `any` işlev. + +## groupBitAnd {#groupbitand} + +Bitwise uygular `AND` sayı serisi için. + +``` sql +groupBitAnd(expr) +``` + +**Parametre** + +`expr` – An expression that results in `UInt*` tür. + +**Dönüş değeri** + +Bu değer `UInt*` tür. + +**Örnek** + +Test verileri: + +``` text +binary decimal +00101100 = 44 +00011100 = 28 +00001101 = 13 +01010101 = 85 +``` + +Sorgu: + +``` sql +SELECT groupBitAnd(num) FROM t +``` + +Nerede `num` test verileri ile sütundur. + +Sonuç: + +``` text +binary decimal +00000100 = 4 +``` + +## groupBitOr {#groupbitor} + +Bitwise uygular `OR` sayı serisi için. + +``` sql +groupBitOr(expr) +``` + +**Parametre** + +`expr` – An expression that results in `UInt*` tür. + +**Dönüş değeri** + +Bu değer `UInt*` tür. + +**Örnek** + +Test verileri: + +``` text +binary decimal +00101100 = 44 +00011100 = 28 +00001101 = 13 +01010101 = 85 +``` + +Sorgu: + +``` sql +SELECT groupBitOr(num) FROM t +``` + +Nerede `num` test verileri ile sütundur. + +Sonuç: + +``` text +binary decimal +01111101 = 125 +``` + +## groupBitXor {#groupbitxor} + +Bitwise uygular `XOR` sayı serisi için. + +``` sql +groupBitXor(expr) +``` + +**Parametre** + +`expr` – An expression that results in `UInt*` tür. + +**Dönüş değeri** + +Bu değer `UInt*` tür. + +**Örnek** + +Test verileri: + +``` text +binary decimal +00101100 = 44 +00011100 = 28 +00001101 = 13 +01010101 = 85 +``` + +Sorgu: + +``` sql +SELECT groupBitXor(num) FROM t +``` + +Nerede `num` test verileri ile sütundur. + +Sonuç: + +``` text +binary decimal +01101000 = 104 +``` + +## groupBitmap {#groupbitmap} + +İşaretsiz tamsayı sütun, Uınt64 tür iade önem, gelen bit eşlem veya Toplama hesaplamaları suffix ekleme -Devlet, sonra iade [bitmap nesnesi](../../sql_reference/functions/bitmap_functions.md). + +``` sql +groupBitmap(expr) +``` + +**Parametre** + +`expr` – An expression that results in `UInt*` tür. + +**Dönüş değeri** + +Bu değer `UInt64` tür. + +**Örnek** + +Test verileri: + +``` text +UserID +1 +1 +2 +3 +``` + +Sorgu: + +``` sql +SELECT groupBitmap(UserID) as num FROM t +``` + +Sonuç: + +``` text +num +3 +``` + +## min (x) {#agg_function-min} + +Minimum hesaplar. + +## max (x) {#agg_function-max} + +Maksimum hesaplar. + +## argMin (arg, val) {#agg-function-argmin} + +Hesaplar ‘arg’ minimum değer ‘val’ değer. Birkaç farklı değer varsa ‘arg’ minimum değerler için ‘val’, karşılaşılan bu değerlerin ilki çıktıdır. + +**Örnek:** + +``` text +┌─user─────┬─salary─┐ +│ director │ 5000 │ +│ manager │ 3000 │ +│ worker │ 1000 │ +└──────────┴────────┘ +``` + +``` sql +SELECT argMin(user, salary) FROM salary +``` + +``` text +┌─argMin(user, salary)─┐ +│ worker │ +└──────────────────────┘ +``` + +## argMax (arg, val) {#agg-function-argmax} + +Hesaplar ‘arg’ maksimum değer ‘val’ değer. Birkaç farklı değer varsa ‘arg’ maksimum değerler için ‘val’, karşılaşılan bu değerlerin ilki çıktıdır. + +## s (um (x) {#agg_function-sum} + +Toplamı hesaplar. +Sadece sayılar için çalışır. + +## sumWithOverflow(x) {#sumwithoverflowx} + +Giriş parametreleri için olduğu gibi sonuç için aynı veri türünü kullanarak sayıların toplamını hesaplar. Toplam bu veri türü için en büyük değeri aşarsa, işlev bir hata döndürür. + +Sadece sayılar için çalışır. + +## sumMap (anahtar, değer) {#agg_functions-summap} + +Toplam thelar ‘value’ belirtilen tuş accordinglara göre dizi ‘key’ dizi. +Eleman sayısı ‘key’ ve ‘value’ toplam her satır için aynı olmalıdır. +Returns a tuple of two arrays: keys in sorted order, and values ​​summed for the corresponding keys. + +Örnek: + +``` sql +CREATE TABLE sum_map( + date Date, + timeslot DateTime, + statusMap Nested( + status UInt16, + requests UInt64 + ) +) ENGINE = Log; +INSERT INTO sum_map VALUES + ('2000-01-01', '2000-01-01 00:00:00', [1, 2, 3], [10, 10, 10]), + ('2000-01-01', '2000-01-01 00:00:00', [3, 4, 5], [10, 10, 10]), + ('2000-01-01', '2000-01-01 00:01:00', [4, 5, 6], [10, 10, 10]), + ('2000-01-01', '2000-01-01 00:01:00', [6, 7, 8], [10, 10, 10]); +SELECT + timeslot, + sumMap(statusMap.status, statusMap.requests) +FROM sum_map +GROUP BY timeslot +``` + +``` text +┌────────────timeslot─┬─sumMap(statusMap.status, statusMap.requests)─┐ +│ 2000-01-01 00:00:00 │ ([1,2,3,4,5],[10,10,20,10,10]) │ +│ 2000-01-01 00:01:00 │ ([4,5,6,7,8],[10,10,20,10,10]) │ +└─────────────────────┴──────────────────────────────────────────────┘ +``` + +## skewPop {#skewpop} + +Hesaplar [çarpıklık](https://en.wikipedia.org/wiki/Skewness) bir sıra. + +``` sql +skewPop(expr) +``` + +**Parametre** + +`expr` — [İfade](../syntax.md#syntax-expressions) bir numara döndürüyor. + +**Döndürülen değer** + +The skewness of the given distribution. Type — [Float64](../../sql_reference/data_types/float.md) + +**Örnek** + +``` sql +SELECT skewPop(value) FROM series_with_value_column +``` + +## skewSamp {#skewsamp} + +Hesaplar [örnek çarpıklık](https://en.wikipedia.org/wiki/Skewness) bir sıra. + +Bir rassal değişkenin çarpıklığının tarafsız bir tahminini temsil eder. + +``` sql +skewSamp(expr) +``` + +**Parametre** + +`expr` — [İfade](../syntax.md#syntax-expressions) bir numara döndürüyor. + +**Döndürülen değer** + +The skewness of the given distribution. Type — [Float64](../../sql_reference/data_types/float.md). Eğer `n <= 1` (`n` örnek boyutudur), daha sonra işlev döner `nan`. + +**Örnek** + +``` sql +SELECT skewSamp(value) FROM series_with_value_column +``` + +## kurtPop {#kurtpop} + +Hesaplar [kurtosis](https://en.wikipedia.org/wiki/Kurtosis) bir sıra. + +``` sql +kurtPop(expr) +``` + +**Parametre** + +`expr` — [İfade](../syntax.md#syntax-expressions) bir numara döndürüyor. + +**Döndürülen değer** + +The kurtosis of the given distribution. Type — [Float64](../../sql_reference/data_types/float.md) + +**Örnek** + +``` sql +SELECT kurtPop(value) FROM series_with_value_column +``` + +## kurtSamp {#kurtsamp} + +Hesaplar [örnek kurtoz](https://en.wikipedia.org/wiki/Kurtosis) bir sıra. + +Eğer geçen değerleri örnek oluşturur, eğer bir rassal değişken kurtosis tarafsız bir tahmini temsil eder. + +``` sql +kurtSamp(expr) +``` + +**Parametre** + +`expr` — [İfade](../syntax.md#syntax-expressions) bir numara döndürüyor. + +**Döndürülen değer** + +The kurtosis of the given distribution. Type — [Float64](../../sql_reference/data_types/float.md). Eğer `n <= 1` (`n` örnek bir boyutudur), daha sonra işlev döner `nan`. + +**Örnek** + +``` sql +SELECT kurtSamp(value) FROM series_with_value_column +``` + +## timeSeriesGroupSum(uıd, zaman damgası, değer) {#agg-function-timeseriesgroupsum} + +`timeSeriesGroupSum` örnek zaman damgası değil hizalama farklı zaman serileri toplayabilir. +İki örnek zaman damgası arasında doğrusal enterpolasyon kullanacak ve daha sonra zaman serilerini birlikte toplayacaktır. + +- `uid` zaman serisi benzersiz kimliği mi, `UInt64`. +- `timestamp` milisaniye veya mikrosaniye desteklemek için Int64 türüdür. +- `value` metr .iktir. + +İşlev, tuples dizisini döndürür `(timestamp, aggregated_value)` çiftliler. + +Bu işlevi kullanmadan önce emin olun `timestamp` artan düzende. + +Örnek: + +``` text +┌─uid─┬─timestamp─┬─value─┐ +│ 1 │ 2 │ 0.2 │ +│ 1 │ 7 │ 0.7 │ +│ 1 │ 12 │ 1.2 │ +│ 1 │ 17 │ 1.7 │ +│ 1 │ 25 │ 2.5 │ +│ 2 │ 3 │ 0.6 │ +│ 2 │ 8 │ 1.6 │ +│ 2 │ 12 │ 2.4 │ +│ 2 │ 18 │ 3.6 │ +│ 2 │ 24 │ 4.8 │ +└─────┴───────────┴───────┘ +``` + +``` sql +CREATE TABLE time_series( + uid UInt64, + timestamp Int64, + value Float64 +) ENGINE = Memory; +INSERT INTO time_series VALUES + (1,2,0.2),(1,7,0.7),(1,12,1.2),(1,17,1.7),(1,25,2.5), + (2,3,0.6),(2,8,1.6),(2,12,2.4),(2,18,3.6),(2,24,4.8); + +SELECT timeSeriesGroupSum(uid, timestamp, value) +FROM ( + SELECT * FROM time_series order by timestamp ASC +); +``` + +Ve sonuç olacak: + +``` text +[(2,0.2),(3,0.9),(7,2.1),(8,2.4),(12,3.6),(17,5.1),(18,5.4),(24,7.2),(25,2.5)] +``` + +## timeSeriesGroupRateSum(uıd, ts, val) {#agg-function-timeseriesgroupratesum} + +Benzer şekilde timeSeriesGroupRateSum, timeSeriesGroupRateSum zaman serisi ve daha sonra toplam oranları birlikte oranını hesaplar. +Ayrıca, bu işlevi kullanmadan önce zaman damgası yükseliş sırasına göre olmalıdır. + +Bu işlevi kullanın, yukarıdaki sonuç olacaktır: + +``` text +[(2,0),(3,0.1),(7,0.3),(8,0.3),(12,0.3),(17,0.3),(18,0.3),(24,0.3),(25,0.1)] +``` + +## avg (x) {#agg_function-avg} + +Ortalama hesaplar. +Sadece sayılar için çalışır. +Sonuç Her zaman Float64. + +## avgWeighted {#avgweighted} + +Hesaplar [ağırlıklı aritmetik ortalama](https://en.wikipedia.org/wiki/Weighted_arithmetic_mean). + +**Sözdizimi** + +``` sql +avgWeighted(x, weight) +``` + +**Parametre** + +- `x` — Values. [Tamsayı](../data_types/int_uint.md) veya [kayan nokta](../data_types/float.md). +- `weight` — Weights of the values. [Tamsayı](../data_types/int_uint.md) veya [kayan nokta](../data_types/float.md). + +Türü `x` ve `weight` aynı olmalıdır. + +**Döndürülen değer** + +- Ağırlıklı ortalama. +- `NaN`. Tüm ağırlıklar 0'a eşitse. + +Tür: [Float64](../data_types/float.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT avgWeighted(x, w) +FROM values('x Int8, w Int8', (4, 1), (1, 0), (10, 2)) +``` + +Sonuç: + +``` text +┌─avgWeighted(x, weight)─┐ +│ 8 │ +└────────────────────────┘ +``` + +## uniq {#agg_function-uniq} + +Bağımsız değişken farklı değerlerin yaklaşık sayısını hesaplar. + +``` sql +uniq(x[, ...]) +``` + +**Parametre** + +Fonksiyon değişken sayıda parametre alır. Parametreler olabilir `Tuple`, `Array`, `Date`, `DateTime`, `String` veya sayısal türleri. + +**Döndürülen değer** + +- A [Uİnt64](../../sql_reference/data_types/int_uint.md)- tip numarası. + +**Uygulama Detayları** + +İşlev: + +- Toplamdaki tüm parametreler için bir karma hesaplar, daha sonra hesaplamalarda kullanır. + +- Bir adaptif örnekleme algoritması kullanır. Hesaplama durumu için işlev, 65536'ya kadar öğe karma değerlerinin bir örneğini kullanır. + + This algorithm is very accurate and very efficient on the CPU. When the query contains several of these functions, using `uniq` is almost as fast as using other aggregate functions. + +- Sonucu deterministically sağlar (sorgu işleme sırasına bağlı değildir). + +Bu işlevi hemen hemen tüm senaryolarda kullanmanızı öneririz. + +**Ayrıca Bakınız** + +- [uniqCombined](#agg_function-uniqcombined) +- [uniqCombined64](#agg_function-uniqcombined64) +- [uniqHLL12](#agg_function-uniqhll12) +- [uniqExact](#agg_function-uniqexact) + +## uniqCombined {#agg_function-uniqcombined} + +Farklı bağımsız değişken değerlerinin yaklaşık sayısını hesaplar. + +``` sql +uniqCombined(HLL_precision)(x[, ...]) +``` + +Bu `uniqCombined` fonksiyon, farklı değerlerin sayısını hesaplamak için iyi bir seçimdir. + +**Parametre** + +Fonksiyon değişken sayıda parametre alır. Parametreler olabilir `Tuple`, `Array`, `Date`, `DateTime`, `String` veya sayısal türleri. + +`HLL_precision` hücre sayısının baz-2 logaritmasıdır. [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog). İsteğe bağlı olarak işlevi kullanabilirsiniz `uniqCombined(x[, ...])`. İçin varsayılan değer `HLL_precision` etkin bir şekilde 96 KiB alan olan 17'dir (2^17 hücre, her biri 6 bit). + +**Döndürülen değer** + +- Numara [Uİnt64](../../sql_reference/data_types/int_uint.md)- tip numarası. + +**Uygulama Detayları** + +İşlev: + +- Bir karma hesaplar (64-bit karma için `String` ve 32-bit aksi halde) agregadaki tüm parametreler için, hesaplamalarda kullanır. + +- Bir hata düzeltme tablosu ile dizi, karma tablo ve HyperLogLog: üç algoritmaları bir arada kullanır. + + For a small number of distinct elements, an array is used. When the set size is larger, a hash table is used. For a larger number of elements, HyperLogLog is used, which will occupy a fixed amount of memory. + +- Sonucu deterministically sağlar (sorgu işleme sırasına bağlı değildir). + +!!! note "Not" + Olmayan için 32-bit karma kullandığından-`String` tipi, sonuç cardinalities önemli ölçüde daha büyük için çok yüksek hata olacak `UINT_MAX` (birkaç on milyarlarca farklı değerden sonra hata hızla artacaktır), bu durumda kullanmanız gerekir [uniqCombined64](#agg_function-uniqcombined64) + +İle karşılaştırıldığında [uniq](#agg_function-uniq) fonksiyonu, `uniqCombined`: + +- Birkaç kez daha az bellek tüketir. +- Birkaç kat daha yüksek doğrulukla hesaplar. +- Genellikle biraz daha düşük performansa sahiptir. Bazı senaryolarda, `uniqCombined` daha iyi performans gösterebilir `uniq` örneğin, ağ üzerinden çok sayıda toplama durumu ileten dağıtılmış sorgularla. + +**Ayrıca Bakınız** + +- [uniq](#agg_function-uniq) +- [uniqCombined64](#agg_function-uniqcombined64) +- [uniqHLL12](#agg_function-uniqhll12) +- [uniqExact](#agg_function-uniqexact) + +## uniqCombined64 {#agg_function-uniqcombined64} + +Aynı olarak [uniqCombined](#agg_function-uniqcombined), ancak tüm veri türleri için 64 bit karma kullanır. + +## uniqHLL12 {#agg_function-uniqhll12} + +Farklı argüman değerlerinin yaklaşık sayısını hesaplar [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog) algoritma. + +``` sql +uniqHLL12(x[, ...]) +``` + +**Parametre** + +Fonksiyon değişken sayıda parametre alır. Parametreler olabilir `Tuple`, `Array`, `Date`, `DateTime`, `String` veya sayısal türleri. + +**Döndürülen değer** + +- A [Uİnt64](../../sql_reference/data_types/int_uint.md)- tip numarası. + +**Uygulama Detayları** + +İşlev: + +- Toplamdaki tüm parametreler için bir karma hesaplar, daha sonra hesaplamalarda kullanır. + +- Farklı bağımsız değişken değerlerinin sayısını yaklaştırmak için HyperLogLog algoritmasını kullanır. + + 212 5-bit cells are used. The size of the state is slightly more than 2.5 KB. The result is not very accurate (up to ~10% error) for small data sets (<10K elements). However, the result is fairly accurate for high-cardinality data sets (10K-100M), with a maximum error of ~1.6%. Starting from 100M, the estimation error increases, and the function will return very inaccurate results for data sets with extremely high cardinality (1B+ elements). + +- Belirli sonucu sağlar (sorgu işleme sırasına bağlı değildir). + +Bu işlevi kullanmanızı önermiyoruz. Çoğu durumda, kullan [uniq](#agg_function-uniq) veya [uniqCombined](#agg_function-uniqcombined) işlev. + +**Ayrıca Bakınız** + +- [uniq](#agg_function-uniq) +- [uniqCombined](#agg_function-uniqcombined) +- [uniqExact](#agg_function-uniqexact) + +## uniqExact {#agg_function-uniqexact} + +Farklı bağımsız değişken değerlerinin tam sayısını hesaplar. + +``` sql +uniqExact(x[, ...]) +``` + +Kullan... `uniqExact` kesinlikle kesin bir sonuca ihtiyacınız varsa işlev. Aksi takdirde kullanın [uniq](#agg_function-uniq) işlev. + +Bu `uniqExact` fonksiyonu daha fazla bellek kullanır `uniq`, çünkü farklı değerlerin sayısı arttıkça devletin büyüklüğü sınırsız büyümeye sahiptir. + +**Parametre** + +Fonksiyon değişken sayıda parametre alır. Parametreler olabilir `Tuple`, `Array`, `Date`, `DateTime`, `String` veya sayısal türleri. + +**Ayrıca Bakınız** + +- [uniq](#agg_function-uniq) +- [uniqCombined](#agg_function-uniqcombined) +- [uniqHLL12](#agg_function-uniqhll12) + +## groupArray (x), groupArray (max\_size)(x) {#agg_function-grouparray} + +Bağımsız değişken değerleri dizisi oluşturur. +Değerler diziye herhangi bir (belirsiz) sırayla eklenebilir. + +İkinci versiyonu (ile `max_size` parametre), elde edilen dizinin boyutunu sınırlar `max_size` öğeler. +Mesela, `groupArray (1) (x)` eşdeğ toer equivalentdir `[any (x)]`. + +Bazı durumlarda, hala yürütme sırasına güvenebilirsiniz. Bu, aşağıdaki durumlar için geçerlidir `SELECT` kullanan bir alt sorgudan gelir `ORDER BY`. + +## grouparrayınsertat (değer, konum) {#grouparrayinsertatvalue-position} + +Belirtilen konumda diziye bir değer ekler. + +!!! note "Not" + Bu işlev, SQL dizileri için geleneksel tek tabanlı konumların aksine sıfır tabanlı konumlar kullanır. + +Accepts the value and position as input. If several values ​​are inserted into the same position, any of them might end up in the resulting array (the first one will be used in the case of single-threaded execution). If no value is inserted into a position, the position is assigned the default value. + +İsteğe bağlı parametreler: + +- Boş pozisyonlarda ikame için varsayılan değer. +- Elde edilen dizinin uzunluğu. Bu, tüm toplama anahtarları için aynı boyuttaki dizileri almanızı sağlar. Bu parametreyi kullanırken, varsayılan değer belirtilmelidir. + +## groupArrayMovingSum {#agg_function-grouparraymovingsum} + +Giriş değerlerinin hareketli toplamını hesaplar. + +``` sql +groupArrayMovingSum(numbers_for_summing) +groupArrayMovingSum(window_size)(numbers_for_summing) +``` + +İşlev, pencere boyutunu bir parametre olarak alabilir. Belirtilmemiş bırakılırsa, işlev, sütundaki satır sayısına eşit pencere boyutunu alır. + +**Parametre** + +- `numbers_for_summing` — [İfade](../syntax.md#syntax-expressions) sayısal veri türü değeri ile sonuçlanır. +- `window_size` — Size of the calculation window. + +**Döndürülen değerler** + +- Giriş verileri ile aynı boyut ve türdeki dizi. + +**Örnek** + +Örnek tablo: + +``` sql +CREATE TABLE t +( + `int` UInt8, + `float` Float32, + `dec` Decimal32(2) +) +ENGINE = TinyLog +``` + +``` text +┌─int─┬─float─┬──dec─┐ +│ 1 │ 1.1 │ 1.10 │ +│ 2 │ 2.2 │ 2.20 │ +│ 4 │ 4.4 │ 4.40 │ +│ 7 │ 7.77 │ 7.77 │ +└─────┴───────┴──────┘ +``` + +Sorgu: + +``` sql +SELECT + groupArrayMovingSum(int) AS I, + groupArrayMovingSum(float) AS F, + groupArrayMovingSum(dec) AS D +FROM t +``` + +``` text +┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐ +│ [1,3,7,14] │ [1.1,3.3000002,7.7000003,15.47] │ [1.10,3.30,7.70,15.47] │ +└────────────┴─────────────────────────────────┴────────────────────────┘ +``` + +``` sql +SELECT + groupArrayMovingSum(2)(int) AS I, + groupArrayMovingSum(2)(float) AS F, + groupArrayMovingSum(2)(dec) AS D +FROM t +``` + +``` text +┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐ +│ [1,3,6,11] │ [1.1,3.3000002,6.6000004,12.17] │ [1.10,3.30,6.60,12.17] │ +└────────────┴─────────────────────────────────┴────────────────────────┘ +``` + +## groupArrayMovingAvg {#agg_function-grouparraymovingavg} + +Giriş değerlerinin hareketli ortalamasını hesaplar. + +``` sql +groupArrayMovingAvg(numbers_for_summing) +groupArrayMovingAvg(window_size)(numbers_for_summing) +``` + +İşlev, pencere boyutunu bir parametre olarak alabilir. Belirtilmemiş bırakılırsa, işlev, sütundaki satır sayısına eşit pencere boyutunu alır. + +**Parametre** + +- `numbers_for_summing` — [İfade](../syntax.md#syntax-expressions) sayısal veri türü değeri ile sonuçlanır. +- `window_size` — Size of the calculation window. + +**Döndürülen değerler** + +- Giriş verileri ile aynı boyut ve türdeki dizi. + +İşlev kullanır [sıfıra doğru yuvarlama](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero). Sonuç veri türü için önemsiz ondalık basamaklar keser. + +**Örnek** + +Örnek tablo `b`: + +``` sql +CREATE TABLE t +( + `int` UInt8, + `float` Float32, + `dec` Decimal32(2) +) +ENGINE = TinyLog +``` + +``` text +┌─int─┬─float─┬──dec─┐ +│ 1 │ 1.1 │ 1.10 │ +│ 2 │ 2.2 │ 2.20 │ +│ 4 │ 4.4 │ 4.40 │ +│ 7 │ 7.77 │ 7.77 │ +└─────┴───────┴──────┘ +``` + +Sorgu: + +``` sql +SELECT + groupArrayMovingAvg(int) AS I, + groupArrayMovingAvg(float) AS F, + groupArrayMovingAvg(dec) AS D +FROM t +``` + +``` text +┌─I─────────┬─F───────────────────────────────────┬─D─────────────────────┐ +│ [0,0,1,3] │ [0.275,0.82500005,1.9250001,3.8675] │ [0.27,0.82,1.92,3.86] │ +└───────────┴─────────────────────────────────────┴───────────────────────┘ +``` + +``` sql +SELECT + groupArrayMovingAvg(2)(int) AS I, + groupArrayMovingAvg(2)(float) AS F, + groupArrayMovingAvg(2)(dec) AS D +FROM t +``` + +``` text +┌─I─────────┬─F────────────────────────────────┬─D─────────────────────┐ +│ [0,1,3,5] │ [0.55,1.6500001,3.3000002,6.085] │ [0.55,1.65,3.30,6.08] │ +└───────────┴──────────────────────────────────┴───────────────────────┘ +``` + +## groupUniqArray (x), groupUniqArray (max\_size)(x) {#groupuniqarrayx-groupuniqarraymax-sizex} + +Farklı bağımsız değişken değerlerinden bir dizi oluşturur. Bellek tüketimi için aynıdır `uniqExact` işlev. + +İkinci versiyonu (ile `max_size` parametre), elde edilen dizinin boyutunu sınırlar `max_size` öğeler. +Mesela, `groupUniqArray(1)(x)` eşdeğ toer equivalentdir `[any(x)]`. + +## quantile {#quantile} + +Yaklaşık hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) sayısal veri dizisinin. + +Bu işlev geçerlidir [rezerv reservoiruar örnek samplinglemesi](https://en.wikipedia.org/wiki/Reservoir_sampling) 8192'ye kadar bir rezervuar boyutu ve örnekleme için rastgele sayı üreteci ile. Sonuç deterministik değildir. Tam bir miktar elde etmek için [quantileExact](#quantileexact) işlev. + +Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) işlev. + +**Sözdizimi** + +``` sql +quantile(level)(expr) +``` + +Takma ad: `median`. + +**Parametre** + +- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median). +- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql_reference/data_types/index.md#data_types), [Tarihli](../../sql_reference/data_types/date.md) veya [DateTime](../../sql_reference/data_types/datetime.md). + +**Döndürülen değer** + +- Belirtilen seviyenin yaklaşık miktarı. + +Tür: + +- [Float64](../../sql_reference/data_types/float.md) sayısal veri türü girişi için. +- [Tarihli](../../sql_reference/data_types/date.md) giriş değerleri varsa `Date` tür. +- [DateTime](../../sql_reference/data_types/datetime.md) giriş değerleri varsa `DateTime` tür. + +**Örnek** + +Giriş tablosu: + +``` text +┌─val─┐ +│ 1 │ +│ 1 │ +│ 2 │ +│ 3 │ +└─────┘ +``` + +Sorgu: + +``` sql +SELECT quantile(val) FROM t +``` + +Sonuç: + +``` text +┌─quantile(val)─┐ +│ 1.5 │ +└───────────────┘ +``` + +**Ayrıca Bakınız** + +- [medyan](#median) +- [quantiles](#quantiles) + +## quantileDeterministic {#quantiledeterministic} + +Yaklaşık hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) sayısal veri dizisinin. + +Bu işlev geçerlidir [rezerv reservoiruar örnek samplinglemesi](https://en.wikipedia.org/wiki/Reservoir_sampling) 8192'ye kadar bir rezervuar boyutu ve örnekleme deterministik algoritması ile. Sonuç deterministiktir. Tam bir miktar elde etmek için [quantileExact](#quantileexact) işlev. + +Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) işlev. + +**Sözdizimi** + +``` sql +quantileDeterministic(level)(expr, determinator) +``` + +Takma ad: `medianDeterministic`. + +**Parametre** + +- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median). +- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql_reference/data_types/index.md#data_types), [Tarihli](../../sql_reference/data_types/date.md) veya [DateTime](../../sql_reference/data_types/datetime.md). +- `determinator` — Number whose hash is used instead of a random number generator in the reservoir sampling algorithm to make the result of sampling deterministic. As a determinator you can use any deterministic positive number, for example, a user id or an event id. If the same determinator value occures too often, the function works incorrectly. + +**Döndürülen değer** + +- Belirtilen seviyenin yaklaşık miktarı. + +Tür: + +- [Float64](../../sql_reference/data_types/float.md) sayısal veri türü girişi için. +- [Tarihli](../../sql_reference/data_types/date.md) giriş değerleri varsa `Date` tür. +- [DateTime](../../sql_reference/data_types/datetime.md) giriş değerleri varsa `DateTime` tür. + +**Örnek** + +Giriş tablosu: + +``` text +┌─val─┐ +│ 1 │ +│ 1 │ +│ 2 │ +│ 3 │ +└─────┘ +``` + +Sorgu: + +``` sql +SELECT quantileDeterministic(val, 1) FROM t +``` + +Sonuç: + +``` text +┌─quantileDeterministic(val, 1)─┐ +│ 1.5 │ +└───────────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [medyan](#median) +- [quantiles](#quantiles) + +## quantileExact {#quantileexact} + +Tam olarak hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) sayısal veri dizisinin. + +To get exact value, all the passed values ​​are combined into an array, which is then partially sorted. Therefore, the function consumes `O(n)` bellek, nerede `n` geçirilen değerler say .ısıdır. Bununla birlikte, az sayıda değer için, işlev çok etkilidir. + +Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) işlev. + +**Sözdizimi** + +``` sql +quantileExact(level)(expr) +``` + +Takma ad: `medianExact`. + +**Parametre** + +- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median). +- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql_reference/data_types/index.md#data_types), [Tarihli](../../sql_reference/data_types/date.md) veya [DateTime](../../sql_reference/data_types/datetime.md). + +**Döndürülen değer** + +- Belirtilen seviyenin miktarı. + +Tür: + +- [Float64](../../sql_reference/data_types/float.md) sayısal veri türü girişi için. +- [Tarihli](../../sql_reference/data_types/date.md) giriş değerleri varsa `Date` tür. +- [DateTime](../../sql_reference/data_types/datetime.md) giriş değerleri varsa `DateTime` tür. + +**Örnek** + +Sorgu: + +``` sql +SELECT quantileExact(number) FROM numbers(10) +``` + +Sonuç: + +``` text +┌─quantileExact(number)─┐ +│ 5 │ +└───────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [medyan](#median) +- [quantiles](#quantiles) + +## quantilexactweighted {#quantileexactweighted} + +Tam olarak hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) her elemanın ağırlığını dikkate alarak sayısal bir veri dizisinin. + +To get exact value, all the passed values ​​are combined into an array, which is then partially sorted. Each value is counted with its weight, as if it is present `weight` times. A hash table is used in the algorithm. Because of this, if the passed values ​​are frequently repeated, the function consumes less RAM than [quantileExact](#quantileexact). Bunun yerine bu işlevi kullanabilirsiniz `quantileExact` ve 1 ağırlığını belirtin. + +Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) işlev. + +**Sözdizimi** + +``` sql +quantileExactWeighted(level)(expr, weight) +``` + +Takma ad: `medianExactWeighted`. + +**Parametre** + +- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median). +- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql_reference/data_types/index.md#data_types), [Tarihli](../../sql_reference/data_types/date.md) veya [DateTime](../../sql_reference/data_types/datetime.md). +- `weight` — Column with weights of sequence members. Weight is a number of value occurrences. + +**Döndürülen değer** + +- Belirtilen seviyenin miktarı. + +Tür: + +- [Float64](../../sql_reference/data_types/float.md) sayısal veri türü girişi için. +- [Tarihli](../../sql_reference/data_types/date.md) giriş değerleri varsa `Date` tür. +- [DateTime](../../sql_reference/data_types/datetime.md) giriş değerleri varsa `DateTime` tür. + +**Örnek** + +Giriş tablosu: + +``` text +┌─n─┬─val─┐ +│ 0 │ 3 │ +│ 1 │ 2 │ +│ 2 │ 1 │ +│ 5 │ 4 │ +└───┴─────┘ +``` + +Sorgu: + +``` sql +SELECT quantileExactWeighted(n, val) FROM t +``` + +Sonuç: + +``` text +┌─quantileExactWeighted(n, val)─┐ +│ 1 │ +└───────────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [medyan](#median) +- [quantiles](#quantiles) + +## quantileTiming {#quantiletiming} + +Belirlenen hassas hesaplar ile [quantile](https://en.wikipedia.org/wiki/Quantile) sayısal veri dizisinin. + +Sonuç deterministiktir (sorgu işleme sırasına bağlı değildir). Fonksiyon yükleme web sayfaları kez veya arka uç yanıt süreleri gibi dağılımları tanımlamak dizileri ile çalışmak için optimize edilmiştir. + +Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) işlev. + +**Sözdizimi** + +``` sql +quantileTiming(level)(expr) +``` + +Takma ad: `medianTiming`. + +**Parametre** + +- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median). + +- `expr` — [İfade](../syntax.md#syntax-expressions) bir sütun değerleri üzerinde dönen bir [Yüzdürmek\*](../../sql_reference/data_types/float.md)- tip numarası. + + - If negative values are passed to the function, the behavior is undefined. + - If the value is greater than 30,000 (a page loading time of more than 30 seconds), it is assumed to be 30,000. + +**Doğruluk** + +Hesaplama doğru ise: + +- Toplam değer sayısı 5670'i geçmez. +- Toplam değer sayısı 5670'i aşıyor, ancak sayfa yükleme süresi 1024 ms'den az. + +Aksi takdirde, hesaplamanın sonucu 16 MS'nin en yakın katlarına yuvarlanır. + +!!! note "Not" + Sayfa yükleme süresi nicelerini hesaplamak için, bu işlev daha etkili ve doğrudur [quantile](#quantile). + +**Döndürülen değer** + +- Belirtilen seviyenin miktarı. + +Tür: `Float32`. + +!!! note "Not" + İşlev valuese hiçbir değer geçir (ilmem (işse (kullanırken `quantileTimingIf`), [Nine](../../sql_reference/data_types/float.md#data_type-float-nan-inf) döndürülür. Bunun amacı, bu vakaları sıfır ile sonuçlanan vakalardan ayırmaktır. Görmek [ORDER BY FLA BYGE](../statements/select.md#select-order-by) sıralama ile ilgili notlar için `NaN` değerler. + +**Örnek** + +Giriş tablosu: + +``` text +┌─response_time─┐ +│ 72 │ +│ 112 │ +│ 126 │ +│ 145 │ +│ 104 │ +│ 242 │ +│ 313 │ +│ 168 │ +│ 108 │ +└───────────────┘ +``` + +Sorgu: + +``` sql +SELECT quantileTiming(response_time) FROM t +``` + +Sonuç: + +``` text +┌─quantileTiming(response_time)─┐ +│ 126 │ +└───────────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [medyan](#median) +- [quantiles](#quantiles) + +## niceletimingweighted {#quantiletimingweighted} + +Belirlenen hassas hesaplar ile [quantile](https://en.wikipedia.org/wiki/Quantile) her sıra üyesi ağırlığına göre sayısal veri dizisi. + +Sonuç deterministiktir (sorgu işleme sırasına bağlı değildir). Fonksiyon yükleme web sayfaları kez veya arka uç yanıt süreleri gibi dağılımları tanımlamak dizileri ile çalışmak için optimize edilmiştir. + +Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) işlev. + +**Sözdizimi** + +``` sql +quantileTimingWeighted(level)(expr, weight) +``` + +Takma ad: `medianTimingWeighted`. + +**Parametre** + +- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median). + +- `expr` — [İfade](../syntax.md#syntax-expressions) bir sütun değerleri üzerinde dönen bir [Yüzdürmek\*](../../sql_reference/data_types/float.md)- tip numarası. + + - If negative values are passed to the function, the behavior is undefined. + - If the value is greater than 30,000 (a page loading time of more than 30 seconds), it is assumed to be 30,000. + +- `weight` — Column with weights of sequence elements. Weight is a number of value occurrences. + +**Doğruluk** + +Hesaplama doğru ise: + +- Toplam değer sayısı 5670'i geçmez. +- Toplam değer sayısı 5670'i aşıyor, ancak sayfa yükleme süresi 1024 ms'den az. + +Aksi takdirde, hesaplamanın sonucu 16 MS'nin en yakın katlarına yuvarlanır. + +!!! note "Not" + Sayfa yükleme süresi nicelerini hesaplamak için, bu işlev daha etkili ve doğrudur [quantile](#quantile). + +**Döndürülen değer** + +- Belirtilen seviyenin miktarı. + +Tür: `Float32`. + +!!! note "Not" + İşlev valuese hiçbir değer geçir (ilmem (işse (kullanırken `quantileTimingIf`), [Nine](../../sql_reference/data_types/float.md#data_type-float-nan-inf) döndürülür. Bunun amacı, bu vakaları sıfır ile sonuçlanan vakalardan ayırmaktır. Görmek [ORDER BY FLA BYGE](../statements/select.md#select-order-by) sıralama ile ilgili notlar için `NaN` değerler. + +**Örnek** + +Giriş tablosu: + +``` text +┌─response_time─┬─weight─┐ +│ 68 │ 1 │ +│ 104 │ 2 │ +│ 112 │ 3 │ +│ 126 │ 2 │ +│ 138 │ 1 │ +│ 162 │ 1 │ +└───────────────┴────────┘ +``` + +Sorgu: + +``` sql +SELECT quantileTimingWeighted(response_time, weight) FROM t +``` + +Sonuç: + +``` text +┌─quantileTimingWeighted(response_time, weight)─┐ +│ 112 │ +└───────────────────────────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [medyan](#median) +- [quantiles](#quantiles) + +## quantileTDigest {#quantiletdigest} + +Yaklaşık hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) kullanarak sayısal veri diz ofisinin [t-dig -est](https://github.com/tdunning/t-digest/blob/master/docs/t-digest-paper/histo.pdf) algoritma. + +Maksimum hata %1'dir. Bellek tüketimi `log(n)`, nere `n` değer say isısıdır. Sonuç, sorguyu çalıştırma sırasına bağlıdır ve nondeterministic. + +Fonksiyonun performansı, performanstan daha düşüktür [quantile](#quantile) veya [quantileTiming](#quantiletiming). Durum boyutunun hassasiyete oranı açısından, bu işlev çok daha iyidir `quantile`. + +Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) işlev. + +**Sözdizimi** + +``` sql +quantileTDigest(level)(expr) +``` + +Takma ad: `medianTDigest`. + +**Parametre** + +- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median). +- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql_reference/data_types/index.md#data_types), [Tarihli](../../sql_reference/data_types/date.md) veya [DateTime](../../sql_reference/data_types/datetime.md). + +**Döndürülen değer** + +- Belirtilen seviyenin yaklaşık miktarı. + +Tür: + +- [Float64](../../sql_reference/data_types/float.md) sayısal veri türü girişi için. +- [Tarihli](../../sql_reference/data_types/date.md) giriş değerleri varsa `Date` tür. +- [DateTime](../../sql_reference/data_types/datetime.md) giriş değerleri varsa `DateTime` tür. + +**Örnek** + +Sorgu: + +``` sql +SELECT quantileTDigest(number) FROM numbers(10) +``` + +Sonuç: + +``` text +┌─quantileTDigest(number)─┐ +│ 4.5 │ +└─────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [medyan](#median) +- [quantiles](#quantiles) + +## quantileTDigestWeighted {#quantiletdigestweighted} + +Yaklaşık hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) kullanarak sayısal veri diz ofisinin [t-dig -est](https://github.com/tdunning/t-digest/blob/master/docs/t-digest-paper/histo.pdf) algoritma. İşlev, her sıra üyesinin ağırlığını dikkate alır. Maksimum hata %1'dir. Bellek tüketimi `log(n)`, nere `n` değer say isısıdır. + +Fonksiyonun performansı, performanstan daha düşüktür [quantile](#quantile) veya [quantileTiming](#quantiletiming). Durum boyutunun hassasiyete oranı açısından, bu işlev çok daha iyidir `quantile`. + +Sonuç, sorguyu çalıştırma sırasına bağlıdır ve nondeterministic. + +Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) işlev. + +**Sözdizimi** + +``` sql +quantileTDigest(level)(expr) +``` + +Takma ad: `medianTDigest`. + +**Parametre** + +- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median). +- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql_reference/data_types/index.md#data_types), [Tarihli](../../sql_reference/data_types/date.md) veya [DateTime](../../sql_reference/data_types/datetime.md). +- `weight` — Column with weights of sequence elements. Weight is a number of value occurrences. + +**Döndürülen değer** + +- Belirtilen seviyenin yaklaşık miktarı. + +Tür: + +- [Float64](../../sql_reference/data_types/float.md) sayısal veri türü girişi için. +- [Tarihli](../../sql_reference/data_types/date.md) giriş değerleri varsa `Date` tür. +- [DateTime](../../sql_reference/data_types/datetime.md) giriş değerleri varsa `DateTime` tür. + +**Örnek** + +Sorgu: + +``` sql +SELECT quantileTDigestWeighted(number, 1) FROM numbers(10) +``` + +Sonuç: + +``` text +┌─quantileTDigestWeighted(number, 1)─┐ +│ 4.5 │ +└────────────────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [medyan](#median) +- [quantiles](#quantiles) + +## medyan {#median} + +Bu `median*` fonksiyonlar karşılık gelen takma adlardır `quantile*` işlevler. Sayısal bir veri örneğinin medyanını hesaplarlar. + +İşlevler: + +- `median` — Alias for [quantile](#quantile). +- `medianDeterministic` — Alias for [quantileDeterministic](#quantiledeterministic). +- `medianExact` — Alias for [quantileExact](#quantileexact). +- `medianExactWeighted` — Alias for [quantilexactweighted](#quantileexactweighted). +- `medianTiming` — Alias for [quantileTiming](#quantiletiming). +- `medianTimingWeighted` — Alias for [niceletimingweighted](#quantiletimingweighted). +- `medianTDigest` — Alias for [quantileTDigest](#quantiletdigest). +- `medianTDigestWeighted` — Alias for [quantileTDigestWeighted](#quantiletdigestweighted). + +**Örnek** + +Giriş tablosu: + +``` text +┌─val─┐ +│ 1 │ +│ 1 │ +│ 2 │ +│ 3 │ +└─────┘ +``` + +Sorgu: + +``` sql +SELECT medianDeterministic(val, 1) FROM t +``` + +Sonuç: + +``` text +┌─medianDeterministic(val, 1)─┐ +│ 1.5 │ +└─────────────────────────────┘ +``` + +## quantiles(level1, level2, …)(x) {#quantiles} + +Tüm quantile fonksiyonları da karşılık gelen quantile fonksiyonlarına sahiptir: `quantiles`, `quantilesDeterministic`, `quantilesTiming`, `quantilesTimingWeighted`, `quantilesExact`, `quantilesExactWeighted`, `quantilesTDigest`. Bu işlevler, listelenen seviyelerin tüm nicelerini tek geçişte hesaplar ve elde edilen değerlerin bir dizisini döndürür. + +## varSamp (x) {#varsampx} + +Miktarı hesaplar `Σ((x - x̅)^2) / (n - 1)`, nere `n` örneklem büyüklüğü ve `x̅`ortalama değer isidir `x`. + +Bir rassal değişkenin varyansının tarafsız bir tahminini temsil eder, eğer geçirilen değerler numunesini oluşturursa. + +Dönüşler `Float64`. Ne zaman `n <= 1`, dönüşler `+∞`. + +## varPop (x) {#varpopx} + +Miktarı hesaplar `Σ((x - x̅)^2) / n`, nere `n` örneklem büyüklüğü ve `x̅`ortalama değer isidir `x`. + +Başka bir deyişle, bir dizi değer için dağılım. Dönüşler `Float64`. + +## stddevSamp(x) {#stddevsampx} + +Sonuç kareköküne eşittir `varSamp(x)`. + +## stddevPop(x) {#stddevpopx} + +Sonuç kareköküne eşittir `varPop(x)`. + +## topK (N) (x) {#topknx} + +Belirtilen sütundaki yaklaşık en sık değerleri bir dizi döndürür. Elde edilen dizi, değerlerin yaklaşık frekansının azalan sırasına göre sıralanır (değerlerin kendileri tarafından değil). + +Uygular [Filtrelenmiş Yerden Tasarruf](http://www.l2f.inesc-id.pt/~fmmb/wiki/uploads/Work/misnis.ref0a.pdf) TopK analiz etmek için algoritma, azaltmak ve birleştirmek algoritması dayalı [Paralel Alan Tasarrufu](https://arxiv.org/pdf/1401.0702.pdf). + +``` sql +topK(N)(column) +``` + +Bu işlev garantili bir sonuç sağlamaz. Bazı durumlarda, hatalar oluşabilir ve en sık kullanılan değerler olmayan sık değerler döndürebilir. + +Biz kullanmanızı öneririz `N < 10` değer; performans büyük ile azalır `N` değerler. Maksimum değeri `N = 65536`. + +**Parametre** + +- ‘N’ dönmek için Öğe sayısıdır. + +Parametre atlanırsa, varsayılan değer 10 kullanılır. + +**Değişkenler** + +- ' x ' – The value to calculate frequency. + +**Örnek** + +Tak thee the [OnTime](../../getting_started/example_datasets/ontime.md) veri kümesi ve üç en sık oluşan değerleri seçin `AirlineID` sütun. + +``` sql +SELECT topK(3)(AirlineID) AS res +FROM ontime +``` + +``` text +┌─res─────────────────┐ +│ [19393,19790,19805] │ +└─────────────────────┘ +``` + +## topKWeighted {#topkweighted} + +Benzer `topK` ancak tamsayı türünde bir ek argüman alır - `weight`. Her değer muhasebeleştirilir `weight` frekans hesaplaması için zamanlar. + +**Sözdizimi** + +``` sql +topKWeighted(N)(x, weight) +``` + +**Parametre** + +- `N` — The number of elements to return. + +**Değişkenler** + +- `x` – The value. +- `weight` — The weight. [Uİnt8](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değer** + +Maksimum yaklaşık ağırlık toplamına sahip değerlerin bir dizisini döndürür. + +**Örnek** + +Sorgu: + +``` sql +SELECT topKWeighted(10)(number, number) FROM numbers(1000) +``` + +Sonuç: + +``` text +┌─topKWeighted(10)(number, number)──────────┐ +│ [999,998,997,996,995,994,993,992,991,990] │ +└───────────────────────────────────────────┘ +``` + +## covarSamp(x, y) {#covarsampx-y} + +Değerini hesaplar `Σ((x - x̅)(y - y̅)) / (n - 1)`. + +Float64 Döndürür. Ne zaman `n <= 1`, returns +∞. + +## covarPop (x, y) {#covarpopx-y} + +Değerini hesaplar `Σ((x - x̅)(y - y̅)) / n`. + +## corr(x, y) {#corrx-y} + +Pearson korelasyon katsayısını hesaplar: `Σ((x - x̅)(y - y̅)) / sqrt(Σ((x - x̅)^2) * Σ((y - y̅)^2))`. + +## categoricalınformationvalue {#categoricalinformationvalue} + +Değerini hesaplar `(P(tag = 1) - P(tag = 0))(log(P(tag = 1)) - log(P(tag = 0)))` her kategori için. + +``` sql +categoricalInformationValue(category1, category2, ..., tag) +``` + +Sonuç, ayrık (kategorik) bir özelliğin nasıl olduğunu gösterir `[category1, category2, ...]` değerini öngör aen bir öğrenme modeline katkıda `tag`. + +## simpleLinearRegression {#simplelinearregression} + +Basit (tek boyutlu) doğrusal regresyon gerçekleştirir. + +``` sql +simpleLinearRegression(x, y) +``` + +Parametre: + +- `x` — Column with dependent variable values. +- `y` — Column with explanatory variable values. + +Döndürülen değerler: + +Devamlılar `(a, b)` ortaya çıkan hat linetın `y = a*x + b`. + +**Örnekler** + +``` sql +SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3]) +``` + +``` text +┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3])─┐ +│ (1,0) │ +└───────────────────────────────────────────────────────────────────┘ +``` + +``` sql +SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6]) +``` + +``` text +┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6])─┐ +│ (1,3) │ +└───────────────────────────────────────────────────────────────────┘ +``` + +## stokastiklinearregression {#agg_functions-stochasticlinearregression} + +Bu fonksiyon stokastik doğrusal regresyon uygular. Öğrenme oranı, L2 regularization katsayısı, mini-batch boyutu için özel parametreleri destekler ve ağırlıkları güncellemek için birkaç yöntem vardır ([Adem](https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Adam) (varsayılan olarak kullanılır), [basit SGD](https://en.wikipedia.org/wiki/Stochastic_gradient_descent), [İvme](https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Momentum), [Nesterov](https://mipt.ru/upload/medialibrary/d7e/41-91.pdf)). + +### Parametre {#agg_functions-stochasticlinearregression-parameters} + +4 özelleştirilebilir parametre vardır. Onlar sırayla işleve geçirilir, ancak dört varsayılan değerleri kullanılacak geçmek gerek yoktur, ancak iyi bir model bazı parametre ayarlama gerekli. + +``` text +stochasticLinearRegression(1.0, 1.0, 10, 'SGD') +``` + +1. `learning rate` Gradyan iniş adımı gerçekleştirildiğinde adım uzunluğundaki katsayıdır. Çok büyük öğrenme oranı, modelin sonsuz ağırlıklarına neden olabilir. Default is `0.00001`. +2. `l2 regularization coefficient` hangi overfitting önlemek için yardımcı olabilir. Default is `0.1`. +3. `mini-batch size` gradyanların hesaplanacağı ve Gradyan inişinin bir adımını gerçekleştirmek için toplanacağı öğelerin sayısını ayarlar. Saf stokastik iniş bir eleman kullanır, ancak küçük partilere(yaklaşık 10 eleman) sahip olmak degrade adımları daha kararlı hale getirir. Default is `15`. +4. `method for updating weights` onlar : `Adam` (varsayılan olarak), `SGD`, `Momentum`, `Nesterov`. `Momentum` ve `Nesterov` biraz daha fazla hesaplama ve bellek gerektirir, ancak stokastik Gradyan yöntemlerinin yakınsama hızı ve kararlılığı açısından yararlı olurlar. + +### Kullanma {#agg_functions-stochasticlinearregression-usage} + +`stochasticLinearRegression` iki adımda kullanılır: modelin takılması ve yeni verilerin tahmin edilmesi. Modeli sığdırmak ve daha sonra kullanım için durumunu kaydetmek için kullandığımız `-State` temel olarak durumu kurtaran birleştirici (model ağırlıkları, vb.). +Fonksiyonu kullan wedığımızı tahmin etmek [evalMLMethod](../functions/machine_learning_functions.md#machine_learning_methods-evalmlmethod), bir argüman olarak bir durumu yanı sıra tahmin etmek için özellikler alır. + + + +**1.** Uydurma + +Böyle bir sorgu kullanılabilir. + +``` sql +CREATE TABLE IF NOT EXISTS train_data +( + param1 Float64, + param2 Float64, + target Float64 +) ENGINE = Memory; + +CREATE TABLE your_model ENGINE = Memory AS SELECT +stochasticLinearRegressionState(0.1, 0.0, 5, 'SGD')(target, param1, param2) +AS state FROM train_data; +``` + +Burada ayrıca veri eklememiz gerekiyor `train_data` Tablo. Parametrelerin sayısı sabit değildir, sadece argümanların sayısına bağlıdır, `linearRegressionState`. Hepsi sayısal değerler olmalıdır. +Hedef değere sahip sütunun(tahmin etmeyi öğrenmek istediğimiz) ilk argüman olarak eklendiğini unutmayın. + +**2.** Öngören + +Bir durumu tabloya kaydettikten sonra, tahmin için birden çok kez kullanabilir, hatta diğer durumlarla birleşebilir ve yeni daha iyi modeller oluşturabiliriz. + +``` sql +WITH (SELECT state FROM your_model) AS model SELECT +evalMLMethod(model, param1, param2) FROM test_data +``` + +Sorgu, tahmin edilen değerlerin bir sütununu döndürür. Not ilk argüman `evalMLMethod` oluyor `AggregateFunctionState` nesne, sonraki özelliklerin sütunlarıdır. + +`test_data` bir tablo gibi mi `train_data` ancak hedef değer içermeyebilir. + +### Not {#agg_functions-stochasticlinearregression-notes} + +1. İki modeli birleştirmek için Kullanıcı böyle bir sorgu oluşturabilir: + `sql SELECT state1 + state2 FROM your_models` + nerede `your_models` tablo her iki modeli de içerir. Bu sorgu yeni dönecektir `AggregateFunctionState` nesne. + +2. Kullanıcı, modeli kaydetmeden oluşturulan modelin ağırlıklarını kendi amaçları için alabilir `-State` birleştirici kullanılır. + `sql SELECT stochasticLinearRegression(0.01)(target, param1, param2) FROM train_data` + Bu sorgu modele uyacak ve ağırlıklarını geri getirecektir-ilk önce modelin parametrelerine karşılık gelen ağırlıklar, sonuncusu önyargıdır. Yani yukarıdaki örnekte sorgu 3 değer içeren bir sütun döndürecektir. + +**Ayrıca Bakınız** + +- [stochasticLogisticRegression](#agg_functions-stochasticlogisticregression) +- [Doğrusal ve lojistik regresyonlar arasındaki fark](https://stackoverflow.com/questions/12146914/what-is-the-difference-between-linear-regression-and-logistic-regression) + +## stochasticLogisticRegression {#agg_functions-stochasticlogisticregression} + +Bu işlev stokastik lojistik regresyon uygular. İkili sınıflandırma problemi için kullanılabilir, stochasticLinearRegression ile aynı özel parametreleri destekler ve aynı şekilde çalışır. + +### Parametre {#agg_functions-stochasticlogisticregression-parameters} + +Parametreler tam olarak stochasticLinearRegression ile aynıdır: +`learning rate`, `l2 regularization coefficient`, `mini-batch size`, `method for updating weights`. +Daha fazla bilgi için bkz. [parametre](#agg_functions-stochasticlinearregression-parameters). + +``` text +stochasticLogisticRegression(1.0, 1.0, 10, 'SGD') +``` + +1. Uydurma + + + + See the `Fitting` section in the [stochasticLinearRegression](#stochasticlinearregression-usage-fitting) description. + + Predicted labels have to be in \[-1, 1\]. + +1. Öngören + + + + Using saved state we can predict probability of object having label `1`. + + ``` sql + WITH (SELECT state FROM your_model) AS model SELECT + evalMLMethod(model, param1, param2) FROM test_data + ``` + + The query will return a column of probabilities. Note that first argument of `evalMLMethod` is `AggregateFunctionState` object, next are columns of features. + + We can also set a bound of probability, which assigns elements to different labels. + + ``` sql + SELECT ans < 1.1 AND ans > 0.5 FROM + (WITH (SELECT state FROM your_model) AS model SELECT + evalMLMethod(model, param1, param2) AS ans FROM test_data) + ``` + + Then the result will be labels. + + `test_data` is a table like `train_data` but may not contain target value. + +**Ayrıca Bakınız** + +- [stokastiklinearregression](#agg_functions-stochasticlinearregression) +- [Doğrusal ve lojistik regresyonlar arasındaki fark.](https://stackoverflow.com/questions/12146914/what-is-the-difference-between-linear-regression-and-logistic-regression) + +## groupBitmapAnd {#groupbitmapand} + +Bu VE bir bitmap sütun, Uınt64 tür iade önem, hesaplamaları suffix ekleme -Devlet, sonra iade [bitmap nesnesi](../../sql_reference/functions/bitmap_functions.md). + +``` sql +groupBitmapAnd(expr) +``` + +**Parametre** + +`expr` – An expression that results in `AggregateFunction(groupBitmap, UInt*)` tür. + +**Dönüş değeri** + +Bu değer `UInt64` tür. + +**Örnek** + +``` sql +DROP TABLE IF EXISTS bitmap_column_expr_test2; +CREATE TABLE bitmap_column_expr_test2 +( + tag_id String, + z AggregateFunction(groupBitmap, UInt32) +) +ENGINE = MergeTree +ORDER BY tag_id; + +INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32)))); +INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32)))); +INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32)))); + +SELECT groupBitmapAnd(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%'); +┌─groupBitmapAnd(z)─┐ +│ 3 │ +└───────────────────┘ + +SELECT arraySort(bitmapToArray(groupBitmapAndState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%'); +┌─arraySort(bitmapToArray(groupBitmapAndState(z)))─┐ +│ [6,8,10] │ +└──────────────────────────────────────────────────┘ +``` + +## groupBitmapOr {#groupbitmapor} + +YA da bir bitmap sütun, Uınt64 tür iade önem, hesaplamaları suffix ekleme -Devlet, sonra iade [bitmap nesnesi](../../sql_reference/functions/bitmap_functions.md). Bu eşdeğerdir `groupBitmapMerge`. + +``` sql +groupBitmapOr(expr) +``` + +**Parametre** + +`expr` – An expression that results in `AggregateFunction(groupBitmap, UInt*)` tür. + +**Dönüş değeri** + +Bu değer `UInt64` tür. + +**Örnek** + +``` sql +DROP TABLE IF EXISTS bitmap_column_expr_test2; +CREATE TABLE bitmap_column_expr_test2 +( + tag_id String, + z AggregateFunction(groupBitmap, UInt32) +) +ENGINE = MergeTree +ORDER BY tag_id; + +INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32)))); +INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32)))); +INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32)))); + +SELECT groupBitmapOr(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%'); +┌─groupBitmapOr(z)─┐ +│ 15 │ +└──────────────────┘ + +SELECT arraySort(bitmapToArray(groupBitmapOrState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%'); +┌─arraySort(bitmapToArray(groupBitmapOrState(z)))─┐ +│ [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15] │ +└─────────────────────────────────────────────────┘ +``` + +## groupBitmapXor {#groupbitmapxor} + +Bir bitmap sütun, Uınt64 tür iade önem hesaplamaları XOR, suffix ekleme -Devlet, sonra iade [bitmap nesnesi](../../sql_reference/functions/bitmap_functions.md). + +``` sql +groupBitmapOr(expr) +``` + +**Parametre** + +`expr` – An expression that results in `AggregateFunction(groupBitmap, UInt*)` tür. + +**Dönüş değeri** + +Bu değer `UInt64` tür. + +**Örnek** + +``` sql +DROP TABLE IF EXISTS bitmap_column_expr_test2; +CREATE TABLE bitmap_column_expr_test2 +( + tag_id String, + z AggregateFunction(groupBitmap, UInt32) +) +ENGINE = MergeTree +ORDER BY tag_id; + +INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32)))); +INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32)))); +INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32)))); + +SELECT groupBitmapXor(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%'); +┌─groupBitmapXor(z)─┐ +│ 10 │ +└───────────────────┘ + +SELECT arraySort(bitmapToArray(groupBitmapXorState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%'); +┌─arraySort(bitmapToArray(groupBitmapXorState(z)))─┐ +│ [1,3,5,6,8,10,11,13,14,15] │ +└──────────────────────────────────────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/agg_functions/reference/) diff --git a/docs/tr/sql_reference/data_types/aggregatefunction.md b/docs/tr/sql_reference/data_types/aggregatefunction.md new file mode 100644 index 00000000000..622e02d9674 --- /dev/null +++ b/docs/tr/sql_reference/data_types/aggregatefunction.md @@ -0,0 +1,70 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 52 +toc_title: AggregateFunction (ad, types_of_arguments...) +--- + +# AggregateFunction(name, types\_of\_arguments…) {#data-type-aggregatefunction} + +Aggregate functions can have an implementation-defined intermediate state that can be serialized to an AggregateFunction(…) data type and stored in a table, usually, by means of [materyalize bir görünüm](../../sql_reference/statements/select.md#create-view). Bir toplama işlevi durumu üretmek için ortak yolu ile toplama işlevi çağırarak olduğunu `-State` sonek. Gelecekte toplanmanın nihai sonucunu elde etmek için, aynı toplama işlevini `-Merge`sonek. + +`AggregateFunction` — parametric data type. + +**Parametre** + +- Toplama işlevinin adı. + + If the function is parametric, specify its parameters too. + +- Toplama işlevi bağımsız değişkenleri türleri. + +**Örnek** + +``` sql +CREATE TABLE t +( + column1 AggregateFunction(uniq, UInt64), + column2 AggregateFunction(anyIf, String, UInt8), + column3 AggregateFunction(quantiles(0.5, 0.9), UInt64) +) ENGINE = ... +``` + +[uniq](../../sql_reference/aggregate_functions/reference.md#agg_function-uniq), anyİf ([herhangi](../../sql_reference/aggregate_functions/reference.md#agg_function-any)+[Eğer](../../sql_reference/aggregate_functions/combinators.md#agg-functions-combinator-if)) ve [quantiles](../../sql_reference/aggregate_functions/reference.md) ClickHouse desteklenen toplam işlevleri vardır. + +## Kullanma {#usage} + +### Veri Ekleme {#data-insertion} + +Veri eklemek için şunları kullanın `INSERT SELECT` agr aggregateega ile `-State`- işlevler. + +**Fonksiyon örnekleri** + +``` sql +uniqState(UserID) +quantilesState(0.5, 0.9)(SendTiming) +``` + +Karşılık gelen fonksiyonların aksine `uniq` ve `quantiles`, `-State`- fonksiyonlar son değer yerine durumu döndürür. Başka bir deyişle, bir değer döndürür `AggregateFunction` tür. + +Sonuç inlarında `SELECT` sorgu, değerleri `AggregateFunction` türü, Tüm ClickHouse çıktı biçimleri için uygulamaya özgü ikili gösterime sahiptir. Örneğin, veri dökümü, `TabSeparated` ile format `SELECT` sorgu, daha sonra bu dökümü kullanarak geri yüklenebilir `INSERT` sorgu. + +### Veri Seçimi {#data-selection} + +Veri seçerken `AggregatingMergeTree` tablo kullanın `GROUP BY` yan tümce ve veri eklerken aynı toplama işlevleri, ancak kullanarak `-Merge`sonek. + +Bir toplama fonksiyonu ile `-Merge` sonek, bir dizi durum alır, bunları birleştirir ve tam veri toplama sonucunu döndürür. + +Örneğin, aşağıdaki iki sorgu aynı sonucu döndürür: + +``` sql +SELECT uniq(UserID) FROM table + +SELECT uniqMerge(state) FROM (SELECT uniqState(UserID) AS state FROM table GROUP BY RegionID) +``` + +## Kullanım Örneği {#usage-example} + +Görmek [AggregatingMergeTree](../../engines/table_engines/mergetree_family/aggregatingmergetree.md) motor açıklaması. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/nested_data_structures/aggregatefunction/) diff --git a/docs/tr/sql_reference/data_types/array.md b/docs/tr/sql_reference/data_types/array.md new file mode 100644 index 00000000000..1db16ebd1fc --- /dev/null +++ b/docs/tr/sql_reference/data_types/array.md @@ -0,0 +1,77 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 51 +toc_title: Dizi(T) +--- + +# Dizi(t) {#data-type-array} + +Bir dizi `T`- tip öğeleri. `T` herhangi bir veri türü, bir dizi dahil edilebilir. + +## Bir dizi oluşturma {#creating-an-array} + +Bir dizi oluşturmak için bir işlev kullanabilirsiniz: + +``` sql +array(T) +``` + +Köşeli parantez de kullanabilirsiniz. + +``` sql +[] +``` + +Bir dizi oluşturma örneği: + +``` sql +SELECT array(1, 2) AS x, toTypeName(x) +``` + +``` text +┌─x─────┬─toTypeName(array(1, 2))─┐ +│ [1,2] │ Array(UInt8) │ +└───────┴─────────────────────────┘ +``` + +``` sql +SELECT [1, 2] AS x, toTypeName(x) +``` + +``` text +┌─x─────┬─toTypeName([1, 2])─┐ +│ [1,2] │ Array(UInt8) │ +└───────┴────────────────────┘ +``` + +## Veri Türleri İle Çalışma {#working-with-data-types} + +Anında bir dizi oluştururken, ClickHouse bağımsız değişken türünü otomatik olarak listelenen tüm bağımsız değişkenleri depolayabilen en dar veri türü olarak tanımlar. Eğer herhangi bir [Nullable](nullable.md#data_type-nullable) veya edebi [NULL](../../sql_reference/syntax.md#null-literal) değerler, bir dizi öğesinin türü de olur [Nullable](nullable.md). + +ClickHouse veri türünü belirleyemedi, bir özel durum oluşturur. Örneğin, aynı anda dizeler ve sayılarla bir dizi oluşturmaya çalışırken bu olur (`SELECT array(1, 'a')`). + +Otomatik veri türü algılama örnekleri: + +``` sql +SELECT array(1, 2, NULL) AS x, toTypeName(x) +``` + +``` text +┌─x──────────┬─toTypeName(array(1, 2, NULL))─┐ +│ [1,2,NULL] │ Array(Nullable(UInt8)) │ +└────────────┴───────────────────────────────┘ +``` + +Uyumsuz veri türleri dizisi oluşturmaya çalışırsanız, ClickHouse bir özel durum atar: + +``` sql +SELECT array(1, 'a') +``` + +``` text +Received exception from server (version 1.1.54388): +Code: 386. DB::Exception: Received from localhost:9000, 127.0.0.1. DB::Exception: There is no supertype for types UInt8, String because some of them are String/FixedString and some of them are not. +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/array/) diff --git a/docs/tr/sql_reference/data_types/boolean.md b/docs/tr/sql_reference/data_types/boolean.md new file mode 100644 index 00000000000..e0641847b98 --- /dev/null +++ b/docs/tr/sql_reference/data_types/boolean.md @@ -0,0 +1,12 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 43 +toc_title: Boeanoleanean +--- + +# Boole Değerleri {#boolean-values} + +Boole değerleri için ayrı bir tür yoktur. 0 veya 1 değerleriyle sınırlı Uİnt8 türünü kullanın. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/boolean/) diff --git a/docs/tr/sql_reference/data_types/date.md b/docs/tr/sql_reference/data_types/date.md new file mode 100644 index 00000000000..fd47a49313c --- /dev/null +++ b/docs/tr/sql_reference/data_types/date.md @@ -0,0 +1,15 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 47 +toc_title: Tarihli +--- + +# Tarihli {#date} + +Tarihli. 1970-01-01 (imzasız) gün sayısı olarak iki bayt olarak saklanır. Unix döneminin başlangıcından hemen sonra, derleme aşamasında bir sabit tarafından tanımlanan üst eşiğe kadar değerlerin depolanmasına izin verir (şu anda, bu 2106 yılına kadar, ancak tam olarak desteklenen son yıl 2105'tir). +Minimum değer 0000-00-00 olarak çıktıdır. + +Tarih değeri saat dilimi olmadan depolanır. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/date/) diff --git a/docs/tr/sql_reference/data_types/datetime.md b/docs/tr/sql_reference/data_types/datetime.md new file mode 100644 index 00000000000..bc5feeed3b5 --- /dev/null +++ b/docs/tr/sql_reference/data_types/datetime.md @@ -0,0 +1,129 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 48 +toc_title: DateTime +--- + +# Datetime {#data_type-datetime} + +Bir takvim tarih ve bir günün bir saat olarak ifade edilebilir, zaman içinde bir anlık saklamak için izin verir. + +Sözdizimi: + +``` sql +DateTime([timezone]) +``` + +Desteklenen değerler aralığı: \[1970-01-01 00:00:00, 2105-12-31 23:59:59\]. + +Çözünürlük: 1 saniye. + +## Kullanım Açıklamaları {#usage-remarks} + +Zaman içindeki nokta bir [Unix zaman damgası](https://en.wikipedia.org/wiki/Unix_time), ne olursa olsun saat dilimi veya gün ışığından yararlanma saati. Ayrıca, `DateTime` tür, tüm sütun için aynı olan saat dilimini depolayabilir, bu da `DateTime` tür değerleri metin biçiminde görüntülenir ve dizeler olarak belirtilen değerlerin nasıl ayrıştırılır (‘2020-01-01 05:00:01’). Saat dilimi tablo (veya resultset) satırlarında depolanır, ancak sütun meta verileri depolanır. +Desteklenen saat dilimlerinin bir listesi şu adreste bulunabilir: [IANA Saat Dilimi veritabanı](https://www.iana.org/time-zones). +Bu `tzdata` paket, içeren [IANA Saat Dilimi veritabanı](https://www.iana.org/time-zones), sisteme Kurul .malıdır. Kullan... `timedatectl list-timezones` yerel bir sistem tarafından bilinen zaman dilimlerini listelemek için komut. + +İçin bir saat dilimi açıkça ayarlayabilirsiniz `DateTime`- bir tablo oluştururken sütunları yazın. Saat dilimi ayarlanmamışsa, ClickHouse değerini kullanır [saat dilimi](../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-timezone) sunucu ayarlarında veya ClickHouse sunucusunun başlatıldığı anda işletim sistemi ayarlarında parametre. + +Bu [clickhouse-müşteri](../../interfaces/cli.md) veri türünü başlatırken bir saat dilimi açıkça ayarlanmamışsa, sunucu saat dilimini varsayılan olarak uygular. İstemci saat dilimini kullanmak için `clickhouse-client` ile... `--use_client_time_zone` parametre. + +ClickHouse çıkış değerleri `YYYY-MM-DD hh:mm:ss` varsayılan olarak metin biçimi. Çıkış ile değiştirebilirsiniz [formatDateTime](../../sql_reference/functions/date_time_functions.md#formatdatetime) işlev. + +Clickhouse'a veri eklerken, Tarih ve saat dizelerinin farklı biçimlerini kullanabilirsiniz. [date\_time\_input\_format](../../operations/settings/settings.md#settings-date_time_input_format) ayar. + +## Örnekler {#examples} + +**1.** Bir tablo ile bir tablo oluşturma `DateTime`- sütun yazın ve içine veri ekleme: + +``` sql +CREATE TABLE dt +( + `timestamp` DateTime('Europe/Moscow'), + `event_id` UInt8 +) +ENGINE = TinyLog; +``` + +``` sql +INSERT INTO dt Values (1546300800, 1), ('2019-01-01 00:00:00', 2); +``` + +``` sql +SELECT * FROM dt; +``` + +``` text +┌───────────timestamp─┬─event_id─┐ +│ 2019-01-01 03:00:00 │ 1 │ +│ 2019-01-01 00:00:00 │ 2 │ +└─────────────────────┴──────────┘ +``` + +- Bir tamsayı olarak datetime eklerken, Unıx Zaman Damgası (UTC) olarak kabul edilir. `1546300800` temsil etmek `'2019-01-01 00:00:00'` UTC. Ancak, `timestamp` sütun vardır `Europe/Moscow` (UTC+3) belirtilen zaman dilimi, dize olarak çıkış yaparken değer olarak gösterilecektir `'2019-01-01 03:00:00'` +- Dize değerini datetime olarak eklerken, sütun saat diliminde olduğu kabul edilir. `'2019-01-01 00:00:00'` will gibi muamele `Europe/Moscow` saat dilimi ve farklı kaydedildi `1546290000`. + +**2.** Üzerinde filtreleme `DateTime` değerler + +``` sql +SELECT * FROM dt WHERE timestamp = toDateTime('2019-01-01 00:00:00', 'Europe/Moscow') +``` + +``` text +┌───────────timestamp─┬─event_id─┐ +│ 2019-01-01 00:00:00 │ 2 │ +└─────────────────────┴──────────┘ +``` + +`DateTime` sütun değerleri, bir dize değeri kullanılarak filtrelenebilir `WHERE` yüklem. Dönüştürül willecektir `DateTime` otomatik olarak: + +``` sql +SELECT * FROM dt WHERE timestamp = '2019-01-01 00:00:00' +``` + +``` text +┌───────────timestamp─┬─event_id─┐ +│ 2019-01-01 03:00:00 │ 1 │ +└─────────────────────┴──────────┘ +``` + +**3.** Bir saat dilimi almak `DateTime`- type Col columnum columnn: + +``` sql +SELECT toDateTime(now(), 'Europe/Moscow') AS column, toTypeName(column) AS x +``` + +``` text +┌──────────────column─┬─x─────────────────────────┐ +│ 2019-10-16 04:12:04 │ DateTime('Europe/Moscow') │ +└─────────────────────┴───────────────────────────┘ +``` + +**4.** Zaman dilimi dönüştürme + +``` sql +SELECT +toDateTime(timestamp, 'Europe/London') as lon_time, +toDateTime(timestamp, 'Europe/Moscow') as mos_time +FROM dt +``` + +``` text +┌───────────lon_time──┬────────────mos_time─┐ +│ 2019-01-01 00:00:00 │ 2019-01-01 03:00:00 │ +│ 2018-12-31 21:00:00 │ 2019-01-01 00:00:00 │ +└─────────────────────┴─────────────────────┘ +``` + +## Ayrıca Bakınız {#see-also} + +- [Tip dönüştürme fonksiyonları](../../sql_reference/functions/type_conversion_functions.md) +- [Tarih ve saatlerle çalışmak için işlevler](../../sql_reference/functions/date_time_functions.md) +- [Dizilerle çalışmak için işlevler](../../sql_reference/functions/array_functions.md) +- [Bu `date_time_input_format` ayar](../../operations/settings/settings.md#settings-date_time_input_format) +- [Bu `timezone` sunucu yapılandırma parametresi](../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-timezone) +- [Tarih ve saatlerle çalışmak için operatörler](../../sql_reference/operators.md#operators-datetime) +- [Bu `Date` veri türü](date.md) + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/datetime/) diff --git a/docs/tr/sql_reference/data_types/datetime64.md b/docs/tr/sql_reference/data_types/datetime64.md new file mode 100644 index 00000000000..82839e174da --- /dev/null +++ b/docs/tr/sql_reference/data_types/datetime64.md @@ -0,0 +1,104 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 49 +toc_title: DateTime64 +--- + +# Datetime64 {#data_type-datetime64} + +Tanımlanmış alt saniye hassasiyetle, bir takvim tarihi ve bir günün saati olarak ifade edilebilir, zaman içinde bir anlık saklamak için izin verir + +Kene boyutu (hassas): 10-hassaslık ikincilikler + +Sözdizimi: + +``` sql +DateTime64(precision, [timezone]) +``` + +DAHİLİ olarak, verileri bir dizi olarak saklar ‘ticks’ epoch başlangıçtan beri (1970-01-01 00:00:00 UTC) Int64 olarak. Kene çözünürlüğü hassasiyet parametresi tarafından belirlenir. Ayrıca, `DateTime64` tür, tüm sütun için aynı olan saat dilimini depolayabilir, bu da `DateTime64` tür değerleri metin biçiminde görüntülenir ve dizeler olarak belirtilen değerlerin nasıl ayrıştırılır (‘2020-01-01 05:00:01.000’). Saat dilimi tablo (veya resultset) satırlarında depolanır, ancak sütun meta verileri depolanır. Ayrıntıları görün [DateTime](datetime.md). + +## Örnekler {#examples} + +**1.** İle bir tablo oluşturma `DateTime64`- sütun yazın ve içine veri ekleme: + +``` sql +CREATE TABLE dt +( + `timestamp` DateTime64(3, 'Europe/Moscow'), + `event_id` UInt8 +) +ENGINE = TinyLog +``` + +``` sql +INSERT INTO dt Values (1546300800000, 1), ('2019-01-01 00:00:00', 2) +``` + +``` sql +SELECT * FROM dt +``` + +``` text +┌───────────────timestamp─┬─event_id─┐ +│ 2019-01-01 03:00:00.000 │ 1 │ +│ 2019-01-01 00:00:00.000 │ 2 │ +└─────────────────────────┴──────────┘ +``` + +- Bir tamsayı olarak datetime eklerken, uygun şekilde ölçeklendirilmiş bir Unıx Zaman Damgası (UTC) olarak kabul edilir. `1546300800000` (hassas 3 ile) temsil eder `'2019-01-01 00:00:00'` UTC. Ancak, `timestamp` sütun vardır `Europe/Moscow` (UTC+3) belirtilen zaman dilimi, bir dize olarak çıkış yaparken değer olarak gösterilir `'2019-01-01 03:00:00'` +- Dize değerini datetime olarak eklerken, sütun saat diliminde olduğu kabul edilir. `'2019-01-01 00:00:00'` will gibi muamele `Europe/Moscow` saat dilimi ve olarak saklanır `1546290000000`. + +**2.** Üzerinde filtreleme `DateTime64` değerler + +``` sql +SELECT * FROM dt WHERE timestamp = toDateTime64('2019-01-01 00:00:00', 3, 'Europe/Moscow') +``` + +``` text +┌───────────────timestamp─┬─event_id─┐ +│ 2019-01-01 00:00:00.000 │ 2 │ +└─────────────────────────┴──────────┘ +``` + +Aksine `DateTime`, `DateTime64` değerler dönüştürülmez `String` otomatik olarak + +**3.** Bir saat dilimi almak `DateTime64`- tip değeri: + +``` sql +SELECT toDateTime64(now(), 3, 'Europe/Moscow') AS column, toTypeName(column) AS x +``` + +``` text +┌──────────────────column─┬─x──────────────────────────────┐ +│ 2019-10-16 04:12:04.000 │ DateTime64(3, 'Europe/Moscow') │ +└─────────────────────────┴────────────────────────────────┘ +``` + +**4.** Zaman dilimi dönüştürme + +``` sql +SELECT +toDateTime64(timestamp, 3, 'Europe/London') as lon_time, +toDateTime64(timestamp, 3, 'Europe/Moscow') as mos_time +FROM dt +``` + +``` text +┌───────────────lon_time──┬────────────────mos_time─┐ +│ 2019-01-01 00:00:00.000 │ 2019-01-01 03:00:00.000 │ +│ 2018-12-31 21:00:00.000 │ 2019-01-01 00:00:00.000 │ +└─────────────────────────┴─────────────────────────┘ +``` + +## Ayrıca Bakınız {#see-also} + +- [Tip dönüştürme fonksiyonları](../../sql_reference/functions/type_conversion_functions.md) +- [Tarih ve saatlerle çalışmak için işlevler](../../sql_reference/functions/date_time_functions.md) +- [Dizilerle çalışmak için işlevler](../../sql_reference/functions/array_functions.md) +- [Bu `date_time_input_format` ayar](../../operations/settings/settings.md#settings-date_time_input_format) +- [Bu `timezone` sunucu yapılandırma parametresi](../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-timezone) +- [Tarih ve saatlerle çalışmak için operatörler](../../sql_reference/operators.md#operators-datetime) +- [`Date` veri türü](date.md) +- [`DateTime` veri türü](datetime.md) diff --git a/docs/tr/sql_reference/data_types/decimal.md b/docs/tr/sql_reference/data_types/decimal.md new file mode 100644 index 00000000000..6ec15a52e12 --- /dev/null +++ b/docs/tr/sql_reference/data_types/decimal.md @@ -0,0 +1,109 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 42 +toc_title: "Ondal\u0131k" +--- + +# Ondalık(P, S), Decimal32 (S), Decimal64( S), Decimal128 (S) {#decimalp-s-decimal32s-decimal64s-decimal128s} + +Ekleme, çıkarma ve çarpma işlemleri sırasında hassasiyeti koruyan imzalı sabit noktalı sayılar. Bölünme için en az önemli basamak atılır (yuvarlatılmamış). + +## Parametre {#parameters} + +- P-hassas. Geçerli Aralık: \[1: 38 \]. Kaç ondalık basamak sayısı (kesir dahil) olabilir belirler. +- S-scale. Geçerli Aralık: \[0: P\]. Kaç ondalık basamak kesir olabilir belirler. + +P parametre değerine bağlı olarak ondalık (P, S) bir eşanlamlıdır: +- P \[ 1 : 9\] - Decimal32(S) için) +- P \[ 10 : 18\] - Decimal64(ler) için) +- P \[ 19 : 38\] - Decimal128(ler) için) + +## Ondalık değer aralıkları {#decimal-value-ranges} + +- Decimal32(S) - ( -1 \* 10^(9 - S), 1 \* 10^(9-S) ) +- Decimal64(S) - ( -1 \* 10^(18 - S), 1 \* 10^(18-S) ) +- Decimal128(S) - ( -1 \* 10^(38 - S), 1 \* 10^(38-S) ) + +Örneğin, Decimal32 (4) -99999.9999 99999.9999 0.0001 adım ile sayılar içerebilir. + +## İç temsil {#internal-representation} + +Dahili veri, ilgili bit genişliğine sahip normal imzalı tamsayılar olarak temsil edilir. Bellekte saklanabilen gerçek değer aralıkları, yukarıda belirtilenden biraz daha büyüktür ve yalnızca bir dizeden dönüştürmede kontrol edilir. + +Modern CPU 128-bit tamsayıları doğal olarak desteklemediğinden, Decimal128 üzerindeki işlemler öykünülür. Bu Decimal128 nedeniyle Decimal32/Decimal64'ten önemli ölçüde daha yavaş çalışır. + +## İşlemler ve sonuç türü {#operations-and-result-type} + +Ondalık sonuçtaki ikili işlemler daha geniş sonuç türünde (herhangi bir bağımsız değişken sırası ile) sonuçlanır. + +- Decimal64(S1) Decimal32 (S2) - \> Decimal64 (S) +- Decimal128(S1) Decimal32 (S2) - \> Decimal128(S) +- Decimal128(S1) Decimal64 (S2) - \> Decimal128(S) + +Ölçek kuralları: + +- ekleme, çıkarma: s = max (S1, S2). +- multuply: S = S1 + S2. +- böl: S = S1. + +Ondalık ve tamsayılar arasındaki benzer işlemler için sonuç, bir bağımsız değişkenle aynı boyutta ondalık olur. + +Ondalık ve Float32 / Float64 arasındaki işlemler tanımlanmamıştır. Bunlara ihtiyacınız varsa, todecimal32, toDecimal64, toDecimal128 veya toFloat32, toFloat64 builtins kullanarak bağımsız değişkenlerden birini açıkça yayınlayabilirsiniz. Sonucun hassasiyeti kaybedeceğini ve tür dönüşümünün hesaplamalı olarak pahalı bir işlem olduğunu unutmayın. + +Float64 (örneğin, var veya stddev) ondalık dönüş sonucu bazı işlevler. Ara hesaplamalar hala Float64 ve aynı değerlere sahip ondalık girişler arasında farklı sonuçlara yol açabilecek ondalık olarak gerçekleştirilebilir. + +## Taşma kontrolleri {#overflow-checks} + +Ondalık hesaplamalar sırasında tamsayı taşmaları gerçekleşebilir. Bir kesirdeki aşırı rakamlar atılır (yuvarlatılmamış). Tamsayı bölümünde aşırı basamak bir istisna yol açacaktır. + +``` sql +SELECT toDecimal32(2, 4) AS x, x / 3 +``` + +``` text +┌──────x─┬─divide(toDecimal32(2, 4), 3)─┐ +│ 2.0000 │ 0.6666 │ +└────────┴──────────────────────────────┘ +``` + +``` sql +SELECT toDecimal32(4.2, 8) AS x, x * x +``` + +``` text +DB::Exception: Scale is out of bounds. +``` + +``` sql +SELECT toDecimal32(4.2, 8) AS x, 6 * x +``` + +``` text +DB::Exception: Decimal math overflow. +``` + +Taşma kontrolleri operasyonların yavaşlamasına neden olur. Taşmaların mümkün olmadığı biliniyorsa, kontrolleri kullanarak devre dışı bırakmak mantıklıdır `decimal_check_overflow` ayar. Kontroller devre dışı bırakıldığında ve taşma gerçekleştiğinde, sonuç yanlış olacaktır: + +``` sql +SET decimal_check_overflow = 0; +SELECT toDecimal32(4.2, 8) AS x, 6 * x +``` + +``` text +┌──────────x─┬─multiply(6, toDecimal32(4.2, 8))─┐ +│ 4.20000000 │ -17.74967296 │ +└────────────┴──────────────────────────────────┘ +``` + +Taşma kontrolleri sadece aritmetik işlemlerde değil, değer karşılaştırmasında da gerçekleşir: + +``` sql +SELECT toDecimal32(1, 8) < 100 +``` + +``` text +DB::Exception: Can't compare. +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/decimal/) diff --git a/docs/tr/sql_reference/data_types/domains/index.md b/docs/tr/sql_reference/data_types/domains/index.md new file mode 100644 index 00000000000..e2632761647 --- /dev/null +++ b/docs/tr/sql_reference/data_types/domains/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: Etkiler +toc_priority: 56 +--- + + diff --git a/docs/tr/sql_reference/data_types/domains/ipv4.md b/docs/tr/sql_reference/data_types/domains/ipv4.md new file mode 100644 index 00000000000..51611ad97de --- /dev/null +++ b/docs/tr/sql_reference/data_types/domains/ipv4.md @@ -0,0 +1,84 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 59 +toc_title: Ipv44 +--- + +## Ipv44 {#ipv4} + +`IPv4` dayalı bir doma aindir `UInt32` tip ve IPv4 değerlerini depolamak için yazılan bir yedek olarak hizmet eder. İnsan dostu giriş-çıkış biçimi ve muayene ile ilgili sütun tipi bilgileri ile kompakt depolama sağlar. + +### Temel Kullanım {#basic-usage} + +``` sql +CREATE TABLE hits (url String, from IPv4) ENGINE = MergeTree() ORDER BY url; + +DESCRIBE TABLE hits; +``` + +``` text +┌─name─┬─type───┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┐ +│ url │ String │ │ │ │ │ +│ from │ IPv4 │ │ │ │ │ +└──────┴────────┴──────────────┴────────────────────┴─────────┴──────────────────┘ +``` + +Veya IPv4 etki alanını anahtar olarak kullanabilirsiniz: + +``` sql +CREATE TABLE hits (url String, from IPv4) ENGINE = MergeTree() ORDER BY from; +``` + +`IPv4` etki alanı IPv4 dizeleri olarak özel giriş biçimini destekler: + +``` sql +INSERT INTO hits (url, from) VALUES ('https://wikipedia.org', '116.253.40.133')('https://clickhouse.tech', '183.247.232.58')('https://clickhouse.yandex/docs/en/', '116.106.34.242'); + +SELECT * FROM hits; +``` + +``` text +┌─url────────────────────────────────┬───────────from─┐ +│ https://clickhouse.tech/docs/en/ │ 116.106.34.242 │ +│ https://wikipedia.org │ 116.253.40.133 │ +│ https://clickhouse.tech │ 183.247.232.58 │ +└────────────────────────────────────┴────────────────┘ +``` + +Değerler kompakt ikili formda saklanır: + +``` sql +SELECT toTypeName(from), hex(from) FROM hits LIMIT 1; +``` + +``` text +┌─toTypeName(from)─┬─hex(from)─┐ +│ IPv4 │ B7F7E83A │ +└──────────────────┴───────────┘ +``` + +Etki alanı değerleri örtülü olarak dışındaki türlere dönüştürülemez `UInt32`. +Dönüştürmek istiyorsanız `IPv4` bir dizeye değer, bunu açıkça yapmak zorundasınız `IPv4NumToString()` işlev: + +``` sql +SELECT toTypeName(s), IPv4NumToString(from) as s FROM hits LIMIT 1; +``` + + ┌─toTypeName(IPv4NumToString(from))─┬─s──────────────┐ + │ String │ 183.247.232.58 │ + └───────────────────────────────────┴────────────────┘ + +Ya da bir döküm `UInt32` değer: + +``` sql +SELECT toTypeName(i), CAST(from as UInt32) as i FROM hits LIMIT 1; +``` + +``` text +┌─toTypeName(CAST(from, 'UInt32'))─┬──────────i─┐ +│ UInt32 │ 3086477370 │ +└──────────────────────────────────┴────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/domains/ipv4) diff --git a/docs/tr/sql_reference/data_types/domains/ipv6.md b/docs/tr/sql_reference/data_types/domains/ipv6.md new file mode 100644 index 00000000000..71c9db90f9f --- /dev/null +++ b/docs/tr/sql_reference/data_types/domains/ipv6.md @@ -0,0 +1,86 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 60 +toc_title: IPv6 +--- + +## IPv6 {#ipv6} + +`IPv6` dayalı bir doma aindir `FixedString(16)` tip ve IPv6 değerlerini depolamak için yazılan bir yedek olarak hizmet eder. İnsan dostu giriş-çıkış biçimi ve muayene ile ilgili sütun tipi bilgileri ile kompakt depolama sağlar. + +### Temel Kullanım {#basic-usage} + +``` sql +CREATE TABLE hits (url String, from IPv6) ENGINE = MergeTree() ORDER BY url; + +DESCRIBE TABLE hits; +``` + +``` text +┌─name─┬─type───┬─default_type─┬─default_expression─┬─comment─┬─codec_expression─┐ +│ url │ String │ │ │ │ │ +│ from │ IPv6 │ │ │ │ │ +└──────┴────────┴──────────────┴────────────────────┴─────────┴──────────────────┘ +``` + +Veya kullanabilirsiniz `IPv6` anahtar olarak etki alanı: + +``` sql +CREATE TABLE hits (url String, from IPv6) ENGINE = MergeTree() ORDER BY from; +``` + +`IPv6` etki alanı IPv6 dizeleri olarak özel girişi destekler: + +``` sql +INSERT INTO hits (url, from) VALUES ('https://wikipedia.org', '2a02:aa08:e000:3100::2')('https://clickhouse.tech', '2001:44c8:129:2632:33:0:252:2')('https://clickhouse.yandex/docs/en/', '2a02:e980:1e::1'); + +SELECT * FROM hits; +``` + +``` text +┌─url────────────────────────────────┬─from──────────────────────────┐ +│ https://clickhouse.tech │ 2001:44c8:129:2632:33:0:252:2 │ +│ https://clickhouse.tech/docs/en/ │ 2a02:e980:1e::1 │ +│ https://wikipedia.org │ 2a02:aa08:e000:3100::2 │ +└────────────────────────────────────┴───────────────────────────────┘ +``` + +Değerler kompakt ikili formda saklanır: + +``` sql +SELECT toTypeName(from), hex(from) FROM hits LIMIT 1; +``` + +``` text +┌─toTypeName(from)─┬─hex(from)────────────────────────┐ +│ IPv6 │ 200144C8012926320033000002520002 │ +└──────────────────┴──────────────────────────────────┘ +``` + +Etki alanı değerleri örtülü olarak dışındaki türlere dönüştürülemez `FixedString(16)`. +Dönüştürmek istiyorsanız `IPv6` bir dizeye değer, bunu açıkça yapmak zorundasınız `IPv6NumToString()` işlev: + +``` sql +SELECT toTypeName(s), IPv6NumToString(from) as s FROM hits LIMIT 1; +``` + +``` text +┌─toTypeName(IPv6NumToString(from))─┬─s─────────────────────────────┐ +│ String │ 2001:44c8:129:2632:33:0:252:2 │ +└───────────────────────────────────┴───────────────────────────────┘ +``` + +Ya da bir döküm `FixedString(16)` değer: + +``` sql +SELECT toTypeName(i), CAST(from as FixedString(16)) as i FROM hits LIMIT 1; +``` + +``` text +┌─toTypeName(CAST(from, 'FixedString(16)'))─┬─i───────┐ +│ FixedString(16) │ ��� │ +└───────────────────────────────────────────┴─────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/domains/ipv6) diff --git a/docs/tr/sql_reference/data_types/domains/overview.md b/docs/tr/sql_reference/data_types/domains/overview.md new file mode 100644 index 00000000000..97e3ef5018a --- /dev/null +++ b/docs/tr/sql_reference/data_types/domains/overview.md @@ -0,0 +1,32 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 58 +toc_title: "Genel bak\u0131\u015F" +--- + +# Etkiler {#domains} + +Etki alanları, varolan temel türün üstüne bazı ek özellikler ekleyen, ancak temel veri türünün kablolu ve disk üstü biçimini sağlam bırakan özel amaçlı türlerdir. Şu anda, ClickHouse kullanıcı tanımlı etki alanlarını desteklemiyor. + +Örneğin, ilgili taban türünün kullanılabileceği her yerde etki alanlarını kullanabilirsiniz: + +- Etki alanı türünde bir sütun oluşturma +- Alan sütunundan/alanına değerleri okuma / yazma +- Bir temel türü bir dizin olarak kullanılabilir, bir dizin olarak kullanın +- Etki alanı sütun değerleri ile çağrı fonksiyonları + +### Alanların ekstra özellikleri {#extra-features-of-domains} + +- Açık sütun türü adı `SHOW CREATE TABLE` veya `DESCRIBE TABLE` +- İle insan dostu format inputtan giriş `INSERT INTO domain_table(domain_column) VALUES(...)` +- İçin insan dostu forma outputta çıktı `SELECT domain_column FROM domain_table` +- Harici bir kaynaktan insan dostu biçimde veri yükleme: `INSERT INTO domain_table FORMAT CSV ...` + +### Sınırlamalar {#limitations} + +- Temel türün dizin sütununu etki alanı türüne dönüştürülemiyor `ALTER TABLE`. +- Başka bir sütun veya tablodan veri eklerken dize değerlerini dolaylı olarak etki alanı değerlerine dönüştüremez. +- Etki alanı, depolanan değerler üzerinde hiçbir kısıtlama ekler. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/domains/overview) diff --git a/docs/tr/sql_reference/data_types/enum.md b/docs/tr/sql_reference/data_types/enum.md new file mode 100644 index 00000000000..65c687835dc --- /dev/null +++ b/docs/tr/sql_reference/data_types/enum.md @@ -0,0 +1,132 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 50 +toc_title: Enum +--- + +# Enum {#enum} + +Adlandırılmış değerlerden oluşan numaralandırılmış tür. + +Adlandırılmış değerler olarak bildirilmelidir `'string' = integer` çiftliler. ClickHouse yalnızca sayıları saklar, ancak adları aracılığıyla değerlerle işlemleri destekler. + +ClickHouse destekler: + +- 8-bit `Enum`. En fazla 256 değerleri numaralandırılmış içerebilir `[-128, 127]` Aralık. +- 16-bit `Enum`. En fazla 65536 değerleri numaralandırılmış içerebilir `[-32768, 32767]` Aralık. + +ClickHouse otomatik olarak türünü seçer `Enum` veri eklendiğinde. Ayrıca kullanabilirsiniz `Enum8` veya `Enum16` türleri depolama boyutunda emin olmak için. + +## Kullanım Örnekleri {#usage-examples} + +Burada bir tablo oluşturuyoruz `Enum8('hello' = 1, 'world' = 2)` type Col columnum columnn: + +``` sql +CREATE TABLE t_enum +( + x Enum('hello' = 1, 'world' = 2) +) +ENGINE = TinyLog +``` + +Sütun `x` yalnızca tür tanımında listelenen değerleri depolayabilir: `'hello'` veya `'world'`. Başka bir değer kaydetmeye çalışırsanız, ClickHouse bir özel durum yükseltir. Bunun için 8-bit boyutu `Enum` otomatik olarak seçilir. + +``` sql +INSERT INTO t_enum VALUES ('hello'), ('world'), ('hello') +``` + +``` text +Ok. +``` + +``` sql +INSERT INTO t_enum values('a') +``` + +``` text +Exception on client: +Code: 49. DB::Exception: Unknown element 'a' for type Enum('hello' = 1, 'world' = 2) +``` + +Tablodan veri sorguladığınızda, ClickHouse dize değerleri `Enum`. + +``` sql +SELECT * FROM t_enum +``` + +``` text +┌─x─────┐ +│ hello │ +│ world │ +│ hello │ +└───────┘ +``` + +Satırların sayısal eşdeğerlerini görmeniz gerekiyorsa, `Enum` tamsayı türüne değer. + +``` sql +SELECT CAST(x, 'Int8') FROM t_enum +``` + +``` text +┌─CAST(x, 'Int8')─┐ +│ 1 │ +│ 2 │ +│ 1 │ +└─────────────────┘ +``` + +Bir sorguda bir Enum değeri oluşturmak için, ayrıca kullanmanız gerekir `CAST`. + +``` sql +SELECT toTypeName(CAST('a', 'Enum(\'a\' = 1, \'b\' = 2)')) +``` + +``` text +┌─toTypeName(CAST('a', 'Enum(\'a\' = 1, \'b\' = 2)'))─┐ +│ Enum8('a' = 1, 'b' = 2) │ +└─────────────────────────────────────────────────────┘ +``` + +## Genel Kurallar ve kullanım {#general-rules-and-usage} + +Değerlerin her birine aralıkta bir sayı atanır `-128 ... 127` için `Enum8` veya aralık inta `-32768 ... 32767` için `Enum16`. Tüm dizeler ve sayılar farklı olmalıdır. Boş bir dize izin verilir. Bu tür belirtilmişse (bir tablo tanımında), sayılar rasgele bir sırada olabilir. Ancak, sipariş önemli değil. + +Ne dize ne de sayısal değer bir `Enum` olabilir [NULL](../../sql_reference/syntax.md). + +Bir `Enum` içerdiği olabilir [Nullable](nullable.md) tür. Yani sorguyu kullanarak bir tablo oluşturursanız + +``` sql +CREATE TABLE t_enum_nullable +( + x Nullable( Enum8('hello' = 1, 'world' = 2) ) +) +ENGINE = TinyLog +``` + +bu mağaza değil sadece `'hello'` ve `'world'`, ama `NULL`, yanında. + +``` sql +INSERT INTO t_enum_nullable Values('hello'),('world'),(NULL) +``` + +RAM, bir `Enum` sütun aynı şekilde saklanır `Int8` veya `Int16` karşılık gelen sayısal değerlerin. + +Metin formunda okurken, ClickHouse değeri bir dize olarak ayrıştırır ve karşılık gelen dizeyi Enum değerleri kümesinden arar. Bulunmazsa, bir istisna atılır. Metin biçiminde okurken, dize okunur ve karşılık gelen sayısal değer aranır. Bulunmazsa bir istisna atılır. +Metin formunda yazarken, değeri karşılık gelen dize olarak yazar. Sütun verileri çöp içeriyorsa (geçerli kümeden olmayan sayılar), bir özel durum atılır. İkili formda okurken ve yazarken, Int8 ve Int16 veri türleri ile aynı şekilde çalışır. +Örtülü varsayılan değer, en düşük sayıya sahip değerdir. + +Sırasında `ORDER BY`, `GROUP BY`, `IN`, `DISTINCT` ve böylece, Enumlar karşılık gelen sayılarla aynı şekilde davranır. Örneğin, sipariş onları sayısal olarak sıralar. Eşitlik ve karşılaştırma işleçleri, alttaki sayısal değerler üzerinde yaptıkları gibi Enumlarda aynı şekilde çalışır. + +Enum değerleri sayılarla karşılaştırılamaz. Enums sabit bir dize ile karşılaştırılabilir. Karşılaştırılan dize Enum için geçerli bir değer değilse, bir özel durum atılır. IN operatörü, sol taraftaki Enum ve sağ taraftaki bir dizi dizeyle desteklenir. Dizeler, karşılık gelen Enumun değerleridir. + +Most numeric and string operations are not defined for Enum values, e.g. adding a number to an Enum or concatenating a string to an Enum. +Ancak, Enum doğal bir `toString` dize değerini döndüren işlev. + +Enum değerleri de kullanarak sayısal türlere dönüştürülebilir `toT` fonksiyon, burada t sayısal bir türdür. T enum'un temel sayısal türüne karşılık geldiğinde, bu dönüşüm sıfır maliyetlidir. +Enum türü, yalnızca değer kümesi değiştirilirse, alter kullanılarak maliyet olmadan değiştirilebilir. Her iki ekleme ve Alter kullanarak Enum üyeleri kaldırmak mümkündür (kaldırma yalnızca kaldırılan değer tabloda hiç kullanılmadıysa güvenlidir). Bir koruma olarak, önceden tanımlanmış bir Enum üyesinin sayısal değerini değiştirmek bir istisna atar. + +ALTER kullanarak, bir Enum8 için bir Enum16 veya tam tersi, Int8 için Int16 değiştirme gibi değiştirmek mümkündür. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/enum/) diff --git a/docs/tr/sql_reference/data_types/fixedstring.md b/docs/tr/sql_reference/data_types/fixedstring.md new file mode 100644 index 00000000000..bf716f4d591 --- /dev/null +++ b/docs/tr/sql_reference/data_types/fixedstring.md @@ -0,0 +1,63 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 45 +toc_title: FixedString(N) +--- + +# Fixedstring {#fixedstring} + +Sabit uzunlukta bir dize `N` bayt (ne karakter ne de kod noktaları). + +Bir sütun bildirmek için `FixedString` yazın, aşağıdaki sözdizimini kullanın: + +``` sql + FixedString(N) +``` + +Nerede `N` doğal bir sayıdır. + +Bu `FixedString` veri tam olarak uzunluğa sahip olduğunda tür etkilidir `N` baytlar. Diğer tüm durumlarda, verimliliği düşürmesi muhtemeldir. + +Verimli bir şekilde depolan theabilen değerlere örnekler `FixedString`- yazılan sütunlar: + +- IP adreslerinin ikili gösterimi (`FixedString(16)` IPv6 için). +- Language codes (ru\_RU, en\_US … ). +- Currency codes (USD, RUB … ). +- Karma ikili gösterimi (`FixedString(16)` MD5 için, `FixedString(32)` SHA256 için). + +UUID değerlerini depolamak için [UUID](uuid.md) veri türü. + +Verileri eklerken, ClickHouse: + +- Dize daha az içeriyorsa, boş bayt ile bir dize tamamlar `N` baytlar. +- Atar `Too large value for FixedString(N)` dize birden fazla içeriyorsa, özel durum `N` baytlar. + +Verileri seçerken, ClickHouse dize sonunda boş bayt kaldırmaz. Eğer kullanıyorsanız `WHERE` yan tümcesi, null bayt el ile eşleştirmek için eklemelisiniz `FixedString` değer. Kullanımı için aşağıdaki örnek, nasıl gösterir `WHERE` fık withra ile `FixedString`. + +Aşağıdaki tabloyu tek ile düşünelim `FixedString(2)` sütun: + +``` text +┌─name──┐ +│ b │ +└───────┘ +``` + +Sorgu `SELECT * FROM FixedStringTable WHERE a = 'b'` sonuç olarak herhangi bir veri döndürmez. Filtre desenini boş baytlarla tamamlamalıyız. + +``` sql +SELECT * FROM FixedStringTable +WHERE a = 'b\0' +``` + +``` text +┌─a─┐ +│ b │ +└───┘ +``` + +Bu davranış için MySQL farklıdır `CHAR` tür (burada dizeler boşluklarla doldurulur ve boşluklar çıktı için kaldırılır). + +Not uzunluğu `FixedString(N)` değer sabittir. Bu [uzunluk](../../sql_reference/functions/array_functions.md#array_functions-length) fonksiyon döndürür `N` hatta eğer `FixedString(N)` değer yalnızca boş baytlarla doldurulur, ancak [boş](../../sql_reference/functions/string_functions.md#empty) fonksiyon döndürür `1` bu durumda. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/fixedstring/) diff --git a/docs/tr/sql_reference/data_types/float.md b/docs/tr/sql_reference/data_types/float.md new file mode 100644 index 00000000000..0b5bd76be86 --- /dev/null +++ b/docs/tr/sql_reference/data_types/float.md @@ -0,0 +1,87 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 41 +toc_title: Float32, Float64 +--- + +# Float32, Float64 {#float32-float64} + +[Kayan nokta numaraları](https://en.wikipedia.org/wiki/IEEE_754). + +Türleri C türlerine eşdeğerdir: + +- `Float32` - `float` +- `Float64` - `double` + +Verileri mümkün olduğunda tamsayı biçiminde saklamanızı öneririz. Örneğin, sabit hassas sayıları parasal tutarlar veya sayfa yükleme süreleri gibi milisaniye cinsinden tamsayı değerlerine dönüştürün. + +## Kayan noktalı sayıları kullanma {#using-floating-point-numbers} + +- Kayan noktalı sayılarla yapılan hesaplamalar yuvarlama hatası oluşturabilir. + + + +``` sql +SELECT 1 - 0.9 +``` + +``` text +┌───────minus(1, 0.9)─┐ +│ 0.09999999999999998 │ +└─────────────────────┘ +``` + +- Hesaplamanın sonucu hesaplama yöntemine (bilgisayar sisteminin işlemci tipi ve mimarisi) bağlıdır. +- Kayan nokta hesaplamaları, sonsuzluk gibi sayılarla sonuçlanabilir (`Inf`) ve “not-a-number” (`NaN`). Hesaplamaların sonuçlarını işlerken bu dikkate alınmalıdır. +- Kayan noktalı sayıları metinden ayrıştırırken, sonuç en yakın makine tarafından temsil edilebilir sayı olmayabilir. + +## N andan ve In andf {#data_type-float-nan-inf} + +Standart SQL aksine, ClickHouse kayan noktalı sayılar aşağıdaki kategorileri destekler: + +- `Inf` – Infinity. + + + +``` sql +SELECT 0.5 / 0 +``` + +``` text +┌─divide(0.5, 0)─┐ +│ inf │ +└────────────────┘ +``` + +- `-Inf` – Negative infinity. + + + +``` sql +SELECT -0.5 / 0 +``` + +``` text +┌─divide(-0.5, 0)─┐ +│ -inf │ +└─────────────────┘ +``` + +- `NaN` – Not a number. + + + +``` sql +SELECT 0 / 0 +``` + +``` text +┌─divide(0, 0)─┐ +│ nan │ +└──────────────┘ +``` + + See the rules for `NaN` sorting in the section [ORDER BY clause](../sql_reference/statements/select.md). + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/float/) diff --git a/docs/tr/sql_reference/data_types/index.md b/docs/tr/sql_reference/data_types/index.md new file mode 100644 index 00000000000..c2fdda0c8e8 --- /dev/null +++ b/docs/tr/sql_reference/data_types/index.md @@ -0,0 +1,15 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "Veri T\xFCrleri" +toc_priority: 37 +toc_title: "Giri\u015F" +--- + +# Veri Türleri {#data_types} + +ClickHouse tablo hücrelerinde veri çeşitli saklayabilirsiniz. + +Bu bölümde desteklenen veri türleri ve varsa bunları kullanmak ve/veya uygulamak için özel hususlar açıklanmaktadır. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/) diff --git a/docs/tr/sql_reference/data_types/int_uint.md b/docs/tr/sql_reference/data_types/int_uint.md new file mode 100644 index 00000000000..2c7b47eb4c6 --- /dev/null +++ b/docs/tr/sql_reference/data_types/int_uint.md @@ -0,0 +1,26 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 40 +toc_title: "U\u0130nt8, U\u0130nt16, U\u0130nt32, Uint64, Int8, Int16, Int32, Int64" +--- + +# Uİnt8, Uİnt16, Uİnt32, Uint64, Int8, Int16, Int32, Int64 {#uint8-uint16-uint32-uint64-int8-int16-int32-int64} + +Sabit uzunlukta tamsayılar, veya bir işareti olmadan. + +## İnt Aralıkları {#int-ranges} + +- Int8- \[-128: 127\] +- Int16 - \[-32768: 32767\] +- Int32 - \[-2147483648: 2147483647\] +- Int64 - \[-9223372036854775808: 9223372036854775807\] + +## Uint Aralıkları {#uint-ranges} + +- Uİnt8- \[0: 255\] +- Uİnt16- \[0: 65535\] +- Uİnt32- \[0: 4294967295\] +- Uİnt64 - \[0: 18446744073709551615\] + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/int_uint/) diff --git a/docs/tr/sql_reference/data_types/nested_data_structures/index.md b/docs/tr/sql_reference/data_types/nested_data_structures/index.md new file mode 100644 index 00000000000..53a998fa8a8 --- /dev/null +++ b/docs/tr/sql_reference/data_types/nested_data_structures/index.md @@ -0,0 +1,12 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "\u0130\xE7 \u0130\xE7e Veri Yap\u0131lar\u0131" +toc_hidden: true +toc_priority: 54 +toc_title: "gizlenmi\u015F" +--- + +# İç İçe Veri Yapıları {#nested-data-structures} + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/nested_data_structures/) diff --git a/docs/tr/sql_reference/data_types/nested_data_structures/nested.md b/docs/tr/sql_reference/data_types/nested_data_structures/nested.md new file mode 100644 index 00000000000..8cd2dc3a558 --- /dev/null +++ b/docs/tr/sql_reference/data_types/nested_data_structures/nested.md @@ -0,0 +1,106 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 57 +toc_title: "\u0130\xE7 \u0130\xE7e (Name1 Type1, Name2 Type2,...)" +--- + +# Nested(name1 Type1, Name2 Type2, …) {#nestedname1-type1-name2-type2} + +A nested data structure is like a table inside a cell. The parameters of a nested data structure – the column names and types – are specified the same way as in a [CREATE TABLE](../../../sql_reference/statements/create.md) sorgu. Her tablo satırı, iç içe geçmiş veri yapısındaki herhangi bir sayıda satıra karşılık gelebilir. + +Örnek: + +``` sql +CREATE TABLE test.visits +( + CounterID UInt32, + StartDate Date, + Sign Int8, + IsNew UInt8, + VisitID UInt64, + UserID UInt64, + ... + Goals Nested + ( + ID UInt32, + Serial UInt32, + EventTime DateTime, + Price Int64, + OrderID String, + CurrencyID UInt32 + ), + ... +) ENGINE = CollapsingMergeTree(StartDate, intHash32(UserID), (CounterID, StartDate, intHash32(UserID), VisitID), 8192, Sign) +``` + +Bu örnek bildirir `Goals` dönüşümlerle ilgili verileri içeren iç içe veri yapısı (ulaşılan hedefler). Her satır içinde ‘visits’ tablo sıfır veya dönüşüm herhangi bir sayıda karşılık gelebilir. + +Sadece tek bir yuvalama seviyesi desteklenir. Diziler içeren iç içe geçmiş yapıların sütunları çok boyutlu dizilere eşdeğerdir, bu nedenle sınırlı desteğe sahiptirler (bu sütunları MergeTree altyapısı ile tablolarda depolamak için destek yoktur). + +Çoğu durumda, iç içe geçmiş bir veri yapısıyla çalışırken, sütunları bir nokta ile ayrılmış sütun adlarıyla belirtilir. Bu sütunlar eşleşen türleri bir dizi oluşturur. Tek bir iç içe geçmiş veri yapısının tüm sütun dizileri aynı uzunluğa sahiptir. + +Örnek: + +``` sql +SELECT + Goals.ID, + Goals.EventTime +FROM test.visits +WHERE CounterID = 101500 AND length(Goals.ID) < 5 +LIMIT 10 +``` + +``` text +┌─Goals.ID───────────────────────┬─Goals.EventTime───────────────────────────────────────────────────────────────────────────┐ +│ [1073752,591325,591325] │ ['2014-03-17 16:38:10','2014-03-17 16:38:48','2014-03-17 16:42:27'] │ +│ [1073752] │ ['2014-03-17 00:28:25'] │ +│ [1073752] │ ['2014-03-17 10:46:20'] │ +│ [1073752,591325,591325,591325] │ ['2014-03-17 13:59:20','2014-03-17 22:17:55','2014-03-17 22:18:07','2014-03-17 22:18:51'] │ +│ [] │ [] │ +│ [1073752,591325,591325] │ ['2014-03-17 11:37:06','2014-03-17 14:07:47','2014-03-17 14:36:21'] │ +│ [] │ [] │ +│ [] │ [] │ +│ [591325,1073752] │ ['2014-03-17 00:46:05','2014-03-17 00:46:05'] │ +│ [1073752,591325,591325,591325] │ ['2014-03-17 13:28:33','2014-03-17 13:30:26','2014-03-17 18:51:21','2014-03-17 18:51:45'] │ +└────────────────────────────────┴───────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +İç içe geçmiş bir veri yapısını aynı uzunlukta birden çok sütun dizisi kümesi olarak düşünmek en kolay yoldur. + +Bir SELECT sorgusunun tek tek sütunlar yerine tüm iç içe geçmiş veri yapısının adını belirtebileceği tek yer array JOIN yan tümcesi. Daha fazla bilgi için, bkz. “ARRAY JOIN clause”. Örnek: + +``` sql +SELECT + Goal.ID, + Goal.EventTime +FROM test.visits +ARRAY JOIN Goals AS Goal +WHERE CounterID = 101500 AND length(Goals.ID) < 5 +LIMIT 10 +``` + +``` text +┌─Goal.ID─┬──────Goal.EventTime─┐ +│ 1073752 │ 2014-03-17 16:38:10 │ +│ 591325 │ 2014-03-17 16:38:48 │ +│ 591325 │ 2014-03-17 16:42:27 │ +│ 1073752 │ 2014-03-17 00:28:25 │ +│ 1073752 │ 2014-03-17 10:46:20 │ +│ 1073752 │ 2014-03-17 13:59:20 │ +│ 591325 │ 2014-03-17 22:17:55 │ +│ 591325 │ 2014-03-17 22:18:07 │ +│ 591325 │ 2014-03-17 22:18:51 │ +│ 1073752 │ 2014-03-17 11:37:06 │ +└─────────┴─────────────────────┘ +``` + +İç içe geçmiş veri yapısının tamamı için SELECT gerçekleştiremezsiniz. Yalnızca bir parçası olan tek tek sütunları açıkça listeleyebilirsiniz. + +Bir INSERT sorgusu için, iç içe geçmiş bir veri yapısının tüm bileşen sütun dizilerini ayrı ayrı (tek tek sütun dizileri gibi) iletmelisiniz. Ekleme sırasında, sistem aynı uzunluğa sahip olduklarını kontrol eder. + +Bir tanımlama sorgusu için, iç içe geçmiş bir veri yapısındaki sütunlar aynı şekilde ayrı olarak listelenir. + +İç içe geçmiş bir veri yapısındaki öğeler için ALTER sorgusu sınırlamaları vardır. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/nested_data_structures/nested/) diff --git a/docs/tr/sql_reference/data_types/nullable.md b/docs/tr/sql_reference/data_types/nullable.md new file mode 100644 index 00000000000..1950e2b1b77 --- /dev/null +++ b/docs/tr/sql_reference/data_types/nullable.md @@ -0,0 +1,46 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 54 +toc_title: Nullable +--- + +# Nullable (typename) {#data_type-nullable} + +Özel işaretleyici saklamak için izin verir ([NULL](../../sql_reference/syntax.md)) bu ifade eder “missing value” tarafından izin verilen normal değerlerin yanında `TypeName`. Örneğin, bir `Nullable(Int8)` tipi sütun saklayabilirsiniz `Int8` değerleri yazın ve değeri olmayan satırlar depolayacaktır `NULL`. + +İçin... `TypeName`, bileşik veri türlerini kullanamazsınız [Dizi](array.md) ve [Demet](tuple.md). Bileşik veri türleri şunları içerebilir `Nullable` gibi tür değerleri `Array(Nullable(Int8))`. + +A `Nullable` tür alanı tablo dizinlerine dahil edilemez. + +`NULL` herhangi biri için varsayılan değer mi `Nullable` ClickHouse sunucu yapılandırmasında aksi belirtilmediği sürece yazın. + +## Depolama Özellikleri {#storage-features} + +İçermek `Nullable` bir tablo sütunundaki değerleri yazın, ClickHouse ile ayrı bir dosya kullanır `NULL` değerleri ile normal dosyaya ek olarak Maskeler. Maskeli girişleri ClickHouse ayırt izin dosyası `NULL` ve her tablo satırı için karşılık gelen veri türünün varsayılan değeri. Ek bir dosya nedeniyle, `Nullable` sütun, benzer bir normal olana kıyasla ek depolama alanı tüketir. + +!!! info "Not" + Kullanım `Nullable` neredeyse her zaman performansı olumsuz etkiler, veritabanlarınızı tasarlarken bunu aklınızda bulundurun. + +## Kullanım Örneği {#usage-example} + +``` sql +CREATE TABLE t_null(x Int8, y Nullable(Int8)) ENGINE TinyLog +``` + +``` sql +INSERT INTO t_null VALUES (1, NULL), (2, 3) +``` + +``` sql +SELECT x + y FROM t_null +``` + +``` text +┌─plus(x, y)─┐ +│ ᴺᵁᴸᴸ │ +│ 5 │ +└────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/nullable/) diff --git a/docs/tr/sql_reference/data_types/special_data_types/expression.md b/docs/tr/sql_reference/data_types/special_data_types/expression.md new file mode 100644 index 00000000000..a098b0c6365 --- /dev/null +++ b/docs/tr/sql_reference/data_types/special_data_types/expression.md @@ -0,0 +1,12 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 58 +toc_title: "\u0130fade" +--- + +# İfade {#expression} + +İfadeler, lambda'ları yüksek mertebeden işlevlerde temsil etmek için kullanılır. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/special_data_types/expression/) diff --git a/docs/tr/sql_reference/data_types/special_data_types/index.md b/docs/tr/sql_reference/data_types/special_data_types/index.md new file mode 100644 index 00000000000..700bf57784b --- /dev/null +++ b/docs/tr/sql_reference/data_types/special_data_types/index.md @@ -0,0 +1,14 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "\xD6zel Veri T\xFCrleri" +toc_hidden: true +toc_priority: 55 +toc_title: "gizlenmi\u015F" +--- + +# Özel Veri Türleri {#special-data-types} + +Özel veri türü değerleri Tablo veya çıktı sorgu sonuçlarında kaydetmek için seri hale getirilemez, ancak sorgu yürütme sırasında bir ara sonuç olarak kullanılabilir. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/special_data_types/) diff --git a/docs/tr/sql_reference/data_types/special_data_types/interval.md b/docs/tr/sql_reference/data_types/special_data_types/interval.md new file mode 100644 index 00000000000..e95f5a98cfd --- /dev/null +++ b/docs/tr/sql_reference/data_types/special_data_types/interval.md @@ -0,0 +1,85 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 61 +toc_title: "Aral\u0131kl\u0131" +--- + +# Aralıklı {#data-type-interval} + +Zaman ve Tarih aralıklarını temsil eden veri türleri ailesi. Ortaya çıkan türleri [INTERVAL](../../../sql_reference/operators.md#operator-interval) operatör. + +!!! warning "Uyarıcı" + `Interval` veri türü değerleri tablolarda saklanamaz. + +Yapılı: + +- İmzasız bir tamsayı değeri olarak zaman aralığı. +- Bir aralık türü. + +Desteklenen Aralık türleri: + +- `SECOND` +- `MINUTE` +- `HOUR` +- `DAY` +- `WEEK` +- `MONTH` +- `QUARTER` +- `YEAR` + +Her Aralık türü için ayrı bir veri türü vardır. Örneğin, `DAY` Aralık karşılık gelir `IntervalDay` veri türü: + +``` sql +SELECT toTypeName(INTERVAL 4 DAY) +``` + +``` text +┌─toTypeName(toIntervalDay(4))─┐ +│ IntervalDay │ +└──────────────────────────────┘ +``` + +## Kullanım Açıklamaları {#data-type-interval-usage-remarks} + +Kullanabilirsiniz `Interval`- aritmetik işlemlerde değerler yazın [Tarihli](../../../sql_reference/data_types/date.md) ve [DateTime](../../../sql_reference/data_types/datetime.md)- tip değerleri. Örneğin, geçerli saate 4 gün ekleyebilirsiniz: + +``` sql +SELECT now() as current_date_time, current_date_time + INTERVAL 4 DAY +``` + +``` text +┌───current_date_time─┬─plus(now(), toIntervalDay(4))─┐ +│ 2019-10-23 10:58:45 │ 2019-10-27 10:58:45 │ +└─────────────────────┴───────────────────────────────┘ +``` + +Farklı tiplere sahip aralıklar birleştirilemez. Gibi aralıklarla kullanamazsınız `4 DAY 1 HOUR`. Aralıkların, örneğin aralığın en küçük birimine eşit veya daha küçük olan birimlerdeki aralıkları belirtin `1 day and an hour` aralık olarak ifade edilebilir `25 HOUR` veya `90000 SECOND`. + +İle aritmetik işlemler yapamazsınız `Interval`- değerleri yazın, ancak farklı türde aralıklar ekleyebilirsiniz. `Date` veya `DateTime` veri türleri. Mesela: + +``` sql +SELECT now() AS current_date_time, current_date_time + INTERVAL 4 DAY + INTERVAL 3 HOUR +``` + +``` text +┌───current_date_time─┬─plus(plus(now(), toIntervalDay(4)), toIntervalHour(3))─┐ +│ 2019-10-23 11:16:28 │ 2019-10-27 14:16:28 │ +└─────────────────────┴────────────────────────────────────────────────────────┘ +``` + +Aşağıdaki sorgu bir özel duruma neden olur: + +``` sql +select now() AS current_date_time, current_date_time + (INTERVAL 4 DAY + INTERVAL 3 HOUR) +``` + +``` text +Received exception from server (version 19.14.1): +Code: 43. DB::Exception: Received from localhost:9000. DB::Exception: Wrong argument types for function plus: if one argument is Interval, then another must be Date or DateTime.. +``` + +## Ayrıca Bakınız {#see-also} + +- [INTERVAL](../../../sql_reference/operators.md#operator-interval) operatör +- [toİnterval](../../../sql_reference/functions/type_conversion_functions.md#function-tointerval) tip dönüştürme işlevleri diff --git a/docs/tr/sql_reference/data_types/special_data_types/nothing.md b/docs/tr/sql_reference/data_types/special_data_types/nothing.md new file mode 100644 index 00000000000..046c36ab047 --- /dev/null +++ b/docs/tr/sql_reference/data_types/special_data_types/nothing.md @@ -0,0 +1,26 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 60 +toc_title: "Hi\xE7bir \u015Fey" +--- + +# Hiçbir şey {#nothing} + +Bu veri türünün tek amacı, bir değerin beklenmediği durumları temsil etmektir. Yani bir oluşturamazsınız `Nothing` type value. + +Örneğin, literal [NULL](../../../sql_reference/syntax.md#null-literal) türü vardır `Nullable(Nothing)`. Daha fazla görmek [Nullable](../../../sql_reference/data_types/nullable.md). + +Bu `Nothing` tür boş dizileri belirtmek için de kullanılabilir: + +``` sql +SELECT toTypeName(array()) +``` + +``` text +┌─toTypeName(array())─┐ +│ Array(Nothing) │ +└─────────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/special_data_types/nothing/) diff --git a/docs/tr/sql_reference/data_types/special_data_types/set.md b/docs/tr/sql_reference/data_types/special_data_types/set.md new file mode 100644 index 00000000000..f12fac0e56f --- /dev/null +++ b/docs/tr/sql_reference/data_types/special_data_types/set.md @@ -0,0 +1,12 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 59 +toc_title: Koymak +--- + +# Koymak {#set} + +Sağ yarısı için kullanılan bir [IN](../../../sql_reference/statements/select.md#select-in-operators) ifade. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/special_data_types/set/) diff --git a/docs/tr/sql_reference/data_types/string.md b/docs/tr/sql_reference/data_types/string.md new file mode 100644 index 00000000000..0b7c5918dc7 --- /dev/null +++ b/docs/tr/sql_reference/data_types/string.md @@ -0,0 +1,20 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 44 +toc_title: Dize +--- + +# Dize {#string} + +Keyfi uzunlukta dizeler. Uzunluk sınırlı değildir. Değer, boş bayt da dahil olmak üzere rasgele bir bayt kümesi içerebilir. +Dize türü türleri değiştirir VARCHAR, BLOB, CLOB, ve diğerleri diğer DBMSs. + +## Kodlamalar {#encodings} + +ClickHouse kodlama kavramına sahip değildir. Dizeler, depolanan ve olduğu gibi çıkan rasgele bir bayt kümesi içerebilir. +Metinleri saklamanız gerekiyorsa, UTF-8 kodlamasını kullanmanızı öneririz. En azından, terminaliniz UTF-8 kullanıyorsa (önerildiği gibi), dönüşüm yapmadan değerlerinizi okuyabilir ve yazabilirsiniz. +Benzer şekilde, dizelerle çalışmak için belirli işlevler, dizenin UTF-8 kodlu bir metni temsil eden bir bayt kümesi içerdiği varsayımı altında çalışan ayrı varyasyonlara sahiptir. +Örneğin, ‘length’ işlev, bayt cinsinden dize uzunluğunu hesaplar; ‘lengthUTF8’ işlev, değerin UTF-8 kodlanmış olduğunu varsayarak Unicode kod noktalarındaki dize uzunluğunu hesaplar. + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/string/) diff --git a/docs/tr/sql_reference/data_types/tuple.md b/docs/tr/sql_reference/data_types/tuple.md new file mode 100644 index 00000000000..64f2b2b2aec --- /dev/null +++ b/docs/tr/sql_reference/data_types/tuple.md @@ -0,0 +1,52 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 53 +toc_title: Tuple (T1, T2, ...) +--- + +# Tuple(t1, T2, …) {#tuplet1-t2} + +Elemanlarının bir demet, her bir birey olması [tür](index.md#data_types). + +Tuples geçici sütun gruplama için kullanılır. Sütunlar, bir sorguda bir In ifadesi kullanıldığında ve lambda işlevlerinin belirli resmi parametrelerini belirtmek için gruplandırılabilir. Daha fazla bilgi için bölümlere bakın [Operatör İNLERDE](../../sql_reference/statements/select.md) ve [Yüksek mertebeden fonksiyonlar](../../sql_reference/functions/higher_order_functions.md). + +Tuples bir sorgunun sonucu olabilir. Bu durumda, json dışındaki metin formatları için değerler köşeli parantez içinde virgülle ayrılır. JSON formatlarında, tuples diziler olarak çıktılanır (köşeli parantez içinde). + +## Bir Tuple oluşturma {#creating-a-tuple} + +Bir tuple oluşturmak için bir işlev kullanabilirsiniz: + +``` sql +tuple(T1, T2, ...) +``` + +Bir tuple oluşturma örneği: + +``` sql +SELECT tuple(1,'a') AS x, toTypeName(x) +``` + +``` text +┌─x───────┬─toTypeName(tuple(1, 'a'))─┐ +│ (1,'a') │ Tuple(UInt8, String) │ +└─────────┴───────────────────────────┘ +``` + +## Veri Türleri İle Çalışma {#working-with-data-types} + +Anında bir tuple oluştururken, ClickHouse her bağımsız değişkenin türünü bağımsız değişken değerini depolayabilen türlerin en azı olarak otomatik olarak algılar. Argüman ise [NULL](../../sql_reference/syntax.md#null-literal), tuple elemanının türü [Nullable](nullable.md). + +Otomatik veri türü algılama örneği: + +``` sql +SELECT tuple(1, NULL) AS x, toTypeName(x) +``` + +``` text +┌─x────────┬─toTypeName(tuple(1, NULL))──────┐ +│ (1,NULL) │ Tuple(UInt8, Nullable(Nothing)) │ +└──────────┴─────────────────────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/tuple/) diff --git a/docs/tr/sql_reference/data_types/uuid.md b/docs/tr/sql_reference/data_types/uuid.md new file mode 100644 index 00000000000..9fb502227be --- /dev/null +++ b/docs/tr/sql_reference/data_types/uuid.md @@ -0,0 +1,77 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 46 +toc_title: UUID +--- + +# UUID {#uuid-data-type} + +Evrensel olarak benzersiz bir tanımlayıcı (UUID), kayıtları tanımlamak için kullanılan 16 baytlık bir sayıdır. UUID hakkında ayrıntılı bilgi için bkz [Vikipedi](https://en.wikipedia.org/wiki/Universally_unique_identifier). + +UUID türü değeri örneği aşağıda temsil edilmektedir: + +``` text +61f0c404-5cb3-11e7-907b-a6006ad3dba0 +``` + +Yeni bir kayıt eklerken UUID sütun değerini belirtmezseniz, UUID değeri sıfır ile doldurulur: + +``` text +00000000-0000-0000-0000-000000000000 +``` + +## Nasıl Oluşturulur {#how-to-generate} + +UUID değerini oluşturmak için ClickHouse, [generateuuıdv4](../../sql_reference/functions/uuid_functions.md) işlev. + +## Kullanım Örneği {#usage-example} + +**Örnek 1** + +Bu örnek, UUID türü sütunuyla bir tablo oluşturma ve tabloya bir değer ekleme gösterir. + +``` sql +CREATE TABLE t_uuid (x UUID, y String) ENGINE=TinyLog +``` + +``` sql +INSERT INTO t_uuid SELECT generateUUIDv4(), 'Example 1' +``` + +``` sql +SELECT * FROM t_uuid +``` + +``` text +┌────────────────────────────────────x─┬─y─────────┐ +│ 417ddc5d-e556-4d27-95dd-a34d84e46a50 │ Example 1 │ +└──────────────────────────────────────┴───────────┘ +``` + +**Örnek 2** + +Bu örnekte, yeni bir kayıt eklerken UUID sütun değeri belirtilmedi. + +``` sql +INSERT INTO t_uuid (y) VALUES ('Example 2') +``` + +``` sql +SELECT * FROM t_uuid +``` + +``` text +┌────────────────────────────────────x─┬─y─────────┐ +│ 417ddc5d-e556-4d27-95dd-a34d84e46a50 │ Example 1 │ +│ 00000000-0000-0000-0000-000000000000 │ Example 2 │ +└──────────────────────────────────────┴───────────┘ +``` + +## Kısıtlama {#restrictions} + +UUID veri türü sadece hangi fonksiyonları destekler [Dize](string.md) veri türü de destekler (örneğin, [dakika](../../sql_reference/aggregate_functions/reference.md#agg_function-min), [maksimum](../../sql_reference/aggregate_functions/reference.md#agg_function-max), ve [sayma](../../sql_reference/aggregate_functions/reference.md#agg_function-count)). + +UUID veri türü aritmetik işlemler tarafından desteklenmez (örneğin, [abs](../../sql_reference/functions/arithmetic_functions.md#arithm_func-abs)) veya toplama fonksiyonları gibi [toplam](../../sql_reference/aggregate_functions/reference.md#agg_function-sum) ve [avg](../../sql_reference/aggregate_functions/reference.md#agg_function-avg). + +[Orijinal makale](https://clickhouse.tech/docs/en/data_types/uuid/) diff --git a/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts.md b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts.md new file mode 100644 index 00000000000..ac85ccd1724 --- /dev/null +++ b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts.md @@ -0,0 +1,56 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 39 +toc_title: "Genel A\xE7\u0131klama" +--- + +# Dış Söz Dictionarieslükler {#dicts-external-dicts} + +Çeşitli veri kaynaklarından kendi sözlükleri ekleyebilirsiniz. Bir sözlük için veri kaynağı, yerel bir metin veya yürütülebilir dosya, bir HTTP(s) kaynağı veya başka bir DBMS olabilir. Daha fazla bilgi için, bkz. “[Dış sözlükler için kaynaklar](external_dicts_dict_sources.md)”. + +ClickHouse: + +- Sözlükleri RAM'de tamamen veya kısmen saklar. +- Sözlükleri periyodik olarak günceller ve eksik değerleri dinamik olarak yükler. Başka bir deyişle, sözlükler dinamik olarak yüklenebilir. +- Xml dosyaları ile harici sözlükler oluşturmak için izin verir veya [DDL sorguları](../../statements/create.md#create-dictionary-query). + +Dış sözlüklerin yapılandırması bir veya daha fazla xml dosyasında bulunabilir. Yapılandırma yolu belirtilen [dictionaries\_config](../../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-dictionaries_config) parametre. + +Sözlükler sunucu başlangıçta veya ilk kullanımda, bağlı olarak yüklenebilir [dictionaries\_lazy\_load](../../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-dictionaries_lazy_load) ayar. + +Sözlük yapılandırma dosyası aşağıdaki biçime sahiptir: + +``` xml + + An optional element with any content. Ignored by the ClickHouse server. + + + /etc/metrika.xml + + + + + + + + +``` + +Yapabilirsin [yapılandırmak](external_dicts_dict.md) aynı dosyada sözlükler herhangi bir sayıda. + +[Sözlükler için DDL sorguları](../../statements/create.md#create-dictionary-query) sunucu yapılandırmasında herhangi bir ek kayıt gerektirmez. Tablolar veya görünümler gibi birinci sınıf varlıklar olarak sözlüklerle çalışmaya izin verirler. + +!!! attention "Dikkat" + Küçük bir sözlük için değerleri, bir `SELECT` sorgu (bkz. [dönüştürmek](../../../sql_reference/functions/other_functions.md) işlev). Bu işlevsellik harici sözlüklerle ilgili değildir. + +## Ayrıca Bakınız {#ext-dicts-see-also} + +- [Harici bir sözlük yapılandırma](external_dicts_dict.md) +- [Sözlükleri bellekte saklama](external_dicts_dict_layout.md) +- [Sözlük Güncellemeleri](external_dicts_dict_lifetime.md) +- [Dış Sözlüklerin kaynakları](external_dicts_dict_sources.md) +- [Sözlük anahtarı ve alanları](external_dicts_dict_structure.md) +- [Harici Sözlüklerle çalışmak için işlevler](../../../sql_reference/functions/ext_dict_functions.md) + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/dicts/external_dicts/) diff --git a/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict.md b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict.md new file mode 100644 index 00000000000..b931143903e --- /dev/null +++ b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict.md @@ -0,0 +1,53 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 40 +toc_title: "Harici bir s\xF6zl\xFCk yap\u0131land\u0131rma" +--- + +# Harici bir sözlük yapılandırma {#dicts-external-dicts-dict} + +Sözlük xml dosyası kullanılarak yapılandırılmışsa, sözlük yapılandırması aşağıdaki yapıya sahiptir: + +``` xml + + dict_name + + + + + + + + + + + + + + + + + +``` + +İlgili [DDL-sorgu](../../statements/create.md#create-dictionary-query) aşağıdaki yapıya sahiptir: + +``` sql +CREATE DICTIONARY dict_name +( + ... -- attributes +) +PRIMARY KEY ... -- complex or single key configuration +SOURCE(...) -- Source configuration +LAYOUT(...) -- Memory layout configuration +LIFETIME(...) -- Lifetime of dictionary in memory +``` + +- `name` – The identifier that can be used to access the dictionary. Use the characters `[a-zA-Z0-9_\-]`. +- [kaynaklı](external_dicts_dict_sources.md) — Source of the dictionary. +- [düzen](external_dicts_dict_layout.md) — Dictionary layout in memory. +- [yapılı](external_dicts_dict_structure.md) — Structure of the dictionary . A key and attributes that can be retrieved by this key. +- [ömür](external_dicts_dict_lifetime.md) — Frequency of dictionary updates. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/dicts/external_dicts_dict/) diff --git a/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_hierarchical.md b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_hierarchical.md new file mode 100644 index 00000000000..6945173c529 --- /dev/null +++ b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_hierarchical.md @@ -0,0 +1,70 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 45 +toc_title: "Hiyerar\u015Fik s\xF6zl\xFCkler" +--- + +# Hiyerarşik Sözlükler {#hierarchical-dictionaries} + +ClickHouse bir hiyerarşik sözlükler destekler [sayısal tuş](external_dicts_dict_structure.md#ext_dict-numeric-key). + +Aşağıdaki hiyerarşik yapıya bakın: + +``` text +0 (Common parent) +│ +├── 1 (Russia) +│ │ +│ └── 2 (Moscow) +│ │ +│ └── 3 (Center) +│ +└── 4 (Great Britain) + │ + └── 5 (London) +``` + +Bu hiyerarşi aşağıdaki sözlük tablosu olarak ifade edilebilir. + +| region\_id | parent\_region | region\_name | +|------------|----------------|--------------| +| 1 | 0 | Rusya | +| 2 | 1 | Moskova | +| 3 | 2 | Merkezli | +| 4 | 0 | İngiltere | +| 5 | 4 | Londra | + +Bu tablo bir sütun içerir `parent_region` bu öğe için en yakın ebeveynin anahtarını içerir. + +ClickHouse destekler [hiyerarşik](external_dicts_dict_structure.md#hierarchical-dict-attr) için mülkiyet [dış sözlük](index.md) öznitelik. Bu özellik, yukarıda açıklanana benzer hiyerarşik sözlüğü yapılandırmanıza izin verir. + +Bu [dictGetHierarchy](../../../sql_reference/functions/ext_dict_functions.md#dictgethierarchy) fonksiyonu bir elemanın üst zincir almak için izin verir. + +Örneğimiz için, sözlüğün yapısı aşağıdaki gibi olabilir: + +``` xml + + + + region_id + + + + parent_region + UInt64 + 0 + true + + + + region_name + String + + + + + +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/dicts/external_dicts_dict_hierarchical/) diff --git a/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_layout.md b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_layout.md new file mode 100644 index 00000000000..174d6830839 --- /dev/null +++ b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_layout.md @@ -0,0 +1,373 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 41 +toc_title: "S\xF6zl\xFCkleri bellekte saklama" +--- + +# Sözlükleri Bellekte Saklama {#dicts-external-dicts-dict-layout} + +Sözlükleri bellekte saklamanın çeşitli yolları vardır. + +Biz tavsiye [düzlük](#flat), [karıştırıyordu](#dicts-external_dicts_dict_layout-hashed) ve [complex\_key\_hashed](#complex-key-hashed). hangi optimum işleme hızı sağlamak. + +Önbelleğe alma, potansiyel olarak düşük performans ve en uygun parametreleri seçmede zorluklar nedeniyle önerilmez. Bölümünde devamını oku “[önbellek](#cache)”. + +Sözlük performansını artırmanın birkaç yolu vardır: + +- Sonra sözlük ile çalışmak için işlevi çağırın `GROUP BY`. +- Mark enjektif olarak ayıklamak için nitelikler. Farklı öznitelik değerleri farklı anahtarlara karşılık geliyorsa, bir öznitelik ınjective olarak adlandırılır. Yani ne zaman `GROUP BY` anahtar tarafından bir öznitelik değeri getiren bir işlev kullanır, bu işlev otomatik olarak dışarı alınır `GROUP BY`. + +ClickHouse, sözlüklerdeki hatalar için bir istisna oluşturur. Hata örnekleri: + +- Erişilen sözlük yüklenemedi. +- Bir sorgulama hatası `cached` sözlük. + +Sen dış sözlükler ve durumları listesini görüntüleyebilirsiniz `system.dictionaries` Tablo. + +Yapılandırma şöyle görünüyor: + +``` xml + + + ... + + + + + + ... + + +``` + +İlgili [DDL-sorgu](../../statements/create.md#create-dictionary-query): + +``` sql +CREATE DICTIONARY (...) +... +LAYOUT(LAYOUT_TYPE(param value)) -- layout settings +... +``` + +## Sözlükleri Bellekte Saklamanın Yolları {#ways-to-store-dictionaries-in-memory} + +- [düzlük](#flat) +- [karıştırıyordu](#dicts-external_dicts_dict_layout-hashed) +- [sparse\_hashed](#dicts-external_dicts_dict_layout-sparse_hashed) +- [önbellek](#cache) +- [range\_hashed](#range-hashed) +- [complex\_key\_hashed](#complex-key-hashed) +- [complex\_key\_cache](#complex-key-cache) +- [ıp\_trie](#ip-trie) + +### düzlük {#flat} + +Sözlük tamamen düz diziler şeklinde bellekte saklanır. Sözlük ne kadar bellek kullanıyor? Miktar, en büyük anahtarın boyutuyla orantılıdır (kullanılan alanda). + +Sözlük anahtarı vardır `UInt64` yazın ve değeri 500.000 ile sınırlıdır. Sözlük oluştururken daha büyük bir anahtar bulunursa, ClickHouse bir özel durum atar ve sözlüğü oluşturmaz. + +Her türlü kaynak desteklenmektedir. Güncellerken, veriler (bir dosyadan veya bir tablodan) bütünüyle okunur. + +Bu yöntem, sözlüğü saklamak için mevcut tüm yöntemler arasında en iyi performansı sağlar. + +Yapılandırma örneği: + +``` xml + + + +``` + +veya + +``` sql +LAYOUT(FLAT()) +``` + +### karıştırıyordu {#dicts-external_dicts_dict_layout-hashed} + +Sözlük tamamen bir karma tablo şeklinde bellekte saklanır. Sözlük, uygulamada herhangi bir tanımlayıcıya sahip herhangi bir sayıda öğe içerebilir, anahtar sayısı on milyonlarca öğeye ulaşabilir. + +Her türlü kaynak desteklenmektedir. Güncellerken, veriler (bir dosyadan veya bir tablodan) bütünüyle okunur. + +Yapılandırma örneği: + +``` xml + + + +``` + +veya + +``` sql +LAYOUT(HASHED()) +``` + +### sparse\_hashed {#dicts-external_dicts_dict_layout-sparse_hashed} + +Benzer `hashed`, ancak daha fazla CPU kullanımı lehine daha az bellek kullanır. + +Yapılandırma örneği: + +``` xml + + + +``` + +``` sql +LAYOUT(SPARSE_HASHED()) +``` + +### complex\_key\_hashed {#complex-key-hashed} + +Bu tür depolama kompozit ile kullanım içindir [anahtarlar](external_dicts_dict_structure.md). Benzer `hashed`. + +Yapılandırma örneği: + +``` xml + + + +``` + +``` sql +LAYOUT(COMPLEX_KEY_HASHED()) +``` + +### range\_hashed {#range-hashed} + +Sözlük, sıralı bir aralık dizisi ve bunlara karşılık gelen değerleri olan bir karma tablo şeklinde bellekte saklanır. + +Bu depolama yöntemi, hashed ile aynı şekilde çalışır ve anahtara ek olarak tarih/saat (rasgele sayısal tür) aralıklarının kullanılmasına izin verir. + +Örnek: tablo, her reklamveren için biçimdeki indirimleri içerir: + +``` text ++---------|-------------|-------------|------+ +| advertiser id | discount start date | discount end date | amount | ++===============+=====================+===================+========+ +| 123 | 2015-01-01 | 2015-01-15 | 0.15 | ++---------|-------------|-------------|------+ +| 123 | 2015-01-16 | 2015-01-31 | 0.25 | ++---------|-------------|-------------|------+ +| 456 | 2015-01-01 | 2015-01-15 | 0.05 | ++---------|-------------|-------------|------+ +``` + +Tarih aralıkları için bir örnek kullanmak için, `range_min` ve `range_max` element inler [yapılı](external_dicts_dict_structure.md). Bu elemanlar elemanları içermelidir `name` ve`type` (eğer `type` belirtilmemişse, varsayılan tür kullanılır-Tarih). `type` herhangi bir sayısal tür olabilir (Date / DateTime / Uint64 / Int32 / others). + +Örnek: + +``` xml + + + Id + + + first + Date + + + last + Date + + ... +``` + +veya + +``` sql +CREATE DICTIONARY somedict ( + id UInt64, + first Date, + last Date +) +PRIMARY KEY id +LAYOUT(RANGE_HASHED()) +RANGE(MIN first MAX last) +``` + +Bu sözlüklerle çalışmak için, `dictGetT` bir aralığın seçildiği işlev: + +``` sql +dictGetT('dict_name', 'attr_name', id, date) +``` + +Bu işlev belirtilen değerin değerini döndürür `id`s ve geçirilen tarihi içeren tarih aralığı. + +Algoritmanın detayları: + +- Eğer... `id` not fo orund veya a range is not fo aund for the `id`, sözlük için varsayılan değeri döndürür. +- Çakışan aralıklar varsa, herhangi birini kullanabilirsiniz. +- Aralık sınırlayıcı ise `NULL` veya geçersiz bir tarih (örneğin 1900-01-01 veya 2039-01-01), Aralık açık bırakılır. Aralık her iki tarafta da açık olabilir. + +Yapılandırma örneği: + +``` xml + + + + ... + + + + + + + + Abcdef + + + StartTimeStamp + UInt64 + + + EndTimeStamp + UInt64 + + + XXXType + String + + + + + + +``` + +veya + +``` sql +CREATE DICTIONARY somedict( + Abcdef UInt64, + StartTimeStamp UInt64, + EndTimeStamp UInt64, + XXXType String DEFAULT '' +) +PRIMARY KEY Abcdef +RANGE(MIN StartTimeStamp MAX EndTimeStamp) +``` + +### önbellek {#cache} + +Sözlük, sabit sayıda hücre içeren bir önbellekte saklanır. Bu hücreler sık kullanılan elementleri içerir. + +Bir sözlük ararken, önce önbellek aranır. Her veri bloğu için, önbellekte bulunmayan veya güncel olmayan tüm anahtarlar, kaynak kullanılarak istenir `SELECT attrs... FROM db.table WHERE id IN (k1, k2, ...)`. Alınan veriler daha sonra önbelleğe yazılır. + +Önbellek sözlükleri için, sona erme [ömür](external_dicts_dict_lifetime.md) önbellekteki verilerin ayarlanabilir. Eğer daha fazla zaman `lifetime` bir hücrede veri yüklenmesinden bu yana geçti, hücrenin değeri kullanılmaz ve bir dahaki sefere kullanılması gerektiğinde yeniden istenir. +Bu, sözlükleri saklamanın tüm yollarından en az etkilidir. Önbelleğin hızı, doğru ayarlara ve kullanım senaryosuna bağlıdır. Bir önbellek türü sözlüğü, yalnızca isabet oranları yeterince yüksek olduğunda (önerilen %99 ve daha yüksek) iyi performans gösterir. Sen ortalama isabet oranı görebilirsiniz `system.dictionaries` Tablo. + +Önbellek performansını artırmak için bir alt sorgu ile kullanın `LIMIT`, ve harici sözlük ile işlevini çağırın. + +Destek [kaynaklılar](external_dicts_dict_sources.md): MySQL, ClickHouse, yürütülebilir, HTTP. + +Ayarlar örneği: + +``` xml + + + + 1000000000 + + +``` + +veya + +``` sql +LAYOUT(CACHE(SIZE_IN_CELLS 1000000000)) +``` + +Yeterince büyük bir önbellek boyutu ayarlayın. Sen hücre sayısını seçmek için deneme gerekir: + +1. Bazı değer ayarlayın. +2. Önbellek tamamen doluncaya kadar sorguları çalıştırın. +3. Kullanarak bellek tüketimini değerlendirmek `system.dictionaries` Tablo. +4. Gerekli bellek tüketimine ulaşılana kadar hücre sayısını artırın veya azaltın. + +!!! warning "Uyarıcı" + Rasgele okuma ile sorguları işlemek için yavaş olduğundan, ClickHouse kaynak olarak kullanmayın. + +### complex\_key\_cache {#complex-key-cache} + +Bu tür depolama kompozit ile kullanım içindir [anahtarlar](external_dicts_dict_structure.md). Benzer `cache`. + +### ıp\_trie {#ip-trie} + +Bu tür depolama, ağ öneklerini (IP adresleri) asn gibi meta verilere eşlemek içindir. + +Örnek: tablo, ağ önekleri ve bunlara karşılık gelen sayı ve ülke kodu içerir: + +``` text + +-----------|-----|------+ + | prefix | asn | cca2 | + +=================+=======+========+ + | 202.79.32.0/20 | 17501 | NP | + +-----------|-----|------+ + | 2620:0:870::/48 | 3856 | US | + +-----------|-----|------+ + | 2a02:6b8:1::/48 | 13238 | RU | + +-----------|-----|------+ + | 2001:db8::/32 | 65536 | ZZ | + +-----------|-----|------+ +``` + +Bu tür bir düzen kullanırken, yapının bileşik bir anahtarı olmalıdır. + +Örnek: + +``` xml + + + + prefix + String + + + + asn + UInt32 + + + + cca2 + String + ?? + + ... +``` + +veya + +``` sql +CREATE DICTIONARY somedict ( + prefix String, + asn UInt32, + cca2 String DEFAULT '??' +) +PRIMARY KEY prefix +``` + +Anahtarın izin verilen bir IP öneki içeren yalnızca bir dize türü özniteliği olması gerekir. Diğer türler henüz desteklenmiyor. + +Sorgular için aynı işlevleri kullanmanız gerekir (`dictGetT` bir tuple ile) kompozit tuşları ile sözlükler gelince: + +``` sql +dictGetT('dict_name', 'attr_name', tuple(ip)) +``` + +İşlev ya alır `UInt32` IPv4 için veya `FixedString(16)` IPv6 için: + +``` sql +dictGetString('prefix', 'asn', tuple(IPv6StringToNum('2001:db8::1'))) +``` + +Diğer türler henüz desteklenmiyor. İşlev, bu IP adresine karşılık gelen önek için özniteliği döndürür. Örtüşen önekler varsa, en spesifik olanı döndürülür. + +Veri bir saklanan `trie`. Tamamen RAM'e uyması gerekir. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/dicts/external_dicts_dict_layout/) diff --git a/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_lifetime.md b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_lifetime.md new file mode 100644 index 00000000000..d630e9e0128 --- /dev/null +++ b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_lifetime.md @@ -0,0 +1,91 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 42 +toc_title: "S\xF6zl\xFCk G\xFCncellemeleri" +--- + +# Sözlük Güncellemeleri {#dictionary-updates} + +ClickHouse sözlükleri periyodik olarak günceller. Tam olarak karşıdan yüklenen sözlükler için Güncelleştirme aralığı ve önbelleğe alınmış sözlükler için geçersiz kılma aralığı `` saniyeler içinde etiketleyin. + +Sözlük güncelleştirmeleri (ilk kullanım için yükleme dışında) sorguları engellemez. Güncellemeler sırasında, bir sözlüğün eski sürümü kullanılır. Güncelleştirme sırasında bir hata oluşursa, hata sunucu günlüğüne yazılır ve sorgular sözlüklerin eski sürümünü kullanmaya devam eder. + +Ayarlar örneği: + +``` xml + + ... + 300 + ... + +``` + +``` sql +CREATE DICTIONARY (...) +... +LIFETIME(300) +... +``` + +Ayar `0` (`LIFETIME(0)`) söz dictionarieslük .lerin güncel updatinglenmesini engeller. + +Yükseltmeler için bir zaman aralığı ayarlayabilirsiniz ve ClickHouse bu aralıkta eşit rastgele bir zaman seçecektir. Bu, çok sayıda sunucuda yükseltme yaparken yükü sözlük kaynağına dağıtmak için gereklidir. + +Ayarlar örneği: + +``` xml + + ... + + 300 + 360 + + ... + +``` + +veya + +``` sql +LIFETIME(MIN 300 MAX 360) +``` + +Eğer `0` ve `0`, ClickHouse sözlüğü zaman aşımı ile yeniden yüklemez. +Bu durumda, Sözlük yapılandırma dosyası değiştirilmişse veya ClickHouse sözlüğü daha önce yeniden yükleyebilir. `SYSTEM RELOAD DICTIONARY` komut yürütüldü. + +Sözlükleri yükseltirken, ClickHouse sunucusu türüne bağlı olarak farklı mantık uygular [kaynaklı](external_dicts_dict_sources.md): + +Sözlükleri yükseltirken, ClickHouse sunucusu türüne bağlı olarak farklı mantık uygular [kaynaklı](external_dicts_dict_sources.md): + +- Bir metin dosyası için değişiklik zamanını kontrol eder. Zaman önceden kaydedilmiş zaman farklıysa, sözlük güncelleştirilir. +- Myısam tabloları için, değişiklik zamanı bir `SHOW TABLE STATUS` sorgu. +- Diğer kaynaklardan gelen sözlükler varsayılan olarak her zaman güncellenir. + +MySQL (InnoDB), ODBC ve ClickHouse kaynakları için, sözlükleri her seferinde değil, gerçekten değiştiyse güncelleyecek bir sorgu ayarlayabilirsiniz. Bunu yapmak için şu adımları izleyin: + +- Sözlük tablosu, kaynak verileri güncelleştirildiğinde her zaman değişen bir alana sahip olmalıdır. +- Kaynak ayarları, değişen alanı alan bir sorgu belirtmeniz gerekir. ClickHouse sunucu sorgu sonucu bir satır olarak yorumlar ve bu satır önceki durumuna göre değişmişse, sözlük güncelleştirilir. Sorguda belirtme `` için ayar fieldlardaki alan [kaynaklı](external_dicts_dict_sources.md). + +Ayarlar örneği: + +``` xml + + ... + + ... + SELECT update_time FROM dictionary_source where id = 1 + + ... + +``` + +veya + +``` sql +... +SOURCE(ODBC(... invalidate_query 'SELECT update_time FROM dictionary_source where id = 1')) +... +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/dicts/external_dicts_dict_lifetime/) diff --git a/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_sources.md b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_sources.md new file mode 100644 index 00000000000..d2ea01c54ce --- /dev/null +++ b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_sources.md @@ -0,0 +1,608 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 43 +toc_title: "D\u0131\u015F S\xF6zl\xFCklerin kaynaklar\u0131" +--- + +# Dış Sözlüklerin Kaynakları {#dicts-external-dicts-dict-sources} + +Harici bir sözlük birçok farklı kaynaktan bağlanabilir. + +Sözlük xml dosyası kullanılarak yapılandırılmışsa, yapılandırma şöyle görünür: + +``` xml + + + ... + + + + + + ... + + ... + +``` + +Durumunda [DDL-sorgu](../../statements/create.md#create-dictionary-query), eşit yapılandırma gibi görünüyor olacak: + +``` sql +CREATE DICTIONARY dict_name (...) +... +SOURCE(SOURCE_TYPE(param1 val1 ... paramN valN)) -- Source configuration +... +``` + +Kaynak yapılandırılmış `source` bölme. + +Kaynak türleri (`source_type`): + +- [Yerel dosya](#dicts-external_dicts_dict_sources-local_file) +- [Yürütülebilir dosya](#dicts-external_dicts_dict_sources-executable) +- [HTTP (s)](#dicts-external_dicts_dict_sources-http) +- DBMS + - [ODBC](#dicts-external_dicts_dict_sources-odbc) + - [MySQL](#dicts-external_dicts_dict_sources-mysql) + - [ClickHouse](#dicts-external_dicts_dict_sources-clickhouse) + - [MongoDB](#dicts-external_dicts_dict_sources-mongodb) + - [Redis](#dicts-external_dicts_dict_sources-redis) + +## Yerel Dosya {#dicts-external_dicts_dict_sources-local_file} + +Ayarlar örneği: + +``` xml + + + /opt/dictionaries/os.tsv + TabSeparated + + +``` + +veya + +``` sql +SOURCE(FILE(path '/opt/dictionaries/os.tsv' format 'TabSeparated')) +``` + +Ayar alanları: + +- `path` – The absolute path to the file. +- `format` – The file format. All the formats described in “[Biçimliler](../../../interfaces/formats.md#formats)” desteklenir. + +## Yürütülebilir Dosya {#dicts-external_dicts_dict_sources-executable} + +Yürütülebilir dosyalarla çalışmak Aşağıdakilere bağlıdır [sözlük bellekte nasıl saklanır](external_dicts_dict_layout.md). Sözlük kullanılarak saklan theıyorsa `cache` ve `complex_key_cache` ClickHouse, yürütülebilir dosyanın STDIN'SİNE bir istek göndererek gerekli anahtarları ister. Aksi takdirde, clickhouse yürütülebilir dosyayı başlatır ve çıktısını sözlük verileri olarak değerlendirir. + +Ayarlar örneği: + +``` xml + + + cat /opt/dictionaries/os.tsv + TabSeparated + + +``` + +veya + +``` sql +SOURCE(EXECUTABLE(command 'cat /opt/dictionaries/os.tsv' format 'TabSeparated')) +``` + +Ayar alanları: + +- `command` – The absolute path to the executable file, or the file name (if the program directory is written to `PATH`). +- `format` – The file format. All the formats described in “[Biçimliler](../../../interfaces/formats.md#formats)” desteklenir. + +## Http (s) {#dicts-external_dicts_dict_sources-http} + +Bir HTTP (s) sunucusuyla çalışmak Aşağıdakilere bağlıdır [sözlük bellekte nasıl saklanır](external_dicts_dict_layout.md). Sözlük kullanılarak saklan theıyorsa `cache` ve `complex_key_cache`, ClickHouse aracılığıyla bir istek göndererek gerekli anahtarları ister `POST` yöntem. + +Ayarlar örneği: + +``` xml + + + http://[::1]/os.tsv + TabSeparated + + user + password + + +
+ API-KEY + key +
+ + + +``` + +veya + +``` sql +SOURCE(HTTP( + url 'http://[::1]/os.tsv' + format 'TabSeparated' + credentials(user 'user' password 'password') + headers(header(name 'API-KEY' value 'key')) +)) +``` + +Clickhouse'un bir HTTPS kaynağına erişebilmesi için şunları yapmanız gerekir [openssl'yi yapılandırma](../../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-openssl) sunucu yapılandırmasında. + +Ayar alanları: + +- `url` – The source URL. +- `format` – The file format. All the formats described in “[Biçimliler](../../../interfaces/formats.md#formats)” desteklenir. +- `credentials` – Basic HTTP authentication. Optional parameter. + - `user` – Username required for the authentication. + - `password` – Password required for the authentication. +- `headers` – All custom HTTP headers entries used for the HTTP request. Optional parameter. + - `header` – Single HTTP header entry. + - `name` – Identifiant name used for the header send on the request. + - `value` – Value set for a specific identifiant name. + +## ODBC {#dicts-external_dicts_dict_sources-odbc} + +ODBC sürücüsü olan herhangi bir veritabanını bağlamak için bu yöntemi kullanabilirsiniz. + +Ayarlar örneği: + +``` xml + + + DatabaseName + ShemaName.TableName
+ DSN=some_parameters + SQL_QUERY + + +``` + +veya + +``` sql +SOURCE(ODBC( + db 'DatabaseName' + table 'SchemaName.TableName' + connection_string 'DSN=some_parameters' + invalidate_query 'SQL_QUERY' +)) +``` + +Ayar alanları: + +- `db` – Name of the database. Omit it if the database name is set in the `` parametre. +- `table` – Name of the table and schema if exists. +- `connection_string` – Connection string. +- `invalidate_query` – Query for checking the dictionary status. Optional parameter. Read more in the section [Sözlükleri güncelleme](external_dicts_dict_lifetime.md). + +ClickHouse, ODBC sürücüsünden alıntı sembolleri alır ve sorgulardaki tüm ayarları sürücüye aktarır, bu nedenle tablo adını veritabanındaki tablo adı durumuna göre ayarlamak gerekir. + +Oracle kullanırken kodlamalarla ilgili bir sorununuz varsa, ilgili [FAQ](../../../faq/general.md#oracle-odbc-encodings) makale. + +### ODBC Sözlük işlevselliği bilinen güvenlik açığı {#known-vulnerability-of-the-odbc-dictionary-functionality} + +!!! attention "Dikkat" + ODBC sürücüsü bağlantı parametresi aracılığıyla veritabanına bağlanırken `Servername` yerine. Bu durumda değerler `USERNAME` ve `PASSWORD` itibaren `odbc.ini` uzak sunucuya gönderilir ve tehlikeye girebilir. + +**Güvensiz kullanım örneği** + +PostgreSQL için unixodbc'yi yapılandıralım. İçeriği `/etc/odbc.ini`: + +``` text +[gregtest] +Driver = /usr/lib/psqlodbca.so +Servername = localhost +PORT = 5432 +DATABASE = test_db +#OPTION = 3 +USERNAME = test +PASSWORD = test +``` + +Daha sonra aşağıdaki gibi bir sorgu yaparsanız + +``` sql +SELECT * FROM odbc('DSN=gregtest;Servername=some-server.com', 'test_db'); +``` + +ODBC sürücüsü değerleri gönderir `USERNAME` ve `PASSWORD` itibaren `odbc.ini` -e doğru `some-server.com`. + +### PostgreSQL Bağlanma Örneği {#example-of-connecting-postgresql} + +UB .untu OS. + +PostgreSQL için UNİXODBC ve ODBC sürücüsünü yükleme: + +``` bash +$ sudo apt-get install -y unixodbc odbcinst odbc-postgresql +``` + +Yapılandırma `/etc/odbc.ini` (veya `~/.odbc.ini`): + +``` text + [DEFAULT] + Driver = myconnection + + [myconnection] + Description = PostgreSQL connection to my_db + Driver = PostgreSQL Unicode + Database = my_db + Servername = 127.0.0.1 + UserName = username + Password = password + Port = 5432 + Protocol = 9.3 + ReadOnly = No + RowVersioning = No + ShowSystemTables = No + ConnSettings = +``` + +Clickhouse'da sözlük yapılandırması: + +``` xml + + + table_name + + + + + DSN=myconnection + postgresql_table
+ + + + 300 + 360 + + + + + + + id + + + some_column + UInt64 + 0 + + + + +``` + +veya + +``` sql +CREATE DICTIONARY table_name ( + id UInt64, + some_column UInt64 DEFAULT 0 +) +PRIMARY KEY id +SOURCE(ODBC(connection_string 'DSN=myconnection' table 'postgresql_table')) +LAYOUT(HASHED()) +LIFETIME(MIN 300 MAX 360) +``` + +Düzenlemeniz gerekebilir `odbc.ini` sürücü ile kitaplığın tam yolunu belirtmek için `DRIVER=/usr/local/lib/psqlodbcw.so`. + +### MS SQL Server bağlanma örneği {#example-of-connecting-ms-sql-server} + +UB .untu OS. + +Sürücüyü yükleme: : + +``` bash +$ sudo apt-get install tdsodbc freetds-bin sqsh +``` + +Sürücüyü yapılandırma: + +``` bash + $ cat /etc/freetds/freetds.conf + ... + + [MSSQL] + host = 192.168.56.101 + port = 1433 + tds version = 7.0 + client charset = UTF-8 + + $ cat /etc/odbcinst.ini + ... + + [FreeTDS] + Description = FreeTDS + Driver = /usr/lib/x86_64-linux-gnu/odbc/libtdsodbc.so + Setup = /usr/lib/x86_64-linux-gnu/odbc/libtdsS.so + FileUsage = 1 + UsageCount = 5 + + $ cat ~/.odbc.ini + ... + + [MSSQL] + Description = FreeTDS + Driver = FreeTDS + Servername = MSSQL + Database = test + UID = test + PWD = test + Port = 1433 +``` + +Clickhouse'da sözlüğü yapılandırma: + +``` xml + + + test + + + dict
+ DSN=MSSQL;UID=test;PWD=test + + + + + 300 + 360 + + + + + + + + + k + + + s + String + + + + + +``` + +veya + +``` sql +CREATE DICTIONARY test ( + k UInt64, + s String DEFAULT '' +) +PRIMARY KEY k +SOURCE(ODBC(table 'dict' connection_string 'DSN=MSSQL;UID=test;PWD=test')) +LAYOUT(FLAT()) +LIFETIME(MIN 300 MAX 360) +``` + +## DBMS {#dbms} + +### Mysql {#dicts-external_dicts_dict_sources-mysql} + +Ayarlar örneği: + +``` xml + + + 3306 + clickhouse + qwerty + + example01-1 + 1 + + + example01-2 + 1 + + db_name + table_name
+ id=10 + SQL_QUERY + + +``` + +veya + +``` sql +SOURCE(MYSQL( + port 3306 + user 'clickhouse' + password 'qwerty' + replica(host 'example01-1' priority 1) + replica(host 'example01-2' priority 1) + db 'db_name' + table 'table_name' + where 'id=10' + invalidate_query 'SQL_QUERY' +)) +``` + +Ayar alanları: + +- `port` – The port on the MySQL server. You can specify it for all replicas, or for each one individually (inside ``). + +- `user` – Name of the MySQL user. You can specify it for all replicas, or for each one individually (inside ``). + +- `password` – Password of the MySQL user. You can specify it for all replicas, or for each one individually (inside ``). + +- `replica` – Section of replica configurations. There can be multiple sections. + + - `replica/host` – The MySQL host. + - `replica/priority` – The replica priority. When attempting to connect, ClickHouse traverses the replicas in order of priority. The lower the number, the higher the priority. + +- `db` – Name of the database. + +- `table` – Name of the table. + +- `where` – The selection criteria. The syntax for conditions is the same as for `WHERE` MySQL, örneğin, `id > 10 AND id < 20`. İsteğe bağlı parametre. + +- `invalidate_query` – Query for checking the dictionary status. Optional parameter. Read more in the section [Sözlükleri güncelleme](external_dicts_dict_lifetime.md). + +MySQL yuva üzerinden yerel bir ana bilgisayara bağlanabilir. Bunu yapmak için, ayarlayın `host` ve `socket`. + +Ayarlar örneği: + +``` xml + + + localhost + /path/to/socket/file.sock + clickhouse + qwerty + db_name + table_name
+ id=10 + SQL_QUERY + + +``` + +veya + +``` sql +SOURCE(MYSQL( + host 'localhost' + socket '/path/to/socket/file.sock' + user 'clickhouse' + password 'qwerty' + db 'db_name' + table 'table_name' + where 'id=10' + invalidate_query 'SQL_QUERY' +)) +``` + +### ClickHouse {#dicts-external_dicts_dict_sources-clickhouse} + +Ayarlar örneği: + +``` xml + + + example01-01-1 + 9000 + default + + default + ids
+ id=10 + + +``` + +veya + +``` sql +SOURCE(CLICKHOUSE( + host 'example01-01-1' + port 9000 + user 'default' + password '' + db 'default' + table 'ids' + where 'id=10' +)) +``` + +Ayar alanları: + +- `host` – The ClickHouse host. If it is a local host, the query is processed without any network activity. To improve fault tolerance, you can create a [Dağılı](../../../engines/table_engines/special/distributed.md) tablo ve sonraki yapılandırmalarda girin. +- `port` – The port on the ClickHouse server. +- `user` – Name of the ClickHouse user. +- `password` – Password of the ClickHouse user. +- `db` – Name of the database. +- `table` – Name of the table. +- `where` – The selection criteria. May be omitted. +- `invalidate_query` – Query for checking the dictionary status. Optional parameter. Read more in the section [Sözlükleri güncelleme](external_dicts_dict_lifetime.md). + +### Mongodb {#dicts-external_dicts_dict_sources-mongodb} + +Ayarlar örneği: + +``` xml + + + localhost + 27017 + + + test + dictionary_source + + +``` + +veya + +``` sql +SOURCE(MONGO( + host 'localhost' + port 27017 + user '' + password '' + db 'test' + collection 'dictionary_source' +)) +``` + +Ayar alanları: + +- `host` – The MongoDB host. +- `port` – The port on the MongoDB server. +- `user` – Name of the MongoDB user. +- `password` – Password of the MongoDB user. +- `db` – Name of the database. +- `collection` – Name of the collection. + +### Redis {#dicts-external_dicts_dict_sources-redis} + +Ayarlar örneği: + +``` xml + + + localhost + 6379 + simple + 0 + + +``` + +veya + +``` sql +SOURCE(REDIS( + host 'localhost' + port 6379 + storage_type 'simple' + db_index 0 +)) +``` + +Ayar alanları: + +- `host` – The Redis host. +- `port` – The port on the Redis server. +- `storage_type` – The structure of internal Redis storage using for work with keys. `simple` basit kaynaklar ve karma tek anahtar kaynaklar içindir, `hash_map` iki anahtarlı karma kaynaklar içindir. Ranged kaynakları ve karmaşık anahtarlı önbellek kaynakları desteklenmez. İhmal edilebilir, varsayılan değer `simple`. +- `db_index` – The specific numeric index of Redis logical database. May be omitted, default value is 0. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/dicts/external_dicts_dict_sources/) diff --git a/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_structure.md b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_structure.md new file mode 100644 index 00000000000..bd404e3b822 --- /dev/null +++ b/docs/tr/sql_reference/dictionaries/external_dictionaries/external_dicts_dict_structure.md @@ -0,0 +1,175 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 44 +toc_title: "S\xF6zl\xFCk anahtar\u0131 ve alanlar\u0131" +--- + +# Sözlük anahtarı ve alanları {#dictionary-key-and-fields} + +Bu `` yan tümcesi sözlük anahtarı ve sorgular için kullanılabilir alanları açıklar. + +XML açıklaması: + +``` xml + + + + Id + + + + + + + ... + + + +``` + +Nitelikler elemanlarda açıklanmıştır: + +- `` — [Anahtar sütun](external_dicts_dict_structure.md#ext_dict_structure-key). +- `` — [Veri sütunu](external_dicts_dict_structure.md#ext_dict_structure-attributes). Birden fazla sayıda özellik olabilir. + +DDL sorgusu: + +``` sql +CREATE DICTIONARY dict_name ( + Id UInt64, + -- attributes +) +PRIMARY KEY Id +... +``` + +Öznitelikler sorgu gövdesinde açıklanmıştır: + +- `PRIMARY KEY` — [Anahtar sütun](external_dicts_dict_structure.md#ext_dict_structure-key) +- `AttrName AttrType` — [Veri sütunu](external_dicts_dict_structure.md#ext_dict_structure-attributes). Birden fazla sayıda özellik olabilir. + +## Anahtar {#ext_dict_structure-key} + +ClickHouse aşağıdaki anahtar türlerini destekler: + +- Sayısal tuş. `UInt64`. Tanımlanan `` etiket veya kullanma `PRIMARY KEY` kelime. +- Kompozit anahtar. Farklı türde değerler kümesi. Etiket definedinde tanımlı `` veya `PRIMARY KEY` kelime. + +Bir xml yapısı şunları içerebilir `` veya ``. DDL sorgusu tek içermelidir `PRIMARY KEY`. + +!!! warning "Uyarıcı" + Anahtarı bir öznitelik olarak tanımlamamalısınız. + +### Sayısal Tuş {#ext_dict-numeric-key} + +Tür: `UInt64`. + +Yapılandırma örneği: + +``` xml + + Id + +``` + +Yapılandırma alanları: + +- `name` – The name of the column with keys. + +DDL sorgusu için: + +``` sql +CREATE DICTIONARY ( + Id UInt64, + ... +) +PRIMARY KEY Id +... +``` + +- `PRIMARY KEY` – The name of the column with keys. + +### Kompozit Anahtar {#composite-key} + +Anahtar bir olabilir `tuple` her türlü alandan. Bu [düzen](external_dicts_dict_layout.md) bu durumda olmalıdır `complex_key_hashed` veya `complex_key_cache`. + +!!! tip "Uç" + Bileşik bir anahtar tek bir elemandan oluşabilir. Bu, örneğin bir dizeyi anahtar olarak kullanmayı mümkün kılar. + +Anahtar yapısı eleman ayarlanır ``. Anahtar alanlar sözlük ile aynı biçimde belirtilir [öznitelik](external_dicts_dict_structure.md). Örnek: + +``` xml + + + + field1 + String + + + field2 + UInt32 + + ... + +... +``` + +veya + +``` sql +CREATE DICTIONARY ( + field1 String, + field2 String + ... +) +PRIMARY KEY field1, field2 +... +``` + +Bir sorgu için `dictGet*` fonksiyon, bir tuple anahtar olarak geçirilir. Örnek: `dictGetString('dict_name', 'attr_name', tuple('string for field1', num_for_field2))`. + +## Öznitelik {#ext_dict_structure-attributes} + +Yapılandırma örneği: + +``` xml + + ... + + Name + ClickHouseDataType + + rand64() + true + true + true + + +``` + +veya + +``` sql +CREATE DICTIONARY somename ( + Name ClickHouseDataType DEFAULT '' EXPRESSION rand64() HIERARCHICAL INJECTIVE IS_OBJECT_ID +) +``` + +Yapılandırma alanları: + +| Etiket | Açıklama | Gerekli | +|------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------| +| `name` | Sütun adı. | Evet | +| `type` | ClickHouse veri türü.
ClickHouse, sözlükten belirtilen veri türüne değer atmaya çalışır. Örneğin, MySQL için alan olabilir `TEXT`, `VARCHAR`, veya `BLOB` MySQL kaynak tablosunda, ancak şu şekilde yüklenebilir `String` Clickhouse'da.
[Nullable](../../../sql_reference/data_types/nullable.md) desteklenmiyor. | Evet | +| `null_value` | Varolan olmayan bir öğe için varsayılan değer.
Örnekte, boş bir dizedir. Kullanamazsınız `NULL` bu alanda. | Evet | +| `expression` | [İfade](../../syntax.md#syntax-expressions) bu ClickHouse değeri yürütür.
İfade, uzak SQL veritabanında bir sütun adı olabilir. Bu nedenle, uzak sütun için bir diğer ad oluşturmak için kullanabilirsiniz.

Varsayılan değer: ifade yok. | Hayır | +| `hierarchical` | Eğer `true`, öznitelik, geçerli anahtar için bir üst anahtarın değerini içerir. Görmek [Hiyerarşik Sözlükler](external_dicts_dict_hierarchical.md).

Varsayılan değer: `false`. | Hayır | +| `injective` | Olup olmadığını gösteren bayrak `id -> attribute` ima isge is [enjektif](https://en.wikipedia.org/wiki/Injective_function).
Eğer `true`, ClickHouse sonra otomatik olarak yerleştirebilirsiniz `GROUP BY` fık .ra ile ilgili istek dictionariesleriniz Genellikle bu tür taleplerin miktarını önemli ölçüde azaltır.

Varsayılan değer: `false`. | Hayır | +| `is_object_id` | Bir MongoDB belgesi için sorgunun yürütülüp yürütülmediğini gösteren bayrak `ObjectID`.

Varsayılan değer: `false`. | Hayır | + +## Ayrıca Bakınız {#see-also} + +- [Harici sözlüklerle çalışmak için işlevler](../../../sql_reference/functions/ext_dict_functions.md). + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/dicts/external_dicts_dict_structure/) diff --git a/docs/tr/sql_reference/dictionaries/external_dictionaries/index.md b/docs/tr/sql_reference/dictionaries/external_dictionaries/index.md new file mode 100644 index 00000000000..d5eaa1e55b6 --- /dev/null +++ b/docs/tr/sql_reference/dictionaries/external_dictionaries/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "D\u0131\u015F S\xF6z Dictionariesl\xFCkler" +toc_priority: 37 +--- + + diff --git a/docs/tr/sql_reference/dictionaries/index.md b/docs/tr/sql_reference/dictionaries/index.md new file mode 100644 index 00000000000..a8a6c3605b4 --- /dev/null +++ b/docs/tr/sql_reference/dictionaries/index.md @@ -0,0 +1,22 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "S\xF6zl\xFCkler" +toc_priority: 35 +toc_title: "Giri\u015F" +--- + +# Sözlükler {#dictionaries} + +Bir sözlük bir haritalama (`key -> attributes`) bu referans listeleri çeşitli türleri için uygundur. + +ClickHouse, sorgularda kullanılabilecek sözlüklerle çalışmak için özel işlevleri destekler. Sözlükleri işlevlerle kullanmak daha kolay ve daha verimlidir. `JOIN` referans tabloları ile. + +[NULL](../syntax.md#null) değerler sözlükte saklanamaz. + +ClickHouse destekler: + +- [Dahili sözlükler](internal_dicts.md#internal_dicts) bir özel ile [fonksiyonlar kümesi](../../sql_reference/functions/ym_dict_functions.md). +- [Eklenti (harici) söz dictionarieslükler](external_dictionaries/external_dicts.md) ile bir [fonksiyonlar net](../../sql_reference/functions/ext_dict_functions.md). + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/dicts/) diff --git a/docs/tr/sql_reference/dictionaries/internal_dicts.md b/docs/tr/sql_reference/dictionaries/internal_dicts.md new file mode 100644 index 00000000000..b7a1d46207c --- /dev/null +++ b/docs/tr/sql_reference/dictionaries/internal_dicts.md @@ -0,0 +1,55 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 39 +toc_title: "\u0130\xE7 S\xF6z Dictionariesl\xFCkler" +--- + +# İç söz dictionarieslükler {#internal_dicts} + +ClickHouse, bir geobase ile çalışmak için yerleşik bir özellik içerir. + +Bu size sağlar: + +- Adını istediğiniz dilde almak için bölgenin kimliğini kullanın. +- Bir şehir, bölge, federal bölge, ülke veya kıtanın kimliğini almak için bölgenin kimliğini kullanın. +- Bir bölgenin başka bir bölgenin parçası olup olmadığını kontrol edin. +- Ana bölgeler zinciri alın. + +Tüm fonksiyonları destek “translocality,” aynı anda bölge mülkiyeti farklı bakış açıları kullanma yeteneği. Daha fazla bilgi için bölüme bakın “Functions for working with Yandex.Metrica dictionaries”. + +İç sözlükler varsayılan pakette devre dışı bırakılır. +Bunları etkinleştirmek için, parametreleri uncomment `path_to_regions_hierarchy_file` ve `path_to_regions_names_files` sunucu yapılandırma dosyasında. + +Geobase metin dosyalarından yüklenir. + +Place the `regions_hierarchy*.txt` dosyaları içine `path_to_regions_hierarchy_file` dizin. Bu yapılandırma parametresi, `regions_hierarchy.txt` dosya (varsayılan bölgesel hiyerarşi) ve diğer dosyalar (`regions_hierarchy_ua.txt`) aynı dizinde bulunmalıdır. + +Koy... `regions_names_*.txt` dosyalar içinde `path_to_regions_names_files` dizin. + +Bu dosyaları kendiniz de oluşturabilirsiniz. Dosya biçimi aşağıdaki gibidir: + +`regions_hierarchy*.txt`: TabSeparated (başlık yok), sütunlar: + +- bölge kimliği (`UInt32`) +- üst bölge kimliği (`UInt32`) +- bölge tipi (`UInt8`): 1 - kıta, 3-ülke, 4-federal bölge, 5-bölge, 6-şehir; diğer türlerin değerleri yoktur +- nüfuslu (`UInt32`) — optional column + +`regions_names_*.txt`: TabSeparated (başlık yok), sütunlar: + +- bölge kimliği (`UInt32`) +- bölge adı (`String`) — Can't contain tabs or line feeds, even escaped ones. + +RAM'de depolamak için düz bir dizi kullanılır. Bu nedenle, IDs bir milyondan fazla olmamalıdır. + +Sözlükler sunucuyu yeniden başlatmadan güncellenebilir. Ancak, kullanılabilir sözlükler kümesi güncelleştirilmez. +Güncellemeler için dosya değiştirme süreleri kontrol edilir. Bir dosya değiştiyse, sözlük güncelleştirilir. +Değişiklikleri kontrol etmek için Aralık `builtin_dictionaries_reload_interval` parametre. +Sözlük güncelleştirmeleri (ilk kullanımda yükleme dışında) sorguları engellemez. Güncelleştirmeler sırasında, sorgular sözlüklerin eski sürümlerini kullanır. Güncelleştirme sırasında bir hata oluşursa, hata sunucu günlüğüne yazılır ve sorgular sözlüklerin eski sürümünü kullanmaya devam eder. + +Sözlükleri geobase ile periyodik olarak güncellemenizi öneririz. Bir güncelleme sırasında yeni dosyalar oluşturun ve bunları ayrı bir konuma yazın. Her şey hazır olduğunda, bunları sunucu tarafından kullanılan dosyalara yeniden adlandırın. + +OS tanımlayıcıları ve Yandex ile çalışmak için işlevler de vardır.Metrica arama motorları, ancak kullanılmamalıdır. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/dicts/internal_dicts/) diff --git a/docs/tr/sql_reference/functions/arithmetic_functions.md b/docs/tr/sql_reference/functions/arithmetic_functions.md new file mode 100644 index 00000000000..594e9bd4699 --- /dev/null +++ b/docs/tr/sql_reference/functions/arithmetic_functions.md @@ -0,0 +1,87 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 35 +toc_title: Aritmetik +--- + +# Aritmetik fonksiyonlar {#arithmetic-functions} + +Tüm aritmetik işlevler için, sonuç türü, böyle bir tür varsa, sonucun sığdığı en küçük sayı türü olarak hesaplanır. Minimum, bit sayısına, imzalanıp imzalanmadığına ve yüzüp yüzmediğine bağlı olarak aynı anda alınır. Yeterli bit yoksa, en yüksek bit türü alınır. + +Örnek: + +``` sql +SELECT toTypeName(0), toTypeName(0 + 0), toTypeName(0 + 0 + 0), toTypeName(0 + 0 + 0 + 0) +``` + +``` text +┌─toTypeName(0)─┬─toTypeName(plus(0, 0))─┬─toTypeName(plus(plus(0, 0), 0))─┬─toTypeName(plus(plus(plus(0, 0), 0), 0))─┐ +│ UInt8 │ UInt16 │ UInt32 │ UInt64 │ +└───────────────┴────────────────────────┴─────────────────────────────────┴──────────────────────────────────────────┘ +``` + +Aritmetik fonksiyonlar, uint8, Uİnt16, Uİnt32, Uint64, Int8, Int16, Int32, Int64, Float32 veya Float64 türlerinden herhangi bir çift için çalışır. + +Taşma, C++ile aynı şekilde üretilir. + +## artı (a, b), A + B operatörü {#plusa-b-a-b-operator} + +Sayıların toplamını hesaplar. +Ayrıca bir tarih veya tarih ve Saat ile tamsayı numaraları ekleyebilirsiniz. Bir tarih durumunda, bir tamsayı eklemek, karşılık gelen gün sayısını eklemek anlamına gelir. Zamanla bir tarih için, karşılık gelen saniye sayısını eklemek anlamına gelir. + +## eksi (a, b), A - B operatörü {#minusa-b-a-b-operator} + +Farkı hesaplar. Sonuç her zaman imzalanır. + +You can also calculate integer numbers from a date or date with time. The idea is the same – see above for ‘plus’. + +## çarp operatorma (a, b), A \* B operatörü {#multiplya-b-a-b-operator} + +Sayıların ürününü hesaplar. + +## böl (a, b), A / B operatörü {#dividea-b-a-b-operator} + +Sayıların bölümünü hesaplar. Sonuç türü her zaman bir kayan nokta türüdür. +Tam sayı bölümü değildir. Tamsayı bölümü için, ‘intDiv’ işlev. +Sıfıra bölerek zaman olsun ‘inf’, ‘-inf’, veya ‘nan’. + +## ıntdiv(a, b) {#intdiva-b} + +Sayıların bölümünü hesaplar. Tamsayılara bölünür, yuvarlanır (mutlak değere göre). +Sıfıra bölünürken veya en az negatif sayıyı eksi bir ile bölürken bir istisna atılır. + +## ıntdivorzero(a, b) {#intdivorzeroa-b} + +Farklıdır ‘intDiv’ bu, sıfıra bölünürken veya en az bir negatif sayıyı eksi bir ile bölerek sıfır döndürür. + +## modulo (a, b), A % B operatörü {#moduloa-b-a-b-operator} + +Bölünmeden sonra kalan hesaplar. +Bağımsız değişkenler kayan nokta sayılarıysa, ondalık bölümü bırakarak tamsayılara önceden dönüştürülürler. +Kalan C++ile aynı anlamda alınır. Kesik bölme negatif sayılar için kullanılır. +Sıfıra bölünürken veya en az negatif sayıyı eksi bir ile bölürken bir istisna atılır. + +## moduloOrZero(a, b) {#moduloorzeroa-b} + +Farklıdır ‘modulo’ bölen sıfır olduğunda sıfır döndürür. + +## negate (a), - bir operatör {#negatea-a-operator} + +Ters işareti ile bir sayı hesaplar. Sonuç her zaman imzalanır. + +## abs (a) {#arithm_func-abs} + +\(A\) sayısının mutlak değerini hesaplar. Yani, \< 0 ise,- A döndürür. imzasız türler için hiçbir şey yapmaz. İmzalı tamsayı türleri için imzasız bir sayı döndürür. + +## gcd (a, b) {#gcda-b} + +Sayıların en büyük ortak böleni döndürür. +Sıfıra bölünürken veya en az negatif sayıyı eksi bir ile bölürken bir istisna atılır. + +## lcm(a, b) {#lcma-b} + +Sayıların en az ortak katını döndürür. +Sıfıra bölünürken veya en az negatif sayıyı eksi bir ile bölürken bir istisna atılır. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/arithmetic_functions/) diff --git a/docs/tr/sql_reference/functions/array_functions.md b/docs/tr/sql_reference/functions/array_functions.md new file mode 100644 index 00000000000..9e3221435ed --- /dev/null +++ b/docs/tr/sql_reference/functions/array_functions.md @@ -0,0 +1,1061 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 46 +toc_title: "Dizilerle \xE7al\u0131\u015Fma" +--- + +# Dizilerle çalışmak için işlevler {#functions-for-working-with-arrays} + +## boş {#function-empty} + +Boş bir dizi için 1 veya boş olmayan bir dizi için 0 döndürür. +Sonuç türü Uint8'dir. +İşlev ayrıca dizeler için de çalışır. + +## notEmpty {#function-notempty} + +Boş bir dizi için 0 veya boş olmayan bir dizi için 1 döndürür. +Sonuç türü Uint8'dir. +İşlev ayrıca dizeler için de çalışır. + +## uzunluk {#array_functions-length} + +Dizideki öğe sayısını döndürür. +Sonuç türü Uint64'tür. +İşlev ayrıca dizeler için de çalışır. + +## emptyArrayUİnt8, emptyArrayUİnt16, emptyArrayUİnt32, emptyArrayUİnt64 {#emptyarrayuint8-emptyarrayuint16-emptyarrayuint32-emptyarrayuint64} + +## emptyArrayİnt8, emptyArrayİnt16, emptyArrayİnt32, emptyArrayİnt64 {#emptyarrayint8-emptyarrayint16-emptyarrayint32-emptyarrayint64} + +## emptyArrayFloat32, emptyArrayFloat64 {#emptyarrayfloat32-emptyarrayfloat64} + +## emptyArrayDate, emptyArrayDateTime {#emptyarraydate-emptyarraydatetime} + +## emptyArrayString {#emptyarraystring} + +Sıfır bağımsız değişkeni kabul eder ve uygun türde boş bir dizi döndürür. + +## emptyArrayToSingle {#emptyarraytosingle} + +Boş bir dizi kabul eder ve varsayılan değere eşit bir tek öğe dizisi döndürür. + +## Aralık (bitiş), Aralık(başlangıç, bitiş \[, adım\]) {#rangeend-rangestart-end-step} + +1 Adım-başından sonuna kadar sayıların bir dizi döndürür. +Eğer argüman `start` belirtilmemiş, varsayılan olarak 0. +Eğer argüman `step` belirtilmemiş, varsayılan olarak 1. +Neredeyse pythonic gibi davranışlar `range`. Ancak fark, tüm argümanların tipinin olması gerektiğidir `UInt` şiir. +Bir veri bloğunda toplam uzunluğu 100.000.000'den fazla öğe olan diziler oluşturulursa, bir istisna atılır. + +## array(x1, …), operator \[x1, …\] {#arrayx1-operator-x1} + +İşlev bağımsız değişkenlerinden bir dizi oluşturur. +Bağımsız değişkenler sabit olmalı ve en küçük ortak türe sahip türlere sahip olmalıdır. En az bir argüman geçirilmelidir, çünkü aksi takdirde hangi tür dizinin oluşturulacağı açık değildir. Yani, boş bir dizi oluşturmak için bu işlevi kullanamazsınız (bunu yapmak için, ‘emptyArray\*’ fonksiyon yukarıda açıklandığı. +Ret anur anns an ‘Array(T)’ sonucu yazın, nerede ‘T’ geçirilen bağımsız değişkenlerin en küçük ortak türüdür. + +## arrayConcat {#arrayconcat} + +Argüman olarak geçirilen dizileri birleştirir. + +``` sql +arrayConcat(arrays) +``` + +**Parametre** + +- `arrays` – Arbitrary number of arguments of [Dizi](../../sql_reference/data_types/array.md) tür. + **Örnek** + + + +``` sql +SELECT arrayConcat([1, 2], [3, 4], [5, 6]) AS res +``` + +``` text +┌─res───────────┐ +│ [1,2,3,4,5,6] │ +└───────────────┘ +``` + +## arrayElement (arr, n), operatör arr\[n\] {#arrayelementarr-n-operator-arrn} + +İnd theex ile eleman alın `n` diz theiden `arr`. `n` herhangi bir tamsayı türü olmalıdır. +Bir dizideki dizinler birinden başlar. +Negatif dizinler desteklenir. Bu durumda, sondan numaralandırılmış ilgili elemanı seçer. Mesela, `arr[-1]` dizideki son öğedir. + +Dizin bir dizinin sınırlarının dışına düşerse, bazı varsayılan değer döndürür (sayılar için 0, dizeler için boş bir dize vb.).), sabit olmayan bir dizi ve sabit bir dizin 0 olan durum hariç (bu durumda bir hata olacaktır `Array indices are 1-based`). + +## has (arr, elem) {#hasarr-elem} + +Olup olmadığını denetler ‘arr’ dizi var ‘elem’ öğe. +Öğe dizide değilse 0 veya varsa 1 değerini döndürür. + +`NULL` değer olarak iş islenir. + +``` sql +SELECT has([1, 2, NULL], NULL) +``` + +``` text +┌─has([1, 2, NULL], NULL)─┐ +│ 1 │ +└─────────────────────────┘ +``` + +## hasAll {#hasall} + +Bir dizi başka bir alt kümesi olup olmadığını denetler. + +``` sql +hasAll(set, subset) +``` + +**Parametre** + +- `set` – Array of any type with a set of elements. +- `subset` – Array of any type with elements that should be tested to be a subset of `set`. + +**Dönüş değerleri** + +- `1`, eğer `set` tüm öğeleri içerir `subset`. +- `0`, başka. + +**Tuhaf özellikler** + +- Boş bir dizi, herhangi bir dizinin bir alt kümesidir. +- `Null` bir değer olarak işlenir. +- Her iki dizideki değerlerin sırası önemli değil. + +**Örnekler** + +`SELECT hasAll([], [])` döner 1. + +`SELECT hasAll([1, Null], [Null])` döner 1. + +`SELECT hasAll([1.0, 2, 3, 4], [1, 3])` döner 1. + +`SELECT hasAll(['a', 'b'], ['a'])` döner 1. + +`SELECT hasAll([1], ['a'])` 0 döndürür. + +`SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [3, 5]])` 0 döndürür. + +## hasAny {#hasany} + +İki dizinin bazı öğelerle kesiştiği olup olmadığını kontrol eder. + +``` sql +hasAny(array1, array2) +``` + +**Parametre** + +- `array1` – Array of any type with a set of elements. +- `array2` – Array of any type with a set of elements. + +**Dönüş değerleri** + +- `1`, eğer `array1` ve `array2` en azından benzer bir öğeye sahip olun. +- `0`, başka. + +**Tuhaf özellikler** + +- `Null` bir değer olarak işlenir. +- Her iki dizideki değerlerin sırası önemli değil. + +**Örnekler** + +`SELECT hasAny([1], [])` dönüşler `0`. + +`SELECT hasAny([Null], [Null, 1])` dönüşler `1`. + +`SELECT hasAny([-128, 1., 512], [1])` dönüşler `1`. + +`SELECT hasAny([[1, 2], [3, 4]], ['a', 'c'])` dönüşler `0`. + +`SELECT hasAll([[1, 2], [3, 4]], [[1, 2], [1, 2]])` dönüşler `1`. + +## ındexof(arr, x) {#indexofarr-x} + +İlk dizini döndürür ‘x’ dizide ise öğe (1'den başlayarak) veya değilse 0. + +Örnek: + +``` sql +SELECT indexOf([1, 3, NULL, NULL], NULL) +``` + +``` text +┌─indexOf([1, 3, NULL, NULL], NULL)─┐ +│ 3 │ +└───────────────────────────────────┘ +``` + +Elem setents set to `NULL` normal değerler olarak ele alınır. + +## countEqual(arr, x) {#countequalarr-x} + +X eşit dizideki öğelerin sayısını döndürür. Arraycount eşdeğer (elem - \> elem = x, arr). + +`NULL` öğeler ayrı değerler olarak işlenir. + +Örnek: + +``` sql +SELECT countEqual([1, 2, NULL, NULL], NULL) +``` + +``` text +┌─countEqual([1, 2, NULL, NULL], NULL)─┐ +│ 2 │ +└──────────────────────────────────────┘ +``` + +## arrayEnumerate(arr) {#array_functions-arrayenumerate} + +Returns the array \[1, 2, 3, …, length (arr) \] + +Bu işlev normalde ARRAY JOIN ile kullanılır. ARRAY JOİN uyguladıktan sonra her dizi için sadece bir kez bir şey saymaya izin verir. Örnek: + +``` sql +SELECT + count() AS Reaches, + countIf(num = 1) AS Hits +FROM test.hits +ARRAY JOIN + GoalsReached, + arrayEnumerate(GoalsReached) AS num +WHERE CounterID = 160656 +LIMIT 10 +``` + +``` text +┌─Reaches─┬──Hits─┐ +│ 95606 │ 31406 │ +└─────────┴───────┘ +``` + +Bu örnekte, Reaches dönüşümlerin sayısıdır (ARRAY JOİN uygulandıktan sonra alınan dizeler) ve İsabetler sayfa görüntüleme sayısıdır (ARRAY JOİN önce dizeler). Bu özel durumda, aynı sonucu daha kolay bir şekilde alabilirsiniz: + +``` sql +SELECT + sum(length(GoalsReached)) AS Reaches, + count() AS Hits +FROM test.hits +WHERE (CounterID = 160656) AND notEmpty(GoalsReached) +``` + +``` text +┌─Reaches─┬──Hits─┐ +│ 95606 │ 31406 │ +└─────────┴───────┘ +``` + +Bu fonksiyon aynı zamanda yüksek mertebeden fonksiyonlarda da kullanılabilir. Örneğin, bir koşulla eşleşen öğeler için dizi dizinleri almak için kullanabilirsiniz. + +## arrayEnumerateUniq(arr, …) {#arrayenumerateuniqarr} + +Kaynak diziyle aynı boyutta bir dizi döndürür ve her öğe için aynı değere sahip öğeler arasında konumunun ne olduğunu gösterir. +Örneğin: arrayEnumerateUniq(\[10, 20, 10, 30\]) = \[1, 1, 2, 1\]. + +Bu işlev, dizi birleştirme ve dizi öğelerinin toplanmasını kullanırken kullanışlıdır. +Örnek: + +``` sql +SELECT + Goals.ID AS GoalID, + sum(Sign) AS Reaches, + sumIf(Sign, num = 1) AS Visits +FROM test.visits +ARRAY JOIN + Goals, + arrayEnumerateUniq(Goals.ID) AS num +WHERE CounterID = 160656 +GROUP BY GoalID +ORDER BY Reaches DESC +LIMIT 10 +``` + +``` text +┌──GoalID─┬─Reaches─┬─Visits─┐ +│ 53225 │ 3214 │ 1097 │ +│ 2825062 │ 3188 │ 1097 │ +│ 56600 │ 2803 │ 488 │ +│ 1989037 │ 2401 │ 365 │ +│ 2830064 │ 2396 │ 910 │ +│ 1113562 │ 2372 │ 373 │ +│ 3270895 │ 2262 │ 812 │ +│ 1084657 │ 2262 │ 345 │ +│ 56599 │ 2260 │ 799 │ +│ 3271094 │ 2256 │ 812 │ +└─────────┴─────────┴────────┘ +``` + +Bu örnekte, her hedef kimliğinin dönüşüm sayısı (hedefler iç içe geçmiş veri yapısındaki her öğe, bir dönüşüm olarak adlandırdığımız ulaşılan bir hedeftir) ve oturum sayısı Hesaplaması vardır. ARRAY JOİN olmadan, oturum sayısını sum(Sign) olarak sayardık. Ancak bu özel durumda, satırlar iç içe geçmiş hedefler yapısıyla çarpıldı, bu nedenle her oturumu bir kez saymak için arrayenumerateuniq değerine bir koşul uyguluyoruz(Goals.ID) fonksiyonu. + +Arrayenumerateuniq işlevi, bağımsız değişkenlerle aynı boyutta birden çok dizi alabilir. Bu durumda, tüm dizilerde aynı konumlardaki elemanların tuplesleri için benzersizlik düşünülür. + +``` sql +SELECT arrayEnumerateUniq([1, 1, 1, 2, 2, 2], [1, 1, 2, 1, 1, 2]) AS res +``` + +``` text +┌─res───────────┐ +│ [1,2,1,1,2,1] │ +└───────────────┘ +``` + +Bu, iç içe geçmiş bir veri yapısı ve bu yapıdaki birden çok öğe arasında daha fazla toplama ile dizi birleşimini kullanırken gereklidir. + +## arrayPopBack {#arraypopback} + +Son öğeyi diziden kaldırır. + +``` sql +arrayPopBack(array) +``` + +**Parametre** + +- `array` – Array. + +**Örnek** + +``` sql +SELECT arrayPopBack([1, 2, 3]) AS res +``` + +``` text +┌─res───┐ +│ [1,2] │ +└───────┘ +``` + +## arrayPopFront {#arraypopfront} + +İlk öğeyi diziden kaldırır. + +``` sql +arrayPopFront(array) +``` + +**Parametre** + +- `array` – Array. + +**Örnek** + +``` sql +SELECT arrayPopFront([1, 2, 3]) AS res +``` + +``` text +┌─res───┐ +│ [2,3] │ +└───────┘ +``` + +## arrayPushBack {#arraypushback} + +Dizinin sonuna bir öğe ekler. + +``` sql +arrayPushBack(array, single_value) +``` + +**Parametre** + +- `array` – Array. +- `single_value` – A single value. Only numbers can be added to an array with numbers, and only strings can be added to an array of strings. When adding numbers, ClickHouse automatically sets the `single_value` dizinin veri türü için yazın. Clickhouse'daki veri türleri hakkında daha fazla bilgi için bkz. “[Veri türleri](../../sql_reference/data_types/index.md#data_types)”. Olabilir `NULL`. Fonksiyon bir ekler `NULL` bir dizi için öğe ve dizi öğeleri türü dönüştürür `Nullable`. + +**Örnek** + +``` sql +SELECT arrayPushBack(['a'], 'b') AS res +``` + +``` text +┌─res───────┐ +│ ['a','b'] │ +└───────────┘ +``` + +## arrayPushFront {#arraypushfront} + +Dizinin başına bir öğe ekler. + +``` sql +arrayPushFront(array, single_value) +``` + +**Parametre** + +- `array` – Array. +- `single_value` – A single value. Only numbers can be added to an array with numbers, and only strings can be added to an array of strings. When adding numbers, ClickHouse automatically sets the `single_value` dizinin veri türü için yazın. Clickhouse'daki veri türleri hakkında daha fazla bilgi için bkz. “[Veri türleri](../../sql_reference/data_types/index.md#data_types)”. Olabilir `NULL`. Fonksiyon bir ekler `NULL` bir dizi için öğe ve dizi öğeleri türü dönüştürür `Nullable`. + +**Örnek** + +``` sql +SELECT arrayPushFront(['b'], 'a') AS res +``` + +``` text +┌─res───────┐ +│ ['a','b'] │ +└───────────┘ +``` + +## arrayResize {#arrayresize} + +Dizinin uzunluğunu değiştirir. + +``` sql +arrayResize(array, size[, extender]) +``` + +**Parametre:** + +- `array` — Array. +- `size` — Required length of the array. + - Eğer `size` dizinin orijinal boyutundan daha az, dizi sağdan kesilir. +- Eğer `size` dizinin başlangıç boyutundan daha büyük, dizi sağa uzatılır `extender` dizi öğelerinin veri türü için değerler veya varsayılan değerler. +- `extender` — Value for extending an array. Can be `NULL`. + +**Döndürülen değer:** + +Bir dizi uzunluk `size`. + +**Arama örnekleri** + +``` sql +SELECT arrayResize([1], 3) +``` + +``` text +┌─arrayResize([1], 3)─┐ +│ [1,0,0] │ +└─────────────────────┘ +``` + +``` sql +SELECT arrayResize([1], 3, NULL) +``` + +``` text +┌─arrayResize([1], 3, NULL)─┐ +│ [1,NULL,NULL] │ +└───────────────────────────┘ +``` + +## arraySlice {#arrayslice} + +Dizinin bir dilimini döndürür. + +``` sql +arraySlice(array, offset[, length]) +``` + +**Parametre** + +- `array` – Array of data. +- `offset` – Indent from the edge of the array. A positive value indicates an offset on the left, and a negative value is an indent on the right. Numbering of the array items begins with 1. +- `length` - Gerekli dilimin uzunluğu. Negatif bir değer belirtirseniz, işlev açık bir dilim döndürür `[offset, array_length - length)`. Değeri atlarsanız, işlev dilimi döndürür `[offset, the_end_of_array]`. + +**Örnek** + +``` sql +SELECT arraySlice([1, 2, NULL, 4, 5], 2, 3) AS res +``` + +``` text +┌─res────────┐ +│ [2,NULL,4] │ +└────────────┘ +``` + +Ar arrayray elem toents set to `NULL` normal değerler olarak ele alınır. + +## arraySort(\[func,\] arr, …) {#array_functions-sort} + +Elemanları sıralar `arr` artan düzende dizi. Eğer... `func` fonksiyonu belirtilir, sıralama düzeni sonucu belirlenir `func` fonksiyon dizinin elemanlarına uygulanır. Eğer `func` birden fazla argüman kabul eder, `arraySort` fonksiyon argümanları birkaç diziler geçirilir `func` karşılık gelir. Ayrıntılı örnekler sonunda gösterilir `arraySort` açıklama. + +Tamsayı değerleri sıralama örneği: + +``` sql +SELECT arraySort([1, 3, 3, 0]); +``` + +``` text +┌─arraySort([1, 3, 3, 0])─┐ +│ [0,1,3,3] │ +└─────────────────────────┘ +``` + +Dize değerleri sıralama örneği: + +``` sql +SELECT arraySort(['hello', 'world', '!']); +``` + +``` text +┌─arraySort(['hello', 'world', '!'])─┐ +│ ['!','hello','world'] │ +└────────────────────────────────────┘ +``` + +Aşağıdaki sıralama sırasını göz önünde bulundurun `NULL`, `NaN` ve `Inf` değerler: + +``` sql +SELECT arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]); +``` + +``` text +┌─arraySort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf])─┐ +│ [-inf,-4,1,2,3,inf,nan,nan,NULL,NULL] │ +└───────────────────────────────────────────────────────────┘ +``` + +- `-Inf` değerler dizide ilk sırada yer alır. +- `NULL` değerler dizideki son değerlerdir. +- `NaN` değerler hemen önce `NULL`. +- `Inf` değerler hemen önce `NaN`. + +Not thate that `arraySort` is a [yüksek sipariş fonksiyonu](higher_order_functions.md). Bir lambda işlevini ilk argüman olarak iletebilirsiniz. Bu durumda, sıralama sırası, dizinin elemanlarına uygulanan lambda işlevinin sonucu ile belirlenir. + +Aşağıdaki örneği ele alalım: + +``` sql +SELECT arraySort((x) -> -x, [1, 2, 3]) as res; +``` + +``` text +┌─res─────┐ +│ [3,2,1] │ +└─────────┘ +``` + +For each element of the source array, the lambda function returns the sorting key, that is, \[1 –\> -1, 2 –\> -2, 3 –\> -3\]. Since the `arraySort` fonksiyon tuşları artan sırayla sıralar, sonuç \[3, 2, 1\]. Böylece, `(x) –> -x` lambda fonksiyonu setleri [azalan düzen](#array_functions-reverse-sort) bir sıralama içinde. + +Lambda işlevi birden çok bağımsız değişken kabul edebilir. Bu durumda, geçmek gerekir `arraySort` işlev lambda işlevinin argümanlarının karşılık geleceği aynı uzunlukta birkaç dizi. Elde edilen dizi ilk giriş dizisinden elemanlardan oluşacaktır; bir sonraki giriş dizilerinden elemanlar sıralama anahtarlarını belirtir. Mesela: + +``` sql +SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]) as res; +``` + +``` text +┌─res────────────────┐ +│ ['world', 'hello'] │ +└────────────────────┘ +``` + +Burada, ikinci dizide (\[2, 1\]) geçirilen öğeler, kaynak diziden karşılık gelen öğe için bir sıralama anahtarı tanımlar (\[‘hello’, ‘world’\]), bu, \[‘hello’ –\> 2, ‘world’ –\> 1\]. Since the lambda function doesn't use `x`, kaynak dizinin gerçek değerleri sonuçtaki sırayı etkilemez. Böyle, ‘hello’ sonuçtaki ikinci eleman olacak ve ‘world’ ilk olacak. + +Diğer örnekler aşağıda gösterilmiştir. + +``` sql +SELECT arraySort((x, y) -> y, [0, 1, 2], ['c', 'b', 'a']) as res; +``` + +``` text +┌─res─────┐ +│ [2,1,0] │ +└─────────┘ +``` + +``` sql +SELECT arraySort((x, y) -> -y, [0, 1, 2], [1, 2, 3]) as res; +``` + +``` text +┌─res─────┐ +│ [2,1,0] │ +└─────────┘ +``` + +!!! note "Not" + Sıralama verimliliğini artırmak için, [Schwartzian dönüşümü](https://en.wikipedia.org/wiki/Schwartzian_transform) kullanılır. + +## arrayReverseSort(\[func,\] arr, …) {#array_functions-reverse-sort} + +Elemanları sıralar `arr` azalan sırayla dizi. Eğer... `func` fonksiyon belirtilir, `arr` sonucuna göre sıra islanır. `func` işlev dizinin öğelerine uygulanır ve sonra sıralanmış dizi tersine çevrilir. Eğer `func` birden fazla argüman kabul eder, `arrayReverseSort` fonksiyon argümanları birkaç diziler geçirilir `func` karşılık gelir. Ayrıntılı örnekler sonunda gösterilir `arrayReverseSort` açıklama. + +Tamsayı değerleri sıralama örneği: + +``` sql +SELECT arrayReverseSort([1, 3, 3, 0]); +``` + +``` text +┌─arrayReverseSort([1, 3, 3, 0])─┐ +│ [3,3,1,0] │ +└────────────────────────────────┘ +``` + +Dize değerleri sıralama örneği: + +``` sql +SELECT arrayReverseSort(['hello', 'world', '!']); +``` + +``` text +┌─arrayReverseSort(['hello', 'world', '!'])─┐ +│ ['world','hello','!'] │ +└───────────────────────────────────────────┘ +``` + +Aşağıdaki sıralama sırasını göz önünde bulundurun `NULL`, `NaN` ve `Inf` değerler: + +``` sql +SELECT arrayReverseSort([1, nan, 2, NULL, 3, nan, -4, NULL, inf, -inf]) as res; +``` + +``` text +┌─res───────────────────────────────────┐ +│ [inf,3,2,1,-4,-inf,nan,nan,NULL,NULL] │ +└───────────────────────────────────────┘ +``` + +- `Inf` değerler dizide ilk sırada yer alır. +- `NULL` değerler dizideki son değerlerdir. +- `NaN` değerler hemen önce `NULL`. +- `-Inf` değerler hemen önce `NaN`. + +Not `arrayReverseSort` is a [yüksek sipariş fonksiyonu](higher_order_functions.md). Bir lambda işlevini ilk argüman olarak iletebilirsiniz. Örnek aşağıda gösterilmiştir. + +``` sql +SELECT arrayReverseSort((x) -> -x, [1, 2, 3]) as res; +``` + +``` text +┌─res─────┐ +│ [1,2,3] │ +└─────────┘ +``` + +Dizi aşağıdaki şekilde sıralanır: + +1. İlk başta, kaynak dizi (\[1, 2, 3\]), dizinin elemanlarına uygulanan lambda işlevinin sonucuna göre sıralanır. Sonuç bir dizidir \[3, 2, 1\]. +2. Önceki adımda elde edilen dizi tersine çevrilir. Yani, nihai sonuç \[1, 2, 3\]. + +Lambda işlevi birden çok bağımsız değişken kabul edebilir. Bu durumda, geçmek gerekir `arrayReverseSort` işlev lambda işlevinin argümanlarının karşılık geleceği aynı uzunlukta birkaç dizi. Elde edilen dizi ilk giriş dizisinden elemanlardan oluşacaktır; bir sonraki giriş dizilerinden elemanlar sıralama anahtarlarını belirtir. Mesela: + +``` sql +SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res; +``` + +``` text +┌─res───────────────┐ +│ ['hello','world'] │ +└───────────────────┘ +``` + +Bu örnekte, dizi aşağıdaki şekilde sıralanır: + +1. İlk başta, kaynak dizi (\[‘hello’, ‘world’\]) dizilerin elemanlarına uygulanan lambda işlevinin sonucuna göre sıralanır. İkinci dizide geçirilen öğeler (\[2, 1\]), kaynak diziden karşılık gelen öğeler için sıralama anahtarlarını tanımlar. Sonuç bir dizidir \[‘world’, ‘hello’\]. +2. Önceki adımda sıralanmış dizi tersine çevrilir. Yani, nihai sonuç \[‘hello’, ‘world’\]. + +Diğer örnekler aşağıda gösterilmiştir. + +``` sql +SELECT arrayReverseSort((x, y) -> y, [4, 3, 5], ['a', 'b', 'c']) AS res; +``` + +``` text +┌─res─────┐ +│ [5,3,4] │ +└─────────┘ +``` + +``` sql +SELECT arrayReverseSort((x, y) -> -y, [4, 3, 5], [1, 2, 3]) AS res; +``` + +``` text +┌─res─────┐ +│ [4,3,5] │ +└─────────┘ +``` + +## arrayUniq(arr, …) {#arrayuniqarr} + +Bir bağımsız değişken geçirilirse, dizideki farklı öğelerin sayısını sayar. +Birden çok bağımsız değişken geçirilirse, birden çok dizideki karşılık gelen konumlardaki farklı öğe kümelerinin sayısını sayar. + +Bir dizideki benzersiz öğelerin bir listesini almak istiyorsanız, arrayreduce kullanabilirsiniz(‘groupUniqArray’, arr). + +## arrayJoin(arr) {#array-functions-join} + +Özel bir işlev. Bölümüne bakınız [“ArrayJoin function”](array_join.md#functions_arrayjoin). + +## arrayDifference {#arraydifference} + +Bitişik dizi öğeleri arasındaki farkı hesaplar. İlk öğenin 0 olacağı bir dizi döndürür, ikincisi arasındaki farktır `a[1] - a[0]`, etc. The type of elements in the resulting array is determined by the type inference rules for subtraction (e.g. `UInt8` - `UInt8` = `Int16`). + +**Sözdizimi** + +``` sql +arrayDifference(array) +``` + +**Parametre** + +- `array` – [Dizi](https://clickhouse.yandex/docs/en/data_types/array/). + +**Döndürülen değerler** + +Bitişik öğeler arasındaki farklar dizisini döndürür. + +Tür: [Uİnt\*](https://clickhouse.yandex/docs/en/data_types/int_uint/#uint-ranges), [Tamsayı\*](https://clickhouse.yandex/docs/en/data_types/int_uint/#int-ranges), [Yüzdürmek\*](https://clickhouse.yandex/docs/en/data_types/float/). + +**Örnek** + +Sorgu: + +``` sql +SELECT arrayDifference([1, 2, 3, 4]) +``` + +Sonuç: + +``` text +┌─arrayDifference([1, 2, 3, 4])─┐ +│ [0,1,1,1] │ +└───────────────────────────────┘ +``` + +Sonuç türü Int64 nedeniyle taşma örneği: + +Sorgu: + +``` sql +SELECT arrayDifference([0, 10000000000000000000]) +``` + +Sonuç: + +``` text +┌─arrayDifference([0, 10000000000000000000])─┐ +│ [0,-8446744073709551616] │ +└────────────────────────────────────────────┘ +``` + +## arrayDistinct {#arraydistinct} + +Bir dizi alır, yalnızca farklı öğeleri içeren bir dizi döndürür. + +**Sözdizimi** + +``` sql +arrayDistinct(array) +``` + +**Parametre** + +- `array` – [Dizi](https://clickhouse.yandex/docs/en/data_types/array/). + +**Döndürülen değerler** + +Farklı öğeleri içeren bir dizi döndürür. + +**Örnek** + +Sorgu: + +``` sql +SELECT arrayDistinct([1, 2, 2, 3, 1]) +``` + +Sonuç: + +``` text +┌─arrayDistinct([1, 2, 2, 3, 1])─┐ +│ [1,2,3] │ +└────────────────────────────────┘ +``` + +## arrayEnumerateDense(arr) {#array_functions-arrayenumeratedense} + +Kaynak diziyle aynı boyutta bir dizi döndürür ve her öğenin kaynak dizide ilk olarak nerede göründüğünü gösterir. + +Örnek: + +``` sql +SELECT arrayEnumerateDense([10, 20, 10, 30]) +``` + +``` text +┌─arrayEnumerateDense([10, 20, 10, 30])─┐ +│ [1,2,1,3] │ +└───────────────────────────────────────┘ +``` + +## arrayıntersect(arr) {#array-functions-arrayintersect} + +Birden çok dizi alır, tüm kaynak dizilerde bulunan öğeleri içeren bir dizi döndürür. Elde edilen dizideki öğeler sırası ilk dizideki ile aynıdır. + +Örnek: + +``` sql +SELECT + arrayIntersect([1, 2], [1, 3], [2, 3]) AS no_intersect, + arrayIntersect([1, 2], [1, 3], [1, 4]) AS intersect +``` + +``` text +┌─no_intersect─┬─intersect─┐ +│ [] │ [1] │ +└──────────────┴───────────┘ +``` + +## arrayReduce {#arrayreduce} + +Dizi öğelerine bir toplama işlevi uygular ve sonucunu döndürür. Toplama işlevinin adı, tek tırnak içinde bir dize olarak geçirilir `'max'`, `'sum'`. Parametrik toplama işlevleri kullanıldığında, parametre parantez içinde işlev adından sonra gösterilir `'uniqUpTo(6)'`. + +**Sözdizimi** + +``` sql +arrayReduce(agg_func, arr1, arr2, ..., arrN) +``` + +**Parametre** + +- `agg_func` — The name of an aggregate function which should be a constant [dize](../../sql_reference/data_types/string.md). +- `arr` — Any number of [dizi](../../sql_reference/data_types/array.md) sütunları toplama işlevinin parametreleri olarak yazın. + +**Döndürülen değer** + +**Örnek** + +``` sql +SELECT arrayReduce('max', [1, 2, 3]) +``` + +``` text +┌─arrayReduce('max', [1, 2, 3])─┐ +│ 3 │ +└───────────────────────────────┘ +``` + +Bir toplama işlevi birden çok bağımsız değişken alırsa, bu işlev aynı boyuttaki birden çok diziye uygulanmalıdır. + +``` sql +SELECT arrayReduce('maxIf', [3, 5], [1, 0]) +``` + +``` text +┌─arrayReduce('maxIf', [3, 5], [1, 0])─┐ +│ 3 │ +└──────────────────────────────────────┘ +``` + +Parametrik toplama fonksiyonu ile örnek: + +``` sql +SELECT arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) +``` + +``` text +┌─arrayReduce('uniqUpTo(3)', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])─┐ +│ 4 │ +└─────────────────────────────────────────────────────────────┘ +``` + +## arrayReduceİnRanges {#arrayreduceinranges} + +Belirli aralıklardaki dizi öğelerine bir toplama işlevi uygular ve her aralığa karşılık gelen sonucu içeren bir dizi döndürür. Fonksiyon aynı sonucu birden fazla olarak döndürür `arrayReduce(agg_func, arraySlice(arr1, index, length), ...)`. + +**Sözdizimi** + +``` sql +arrayReduceInRanges(agg_func, ranges, arr1, arr2, ..., arrN) +``` + +**Parametre** + +- `agg_func` — The name of an aggregate function which should be a constant [dize](../../sql_reference/data_types/string.md). +- `ranges` — The ranges to aggretate which should be an [dizi](../../sql_reference/data_types/array.md) -den [Demetler](../../sql_reference/data_types/tuple.md) indeks ve her aralığın uzunluğunu içeren. +- `arr` — Any number of [dizi](../../sql_reference/data_types/array.md) sütunları toplama işlevinin parametreleri olarak yazın. + +**Döndürülen değer** + +**Örnek** + +``` sql +SELECT arrayReduceInRanges( + 'sum', + [(1, 5), (2, 3), (3, 4), (4, 4)], + [1000000, 200000, 30000, 4000, 500, 60, 7] +) AS res +``` + +``` text +┌─res─────────────────────────┐ +│ [1234500,234000,34560,4567] │ +└─────────────────────────────┘ +``` + +## arrayReverse(arr) {#arrayreverse} + +Öğeleri ters sırada içeren orijinal diziyle aynı boyutta bir dizi döndürür. + +Örnek: + +``` sql +SELECT arrayReverse([1, 2, 3]) +``` + +``` text +┌─arrayReverse([1, 2, 3])─┐ +│ [3,2,1] │ +└─────────────────────────┘ +``` + +## ters (arr) {#array-functions-reverse} + +Eşanlamlı [“arrayReverse”](#array_functions-arrayreverse) + +## arrayFlatten {#arrayflatten} + +Bir dizi diziyi düz bir diziye dönüştürür. + +İşlev: + +- İç içe geçmiş dizilerin herhangi bir derinliği için geçerlidir. +- Zaten düz olan dizileri değiştirmez. + +Düzleştirilmiş dizi, tüm kaynak dizilerdeki tüm öğeleri içerir. + +**Sözdizimi** + +``` sql +flatten(array_of_arrays) +``` + +Takma ad: `flatten`. + +**Parametre** + +- `array_of_arrays` — [Dizi](../../sql_reference/data_types/array.md) dizilerin. Mesela, `[[1,2,3], [4,5]]`. + +**Örnekler** + +``` sql +SELECT flatten([[[1]], [[2], [3]]]) +``` + +``` text +┌─flatten(array(array([1]), array([2], [3])))─┐ +│ [1,2,3] │ +└─────────────────────────────────────────────┘ +``` + +## arrayCompact {#arraycompact} + +Ardışık yinelenen öğeleri bir diziden kaldırır. Sonuç değerlerinin sırası, kaynak dizideki sıraya göre belirlenir. + +**Sözdizimi** + +``` sql +arrayCompact(arr) +``` + +**Parametre** + +`arr` — The [dizi](../../sql_reference/data_types/array.md) incelemek. + +**Döndürülen değer** + +Yinelenen olmadan dizi. + +Tür: `Array`. + +**Örnek** + +Sorgu: + +``` sql +SELECT arrayCompact([1, 1, nan, nan, 2, 3, 3, 3]) +``` + +Sonuç: + +``` text +┌─arrayCompact([1, 1, nan, nan, 2, 3, 3, 3])─┐ +│ [1,nan,nan,2,3] │ +└────────────────────────────────────────────┘ +``` + +## arrayZip {#arrayzip} + +Birden çok diziyi tek bir dizide birleştirir. Elde edilen dizi, listelenen bağımsız değişken sırasına göre gruplandırılmış kaynak dizilerin karşılık gelen öğelerini içerir. + +**Sözdizimi** + +``` sql +arrayZip(arr1, arr2, ..., arrN) +``` + +**Parametre** + +- `arrN` — [Dizi](../data_types/array.md). + +İşlev, farklı türde herhangi bir dizi alabilir. Tüm giriş dizileri eşit boyutta olmalıdır. + +**Döndürülen değer** + +- Gruplandırılmış kaynak dizilerden öğelerle dizi [Demetler](../data_types/tuple.md). Veri türleri tuple giriş dizileri türleri ile aynıdır ve diziler geçirilir aynı sırada. + +Tür: [Dizi](../data_types/array.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT arrayZip(['a', 'b', 'c'], [5, 2, 1]) +``` + +Sonuç: + +``` text +┌─arrayZip(['a', 'b', 'c'], [5, 2, 1])─┐ +│ [('a',5),('b',2),('c',1)] │ +└──────────────────────────────────────┘ +``` + +## arrayAUC {#arrayauc} + +Auc'yi hesaplayın (makine öğreniminde bir kavram olan eğrinin altındaki alan, daha fazla ayrıntıya bakın: https://en.wikipedia.org/wiki/Receiver\_operating\_characteristic\#Area\_under\_the\_curve). + +**Sözdizimi** + +``` sql +arrayAUC(arr_scores, arr_labels) +``` + +**Parametre** +- `arr_scores` — scores prediction model gives. +- `arr_labels` — labels of samples, usually 1 for positive sample and 0 for negtive sample. + +**Döndürülen değer** +Float64 türü ile AUC değerini döndürür. + +**Örnek** +Sorgu: + +``` sql +select arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1]) +``` + +Sonuç: + +``` text +┌─arrayAUC([0.1, 0.4, 0.35, 0.8], [0, 0, 1, 1])─┐ +│ 0.75 │ +└────────────────────────────────────────---──┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/array_functions/) diff --git a/docs/tr/sql_reference/functions/array_join.md b/docs/tr/sql_reference/functions/array_join.md new file mode 100644 index 00000000000..f59ed95805b --- /dev/null +++ b/docs/tr/sql_reference/functions/array_join.md @@ -0,0 +1,37 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 61 +toc_title: arrayJoin +--- + +# arrayjoin işlevi {#functions_arrayjoin} + +Bu çok sıradışı bir işlevdir. + +Normal işlevler bir dizi satırı değiştirmez, ancak her satırdaki değerleri değiştirir (harita). +Toplama işlevleri bir dizi satırı sıkıştırır (katlayın veya azaltın). +Bu ‘arrayJoin’ işlev her satırı alır ve bir dizi satır oluşturur (açılır). + +Bu işlev bir diziyi bağımsız değişken olarak alır ve kaynak satırı dizideki öğe sayısı için birden çok satıra yayar. +Sütunlardaki tüm değerler, bu işlevin uygulandığı sütundaki değerler dışında kopyalanır; karşılık gelen dizi değeri ile değiştirilir. + +Bir sorgu birden çok kullanabilirsiniz `arrayJoin` işlevler. Bu durumda, dönüşüm birden çok kez gerçekleştirilir. + +Daha geniş olanaklar sağlayan SELECT sorgusunda dizi birleştirme sözdizimini not alın. + +Örnek: + +``` sql +SELECT arrayJoin([1, 2, 3] AS src) AS dst, 'Hello', src +``` + +``` text +┌─dst─┬─\'Hello\'─┬─src─────┐ +│ 1 │ Hello │ [1,2,3] │ +│ 2 │ Hello │ [1,2,3] │ +│ 3 │ Hello │ [1,2,3] │ +└─────┴───────────┴─────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/array_join/) diff --git a/docs/tr/sql_reference/functions/bit_functions.md b/docs/tr/sql_reference/functions/bit_functions.md new file mode 100644 index 00000000000..1e8d9761d5d --- /dev/null +++ b/docs/tr/sql_reference/functions/bit_functions.md @@ -0,0 +1,255 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 48 +toc_title: Bitlik +--- + +# Bit fonksiyonları {#bit-functions} + +Bit işlevleri, uint8, Uİnt16, Uİnt32, Uint64, Int8, Int16, Int32, Int64, Float32 veya Float64 türlerinden herhangi bir çift için çalışır. + +Sonuç türü, bağımsız değişkenlerinin maksimum bitlerine eşit bit içeren bir tamsayıdır. Bağımsız değişkenlerden en az biri imzalanırsa, sonuç imzalı bir sayıdır. Bir bağımsız değişken bir kayan noktalı sayı ise, Int64 için cast. + +## bıtor(a, b) {#bitanda-b} + +## bitOr(a, b) {#bitora-b} + +## bitXor(a, b) {#bitxora-b} + +## bitNot (a) {#bitnota} + +## bitShiftLeft(a, b) {#bitshiftlefta-b} + +## bitShiftRight(a, b) {#bitshiftrighta-b} + +## bitRotateLeft(a, b) {#bitrotatelefta-b} + +## bitRotateRight(a, b) {#bitrotaterighta-b} + +## bitTest {#bittest} + +Herhangi bir tamsayı alır ve dönüştürür [ikili form](https://en.wikipedia.org/wiki/Binary_number), belirtilen konumda bir bit değerini döndürür. Geri sayım sağdan sola 0 başlar. + +**Sözdizimi** + +``` sql +SELECT bitTest(number, index) +``` + +**Parametre** + +- `number` – integer number. +- `index` – position of bit. + +**Döndürülen değerler** + +Belirtilen konumda bit değeri döndürür. + +Tür: `UInt8`. + +**Örnek** + +Örneğin, taban-2 (ikili) sayı sistemindeki 43 sayısı 101011'dir. + +Sorgu: + +``` sql +SELECT bitTest(43, 1) +``` + +Sonuç: + +``` text +┌─bitTest(43, 1)─┐ +│ 1 │ +└────────────────┘ +``` + +Başka bir örnek: + +Sorgu: + +``` sql +SELECT bitTest(43, 2) +``` + +Sonuç: + +``` text +┌─bitTest(43, 2)─┐ +│ 0 │ +└────────────────┘ +``` + +## bitTestAll {#bittestall} + +Sonucu döndürür [mantıksal conjuction](https://en.wikipedia.org/wiki/Logical_conjunction) Verilen pozisyonlarda tüm bitlerin (ve operatörü). Geri sayım sağdan sola 0 başlar. + +Bitsel işlemler için conjuction: + +0 AND 0 = 0 + +0 AND 1 = 0 + +1 AND 0 = 0 + +1 AND 1 = 1 + +**Sözdizimi** + +``` sql +SELECT bitTestAll(number, index1, index2, index3, index4, ...) +``` + +**Parametre** + +- `number` – integer number. +- `index1`, `index2`, `index3`, `index4` – positions of bit. For example, for set of positions (`index1`, `index2`, `index3`, `index4`) doğru ise ve sadece tüm pozisyon trueları doğru ise (`index1` ⋀ `index2`, ⋀ `index3` ⋀ `index4`). + +**Döndürülen değerler** + +Mantıksal conjuction sonucunu döndürür. + +Tür: `UInt8`. + +**Örnek** + +Örneğin, taban-2 (ikili) sayı sistemindeki 43 sayısı 101011'dir. + +Sorgu: + +``` sql +SELECT bitTestAll(43, 0, 1, 3, 5) +``` + +Sonuç: + +``` text +┌─bitTestAll(43, 0, 1, 3, 5)─┐ +│ 1 │ +└────────────────────────────┘ +``` + +Başka bir örnek: + +Sorgu: + +``` sql +SELECT bitTestAll(43, 0, 1, 3, 5, 2) +``` + +Sonuç: + +``` text +┌─bitTestAll(43, 0, 1, 3, 5, 2)─┐ +│ 0 │ +└───────────────────────────────┘ +``` + +## bitTestAny {#bittestany} + +Sonucu döndürür [mantıksal ayrılma](https://en.wikipedia.org/wiki/Logical_disjunction) Verilen konumlardaki tüm bitlerin (veya operatör). Geri sayım sağdan sola 0 başlar. + +Bitsel işlemler için ayrılma: + +0 OR 0 = 0 + +0 OR 1 = 1 + +1 OR 0 = 1 + +1 OR 1 = 1 + +**Sözdizimi** + +``` sql +SELECT bitTestAny(number, index1, index2, index3, index4, ...) +``` + +**Parametre** + +- `number` – integer number. +- `index1`, `index2`, `index3`, `index4` – positions of bit. + +**Döndürülen değerler** + +Mantıksal disjuction sonucunu döndürür. + +Tür: `UInt8`. + +**Örnek** + +Örneğin, taban-2 (ikili) sayı sistemindeki 43 sayısı 101011'dir. + +Sorgu: + +``` sql +SELECT bitTestAny(43, 0, 2) +``` + +Sonuç: + +``` text +┌─bitTestAny(43, 0, 2)─┐ +│ 1 │ +└──────────────────────┘ +``` + +Başka bir örnek: + +Sorgu: + +``` sql +SELECT bitTestAny(43, 4, 2) +``` + +Sonuç: + +``` text +┌─bitTestAny(43, 4, 2)─┐ +│ 0 │ +└──────────────────────┘ +``` + +## bitCount {#bitcount} + +Bir sayının ikili gösteriminde birine ayarlanmış bit sayısını hesaplar. + +**Sözdizimi** + +``` sql +bitCount(x) +``` + +**Parametre** + +- `x` — [Tamsayı](../../sql_reference/data_types/int_uint.md) veya [kayan nokta](../../sql_reference/data_types/float.md) numara. İşlev, bellekteki değer gösterimini kullanır. Kayan noktalı sayıları desteklemeye izin verir. + +**Döndürülen değer** + +- Giriş numarasında birine ayarlanmış bit sayısı. + +İşlev, giriş değerini daha büyük bir türe dönüştürmez ([işaret uzantısı](https://en.wikipedia.org/wiki/Sign_extension)). Bu yüzden, örneğin , `bitCount(toUInt8(-1)) = 8`. + +Tür: `UInt8`. + +**Örnek** + +Örneğin 333 sayısını alın. İkili gösterimi: 0000000101001101. + +Sorgu: + +``` sql +SELECT bitCount(333) +``` + +Sonuç: + +``` text +┌─bitCount(333)─┐ +│ 5 │ +└───────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/bit_functions/) diff --git a/docs/tr/sql_reference/functions/bitmap_functions.md b/docs/tr/sql_reference/functions/bitmap_functions.md new file mode 100644 index 00000000000..1b4fb53e0e3 --- /dev/null +++ b/docs/tr/sql_reference/functions/bitmap_functions.md @@ -0,0 +1,496 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 49 +toc_title: "E\u015Flem" +--- + +# Bitmap işlevleri {#bitmap-functions} + +Bitmap işlevleri iki bit eşlemler nesne değeri hesaplama için çalışmak, yeni bitmap veya kardinality formül hesaplama, and, or, xor ve not, vb gibi kullanırken döndürmektir. + +Bitmap nesnesi için 2 çeşit inşaat yöntemi vardır. Biri-State ile toplama işlevi groupBitmap tarafından inşa edilecek, diğeri Array nesnesi tarafından inşa edilecek. Ayrıca bitmap nesnesini dizi nesnesine dönüştürmektir. + +Roaringbitmap, Bitmap nesnelerinin gerçek depolanması sırasında bir veri yapısına sarılır. Önemlilik 32'den küçük veya eşit olduğunda, Set objet kullanır. Kardinality 32'den büyük olduğunda, roaringbitmap nesnesi kullanır. Bu nedenle düşük kardinalite kümesinin depolanması daha hızlıdır. + +RoaringBitmap hakkında daha fazla bilgi için bkz: [CRoaring](https://github.com/RoaringBitmap/CRoaring). + +## bitmapBuild {#bitmap_functions-bitmapbuild} + +İmzasız tamsayı dizisinden bir bit eşlem oluşturun. + +``` sql +bitmapBuild(array) +``` + +**Parametre** + +- `array` – unsigned integer array. + +**Örnek** + +``` sql +SELECT bitmapBuild([1, 2, 3, 4, 5]) AS res, toTypeName(res) +``` + +``` text +┌─res─┬─toTypeName(bitmapBuild([1, 2, 3, 4, 5]))─────┐ +│  │ AggregateFunction(groupBitmap, UInt8) │ +└─────┴──────────────────────────────────────────────┘ +``` + +## bitmapToArray {#bitmaptoarray} + +Bitmap'i tamsayı dizisine dönüştürün. + +``` sql +bitmapToArray(bitmap) +``` + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapToArray(bitmapBuild([1, 2, 3, 4, 5])) AS res +``` + +``` text +┌─res─────────┐ +│ [1,2,3,4,5] │ +└─────────────┘ +``` + +## bitmapsubsetınrange {#bitmap-functions-bitmapsubsetinrange} + +Belirtilen aralıktaki alt kümesi döndürür (range\_end içermez). + +``` sql +bitmapSubsetInRange(bitmap, range_start, range_end) +``` + +**Parametre** + +- `bitmap` – [Bitmap nesnesi](#bitmap_functions-bitmapbuild). +- `range_start` – range start point. Type: [Uİnt32](../../sql_reference/data_types/int_uint.md). +- `range_end` – range end point(excluded). Type: [Uİnt32](../../sql_reference/data_types/int_uint.md). + +**Örnek** + +``` sql +SELECT bitmapToArray(bitmapSubsetInRange(bitmapBuild([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,100,200,500]), toUInt32(30), toUInt32(200))) AS res +``` + +``` text +┌─res───────────────┐ +│ [30,31,32,33,100] │ +└───────────────────┘ +``` + +## bitmapSubsetLimit {#bitmapsubsetlimit} + +Arasında alınan n öğeleri ile bitmap bir alt kümesi oluşturur `range_start` ve `cardinality_limit`. + +**Sözdizimi** + +``` sql +bitmapSubsetLimit(bitmap, range_start, cardinality_limit) +``` + +**Parametre** + +- `bitmap` – [Bitmap nesnesi](#bitmap_functions-bitmapbuild). +- `range_start` – The subset starting point. Type: [Uİnt32](../../sql_reference/data_types/int_uint.md). +- `cardinality_limit` – The subset cardinality upper limit. Type: [Uİnt32](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değer** + +Alt. + +Tür: `Bitmap object`. + +**Örnek** + +Sorgu: + +``` sql +SELECT bitmapToArray(bitmapSubsetLimit(bitmapBuild([0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,100,200,500]), toUInt32(30), toUInt32(200))) AS res +``` + +Sonuç: + +``` text +┌─res───────────────────────┐ +│ [30,31,32,33,100,200,500] │ +└───────────────────────────┘ +``` + +## bitmapContains {#bitmap_functions-bitmapcontains} + +Bit eşlem bir öğe içerip içermediğini denetler. + +``` sql +bitmapContains(haystack, needle) +``` + +**Parametre** + +- `haystack` – [Bitmap nesnesi](#bitmap_functions-bitmapbuild), fonksiyon arar nerede. +- `needle` – Value that the function searches. Type: [Uİnt32](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değerler** + +- 0 — If `haystack` içermez `needle`. +- 1 — If `haystack` içeriyor `needle`. + +Tür: `UInt8`. + +**Örnek** + +``` sql +SELECT bitmapContains(bitmapBuild([1,5,7,9]), toUInt32(9)) AS res +``` + +``` text +┌─res─┐ +│ 1 │ +└─────┘ +``` + +## bitmapHasAny {#bitmaphasany} + +İki bit eşlemin bazı öğelerle kesiştiği olup olmadığını kontrol eder. + +``` sql +bitmapHasAny(bitmap1, bitmap2) +``` + +Eğer eminseniz `bitmap2` kesinlikle bir öğe içerir, kullanmayı düşünün [bitmapContains](#bitmap_functions-bitmapcontains) işlev. Daha verimli çalışır. + +**Parametre** + +- `bitmap*` – bitmap object. + +**Dönüş değerleri** + +- `1`, eğer `bitmap1` ve `bitmap2` en azından benzer bir öğeye sahip olun. +- `0`, başka. + +**Örnek** + +``` sql +SELECT bitmapHasAny(bitmapBuild([1,2,3]),bitmapBuild([3,4,5])) AS res +``` + +``` text +┌─res─┐ +│ 1 │ +└─────┘ +``` + +## bitmapHasAll {#bitmaphasall} + +Benzer `hasAll(array, array)` ilk bit eşlem, ikincisinin tüm öğelerini içeriyorsa, 1 değerini döndürür, aksi halde 0. +İkinci bağımsız değişken boş bir bit eşlem ise, 1 döndürür. + +``` sql +bitmapHasAll(bitmap,bitmap) +``` + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapHasAll(bitmapBuild([1,2,3]),bitmapBuild([3,4,5])) AS res +``` + +``` text +┌─res─┐ +│ 0 │ +└─────┘ +``` + +## bitmapCardinality {#bitmapcardinality} + +Retrun bit eşlem kardinalite türü Uİnt64. + +``` sql +bitmapCardinality(bitmap) +``` + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapCardinality(bitmapBuild([1, 2, 3, 4, 5])) AS res +``` + +``` text +┌─res─┐ +│ 5 │ +└─────┘ +``` + +## bitmapMin {#bitmapmin} + +Kümedeki uint64 türünün en küçük değerini yeniden çalıştırın, küme boşsa UİNT32\_MAX. + + bitmapMin(bitmap) + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapMin(bitmapBuild([1, 2, 3, 4, 5])) AS res +``` + + ┌─res─┐ + │ 1 │ + └─────┘ + +## bitmapMax {#bitmapmax} + +Küme boşsa, kümedeki uint64 türünün en büyük değerini 0 olarak yeniden çalıştırın. + + bitmapMax(bitmap) + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapMax(bitmapBuild([1, 2, 3, 4, 5])) AS res +``` + + ┌─res─┐ + │ 5 │ + └─────┘ + +## bitmapTransform {#bitmaptransform} + +Bitmap'teki bir değer dizisini başka bir değer dizisine dönüştürün, sonuç yeni bir bitmap'tir. + + bitmapTransform(bitmap, from_array, to_array) + +**Parametre** + +- `bitmap` – bitmap object. +- `from_array` – UInt32 array. For idx in range \[0, from\_array.size()), if bitmap contains from\_array\[idx\], then replace it with to\_array\[idx\]. Note that the result depends on array ordering if there are common elements between from\_array and to\_array. +- `to_array` – UInt32 array, its size shall be the same to from\_array. + +**Örnek** + +``` sql +SELECT bitmapToArray(bitmapTransform(bitmapBuild([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), cast([5,999,2] as Array(UInt32)), cast([2,888,20] as Array(UInt32)))) AS res +``` + + ┌─res───────────────────┐ + │ [1,3,4,6,7,8,9,10,20] │ + └───────────────────────┘ + +## bitmapAnd {#bitmapand} + +İki bitmap ve hesaplama, sonuç yeni bir bitmap'tir. + +``` sql +bitmapAnd(bitmap,bitmap) +``` + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapToArray(bitmapAnd(bitmapBuild([1,2,3]),bitmapBuild([3,4,5]))) AS res +``` + +``` text +┌─res─┐ +│ [3] │ +└─────┘ +``` + +## bitmapOr {#bitmapor} + +İki bitmap veya hesaplama, sonuç yeni bir bitmap'tir. + +``` sql +bitmapOr(bitmap,bitmap) +``` + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapToArray(bitmapOr(bitmapBuild([1,2,3]),bitmapBuild([3,4,5]))) AS res +``` + +``` text +┌─res─────────┐ +│ [1,2,3,4,5] │ +└─────────────┘ +``` + +## bitmapXor {#bitmapxor} + +İki bitmap XOR hesaplama, sonuç yeni bir bitmap. + +``` sql +bitmapXor(bitmap,bitmap) +``` + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapToArray(bitmapXor(bitmapBuild([1,2,3]),bitmapBuild([3,4,5]))) AS res +``` + +``` text +┌─res───────┐ +│ [1,2,4,5] │ +└───────────┘ +``` + +## bitmapAndnot {#bitmapandnot} + +İki bit eşlem andnot hesaplama, sonuç yeni bir bit eşlem. + +``` sql +bitmapAndnot(bitmap,bitmap) +``` + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapToArray(bitmapAndnot(bitmapBuild([1,2,3]),bitmapBuild([3,4,5]))) AS res +``` + +``` text +┌─res───┐ +│ [1,2] │ +└───────┘ +``` + +## bitmapAndCardinality {#bitmapandcardinality} + +İki bitmap ve hesaplama, uint64 türünün kardinalliğini döndürür. + +``` sql +bitmapAndCardinality(bitmap,bitmap) +``` + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapAndCardinality(bitmapBuild([1,2,3]),bitmapBuild([3,4,5])) AS res; +``` + +``` text +┌─res─┐ +│ 1 │ +└─────┘ +``` + +## bitmapOrCardinality {#bitmaporcardinality} + +İki bitmap veya hesaplama, uint64 türünün kardinalliğini döndürür. + +``` sql +bitmapOrCardinality(bitmap,bitmap) +``` + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapOrCardinality(bitmapBuild([1,2,3]),bitmapBuild([3,4,5])) AS res; +``` + +``` text +┌─res─┐ +│ 5 │ +└─────┘ +``` + +## bitmapXorCardinality {#bitmapxorcardinality} + +İki bitmap XOR hesaplama, uint64 türünün kardinalliğini döndürür. + +``` sql +bitmapXorCardinality(bitmap,bitmap) +``` + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapXorCardinality(bitmapBuild([1,2,3]),bitmapBuild([3,4,5])) AS res; +``` + +``` text +┌─res─┐ +│ 4 │ +└─────┘ +``` + +## bitmapAndnotCardinality {#bitmapandnotcardinality} + +İki bitmap andnot hesaplama, uint64 türünün kardinalliğini döndürür. + +``` sql +bitmapAndnotCardinality(bitmap,bitmap) +``` + +**Parametre** + +- `bitmap` – bitmap object. + +**Örnek** + +``` sql +SELECT bitmapAndnotCardinality(bitmapBuild([1,2,3]),bitmapBuild([3,4,5])) AS res; +``` + +``` text +┌─res─┐ +│ 2 │ +└─────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/bitmap_functions/) diff --git a/docs/tr/sql_reference/functions/comparison_functions.md b/docs/tr/sql_reference/functions/comparison_functions.md new file mode 100644 index 00000000000..d041459bb05 --- /dev/null +++ b/docs/tr/sql_reference/functions/comparison_functions.md @@ -0,0 +1,37 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 36 +toc_title: "Kar\u015F\u0131la\u015Ft\u0131rma" +--- + +# Karşılaştırma fonksiyonları {#comparison-functions} + +Karşılaştırma işlevleri her zaman 0 veya 1 (Uint8) döndürür. + +Aşağıdaki türler karşılaştırılabilir: + +- şiir +- dizeler ve sabit dizeler +- tarihliler +- tarihleri ile saatleri + +her grup içinde, ancak farklı gruplar arasında değil. + +Örneğin, bir tarihi bir dizeyle karşılaştıramazsınız. Bir tarih dizesi dönüştürmek, ya da tam tersi bir işlev kullanmak zorunda. + +Dizeler baytlarla karşılaştırılır. Daha kısa bir dize, onunla başlayan ve en az bir karakter daha içeren tüm dizelerden daha küçüktür. + +## eşittir, a = b VE a = = B operatörü {#function-equals} + +## notEquals, a ! operatör = b VE A \<\> b {#function-notequals} + +## l ,ess, \< operat \ operatör {#function-greater} + +## lessOrEquals, \< = operatör {#function-lessorequals} + +## greaterOrEquals, \> = operatör {#function-greaterorequals} + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/comparison_functions/) diff --git a/docs/tr/sql_reference/functions/conditional_functions.md b/docs/tr/sql_reference/functions/conditional_functions.md new file mode 100644 index 00000000000..b2e918666a0 --- /dev/null +++ b/docs/tr/sql_reference/functions/conditional_functions.md @@ -0,0 +1,207 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 43 +toc_title: "Ko\u015Fullu " +--- + +# Koşullu fonksiyonlar {#conditional-functions} + +## eğer {#if} + +Koşullu dallanmayı kontrol eder. Çoğu sistemin aksine, ClickHouse her zaman her iki ifadeyi de değerlendirir `then` ve `else`. + +**Sözdizimi** + +``` sql +SELECT if(cond, then, else) +``` + +Eğer durum `cond` sıfır olmayan bir değere değerlendirir, ifadenin sonucunu döndürür `then` ve ifad andenin sonucu `else` varsa, atlanır. Eğer... `cond` sıfır veya `NULL` fakat daha sonra sonucu `then` ifade atlanır ve sonucu `else` Ifade, varsa, döndürülür. + +**Parametre** + +- `cond` – The condition for evaluation that can be zero or not. The type is UInt8, Nullable(UInt8) or NULL. +- `then` - Koşul karşılanırsa dönmek için ifade. +- `else` - Koşul karşılanmazsa dönmek için ifade. + +**Döndürülen değerler** + +İşlev yürütür `then` ve `else` ifadeler ve koşulun olup olmadığına bağlı olarak sonucunu döndürür `cond` sıfır ya da değil. + +**Örnek** + +Sorgu: + +``` sql +SELECT if(1, plus(2, 2), plus(2, 6)) +``` + +Sonuç: + +``` text +┌─plus(2, 2)─┐ +│ 4 │ +└────────────┘ +``` + +Sorgu: + +``` sql +SELECT if(0, plus(2, 2), plus(2, 6)) +``` + +Sonuç: + +``` text +┌─plus(2, 6)─┐ +│ 8 │ +└────────────┘ +``` + +- `then` ve `else` en düşük ortak türe sahip olmalıdır. + +**Örnek:** + +Bunu al `LEFT_RIGHT` Tablo: + +``` sql +SELECT * +FROM LEFT_RIGHT + +┌─left─┬─right─┐ +│ ᴺᵁᴸᴸ │ 4 │ +│ 1 │ 3 │ +│ 2 │ 2 │ +│ 3 │ 1 │ +│ 4 │ ᴺᵁᴸᴸ │ +└──────┴───────┘ +``` + +Aşağıdaki sorgu karşılaştırır `left` ve `right` değerler: + +``` sql +SELECT + left, + right, + if(left < right, 'left is smaller than right', 'right is greater or equal than left') AS is_smaller +FROM LEFT_RIGHT +WHERE isNotNull(left) AND isNotNull(right) + +┌─left─┬─right─┬─is_smaller──────────────────────────┐ +│ 1 │ 3 │ left is smaller than right │ +│ 2 │ 2 │ right is greater or equal than left │ +│ 3 │ 1 │ right is greater or equal than left │ +└──────┴───────┴─────────────────────────────────────┘ +``` + +Not: `NULL` bu örnekte değerler kullanılmaz, kontrol edin [Koşullardaki boş değerler](#null-values-in-conditionals) bölme. + +## Üçlü Operatör {#ternary-operator} + +Aynı gibi çalışıyor. `if` işlev. + +Sözdizimi: `cond ? then : else` + +Dönüşler `then` eğer... `cond` true (sıfırdan büyük) olarak değerlendirir, aksi takdirde döndürür `else`. + +- `cond` türü olmalıdır `UInt8`, ve `then` ve `else` en düşük ortak türe sahip olmalıdır. + +- `then` ve `else` olabilir `NULL` + +**Ayrıca bakınız** + +- [ifNotFinite](other_functions.md#ifnotfinite). + +## multiİf {#multiif} + +Yaz allowsmanızı sağlar [CASE](../operators.md#operator_case) operatör sorguda daha kompakt. + +Sözdizimi: `multiIf(cond_1, then_1, cond_2, then_2, ..., else)` + +**Parametre:** + +- `cond_N` — The condition for the function to return `then_N`. +- `then_N` — The result of the function when executed. +- `else` — The result of the function if none of the conditions is met. + +İşlev kabul eder `2N+1` parametre. + +**Döndürülen değerler** + +İşlev, değerlerden birini döndürür `then_N` veya `else` bu koşullara bağlı olarak `cond_N`. + +**Örnek** + +Yine kullanarak `LEFT_RIGHT` Tablo. + +``` sql +SELECT + left, + right, + multiIf(left < right, 'left is smaller', left > right, 'left is greater', left = right, 'Both equal', 'Null value') AS result +FROM LEFT_RIGHT + +┌─left─┬─right─┬─result──────────┐ +│ ᴺᵁᴸᴸ │ 4 │ Null value │ +│ 1 │ 3 │ left is smaller │ +│ 2 │ 2 │ Both equal │ +│ 3 │ 1 │ left is greater │ +│ 4 │ ᴺᵁᴸᴸ │ Null value │ +└──────┴───────┴─────────────────┘ +``` + +## Koşullu sonuçları doğrudan kullanma {#using-conditional-results-directly} + +Koşullar her zaman sonuç `0`, `1` veya `NULL`. Böylece koşullu sonuçları doğrudan bu şekilde kullanabilirsiniz: + +``` sql +SELECT left < right AS is_small +FROM LEFT_RIGHT + +┌─is_small─┐ +│ ᴺᵁᴸᴸ │ +│ 1 │ +│ 0 │ +│ 0 │ +│ ᴺᵁᴸᴸ │ +└──────────┘ +``` + +## Koşullardaki boş değerler {#null-values-in-conditionals} + +Ne zaman `NULL` değerler koşullarla ilgilidir, sonuç da olacaktır `NULL`. + +``` sql +SELECT + NULL < 1, + 2 < NULL, + NULL < NULL, + NULL = NULL + +┌─less(NULL, 1)─┬─less(2, NULL)─┬─less(NULL, NULL)─┬─equals(NULL, NULL)─┐ +│ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ +└───────────────┴───────────────┴──────────────────┴────────────────────┘ +``` + +Bu nedenle, sorgularınızı türleri dikkatli bir şekilde oluşturmalısınız `Nullable`. + +Aşağıdaki örnek, eşittir koşulu eklemek başarısız tarafından bu gösterir `multiIf`. + +``` sql +SELECT + left, + right, + multiIf(left < right, 'left is smaller', left > right, 'right is smaller', 'Both equal') AS faulty_result +FROM LEFT_RIGHT + +┌─left─┬─right─┬─faulty_result────┐ +│ ᴺᵁᴸᴸ │ 4 │ Both equal │ +│ 1 │ 3 │ left is smaller │ +│ 2 │ 2 │ Both equal │ +│ 3 │ 1 │ right is smaller │ +│ 4 │ ᴺᵁᴸᴸ │ Both equal │ +└──────┴───────┴──────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/conditional_functions/) diff --git a/docs/tr/sql_reference/functions/date_time_functions.md b/docs/tr/sql_reference/functions/date_time_functions.md new file mode 100644 index 00000000000..fdcbacc7749 --- /dev/null +++ b/docs/tr/sql_reference/functions/date_time_functions.md @@ -0,0 +1,450 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 39 +toc_title: "Tarih ve Saatlerle \xE7al\u0131\u015Fma" +--- + +# Tarih ve saatlerle çalışmak için işlevler {#functions-for-working-with-dates-and-times} + +Saat dilimleri için destek + +Saat dilimi için mantıksal kullanımı olan tarih ve Saat ile çalışmak için tüm işlevler, ikinci bir isteğe bağlı saat dilimi bağımsız değişkeni kabul edebilir. Örnek: Asya / Yekaterinburg. Bu durumda, yerel (varsayılan) yerine belirtilen saat dilimini kullanırlar. + +``` sql +SELECT + toDateTime('2016-06-15 23:00:00') AS time, + toDate(time) AS date_local, + toDate(time, 'Asia/Yekaterinburg') AS date_yekat, + toString(time, 'US/Samoa') AS time_samoa +``` + +``` text +┌────────────────time─┬─date_local─┬─date_yekat─┬─time_samoa──────────┐ +│ 2016-06-15 23:00:00 │ 2016-06-15 │ 2016-06-16 │ 2016-06-15 09:00:00 │ +└─────────────────────┴────────────┴────────────┴─────────────────────┘ +``` + +UTC'DEN saat sayısına göre farklı olan yalnızca saat dilimleri desteklenir. + +## toTimeZone {#totimezone} + +Saat veya tarih ve saati belirtilen saat dilimine dönüştürün. + +## toYear {#toyear} + +Bir tarihi veya tarihi zamanla yıl numarasını (AD) içeren bir Uınt16 numarasına dönüştürür. + +## toQuarter {#toquarter} + +Bir tarihi veya tarihi zaman ile çeyrek sayısını içeren bir Uİnt8 numarasına dönüştürür. + +## toMonth {#tomonth} + +Bir tarih veya tarih ile saati, ay numarasını (1-12) içeren bir Uİnt8 numarasına dönüştürür. + +## bugünyıl {#todayofyear} + +Bir tarih veya tarih ile saat, yılın gün sayısını (1-366) içeren bir Uınt16 numarasına dönüştürür. + +## bugünay {#todayofmonth} + +Bir tarih veya tarih ile saat, Ayın gün sayısını (1-31) içeren bir Uınt8 numarasına dönüştürür. + +## bugünhafta {#todayofweek} + +Bir tarih veya tarih ile saat, haftanın gününün sayısını içeren bir Uınt8 numarasına dönüştürür (Pazartesi 1 ve pazar 7'dir). + +## toHour {#tohour} + +Saatli bir tarihi, 24 saatlik süre (0-23) saat sayısını içeren bir Uınt8 numarasına dönüştürür. +This function assumes that if clocks are moved ahead, it is by one hour and occurs at 2 a.m., and if clocks are moved back, it is by one hour and occurs at 3 a.m. (which is not always true – even in Moscow the clocks were twice changed at a different time). + +## toMinute {#tominute} + +Saatli bir tarihi, saatin dakika sayısını (0-59) içeren bir Uınt8 numarasına dönüştürür. + +## toSecond {#tosecond} + +Dakika (0-59) ikinci sayısını içeren bir uınt8 numarasına zaman ile bir tarih dönüştürür. +Sıçrama saniye hesaba değildir. + +## toUnixTimestamp {#to-unix-timestamp} + +DateTime argümanı için: değeri dahili sayısal gösterimine dönüştürür (Unıx Zaman Damgası). +String argümanı için: datetime'ı dizeden saat dilimine göre ayrıştırın (isteğe bağlı ikinci argüman, sunucu zaman dilimi varsayılan olarak kullanılır) ve karşılık gelen unıx zaman damgasını döndürür. +Tarih argümanı için: davranış belirtilmemiş. + +**Sözdizimi** + +``` sql +toUnixTimestamp(datetime) +toUnixTimestamp(str, [timezone]) +``` + +**Döndürülen değer** + +- Unix zaman damgasını döndürür. + +Tür: `UInt32`. + +**Örnek** + +Sorgu: + +``` sql +SELECT toUnixTimestamp('2017-11-05 08:07:47', 'Asia/Tokyo') AS unix_timestamp +``` + +Sonuç: + +``` text +┌─unix_timestamp─┐ +│ 1509836867 │ +└────────────────┘ +``` + +## toStartOfYear {#tostartofyear} + +Yılın ilk gününe kadar bir tarih veya tarih aşağı yuvarlar. +Tarihi döndürür. + +## toStartOfİSOYear {#tostartofisoyear} + +ISO yılın ilk gününe kadar bir tarih veya tarih aşağı yuvarlar. +Tarihi döndürür. + +## toStartOfQuarter {#tostartofquarter} + +Çeyrek ilk güne kadar bir tarih veya tarih aşağı yuvarlar. +Çeyreğin ilk günü 1 Ocak, 1 Nisan, 1 Temmuz veya 1 ekim'dir. +Tarihi döndürür. + +## toStartOfMonth {#tostartofmonth} + +Ayın ilk gününe kadar bir tarih veya tarih aşağı yuvarlar. +Tarihi döndürür. + +!!! attention "Dikkat" + Yanlış tarihleri ayrıştırma davranışı uygulamaya özeldir. ClickHouse sıfır tarihi döndürebilir, bir istisna atabilir veya yapabilir “natural” taşmak. + +## toMonday {#tomonday} + +En yakın Pazartesi günü bir tarih veya tarih aşağı yuvarlar. +Tarihi döndürür. + +## toStartOfWeek(t \[, mod\]) {#tostartofweektmode} + +Modu ile en yakın pazar veya Pazartesi zaman bir tarih veya tarih aşağı yuvarlar. +Tarihi döndürür. +Mod bağımsız değişkeni, toWeek () için mod bağımsız değişkeni gibi çalışır. Tek bağımsız değişken sözdizimi için 0 mod değeri kullanılır. + +## toStartOfDay {#tostartofday} + +Günün başlangıcına kadar bir tarih aşağı yuvarlar. + +## toStartOfHour {#tostartofhour} + +Saat başlangıcına kadar bir tarih aşağı yuvarlar. + +## toStartOfMinute {#tostartofminute} + +Dakikanın başlangıcına kadar bir tarih aşağı yuvarlar. + +## toStartOfFiveMinute {#tostartoffiveminute} + +Beş dakikalık aralığın başlangıcına kadar bir tarih aşağı yuvarlar. + +## toStartOfTenMinutes {#tostartoftenminutes} + +On dakikalık aralığın başlangıcına kadar bir tarih aşağı yuvarlar. + +## toStartOfFifteenMinutes {#tostartoffifteenminutes} + +On beş dakikalık aralığın başlangıcına kadar tarih aşağı yuvarlar. + +## toStartOfİnterval (time\_or\_data, Aralık x birimi \[, time\_zone\]) {#tostartofintervaltime-or-data-interval-x-unit-time-zone} + +Bu, diğer işlevlerin bir genellemesidir `toStartOf*`. Mesela, +`toStartOfInterval(t, INTERVAL 1 year)` aynı döndürür `toStartOfYear(t)`, +`toStartOfInterval(t, INTERVAL 1 month)` aynı döndürür `toStartOfMonth(t)`, +`toStartOfInterval(t, INTERVAL 1 day)` aynı döndürür `toStartOfDay(t)`, +`toStartOfInterval(t, INTERVAL 15 minute)` aynı döndürür `toStartOfFifteenMinutes(t)` vb. + +## toTime {#totime} + +Belirli bir sabit tarihe zaman ile bir tarih dönüştürür, zaman korurken. + +## toRelativeYearNum {#torelativeyearnum} + +Geçmişte belirli bir sabit noktadan başlayarak, yıl sayısına saat veya tarih ile bir tarih dönüştürür. + +## toRelativeQuarterNum {#torelativequarternum} + +Geçmişte belirli bir sabit noktadan başlayarak, çeyrek sayısına saat veya tarih ile bir tarih dönüştürür. + +## toRelativeMonthNum {#torelativemonthnum} + +Geçmişte belirli bir sabit noktadan başlayarak, Ayın sayısına saat veya tarih ile bir tarih dönüştürür. + +## toRelativeWeekNum {#torelativeweeknum} + +Geçmişte belirli bir sabit noktadan başlayarak, haftanın sayısına saat veya tarih ile bir tarih dönüştürür. + +## toRelativeDayNum {#torelativedaynum} + +Geçmişte belirli bir sabit noktadan başlayarak, günün sayısına saat veya tarih ile bir tarih dönüştürür. + +## toRelativeHourNum {#torelativehournum} + +Geçmişte belirli bir sabit noktadan başlayarak, saat veya tarih ile bir tarih saat sayısına dönüştürür. + +## toRelativeMinuteNum {#torelativeminutenum} + +Geçmişte belirli bir sabit noktadan başlayarak, dakika sayısına saat veya tarih ile bir tarih dönüştürür. + +## toRelativeSecondNum {#torelativesecondnum} + +Geçmişte belirli bir sabit noktadan başlayarak, ikinci sayısına saat veya tarih ile bir tarih dönüştürür. + +## toİSOYear {#toisoyear} + +ISO yıl numarasını içeren bir uınt16 numarasına bir tarih veya tarih zaman dönüştürür. + +## toİSOWeek {#toisoweek} + +ISO hafta numarasını içeren bir uınt8 numarasına bir tarih veya tarih zaman dönüştürür. + +## toWeek (tarih \[, mod\]) {#toweekdatemode} + +Bu işlev, date veya datetime için hafta numarasını döndürür. ToWeek () ' in iki bağımsız değişkenli formu, haftanın pazar veya Pazartesi günü başlayıp başlamadığını ve dönüş değerinin 0 ile 53 arasında mı yoksa 1 ile 53 arasında mı olması gerektiğini belirlemenizi sağlar. Mod bağımsız değişkeni atlanırsa, varsayılan mod 0'dır. +`toISOWeek()`eşdeğer bir uyumluluk işlevidir `toWeek(date,3)`. +Aşağıdaki tabloda mod bağımsız değişkeni nasıl çalıştığını açıklar. + +| Modu | Haftanın ilk günü | Aralık | Week 1 is the first week … | +|------|-------------------|--------|----------------------------------| +| 0 | Pazar | 0-53 | bu yıl bir pazar günü ile | +| 1 | Pazartesi | 0-53 | bu yıl 4 veya daha fazla gün ile | +| 2 | Pazar | 1-53 | bu yıl bir pazar günü ile | +| 3 | Pazartesi | 1-53 | bu yıl 4 veya daha fazla gün ile | +| 4 | Pazar | 0-53 | bu yıl 4 veya daha fazla gün ile | +| 5 | Pazartesi | 0-53 | bu yıl bir Pazartesi ile | +| 6 | Pazar | 1-53 | bu yıl 4 veya daha fazla gün ile | +| 7 | Pazartesi | 1-53 | bu yıl bir Pazartesi ile | +| 8 | Pazar | 1-53 | 1 Ocak içerir | +| 9 | Pazartesi | 1-53 | 1 Ocak içerir | + +Bir anlamı olan mod değerleri için “with 4 or more days this year,” haftalar ISO 8601: 1988'e göre numaralandırılmıştır: + +- 1 Ocak içeren haftanın yeni yılda 4 veya daha fazla günü varsa, 1. haftadır. + +- Aksi takdirde, bir önceki yılın son haftasıdır ve bir sonraki hafta 1. haftadır. + +Bir anlamı olan mod değerleri için “contains January 1”, 1 Ocak haftanın 1.haft .asıdır. Haftanın yeni yılda kaç gün içerdiği önemli değil, sadece bir gün içerse bile. + +``` sql +toWeek(date, [, mode][, Timezone]) +``` + +**Parametre** + +- `date` – Date or DateTime. +- `mode` – Optional parameter, Range of values is \[0,9\], default is 0. +- `Timezone` – Optional parameter, it behaves like any other conversion function. + +**Örnek** + +``` sql +SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9; +``` + +``` text +┌───────date─┬─week0─┬─week1─┬─week9─┐ +│ 2016-12-27 │ 52 │ 52 │ 1 │ +└────────────┴───────┴───────┴───────┘ +``` + +## toYearWeek (tarih \[, mod\]) {#toyearweekdatemode} + +Bir tarih için yıl ve hafta döndürür. Sonuçtaki yıl, yılın ilk ve son haftası için tarih argümanındaki yıldan farklı olabilir. + +Mod bağımsız değişkeni, toWeek () için mod bağımsız değişkeni gibi çalışır. Tek bağımsız değişken sözdizimi için 0 mod değeri kullanılır. + +`toISOYear()`eşdeğer bir uyumluluk işlevidir `intDiv(toYearWeek(date,3),100)`. + +**Örnek** + +``` sql +SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(date,1) AS yearWeek1, toYearWeek(date,9) AS yearWeek9; +``` + +``` text +┌───────date─┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┐ +│ 2016-12-27 │ 201652 │ 201652 │ 201701 │ +└────────────┴───────────┴───────────┴───────────┘ +``` + +## şimdi {#now} + +Sıfır bağımsız değişkeni kabul eder ve geçerli saati istek yürütme anlarından birinde döndürür. +Bu işlev, isteğin tamamlanması uzun zaman alsa bile bir sabit döndürür. + +## bugünkü {#today} + +Sıfır bağımsız değişkeni kabul eder ve geçerli tarihi, istek yürütme anlarından birinde döndürür. +Olarak aynı ‘toDate(now())’. + +## dün {#yesterday} + +Sıfır bağımsız değişkeni kabul eder ve istek yürütme anlarından birinde dünün tarihini döndürür. +Olarak aynı ‘today() - 1’. + +## zaman dilimi {#timeslot} + +Yarım saat için zaman yuvarlar. +Bu fonksiyon (kayıt olmak için özeldir.Metrica, yarım saat, bir izleme etiketi, tek bir kullanıcının ardışık sayfa görüntülemelerini, zaman içinde bu miktardan kesinlikle daha fazla farklılık gösteriyorsa, bir oturumu iki oturuma bölmek için minimum zaman miktarıdır. Bu, ilgili oturumda bulunan sayfa görüntülemelerini aramak için tuples (etiket kimliği, kullanıcı kimliği ve zaman dilimi) kullanılabileceği anlamına gelir. + +## toYYYYMM {#toyyyymm} + +Bir tarih veya tarih ile saat, yıl ve ay numarasını (YYYY \* 100 + MM) içeren bir Uınt32 numarasına dönüştürür. + +## toYYYYMMDD {#toyyyymmdd} + +Bir tarih veya tarih ile saat, yıl ve ay numarasını içeren bir Uınt32 numarasına dönüştürür (YYYY \* 10000 + MM \* 100 + DD). + +## toYYYYMMDDhhmmss {#toyyyymmddhhmmss} + +Bir tarihi veya tarihi, yıl ve ay numarasını içeren bir Uınt64 numarasına dönüştürür (YYYY \* 1000000 + MM \* 1000000 + DD \* 1000000 + hh \* 10000 + mm \* 100 + ss). + +## addYears, addMonths, addWeeks, addDays, addHours, addMinutes, addSeconds, addQuarters {#addyears-addmonths-addweeks-adddays-addhours-addminutes-addseconds-addquarters} + +İşlev, bir tarih/DateTime aralığına bir tarih/DateTime ekler ve ardından Tarih/Datetime'ı döndürür. Mesela: + +``` sql +WITH + toDate('2018-01-01') AS date, + toDateTime('2018-01-01 00:00:00') AS date_time +SELECT + addYears(date, 1) AS add_years_with_date, + addYears(date_time, 1) AS add_years_with_date_time +``` + +``` text +┌─add_years_with_date─┬─add_years_with_date_time─┐ +│ 2019-01-01 │ 2019-01-01 00:00:00 │ +└─────────────────────┴──────────────────────────┘ +``` + +## subtractYears, subtractMonths, subtractWeeks, subtractDays, subtractHours, subtractMinutes, subtractSeconds, subtractQuarters {#subtractyears-subtractmonths-subtractweeks-subtractdays-subtracthours-subtractminutes-subtractseconds-subtractquarters} + +Fonksiyon bir tarih/DateTime aralığını bir tarih/DateTime olarak çıkarır ve ardından Tarih/Datetime'ı döndürür. Mesela: + +``` sql +WITH + toDate('2019-01-01') AS date, + toDateTime('2019-01-01 00:00:00') AS date_time +SELECT + subtractYears(date, 1) AS subtract_years_with_date, + subtractYears(date_time, 1) AS subtract_years_with_date_time +``` + +``` text +┌─subtract_years_with_date─┬─subtract_years_with_date_time─┐ +│ 2018-01-01 │ 2018-01-01 00:00:00 │ +└──────────────────────────┴───────────────────────────────┘ +``` + +## dateDiff {#datediff} + +İki Date veya DateTime değerleri arasındaki farkı döndürür. + +**Sözdizimi** + +``` sql +dateDiff('unit', startdate, enddate, [timezone]) +``` + +**Parametre** + +- `unit` — Time unit, in which the returned value is expressed. [Dize](../syntax.md#syntax-string-literal). + + Supported values: + + | unit | + | ---- | + |second | + |minute | + |hour | + |day | + |week | + |month | + |quarter | + |year | + +- `startdate` — The first time value to compare. [Tarihli](../../sql_reference/data_types/date.md) veya [DateTime](../../sql_reference/data_types/datetime.md). + +- `enddate` — The second time value to compare. [Tarihli](../../sql_reference/data_types/date.md) veya [DateTime](../../sql_reference/data_types/datetime.md). + +- `timezone` — Optional parameter. If specified, it is applied to both `startdate` ve `enddate`. Belirtilmemişse, saat dilimleri `startdate` ve `enddate` kullanılır. Aynı değilse, sonuç belirtilmemiştir. + +**Döndürülen değer** + +Arasındaki fark `startdate` ve `enddate` ifade edilen `unit`. + +Tür: `int`. + +**Örnek** + +Sorgu: + +``` sql +SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')); +``` + +Sonuç: + +``` text +┌─dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00'))─┐ +│ 25 │ +└────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +## (StartTime, Süresi,\[, Boyutu zaman yuvasının\]) {#timeslotsstarttime-duration-size} + +Başlayan bir zaman aralığı için ‘StartTime’ ve devam etmek için ‘Duration’ saniye, bu aralıktan aşağı yuvarlanan noktalardan oluşan zaman içinde bir dizi moment döndürür ‘Size’ saniyeler içinde. ‘Size’ isteğe bağlı bir parametredir: varsayılan olarak 1800 olarak ayarlanmış bir sabit Uİnt32. +Mesela, `timeSlots(toDateTime('2012-01-01 12:20:00'), 600) = [toDateTime('2012-01-01 12:00:00'), toDateTime('2012-01-01 12:30:00')]`. +Bu, ilgili oturumda sayfa görüntülemelerini aramak için gereklidir. + +## formatDateTime (saat, Biçim \[, Saat Dilimi\]) {#formatdatetime} + +Function formats a Time according given Format string. N.B.: Format is a constant expression, e.g. you can not have multiple formats for single result column. + +Biçim için desteklenen değiştiriciler: +(“Example” sütun, zaman için biçimlendirme sonucunu gösterir `2018-01-02 22:33:44`) + +| Değiştirici | Açıklama | Örnek | +|-------------|----------------------------------------------------------|------------| +| %C | yıl 100'e bölünür ve tamsayıya kesilir (00-99) | 20 | +| %d | Ayın günü, sıfır yastıklı (01-31) | 02 | +| %D | Kısa MM/DD/YY tarih, eşdeğer %m / %d / % y | 01/02/18 | +| %e | Ayın günü, boşluk dolgulu (1-31) | 2 | +| %F | kısa YYYY-AA-DD tarih, eşdeğer %Y-%m - %d | 2018-01-02 | +| %H | 24 saat formatında saat (00-23) | 22 | +| %I | 12h formatında saat (01-12) | 10 | +| %j | yılın günü (001-366) | 002 | +| %metre | ondalık sayı olarak ay (01-12) | 01 | +| %M | dakika (00-59) | 33 | +| %ve | new-line char (ac (ter (") | | +| %p | AM veya PM atama | PM | +| %R | 24-hour HH: MM Zaman, eşdeğer %H:%M | 22:33 | +| %S | ikinci (00-59) | 44 | +| %t | yatay-sekme karakteri (') | | +| %T | ISO 8601 saat biçimi (HH:MM:SS), eşdeğer %H:%M: % S | 22:33:44 | +| %u | ISO 8601 hafta içi sayı olarak Pazartesi olarak 1 (1-7) | 2 | +| %V | ISO 8601 hafta numarası (01-53) | 01 | +| %g | Pazar günü 0 (0-6) olarak ondalık sayı olarak hafta içi) | 2 | +| %y | Yıl, son iki basamak (00-99) | 18 | +| %Y | Yıllık | 2018 | +| %% | im | % | + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/date_time_functions/) diff --git a/docs/tr/sql_reference/functions/encoding_functions.md b/docs/tr/sql_reference/functions/encoding_functions.md new file mode 100644 index 00000000000..49ad1467957 --- /dev/null +++ b/docs/tr/sql_reference/functions/encoding_functions.md @@ -0,0 +1,175 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 52 +toc_title: "Kodlam\u0131\u015F" +--- + +# Kodlama fonksiyonları {#encoding-functions} + +## kömürleşmek {#char} + +Geçirilen bağımsız değişkenlerin sayısı olarak uzunluğu olan dizeyi döndürür ve her bayt karşılık gelen bağımsız değişken değerine sahiptir. Sayısal türlerin birden çok bağımsız değişkeni kabul eder. Bağımsız değişken değeri uint8 veri türü aralığının dışındaysa, Olası yuvarlama ve taşma ile Uint8'e dönüştürülür. + +**Sözdizimi** + +``` sql +char(number_1, [number_2, ..., number_n]); +``` + +**Parametre** + +- `number_1, number_2, ..., number_n` — Numerical arguments interpreted as integers. Types: [Tamsayı](../../sql_reference/data_types/int_uint.md), [Yüzdürmek](../../sql_reference/data_types/float.md). + +**Döndürülen değer** + +- verilen bayt dizisi. + +Tür: `String`. + +**Örnek** + +Sorgu: + +``` sql +SELECT char(104.1, 101, 108.9, 108.9, 111) AS hello +``` + +Sonuç: + +``` text +┌─hello─┐ +│ hello │ +└───────┘ +``` + +Karşılık gelen baytları geçirerek bir rasgele kodlama dizesi oluşturabilirsiniz. İşte UTF-8 için örnek: + +Sorgu: + +``` sql +SELECT char(0xD0, 0xBF, 0xD1, 0x80, 0xD0, 0xB8, 0xD0, 0xB2, 0xD0, 0xB5, 0xD1, 0x82) AS hello; +``` + +Sonuç: + +``` text +┌─hello──┐ +│ привет │ +└────────┘ +``` + +Sorgu: + +``` sql +SELECT char(0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD) AS hello; +``` + +Sonuç: + +``` text +┌─hello─┐ +│ 你好 │ +└───────┘ +``` + +## büyü {#hex} + +Bağımsız değişkenin onaltılık gösterimini içeren bir dize döndürür. + +**Sözdizimi** + +``` sql +hex(arg) +``` + +İşlev büyük harfler kullanıyor `A-F` ve herhangi bir önek kullanmamak (gibi `0x`) veya sonekler (gibi `h`). + +Tamsayı argümanları için, onaltılık basamak yazdırır (“nibbles”) en önemliden en önemlisine (big endian veya “human readable” sipariş). En önemli sıfır olmayan baytla başlar (önde gelen sıfır bayt atlanır), ancak önde gelen basamak sıfır olsa bile her baytın her iki basamağını da yazdırır. + +Örnek: + +**Örnek** + +Sorgu: + +``` sql +SELECT hex(1); +``` + +Sonuç: + +``` text +01 +``` + +Tip değerleri `Date` ve `DateTime` karşılık gelen tamsayılar olarak biçimlendirilir (tarih için çağdan bu yana geçen gün sayısı ve datetime için Unix zaman damgasının değeri). + +İçin `String` ve `FixedString`, tüm bayt sadece iki onaltılık sayı olarak kodlanır. Sıfır bayt ihmal edilmez. + +Kayan nokta ve ondalık türlerinin değerleri, bellekteki gösterimi olarak kodlanır. Küçük endian mimarisini desteklediğimiz için, bunlar küçük endian'da kodlanmıştır. Sıfır önde gelen / sondaki bayt ihmal edilmez. + +**Parametre** + +- `arg` — A value to convert to hexadecimal. Types: [Dize](../../sql_reference/data_types/string.md), [Uİnt](../../sql_reference/data_types/int_uint.md), [Yüzdürmek](../../sql_reference/data_types/float.md), [Ondalık](../../sql_reference/data_types/decimal.md), [Tarihli](../../sql_reference/data_types/date.md) veya [DateTime](../../sql_reference/data_types/datetime.md). + +**Döndürülen değer** + +- Bağımsız değişken onaltılık gösterimi ile bir dize. + +Tür: `String`. + +**Örnek** + +Sorgu: + +``` sql +SELECT hex(toFloat32(number)) as hex_presentation FROM numbers(15, 2); +``` + +Sonuç: + +``` text +┌─hex_presentation─┐ +│ 00007041 │ +│ 00008041 │ +└──────────────────┘ +``` + +Sorgu: + +``` sql +SELECT hex(toFloat64(number)) as hex_presentation FROM numbers(15, 2); +``` + +Sonuç: + +``` text +┌─hex_presentation─┐ +│ 0000000000002E40 │ +│ 0000000000003040 │ +└──────────────────┘ +``` + +## unhex (str) {#unhexstr} + +Onaltılık basamak herhangi bir sayıda içeren bir dize kabul eder ve karşılık gelen bayt içeren bir dize döndürür. Hem büyük hem de küçük harfleri destekler a-F. onaltılık basamak sayısı bile olmak zorunda değildir. Tek ise, son rakam 00-0F baytın en az önemli yarısı olarak yorumlanır. Bağımsız değişken dizesi onaltılık basamaklardan başka bir şey içeriyorsa, uygulama tanımlı bazı sonuçlar döndürülür (bir özel durum atılmaz). +Sonucu bir sayıya dönüştürmek istiyorsanız, ‘reverse’ ve ‘reinterpretAsType’ işlevler. + +## UUİDStringToNum (str) {#uuidstringtonumstr} + +Biçiminde 36 karakter içeren bir dize kabul eder `123e4567-e89b-12d3-a456-426655440000` ve bir fixedstring(16) bayt kümesi olarak döndürür. + +## UUİDNumToString (str) {#uuidnumtostringstr} + +FixedString(16) değerini kabul eder. Metin biçiminde 36 karakter içeren bir dize döndürür. + +## bitmaskToList (num) {#bitmasktolistnum} + +Bir tamsayı kabul eder. Özetlendiğinde kaynak sayısını toplayan iki güç listesini içeren bir dize döndürür. Artan düzende metin biçiminde boşluk bırakmadan virgülle ayrılırlar. + +## bitmaskToArray (num) {#bitmasktoarraynum} + +Bir tamsayı kabul eder. Özetlendiğinde kaynak sayısını toplayan iki güç listesini içeren bir uint64 sayı dizisi döndürür. Dizideki sayılar artan düzendedir. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/encoding_functions/) diff --git a/docs/tr/sql_reference/functions/ext_dict_functions.md b/docs/tr/sql_reference/functions/ext_dict_functions.md new file mode 100644 index 00000000000..564ec9d5df0 --- /dev/null +++ b/docs/tr/sql_reference/functions/ext_dict_functions.md @@ -0,0 +1,205 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 58 +toc_title: "Harici S\xF6zl\xFCklerle \xE7al\u0131\u015Fma" +--- + +# Harici Sözlüklerle Çalışmak İçin İşlevler {#ext_dict_functions} + +Dış sözlükleri bağlama ve yapılandırma hakkında bilgi için bkz. [Dış söz dictionarieslükler](../../sql_reference/dictionaries/external_dictionaries/external_dicts.md). + +## dictGet {#dictget} + +Harici bir sözlükten bir değer alır. + +``` sql +dictGet('dict_name', 'attr_name', id_expr) +dictGetOrDefault('dict_name', 'attr_name', id_expr, default_value_expr) +``` + +**Parametre** + +- `dict_name` — Name of the dictionary. [String lit literal](../syntax.md#syntax-string-literal). +- `attr_name` — Name of the column of the dictionary. [String lit literal](../syntax.md#syntax-string-literal). +- `id_expr` — Key value. [İfade](../syntax.md#syntax-expressions) dönen bir [Uİnt64](../../sql_reference/data_types/int_uint.md) veya [Demet](../../sql_reference/data_types/tuple.md)- sözlük yapılandırmasına bağlı olarak değer yazın. +- `default_value_expr` — Value returned if the dictionary doesn't contain a row with the `id_expr` anahtar. [İfade](../syntax.md#syntax-expressions) veri türü için yapılandırılmış değeri döndürme `attr_name` öznitelik. + +**Döndürülen değer** + +- ClickHouse özniteliği başarıyla ayrıştırırsa [öznitelik veri türü](../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_structure.md#ext_dict_structure-attributes), fonksiyonlar karşılık gelen sözlük özniteliğinin değerini döndürür `id_expr`. + +- Anahtar yoksa, karşılık gelen `id_expr`, söz thelükte, sonra: + + - `dictGet` returns the content of the `` element specified for the attribute in the dictionary configuration. + - `dictGetOrDefault` returns the value passed as the `default_value_expr` parameter. + +Clickhouse, özniteliğin değerini ayrıştıramazsa veya değer öznitelik veri türüyle eşleşmiyorsa bir özel durum atar. + +**Örnek** + +Metin dosyası oluşturma `ext-dict-text.csv` aşağıdakileri içeren: + +``` text +1,1 +2,2 +``` + +İlk sütun `id` ikinci sütun `c1`. + +Dış sözlüğü yapılandırma: + +``` xml + + + ext-dict-test + + + /path-to/ext-dict-test.csv + CSV + + + + + + + + id + + + c1 + UInt32 + + + + 0 + + +``` + +Sorguyu gerçekleştir: + +``` sql +SELECT + dictGetOrDefault('ext-dict-test', 'c1', number + 1, toUInt32(number * 10)) AS val, + toTypeName(val) AS type +FROM system.numbers +LIMIT 3 +``` + +``` text +┌─val─┬─type───┐ +│ 1 │ UInt32 │ +│ 2 │ UInt32 │ +│ 20 │ UInt32 │ +└─────┴────────┘ +``` + +**Ayrıca Bakınız** + +- [Dış Söz Dictionarieslükler](../../sql_reference/dictionaries/external_dictionaries/external_dicts.md) + +## dictHas {#dicthas} + +Bir anahtar sözlükte mevcut olup olmadığını denetler. + +``` sql +dictHas('dict_name', id_expr) +``` + +**Parametre** + +- `dict_name` — Name of the dictionary. [String lit literal](../syntax.md#syntax-string-literal). +- `id_expr` — Key value. [İfade](../syntax.md#syntax-expressions) dönen bir [Uİnt64](../../sql_reference/data_types/int_uint.md)- tip değeri. + +**Döndürülen değer** + +- 0, anahtar yoksa. +- 1, bir anahtar varsa. + +Tür: `UInt8`. + +## dictGetHierarchy {#dictgethierarchy} + +Bir anahtarın tüm ebeveynlerini içeren bir dizi oluşturur. [hiyerarş dictionaryik sözlük](../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_hierarchical.md). + +**Sözdizimi** + +``` sql +dictGetHierarchy('dict_name', key) +``` + +**Parametre** + +- `dict_name` — Name of the dictionary. [String lit literal](../syntax.md#syntax-string-literal). +- `key` — Key value. [İfade](../syntax.md#syntax-expressions) dönen bir [Uİnt64](../../sql_reference/data_types/int_uint.md)- tip değeri. + +**Döndürülen değer** + +- Anahtar için ebeveynler. + +Tür: [Dizi (Uİnt64)](../../sql_reference/data_types/array.md). + +## dictİsİn {#dictisin} + +Sözlükteki tüm hiyerarşik zincir boyunca bir anahtarın atasını kontrol eder. + +``` sql +dictIsIn('dict_name', child_id_expr, ancestor_id_expr) +``` + +**Parametre** + +- `dict_name` — Name of the dictionary. [String lit literal](../syntax.md#syntax-string-literal). +- `child_id_expr` — Key to be checked. [İfade](../syntax.md#syntax-expressions) dönen bir [Uİnt64](../../sql_reference/data_types/int_uint.md)- tip değeri. +- `ancestor_id_expr` — Alleged ancestor of the `child_id_expr` anahtar. [İfade](../syntax.md#syntax-expressions) dönen bir [Uİnt64](../../sql_reference/data_types/int_uint.md)- tip değeri. + +**Döndürülen değer** + +- 0, eğer `child_id_expr` bir çocuk değil mi `ancestor_id_expr`. +- 1, Eğer `child_id_expr` bir çocuk `ancestor_id_expr` veya eğer `child_id_expr` is an `ancestor_id_expr`. + +Tür: `UInt8`. + +## Diğer Fonksiyonlar {#ext_dict_functions-other} + +ClickHouse sözlük yapılandırma ne olursa olsun belirli bir veri türü için sözlük öznitelik değerlerini dönüştürmek özel işlevleri destekler. + +İşlevler: + +- `dictGetInt8`, `dictGetInt16`, `dictGetInt32`, `dictGetInt64` +- `dictGetUInt8`, `dictGetUInt16`, `dictGetUInt32`, `dictGetUInt64` +- `dictGetFloat32`, `dictGetFloat64` +- `dictGetDate` +- `dictGetDateTime` +- `dictGetUUID` +- `dictGetString` + +Tüm bu işlevler `OrDefault` değişiklik. Mesela, `dictGetDateOrDefault`. + +Sözdizimi: + +``` sql +dictGet[Type]('dict_name', 'attr_name', id_expr) +dictGet[Type]OrDefault('dict_name', 'attr_name', id_expr, default_value_expr) +``` + +**Parametre** + +- `dict_name` — Name of the dictionary. [String lit literal](../syntax.md#syntax-string-literal). +- `attr_name` — Name of the column of the dictionary. [String lit literal](../syntax.md#syntax-string-literal). +- `id_expr` — Key value. [İfade](../syntax.md#syntax-expressions) dönen bir [Uİnt64](../../sql_reference/data_types/int_uint.md)- tip değeri. +- `default_value_expr` — Value which is returned if the dictionary doesn't contain a row with the `id_expr` anahtar. [İfade](../syntax.md#syntax-expressions) veri türü için yapılandırılmış bir değer döndürme `attr_name` öznitelik. + +**Döndürülen değer** + +- ClickHouse özniteliği başarıyla ayrıştırırsa [öznitelik veri türü](../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_structure.md#ext_dict_structure-attributes), fonksiyonlar karşılık gelen sözlük özniteliğinin değerini döndürür `id_expr`. + +- İsten nomiyorsa `id_expr` söz thelükte o zaman: + + - `dictGet[Type]` returns the content of the `` element specified for the attribute in the dictionary configuration. + - `dictGet[Type]OrDefault` returns the value passed as the `default_value_expr` parameter. + +Clickhouse, özniteliğin değerini ayrıştıramazsa veya değer öznitelik veri türüyle eşleşmiyorsa bir özel durum atar. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/ext_dict_functions/) diff --git a/docs/tr/sql_reference/functions/functions_for_nulls.md b/docs/tr/sql_reference/functions/functions_for_nulls.md new file mode 100644 index 00000000000..59567067c42 --- /dev/null +++ b/docs/tr/sql_reference/functions/functions_for_nulls.md @@ -0,0 +1,312 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 63 +toc_title: "Null arg\xFCmanlarla \xE7al\u0131\u015Fma" +--- + +# Null agregalarla çalışmak için işlevler {#functions-for-working-with-nullable-aggregates} + +## isNull {#isnull} + +Bağımsız değişken olup olmadığını denetler [NULL](../syntax.md#null). + +``` sql +isNull(x) +``` + +**Parametre** + +- `x` — A value with a non-compound data type. + +**Döndürülen değer** + +- `1` eğer `x` oluyor `NULL`. +- `0` eğer `x` değildir `NULL`. + +**Örnek** + +Giriş tablosu + +``` text +┌─x─┬────y─┐ +│ 1 │ ᴺᵁᴸᴸ │ +│ 2 │ 3 │ +└───┴──────┘ +``` + +Sorgu + +``` sql +SELECT x FROM t_null WHERE isNull(y) +``` + +``` text +┌─x─┐ +│ 1 │ +└───┘ +``` + +## isNotNull {#isnotnull} + +Bağımsız değişken olup olmadığını denetler [NULL](../syntax.md#null). + +``` sql +isNotNull(x) +``` + +**Parametre:** + +- `x` — A value with a non-compound data type. + +**Döndürülen değer** + +- `0` eğer `x` oluyor `NULL`. +- `1` eğer `x` değildir `NULL`. + +**Örnek** + +Giriş tablosu + +``` text +┌─x─┬────y─┐ +│ 1 │ ᴺᵁᴸᴸ │ +│ 2 │ 3 │ +└───┴──────┘ +``` + +Sorgu + +``` sql +SELECT x FROM t_null WHERE isNotNull(y) +``` + +``` text +┌─x─┐ +│ 2 │ +└───┘ +``` + +## birleşmek {#coalesce} + +Olup olmadığını soldan sağa denetler `NULL` argümanlar geçti ve ilk olmayan döndürür-`NULL` değişken. + +``` sql +coalesce(x,...) +``` + +**Parametre:** + +- Bileşik olmayan tipte herhangi bir sayıda parametre. Tüm parametreler veri türüne göre uyumlu olmalıdır. + +**Döndürülen değerler** + +- İlk sigara-`NULL` değişken. +- `NULL`, eğer tüm argümanlar `NULL`. + +**Örnek** + +Bir müşteriyle iletişim kurmak için birden çok yol belirtebilecek kişilerin listesini düşünün. + +``` text +┌─name─────┬─mail─┬─phone─────┬──icq─┐ +│ client 1 │ ᴺᵁᴸᴸ │ 123-45-67 │ 123 │ +│ client 2 │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ ᴺᵁᴸᴸ │ +└──────────┴──────┴───────────┴──────┘ +``` + +Bu `mail` ve `phone` alanlar String tip ofindedir, ancak `icq` Fi fieldeld is `UInt32`, bu yüzden dönüştürülmesi gerekiyor `String`. + +Müşteri için ilk kullanılabilir iletişim yöntemini kişi listesinden alın: + +``` sql +SELECT coalesce(mail, phone, CAST(icq,'Nullable(String)')) FROM aBook +``` + +``` text +┌─name─────┬─coalesce(mail, phone, CAST(icq, 'Nullable(String)'))─┐ +│ client 1 │ 123-45-67 │ +│ client 2 │ ᴺᵁᴸᴸ │ +└──────────┴──────────────────────────────────────────────────────┘ +``` + +## ifNull {#ifnull} + +Ana bağımsız değişken ise alternatif bir değer döndürür `NULL`. + +``` sql +ifNull(x,alt) +``` + +**Parametre:** + +- `x` — The value to check for `NULL`. +- `alt` — The value that the function returns if `x` oluyor `NULL`. + +**Döndürülen değerler** + +- Değer `x`, eğer `x` değildir `NULL`. +- Değer `alt`, eğer `x` oluyor `NULL`. + +**Örnek** + +``` sql +SELECT ifNull('a', 'b') +``` + +``` text +┌─ifNull('a', 'b')─┐ +│ a │ +└──────────────────┘ +``` + +``` sql +SELECT ifNull(NULL, 'b') +``` + +``` text +┌─ifNull(NULL, 'b')─┐ +│ b │ +└───────────────────┘ +``` + +## nullİf {#nullif} + +Dönüşler `NULL` argümanlar eşitse. + +``` sql +nullIf(x, y) +``` + +**Parametre:** + +`x`, `y` — Values for comparison. They must be compatible types, or ClickHouse will generate an exception. + +**Döndürülen değerler** + +- `NULL`, argümanlar eşitse. +- Bu `x` bağımsız değişkenler eşit değilse, değer. + +**Örnek** + +``` sql +SELECT nullIf(1, 1) +``` + +``` text +┌─nullIf(1, 1)─┐ +│ ᴺᵁᴸᴸ │ +└──────────────┘ +``` + +``` sql +SELECT nullIf(1, 2) +``` + +``` text +┌─nullIf(1, 2)─┐ +│ 1 │ +└──────────────┘ +``` + +## assumeNotNull {#assumenotnull} + +Bir tür değeri ile sonuçlanır [Nullable](../../sql_reference/data_types/nullable.md) bir sigara için- `Nullable` eğer değer değil `NULL`. + +``` sql +assumeNotNull(x) +``` + +**Parametre:** + +- `x` — The original value. + +**Döndürülen değerler** + +- Olmayan orijinal değeri-`Nullable` tipi, değilse `NULL`. +- Olmayan için varsayılan değer-`Nullable` özgün değer ise yazın `NULL`. + +**Örnek** + +Düşünün `t_null` Tablo. + +``` sql +SHOW CREATE TABLE t_null +``` + +``` text +┌─statement─────────────────────────────────────────────────────────────────┐ +│ CREATE TABLE default.t_null ( x Int8, y Nullable(Int8)) ENGINE = TinyLog │ +└───────────────────────────────────────────────────────────────────────────┘ +``` + +``` text +┌─x─┬────y─┐ +│ 1 │ ᴺᵁᴸᴸ │ +│ 2 │ 3 │ +└───┴──────┘ +``` + +Uygula `assumeNotNull` fonksiyonu için `y` sütun. + +``` sql +SELECT assumeNotNull(y) FROM t_null +``` + +``` text +┌─assumeNotNull(y)─┐ +│ 0 │ +│ 3 │ +└──────────────────┘ +``` + +``` sql +SELECT toTypeName(assumeNotNull(y)) FROM t_null +``` + +``` text +┌─toTypeName(assumeNotNull(y))─┐ +│ Int8 │ +│ Int8 │ +└──────────────────────────────┘ +``` + +## toNullable {#tonullable} + +Bağımsız değişken türünü dönüştürür `Nullable`. + +``` sql +toNullable(x) +``` + +**Parametre:** + +- `x` — The value of any non-compound type. + +**Döndürülen değer** + +- Bir ile giriş değeri `Nullable` tür. + +**Örnek** + +``` sql +SELECT toTypeName(10) +``` + +``` text +┌─toTypeName(10)─┐ +│ UInt8 │ +└────────────────┘ +``` + +``` sql +SELECT toTypeName(toNullable(10)) +``` + +``` text +┌─toTypeName(toNullable(10))─┐ +│ Nullable(UInt8) │ +└────────────────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/functions_for_nulls/) diff --git a/docs/tr/sql_reference/functions/geo.md b/docs/tr/sql_reference/functions/geo.md new file mode 100644 index 00000000000..353418c7b97 --- /dev/null +++ b/docs/tr/sql_reference/functions/geo.md @@ -0,0 +1,510 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 62 +toc_title: "Co\u011Frafi koordinatlar ile \xE7al\u0131\u015Fma" +--- + +# Coğrafi Koordinatlarla çalışmak için fonksiyonlar {#functions-for-working-with-geographical-coordinates} + +## greatCircleDistance {#greatcircledistance} + +Dünya yüzeyindeki iki nokta arasındaki mesafeyi kullanarak hesaplayın [büyük daire formülü](https://en.wikipedia.org/wiki/Great-circle_distance). + +``` sql +greatCircleDistance(lon1Deg, lat1Deg, lon2Deg, lat2Deg) +``` + +**Giriş parametreleri** + +- `lon1Deg` — Longitude of the first point in degrees. Range: `[-180°, 180°]`. +- `lat1Deg` — Latitude of the first point in degrees. Range: `[-90°, 90°]`. +- `lon2Deg` — Longitude of the second point in degrees. Range: `[-180°, 180°]`. +- `lat2Deg` — Latitude of the second point in degrees. Range: `[-90°, 90°]`. + +Pozitif değerler Kuzey enlemi ve Doğu boylamına karşılık gelir ve negatif değerler Güney enlemi ve Batı boylamına karşılık gelir. + +**Döndürülen değer** + +Dünya yüzeyindeki iki nokta arasındaki mesafe, metre cinsinden. + +Girdi parametre değerleri aralığın dışına düştüğünde bir özel durum oluşturur. + +**Örnek** + +``` sql +SELECT greatCircleDistance(55.755831, 37.617673, -55.755831, -37.617673) +``` + +``` text +┌─greatCircleDistance(55.755831, 37.617673, -55.755831, -37.617673)─┐ +│ 14132374.194975413 │ +└───────────────────────────────────────────────────────────────────┘ +``` + +## pointİnEllipses {#pointinellipses} + +Noktanın elipslerden en az birine ait olup olmadığını kontrol eder. +Koordinatlar kartezyen koordinat sisteminde geometriktir. + +``` sql +pointInEllipses(x, y, x₀, y₀, a₀, b₀,...,xₙ, yₙ, aₙ, bₙ) +``` + +**Giriş parametreleri** + +- `x, y` — Coordinates of a point on the plane. +- `xᵢ, yᵢ` — Coordinates of the center of the `i`-inci üç nokta. +- `aᵢ, bᵢ` — Axes of the `i`- x, y koordinatları birimlerinde üç nokta. + +Giriş parametreleri olmalıdır `2+4⋅n`, nere `n` elips sayısıdır. + +**Döndürülen değerler** + +`1` nokta elipslerden en az birinin içindeyse; `0`hayır değil. + +**Örnek** + +``` sql +SELECT pointInEllipses(10., 10., 10., 9.1, 1., 0.9999) +``` + +``` text +┌─pointInEllipses(10., 10., 10., 9.1, 1., 0.9999)─┐ +│ 1 │ +└─────────────────────────────────────────────────┘ +``` + +## pointİnPolygon {#pointinpolygon} + +Noktanın düzlemdeki poligona ait olup olmadığını kontrol eder. + +``` sql +pointInPolygon((x, y), [(a, b), (c, d) ...], ...) +``` + +**Giriş değerleri** + +- `(x, y)` — Coordinates of a point on the plane. Data type — [Demet](../../sql_reference/data_types/tuple.md) — A tuple of two numbers. +- `[(a, b), (c, d) ...]` — Polygon vertices. Data type — [Dizi](../../sql_reference/data_types/array.md). Her köşe bir çift koordinat ile temsil edilir `(a, b)`. Köşeler saat yönünde veya saat yönünün tersine sırayla belirtilmelidir. Minimum köşe sayısı 3'tür. Çokgen sabit olmalıdır. +- Fonksiyon ayrıca delikli çokgenleri de destekler (bölümleri keser). Bu durumda, işlevin ek argümanlarını kullanarak kesilen bölümleri tanımlayan çokgenler ekleyin. İşlev, basit olmayan bağlı çokgenleri desteklemez. + +**Döndürülen değerler** + +`1` nokta çokgenin içinde ise, `0` hayır değil. +Nokta çokgen sınırında ise, işlev 0 veya 1 döndürebilir. + +**Örnek** + +``` sql +SELECT pointInPolygon((3., 3.), [(6, 0), (8, 4), (5, 8), (0, 2)]) AS res +``` + +``` text +┌─res─┐ +│ 1 │ +└─────┘ +``` + +## geohashEncode {#geohashencode} + +Enlem ve boylamı bir geohash-string olarak kodlar, Lütfen bakınız (http://geohash.org/, https://en.wikipedia.org/wiki/Geohash). + +``` sql +geohashEncode(longitude, latitude, [precision]) +``` + +**Giriş değerleri** + +- boylam-kodlamak istediğiniz koordinatın boylam kısmı. Aralık floatingta yüz floatingen`[-180°, 180°]` +- latitude-kodlamak istediğiniz koordinatın enlem kısmı. Aralık floatingta yüz floatingen `[-90°, 90°]` +- hassas-isteğe bağlı, elde edilen kodlanmış dizenin uzunluğu, varsayılan olarak `12`. Aralıktaki tamsayı `[1, 12]`. Herhangi bir değer daha az `1` veya daha büyük `12` sessizce dönüştürülür `12`. + +**Döndürülen değerler** + +- alfanümerik `String` kodlanmış koordinat (base32-kodlama alfabesinin değiştirilmiş versiyonu kullanılır). + +**Örnek** + +``` sql +SELECT geohashEncode(-5.60302734375, 42.593994140625, 0) AS res +``` + +``` text +┌─res──────────┐ +│ ezs42d000000 │ +└──────────────┘ +``` + +## geohashDecode {#geohashdecode} + +Herhangi bir geohash kodlu dizeyi boylam ve enlem olarak çözer. + +**Giriş değerleri** + +- kodlanmış dize-geohash kodlanmış dize. + +**Döndürülen değerler** + +- (boylam, enlem) - 2-tuple `Float64` boylam ve enlem değerleri. + +**Örnek** + +``` sql +SELECT geohashDecode('ezs42') AS res +``` + +``` text +┌─res─────────────────────────────┐ +│ (-5.60302734375,42.60498046875) │ +└─────────────────────────────────┘ +``` + +## geoToH3 {#geotoh3} + +Dönüşler [H3](https://uber.github.io/h3/#/documentation/overview/introduction) nokta Endeksi `(lon, lat)` belirtilen çözünürlük ile. + +[H3](https://uber.github.io/h3/#/documentation/overview/introduction) Dünya yüzeyinin altıgen fayanslara bile bölündüğü coğrafi bir indeksleme sistemidir. Bu sistem hiyerarşiktir, örn. üst seviyedeki her altıgen yedi hatta daha küçük olanlara bölünebilir. + +Bu endeks öncelikle kovalama yerleri ve diğer coğrafi manipülasyonlar için kullanılır. + +**Sözdizimi** + +``` sql +geoToH3(lon, lat, resolution) +``` + +**Parametre** + +- `lon` — Longitude. Type: [Float64](../../sql_reference/data_types/float.md). +- `lat` — Latitude. Type: [Float64](../../sql_reference/data_types/float.md). +- `resolution` — Index resolution. Range: `[0, 15]`. Tür: [Uİnt8](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değerler** + +- Altıgen dizin numarası. +- Hata durumunda 0. + +Tür: `UInt64`. + +**Örnek** + +Sorgu: + +``` sql +SELECT geoToH3(37.79506683, 55.71290588, 15) as h3Index +``` + +Sonuç: + +``` text +┌────────────h3Index─┐ +│ 644325524701193974 │ +└────────────────────┘ +``` + +## geohashesİnBox {#geohashesinbox} + +Verilen kutunun içine giren ve verilen kutunun sınırlarını kesişen, temel olarak diziye düzleştirilmiş bir 2D ızgarası olan bir dizi geohash kodlu dizeler dizisi döndürür. + +**Giriş değerleri** + +- longitude\_min - min boylam, aralıkta kayan değer `[-180°, 180°]` +- latitude\_min - min enlem, aralıkta kayan değer `[-90°, 90°]` +- longitude\_max-maksimum boylam, aralıkta kayan değer `[-180°, 180°]` +- latitude\_max-maksimum enlem, aralıkta kayan değer `[-90°, 90°]` +- hassas-geohash hassas, `UInt8` Aralık inta `[1, 12]` + +Lütfen tüm koordinat parametrelerinin aynı tipte olması gerektiğini unutmayın: `Float32` veya `Float64`. + +**Döndürülen değerler** + +- verilen alanı kapsayan geohash kutularının hassas uzun dizeleri dizisi, öğelerin sırasına güvenmemelisiniz. +- \[\]- eğer boş dizi *dakika* değerleri *enlem* ve *Boylam* karşılık gelenden daha az değil *maksimum* değerler. + +Ortaya çıkan dizi 10'000' 000 ürün uzunluğundaysa, işlevin bir istisna atacağını lütfen unutmayın. + +**Örnek** + +``` sql +SELECT geohashesInBox(24.48, 40.56, 24.785, 40.81, 4) AS thasos +``` + +``` text +┌─thasos──────────────────────────────────────┐ +│ ['sx1q','sx1r','sx32','sx1w','sx1x','sx38'] │ +└─────────────────────────────────────────────┘ +``` + +## h3GetBaseCell {#h3getbasecell} + +Dizin temel hücre numarasını döndürür. + +**Sözdizimi** + +``` sql +h3GetBaseCell(index) +``` + +**Parametre** + +- `index` — Hexagon index number. Type: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değerler** + +- Altıgen baz hücre numarası. Tür: [Uİnt8](../../sql_reference/data_types/int_uint.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT h3GetBaseCell(612916788725809151) as basecell +``` + +Sonuç: + +``` text +┌─basecell─┐ +│ 12 │ +└──────────┘ +``` + +## h3HexAreaM2 {#h3hexaream2} + +Verilen çözünürlükte metrekare ortalama altıgen alan. + +**Sözdizimi** + +``` sql +h3HexAreaM2(resolution) +``` + +**Parametre** + +- `resolution` — Index resolution. Range: `[0, 15]`. Tür: [Uİnt8](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değerler** + +- Area in m². Type: [Float64](../../sql_reference/data_types/float.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT h3HexAreaM2(13) as area +``` + +Sonuç: + +``` text +┌─area─┐ +│ 43.9 │ +└──────┘ +``` + +## h3İndexesAreNeighbors {#h3indexesareneighbors} + +Sağlanan H3indexlerin komşu olup olmadığını döndürür. + +**Sözdizimi** + +``` sql +h3IndexesAreNeighbors(index1, index2) +``` + +**Parametre** + +- `index1` — Hexagon index number. Type: [Uİnt64](../../sql_reference/data_types/int_uint.md). +- `index2` — Hexagon index number. Type: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değerler** + +- Dönüşler `1` dizinler komşu ise, `0` başka. Tür: [Uİnt8](../../sql_reference/data_types/int_uint.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT h3IndexesAreNeighbors(617420388351344639, 617420388352655359) AS n +``` + +Sonuç: + +``` text +┌─n─┐ +│ 1 │ +└───┘ +``` + +## h3ToChildren {#h3tochildren} + +Verilen dizinin alt dizinlerini içeren bir dizi döndürür. + +**Sözdizimi** + +``` sql +h3ToChildren(index, resolution) +``` + +**Parametre** + +- `index` — Hexagon index number. Type: [Uİnt64](../../sql_reference/data_types/int_uint.md). +- `resolution` — Index resolution. Range: `[0, 15]`. Tür: [Uİnt8](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değerler** + +- Alt H3 dizinleri ile dizi. Dizi türü: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT h3ToChildren(599405990164561919, 6) AS children +``` + +Sonuç: + +``` text +┌─children───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ +│ [603909588852408319,603909588986626047,603909589120843775,603909589255061503,603909589389279231,603909589523496959,603909589657714687] │ +└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +## h3ToParent {#h3toparent} + +Verilen dizini içeren üst (kaba) dizini döndürür. + +**Sözdizimi** + +``` sql +h3ToParent(index, resolution) +``` + +**Parametre** + +- `index` — Hexagon index number. Type: [Uİnt64](../../sql_reference/data_types/int_uint.md). +- `resolution` — Index resolution. Range: `[0, 15]`. Tür: [Uİnt8](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değerler** + +- Ana H3 Endeksi. Tür: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT h3ToParent(599405990164561919, 3) as parent +``` + +Sonuç: + +``` text +┌─────────────parent─┐ +│ 590398848891879423 │ +└────────────────────┘ +``` + +## h3ToString {#h3tostring} + +Dizinin H3ındex gösterimini dize gösterimine dönüştürür. + +``` sql +h3ToString(index) +``` + +**Parametre** + +- `index` — Hexagon index number. Type: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değerler** + +- H3 dizininin dize gösterimi. Tür: [Dize](../../sql_reference/data_types/string.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT h3ToString(617420388352917503) as h3_string +``` + +Sonuç: + +``` text +┌─h3_string───────┐ +│ 89184926cdbffff │ +└─────────────────┘ +``` + +## stringToH3 {#stringtoh3} + +Dize gösterimini H3ındex (Uİnt64) gösterimine dönüştürür. + +``` sql +stringToH3(index_str) +``` + +**Parametre** + +- `index_str` — String representation of the H3 index. Type: [Dize](../../sql_reference/data_types/string.md). + +**Döndürülen değerler** + +- Altıgen dizin numarası. Hata 0 döndürür. Tür: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT stringToH3('89184926cc3ffff') as index +``` + +Sonuç: + +``` text +┌──────────────index─┐ +│ 617420388351344639 │ +└────────────────────┘ +``` + +## h3GetResolution {#h3getresolution} + +Dizin çözünürlüğünü döndürür. + +**Sözdizimi** + +``` sql +h3GetResolution(index) +``` + +**Parametre** + +- `index` — Hexagon index number. Type: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değerler** + +- Dizin çözünürlüğü. Aralık: `[0, 15]`. Tür: [Uİnt8](../../sql_reference/data_types/int_uint.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT h3GetResolution(617420388352917503) as res +``` + +Sonuç: + +``` text +┌─res─┐ +│ 9 │ +└─────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/geo/) diff --git a/docs/tr/sql_reference/functions/hash_functions.md b/docs/tr/sql_reference/functions/hash_functions.md new file mode 100644 index 00000000000..fbb21597943 --- /dev/null +++ b/docs/tr/sql_reference/functions/hash_functions.md @@ -0,0 +1,446 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 50 +toc_title: Karma +--- + +# Karma fonksiyonlar {#hash-functions} + +Hash fonksiyonları elementlerin deterministik sözde rastgele karıştırma için kullanılabilir. + +## halfMD5 {#hash-functions-halfmd5} + +[Yorumluyor](../../sql_reference/functions/type_conversion_functions.md#type_conversion_functions-reinterpretAsString) tüm giriş parametrelerini dizeler olarak hesaplar ve [MD5](https://en.wikipedia.org/wiki/MD5) her biri için karma değeri. Sonra karmaları birleştirir, elde edilen dizenin karmasının ilk 8 baytını alır ve bunları şöyle yorumlar `UInt64` büyük endian bayt sırasına göre. + +``` sql +halfMD5(par1, ...) +``` + +İşlev nispeten yavaştır (işlemci çekirdeği başına saniyede 5 milyon kısa dizge). +Kullanmayı düşünün [sifash64](#hash_functions-siphash64) bunun yerine işlev. + +**Parametre** + +Fonksiyon, değişken sayıda giriş parametresi alır. Parametreler herhangi biri olabilir [desteklenen veri türleri](../../sql_reference/data_types/index.md). + +**Döndürülen Değer** + +A [Uİnt64](../../sql_reference/data_types/int_uint.md) veri türü karma değeri. + +**Örnek** + +``` sql +SELECT halfMD5(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS halfMD5hash, toTypeName(halfMD5hash) AS type +``` + +``` text +┌────────halfMD5hash─┬─type───┐ +│ 186182704141653334 │ UInt64 │ +└────────────────────┴────────┘ +``` + +## MD5 {#hash_functions-md5} + +MD5 bir dizeden hesaplar ve elde edilen bayt kümesini FixedString(16) olarak döndürür. +Özellikle MD5'E ihtiyacınız yoksa, ancak iyi bir şifreleme 128 bit karmasına ihtiyacınız varsa, ‘sipHash128’ bunun yerine işlev. +Md5sum yardımcı programı tarafından çıktı ile aynı sonucu elde etmek istiyorsanız, lower(hex(MD5(s))) kullanın. + +## sifash64 {#hash_functions-siphash64} + +64-bit üretir [Sifash](https://131002.net/siphash/) karma değeri. + +``` sql +sipHash64(par1,...) +``` + +Bu bir şifreleme karma işlevidir. En az üç kat daha hızlı çalışır [MD5](#hash_functions-md5) işlev. + +İşlev [yorumluyor](../../sql_reference/functions/type_conversion_functions.md#type_conversion_functions-reinterpretAsString) tüm giriş parametreleri dizeleri olarak ve bunların her biri için karma değerini hesaplar. Sonra aşağıdaki algoritma ile karmaları birleştirir: + +1. Tüm giriş parametrelerini karma yaptıktan sonra, işlev karma dizisini alır. +2. Fonksiyon birinci ve ikinci öğeleri alır ve bunların dizisi için bir karma hesaplar. +3. Daha sonra işlev, önceki adımda hesaplanan karma değeri ve ilk karma dizinin üçüncü öğesini alır ve bunların dizisi için bir karma hesaplar. +4. Önceki adım, ilk karma dizinin kalan tüm öğeleri için tekrarlanır. + +**Parametre** + +Fonksiyon, değişken sayıda giriş parametresi alır. Parametreler herhangi biri olabilir [desteklenen veri türleri](../../sql_reference/data_types/index.md). + +**Döndürülen Değer** + +A [Uİnt64](../../sql_reference/data_types/int_uint.md) veri türü karma değeri. + +**Örnek** + +``` sql +SELECT sipHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS SipHash, toTypeName(SipHash) AS type +``` + +``` text +┌──────────────SipHash─┬─type───┐ +│ 13726873534472839665 │ UInt64 │ +└──────────────────────┴────────┘ +``` + +## sifash128 {#hash_functions-siphash128} + +Bir dizeden Sifash hesaplar. +Bir dize türü bağımsız değişkeni kabul eder. Fixedstring(16) Döndürür. +Sifash64'ten farklıdır, çünkü son xor katlama durumu sadece 128 bit'e kadar yapılır. + +## cityHash64 {#cityhash64} + +64-bit üretir [CityHash](https://github.com/google/cityhash) karma değeri. + +``` sql +cityHash64(par1,...) +``` + +Bu hızlı olmayan şifreleme karma işlevidir. Dize parametreleri için CityHash algoritmasını ve diğer veri türleriyle parametreler için uygulamaya özgü hızlı kriptografik olmayan karma işlevini kullanır. İşlev, nihai sonuçları almak için CityHash birleştiricisini kullanır. + +**Parametre** + +Fonksiyon, değişken sayıda giriş parametresi alır. Parametreler herhangi biri olabilir [desteklenen veri türleri](../../sql_reference/data_types/index.md). + +**Döndürülen Değer** + +A [Uİnt64](../../sql_reference/data_types/int_uint.md) veri türü karma değeri. + +**Örnekler** + +Çağrı örneği: + +``` sql +SELECT cityHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS CityHash, toTypeName(CityHash) AS type +``` + +``` text +┌─────────────CityHash─┬─type───┐ +│ 12072650598913549138 │ UInt64 │ +└──────────────────────┴────────┘ +``` + +Aşağıdaki örnek, tüm tablonun sağlama toplamının satır sırasına kadar doğrulukla nasıl hesaplanacağını gösterir: + +``` sql +SELECT groupBitXor(cityHash64(*)) FROM table +``` + +## intHash32 {#inthash32} + +Herhangi bir tamsayı türünden 32 bit karma kodu hesaplar. +Bu, sayılar için ortalama kalitenin nispeten hızlı bir kriptografik olmayan karma işlevidir. + +## intHash64 {#inthash64} + +Herhangi bir tamsayı türünden 64 bit karma kodu hesaplar. +Inthash32'den daha hızlı çalışır. Ortalama kalite. + +## SHA1 {#sha1} + +## SHA224 {#sha224} + +## SHA256 {#sha256} + +Bir dizeden SHA-1, SHA-224 veya SHA-256 hesaplar ve elde edilen bayt kümesini FixedString(20), FixedString(28) veya FixedString(32) olarak döndürür. +İşlev oldukça yavaş çalışır (SHA-1, işlemci çekirdeği başına saniyede yaklaşık 5 milyon kısa dizgiyi işler, SHA-224 ve SHA-256 ise yaklaşık 2.2 milyon işlem yapar). +Bu işlevi yalnızca belirli bir karma işleve ihtiyacınız olduğunda ve bunu seçemediğinizde kullanmanızı öneririz. +Bu gibi durumlarda bile, SELECTS'TE uygulamak yerine, tabloya eklerken işlev çevrimdışı ve ön hesaplama değerlerini uygulamanızı öneririz. + +## URLHash(url \[, N\]) {#urlhashurl-n} + +Bir tür normalleştirme kullanarak bir URL'den elde edilen bir dize için hızlı, iyi kalitede olmayan şifreleme karma işlevi. +`URLHash(s)` – Calculates a hash from a string without one of the trailing symbols `/`,`?` veya `#` sonunda, varsa. +`URLHash(s, N)` – Calculates a hash from a string up to the N level in the URL hierarchy, without one of the trailing symbols `/`,`?` veya `#` sonunda, varsa. +Düzeyleri URLHierarchy aynıdır. Bu fonksiyon (kayıt olmak için özeldir.Metrica. + +## farmHash64 {#farmhash64} + +64-bit üretir [FarmHash](https://github.com/google/farmhash) karma değeri. + +``` sql +farmHash64(par1, ...) +``` + +Fonksiyonu kullanır `Hash64` tüm yöntem [mevcut yöntemler](https://github.com/google/farmhash/blob/master/src/farmhash.h). + +**Parametre** + +Fonksiyon, değişken sayıda giriş parametresi alır. Parametreler herhangi biri olabilir [desteklenen veri türleri](../../sql_reference/data_types/index.md). + +**Döndürülen Değer** + +A [Uİnt64](../../sql_reference/data_types/int_uint.md) veri türü karma değeri. + +**Örnek** + +``` sql +SELECT farmHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS FarmHash, toTypeName(FarmHash) AS type +``` + +``` text +┌─────────────FarmHash─┬─type───┐ +│ 17790458267262532859 │ UInt64 │ +└──────────────────────┴────────┘ +``` + +## javaHash {#hash_functions-javahash} + +Hesaplıyor [JavaHash](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452) bir ipten. Bu karma işlevi ne hızlı ne de iyi bir kaliteye sahip değildir. Bunu kullanmanın tek nedeni, bu algoritmanın zaten başka bir sistemde kullanılmasıdır ve tam olarak aynı sonucu hesaplamanız gerekir. + +**Sözdizimi** + +``` sql +SELECT javaHash(''); +``` + +**Döndürülen değer** + +A `Int32` veri türü karma değeri. + +**Örnek** + +Sorgu: + +``` sql +SELECT javaHash('Hello, world!'); +``` + +Sonuç: + +``` text +┌─javaHash('Hello, world!')─┐ +│ -1880044555 │ +└───────────────────────────┘ +``` + +## javaHashUTF16LE {#javahashutf16le} + +Hesaplıyor [JavaHash](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452) bir dizeden, UTF-16LE kodlamasında bir dizeyi temsil eden bayt içerdiğini varsayarak. + +**Sözdizimi** + +``` sql +javaHashUTF16LE(stringUtf16le) +``` + +**Parametre** + +- `stringUtf16le` — a string in UTF-16LE encoding. + +**Döndürülen değer** + +A `Int32` veri türü karma değeri. + +**Örnek** + +UTF-16LE kodlanmış dize ile doğru sorgu. + +Sorgu: + +``` sql +SELECT javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le')) +``` + +Sonuç: + +``` text +┌─javaHashUTF16LE(convertCharset('test', 'utf-8', 'utf-16le'))─┐ +│ 3556498 │ +└──────────────────────────────────────────────────────────────┘ +``` + +## hiveHash {#hash-functions-hivehash} + +Hesaplıyor `HiveHash` bir ipten. + +``` sql +SELECT hiveHash(''); +``` + +Bu sadece [JavaHash](#hash_functions-javahash) sıfırlanmış işaret biti ile. Bu işlev kullanılır [Apache Kov Hanı](https://en.wikipedia.org/wiki/Apache_Hive) 3.0 öncesi sürümler için. Bu karma işlevi ne hızlı ne de iyi bir kaliteye sahip değildir. Bunu kullanmanın tek nedeni, bu algoritmanın zaten başka bir sistemde kullanılmasıdır ve tam olarak aynı sonucu hesaplamanız gerekir. + +**Döndürülen değer** + +A `Int32` veri türü karma değeri. + +Tür: `hiveHash`. + +**Örnek** + +Sorgu: + +``` sql +SELECT hiveHash('Hello, world!'); +``` + +Sonuç: + +``` text +┌─hiveHash('Hello, world!')─┐ +│ 267439093 │ +└───────────────────────────┘ +``` + +## metroHash64 {#metrohash64} + +64-bit üretir [MetroHash](http://www.jandrewrogers.com/2015/05/27/metrohash/) karma değeri. + +``` sql +metroHash64(par1, ...) +``` + +**Parametre** + +Fonksiyon, değişken sayıda giriş parametresi alır. Parametreler herhangi biri olabilir [desteklenen veri türleri](../../sql_reference/data_types/index.md). + +**Döndürülen Değer** + +A [Uİnt64](../../sql_reference/data_types/int_uint.md) veri türü karma değeri. + +**Örnek** + +``` sql +SELECT metroHash64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MetroHash, toTypeName(MetroHash) AS type +``` + +``` text +┌────────────MetroHash─┬─type───┐ +│ 14235658766382344533 │ UInt64 │ +└──────────────────────┴────────┘ +``` + +## jumpConsistentHash {#jumpconsistenthash} + +Bir Uint64 Formu jumpconsistenthash hesaplar. +İki bağımsız değişkeni kabul eder: bir uint64 tipi anahtar ve kova sayısı. Int32 Döndürür. +Daha fazla bilgi için bağlantıya bakın: [JumpConsistentHash](https://arxiv.org/pdf/1406.2294.pdf) + +## murmurHash2\_32, murmurHash2\_64 {#murmurhash2-32-murmurhash2-64} + +Üreten bir [MurmurHash2](https://github.com/aappleby/smhasher) karma değeri. + +``` sql +murmurHash2_32(par1, ...) +murmurHash2_64(par1, ...) +``` + +**Parametre** + +Her iki işlev de değişken sayıda giriş parametresi alır. Parametreler herhangi biri olabilir [desteklenen veri türleri](../../sql_reference/data_types/index.md). + +**Döndürülen Değer** + +- Bu `murmurHash2_32` fonksiyon hash değerini döndürür [Uİnt32](../../sql_reference/data_types/int_uint.md) veri türü. +- Bu `murmurHash2_64` fonksiyon hash değerini döndürür [Uİnt64](../../sql_reference/data_types/int_uint.md) veri türü. + +**Örnek** + +``` sql +SELECT murmurHash2_64(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash2, toTypeName(MurmurHash2) AS type +``` + +``` text +┌──────────MurmurHash2─┬─type───┐ +│ 11832096901709403633 │ UInt64 │ +└──────────────────────┴────────┘ +``` + +## murmurHash3\_32, murmurHash3\_64 {#murmurhash3-32-murmurhash3-64} + +Üreten bir [MurmurHash3](https://github.com/aappleby/smhasher) karma değeri. + +``` sql +murmurHash3_32(par1, ...) +murmurHash3_64(par1, ...) +``` + +**Parametre** + +Her iki işlev de değişken sayıda giriş parametresi alır. Parametreler herhangi biri olabilir [desteklenen veri türleri](../../sql_reference/data_types/index.md). + +**Döndürülen Değer** + +- Bu `murmurHash3_32` fonksiyon bir [Uİnt32](../../sql_reference/data_types/int_uint.md) veri türü karma değeri. +- Bu `murmurHash3_64` fonksiyon bir [Uİnt64](../../sql_reference/data_types/int_uint.md) veri türü karma değeri. + +**Örnek** + +``` sql +SELECT murmurHash3_32(array('e','x','a'), 'mple', 10, toDateTime('2019-06-15 23:00:00')) AS MurmurHash3, toTypeName(MurmurHash3) AS type +``` + +``` text +┌─MurmurHash3─┬─type───┐ +│ 2152717 │ UInt32 │ +└─────────────┴────────┘ +``` + +## murmurHash3\_128 {#murmurhash3-128} + +128-bit üretir [MurmurHash3](https://github.com/aappleby/smhasher) karma değeri. + +``` sql +murmurHash3_128( expr ) +``` + +**Parametre** + +- `expr` — [İfadeler](../syntax.md#syntax-expressions) dönen bir [Dize](../../sql_reference/data_types/string.md)- tip değeri. + +**Döndürülen Değer** + +A [FixedString (16)](../../sql_reference/data_types/fixedstring.md) veri türü karma değeri. + +**Örnek** + +``` sql +SELECT murmurHash3_128('example_string') AS MurmurHash3, toTypeName(MurmurHash3) AS type +``` + +``` text +┌─MurmurHash3──────┬─type────────────┐ +│ 6�1�4"S5KT�~~q │ FixedString(16) │ +└──────────────────┴─────────────────┘ +``` + +## xxHash32, xxHash64 {#hash-functions-xxhash32} + +Hesaplıyor `xxHash` bir ipten. İki tat, 32 ve 64 bit olarak önerilmiştir. + +``` sql +SELECT xxHash32(''); + +OR + +SELECT xxHash64(''); +``` + +**Döndürülen değer** + +A `Uint32` veya `Uint64` veri türü karma değeri. + +Tür: `xxHash`. + +**Örnek** + +Sorgu: + +``` sql +SELECT xxHash32('Hello, world!'); +``` + +Sonuç: + +``` text +┌─xxHash32('Hello, world!')─┐ +│ 834093149 │ +└───────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [xxHash](http://cyan4973.github.io/xxHash/). + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/hash_functions/) diff --git a/docs/tr/sql_reference/functions/higher_order_functions.md b/docs/tr/sql_reference/functions/higher_order_functions.md new file mode 100644 index 00000000000..e5faadc689a --- /dev/null +++ b/docs/tr/sql_reference/functions/higher_order_functions.md @@ -0,0 +1,264 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 57 +toc_title: "Y\xFCksek Sipari\u015F" +--- + +# Yüksek mertebeden fonksiyonlar {#higher-order-functions} + +## `->` operatör, lambda (params, expr) fonksiyonu {#operator-lambdaparams-expr-function} + +Allows describing a lambda function for passing to a higher-order function. The left side of the arrow has a formal parameter, which is any ID, or multiple formal parameters – any IDs in a tuple. The right side of the arrow has an expression that can use these formal parameters, as well as any table columns. + +Örnekler: `x -> 2 * x, str -> str != Referer.` + +Daha yüksek mertebeden işlevler yalnızca Lambda işlevlerini işlevsel argümanları olarak kabul edebilir. + +Birden çok bağımsız değişkeni kabul eden bir lambda işlevi, daha yüksek mertebeden bir işleve geçirilebilir. Bu durumda, yüksek mertebeden işlev, bu bağımsız değişkenlerin karşılık geleceği aynı uzunlukta birkaç diziden geçirilir. + +Gibi bazı işlevler için [arrayCount](#higher_order_functions-array-count) veya [arraySum](#higher_order_functions-array-count), ilk argüman (lambda işlevi) ihmal edilebilir. Bu durumda, aynı eşleme varsayılır. + +Aşağıdaki işlevler için bir lambda işlevi ihmal edilemez: + +- [arrayMap](#higher_order_functions-array-map) +- [arrayFilter](#higher_order_functions-array-filter) +- [arrayFill](#higher_order_functions-array-fill) +- [arrayReverseFill](#higher_order_functions-array-reverse-fill) +- [arraySplit](#higher_order_functions-array-split) +- [arrayReverseSplit](#higher_order_functions-array-reverse-split) +- [arrayFirst](#higher_order_functions-array-first) +- [arrayFirstİndex](#higher_order_functions-array-first-index) + +### arrayMap(func, arr1, …) {#higher_order_functions-array-map} + +Özgün uygulamadan elde edilen bir dizi döndürür `func` fonksiyon inunda her ele elementmana `arr` dizi. + +Örnekler: + +``` sql +SELECT arrayMap(x -> (x + 2), [1, 2, 3]) as res; +``` + +``` text +┌─res─────┐ +│ [3,4,5] │ +└─────────┘ +``` + +Aşağıdaki örnek, farklı dizilerden bir öğe kümesinin nasıl oluşturulacağını gösterir: + +``` sql +SELECT arrayMap((x, y) -> (x, y), [1, 2, 3], [4, 5, 6]) AS res +``` + +``` text +┌─res─────────────────┐ +│ [(1,4),(2,5),(3,6)] │ +└─────────────────────┘ +``` + +İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayMap` işlev. + +### arrayFilter(func, arr1, …) {#higher_order_functions-array-filter} + +Yalnızca öğeleri içeren bir dizi döndürür `arr1` hangi için `func` 0'dan başka bir şey döndürür. + +Örnekler: + +``` sql +SELECT arrayFilter(x -> x LIKE '%World%', ['Hello', 'abc World']) AS res +``` + +``` text +┌─res───────────┐ +│ ['abc World'] │ +└───────────────┘ +``` + +``` sql +SELECT + arrayFilter( + (i, x) -> x LIKE '%World%', + arrayEnumerate(arr), + ['Hello', 'abc World'] AS arr) + AS res +``` + +``` text +┌─res─┐ +│ [2] │ +└─────┘ +``` + +İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayFilter` işlev. + +### arrayFill(func, arr1, …) {#higher_order_functions-array-fill} + +Tarama yoluyla `arr1` ilk öğeden son öğeye ve değiştir `arr1[i]` tarafından `arr1[i - 1]` eğer `func` 0 döndürür. İlk eleman `arr1` değiştir notilm .eyecektir. + +Örnekler: + +``` sql +SELECT arrayFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res +``` + +``` text +┌─res──────────────────────────────┐ +│ [1,1,3,11,12,12,12,5,6,14,14,14] │ +└──────────────────────────────────┘ +``` + +İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayFill` işlev. + +### arrayReverseFill(func, arr1, …) {#higher_order_functions-array-reverse-fill} + +Tarama yoluyla `arr1` son öğeden ilk öğeye ve değiştir `arr1[i]` tarafından `arr1[i + 1]` eğer `func` 0 döndürür. The La lastst element of `arr1` değiştir notilm .eyecektir. + +Örnekler: + +``` sql +SELECT arrayReverseFill(x -> not isNull(x), [1, null, 3, 11, 12, null, null, 5, 6, 14, null, null]) AS res +``` + +``` text +┌─res────────────────────────────────┐ +│ [1,3,3,11,12,5,5,5,6,14,NULL,NULL] │ +└────────────────────────────────────┘ +``` + +İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayReverseFill` işlev. + +### arraySplit(func, arr1, …) {#higher_order_functions-array-split} + +Bölme `arr1` birden fazla diziye. Ne zaman `func` 0'dan başka bir şey döndürür, dizi öğenin sol tarafında bölünecektir. Dizi ilk öğeden önce bölünmez. + +Örnekler: + +``` sql +SELECT arraySplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res +``` + +``` text +┌─res─────────────┐ +│ [[1,2,3],[4,5]] │ +└─────────────────┘ +``` + +İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arraySplit` işlev. + +### arrayReverseSplit(func, arr1, …) {#higher_order_functions-array-reverse-split} + +Bölme `arr1` birden fazla diziye. Ne zaman `func` 0'dan başka bir şey döndürür, dizi öğenin sağ tarafında bölünecektir. Dizi son öğeden sonra bölünmez. + +Örnekler: + +``` sql +SELECT arrayReverseSplit((x, y) -> y, [1, 2, 3, 4, 5], [1, 0, 0, 1, 0]) AS res +``` + +``` text +┌─res───────────────┐ +│ [[1],[2,3,4],[5]] │ +└───────────────────┘ +``` + +İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arraySplit` işlev. + +### arrayCount(\[func,\] arr1, …) {#higher_order_functions-array-count} + +Func 0'dan başka bir şey döndüren arr dizisindeki öğelerin sayısını döndürür. Eğer ‘func’ belirtilmemişse, dizideki sıfır olmayan öğelerin sayısını döndürür. + +### arrayExists(\[func,\] arr1, …) {#arrayexistsfunc-arr1} + +İçinde en az bir öğe varsa 1 değerini döndürür ‘arr’ hangi için ‘func’ 0'dan başka bir şey döndürür. Aksi takdirde, 0 döndürür. + +### arrayAll(\[func,\] arr1, …) {#arrayallfunc-arr1} + +Döner 1 Eğer ‘func’ içindeki tüm öğeler için 0'dan başka bir şey döndürür ‘arr’. Aksi takdirde, 0 döndürür. + +### arraySum(\[func,\] arr1, …) {#higher-order-functions-array-sum} + +Toplamını döndürür ‘func’ değerler. İşlev atlanırsa, sadece dizi öğelerinin toplamını döndürür. + +### arrayFirst(func, arr1, …) {#higher_order_functions-array-first} + +İlk öğeyi döndürür ‘arr1’ dizi hangi ‘func’ 0'dan başka bir şey döndürür. + +İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayFirst` işlev. + +### arrayFirstIndex(func, arr1, …) {#higher_order_functions-array-first-index} + +İlk öğenin dizinini döndürür ‘arr1’ dizi hangi ‘func’ 0'dan başka bir şey döndürür. + +İlk argümanın (lambda işlevi) atlanamayacağını unutmayın. `arrayFirstIndex` işlev. + +### arrayCumSum(\[func,\] arr1, …) {#arraycumsumfunc-arr1} + +Kaynak dizideki öğelerin kısmi toplamlarının bir dizisini döndürür (çalışan bir toplam). Eğer... `func` işlev belirtilir, daha sonra dizi öğelerinin değerleri toplanmadan önce bu işlev tarafından dönüştürülür. + +Örnek: + +``` sql +SELECT arrayCumSum([1, 1, 1, 1]) AS res +``` + +``` text +┌─res──────────┐ +│ [1, 2, 3, 4] │ +└──────────────┘ +``` + +### arrayCumSumNonNegative(arr) {#arraycumsumnonnegativearr} + +Aynı olarak `arrayCumSum`, kaynak dizideki öğelerin kısmi toplamlarının bir dizisini döndürür (çalışan bir toplam). Farklı `arrayCumSum`, daha sonra döndürülen değer sıfırdan küçük bir değer içerdiğinde, değer sıfır ile değiştirilir ve sonraki hesaplama sıfır parametrelerle gerçekleştirilir. Mesela: + +``` sql +SELECT arrayCumSumNonNegative([1, 1, -4, 1]) AS res +``` + +``` text +┌─res───────┐ +│ [1,2,0,1] │ +└───────────┘ +``` + +### arraySort(\[func,\] arr1, …) {#arraysortfunc-arr1} + +Öğeleri sıralama sonucu bir dizi döndürür `arr1` artan düzende. Eğer... `func` fonksiyon belirtilir, sıralama sırası fonksiyonun sonucu ile belirlenir `func` dizi elemanlarına uygulanır (diziler) + +Bu [Schwartzian dönüşümü](https://en.wikipedia.org/wiki/Schwartzian_transform) sıralama verimliliğini artırmak için kullanılır. + +Örnek: + +``` sql +SELECT arraySort((x, y) -> y, ['hello', 'world'], [2, 1]); +``` + +``` text +┌─res────────────────┐ +│ ['world', 'hello'] │ +└────────────────────┘ +``` + +Hakkında daha fazla bilgi için `arraySort` yöntem, görmek [Dizilerle çalışmak için işlevler](array_functions.md#array_functions-sort) bölme. + +### arrayReverseSort(\[func,\] arr1, …) {#arrayreversesortfunc-arr1} + +Öğeleri sıralama sonucu bir dizi döndürür `arr1` azalan sırada. Eğer... `func` fonksiyon belirtilir, sıralama sırası fonksiyonun sonucu ile belirlenir `func` dizi (diziler) elemanlarına uygulanır. + +Örnek: + +``` sql +SELECT arrayReverseSort((x, y) -> y, ['hello', 'world'], [2, 1]) as res; +``` + +``` text +┌─res───────────────┐ +│ ['hello','world'] │ +└───────────────────┘ +``` + +Hakkında daha fazla bilgi için `arrayReverseSort` yöntem, görmek [Dizilerle çalışmak için işlevler](array_functions.md#array_functions-reverse-sort) bölme. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/higher_order_functions/) diff --git a/docs/tr/sql_reference/functions/in_functions.md b/docs/tr/sql_reference/functions/in_functions.md new file mode 100644 index 00000000000..481c1b61802 --- /dev/null +++ b/docs/tr/sql_reference/functions/in_functions.md @@ -0,0 +1,26 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 60 +toc_title: "In \u0130\u015Flet theic implementingisinin uygulanmas\u0131" +--- + +# In operatörünü uygulamak için işlevler {#functions-for-implementing-the-in-operator} + +## içinde, notİn, globalİn, globalNotİn {#in-functions} + +Bölümüne bakınız [Operatör İNLERDE](../statements/select.md#select-in-operators). + +## tuple(x, y, …), operator (x, y, …) {#tuplex-y-operator-x-y} + +Birden çok sütun gruplama sağlayan bir işlev. +For columns with the types T1, T2, …, it returns a Tuple(T1, T2, …) type tuple containing these columns. There is no cost to execute the function. +Tuples normalde bir argüman için Ara değerler olarak kullanılır operatörler, veya lambda fonksiyonlarının resmi parametrelerin bir listesini oluşturmak için. Tuples bir masaya yazılamaz. + +## tupleElement (tuple, n), operatör x. N {#tupleelementtuple-n-operator-x-n} + +Bir tuple bir sütun alma sağlayan bir işlev. +‘N’ 1'den başlayarak sütun dizinidir. N sabit olmalıdır. ‘N’ bir sabit olması gerekir. ‘N’ tuple boyutundan daha büyük olmayan katı bir pozitif tamsayı olmalıdır. +İşlevi yürütmek için hiçbir maliyet yoktur. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/in_functions/) diff --git a/docs/tr/sql_reference/functions/index.md b/docs/tr/sql_reference/functions/index.md new file mode 100644 index 00000000000..01961c69526 --- /dev/null +++ b/docs/tr/sql_reference/functions/index.md @@ -0,0 +1,74 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "\u0130\u015Flevler" +toc_priority: 32 +toc_title: "Giri\u015F" +--- + +# İşlevler {#functions} + +En az\* iki tür fonksiyon vardır-düzenli Fonksiyonlar (sadece denir “functions”) and aggregate functions. These are completely different concepts. Regular functions work as if they are applied to each row separately (for each row, the result of the function doesn't depend on the other rows). Aggregate functions accumulate a set of values from various rows (i.e. they depend on the entire set of rows). + +Bu bölümde düzenli işlevleri tartışıyoruz. Toplama işlevleri için bölüme bakın “Aggregate functions”. + +\* - Üçüncü bir işlev türü vardır ‘arrayJoin’ fonksiyon aittir; tablo fonksiyonları da ayrı ayrı belirtilebilir.\* + +## Güçlü yazarak {#strong-typing} + +Standart SQL aksine, ClickHouse güçlü yazarak vardır. Başka bir deyişle, türler arasında örtük dönüşümler yapmaz. Her işlev belirli bir tür kümesi için çalışır. Bu, bazen tür dönüştürme işlevlerini kullanmanız gerektiği anlamına gelir. + +## Ortak subexpression eliminasyonu {#common-subexpression-elimination} + +Aynı AST (aynı kayıt veya sözdizimsel ayrıştırma aynı sonucu) olan bir sorgudaki tüm ifadeler aynı değerlere sahip olarak kabul edilir. Bu tür ifadeler bir kez birleştirilir ve yürütülür. Aynı alt sorgular da bu şekilde elimine edilir. + +## Sonuç türleri {#types-of-results} + +Tüm işlevler sonuç olarak tek bir dönüş döndürür (birkaç değer değil, sıfır değer değil). Sonuç türü genellikle değerlerle değil, yalnızca bağımsız değişken türleriyle tanımlanır. Özel durumlar tupleElement işlevi (a.n işleci) ve tofixedstring işlevidir. + +## Devamlılar {#constants} + +Basitlik için, bazı işlevler yalnızca bazı argümanlar için sabitlerle çalışabilir. Örneğin, LİKE operatörünün doğru argümanı sabit olmalıdır. +Hemen hemen tüm işlevler sabit argümanlar için bir sabit döndürür. İstisna, rasgele sayılar üreten işlevlerdir. +Bu ‘now’ işlev, farklı zamanlarda çalıştırılan sorgular için farklı değerler döndürür, ancak sonuç sabit olarak kabul edilir, çünkü sabitlik yalnızca tek bir sorguda önemlidir. +Sabit bir ifade de sabit olarak kabul edilir (örneğin, LİKE operatörünün sağ yarısı birden fazla sabitten oluşturulabilir). + +Fonksiyonlar sabit ve sabit olmayan argümanlar için farklı şekillerde uygulanabilir (farklı kod yürütülür). Ancak, bir sabit ve yalnızca aynı değeri içeren gerçek bir sütun için sonuçlar birbiriyle eşleşmelidir. + +## NULL işleme {#null-processing} + +Fonksiyonlar aşağıdaki davranışlara sahiptir: + +- İşlevin argümanlarından en az biri ise `NULL`, fonksiyon sonucu da `NULL`. +- Her işlevin açıklamasında ayrı ayrı belirtilen özel davranış. ClickHouse kaynak kodunda, bu işlevler `UseDefaultImplementationForNulls=false`. + +## Süreklilik {#constancy} + +Functions can't change the values of their arguments – any changes are returned as the result. Thus, the result of calculating separate functions does not depend on the order in which the functions are written in the query. + +## Hata işleme {#error-handling} + +Veriler geçersizse bazı işlevler bir istisna oluşturabilir. Bu durumda, sorgu iptal edilir ve bir hata metni istemciye döndürülür. Dağıtılmış işlem için sunuculardan birinde bir özel durum oluştuğunda, diğer sunucular da sorguyu iptal etmeye çalışır. + +## Argüman ifadelerinin değerlendirilmesi {#evaluation-of-argument-expressions} + +Hemen hemen tüm programlama dillerinde, argümanlardan biri belirli operatörler için değerlendirilmeyebilir. Bu genellikle operatörler `&&`, `||`, ve `?:`. +Ancak Clickhouse'da, fonksiyonların (operatörler) argümanları her zaman değerlendirilir. Bunun nedeni, sütunların tüm bölümlerinin her satırı ayrı ayrı hesaplamak yerine bir kerede değerlendirilmesidir. + +## Dağıtılmış sorgu işleme işlevleri gerçekleştirme {#performing-functions-for-distributed-query-processing} + +Dağıtılmış sorgu işleme için, sorgu işlemenin mümkün olduğu kadar çok aşaması uzak sunucularda gerçekleştirilir ve aşamaların geri kalanı (Ara sonuçları ve bundan sonra her şeyi birleştirme) istek sahibi sunucuda gerçekleştirilir. + +Bu, işlevlerin farklı sunucularda gerçekleştirilebileceği anlamına gelir. +Örneğin, sorguda `SELECT f(sum(g(x))) FROM distributed_table GROUP BY h(y),` + +- eğer bir `distributed_table` en az iki parçaya sahiptir, fonksiyonlar ‘g’ ve ‘h’ uzak sunucularda gerçekleştirilir ve işlev ‘f’ ıstekçi sunucuda gerçekleştirilir. +- eğer bir `distributed_table` sadece bir parça var, tüm ‘f’, ‘g’, ve ‘h’ fonksiyonlar bu shard'ın sunucusunda gerçekleştirilir. + +Bir işlevin sonucu genellikle hangi sunucuda gerçekleştirildiğine bağlı değildir. Ancak, bazen bu önemlidir. +Örneğin, sözlüklerle çalışan işlevler, üzerinde çalışmakta oldukları sunucuda bulunan sözlüğü kullanır. +Başka bir örnek ise `hostName` yapmak için üzerinde çalıştığı sunucunun adını döndüren işlev `GROUP BY` sunucular tarafından bir `SELECT` sorgu. + +Eğer sorguda bir işlevi istemcisi sunucu üzerinde yapılır, ama uzak sunucularda bunu gerçekleştirmek için ihtiyacınız varsa, bir saramaz mısın ‘any’ toplama işlevi veya bir anahtara ekleyin `GROUP BY`. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/) diff --git a/docs/tr/sql_reference/functions/introspection.md b/docs/tr/sql_reference/functions/introspection.md new file mode 100644 index 00000000000..fdc68fe76fb --- /dev/null +++ b/docs/tr/sql_reference/functions/introspection.md @@ -0,0 +1,310 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 65 +toc_title: "\u0130\xE7g\xF6zlem" +--- + +# İç Gözlem Fonksiyonları {#introspection-functions} + +İç gözlem için bu bölümde açıklanan işlevleri kullanabilirsiniz [ELF](https://en.wikipedia.org/wiki/Executable_and_Linkable_Format) ve [DWARF](https://en.wikipedia.org/wiki/DWARF) sorgu profilleme için. + +!!! warning "Uyarıcı" + Bu işlevler yavaştır ve güvenlik konuları getirebilir. + +İç gözlem fonksiyonlarının düzgün çalışması için: + +- Yüklemek `clickhouse-common-static-dbg` paket. + +- Ayarla... [allow\_introspection\_functions](../../operations/settings/settings.md#settings-allow_introspection_functions) ayar 1. + + For security reasons introspection functions are disabled by default. + +ClickHouse için profiler raporları kaydeder [trace\_log](../../operations/system_tables.md#system_tables-trace_log) sistem tablosu. Tablo ve profiler düzgün yapılandırıldığından emin olun. + +## addressToLine {#addresstoline} + +ClickHouse sunucu işleminin içindeki sanal bellek adresini dosya adına ve clickhouse kaynak kodundaki satır numarasına dönüştürür. + +Resmi ClickHouse paketleri kullanırsanız, yüklemeniz gerekir `clickhouse-common-static-dbg` paket. + +**Sözdizimi** + +``` sql +addressToLine(address_of_binary_instruction) +``` + +**Parametre** + +- `address_of_binary_instruction` ([Uİnt64](../../sql_reference/data_types/int_uint.md)) — Address of instruction in a running process. + +**Döndürülen değer** + +- Kaynak kodu dosya adı ve bu dosyadaki satır numarası iki nokta üst üste ile sınırlandırılmıştır. + + For example, `/build/obj-x86_64-linux-gnu/../src/Common/ThreadPool.cpp:199`, where `199` is a line number. + +- Işlev hata ayıklama bilgilerini bulamadıysanız, bir ikili adı. + +- Adres geçerli değilse, boş dize. + +Tür: [Dize](../../sql_reference/data_types/string.md). + +**Örnek** + +İç gözlem işlevlerini etkinleştirme: + +``` sql +SET allow_introspection_functions=1 +``` + +İlk dizeyi seçme `trace_log` sistem tablosu: + +``` sql +SELECT * FROM system.trace_log LIMIT 1 \G +``` + +``` text +Row 1: +────── +event_date: 2019-11-19 +event_time: 2019-11-19 18:57:23 +revision: 54429 +timer_type: Real +thread_number: 48 +query_id: 421b6855-1858-45a5-8f37-f383409d6d72 +trace: [140658411141617,94784174532828,94784076370703,94784076372094,94784076361020,94784175007680,140658411116251,140658403895439] +``` + +Bu `trace` alan, örnekleme anında yığın izini içerir. + +Tek bir adres için kaynak kodu dosya adını ve satır numarasını alma: + +``` sql +SELECT addressToLine(94784076370703) \G +``` + +``` text +Row 1: +────── +addressToLine(94784076370703): /build/obj-x86_64-linux-gnu/../src/Common/ThreadPool.cpp:199 +``` + +İşlevin tüm yığın izine uygulanması: + +``` sql +SELECT + arrayStringConcat(arrayMap(x -> addressToLine(x), trace), '\n') AS trace_source_code_lines +FROM system.trace_log +LIMIT 1 +\G +``` + +Bu [arrayMap](higher_order_functions.md#higher_order_functions-array-map) işlev, her bir elemanın işlenmesini sağlar `trace` ar arrayray by the `addressToLine` işlev. Gördüğünüz bu işlemin sonucu `trace_source_code_lines` çıktı sütunu. + +``` text +Row 1: +────── +trace_source_code_lines: /lib/x86_64-linux-gnu/libpthread-2.27.so +/usr/lib/debug/usr/bin/clickhouse +/build/obj-x86_64-linux-gnu/../src/Common/ThreadPool.cpp:199 +/build/obj-x86_64-linux-gnu/../src/Common/ThreadPool.h:155 +/usr/include/c++/9/bits/atomic_base.h:551 +/usr/lib/debug/usr/bin/clickhouse +/lib/x86_64-linux-gnu/libpthread-2.27.so +/build/glibc-OTsEL5/glibc-2.27/misc/../sysdeps/unix/sysv/linux/x86_64/clone.S:97 +``` + +## addressToSymbol {#addresstosymbol} + +Clickhouse sunucu işlemi içindeki sanal bellek adresini ClickHouse nesne dosyalarından gelen simgeye dönüştürür. + +**Sözdizimi** + +``` sql +addressToSymbol(address_of_binary_instruction) +``` + +**Parametre** + +- `address_of_binary_instruction` ([Uİnt64](../../sql_reference/data_types/int_uint.md)) — Address of instruction in a running process. + +**Döndürülen değer** + +- ClickHouse nesne dosyalarından sembol. +- Adres geçerli değilse, boş dize. + +Tür: [Dize](../../sql_reference/data_types/string.md). + +**Örnek** + +İç gözlem işlevlerini etkinleştirme: + +``` sql +SET allow_introspection_functions=1 +``` + +İlk dizeyi seçme `trace_log` sistem tablosu: + +``` sql +SELECT * FROM system.trace_log LIMIT 1 \G +``` + +``` text +Row 1: +────── +event_date: 2019-11-20 +event_time: 2019-11-20 16:57:59 +revision: 54429 +timer_type: Real +thread_number: 48 +query_id: 724028bf-f550-45aa-910d-2af6212b94ac +trace: [94138803686098,94138815010911,94138815096522,94138815101224,94138815102091,94138814222988,94138806823642,94138814457211,94138806823642,94138814457211,94138806823642,94138806795179,94138806796144,94138753770094,94138753771646,94138753760572,94138852407232,140399185266395,140399178045583] +``` + +Bu `trace` alan, örnekleme anında yığın izini içerir. + +Tek bir adres için sembol alma: + +``` sql +SELECT addressToSymbol(94138803686098) \G +``` + +``` text +Row 1: +────── +addressToSymbol(94138803686098): _ZNK2DB24IAggregateFunctionHelperINS_20AggregateFunctionSumImmNS_24AggregateFunctionSumDataImEEEEE19addBatchSinglePlaceEmPcPPKNS_7IColumnEPNS_5ArenaE +``` + +İşlevin tüm yığın izine uygulanması: + +``` sql +SELECT + arrayStringConcat(arrayMap(x -> addressToSymbol(x), trace), '\n') AS trace_symbols +FROM system.trace_log +LIMIT 1 +\G +``` + +Bu [arrayMap](higher_order_functions.md#higher_order_functions-array-map) işlev, her bir elemanın işlenmesini sağlar `trace` ar arrayray by the `addressToSymbols` işlev. Gördüğünüz bu işlemin sonucu `trace_symbols` çıktı sütunu. + +``` text +Row 1: +────── +trace_symbols: _ZNK2DB24IAggregateFunctionHelperINS_20AggregateFunctionSumImmNS_24AggregateFunctionSumDataImEEEEE19addBatchSinglePlaceEmPcPPKNS_7IColumnEPNS_5ArenaE +_ZNK2DB10Aggregator21executeWithoutKeyImplERPcmPNS0_28AggregateFunctionInstructionEPNS_5ArenaE +_ZN2DB10Aggregator14executeOnBlockESt6vectorIN3COWINS_7IColumnEE13immutable_ptrIS3_EESaIS6_EEmRNS_22AggregatedDataVariantsERS1_IPKS3_SaISC_EERS1_ISE_SaISE_EERb +_ZN2DB10Aggregator14executeOnBlockERKNS_5BlockERNS_22AggregatedDataVariantsERSt6vectorIPKNS_7IColumnESaIS9_EERS6_ISB_SaISB_EERb +_ZN2DB10Aggregator7executeERKSt10shared_ptrINS_17IBlockInputStreamEERNS_22AggregatedDataVariantsE +_ZN2DB27AggregatingBlockInputStream8readImplEv +_ZN2DB17IBlockInputStream4readEv +_ZN2DB26ExpressionBlockInputStream8readImplEv +_ZN2DB17IBlockInputStream4readEv +_ZN2DB26ExpressionBlockInputStream8readImplEv +_ZN2DB17IBlockInputStream4readEv +_ZN2DB28AsynchronousBlockInputStream9calculateEv +_ZNSt17_Function_handlerIFvvEZN2DB28AsynchronousBlockInputStream4nextEvEUlvE_E9_M_invokeERKSt9_Any_data +_ZN14ThreadPoolImplI20ThreadFromGlobalPoolE6workerESt14_List_iteratorIS0_E +_ZZN20ThreadFromGlobalPoolC4IZN14ThreadPoolImplIS_E12scheduleImplIvEET_St8functionIFvvEEiSt8optionalImEEUlvE1_JEEEOS4_DpOT0_ENKUlvE_clEv +_ZN14ThreadPoolImplISt6threadE6workerESt14_List_iteratorIS0_E +execute_native_thread_routine +start_thread +clone +``` + +## demangle {#demangle} + +Kullanarak alabileceğiniz bir sembolü dönüştürür [addressToSymbol](#addresstosymbol) C++ işlev adına işlev. + +**Sözdizimi** + +``` sql +demangle(symbol) +``` + +**Parametre** + +- `symbol` ([Dize](../../sql_reference/data_types/string.md)) — Symbol from an object file. + +**Döndürülen değer** + +- C++ işlevinin adı. +- Bir sembol geçerli değilse boş dize. + +Tür: [Dize](../../sql_reference/data_types/string.md). + +**Örnek** + +İç gözlem işlevlerini etkinleştirme: + +``` sql +SET allow_introspection_functions=1 +``` + +İlk dizeyi seçme `trace_log` sistem tablosu: + +``` sql +SELECT * FROM system.trace_log LIMIT 1 \G +``` + +``` text +Row 1: +────── +event_date: 2019-11-20 +event_time: 2019-11-20 16:57:59 +revision: 54429 +timer_type: Real +thread_number: 48 +query_id: 724028bf-f550-45aa-910d-2af6212b94ac +trace: [94138803686098,94138815010911,94138815096522,94138815101224,94138815102091,94138814222988,94138806823642,94138814457211,94138806823642,94138814457211,94138806823642,94138806795179,94138806796144,94138753770094,94138753771646,94138753760572,94138852407232,140399185266395,140399178045583] +``` + +Bu `trace` alan, örnekleme anında yığın izini içerir. + +Tek bir adres için bir işlev adı alma: + +``` sql +SELECT demangle(addressToSymbol(94138803686098)) \G +``` + +``` text +Row 1: +────── +demangle(addressToSymbol(94138803686098)): DB::IAggregateFunctionHelper > >::addBatchSinglePlace(unsigned long, char*, DB::IColumn const**, DB::Arena*) const +``` + +İşlevin tüm yığın izine uygulanması: + +``` sql +SELECT + arrayStringConcat(arrayMap(x -> demangle(addressToSymbol(x)), trace), '\n') AS trace_functions +FROM system.trace_log +LIMIT 1 +\G +``` + +Bu [arrayMap](higher_order_functions.md#higher_order_functions-array-map) işlev, her bir elemanın işlenmesini sağlar `trace` ar arrayray by the `demangle` işlev. Gördüğünüz bu işlemin sonucu `trace_functions` çıktı sütunu. + +``` text +Row 1: +────── +trace_functions: DB::IAggregateFunctionHelper > >::addBatchSinglePlace(unsigned long, char*, DB::IColumn const**, DB::Arena*) const +DB::Aggregator::executeWithoutKeyImpl(char*&, unsigned long, DB::Aggregator::AggregateFunctionInstruction*, DB::Arena*) const +DB::Aggregator::executeOnBlock(std::vector::immutable_ptr, std::allocator::immutable_ptr > >, unsigned long, DB::AggregatedDataVariants&, std::vector >&, std::vector >, std::allocator > > >&, bool&) +DB::Aggregator::executeOnBlock(DB::Block const&, DB::AggregatedDataVariants&, std::vector >&, std::vector >, std::allocator > > >&, bool&) +DB::Aggregator::execute(std::shared_ptr const&, DB::AggregatedDataVariants&) +DB::AggregatingBlockInputStream::readImpl() +DB::IBlockInputStream::read() +DB::ExpressionBlockInputStream::readImpl() +DB::IBlockInputStream::read() +DB::ExpressionBlockInputStream::readImpl() +DB::IBlockInputStream::read() +DB::AsynchronousBlockInputStream::calculate() +std::_Function_handler::_M_invoke(std::_Any_data const&) +ThreadPoolImpl::worker(std::_List_iterator) +ThreadFromGlobalPool::ThreadFromGlobalPool::scheduleImpl(std::function, int, std::optional)::{lambda()#3}>(ThreadPoolImpl::scheduleImpl(std::function, int, std::optional)::{lambda()#3}&&)::{lambda()#1}::operator()() const +ThreadPoolImpl::worker(std::_List_iterator) +execute_native_thread_routine +start_thread +clone +``` diff --git a/docs/tr/sql_reference/functions/ip_address_functions.md b/docs/tr/sql_reference/functions/ip_address_functions.md new file mode 100644 index 00000000000..2caa7c49b2a --- /dev/null +++ b/docs/tr/sql_reference/functions/ip_address_functions.md @@ -0,0 +1,248 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 55 +toc_title: "IP adresleriyle \xE7al\u0131\u015Fma" +--- + +# IP adresleriyle çalışmak için işlevler {#functions-for-working-with-ip-addresses} + +## Ipv4numtostring (num) {#ipv4numtostringnum} + +Bir Uınt32 numarası alır. Big endian'da bir IPv4 adresi olarak yorumlar. Karşılık gelen IPv4 adresini a. B. C. d biçiminde içeren bir dize döndürür (ondalık formda nokta ile ayrılmış sayılar). + +## Ipv4stringtonum (s) {#ipv4stringtonums} + +IPv4NumToString ters işlevi. IPv4 adresi geçersiz bir biçime sahipse, 0 döndürür. + +## Ipv4numtostringclassc (num) {#ipv4numtostringclasscnum} + +Ipv4numtostring'e benzer, ancak son sekizli yerine xxx kullanıyor. + +Örnek: + +``` sql +SELECT + IPv4NumToStringClassC(ClientIP) AS k, + count() AS c +FROM test.hits +GROUP BY k +ORDER BY c DESC +LIMIT 10 +``` + +``` text +┌─k──────────────┬─────c─┐ +│ 83.149.9.xxx │ 26238 │ +│ 217.118.81.xxx │ 26074 │ +│ 213.87.129.xxx │ 25481 │ +│ 83.149.8.xxx │ 24984 │ +│ 217.118.83.xxx │ 22797 │ +│ 78.25.120.xxx │ 22354 │ +│ 213.87.131.xxx │ 21285 │ +│ 78.25.121.xxx │ 20887 │ +│ 188.162.65.xxx │ 19694 │ +│ 83.149.48.xxx │ 17406 │ +└────────────────┴───────┘ +``` + +Kullanıl sincedığından beri ‘xxx’ son derece sıradışı, bu gelecekte değiştirilebilir. Bu parçanın tam biçimine güvenmemenizi öneririz. + +### Ipv6numtostring (x) {#ipv6numtostringx} + +IPv6 adresini ikili biçimde içeren bir FixedString(16) değerini kabul eder. Bu adresi metin biçiminde içeren bir dize döndürür. +IPv6 eşlemeli IPv4 adresleri ::ffff:111.222.33.44 biçiminde çıktıdır. Örnekler: + +``` sql +SELECT IPv6NumToString(toFixedString(unhex('2A0206B8000000000000000000000011'), 16)) AS addr +``` + +``` text +┌─addr─────────┐ +│ 2a02:6b8::11 │ +└──────────────┘ +``` + +``` sql +SELECT + IPv6NumToString(ClientIP6 AS k), + count() AS c +FROM hits_all +WHERE EventDate = today() AND substring(ClientIP6, 1, 12) != unhex('00000000000000000000FFFF') +GROUP BY k +ORDER BY c DESC +LIMIT 10 +``` + +``` text +┌─IPv6NumToString(ClientIP6)──────────────┬─────c─┐ +│ 2a02:2168:aaa:bbbb::2 │ 24695 │ +│ 2a02:2698:abcd:abcd:abcd:abcd:8888:5555 │ 22408 │ +│ 2a02:6b8:0:fff::ff │ 16389 │ +│ 2a01:4f8:111:6666::2 │ 16016 │ +│ 2a02:2168:888:222::1 │ 15896 │ +│ 2a01:7e00::ffff:ffff:ffff:222 │ 14774 │ +│ 2a02:8109:eee:ee:eeee:eeee:eeee:eeee │ 14443 │ +│ 2a02:810b:8888:888:8888:8888:8888:8888 │ 14345 │ +│ 2a02:6b8:0:444:4444:4444:4444:4444 │ 14279 │ +│ 2a01:7e00::ffff:ffff:ffff:ffff │ 13880 │ +└─────────────────────────────────────────┴───────┘ +``` + +``` sql +SELECT + IPv6NumToString(ClientIP6 AS k), + count() AS c +FROM hits_all +WHERE EventDate = today() +GROUP BY k +ORDER BY c DESC +LIMIT 10 +``` + +``` text +┌─IPv6NumToString(ClientIP6)─┬──────c─┐ +│ ::ffff:94.26.111.111 │ 747440 │ +│ ::ffff:37.143.222.4 │ 529483 │ +│ ::ffff:5.166.111.99 │ 317707 │ +│ ::ffff:46.38.11.77 │ 263086 │ +│ ::ffff:79.105.111.111 │ 186611 │ +│ ::ffff:93.92.111.88 │ 176773 │ +│ ::ffff:84.53.111.33 │ 158709 │ +│ ::ffff:217.118.11.22 │ 154004 │ +│ ::ffff:217.118.11.33 │ 148449 │ +│ ::ffff:217.118.11.44 │ 148243 │ +└────────────────────────────┴────────┘ +``` + +## Ipv6stringtonum (s) {#ipv6stringtonums} + +IPv6NumToString ters işlevi. IPv6 adresi geçersiz bir biçime sahipse, bir boş bayt dizesi döndürür. +HEX büyük veya küçük harf olabilir. + +## Ipv4toıpv6 (x) {#ipv4toipv6x} + +Alır bir `UInt32` numara. Bir IPv4 adresi olarak yorumlar [büyük endian](https://en.wikipedia.org/wiki/Endianness). Ret aur ANS a `FixedString(16)` IPv6 adresini ikili biçimde içeren değer. Örnekler: + +``` sql +SELECT IPv6NumToString(IPv4ToIPv6(IPv4StringToNum('192.168.0.1'))) AS addr +``` + +``` text +┌─addr───────────────┐ +│ ::ffff:192.168.0.1 │ +└────────────────────┘ +``` + +## cutİPv6 (x, bytesToCutForİPv6, bytesToCutForİPv4) {#cutipv6x-bytestocutforipv6-bytestocutforipv4} + +IPv6 adresini ikili biçimde içeren bir FixedString(16) değerini kabul eder. Metin biçiminde kaldırılan belirtilen bayt sayısının adresini içeren bir dize döndürür. Mesela: + +``` sql +WITH + IPv6StringToNum('2001:0DB8:AC10:FE01:FEED:BABE:CAFE:F00D') AS ipv6, + IPv4ToIPv6(IPv4StringToNum('192.168.0.1')) AS ipv4 +SELECT + cutIPv6(ipv6, 2, 0), + cutIPv6(ipv4, 0, 2) +``` + +``` text +┌─cutIPv6(ipv6, 2, 0)─────────────────┬─cutIPv6(ipv4, 0, 2)─┐ +│ 2001:db8:ac10:fe01:feed:babe:cafe:0 │ ::ffff:192.168.0.0 │ +└─────────────────────────────────────┴─────────────────────┘ +``` + +## Ipv4cidrtorange(ıpv4, cıdr), {#ipv4cidrtorangeipv4-cidr} + +İçeren bir IPv4 ve bir Uint8 değerini kabul eder [CIDR](https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing). Alt ağın alt aralığını ve daha yüksek aralığını içeren iki IPv4 içeren bir tuple döndürür. + +``` sql +SELECT IPv4CIDRToRange(toIPv4('192.168.5.2'), 16) +``` + +``` text +┌─IPv4CIDRToRange(toIPv4('192.168.5.2'), 16)─┐ +│ ('192.168.0.0','192.168.255.255') │ +└────────────────────────────────────────────┘ +``` + +## Ipv6cidrtorange(ıpv6, cıdr), {#ipv6cidrtorangeipv6-cidr} + +CIDR'Yİ içeren bir IPv6 ve bir Uİnt8 değerini kabul eder. Alt ağın alt aralığını ve daha yüksek aralığını içeren iki IPv6 içeren bir tuple döndürür. + +``` sql +SELECT IPv6CIDRToRange(toIPv6('2001:0db8:0000:85a3:0000:0000:ac1f:8001'), 32); +``` + +``` text +┌─IPv6CIDRToRange(toIPv6('2001:0db8:0000:85a3:0000:0000:ac1f:8001'), 32)─┐ +│ ('2001:db8::','2001:db8:ffff:ffff:ffff:ffff:ffff:ffff') │ +└────────────────────────────────────────────────────────────────────────┘ +``` + +## toıpv4 (dize) {#toipv4string} + +İçin bir takma ad `IPv4StringToNum()` bu, IPv4 adresinin bir dize formunu alır ve değerini döndürür [Ipv44](../../sql_reference/data_types/domains/ipv4.md) tarafından döndürülen değere eşit ikili olan tür `IPv4StringToNum()`. + +``` sql +WITH + '171.225.130.45' as IPv4_string +SELECT + toTypeName(IPv4StringToNum(IPv4_string)), + toTypeName(toIPv4(IPv4_string)) +``` + +``` text +┌─toTypeName(IPv4StringToNum(IPv4_string))─┬─toTypeName(toIPv4(IPv4_string))─┐ +│ UInt32 │ IPv4 │ +└──────────────────────────────────────────┴─────────────────────────────────┘ +``` + +``` sql +WITH + '171.225.130.45' as IPv4_string +SELECT + hex(IPv4StringToNum(IPv4_string)), + hex(toIPv4(IPv4_string)) +``` + +``` text +┌─hex(IPv4StringToNum(IPv4_string))─┬─hex(toIPv4(IPv4_string))─┐ +│ ABE1822D │ ABE1822D │ +└───────────────────────────────────┴──────────────────────────┘ +``` + +## toıpv6 (dize) {#toipv6string} + +İçin bir takma ad `IPv6StringToNum()` bu, IPv6 adresinin bir dize formunu alır ve değerini döndürür [IPv6](../../sql_reference/data_types/domains/ipv6.md) tarafından döndürülen değere eşit ikili olan tür `IPv6StringToNum()`. + +``` sql +WITH + '2001:438:ffff::407d:1bc1' as IPv6_string +SELECT + toTypeName(IPv6StringToNum(IPv6_string)), + toTypeName(toIPv6(IPv6_string)) +``` + +``` text +┌─toTypeName(IPv6StringToNum(IPv6_string))─┬─toTypeName(toIPv6(IPv6_string))─┐ +│ FixedString(16) │ IPv6 │ +└──────────────────────────────────────────┴─────────────────────────────────┘ +``` + +``` sql +WITH + '2001:438:ffff::407d:1bc1' as IPv6_string +SELECT + hex(IPv6StringToNum(IPv6_string)), + hex(toIPv6(IPv6_string)) +``` + +``` text +┌─hex(IPv6StringToNum(IPv6_string))─┬─hex(toIPv6(IPv6_string))─────────┐ +│ 20010438FFFF000000000000407D1BC1 │ 20010438FFFF000000000000407D1BC1 │ +└───────────────────────────────────┴──────────────────────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/ip_address_functions/) diff --git a/docs/tr/sql_reference/functions/json_functions.md b/docs/tr/sql_reference/functions/json_functions.md new file mode 100644 index 00000000000..95aaa1768f2 --- /dev/null +++ b/docs/tr/sql_reference/functions/json_functions.md @@ -0,0 +1,231 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 56 +toc_title: "JSON ile \xE7al\u0131\u015Fmak." +--- + +# Json ile çalışmak için fonksiyonlar {#functions-for-working-with-json} + +Üye Olarak.Metrica, JSON kullanıcılar tarafından oturum parametreleri olarak iletilir. Bu JSON ile çalışmak için bazı özel fonksiyonlar var. (Çoğu durumda, JSONs ek olarak önceden işlenir ve elde edilen değerler işlenmiş biçimlerinde ayrı sütunlara konur .) Tüm bu işlevler, JSON'UN ne olabileceğine dair güçlü varsayımlara dayanır, ancak işi yapmak için mümkün olduğunca az şey yapmaya çalışırlar. + +Aşağıdaki varsayımlar yapılır: + +1. Alan adı (işlev bağımsız değişkeni) sabit olmalıdır. +2. Alan adı bir şekilde json'da kanonik olarak kodlanmıştır. Mesela: `visitParamHas('{"abc":"def"}', 'abc') = 1`, ama `visitParamHas('{"\\u0061\\u0062\\u0063":"def"}', 'abc') = 0` +3. Alanlar, herhangi bir yuvalama düzeyinde, ayrım gözetmeksizin aranır. Birden çok eşleşen alan varsa, ilk olay kullanılır. +4. JSON, dize değişmezleri dışında boşluk karakterlerine sahip değildir. + +## visitParamHas (params, isim) {#visitparamhasparams-name} + +İle bir alan olup olmadığını denetler ‘name’ ad. + +## visitParamExtractUİnt (params, isim) {#visitparamextractuintparams-name} + +Uint64 adlı alanın değerinden ayrıştırır ‘name’. Bu bir dize alanı ise, dizenin başlangıcından itibaren bir sayıyı ayrıştırmaya çalışır. Alan yoksa veya varsa ancak bir sayı içermiyorsa, 0 döndürür. + +## visitParamExtractİnt (params, isim) {#visitparamextractintparams-name} + +Int64 için olduğu gibi. + +## visitParamExtractFloat (params, isim) {#visitparamextractfloatparams-name} + +Float64 için olduğu gibi. + +## visitParamExtractBool (params, isim) {#visitparamextractboolparams-name} + +True/false değerini ayrıştırır. Sonuç Uİnt8. + +## visitParamExtractRaw (params, isim) {#visitparamextractrawparams-name} + +Ayırıcılar da dahil olmak üzere bir alanın değerini döndürür. + +Örnekler: + +``` sql +visitParamExtractRaw('{"abc":"\\n\\u0000"}', 'abc') = '"\\n\\u0000"' +visitParamExtractRaw('{"abc":{"def":[1,2,3]}}', 'abc') = '{"def":[1,2,3]}' +``` + +## visitParamExtractString (params, isim) {#visitparamextractstringparams-name} + +Dizeyi çift tırnak içinde ayrıştırır. Değeri unescaped. Unescaping başarısız olursa, boş bir dize döndürür. + +Örnekler: + +``` sql +visitParamExtractString('{"abc":"\\n\\u0000"}', 'abc') = '\n\0' +visitParamExtractString('{"abc":"\\u263a"}', 'abc') = '☺' +visitParamExtractString('{"abc":"\\u263"}', 'abc') = '' +visitParamExtractString('{"abc":"hello}', 'abc') = '' +``` + +Şu anda biçimdeki kod noktaları için destek yok `\uXXXX\uYYYY` bu temel çok dilli düzlemden değildir(UTF-8 yerine CESU-8'e dönüştürülürler). + +Aşağıdaki işlevler dayanmaktadır [simdjson](https://github.com/lemire/simdjson) daha karmaşık json ayrıştırma gereksinimleri için tasarlanmıştır. Yukarıda belirtilen varsayım 2 hala geçerlidir. + +## ısvalidjson(json) {#isvalidjsonjson} + +Dize geçirilen kontroller geçerli bir json'dur. + +Örnekler: + +``` sql +SELECT isValidJSON('{"a": "hello", "b": [-100, 200.0, 300]}') = 1 +SELECT isValidJSON('not a json') = 0 +``` + +## JSONHas(json\[, indices\_or\_keys\]…) {#jsonhasjson-indices-or-keys} + +Değer JSON belgesinde varsa, `1` iade edilecektir. + +Değer yoksa, `0` iade edilecektir. + +Örnekler: + +``` sql +SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 1 +SELECT JSONHas('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 4) = 0 +``` + +`indices_or_keys` sıfır veya daha fazla argüman listesi her biri dize veya tamsayı olabilir. + +- String = nesne üyesine anahtarla erişin. +- Pozitif tamsayı = n-inci üyesine / anahtarına baştan erişin. +- Negatif tamsayı = sondan n-inci üye/anahtara erişin. + +Elemanın minimum Endeksi 1'dir. Böylece 0 öğesi mevcut değildir. + +Hem json dizilerine hem de JSON nesnelerine erişmek için tamsayılar kullanabilirsiniz. + +Bu yüzden, örneğin : + +``` sql +SELECT JSONExtractKey('{"a": "hello", "b": [-100, 200.0, 300]}', 1) = 'a' +SELECT JSONExtractKey('{"a": "hello", "b": [-100, 200.0, 300]}', 2) = 'b' +SELECT JSONExtractKey('{"a": "hello", "b": [-100, 200.0, 300]}', -1) = 'b' +SELECT JSONExtractKey('{"a": "hello", "b": [-100, 200.0, 300]}', -2) = 'a' +SELECT JSONExtractString('{"a": "hello", "b": [-100, 200.0, 300]}', 1) = 'hello' +``` + +## JSONLength(json\[, indices\_or\_keys\]…) {#jsonlengthjson-indices-or-keys} + +Bir json dizisinin veya bir JSON nesnesinin uzunluğunu döndürür. + +Değer yoksa veya yanlış bir türe sahipse, `0` iade edilecektir. + +Örnekler: + +``` sql +SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 3 +SELECT JSONLength('{"a": "hello", "b": [-100, 200.0, 300]}') = 2 +``` + +## JSONType(json\[, indices\_or\_keys\]…) {#jsontypejson-indices-or-keys} + +Bir JSON değerinin türünü döndürür. + +Değer yoksa, `Null` iade edilecektir. + +Örnekler: + +``` sql +SELECT JSONType('{"a": "hello", "b": [-100, 200.0, 300]}') = 'Object' +SELECT JSONType('{"a": "hello", "b": [-100, 200.0, 300]}', 'a') = 'String' +SELECT JSONType('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = 'Array' +``` + +## JSONExtractUInt(json\[, indices\_or\_keys\]…) {#jsonextractuintjson-indices-or-keys} + +## JSONExtractInt(json\[, indices\_or\_keys\]…) {#jsonextractintjson-indices-or-keys} + +## JSONExtractFloat(json\[, indices\_or\_keys\]…) {#jsonextractfloatjson-indices-or-keys} + +## JSONExtractBool(json\[, indices\_or\_keys\]…) {#jsonextractbooljson-indices-or-keys} + +Bir JSON ayrıştırır ve bir değer ayıklayın. Bu işlevler benzer `visitParam` işlevler. + +Değer yoksa veya yanlış bir türe sahipse, `0` iade edilecektir. + +Örnekler: + +``` sql +SELECT JSONExtractInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 1) = -100 +SELECT JSONExtractFloat('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 2) = 200.0 +SELECT JSONExtractUInt('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', -1) = 300 +``` + +## JSONExtractString(json\[, indices\_or\_keys\]…) {#jsonextractstringjson-indices-or-keys} + +Bir json ayrıştırır ve bir dize ayıklayın. Bu işlev benzer `visitParamExtractString` işlevler. + +Değer yoksa veya yanlış bir tür varsa, boş bir dize döndürülür. + +Değeri unescaped. Unescaping başarısız olursa, boş bir dize döndürür. + +Örnekler: + +``` sql +SELECT JSONExtractString('{"a": "hello", "b": [-100, 200.0, 300]}', 'a') = 'hello' +SELECT JSONExtractString('{"abc":"\\n\\u0000"}', 'abc') = '\n\0' +SELECT JSONExtractString('{"abc":"\\u263a"}', 'abc') = '☺' +SELECT JSONExtractString('{"abc":"\\u263"}', 'abc') = '' +SELECT JSONExtractString('{"abc":"hello}', 'abc') = '' +``` + +## JSONExtract(json\[, indices\_or\_keys…\], return\_type) {#jsonextractjson-indices-or-keys-return-type} + +Bir Json ayrıştırır ve verilen ClickHouse veri türünün bir değerini çıkarır. + +Bu, önceki bir genellemedir `JSONExtract` işlevler. +Bu demektir +`JSONExtract(..., 'String')` tam olarak aynı döndürür `JSONExtractString()`, +`JSONExtract(..., 'Float64')` tam olarak aynı döndürür `JSONExtractFloat()`. + +Örnekler: + +``` sql +SELECT JSONExtract('{"a": "hello", "b": [-100, 200.0, 300]}', 'Tuple(String, Array(Float64))') = ('hello',[-100,200,300]) +SELECT JSONExtract('{"a": "hello", "b": [-100, 200.0, 300]}', 'Tuple(b Array(Float64), a String)') = ([-100,200,300],'hello') +SELECT JSONExtract('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 'Array(Nullable(Int8))') = [-100, NULL, NULL] +SELECT JSONExtract('{"a": "hello", "b": [-100, 200.0, 300]}', 'b', 4, 'Nullable(Int64)') = NULL +SELECT JSONExtract('{"passed": true}', 'passed', 'UInt8') = 1 +SELECT JSONExtract('{"day": "Thursday"}', 'day', 'Enum8(\'Sunday\' = 0, \'Monday\' = 1, \'Tuesday\' = 2, \'Wednesday\' = 3, \'Thursday\' = 4, \'Friday\' = 5, \'Saturday\' = 6)') = 'Thursday' +SELECT JSONExtract('{"day": 5}', 'day', 'Enum8(\'Sunday\' = 0, \'Monday\' = 1, \'Tuesday\' = 2, \'Wednesday\' = 3, \'Thursday\' = 4, \'Friday\' = 5, \'Saturday\' = 6)') = 'Friday' +``` + +## JSONExtractKeysAndValues(json\[, indices\_or\_keys…\], value\_type) {#jsonextractkeysandvaluesjson-indices-or-keys-value-type} + +Değerlerin verilen ClickHouse veri türünde olduğu bir json'dan anahtar değer çiftlerini ayrıştırın. + +Örnek: + +``` sql +SELECT JSONExtractKeysAndValues('{"x": {"a": 5, "b": 7, "c": 11}}', 'x', 'Int8') = [('a',5),('b',7),('c',11)]; +``` + +## JSONExtractRaw(json\[, indices\_or\_keys\]…) {#jsonextractrawjson-indices-or-keys} + +Json'un bir bölümünü döndürür. + +Bölüm yoksa veya yanlış bir türe sahipse, boş bir dize döndürülür. + +Örnek: + +``` sql +SELECT JSONExtractRaw('{"a": "hello", "b": [-100, 200.0, 300]}', 'b') = '[-100, 200.0, 300]' +``` + +## JSONExtractArrayRaw(json\[, indices\_or\_keys\]…) {#jsonextractarrayrawjson-indices-or-keys} + +Her biri ayrıştırılmamış dize olarak temsil edilen json dizisinin öğeleriyle bir dizi döndürür. + +Bölüm yoksa veya dizi değilse, boş bir dizi döndürülür. + +Örnek: + +``` sql +SELECT JSONExtractArrayRaw('{"a": "hello", "b": [-100, 200.0, "hello"]}', 'b') = ['-100', '200.0', '"hello"']' +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/json_functions/) diff --git a/docs/tr/sql_reference/functions/logical_functions.md b/docs/tr/sql_reference/functions/logical_functions.md new file mode 100644 index 00000000000..543226319da --- /dev/null +++ b/docs/tr/sql_reference/functions/logical_functions.md @@ -0,0 +1,22 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 37 +toc_title: "Mant\u0131kl\u0131" +--- + +# Mantıksal fonksiyonlar {#logical-functions} + +Mantıksal işlevler herhangi bir sayısal türü kabul eder, ancak 0 veya 1'e eşit bir Uİnt8 numarası döndürür. + +Bir argüman olarak sıfır kabul edilir “false,” sıfır olmayan herhangi bir değer dikkate alınırken “true”. + +## ve, ve operatör {#and-and-operator} + +## or, or operat ,or {#or-or-operator} + +## değil, operatör değil {#not-not-operator} + +## xor {#xor} + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/logical_functions/) diff --git a/docs/tr/sql_reference/functions/machine_learning_functions.md b/docs/tr/sql_reference/functions/machine_learning_functions.md new file mode 100644 index 00000000000..a1d2857ed82 --- /dev/null +++ b/docs/tr/sql_reference/functions/machine_learning_functions.md @@ -0,0 +1,20 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 64 +toc_title: "Makine \xD6\u011Frenme Fonksiyonlar\u0131" +--- + +# Makine Öğrenme Fonksiyonları {#machine-learning-functions} + +## evalMLMethod (tahmin) {#machine_learning_methods-evalmlmethod} + +Tak fittedılmış regresyon model usinglerini kullanarak tahmin `evalMLMethod` işlev. Lin seeke bakınız `linearRegression`. + +### Stokastik Doğrusal Regresyon {#stochastic-linear-regression} + +Bu [stokastiklinearregression](../../sql_reference/aggregate_functions/reference.md#agg_functions-stochasticlinearregression) toplama fonksiyonu, doğrusal model ve MSE kayıp fonksiyonunu kullanarak stokastik Gradyan iniş yöntemini uygular. Kullanma `evalMLMethod` yeni veri üzerinde tahmin etmek için. + +### Stokastik Lojistik Regresyon {#stochastic-logistic-regression} + +Bu [stochasticLogisticRegression](../../sql_reference/aggregate_functions/reference.md#agg_functions-stochasticlogisticregression) toplama işlevi, ikili sınıflandırma problemi için stokastik Gradyan iniş yöntemini uygular. Kullanma `evalMLMethod` yeni veri üzerinde tahmin etmek için. diff --git a/docs/tr/sql_reference/functions/math_functions.md b/docs/tr/sql_reference/functions/math_functions.md new file mode 100644 index 00000000000..dee89681e73 --- /dev/null +++ b/docs/tr/sql_reference/functions/math_functions.md @@ -0,0 +1,116 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 44 +toc_title: Matematiksel +--- + +# Matematiksel fonksiyonlar {#mathematical-functions} + +Tüm işlevler bir Float64 numarası döndürür. Sonucun doğruluğu mümkün olan en yüksek hassasiyete yakındır, ancak sonuç, ilgili gerçek sayıya en yakın makine temsil edilebilir numarası ile çakışmayabilir. + +## e() {#e} + +E numarasına yakın bir Float64 numarası döndürür. + +## pi sayısı() {#pi} + +Returns a Float64 number that is close to the number π. + +## exp(x) {#expx} + +Sayısal bir bağımsız değişken kabul eder ve bir Float64 sayı argümanın üs yakın döndürür. + +## log (x), L (n(x) {#logx-lnx} + +Sayısal bir bağımsız değişken kabul eder ve bağımsız değişken doğal logaritma yakın bir Float64 sayı döndürür. + +## exp2 (x) {#exp2x} + +Sayısal bir bağımsız değişkeni kabul eder ve X gücüne 2'ye yakın bir Float64 numarası döndürür. + +## log2 (x) {#log2x} + +Sayısal bir bağımsız değişken kabul eder ve değişken ikili logaritma yakın bir Float64 sayı döndürür. + +## exp10 (x) {#exp10x} + +Sayısal bir bağımsız değişkeni kabul eder ve 10'a yakın Float64 numarasını x gücüne döndürür. + +## log10(x) {#log10x} + +Sayısal bir bağımsız değişken kabul eder ve bir float64 sayı bağımsız değişken ondalık logaritması yakın döndürür. + +## sqrt(x) {#sqrtx} + +Sayısal bir bağımsız değişken kabul eder ve bağımsız değişken kareköküne yakın bir Float64 numarası döndürür. + +## TCMB (x) {#cbrtx} + +Sayısal bir bağımsız değişkeni kabul eder ve bağımsız değişken kübik köküne yakın bir Float64 numarası döndürür. + +## erf (x) {#erfx} + +Eğer ‘x’ is non-negative, then erf(x / σ√2) standart sapma ile normal dağılıma sahip bir rasgele değişkenin olasılığı var mı ‘σ’ beklenen değerden daha fazla ayrılan değeri alır ‘x’. + +Örnek (üç sigma kuralı): + +``` sql +SELECT erf(3 / sqrt(2)) +``` + +``` text +┌─erf(divide(3, sqrt(2)))─┐ +│ 0.9973002039367398 │ +└─────────────────────────┘ +``` + +## erfc (x) {#erfcx} + +Sayısal bir bağımsız değişkeni kabul eder ve 1 - erf(x) yakın bir Float64 numarası döndürür, ancak büyük için hassasiyet kaybı olmadan ‘x’ değerler. + +## lgamma (x) {#lgammax} + +Gama fonksiyonunun logaritması. + +## tgamma (x) {#tgammax} + +Gama fonksiyonu. + +## günah(x) {#sinx} + +Sinüs. + +## C (os (x) {#cosx} + +Kosinüs. + +## tan (x) {#tanx} + +Teğet. + +## asin (x) {#asinx} + +Ark sinüsü. + +## acos (x) {#acosx} + +Ark kosinüsü. + +## atan (x) {#atanx} + +Ark teğet. + +## pow (x, y), güç (x, y)) {#powx-y-powerx-y} + +İki sayısal bağımsız değişken X ve y alır.X'e yakın bir Float64 numarasını y gücüne döndürür. + +## ıntexp2 {#intexp2} + +Sayısal bir bağımsız değişkeni kabul eder ve X'in gücüne 2'ye yakın bir uint64 numarası döndürür. + +## ıntexp10 {#intexp10} + +Sayısal bir bağımsız değişkeni kabul eder ve X gücüne 10'a yakın bir uint64 numarası döndürür. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/math_functions/) diff --git a/docs/tr/sql_reference/functions/other_functions.md b/docs/tr/sql_reference/functions/other_functions.md new file mode 100644 index 00000000000..052f289c64f --- /dev/null +++ b/docs/tr/sql_reference/functions/other_functions.md @@ -0,0 +1,1079 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 66 +toc_title: "Di\u011Fer" +--- + +# Diğer fonksiyonlar {#other-functions} + +## hostnamename() {#hostname} + +Bu işlevin gerçekleştirildiği ana bilgisayarın adını içeren bir dize döndürür. Dağıtılmış işlem için, bu işlev uzak bir sunucuda gerçekleştirilirse, uzak sunucu ana bilgisayarının adıdır. + +## FQDN {#fqdn} + +Tam etki alanı adını döndürür. + +**Sözdizimi** + +``` sql +fqdn(); +``` + +Bu işlev büyük / küçük harf duyarsızdır. + +**Döndürülen değer** + +- Tam etki alanı adı ile dize. + +Tür: `String`. + +**Örnek** + +Sorgu: + +``` sql +SELECT FQDN(); +``` + +Sonuç: + +``` text +┌─FQDN()──────────────────────────┐ +│ clickhouse.ru-central1.internal │ +└─────────────────────────────────┘ +``` + +## basename {#basename} + +Son eğik çizgi veya ters eğik çizgiden sonra bir dizenin sondaki kısmını ayıklar. Bu işlev, genellikle bir yoldan dosya adını ayıklamak için kullanılır. + +``` sql +basename( expr ) +``` + +**Parametre** + +- `expr` — Expression resulting in a [Dize](../../sql_reference/data_types/string.md) type value. Tüm ters eğik çizgilerin ortaya çıkan değerden kaçması gerekir. + +**Döndürülen Değer** + +İçeren bir dize: + +- Son eğik çizgi veya ters eğik çizgiden sonra bir dizenin sondaki kısmı. + + If the input string contains a path ending with slash or backslash, for example, `/` or `c:\`, the function returns an empty string. + +- Eğik çizgi veya ters eğik çizgi yoksa orijinal dize. + +**Örnek** + +``` sql +SELECT 'some/long/path/to/file' AS a, basename(a) +``` + +``` text +┌─a──────────────────────┬─basename('some\\long\\path\\to\\file')─┐ +│ some\long\path\to\file │ file │ +└────────────────────────┴────────────────────────────────────────┘ +``` + +``` sql +SELECT 'some\\long\\path\\to\\file' AS a, basename(a) +``` + +``` text +┌─a──────────────────────┬─basename('some\\long\\path\\to\\file')─┐ +│ some\long\path\to\file │ file │ +└────────────────────────┴────────────────────────────────────────┘ +``` + +``` sql +SELECT 'some-file-name' AS a, basename(a) +``` + +``` text +┌─a──────────────┬─basename('some-file-name')─┐ +│ some-file-name │ some-file-name │ +└────────────────┴────────────────────────────┘ +``` + +## visibleWidth(x) {#visiblewidthx} + +Değerleri konsola metin biçiminde (sekmeyle ayrılmış) çıkarırken yaklaşık genişliği hesaplar. +Bu işlev, sistem tarafından güzel formatların uygulanması için kullanılır. + +`NULL` karşılık gelen bir dize olarak temsil edilir `NULL` içinde `Pretty` biçimliler. + +``` sql +SELECT visibleWidth(NULL) +``` + +``` text +┌─visibleWidth(NULL)─┐ +│ 4 │ +└────────────────────┘ +``` + +## toTypeName (x) {#totypenamex} + +Geçirilen bağımsız değişken türü adını içeren bir dize döndürür. + +Eğer `NULL` fonksiyona girdi olarak geçirilir, daha sonra `Nullable(Nothing)` bir iç karşılık gelen türü `NULL` Clickhouse'da temsil. + +## blockSize() {#function-blocksize} + +Bloğun boyutunu alır. +Clickhouse'da, sorgular her zaman bloklarda (sütun parçaları kümeleri) çalıştırılır. Bu işlev, aradığınız bloğun boyutunu almanızı sağlar. + +## materialize (x) {#materializex} + +Bir sabiti yalnızca bir değer içeren tam bir sütuna dönüştürür. +Clickhouse'da, tam sütunlar ve sabitler bellekte farklı şekilde temsil edilir. İşlevler, sabit argümanlar ve normal argümanlar için farklı şekilde çalışır (farklı kod yürütülür), ancak sonuç hemen hemen her zaman aynıdır. Bu işlev, bu davranış hata ayıklama içindir. + +## ignore(…) {#ignore} + +Dahil olmak üzere herhangi bir argümanı kabul eder `NULL`. Her zaman 0 döndürür. +Ancak, argüman hala değerlendirilir. Bu kriterler için kullanılabilir. + +## uyku (saniye) {#sleepseconds} + +Uykular ‘seconds’ her veri bloğunda saniye. Bir tamsayı veya kayan noktalı sayı belirtebilirsiniz. + +## sleepEachRow (saniye) {#sleepeachrowseconds} + +Uykular ‘seconds’ her satırda saniye. Bir tamsayı veya kayan noktalı sayı belirtebilirsiniz. + +## currentDatabase() {#currentdatabase} + +Geçerli veritabanının adını döndürür. +Bu işlevi, veritabanını belirtmeniz gereken bir tablo oluştur sorgusunda tablo altyapısı parametrelerinde kullanabilirsiniz. + +## currentUser() {#other-function-currentuser} + +Geçerli kullanıcının oturum açma döndürür. Kullanıcı girişi, bu başlatılan sorgu, durumda distibuted sorguda iade edilecektir. + +``` sql +SELECT currentUser(); +``` + +Takma ad: `user()`, `USER()`. + +**Döndürülen değerler** + +- Geçerli kullanıcının girişi. +- Disributed sorgu durumunda sorgu başlatılan kullanıcının giriş. + +Tür: `String`. + +**Örnek** + +Sorgu: + +``` sql +SELECT currentUser(); +``` + +Sonuç: + +``` text +┌─currentUser()─┐ +│ default │ +└───────────────┘ +``` + +## isFinite (x) {#isfinitex} + +Float32 ve Float64 kabul eder ve bağımsız değişken sonsuz değilse ve bir NaN değilse, Uint8'i 1'e eşit olarak döndürür, aksi halde 0. + +## isİnfinite (x) {#isinfinitex} + +Float32 ve Float64 kabul eder ve bağımsız değişken sonsuz ise 1'e eşit Uİnt8 döndürür, aksi takdirde 0. Bir NaN için 0 döndürüldüğünü unutmayın. + +## ifNotFinite {#ifnotfinite} + +Kayan nokta değerinin sonlu olup olmadığını kontrol eder. + +**Sözdizimi** + + ifNotFinite(x,y) + +**Parametre** + +- `x` — Value to be checked for infinity. Type: [Yüzdürmek\*](../../sql_reference/data_types/float.md). +- `y` — Fallback value. Type: [Yüzdürmek\*](../../sql_reference/data_types/float.md). + +**Döndürülen değer** + +- `x` eğer `x` son isludur. +- `y` eğer `x` sonlu değildir. + +**Örnek** + +Sorgu: + + SELECT 1/0 as infimum, ifNotFinite(infimum,42) + +Sonuç: + + ┌─infimum─┬─ifNotFinite(divide(1, 0), 42)─┐ + │ inf │ 42 │ + └─────────┴───────────────────────────────┘ + +Kullanarak benzer sonuç alabilirsiniz [üçlü operatör](conditional_functions.md#ternary-operator): `isFinite(x) ? x : y`. + +## ısnan (x) {#isnanx} + +Float32 ve Float64 kabul eder ve bağımsız değişken bir NaN, aksi takdirde 0 ise 1'e eşit uint8 döndürür. + +## hasColumnİnTable(\[‘hostname’\[, ‘username’\[, ‘password’\]\],\] ‘database’, ‘table’, ‘column’) {#hascolumnintablehostname-username-password-database-table-column} + +Sabit dizeleri kabul eder: veritabanı adı, tablo adı ve sütun adı. Bir sütun varsa 1'e eşit bir uint8 sabit ifadesi döndürür, aksi halde 0. Hostname parametresi ayarlanmışsa, sınama uzak bir sunucuda çalışır. +Tablo yoksa, işlev bir özel durum atar. +İç içe veri yapısındaki öğeler için işlev, bir sütunun varlığını denetler. İç içe veri yapısının kendisi için işlev 0 döndürür. + +## bar {#function-bar} + +Unicode-art diyagramı oluşturmaya izin verir. + +`bar(x, min, max, width)` genişliği orantılı olan bir bant çizer `(x - min)` ve eşit `width` karakterler ne zaman `x = max`. + +Parametre: + +- `x` — Size to display. +- `min, max` — Integer constants. The value must fit in `Int64`. +- `width` — Constant, positive integer, can be fractional. + +Bant, bir sembolün sekizde birine doğrulukla çizilir. + +Örnek: + +``` sql +SELECT + toHour(EventTime) AS h, + count() AS c, + bar(c, 0, 600000, 20) AS bar +FROM test.hits +GROUP BY h +ORDER BY h ASC +``` + +``` text +┌──h─┬──────c─┬─bar────────────────┐ +│ 0 │ 292907 │ █████████▋ │ +│ 1 │ 180563 │ ██████ │ +│ 2 │ 114861 │ ███▋ │ +│ 3 │ 85069 │ ██▋ │ +│ 4 │ 68543 │ ██▎ │ +│ 5 │ 78116 │ ██▌ │ +│ 6 │ 113474 │ ███▋ │ +│ 7 │ 170678 │ █████▋ │ +│ 8 │ 278380 │ █████████▎ │ +│ 9 │ 391053 │ █████████████ │ +│ 10 │ 457681 │ ███████████████▎ │ +│ 11 │ 493667 │ ████████████████▍ │ +│ 12 │ 509641 │ ████████████████▊ │ +│ 13 │ 522947 │ █████████████████▍ │ +│ 14 │ 539954 │ █████████████████▊ │ +│ 15 │ 528460 │ █████████████████▌ │ +│ 16 │ 539201 │ █████████████████▊ │ +│ 17 │ 523539 │ █████████████████▍ │ +│ 18 │ 506467 │ ████████████████▊ │ +│ 19 │ 520915 │ █████████████████▎ │ +│ 20 │ 521665 │ █████████████████▍ │ +│ 21 │ 542078 │ ██████████████████ │ +│ 22 │ 493642 │ ████████████████▍ │ +│ 23 │ 400397 │ █████████████▎ │ +└────┴────────┴────────────────────┘ +``` + +## dönüştürmek {#transform} + +Bir değeri, bazı öğelerin açıkça tanımlanmış eşlemesine göre diğer öğelere dönüştürür. +Bu fonksiyonun iki varyasyonu vardır: + +### transform (x, array\_from, array\_to, varsayılan) {#transformx-array-from-array-to-default} + +`x` – What to transform. + +`array_from` – Constant array of values for converting. + +`array_to` – Constant array of values to convert the values in ‘from’ -e doğru. + +`default` – Which value to use if ‘x’ değer anylerden hiçbir equaline eşit değildir. ‘from’. + +`array_from` ve `array_to` – Arrays of the same size. + +Türler: + +`transform(T, Array(T), Array(U), U) -> U` + +`T` ve `U` sayısal, dize veya tarih veya DateTime türleri olabilir. +Aynı harfin belirtildiği (t veya U), sayısal türler için bunlar eşleşen türler değil, ortak bir türe sahip türler olabilir. +Örneğin, ilk bağımsız değişken Int64 türüne sahip olabilir, ikincisi ise Array(Uİnt16) türüne sahiptir. + +Eğer... ‘x’ değer, içindeki öğelerden birine eşittir. ‘array\_from’ array, varolan öğeyi döndürür (aynı numaralandırılır) ‘array\_to’ dizi. Aksi takdirde, döner ‘default’. İçinde birden fazla eşleşen öğe varsa ‘array\_from’, maçlardan birini döndürür. + +Örnek: + +``` sql +SELECT + transform(SearchEngineID, [2, 3], ['Yandex', 'Google'], 'Other') AS title, + count() AS c +FROM test.hits +WHERE SearchEngineID != 0 +GROUP BY title +ORDER BY c DESC +``` + +``` text +┌─title─────┬──────c─┐ +│ Yandex │ 498635 │ +│ Google │ 229872 │ +│ Other │ 104472 │ +└───────────┴────────┘ +``` + +### transform (x, array\_from, array\_to) {#transformx-array-from-array-to} + +İlk vary thatasyon differsdan farklıdır. ‘default’ argüman atlandı. +Eğer... ‘x’ değer, içindeki öğelerden birine eşittir. ‘array\_from’ array, eşleşen öğeyi (aynı numaralandırılmış) döndürür ‘array\_to’ dizi. Aksi takdirde, döner ‘x’. + +Türler: + +`transform(T, Array(T), Array(T)) -> T` + +Örnek: + +``` sql +SELECT + transform(domain(Referer), ['yandex.ru', 'google.ru', 'vk.com'], ['www.yandex', 'example.com']) AS s, + count() AS c +FROM test.hits +GROUP BY domain(Referer) +ORDER BY count() DESC +LIMIT 10 +``` + +``` text +┌─s──────────────┬───────c─┐ +│ │ 2906259 │ +│ www.yandex │ 867767 │ +│ ███████.ru │ 313599 │ +│ mail.yandex.ru │ 107147 │ +│ ██████.ru │ 100355 │ +│ █████████.ru │ 65040 │ +│ news.yandex.ru │ 64515 │ +│ ██████.net │ 59141 │ +│ example.com │ 57316 │ +└────────────────┴─────────┘ +``` + +## formatReadableSize (x) {#formatreadablesizex} + +Boyutu (bayt sayısı) kabul eder. Bir sonek (KiB, MıB, vb.) ile yuvarlak bir boyut döndürür.) bir dize olarak. + +Örnek: + +``` sql +SELECT + arrayJoin([1, 1024, 1024*1024, 192851925]) AS filesize_bytes, + formatReadableSize(filesize_bytes) AS filesize +``` + +``` text +┌─filesize_bytes─┬─filesize───┐ +│ 1 │ 1.00 B │ +│ 1024 │ 1.00 KiB │ +│ 1048576 │ 1.00 MiB │ +│ 192851925 │ 183.92 MiB │ +└────────────────┴────────────┘ +``` + +## en az (a, b) {#leasta-b} + +A ve B'den en küçük değeri döndürür. + +## en büyük (a, b) {#greatesta-b} + +A ve B'nin en büyük değerini döndürür. + +## çalışma süresi() {#uptime} + +Sunucunun çalışma süresini saniyeler içinde döndürür. + +## sürüm() {#version} + +Sunucu sürümünü bir dize olarak döndürür. + +## saat dilimi() {#timezone} + +Sunucunun saat dilimini döndürür. + +## blockNumber {#blocknumber} + +Satırın bulunduğu veri bloğunun sıra numarasını döndürür. + +## rowNumberİnBlock {#function-rownumberinblock} + +Veri bloğundaki satırın sıra numarasını döndürür. Farklı veri blokları her zaman yeniden hesaplanır. + +## rownumberınallblocks() {#rownumberinallblocks} + +Veri bloğundaki satırın sıra numarasını döndürür. Bu işlev yalnızca etkilenen veri bloklarını dikkate alır. + +## komşuluk {#neighbor} + +Belirli bir sütunun geçerli satırından önce veya sonra gelen belirli bir ofsette bir satıra erişim sağlayan pencere işlevi. + +**Sözdizimi** + +``` sql +neighbor(column, offset[, default_value]) +``` + +İşlevin sonucu, etkilenen veri bloklarına ve bloktaki veri sırasına bağlıdır. +ORDER BY ile bir alt sorgu yaparsanız ve alt sorgunun dışından işlevi çağırırsanız, beklenen sonucu alabilirsiniz. + +**Parametre** + +- `column` — A column name or scalar expression. +- `offset` — The number of rows forwards or backwards from the current row of `column`. [Int64](../../sql_reference/data_types/int_uint.md). +- `default_value` — Optional. The value to be returned if offset goes beyond the scope of the block. Type of data blocks affected. + +**Döndürülen değerler** + +- İçin değer `column` içinde `offset` eğer geçerli satırdan uzaklık `offset` değer blok sınırları dışında değil. +- İçin varsayılan değer `column` eğer `offset` değer, blok sınırlarının dışındadır. Eğer `default_value` verilir, daha sonra kullanılacaktır. + +Tür: etkilenen veri bloklarının türü veya varsayılan değer türü. + +**Örnek** + +Sorgu: + +``` sql +SELECT number, neighbor(number, 2) FROM system.numbers LIMIT 10; +``` + +Sonuç: + +``` text +┌─number─┬─neighbor(number, 2)─┐ +│ 0 │ 2 │ +│ 1 │ 3 │ +│ 2 │ 4 │ +│ 3 │ 5 │ +│ 4 │ 6 │ +│ 5 │ 7 │ +│ 6 │ 8 │ +│ 7 │ 9 │ +│ 8 │ 0 │ +│ 9 │ 0 │ +└────────┴─────────────────────┘ +``` + +Sorgu: + +``` sql +SELECT number, neighbor(number, 2, 999) FROM system.numbers LIMIT 10; +``` + +Sonuç: + +``` text +┌─number─┬─neighbor(number, 2, 999)─┐ +│ 0 │ 2 │ +│ 1 │ 3 │ +│ 2 │ 4 │ +│ 3 │ 5 │ +│ 4 │ 6 │ +│ 5 │ 7 │ +│ 6 │ 8 │ +│ 7 │ 9 │ +│ 8 │ 999 │ +│ 9 │ 999 │ +└────────┴──────────────────────────┘ +``` + +Bu işlev, yıldan yıla metrik değeri hesaplamak için kullanılabilir: + +Sorgu: + +``` sql +WITH toDate('2018-01-01') AS start_date +SELECT + toStartOfMonth(start_date + (number * 32)) AS month, + toInt32(month) % 100 AS money, + neighbor(money, -12) AS prev_year, + round(prev_year / money, 2) AS year_over_year +FROM numbers(16) +``` + +Sonuç: + +``` text +┌──────month─┬─money─┬─prev_year─┬─year_over_year─┐ +│ 2018-01-01 │ 32 │ 0 │ 0 │ +│ 2018-02-01 │ 63 │ 0 │ 0 │ +│ 2018-03-01 │ 91 │ 0 │ 0 │ +│ 2018-04-01 │ 22 │ 0 │ 0 │ +│ 2018-05-01 │ 52 │ 0 │ 0 │ +│ 2018-06-01 │ 83 │ 0 │ 0 │ +│ 2018-07-01 │ 13 │ 0 │ 0 │ +│ 2018-08-01 │ 44 │ 0 │ 0 │ +│ 2018-09-01 │ 75 │ 0 │ 0 │ +│ 2018-10-01 │ 5 │ 0 │ 0 │ +│ 2018-11-01 │ 36 │ 0 │ 0 │ +│ 2018-12-01 │ 66 │ 0 │ 0 │ +│ 2019-01-01 │ 97 │ 32 │ 0.33 │ +│ 2019-02-01 │ 28 │ 63 │ 2.25 │ +│ 2019-03-01 │ 56 │ 91 │ 1.62 │ +│ 2019-04-01 │ 87 │ 22 │ 0.25 │ +└────────────┴───────┴───────────┴────────────────┘ +``` + +## runningDifference (x) {#other_functions-runningdifference} + +Calculates the difference between successive row values ​​in the data block. +İlk satır için 0 ve sonraki her satır için önceki satırdan farkı döndürür. + +İşlevin sonucu, etkilenen veri bloklarına ve bloktaki veri sırasına bağlıdır. +ORDER BY ile bir alt sorgu yaparsanız ve alt sorgunun dışından işlevi çağırırsanız, beklenen sonucu alabilirsiniz. + +Örnek: + +``` sql +SELECT + EventID, + EventTime, + runningDifference(EventTime) AS delta +FROM +( + SELECT + EventID, + EventTime + FROM events + WHERE EventDate = '2016-11-24' + ORDER BY EventTime ASC + LIMIT 5 +) +``` + +``` text +┌─EventID─┬───────────EventTime─┬─delta─┐ +│ 1106 │ 2016-11-24 00:00:04 │ 0 │ +│ 1107 │ 2016-11-24 00:00:05 │ 1 │ +│ 1108 │ 2016-11-24 00:00:05 │ 0 │ +│ 1109 │ 2016-11-24 00:00:09 │ 4 │ +│ 1110 │ 2016-11-24 00:00:10 │ 1 │ +└─────────┴─────────────────────┴───────┘ +``` + +Lütfen dikkat - blok boyutu sonucu etkiler. Her yeni blok ile, `runningDifference` durum sıfırlandı. + +``` sql +SELECT + number, + runningDifference(number + 1) AS diff +FROM numbers(100000) +WHERE diff != 1 +``` + +``` text +┌─number─┬─diff─┐ +│ 0 │ 0 │ +└────────┴──────┘ +┌─number─┬─diff─┐ +│ 65536 │ 0 │ +└────────┴──────┘ +``` + +``` sql +set max_block_size=100000 -- default value is 65536! + +SELECT + number, + runningDifference(number + 1) AS diff +FROM numbers(100000) +WHERE diff != 1 +``` + +``` text +┌─number─┬─diff─┐ +│ 0 │ 0 │ +└────────┴──────┘ +``` + +## runningDifferenceStartingWithFirstvalue {#runningdifferencestartingwithfirstvalue} + +İçin aynı [runningDifference](./other_functions.md#other_functions-runningdifference), fark ilk satırın değeridir, ilk satırın değerini döndürdü ve sonraki her satır önceki satırdan farkı döndürür. + +## MACNumToString (num) {#macnumtostringnum} + +Bir uınt64 numarasını kabul eder. Big endian'da bir MAC adresi olarak yorumlar. AA:BB:CC:DD:EE:FF biçiminde karşılık gelen MAC adresini içeren bir dize döndürür (onaltılık formda iki nokta üst üste ayrılmış sayılar). + +## MACStringToNum (s) {#macstringtonums} + +MACNumToString ters işlevi. MAC adresi geçersiz bir biçime sahipse, 0 döndürür. + +## MACStringToOUİ (s) {#macstringtoouis} + +AA:BB:CC:DD:EE:FF (onaltılık formda iki nokta üst üste ayrılmış sayılar) biçiminde bir MAC adresi kabul eder. İlk üç sekizli uint64 numarası olarak döndürür. MAC adresi geçersiz bir biçime sahipse, 0 döndürür. + +## getSizeOfEnumType {#getsizeofenumtype} + +Alan sayısını döndürür [Enum](../../sql_reference/data_types/enum.md). + +``` sql +getSizeOfEnumType(value) +``` + +**Parametre:** + +- `value` — Value of type `Enum`. + +**Döndürülen değerler** + +- İle alan sayısı `Enum` giriş değerleri. +- Tür değilse bir istisna atılır `Enum`. + +**Örnek** + +``` sql +SELECT getSizeOfEnumType( CAST('a' AS Enum8('a' = 1, 'b' = 2) ) ) AS x +``` + +``` text +┌─x─┐ +│ 2 │ +└───┘ +``` + +## blockSerializedSize {#blockserializedsize} + +Diskteki boyutu döndürür (sıkıştırmayı hesaba katmadan). + +``` sql +blockSerializedSize(value[, value[, ...]]) +``` + +**Parametre:** + +- `value` — Any value. + +**Döndürülen değerler** + +- (Sıkıştırma olmadan) değerler bloğu için diske yazılacak bayt sayısı. + +**Örnek** + +``` sql +SELECT blockSerializedSize(maxState(1)) as x +``` + +``` text +┌─x─┐ +│ 2 │ +└───┘ +``` + +## toColumnTypeName {#tocolumntypename} + +RAM'DEKİ sütunun veri türünü temsil eden sınıfın adını döndürür. + +``` sql +toColumnTypeName(value) +``` + +**Parametre:** + +- `value` — Any type of value. + +**Döndürülen değerler** + +- Temsil etmek için kullanılan sınıfın adını içeren bir dize `value` RAM veri türü. + +**Arasındaki fark örneği`toTypeName ' and ' toColumnTypeName`** + +``` sql +SELECT toTypeName(CAST('2018-01-01 01:02:03' AS DateTime)) +``` + +``` text +┌─toTypeName(CAST('2018-01-01 01:02:03', 'DateTime'))─┐ +│ DateTime │ +└─────────────────────────────────────────────────────┘ +``` + +``` sql +SELECT toColumnTypeName(CAST('2018-01-01 01:02:03' AS DateTime)) +``` + +``` text +┌─toColumnTypeName(CAST('2018-01-01 01:02:03', 'DateTime'))─┐ +│ Const(UInt32) │ +└───────────────────────────────────────────────────────────┘ +``` + +Örnek gösteriyor ki `DateTime` veri türü olarak bellekte saklanır `Const(UInt32)`. + +## dumpColumnStructure {#dumpcolumnstructure} + +Ram'deki veri yapılarının ayrıntılı bir açıklamasını verir + +``` sql +dumpColumnStructure(value) +``` + +**Parametre:** + +- `value` — Any type of value. + +**Döndürülen değerler** + +- Temsil etmek için kullanılan yapıyı açıklayan bir dize `value` RAM veri türü. + +**Örnek** + +``` sql +SELECT dumpColumnStructure(CAST('2018-01-01 01:02:03', 'DateTime')) +``` + +``` text +┌─dumpColumnStructure(CAST('2018-01-01 01:02:03', 'DateTime'))─┐ +│ DateTime, Const(size = 1, UInt32(size = 1)) │ +└──────────────────────────────────────────────────────────────┘ +``` + +## defaultValueOfArgumentType {#defaultvalueofargumenttype} + +Veri türü için varsayılan değeri verir. + +Kullanıcı tarafından ayarlanan özel sütunlar için varsayılan değerleri içermez. + +``` sql +defaultValueOfArgumentType(expression) +``` + +**Parametre:** + +- `expression` — Arbitrary type of value or an expression that results in a value of an arbitrary type. + +**Döndürülen değerler** + +- `0` sayılar için. +- Dizeler için boş dize. +- `ᴺᵁᴸᴸ` için [Nullable](../../sql_reference/data_types/nullable.md). + +**Örnek** + +``` sql +SELECT defaultValueOfArgumentType( CAST(1 AS Int8) ) +``` + +``` text +┌─defaultValueOfArgumentType(CAST(1, 'Int8'))─┐ +│ 0 │ +└─────────────────────────────────────────────┘ +``` + +``` sql +SELECT defaultValueOfArgumentType( CAST(1 AS Nullable(Int8) ) ) +``` + +``` text +┌─defaultValueOfArgumentType(CAST(1, 'Nullable(Int8)'))─┐ +│ ᴺᵁᴸᴸ │ +└───────────────────────────────────────────────────────┘ +``` + +## çoğaltmak {#other-functions-replicate} + +Tek bir değere sahip bir dizi oluşturur. + +İç uygulama için kullanılan [arrayJoin](array_join.md#functions_arrayjoin). + +``` sql +SELECT replicate(x, arr); +``` + +**Parametre:** + +- `arr` — Original array. ClickHouse creates a new array of the same length as the original and fills it with the value `x`. +- `x` — The value that the resulting array will be filled with. + +**Döndürülen değer** + +Değerle dolu bir dizi `x`. + +Tür: `Array`. + +**Örnek** + +Sorgu: + +``` sql +SELECT replicate(1, ['a', 'b', 'c']) +``` + +Sonuç: + +``` text +┌─replicate(1, ['a', 'b', 'c'])─┐ +│ [1,1,1] │ +└───────────────────────────────┘ +``` + +## filesystemAvailable {#filesystemavailable} + +Veritabanlarının dosyalarının bulunduğu dosya sisteminde kalan alan miktarını döndürür. Her zaman toplam boş alandan daha küçüktür ([filesystemFree](#filesystemfree)) çünkü OS için biraz alan ayrılmıştır. + +**Sözdizimi** + +``` sql +filesystemAvailable() +``` + +**Döndürülen değer** + +- Bayt olarak kullanılabilir kalan alan miktarı. + +Tür: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT formatReadableSize(filesystemAvailable()) AS "Available space", toTypeName(filesystemAvailable()) AS "Type"; +``` + +Sonuç: + +``` text +┌─Available space─┬─Type───┐ +│ 30.75 GiB │ UInt64 │ +└─────────────────┴────────┘ +``` + +## filesystemFree {#filesystemfree} + +Veritabanlarının dosyalarının bulunduğu dosya sistemindeki boş alanın toplam miktarını döndürür. Ayrıca bakınız `filesystemAvailable` + +**Sözdizimi** + +``` sql +filesystemFree() +``` + +**Döndürülen değer** + +- Bayt cinsinden boş alan miktarı. + +Tür: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT formatReadableSize(filesystemFree()) AS "Free space", toTypeName(filesystemFree()) AS "Type"; +``` + +Sonuç: + +``` text +┌─Free space─┬─Type───┐ +│ 32.39 GiB │ UInt64 │ +└────────────┴────────┘ +``` + +## filesystemCapacity {#filesystemcapacity} + +Dosya sisteminin kapasitesini bayt cinsinden döndürür. Değerlendirme için, [yol](../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-path) veri dizinine yapılandırılmalıdır. + +**Sözdizimi** + +``` sql +filesystemCapacity() +``` + +**Döndürülen değer** + +- Dosya sisteminin bayt cinsinden kapasite bilgisi. + +Tür: [Uİnt64](../../sql_reference/data_types/int_uint.md). + +**Örnek** + +Sorgu: + +``` sql +SELECT formatReadableSize(filesystemCapacity()) AS "Capacity", toTypeName(filesystemCapacity()) AS "Type" +``` + +Sonuç: + +``` text +┌─Capacity──┬─Type───┐ +│ 39.32 GiB │ UInt64 │ +└───────────┴────────┘ +``` + +## finalizeAggregation {#function-finalizeaggregation} + +Toplama işlevinin durumunu alır. Toplama sonucunu döndürür (kesinleşmiş durum). + +## runningAccumulate {#function-runningaccumulate} + +Toplama işlevinin durumlarını alır ve değerleri olan bir sütun döndürür, bu durumların bir dizi blok satırı için ilk satırdan geçerli satıra birikmesinin sonucudur. +Örneğin, toplama işlevinin durumunu alır (örnek runningAccumulate (uniqState (Userıd))) ve her blok satırı için, önceki tüm Satırların ve geçerli satırın durumlarının birleştirilmesinde toplama işlevinin sonucunu döndürür. +Bu nedenle, işlevin sonucu, verilerin bloklara bölünmesine ve blok içindeki verilerin sırasına bağlıdır. + +## joinGet {#joinget} + +İşlev, tablodan verileri bir tablodan aynı şekilde ayıklamanızı sağlar [sözlük](../../sql_reference/dictionaries/index.md). + +Veri alır [Katmak](../../engines/table_engines/special/join.md#creating-a-table) belirtilen birleştirme anahtarını kullanarak tablolar. + +Sadece ile oluşturulan tabloları destekler `ENGINE = Join(ANY, LEFT, )` deyim. + +**Sözdizimi** + +``` sql +joinGet(join_storage_table_name, `value_column`, join_keys) +``` + +**Parametre** + +- `join_storage_table_name` — an [tanıtıcı](../syntax.md#syntax-identifiers) aramanın nerede yapıldığını gösterir. Tanımlayıcı varsayılan veritabanında aranır (bkz. parametre `default_database` config dosyası). Varsayılan veritabanını geçersiz kılmak için `USE db_name` veya ayırıcı aracılığıyla veritabanını ve tabloyu belirtin `db_name.db_table` örnek bakın. +- `value_column` — name of the column of the table that contains required data. +- `join_keys` — list of keys. + +**Döndürülen değer** + +Anahtarların listesine karşılık gelen değerlerin listesini döndürür. + +Kaynak tabloda kesin yoksa o zaman `0` veya `null` esas alınarak iade edilecektir [join\_use\_nulls](../../operations/settings/settings.md#join_use_nulls) ayar. + +Hakkında daha fazla bilgi `join_use_nulls` içinde [Birleştirme işlemi](../../engines/table_engines/special/join.md). + +**Örnek** + +Giriş tablosu: + +``` sql +CREATE DATABASE db_test +CREATE TABLE db_test.id_val(`id` UInt32, `val` UInt32) ENGINE = Join(ANY, LEFT, id) SETTINGS join_use_nulls = 1 +INSERT INTO db_test.id_val VALUES (1,11)(2,12)(4,13) +``` + +``` text +┌─id─┬─val─┐ +│ 4 │ 13 │ +│ 2 │ 12 │ +│ 1 │ 11 │ +└────┴─────┘ +``` + +Sorgu: + +``` sql +SELECT joinGet(db_test.id_val,'val',toUInt32(number)) from numbers(4) SETTINGS join_use_nulls = 1 +``` + +Sonuç: + +``` text +┌─joinGet(db_test.id_val, 'val', toUInt32(number))─┐ +│ 0 │ +│ 11 │ +│ 12 │ +│ 0 │ +└──────────────────────────────────────────────────┘ +``` + +## modelEvaluate(model\_name, …) {#function-modelevaluate} + +Dış modeli değerlendirin. +Bir model adı ve model bağımsız değişkenleri kabul eder. Float64 Döndürür. + +## throwİf(x \[, custom\_message\]) {#throwifx-custom-message} + +Argüman sıfır değilse bir istisna atın. +custom\_message-isteğe bağlı bir parametredir: sabit bir dize, bir hata mesajı sağlar + +``` sql +SELECT throwIf(number = 3, 'Too many') FROM numbers(10); +``` + +``` text +↙ Progress: 0.00 rows, 0.00 B (0.00 rows/s., 0.00 B/s.) Received exception from server (version 19.14.1): +Code: 395. DB::Exception: Received from localhost:9000. DB::Exception: Too many. +``` + +## kimlik {#identity} + +Bağımsız değişkeni olarak kullanılan aynı değeri döndürür. Hata ayıklama ve test için kullanılan, dizin kullanarak iptal ve tam bir tarama sorgu performansını almak için izin verir. Olası dizin kullanımı için sorgu analiz edildiğinde, analizör içeriye bakmaz `identity` işlevler. + +**Sözdizimi** + +``` sql +identity(x) +``` + +**Örnek** + +Sorgu: + +``` sql +SELECT identity(42) +``` + +Sonuç: + +``` text +┌─identity(42)─┐ +│ 42 │ +└──────────────┘ +``` + +## randomPrintableASCİİ {#randomascii} + +Rastgele bir dizi ile bir dize oluşturur [ASCII](https://en.wikipedia.org/wiki/ASCII#Printable_characters) yazdırılabilir karakterler. + +**Sözdizimi** + +``` sql +randomPrintableASCII(length) +``` + +**Parametre** + +- `length` — Resulting string length. Positive integer. + + If you pass `length < 0`, behavior of the function is undefined. + +**Döndürülen değer** + +- Rastgele bir dizi dize [ASCII](https://en.wikipedia.org/wiki/ASCII#Printable_characters) yazdırılabilir karakterler. + +Tür: [Dize](../../sql_reference/data_types/string.md) + +**Örnek** + +``` sql +SELECT number, randomPrintableASCII(30) as str, length(str) FROM system.numbers LIMIT 3 +``` + +``` text +┌─number─┬─str────────────────────────────┬─length(randomPrintableASCII(30))─┐ +│ 0 │ SuiCOSTvC0csfABSw=UcSzp2.`rv8x │ 30 │ +│ 1 │ 1Ag NlJ &RCN:*>HVPG;PE-nO"SUFD │ 30 │ +│ 2 │ /"+<"wUTh:=LjJ Vm!c&hI*m#XTfzz │ 30 │ +└────────┴────────────────────────────────┴──────────────────────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/other_functions/) diff --git a/docs/tr/sql_reference/functions/random_functions.md b/docs/tr/sql_reference/functions/random_functions.md new file mode 100644 index 00000000000..e57106426f4 --- /dev/null +++ b/docs/tr/sql_reference/functions/random_functions.md @@ -0,0 +1,30 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 51 +toc_title: "S\xF6zde Rasgele Say\u0131lar Olu\u015Fturma" +--- + +# Sözde rasgele sayılar üretmek için fonksiyonlar {#functions-for-generating-pseudo-random-numbers} + +Sözde rasgele sayıların kriptografik olmayan jeneratörleri kullanılır. + +Tüm işlevler sıfır bağımsız değişkeni veya bir bağımsız değişkeni kabul eder. +Bir argüman geçirilirse, herhangi bir tür olabilir ve değeri hiçbir şey için kullanılmaz. +Bu argümanın tek amacı, aynı işlevin iki farklı örneğinin farklı rasgele sayılarla farklı sütunlar döndürmesi için ortak alt ifade eliminasyonunu önlemektir. + +## Güney Afrika parası {#rand} + +Tüm uint32 tipi sayılar arasında eşit olarak dağıtılan bir sözde rasgele uint32 numarası döndürür. +Doğrusal bir uyumlu jeneratör kullanır. + +## rand64 {#rand64} + +Tüm uint64 tipi sayılar arasında eşit olarak dağıtılan sözde rasgele bir uint64 numarası döndürür. +Doğrusal bir uyumlu jeneratör kullanır. + +## randConstant {#randconstant} + +Bir sözde rastgele uint32 numarası döndürür, değer farklı bloklar için birdir. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/random_functions/) diff --git a/docs/tr/sql_reference/functions/rounding_functions.md b/docs/tr/sql_reference/functions/rounding_functions.md new file mode 100644 index 00000000000..6d47ae54dae --- /dev/null +++ b/docs/tr/sql_reference/functions/rounding_functions.md @@ -0,0 +1,190 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 45 +toc_title: "D\xF6nm\xFC\u015F" +--- + +# Yuvarlama fonksiyonları {#rounding-functions} + +## kat(x \[, N\]) {#floorx-n} + +Küçük veya eşit olan en büyük yuvarlak sayıyı döndürür `x`. Yuvarlak bir sayı, 1/10N'NİN katları veya 1 / 10N tam değilse, uygun veri türünün en yakın sayısıdır. +‘N’ bir tamsayı sabiti, isteğe bağlı parametredir. Varsayılan olarak sıfırdır, bu da bir tam sayıya yuvarlamak anlamına gelir. +‘N’ negatif olabilir. + +Örnekler: `floor(123.45, 1) = 123.4, floor(123.45, -1) = 120.` + +`x` herhangi bir sayısal türüdür. Sonuç aynı türden bir sayıdır. +Tamsayı argümanları için, bir negatif ile yuvarlamak mantıklıdır `N` değer (negatif olmayan için `N`, işlev hiçbir şey yapmaz). +Yuvarlama taşmasına neden olursa (örneğin, floor (-128, -1)), uygulamaya özgü bir sonuç döndürülür. + +## tavan(x \[, N\]), tavan (x \[, N\]) {#ceilx-n-ceilingx-n} + +Büyük veya eşit olan en küçük yuvarlak sayıyı döndürür `x`. Diğer her şekilde, aynı `floor` (yukarıda) işlevi. + +## trunc(x \[, N\]), truncate(x \[, N\]) {#truncx-n-truncatex-n} + +Mutlak değeri küçük veya eşit olan en büyük mutlak değere sahip yuvarlak sayıyı döndürür `x`‘s. In every other way, it is the same as the ’floor’ (yukarıda) işlevi. + +## Yuvarlak(x \[, N\]) {#rounding_functions-round} + +Belirtilen sayıda ondalık basamak için bir değer yuvarlar. + +İşlev, belirtilen siparişin en yakın numarasını döndürür. Verilen sayı çevreleyen sayılara eşit mesafeye sahip olduğunda, işlev, float sayı türleri için bankacının yuvarlamasını kullanır ve diğer sayı türleri için sıfırdan uzaklaşır. + +``` sql +round(expression [, decimal_places]) +``` + +**Parametre:** + +- `expression` — A number to be rounded. Can be any [ifade](../syntax.md#syntax-expressions) sayısal dönen [veri türü](../../sql_reference/data_types/index.md#data_types). +- `decimal-places` — An integer value. + - Eğer `decimal-places > 0` sonra işlev değeri ondalık noktanın sağına yuvarlar. + - Eğer `decimal-places < 0` ardından işlev değeri ondalık noktanın soluna yuvarlar. + - Eğer `decimal-places = 0` sonra işlev değeri tamsayı olarak yuvarlar. Bu durumda argüman ihmal edilebilir. + +**Döndürülen değer:** + +Giriş numarası ile aynı türden yuvarlatılmış sayı. + +### Örnekler {#examples} + +**Kullanım örneği** + +``` sql +SELECT number / 2 AS x, round(x) FROM system.numbers LIMIT 3 +``` + +``` text +┌───x─┬─round(divide(number, 2))─┐ +│ 0 │ 0 │ +│ 0.5 │ 0 │ +│ 1 │ 1 │ +└─────┴──────────────────────────┘ +``` + +**Yuvarlama örnekleri** + +En yakın numaraya yuvarlama. + +``` text +round(3.2, 0) = 3 +round(4.1267, 2) = 4.13 +round(22,-1) = 20 +round(467,-2) = 500 +round(-467,-2) = -500 +``` + +Bankacı yuvarlanıyor. + +``` text +round(3.5) = 4 +round(4.5) = 4 +round(3.55, 1) = 3.6 +round(3.65, 1) = 3.6 +``` + +**Ayrıca Bakınız** + +- [roundBankers](#roundbankers) + +## roundBankers {#roundbankers} + +Bir sayıyı belirtilen ondalık konuma yuvarlar. + +- Yuvarlama sayısı iki sayı arasında yarıya ise, işlev banker yuvarlama kullanır. + + Banker's rounding is a method of rounding fractional numbers. When the rounding number is halfway between two numbers, it's rounded to the nearest even digit at the specified decimal position. For example: 3.5 rounds up to 4, 2.5 rounds down to 2. + + It's the default rounding method for floating point numbers defined in [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754#Roundings_to_nearest). The [round](#rounding_functions-round) function performs the same rounding for floating point numbers. The `roundBankers` function also rounds integers the same way, for example, `roundBankers(45, -1) = 40`. + +- Diğer durumlarda, işlev sayıları en yakın tam sayıya yuvarlar. + +Banker yuvarlama kullanarak, yuvarlama numaraları toplama veya bu sayıları çıkarma sonuçları üzerindeki etkisini azaltabilir. + +Örneğin, farklı yuvarlama ile 1.5, 2.5, 3.5, 4.5 sayılarını topla: + +- Yuvarlama yok: 1.5 + 2.5 + 3.5 + 4.5 = 12. +- Bankacı yuvarlama: 2 + 2 + 4 + 4 = 12. +- En yakın tam sayıya yuvarlama: 2 + 3 + 4 + 5 = 14. + +**Sözdizimi** + +``` sql +roundBankers(expression [, decimal_places]) +``` + +**Parametre** + +- `expression` — A number to be rounded. Can be any [ifade](../syntax.md#syntax-expressions) sayısal dönen [veri türü](../../sql_reference/data_types/index.md#data_types). +- `decimal-places` — Decimal places. An integer number. + - `decimal-places > 0` — The function rounds the number to the given position right of the decimal point. Example: `roundBankers(3.55, 1) = 3.6`. + - `decimal-places < 0` — The function rounds the number to the given position left of the decimal point. Example: `roundBankers(24.55, -1) = 20`. + - `decimal-places = 0` — The function rounds the number to an integer. In this case the argument can be omitted. Example: `roundBankers(2.5) = 2`. + +**Döndürülen değer** + +Banker yuvarlama yöntemi tarafından yuvarlanan bir değer. + +### Örnekler {#examples-1} + +**Kullanım örneği** + +Sorgu: + +``` sql + SELECT number / 2 AS x, roundBankers(x, 0) AS b fROM system.numbers limit 10 +``` + +Sonuç: + +``` text +┌───x─┬─b─┐ +│ 0 │ 0 │ +│ 0.5 │ 0 │ +│ 1 │ 1 │ +│ 1.5 │ 2 │ +│ 2 │ 2 │ +│ 2.5 │ 2 │ +│ 3 │ 3 │ +│ 3.5 │ 4 │ +│ 4 │ 4 │ +│ 4.5 │ 4 │ +└─────┴───┘ +``` + +**Bankacı yuvarlama örnekleri** + +``` text +roundBankers(0.4) = 0 +roundBankers(-3.5) = -4 +roundBankers(4.5) = 4 +roundBankers(3.55, 1) = 3.6 +roundBankers(3.65, 1) = 3.6 +roundBankers(10.35, 1) = 10.4 +roundBankers(10.755, 2) = 11,76 +``` + +**Ayrıca Bakınız** + +- [turlu](#rounding_functions-round) + +## roundToExp2 (num) {#roundtoexp2num} + +Bir sayı kabul eder. Sayı birden az ise, 0 döndürür. Aksi takdirde, sayıyı en yakın (negatif olmayan) iki dereceye yuvarlar. + +## roundDuration (num) {#rounddurationnum} + +Bir sayı kabul eder. Sayı birden az ise, 0 döndürür. Aksi takdirde, sayıyı kümeden sayılara yuvarlar: 1, 10, 30, 60, 120, 180, 240, 300, 600, 1200, 1800, 3600, 7200, 18000, 36000. Bu fonksiyon (kayıt olmak için özeldir.Metrica ve oturum uzunluğu raporu uygulamak için kullanılır. + +## roundAge (num) {#roundagenum} + +Bir sayı kabul eder. Sayı 18'den küçükse, 0 döndürür. Aksi takdirde, sayıyı kümeden bir sayıya yuvarlar: 18, 25, 35, 45, 55. Bu fonksiyon (kayıt olmak için özeldir.Metrica ve kullanıcı yaş raporu uygulamak için kullanılır. + +## roundDown (num, arr) {#rounddownnum-arr} + +Bir sayıyı kabul eder ve belirtilen Dizideki bir öğeye yuvarlar. Değer en düşük sınırdan küçükse, en düşük sınır döndürülür. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/rounding_functions/) diff --git a/docs/tr/sql_reference/functions/splitting_merging_functions.md b/docs/tr/sql_reference/functions/splitting_merging_functions.md new file mode 100644 index 00000000000..81269606d98 --- /dev/null +++ b/docs/tr/sql_reference/functions/splitting_merging_functions.md @@ -0,0 +1,116 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 47 +toc_title: "Dizeleri ve dizileri b\xF6lme ve birle\u015Ftirme" +--- + +# Dizeleri ve dizileri bölme ve birleştirme işlevleri {#functions-for-splitting-and-merging-strings-and-arrays} + +## splitByChar (ayırıcı, s) {#splitbycharseparator-s} + +Bir dizeyi belirtilen bir karakterle ayrılmış alt dizelere böler. Sabit bir dize kullanır `separator` tam olarak bir karakterden oluşan. +Seçili alt dizelerin bir dizisini döndürür. Ayırıcı dizenin başında veya sonunda oluşursa veya ardışık birden çok ayırıcı varsa, boş alt dizeler seçilebilir. + +**Sözdizimi** + +``` sql +splitByChar(, ) +``` + +**Parametre** + +- `separator` — The separator which should contain exactly one character. [Dize](../../sql_reference/data_types/string.md). +- `s` — The string to split. [Dize](../../sql_reference/data_types/string.md). + +**Döndürülen değer (ler)** + +Seçili alt dizelerin bir dizisini döndürür. Boş alt dizeler şu durumlarda seçilebilir: + +- Dizenin başında veya sonunda bir ayırıcı oluşur; +- Birden fazla ardışık ayırıcı vardır; +- Orijinal dize `s` boş. + +Tür: [Dizi](../../sql_reference/data_types/array.md) -den [Dize](../../sql_reference/data_types/string.md). + +**Örnek** + +``` sql +SELECT splitByChar(',', '1,2,3,abcde') +``` + +``` text +┌─splitByChar(',', '1,2,3,abcde')─┐ +│ ['1','2','3','abcde'] │ +└─────────────────────────────────┘ +``` + +## splitByString (ayırıcı, s) {#splitbystringseparator-s} + +Bir dizeyi bir dizeyle ayrılmış alt dizelere böler. Sabit bir dize kullanır `separator` ayırıcı olarak birden fazla karakter. Eğer dize `separator` boş olduğunu, bu bölünmüş dize `s` tek karakter dizisine. + +**Sözdizimi** + +``` sql +splitByString(, ) +``` + +**Parametre** + +- `separator` — The separator. [Dize](../../sql_reference/data_types/string.md). +- `s` — The string to split. [Dize](../../sql_reference/data_types/string.md). + +**Döndürülen değer (ler)** + +Seçili alt dizelerin bir dizisini döndürür. Boş alt dizeler şu durumlarda seçilebilir: + +Tür: [Dizi](../../sql_reference/data_types/array.md) -den [Dize](../../sql_reference/data_types/string.md). + +- Boş olmayan bir ayırıcı dizenin başında veya sonunda oluşur; +- Birden fazla ardışık boş olmayan ayırıcı vardır; +- Orijinal dize `s` ayırıcı boş değilken boş. + +**Örnek** + +``` sql +SELECT splitByString(', ', '1, 2 3, 4,5, abcde') +``` + +``` text +┌─splitByString(', ', '1, 2 3, 4,5, abcde')─┐ +│ ['1','2 3','4,5','abcde'] │ +└───────────────────────────────────────────┘ +``` + +``` sql +SELECT splitByString('', 'abcde') +``` + +``` text +┌─splitByString('', 'abcde')─┐ +│ ['a','b','c','d','e'] │ +└────────────────────────────┘ +``` + +## arrayStringConcat(arr \[, ayırıcı\]) {#arraystringconcatarr-separator} + +Dizide listelenen dizeleri ayırıcı ile birleştirir.'separator' isteğe bağlı bir parametredir: varsayılan olarak boş bir dizeye ayarlanmış sabit bir dize. +Dizeyi döndürür. + +## alphaTokens (s) {#alphatokenss} + +A-z ve A-Z aralıklarından ardışık baytların alt dizelerini seçer. + +**Örnek** + +``` sql +SELECT alphaTokens('abca1abc') +``` + +``` text +┌─alphaTokens('abca1abc')─┐ +│ ['abca','abc'] │ +└─────────────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/splitting_merging_functions/) diff --git a/docs/tr/sql_reference/functions/string_functions.md b/docs/tr/sql_reference/functions/string_functions.md new file mode 100644 index 00000000000..012c8210537 --- /dev/null +++ b/docs/tr/sql_reference/functions/string_functions.md @@ -0,0 +1,489 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 40 +toc_title: "Dizeleri ile \xE7al\u0131\u015Fma" +--- + +# Dizelerle çalışmak için işlevler {#functions-for-working-with-strings} + +## boş {#empty} + +Boş bir dize için 1 veya boş olmayan bir dize için 0 döndürür. +Sonuç türü Uint8'dir. +Bir boşluk veya boş bayt olsa bile, en az bir bayt içeriyorsa, bir dize boş olarak kabul edilir. +İşlev ayrıca diziler için de çalışır. + +## notEmpty {#notempty} + +Boş bir dize için 0 veya boş olmayan bir dize için 1 döndürür. +Sonuç türü Uint8'dir. +İşlev ayrıca diziler için de çalışır. + +## uzunluk {#length} + +Bir dizenin uzunluğunu bayt cinsinden döndürür (karakterlerde değil, kod noktalarında değil). +Sonuç türü Uint64'tür. +İşlev ayrıca diziler için de çalışır. + +## lengthUTF8 {#lengthutf8} + +Dizenin UTF-8 kodlanmış metni oluşturan bir bayt kümesi içerdiğini varsayarak, Unicode kod noktalarında (karakterlerde değil) bir dizenin uzunluğunu döndürür. Bu varsayım karşılanmazsa, bir sonuç döndürür (bir istisna atmaz). +Sonuç türü Uint64'tür. + +## char\_length, CHAR\_LENGTH {#char-length} + +Dizenin UTF-8 kodlanmış metni oluşturan bir bayt kümesi içerdiğini varsayarak, Unicode kod noktalarında (karakterlerde değil) bir dizenin uzunluğunu döndürür. Bu varsayım karşılanmazsa, bir sonuç döndürür (bir istisna atmaz). +Sonuç türü Uint64'tür. + +## character\_length, CHARACTER\_LENGTH {#character-length} + +Dizenin UTF-8 kodlanmış metni oluşturan bir bayt kümesi içerdiğini varsayarak, Unicode kod noktalarında (karakterlerde değil) bir dizenin uzunluğunu döndürür. Bu varsayım karşılanmazsa, bir sonuç döndürür (bir istisna atmaz). +Sonuç türü Uint64'tür. + +## alt, lcase {#lower} + +Bir dizedeki ASCII Latin sembollerini küçük harfe dönüştürür. + +## üst, ucase {#upper} + +Bir dizedeki ASCII Latin sembollerini büyük harfe dönüştürür. + +## lowerUTF8 {#lowerutf8} + +Dizenin UTF-8 kodlu bir metni oluşturan bir bayt kümesi içerdiğini varsayarak bir dizeyi küçük harfe dönüştürür. +Dili algılamaz. Yani Türkçe için sonuç tam olarak doğru olmayabilir. +UTF-8 bayt dizisinin uzunluğu bir kod noktasının büyük ve küçük harf için farklıysa, sonuç bu kod noktası için yanlış olabilir. +Dize, UTF-8 olmayan bir bayt kümesi içeriyorsa, davranış tanımsızdır. + +## upperUTF8 {#upperutf8} + +Dize, UTF-8 kodlanmış bir metni oluşturan bir bayt kümesi içerdiğini varsayarak bir dizeyi büyük harfe dönüştürür. +Dili algılamaz. Yani Türkçe için sonuç tam olarak doğru olmayabilir. +UTF-8 bayt dizisinin uzunluğu bir kod noktasının büyük ve küçük harf için farklıysa, sonuç bu kod noktası için yanlış olabilir. +Dize, UTF-8 olmayan bir bayt kümesi içeriyorsa, davranış tanımsızdır. + +## ısvalidutf8 {#isvalidutf8} + +Bayt kümesi geçerli UTF-8 kodlanmış, aksi takdirde 0 ise, 1 döndürür. + +## toValidUTF8 {#tovalidutf8} + +Geçersiz UTF-8 karakterlerini değiştirir `�` (U+FFFD) karakteri. Bir satırda çalışan tüm geçersiz karakterler bir yedek karaktere daraltılır. + +``` sql +toValidUTF8( input_string ) +``` + +Parametre: + +- input\_string — Any set of bytes represented as the [Dize](../../sql_reference/data_types/string.md) veri türü nesnesi. + +Döndürülen değer: geçerli UTF-8 dizesi. + +**Örnek** + +``` sql +SELECT toValidUTF8('\x61\xF0\x80\x80\x80b') +``` + +``` text +┌─toValidUTF8('a����b')─┐ +│ a�b │ +└───────────────────────┘ +``` + +## tekrarlama {#repeat} + +Bir dizeyi belirtilen kadar çok tekrarlar ve çoğaltılmış değerleri tek bir dize olarak birleştirir. + +**Sözdizimi** + +``` sql +repeat(s, n) +``` + +**Parametre** + +- `s` — The string to repeat. [Dize](../../sql_reference/data_types/string.md). +- `n` — The number of times to repeat the string. [Uİnt](../../sql_reference/data_types/int_uint.md). + +**Döndürülen değer** + +Dize içeren tek dize `s` tekrarlanan `n` kez. Eğer `n` \< 1, işlev boş dize döndürür. + +Tür: `String`. + +**Örnek** + +Sorgu: + +``` sql +SELECT repeat('abc', 10) +``` + +Sonuç: + +``` text +┌─repeat('abc', 10)──────────────┐ +│ abcabcabcabcabcabcabcabcabcabc │ +└────────────────────────────────┘ +``` + +## tersi {#reverse} + +Dizeyi tersine çevirir (bayt dizisi olarak). + +## reverseUTF8 {#reverseutf8} + +Dizenin UTF-8 metnini temsil eden bir bayt kümesi içerdiğini varsayarak bir Unicode kod noktası dizisini tersine çevirir. Aksi takdirde, başka bir şey yapar(bir istisna atmaz). + +## format(pattern, s0, s1, …) {#format} + +Bağımsız değişkenlerde listelenen dize ile sabit desen biçimlendirme. `pattern` basitleştirilmiş bir Python biçimi desenidir. Biçim dizesi içerir “replacement fields” kıvırcık parantez ile çevrili `{}`. Parantez içinde bulunmayan herhangi bir şey, çıktıya değişmeden kopyalanan hazır metin olarak kabul edilir. Literal metne bir ayraç karakteri eklemeniz gerekiyorsa, iki katına çıkararak kaçabilir: `{{ '{{' }}` ve `{{ '}}' }}`. Alan adları sayılar (sıfırdan başlayarak) veya boş olabilir (daha sonra sonuç numaraları olarak kabul edilir). + +``` sql +SELECT format('{1} {0} {1}', 'World', 'Hello') +``` + +``` text +┌─format('{1} {0} {1}', 'World', 'Hello')─┐ +│ Hello World Hello │ +└─────────────────────────────────────────┘ +``` + +``` sql +SELECT format('{} {}', 'Hello', 'World') +``` + +``` text +┌─format('{} {}', 'Hello', 'World')─┐ +│ Hello World │ +└───────────────────────────────────┘ +``` + +## concat {#concat} + +Bağımsız değişkenlerde listelenen dizeleri ayırıcı olmadan birleştirir. + +**Sözdizimi** + +``` sql +concat(s1, s2, ...) +``` + +**Parametre** + +String veya FixedString türünün değerleri. + +**Döndürülen değerler** + +Bağımsız değişkenlerin birleştirilmesinden kaynaklanan dizeyi döndürür. + +Argüman değerlerinden herhangi biri ise `NULL`, `concat` dönüşler `NULL`. + +**Örnek** + +Sorgu: + +``` sql +SELECT concat('Hello, ', 'World!') +``` + +Sonuç: + +``` text +┌─concat('Hello, ', 'World!')─┐ +│ Hello, World! │ +└─────────────────────────────┘ +``` + +## concatassumeınjective {#concatassumeinjective} + +Aynı olarak [concat](#concat) emin olun bu ihtiyaç fark var `concat(s1, s2, ...) → sn` enjekte edilir, grup tarafından optimizasyonu için kullanılacaktır. + +İşlev adlı “injective” bağımsız değişkenlerin farklı değerleri için her zaman farklı sonuç döndürürse. Başka bir deyişle: farklı argümanlar asla aynı sonucu vermez. + +**Sözdizimi** + +``` sql +concatAssumeInjective(s1, s2, ...) +``` + +**Parametre** + +String veya FixedString türünün değerleri. + +**Döndürülen değerler** + +Bağımsız değişkenlerin birleştirilmesinden kaynaklanan dizeyi döndürür. + +Argüman değerlerinden herhangi biri ise `NULL`, `concatAssumeInjective` dönüşler `NULL`. + +**Örnek** + +Giriş tablosu: + +``` sql +CREATE TABLE key_val(`key1` String, `key2` String, `value` UInt32) ENGINE = TinyLog; +INSERT INTO key_val VALUES ('Hello, ','World',1), ('Hello, ','World',2), ('Hello, ','World!',3), ('Hello',', World!',2); +SELECT * from key_val; +``` + +``` text +┌─key1────┬─key2─────┬─value─┐ +│ Hello, │ World │ 1 │ +│ Hello, │ World │ 2 │ +│ Hello, │ World! │ 3 │ +│ Hello │ , World! │ 2 │ +└─────────┴──────────┴───────┘ +``` + +Sorgu: + +``` sql +SELECT concat(key1, key2), sum(value) FROM key_val GROUP BY concatAssumeInjective(key1, key2) +``` + +Sonuç: + +``` text +┌─concat(key1, key2)─┬─sum(value)─┐ +│ Hello, World! │ 3 │ +│ Hello, World! │ 2 │ +│ Hello, World │ 3 │ +└────────────────────┴────────────┘ +``` + +## alt dize (s, ofset, uzunluk), orta (s, ofset, uzunluk), substr (s, ofset, uzunluk) {#substring} + +Bayttan başlayarak bir alt dize döndürür ‘offset’ ind thatex yani ‘length’ uzun bayt. Karakter indeksleme birinden başlar (standart SQL'DE olduğu gibi). Bu ‘offset’ ve ‘length’ bağımsız değişkenler sabit olmalıdır. + +## substringUTF8(s, ofset, uzunluk) {#substringutf8} + +Olarak aynı ‘substring’, ancak Unicode kod noktaları için. Dizenin UTF-8 kodlanmış bir metni temsil eden bir bayt kümesi içerdiği varsayımı altında çalışır. Bu varsayım karşılanmazsa, bir sonuç döndürür (bir istisna atmaz). + +## appendTrailingCharİfAbsent (s, c) {#appendtrailingcharifabsent} + +Eğer... ‘s’ dize boş değildir ve ‘c’ sonunda karakter, ekler ‘c’ sonuna kadar karakter. + +## convertCharset (s, from, to) {#convertcharset} + +Dize döndürür ‘s’ bu kodlamadan dönüştürüldü ‘from’ kod encodinglamaya ‘to’. + +## base64Encode (s) {#base64encode} + +Kodluyor ‘s’ Base64 içine dize + +## base64Decode (s) {#base64decode} + +Base64 kodlu dizeyi çözme ‘s’ orijinal dizeye. Başarısızlık durumunda bir istisna yükseltir. + +## tryBase64Decode (s) {#trybase64decode} + +Base64decode'a benzer, ancak hata durumunda boş bir dize döndürülür. + +## endsWith (s, sonek) {#endswith} + +Belirtilen sonek ile bitip bitmeyeceğini döndürür. Dize belirtilen sonek ile biterse 1 değerini döndürür, aksi takdirde 0 değerini döndürür. + +## startsWith (str, önek) {#startswith} + +Dize belirtilen önek ile başlayıp başlamadığını 1 döndürür, aksi halde 0 döndürür. + +``` sql +SELECT startsWith('Spider-Man', 'Spi'); +``` + +**Döndürülen değerler** + +- 1, dize belirtilen önek ile başlarsa. +- 0, dize belirtilen önek ile başlamazsa. + +**Örnek** + +Sorgu: + +``` sql +SELECT startsWith('Hello, world!', 'He'); +``` + +Sonuç: + +``` text +┌─startsWith('Hello, world!', 'He')─┐ +│ 1 │ +└───────────────────────────────────┘ +``` + +## kırpmak {#trim} + +Belirtilen tüm karakterleri bir dizenin başlangıcından veya sonundan kaldırır. +Varsayılan olarak, bir dizenin her iki ucundan ortak boşlukların (ASCII karakteri 32) tüm ardışık tekrarlarını kaldırır. + +**Sözdizimi** + +``` sql +trim([[LEADING|TRAILING|BOTH] trim_character FROM] input_string) +``` + +**Parametre** + +- `trim_character` — specified characters for trim. [Dize](../../sql_reference/data_types/string.md). +- `input_string` — string for trim. [Dize](../../sql_reference/data_types/string.md). + +**Döndürülen değer** + +Önde gelen ve (veya) belirtilen karakterleri izleyen bir dize. + +Tür: `String`. + +**Örnek** + +Sorgu: + +``` sql +SELECT trim(BOTH ' ()' FROM '( Hello, world! )') +``` + +Sonuç: + +``` text +┌─trim(BOTH ' ()' FROM '( Hello, world! )')─┐ +│ Hello, world! │ +└───────────────────────────────────────────────┘ +``` + +## trimLeft {#trimleft} + +Bir dizenin başlangıcından ortak boşluk (ASCII karakteri 32) tüm ardışık tekrarlarını kaldırır. Diğer boşluk karakterlerini (sekme, boşluksuz boşluk, vb.) kaldırmaz.). + +**Sözdizimi** + +``` sql +trimLeft(input_string) +``` + +Takma ad: `ltrim(input_string)`. + +**Parametre** + +- `input_string` — string to trim. [Dize](../../sql_reference/data_types/string.md). + +**Döndürülen değer** + +Bir dize olmadan lider ortak whitespaces. + +Tür: `String`. + +**Örnek** + +Sorgu: + +``` sql +SELECT trimLeft(' Hello, world! ') +``` + +Sonuç: + +``` text +┌─trimLeft(' Hello, world! ')─┐ +│ Hello, world! │ +└─────────────────────────────────────┘ +``` + +## trimRight {#trimright} + +Bir dizenin sonundan ortak boşluk (ASCII karakteri 32) tüm ardışık tekrarlarını kaldırır. Diğer boşluk karakterlerini (sekme, boşluksuz boşluk, vb.) kaldırmaz.). + +**Sözdizimi** + +``` sql +trimRight(input_string) +``` + +Takma ad: `rtrim(input_string)`. + +**Parametre** + +- `input_string` — string to trim. [Dize](../../sql_reference/data_types/string.md). + +**Döndürülen değer** + +Ortak whitespaces firar olmadan bir dize. + +Tür: `String`. + +**Örnek** + +Sorgu: + +``` sql +SELECT trimRight(' Hello, world! ') +``` + +Sonuç: + +``` text +┌─trimRight(' Hello, world! ')─┐ +│ Hello, world! │ +└──────────────────────────────────────┘ +``` + +## trimBoth {#trimboth} + +Bir dizenin her iki ucundan ortak boşluk (ASCII karakteri 32) tüm ardışık tekrarlarını kaldırır. Diğer boşluk karakterlerini (sekme, boşluksuz boşluk, vb.) kaldırmaz.). + +**Sözdizimi** + +``` sql +trimBoth(input_string) +``` + +Takma ad: `trim(input_string)`. + +**Parametre** + +- `input_string` — string to trim. [Dize](../../sql_reference/data_types/string.md). + +**Döndürülen değer** + +Bir dize olmadan lider ve sondaki ortak whitespaces. + +Tür: `String`. + +**Örnek** + +Sorgu: + +``` sql +SELECT trimBoth(' Hello, world! ') +``` + +Sonuç: + +``` text +┌─trimBoth(' Hello, world! ')─┐ +│ Hello, world! │ +└─────────────────────────────────────┘ +``` + +## CRC32 (s) {#crc32} + +CRC-32-IEEE 802.3 polinom ve başlangıç değerini kullanarak bir dizenin CRC32 sağlama toplamını döndürür `0xffffffff` (zlib uygulaması). + +Sonuç türü Uint32'dir. + +## Crc32ieee (s) {#crc32ieee} + +CRC-32-IEEE 802.3 polinomunu kullanarak bir dizenin CRC32 sağlama toplamını döndürür. + +Sonuç türü Uint32'dir. + +## CRC64 (s) {#crc64} + +CRC-64-ECMA polinomunu kullanarak bir dizenin CRC64 sağlama toplamını döndürür. + +Sonuç türü Uint64'tür. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/string_functions/) diff --git a/docs/tr/sql_reference/functions/string_replace_functions.md b/docs/tr/sql_reference/functions/string_replace_functions.md new file mode 100644 index 00000000000..6a6c0e56aec --- /dev/null +++ b/docs/tr/sql_reference/functions/string_replace_functions.md @@ -0,0 +1,94 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 42 +toc_title: "Dizelerde de\u011Fi\u015Ftirilmesi i\xE7in" +--- + +# Dizelerde arama ve değiştirme işlevleri {#functions-for-searching-and-replacing-in-strings} + +## replaceOne(Samanlık, desen, değiştirme) {#replaceonehaystack-pattern-replacement} + +Varsa, ilk oluş replacesumun yerini ‘pattern’ substring içinde ‘haystack’ ile... ‘replacement’ dize. +Ahiret, ‘pattern’ ve ‘replacement’ sabitleri olması gerekir. + +## replaceAll (Samanlık, desen, değiştirme), değiştirin (Samanlık, desen, değiştirme) {#replaceallhaystack-pattern-replacement-replacehaystack-pattern-replacement} + +Tüm oluşumları değiştirir ‘pattern’ substring içinde ‘haystack’ ile... ‘replacement’ dize. + +## replaceRegexpOne(Samanlık, desen, değiştirme) {#replaceregexponehaystack-pattern-replacement} + +Kullanarak değiştirme ‘pattern’ düzenli ifade. Re2 düzenli ifade. +Varsa, yalnızca ilk oluşumu değiştirir. +Bir desen olarak belirtilebilir ‘replacement’. Bu desen değiştirmeleri içerebilir `\0-\9`. +İkame `\0` tüm düzenli ifadeyi içerir. İkameler `\1-\9` alt desene karşılık gelir numbers.To use the `\` bir şablondaki karakter, kullanarak kaçış `\`. +Ayrıca, bir dize literalinin ekstra bir kaçış gerektirdiğini unutmayın. + +Örnek 1. Tarihi Amerikan format convertingına dönüştürme: + +``` sql +SELECT DISTINCT + EventDate, + replaceRegexpOne(toString(EventDate), '(\\d{4})-(\\d{2})-(\\d{2})', '\\2/\\3/\\1') AS res +FROM test.hits +LIMIT 7 +FORMAT TabSeparated +``` + +``` text +2014-03-17 03/17/2014 +2014-03-18 03/18/2014 +2014-03-19 03/19/2014 +2014-03-20 03/20/2014 +2014-03-21 03/21/2014 +2014-03-22 03/22/2014 +2014-03-23 03/23/2014 +``` + +Örnek 2. Bir dize on kez kopyalama: + +``` sql +SELECT replaceRegexpOne('Hello, World!', '.*', '\\0\\0\\0\\0\\0\\0\\0\\0\\0\\0') AS res +``` + +``` text +┌─res────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ +│ Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World!Hello, World! │ +└────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ +``` + +## replaceRegexpAll(Samanlık, desen, değiştirme) {#replaceregexpallhaystack-pattern-replacement} + +Bu aynı şeyi yapar, ancak tüm oluşumların yerini alır. Örnek: + +``` sql +SELECT replaceRegexpAll('Hello, World!', '.', '\\0\\0') AS res +``` + +``` text +┌─res────────────────────────┐ +│ HHeelllloo,, WWoorrlldd!! │ +└────────────────────────────┘ +``` + +Normal bir ifade boş bir alt dize üzerinde çalıştıysa, bir istisna olarak, değiştirme birden çok kez yapılmaz. +Örnek: + +``` sql +SELECT replaceRegexpAll('Hello, World!', '^', 'here: ') AS res +``` + +``` text +┌─res─────────────────┐ +│ here: Hello, World! │ +└─────────────────────┘ +``` + +## regexpQuoteMeta (s) {#regexpquotemetas} + +İşlev, dizedeki bazı önceden tanımlanmış karakterlerden önce bir ters eğik çizgi ekler. +Önceden tanımlanmış karakterler: ‘0’, ‘\\’, ‘\|’, ‘(’, ‘)’, ‘^’, ‘$’, ‘.’, ‘\[’, '\]', ‘?’, '\*‘,’+‘,’{‘,’:‘,’-'. +Bu uygulama biraz re2::RE2::QuoteMeta farklıdır. Sıfır bayttan 00 yerine \\0 olarak çıkar ve yalnızca gerekli karakterlerden kaçar. +Daha fazla bilgi için bağlantıya bakın: [RE2](https://github.com/google/re2/blob/master/re2/re2.cc#L473) + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/string_replace_functions/) diff --git a/docs/tr/sql_reference/functions/string_search_functions.md b/docs/tr/sql_reference/functions/string_search_functions.md new file mode 100644 index 00000000000..bfa3d8d0bd7 --- /dev/null +++ b/docs/tr/sql_reference/functions/string_search_functions.md @@ -0,0 +1,379 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 41 +toc_title: "Arama Dizeleri \u0130\xE7in" +--- + +# Dizeleri aramak için işlevler {#functions-for-searching-strings} + +Arama, tüm bu işlevlerde varsayılan olarak büyük / küçük harf duyarlıdır. Büyük / küçük harf duyarlı arama için ayrı Varyantlar vardır. + +## pozisyon (Samanlık, iğne), bulun (Samanlık, iğne) {#position} + +1'den başlayarak dizedeki bulunan alt dizenin konumunu (bayt cinsinden) döndürür. + +Dize, tek baytlık kodlanmış bir metni temsil eden bir bayt kümesi içerdiği varsayımı altında çalışır. Bu varsayım karşılanmazsa ve bir karakter tek bir bayt kullanılarak temsil edilemezse, işlev bir istisna atmaz ve beklenmeyen bir sonuç döndürür. Karakter iki bayt kullanılarak temsil edilebilirse, iki bayt vb. kullanır. + +Büyük / küçük harf duyarsız arama için işlevi kullanın [positionCaseİnsensitive](#positioncaseinsensitive). + +**Sözdizimi** + +``` sql +position(haystack, needle) +``` + +Takma ad: `locate(haystack, needle)`. + +**Parametre** + +- `haystack` — string, in which substring will to be searched. [Dize](../syntax.md#syntax-string-literal). +- `needle` — substring to be searched. [Dize](../syntax.md#syntax-string-literal). + +**Döndürülen değerler** + +- Alt dize bulunursa, bayt cinsinden başlangıç pozisyonu (1'den sayma). +- 0, alt dize bulunamadı. + +Tür: `Integer`. + +**Örnekler** + +İfade “Hello, world!” tek baytla kodlanmış bir metni temsil eden bir bayt kümesi içerir. İşlev beklenen bazı sonuçları döndürür: + +Sorgu: + +``` sql +SELECT position('Hello, world!', '!') +``` + +Sonuç: + +``` text +┌─position('Hello, world!', '!')─┐ +│ 13 │ +└────────────────────────────────┘ +``` + +Rusça'daki aynı ifade, tek bir bayt kullanılarak temsil edilemeyen karakterler içerir. İşlev beklenmedik bir sonuç verir (kullanım [positionUTF8](#positionutf8) çok bayt kodlu metin için işlev): + +Sorgu: + +``` sql +SELECT position('Привет, мир!', '!') +``` + +Sonuç: + +``` text +┌─position('Привет, мир!', '!')─┐ +│ 21 │ +└───────────────────────────────┘ +``` + +## positionCaseİnsensitive {#positioncaseinsensitive} + +Olarak aynı [konum](#position) 1'den başlayarak dizedeki bulunan alt dizenin konumunu (bayt cinsinden) döndürür. Büyük / küçük harf duyarlı bir arama için işlevi kullanın. + +Dize, tek baytlık kodlanmış bir metni temsil eden bir bayt kümesi içerdiği varsayımı altında çalışır. Bu varsayım karşılanmazsa ve bir karakter tek bir bayt kullanılarak temsil edilemezse, işlev bir istisna atmaz ve beklenmeyen bir sonuç döndürür. Karakter iki bayt kullanılarak temsil edilebilirse, iki bayt vb. kullanır. + +**Sözdizimi** + +``` sql +positionCaseInsensitive(haystack, needle) +``` + +**Parametre** + +- `haystack` — string, in which substring will to be searched. [Dize](../syntax.md#syntax-string-literal). +- `needle` — substring to be searched. [Dize](../syntax.md#syntax-string-literal). + +**Döndürülen değerler** + +- Alt dize bulunursa, bayt cinsinden başlangıç pozisyonu (1'den sayma). +- 0, alt dize bulunamadı. + +Tür: `Integer`. + +**Örnek** + +Sorgu: + +``` sql +SELECT positionCaseInsensitive('Hello, world!', 'hello') +``` + +Sonuç: + +``` text +┌─positionCaseInsensitive('Hello, world!', 'hello')─┐ +│ 1 │ +└───────────────────────────────────────────────────┘ +``` + +## positionUTF8 {#positionutf8} + +1'den başlayarak dizedeki bulunan alt dizenin konumunu (Unicode noktalarında) döndürür. + +Dizenin UTF-8 kodlanmış bir metni temsil eden bir bayt kümesi içerdiği varsayımı altında çalışır. Bu varsayım karşılanmazsa, işlev bir istisna atmaz ve beklenmeyen bir sonuç döndürür. Karakter iki Unicode noktası kullanılarak temsil edilebilirse, iki vb. kullanır. + +Büyük / küçük harf duyarsız arama için işlevi kullanın [positionCaseİnsensitiveUTF8](#positioncaseinsensitiveutf8). + +**Sözdizimi** + +``` sql +positionUTF8(haystack, needle) +``` + +**Parametre** + +- `haystack` — string, in which substring will to be searched. [Dize](../syntax.md#syntax-string-literal). +- `needle` — substring to be searched. [Dize](../syntax.md#syntax-string-literal). + +**Döndürülen değerler** + +- Unicode noktalarında başlangıç pozisyonu (1'den sayma), eğer alt dize bulundu. +- 0, alt dize bulunamadı. + +Tür: `Integer`. + +**Örnekler** + +İfade “Hello, world!” rusça'da, tek noktalı kodlanmış bir metni temsil eden bir dizi Unicode noktası bulunur. İşlev beklenen bazı sonuçları döndürür: + +Sorgu: + +``` sql +SELECT positionUTF8('Привет, мир!', '!') +``` + +Sonuç: + +``` text +┌─positionUTF8('Привет, мир!', '!')─┐ +│ 12 │ +└───────────────────────────────────┘ +``` + +İfade “Salut, étudiante!” karakter nerede `é` bir nokta kullanılarak temsil edilebilir (`U+00E9`) veya iki puan (`U+0065U+0301`) fonksiyon bazı beklenmedik sonuç iade edilebilir: + +Mektup için sorgu `é` bir Unicode noktasını temsil eden `U+00E9`: + +``` sql +SELECT positionUTF8('Salut, étudiante!', '!') +``` + +Sonuç: + +``` text +┌─positionUTF8('Salut, étudiante!', '!')─┐ +│ 17 │ +└────────────────────────────────────────┘ +``` + +Mektup için sorgu `é`, iki Unicode noktası temsil edilen `U+0065U+0301`: + +``` sql +SELECT positionUTF8('Salut, étudiante!', '!') +``` + +Sonuç: + +``` text +┌─positionUTF8('Salut, étudiante!', '!')─┐ +│ 18 │ +└────────────────────────────────────────┘ +``` + +## positionCaseİnsensitiveUTF8 {#positioncaseinsensitiveutf8} + +Olarak aynı [positionUTF8](#positionutf8) ama büyük küçük harf duyarlı. 1'den başlayarak dizedeki bulunan alt dizenin konumunu (Unicode noktalarında) döndürür. + +Dizenin UTF-8 kodlanmış bir metni temsil eden bir bayt kümesi içerdiği varsayımı altında çalışır. Bu varsayım karşılanmazsa, işlev bir istisna atmaz ve beklenmeyen bir sonuç döndürür. Karakter iki Unicode noktası kullanılarak temsil edilebilirse, iki vb. kullanır. + +**Sözdizimi** + +``` sql +positionCaseInsensitiveUTF8(haystack, needle) +``` + +**Parametre** + +- `haystack` — string, in which substring will to be searched. [Dize](../syntax.md#syntax-string-literal). +- `needle` — substring to be searched. [Dize](../syntax.md#syntax-string-literal). + +**Döndürülen değer** + +- Unicode noktalarında başlangıç pozisyonu (1'den sayma), eğer alt dize bulundu. +- 0, alt dize bulunamadı. + +Tür: `Integer`. + +**Örnek** + +Sorgu: + +``` sql +SELECT positionCaseInsensitiveUTF8('Привет, мир!', 'Мир') +``` + +Sonuç: + +``` text +┌─positionCaseInsensitiveUTF8('Привет, мир!', 'Мир')─┐ +│ 9 │ +└────────────────────────────────────────────────────┘ +``` + +## multiSearchAllPositions {#multisearchallpositions} + +Olarak aynı [konum](string_search_functions.md#position) ama döner `Array` dizede bulunan karşılık gelen alt dizelerin konumlarının (bayt cinsinden). Pozisyonlar 1'den başlayarak endekslenir. + +Arama, dize kodlaması ve harmanlama ile ilgili olmayan bayt dizileri üzerinde gerçekleştirilir. + +- Büyük / küçük harf duyarlı ASCII arama için işlevi kullanın `multiSearchAllPositionsCaseInsensitive`. +- UTF-8'de arama yapmak için işlevi kullanın [multiSearchAllPositionsUTF8](#multiSearchAllPositionsUTF8). +- Büyük / küçük harf duyarlı UTF-8 arama için multisearchallpositionscaseınsensitiveutf8 işlevini kullanın. + +**Sözdizimi** + +``` sql +multiSearchAllPositions(haystack, [needle1, needle2, ..., needlen]) +``` + +**Parametre** + +- `haystack` — string, in which substring will to be searched. [Dize](../syntax.md#syntax-string-literal). +- `needle` — substring to be searched. [Dize](../syntax.md#syntax-string-literal). + +**Döndürülen değerler** + +- Bayt cinsinden başlangıç pozisyonları dizisi (1'den sayma), karşılık gelen alt dize bulunursa ve 0 bulunmazsa. + +**Örnek** + +Sorgu: + +``` sql +SELECT multiSearchAllPositions('Hello, World!', ['hello', '!', 'world']) +``` + +Sonuç: + +``` text +┌─multiSearchAllPositions('Hello, World!', ['hello', '!', 'world'])─┐ +│ [0,13,0] │ +└───────────────────────────────────────────────────────────────────┘ +``` + +## multiSearchAllPositionsUTF8 {#multiSearchAllPositionsUTF8} + +Görmek `multiSearchAllPositions`. + +## multiSearchFirstPosition (Samanlık, \[iğne1, iğne2, …, needleve\]) {#multisearchfirstposition} + +Olarak aynı `position` ancak dizenin en soldaki ofsetini döndürür `haystack` bu bazı iğnelerle eşleşti. + +Büyük/küçük harfe duyarsız arama veya / VE UTF-8 biçiminde kullanım işlevleri için `multiSearchFirstPositionCaseInsensitive, multiSearchFirstPositionUTF8, multiSearchFirstPositionCaseInsensitiveUTF8`. + +## multiSearchFirstİndex (Samanlık, \[iğne1, iğne2, …, needleve\]) {#multisearchfirstindexhaystack-needle1-needle2-needlen} + +Dizini döndürür `i` en soldaki bulunan iğnenin (1'den başlayarak)ben diz inede `haystack` ve 0 aksi takdirde. + +Büyük/küçük harfe duyarsız arama veya / VE UTF-8 biçiminde kullanım işlevleri için `multiSearchFirstIndexCaseInsensitive, multiSearchFirstIndexUTF8, multiSearchFirstIndexCaseInsensitiveUTF8`. + +## multiSearchAny (Samanlık, \[iğne1, iğne2, …, needleve\]) {#function-multisearchany} + +Döner 1, Eğer en az bir dize iğneben dize ile eşleşir `haystack` ve 0 aksi takdirde. + +Büyük/küçük harfe duyarsız arama veya / VE UTF-8 biçiminde kullanım işlevleri için `multiSearchAnyCaseInsensitive, multiSearchAnyUTF8, multiSearchAnyCaseInsensitiveUTF8`. + +!!! note "Not" + Tamamı `multiSearch*` fonksiyonlar iğne sayısı 2'den az olmalıdır8 uygulama şartname nedeniyle. + +## maç (Samanlık, desen) {#matchhaystack-pattern} + +Dize eşleşip eşleşmediğini denetler `pattern` düzenli ifade. Bir `re2` düzenli ifade. Bu [sözdizimi](https://github.com/google/re2/wiki/Syntax) of the `re2` düzenli ifadeler, Perl düzenli ifadelerin sözdiziminden daha sınırlıdır. + +Eşleşmezse 0 veya eşleşirse 1 değerini döndürür. + +Ters eğik çizgi sembolünün (`\`) normal ifadede kaçmak için kullanılır. Aynı sembol, dize değişmezlerinde kaçmak için kullanılır. Bu nedenle, normal bir ifadede sembolden kaçmak için, bir dize literalinde iki ters eğik çizgi (\\) yazmanız gerekir. + +Normal ifade, bir bayt kümesiymiş gibi dizeyle çalışır. Normal ifade boş bayt içeremez. +Bir dizedeki alt dizeleri aramak için desenler için, LİKE veya ‘position’, çok daha hızlı çalıştıkları için. + +## multiMatchAny (Samanlık, \[desen1, desen2, …, patternve\]) {#multimatchanyhaystack-pattern1-pattern2-patternn} + +Olarak aynı `match`, ancak normal ifadelerin hiçbiri eşleşmezse 0 ve desenlerden herhangi biri eşleşirse 1 değerini döndürür. Kullanır [hyperscan](https://github.com/intel/hyperscan) kitaplık. Bir dizede alt dizeleri aramak için desenler için, kullanmak daha iyidir `multiSearchAny` çok daha hızlı çalıştığı için. + +!!! note "Not" + Herhangi birinin uzunluğu `haystack` dize 2'den az olmalıdır32 bayt aksi takdirde özel durum atılır. Bu kısıtlama, hyperscan API nedeniyle gerçekleşir. + +## multimatchanyındex (haystack, \[desen1, desen2, …, patternve\]) {#multimatchanyindexhaystack-pattern1-pattern2-patternn} + +Olarak aynı `multiMatchAny`, ancak Samanlık eşleşen herhangi bir dizin döndürür. + +## multiMatchAllİndices (haystack, \[desen1, desen2, …, patternve\]) {#multimatchallindiceshaystack-pattern1-pattern2-patternn} + +Olarak aynı `multiMatchAny`, ancak herhangi bir sırada Samanlık eşleşen tüm indicies dizisini döndürür. + +## multiFuzzyMatchAny (Samanlık, mesafe, \[desen1, desen2, …, patternve\]) {#multifuzzymatchanyhaystack-distance-pattern1-pattern2-patternn} + +Olarak aynı `multiMatchAny`, ancak herhangi bir desen samanlıkta bir sabitle eşleşirse 1 döndürür [mesafeyi Düzenle](https://en.wikipedia.org/wiki/Edit_distance). Bu fonksiyon aynı zamanda deneysel bir moddadır ve son derece yavaş olabilir. Daha fazla bilgi için bkz. [hyperscan belgeleri](https://intel.github.io/hyperscan/dev-reference/compilation.html#approximate-matching). + +## multifuzzymatchanyındex (Samanlık, mesafe, \[desen1, desen2, …, patternve\]) {#multifuzzymatchanyindexhaystack-distance-pattern1-pattern2-patternn} + +Olarak aynı `multiFuzzyMatchAny`, ancak sabit bir düzenleme mesafesi içinde Samanlık eşleşen herhangi bir dizin döndürür. + +## multiFuzzyMatchAllİndices (Samanlık, mesafe, \[desen1, desen2, …, patternve\]) {#multifuzzymatchallindiceshaystack-distance-pattern1-pattern2-patternn} + +Olarak aynı `multiFuzzyMatchAny`, ancak sabit bir düzenleme mesafesi içinde saman yığını ile eşleşen herhangi bir sırada tüm dizinlerin dizisini döndürür. + +!!! note "Not" + `multiFuzzyMatch*` işlevler UTF-8 normal ifadeleri desteklemez ve bu tür ifadeler hyperscan kısıtlaması nedeniyle bayt olarak kabul edilir. + +!!! note "Not" + Hyperscan kullanan tüm işlevleri kapatmak için, ayarı kullanın `SET allow_hyperscan = 0;`. + +## özü (Samanlık, desen) {#extracthaystack-pattern} + +Normal ifade kullanarak bir dize parçasını ayıklar. Eğer ‘haystack’ eşleşmiyor ‘pattern’ regex, boş bir dize döndürülür. Regex alt desenler içermiyorsa, tüm regex ile eşleşen parçayı alır. Aksi takdirde, ilk alt desenle eşleşen parçayı alır. + +## extractAll(Samanlık, desen) {#extractallhaystack-pattern} + +Normal bir ifade kullanarak bir dizenin tüm parçalarını ayıklar. Eğer ‘haystack’ eşleşmiyor ‘pattern’ regex, boş bir dize döndürülür. Regex için tüm eşleşmelerden oluşan bir dizi dizeyi döndürür. Genel olarak, davranış ile aynıdır ‘extract’ işlev (bir alt desen yoksa ilk alt deseni veya tüm ifadeyi alır). + +## gibi (Samanlık, desen), Samanlık gibi desen operatörü {#function-like} + +Bir dizenin basit bir normal ifadeyle eşleşip eşleşmediğini denetler. +Normal ifade metasymbols içerebilir `%` ve `_`. + +`%` herhangi bir bayt miktarını (sıfır karakter dahil) gösterir. + +`_` herhangi bir bayt gösterir. + +Ters eğik çizgi kullanın (`\`) metasimbollerden kaçmak için. Açıklamasında kaçan nota bakın ‘match’ işlev. + +Gibi düzenli ifadeler için `%needle%`, kod daha optimal ve hızlı olarak çalışır `position` işlev. +Diğer normal ifadeler için kod, ‘match’ işlev. + +## notLike (Samanlık, desen), Samanlık desen operatörü gibi değil {#function-notlike} + +Aynı şey ‘like’ ama negatif. + +## ngramDistance(Samanlık, iğne) {#ngramdistancehaystack-needle} + +Arasındaki 4 gram distancelık mesaf theeyi hesaplar `haystack` ve `needle`: counts the symmetric difference between two multisets of 4-grams and normalizes it by the sum of their cardinalities. Returns float number from 0 to 1 – the closer to zero, the more strings are similar to each other. If the constant `needle` veya `haystack` 32kb'den fazla, bir istisna atar. Sabit olmayan bazı `haystack` veya `needle` dizeler 32kb'den daha fazladır, mesafe her zaman birdir. + +Büyük/küçük harf duyarsız arama veya / VE UTF-8 formatında kullanım işlevleri için `ngramDistanceCaseInsensitive, ngramDistanceUTF8, ngramDistanceCaseInsensitiveUTF8`. + +## ngramsearch(Samanlık, iğne) {#ngramsearchhaystack-needle} + +Aynı olarak `ngramDistance` ama arasındaki simetrik olmayan farkı hesaplar `needle` ve `haystack` – the number of n-grams from needle minus the common number of n-grams normalized by the number of `needle` n-büyükanne. Daha yakın, daha `needle` is in the `haystack`. Bulanık dize arama için yararlı olabilir. + +Büyük/küçük harf duyarsız arama veya / VE UTF-8 formatında kullanım işlevleri için `ngramSearchCaseInsensitive, ngramSearchUTF8, ngramSearchCaseInsensitiveUTF8`. + +!!! note "Not" + For UTF-8 case we use 3-gram distance. All these are not perfectly fair n-gram distances. We use 2-byte hashes to hash n-grams and then calculate the (non-)symmetric difference between these hash tables – collisions may occur. With UTF-8 case-insensitive format we do not use fair `tolower` function – we zero the 5-th bit (starting from zero) of each codepoint byte and first bit of zeroth byte if bytes more than one – this works for Latin and mostly for all Cyrillic letters. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/string_search_functions/) diff --git a/docs/tr/sql_reference/functions/type_conversion_functions.md b/docs/tr/sql_reference/functions/type_conversion_functions.md new file mode 100644 index 00000000000..643ddf9dbc0 --- /dev/null +++ b/docs/tr/sql_reference/functions/type_conversion_functions.md @@ -0,0 +1,534 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 38 +toc_title: "Tip D\xF6n\xFC\u015Ft\xFCrme" +--- + +# Tip Dönüştürme Fonksiyonları {#type-conversion-functions} + +## Sayısal dönüşümlerin ortak sorunları {#numeric-conversion-issues} + +Bir değeri birinden başka bir veri türüne dönüştürdüğünüzde, ortak durumda, veri kaybına neden olabilecek güvenli olmayan bir işlem olduğunu unutmamalısınız. Değeri daha büyük bir veri türünden daha küçük bir veri türüne sığdırmaya çalışırsanız veya değerleri farklı veri türleri arasında dönüştürürseniz, veri kaybı oluşabilir. + +ClickHouse vardır [C++ programları ile aynı davranış](https://en.cppreference.com/w/cpp/language/implicit_conversion). + +## toİnt(8/16/32/64) {#toint8163264} + +Bir giriş değeri dönüştürür [Tamsayı](../../sql_reference/data_types/int_uint.md) veri türü. Bu işlev ailesi şunları içerir: + +- `toInt8(expr)` — Results in the `Int8` veri türü. +- `toInt16(expr)` — Results in the `Int16` veri türü. +- `toInt32(expr)` — Results in the `Int32` veri türü. +- `toInt64(expr)` — Results in the `Int64` veri türü. + +**Parametre** + +- `expr` — [İfade](../syntax.md#syntax-expressions) bir sayının ondalık gösterimiyle bir sayı veya dize döndürülmesi. Sayıların ikili, sekizli ve onaltılık gösterimleri desteklenmez. Önde gelen sıfırlar soyulur. + +**Döndürülen değer** + +Tamsayı değeri `Int8`, `Int16`, `Int32`, veya `Int64` veri türü. + +Fonksiyonlar kullanımı [sıfıra doğru yuvarlama](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), yani sayıların kesirli rakamlarını keserler. + +Fonksiyon behaviorların davranışı [N andan ve In andf](../../sql_reference/data_types/float.md#data_type-float-nan-inf) argümanlar tanımsızdır. Hakkında hatırla [sayısal convertions sorunları](#numeric-conversion-issues), fonksiyonları kullanırken. + +**Örnek** + +``` sql +SELECT toInt64(nan), toInt32(32), toInt16('16'), toInt8(8.8) +``` + +``` text +┌─────────toInt64(nan)─┬─toInt32(32)─┬─toInt16('16')─┬─toInt8(8.8)─┐ +│ -9223372036854775808 │ 32 │ 16 │ 8 │ +└──────────────────────┴─────────────┴───────────────┴─────────────┘ +``` + +## toİnt (8/16/32/64)OrZero {#toint8163264orzero} + +String türünde bir argüman alır ve İnt içine ayrıştırmaya çalışır(8 \| 16 \| 32 \| 64). Başarısız olursa, 0 döndürür. + +**Örnek** + +``` sql +select toInt64OrZero('123123'), toInt8OrZero('123qwe123') +``` + +``` text +┌─toInt64OrZero('123123')─┬─toInt8OrZero('123qwe123')─┐ +│ 123123 │ 0 │ +└─────────────────────────┴───────────────────────────┘ +``` + +## toİnt(8/16/32/64) OrNull {#toint8163264ornull} + +String türünde bir argüman alır ve İnt içine ayrıştırmaya çalışır(8 \| 16 \| 32 \| 64). Başarısız olursa, NULL döndürür. + +**Örnek** + +``` sql +select toInt64OrNull('123123'), toInt8OrNull('123qwe123') +``` + +``` text +┌─toInt64OrNull('123123')─┬─toInt8OrNull('123qwe123')─┐ +│ 123123 │ ᴺᵁᴸᴸ │ +└─────────────────────────┴───────────────────────────┘ +``` + +## toUİnt(8/16/32/64) {#touint8163264} + +Bir giriş değeri dönüştürür [Uİnt](../../sql_reference/data_types/int_uint.md) veri türü. Bu işlev ailesi şunları içerir: + +- `toUInt8(expr)` — Results in the `UInt8` veri türü. +- `toUInt16(expr)` — Results in the `UInt16` veri türü. +- `toUInt32(expr)` — Results in the `UInt32` veri türü. +- `toUInt64(expr)` — Results in the `UInt64` veri türü. + +**Parametre** + +- `expr` — [İfade](../syntax.md#syntax-expressions) bir sayının ondalık gösterimiyle bir sayı veya dize döndürülmesi. Sayıların ikili, sekizli ve onaltılık gösterimleri desteklenmez. Önde gelen sıfırlar soyulur. + +**Döndürülen değer** + +Tamsayı değeri `UInt8`, `UInt16`, `UInt32`, veya `UInt64` veri türü. + +Fonksiyonlar kullanımı [sıfıra doğru yuvarlama](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero), yani sayıların kesirli rakamlarını keserler. + +Olumsuz agruments için işlevlerin davranışı ve [N andan ve In andf](../../sql_reference/data_types/float.md#data_type-float-nan-inf) argümanlar tanımsızdır. Örneğin, negatif bir sayı ile bir dize geçirirseniz `'-32'`, ClickHouse bir özel durum yükseltir. Hakkında hatırla [sayısal convertions sorunları](#numeric-conversion-issues), fonksiyonları kullanırken. + +**Örnek** + +``` sql +SELECT toUInt64(nan), toUInt32(-32), toUInt16('16'), toUInt8(8.8) +``` + +``` text +┌───────toUInt64(nan)─┬─toUInt32(-32)─┬─toUInt16('16')─┬─toUInt8(8.8)─┐ +│ 9223372036854775808 │ 4294967264 │ 16 │ 8 │ +└─────────────────────┴───────────────┴────────────────┴──────────────┘ +``` + +## toUİnt (8/16/32/64)OrZero {#touint8163264orzero} + +## toUİnt(8/16/32/64) OrNull {#touint8163264ornull} + +## toFloat(32/64) {#tofloat3264} + +## toFloat (32/64)OrZero {#tofloat3264orzero} + +## toFloat(32/64) OrNull {#tofloat3264ornull} + +## toDate {#todate} + +## toDateOrZero {#todateorzero} + +## toDateOrNull {#todateornull} + +## toDateTime {#todatetime} + +## toDateTimeOrZero {#todatetimeorzero} + +## toDateTimeOrNull {#todatetimeornull} + +## toDecimal(32/64/128) {#todecimal3264128} + +Dönüşüyo `value` to the [Ondalık](../../sql_reference/data_types/decimal.md) hassas veri türü `S`. Bu `value` bir sayı veya bir dize olabilir. Bu `S` (scale) parametresi ondalık basamak sayısını belirtir. + +- `toDecimal32(value, S)` +- `toDecimal64(value, S)` +- `toDecimal128(value, S)` + +## toDecimal(32/64/128) OrNull {#todecimal3264128ornull} + +Bir giriş dizesini bir [Nullable (Ondalık (P, S))](../../sql_reference/data_types/decimal.md) veri türü değeri. Bu işlev ailesi şunları içerir: + +- `toDecimal32OrNull(expr, S)` — Results in `Nullable(Decimal32(S))` veri türü. +- `toDecimal64OrNull(expr, S)` — Results in `Nullable(Decimal64(S))` veri türü. +- `toDecimal128OrNull(expr, S)` — Results in `Nullable(Decimal128(S))` veri türü. + +Bu işlevler yerine kullanılmalıdır `toDecimal*()` fonksiyonlar, eğer bir almak için tercih `NULL` bir giriş değeri ayrıştırma hatası durumunda bir özel durum yerine değer. + +**Parametre** + +- `expr` — [İfade](../syntax.md#syntax-expressions) bir değeri döndürür [Dize](../../sql_reference/data_types/string.md) veri türü. ClickHouse ondalık sayının metinsel temsilini bekler. Mesela, `'1.111'`. +- `S` — Scale, the number of decimal places in the resulting value. + +**Döndürülen değer** + +İçinde bir değer `Nullable(Decimal(P,S))` veri türü. Değeri içerir: + +- İle sayı `S` ondalık basamaklar, ClickHouse giriş dizesi bir sayı olarak yorumlar. +- `NULL`, ClickHouse giriş dizesini bir sayı olarak yorumlayamazsa veya giriş numarası birden fazla içeriyorsa `S` ondalık basamaklar. + +**Örnekler** + +``` sql +SELECT toDecimal32OrNull(toString(-1.111), 5) AS val, toTypeName(val) +``` + +``` text +┌──────val─┬─toTypeName(toDecimal32OrNull(toString(-1.111), 5))─┐ +│ -1.11100 │ Nullable(Decimal(9, 5)) │ +└──────────┴────────────────────────────────────────────────────┘ +``` + +``` sql +SELECT toDecimal32OrNull(toString(-1.111), 2) AS val, toTypeName(val) +``` + +``` text +┌──val─┬─toTypeName(toDecimal32OrNull(toString(-1.111), 2))─┐ +│ ᴺᵁᴸᴸ │ Nullable(Decimal(9, 2)) │ +└──────┴────────────────────────────────────────────────────┘ +``` + +## toDecimal (32/64/128)OrZero {#todecimal3264128orzero} + +Bir giriş değeri dönüştürür [Ondalık(P, S)](../../sql_reference/data_types/decimal.md) veri türü. Bu işlev ailesi şunları içerir: + +- `toDecimal32OrZero( expr, S)` — Results in `Decimal32(S)` veri türü. +- `toDecimal64OrZero( expr, S)` — Results in `Decimal64(S)` veri türü. +- `toDecimal128OrZero( expr, S)` — Results in `Decimal128(S)` veri türü. + +Bu işlevler yerine kullanılmalıdır `toDecimal*()` fonksiyonlar, eğer bir almak için tercih `0` bir giriş değeri ayrıştırma hatası durumunda bir özel durum yerine değer. + +**Parametre** + +- `expr` — [İfade](../syntax.md#syntax-expressions) bir değeri döndürür [Dize](../../sql_reference/data_types/string.md) veri türü. ClickHouse ondalık sayının metinsel temsilini bekler. Mesela, `'1.111'`. +- `S` — Scale, the number of decimal places in the resulting value. + +**Döndürülen değer** + +İçinde bir değer `Nullable(Decimal(P,S))` veri türü. Değeri içerir: + +- İle sayı `S` ondalık basamaklar, ClickHouse giriş dizesi bir sayı olarak yorumlar. +- 0 ile `S` ondalık basamaklar, ClickHouse giriş dizesini bir sayı olarak yorumlayamazsa veya giriş numarası birden fazla içeriyorsa `S` ondalık basamaklar. + +**Örnek** + +``` sql +SELECT toDecimal32OrZero(toString(-1.111), 5) AS val, toTypeName(val) +``` + +``` text +┌──────val─┬─toTypeName(toDecimal32OrZero(toString(-1.111), 5))─┐ +│ -1.11100 │ Decimal(9, 5) │ +└──────────┴────────────────────────────────────────────────────┘ +``` + +``` sql +SELECT toDecimal32OrZero(toString(-1.111), 2) AS val, toTypeName(val) +``` + +``` text +┌──val─┬─toTypeName(toDecimal32OrZero(toString(-1.111), 2))─┐ +│ 0.00 │ Decimal(9, 2) │ +└──────┴────────────────────────────────────────────────────┘ +``` + +## toString {#tostring} + +Sayılar, dizeler (ancak sabit olmayan dizeler), tarihler ve tarihlerle saatler arasında dönüştürme işlevleri. +Tüm bu işlevler bir argümanı kabul eder. + +Bir dizeye veya dizeye dönüştürürken, değer, sekmeyle aynı kuralları kullanarak biçimlendirilir veya ayrıştırılır. ayrı biçim (ve hemen hemen tüm diğer metin biçimleri). Dize ayrıştırılamazsa, bir istisna atılır ve istek iptal edilir. + +Tarihleri sayılara dönüştürürken veya tam tersi, Tarih Unix döneminin başlangıcından bu yana geçen gün sayısına karşılık gelir. +Tarihleri zamanlarla sayılara dönüştürürken veya tam tersi olduğunda, zaman ile tarih, Unix döneminin başlangıcından bu yana geçen saniye sayısına karşılık gelir. + +ToDate / toDateTime işlevleri için tarih ve saatli tarih biçimleri aşağıdaki gibi tanımlanır: + +``` text +YYYY-MM-DD +YYYY-MM-DD hh:mm:ss +``` + +Özel durum olarak, uınt32, Int32, Uınt64 veya Int64 sayısal türlerinden bugüne dönüştürme ve sayı 65536'dan büyük veya eşitse, sayı Unıx zaman damgası (ve gün sayısı olarak değil) olarak yorumlanır ve tarihe yuvarlanır. Bu, yaygın yazı oluşumu için destek sağlar ‘toDate(unix\_timestamp)’, aksi takdirde bir hata olur ve daha hantal yazmayı gerektirir ‘toDate(toDateTime(unix\_timestamp))’. + +Bir tarih ve tarih ile saat arasında dönüştürme doğal bir şekilde gerçekleştirilir: boş bir zaman ekleyerek veya saati bırakarak. + +Sayısal türler arasındaki dönüştürme, C++ ' daki farklı sayısal türler arasındaki atamalarla aynı kuralları kullanır. + +Ayrıca, Tostring işlevi DateTime bağımsız değişkeni, saat dilimi adını içeren ikinci bir dize bağımsız değişkeni alabilir. Örnek: `Asia/Yekaterinburg` Bu durumda, saat belirtilen saat dilimine göre biçimlendirilir. + +``` sql +SELECT + now() AS now_local, + toString(now(), 'Asia/Yekaterinburg') AS now_yekat +``` + +``` text +┌───────────now_local─┬─now_yekat───────────┐ +│ 2016-06-15 00:11:21 │ 2016-06-15 02:11:21 │ +└─────────────────────┴─────────────────────┘ +``` + +Ayrıca bakınız `toUnixTimestamp` işlev. + +## toFixedString(s, N) {#tofixedstrings-n} + +Bir dize türü bağımsız değişkeni dönüştürür bir FixedString(N) türü (sabit uzunlukta bir dize N). N sabit olmalıdır. +Dize n'den daha az bayt varsa, sağa boş bayt ile geçirilir. Dize n'den daha fazla bayt varsa, bir özel durum atılır. + +## tostringcuttozero (s) {#tostringcuttozeros} + +Bir dize veya fixedstring bağımsız değişkeni kabul eder. Bulunan ilk sıfır baytta kesilmiş içeriği olan dizeyi döndürür. + +Örnek: + +``` sql +SELECT toFixedString('foo', 8) AS s, toStringCutToZero(s) AS s_cut +``` + +``` text +┌─s─────────────┬─s_cut─┐ +│ foo\0\0\0\0\0 │ foo │ +└───────────────┴───────┘ +``` + +``` sql +SELECT toFixedString('foo\0bar', 8) AS s, toStringCutToZero(s) AS s_cut +``` + +``` text +┌─s──────────┬─s_cut─┐ +│ foo\0bar\0 │ foo │ +└────────────┴───────┘ +``` + +## reinterpretAsUİnt(8/16/32/64) {#reinterpretasuint8163264} + +## reinterpretAsİnt(8/16/32/64) {#reinterpretasint8163264} + +## reinterpretAsFloat (32/64) {#reinterpretasfloat3264} + +## reinterpretAsDate {#reinterpretasdate} + +## reinterpretAsDateTime {#reinterpretasdatetime} + +Bu işlevler bir dizeyi kabul eder ve dizenin başına yerleştirilen baytları ana bilgisayar düzeninde (little endian) bir sayı olarak yorumlar. Dize yeterince uzun değilse, işlevler dize gerekli sayıda boş baytla doldurulmuş gibi çalışır. Dize gerekenden daha uzunsa, ek bayt yoksayılır. Bir tarih, Unix döneminin başlangıcından bu yana geçen gün sayısı olarak yorumlanır ve zamana sahip bir tarih, Unix döneminin başlangıcından bu yana geçen saniye sayısı olarak yorumlanır. + +## reinterpretAsString {#type_conversion_functions-reinterpretAsString} + +Bu işlev, bir sayı veya tarih veya tarih saat ile kabul eder ve ana bilgisayar düzeninde (little endian) karşılık gelen değeri temsil eden bayt içeren bir dize döndürür. Boş bayt sondan bırakılır. Örneğin, 255 uint32 türü değeri bir bayt uzunluğunda bir dizedir. + +## reinterpretAsFixedString {#reinterpretasfixedstring} + +Bu işlev, bir sayı veya tarih veya tarih saat ile kabul eder ve karşılık gelen değeri ana bilgisayar sırasına (little endian) temsil eden bayt içeren bir FixedString döndürür. Boş bayt sondan bırakılır. Örneğin, 255 uint32 türü değeri bir bayt uzunluğunda bir FixedString. + +## CAS (t(x, t) {#type_conversion_function-cast} + +Dönüşüyo ‘x’ to the ‘t’ veri türü. Sözdizimi CAST (x AS t) da desteklenmektedir. + +Örnek: + +``` sql +SELECT + '2016-06-15 23:00:00' AS timestamp, + CAST(timestamp AS DateTime) AS datetime, + CAST(timestamp AS Date) AS date, + CAST(timestamp, 'String') AS string, + CAST(timestamp, 'FixedString(22)') AS fixed_string +``` + +``` text +┌─timestamp───────────┬────────────datetime─┬───────date─┬─string──────────────┬─fixed_string──────────────┐ +│ 2016-06-15 23:00:00 │ 2016-06-15 23:00:00 │ 2016-06-15 │ 2016-06-15 23:00:00 │ 2016-06-15 23:00:00\0\0\0 │ +└─────────────────────┴─────────────────────┴────────────┴─────────────────────┴───────────────────────────┘ +``` + +Fixedstring(N) ' ye dönüştürme yalnızca String veya FixedString(N) türünde argümanlar için çalışır. + +Type con conversionvers conversionion to [Nullable](../../sql_reference/data_types/nullable.md) ve geri desteklenmektedir. Örnek: + +``` sql +SELECT toTypeName(x) FROM t_null +``` + +``` text +┌─toTypeName(x)─┐ +│ Int8 │ +│ Int8 │ +└───────────────┘ +``` + +``` sql +SELECT toTypeName(CAST(x, 'Nullable(UInt16)')) FROM t_null +``` + +``` text +┌─toTypeName(CAST(x, 'Nullable(UInt16)'))─┐ +│ Nullable(UInt16) │ +│ Nullable(UInt16) │ +└─────────────────────────────────────────┘ +``` + +## toİnterval(yıl\|Çeyrek\|Ay\|hafta\|Gün\|Saat\|Dakika / Saniye) {#function-tointerval} + +Bir sayı türü argümanını bir [Aralıklı](../../sql_reference/data_types/special_data_types/interval.md) veri türü. + +**Sözdizimi** + +``` sql +toIntervalSecond(number) +toIntervalMinute(number) +toIntervalHour(number) +toIntervalDay(number) +toIntervalWeek(number) +toIntervalMonth(number) +toIntervalQuarter(number) +toIntervalYear(number) +``` + +**Parametre** + +- `number` — Duration of interval. Positive integer number. + +**Döndürülen değerler** + +- Değeri `Interval` veri türü. + +**Örnek** + +``` sql +WITH + toDate('2019-01-01') AS date, + INTERVAL 1 WEEK AS interval_week, + toIntervalWeek(1) AS interval_to_week +SELECT + date + interval_week, + date + interval_to_week +``` + +``` text +┌─plus(date, interval_week)─┬─plus(date, interval_to_week)─┐ +│ 2019-01-08 │ 2019-01-08 │ +└───────────────────────────┴──────────────────────────────┘ +``` + +## parseDateTimeBestEffort {#parsedatetimebesteffort} + +Bir tarih ve saati dönüştürür [Dize](../../sql_reference/data_types/string.md) temsil etmek [DateTime](../../sql_reference/data_types/datetime.md#data_type-datetime) veri türü. + +İşlev ayrıştırır [ISO 8601](https://en.wikipedia.org/wiki/ISO_8601), [RFC 1123-5.2.14 RFC-822 Tarih ve Saat özellikleri](https://tools.ietf.org/html/rfc1123#page-55), ClickHouse ve diğer bazı tarih ve saat biçimleri. + +**Sözdizimi** + +``` sql +parseDateTimeBestEffort(time_string [, time_zone]); +``` + +**Parametre** + +- `time_string` — String containing a date and time to convert. [Dize](../../sql_reference/data_types/string.md). +- `time_zone` — Time zone. The function parses `time_string` saat dilimine göre. [Dize](../../sql_reference/data_types/string.md). + +**Desteklenen standart dışı formatlar** + +- 9 içeren bir dize..10 haneli [unix zaman damgası](https://en.wikipedia.org/wiki/Unix_time). +- Tarih ve saat bileşeni olan bir dize: `YYYYMMDDhhmmss`, `DD/MM/YYYY hh:mm:ss`, `DD-MM-YY hh:mm`, `YYYY-MM-DD hh:mm:ss` vb. +- Bir tarih, ancak hiçbir zaman bileşeni ile bir dize: `YYYY`, `YYYYMM`, `YYYY*MM`, `DD/MM/YYYY`, `DD-MM-YY` vb. +- Bir gün ve Saat ile bir dize: `DD`, `DD hh`, `DD hh:mm`. Bu durumda `YYYY-MM` olarak ikame edilir `2000-01`. +- Tarih ve Saat Saat Dilimi uzaklık bilgileri ile birlikte içeren bir dize: `YYYY-MM-DD hh:mm:ss ±h:mm` vb. Mesela, `2020-12-12 17:36:00 -5:00`. + +Ayırıcılı tüm formatlar için işlev, tam adlarıyla veya bir ay adının ilk üç harfiyle ifade edilen ay adlarını ayrıştırır. Örnekler: `24/DEC/18`, `24-Dec-18`, `01-September-2018`. + +**Döndürülen değer** + +- `time_string` dönüştürül thedü `DateTime` veri türü. + +**Örnekler** + +Sorgu: + +``` sql +SELECT parseDateTimeBestEffort('12/12/2020 12:12:57') +AS parseDateTimeBestEffort; +``` + +Sonuç: + +``` text +┌─parseDateTimeBestEffort─┐ +│ 2020-12-12 12:12:57 │ +└─────────────────────────┘ +``` + +Sorgu: + +``` sql +SELECT parseDateTimeBestEffort('Sat, 18 Aug 2018 07:22:16 GMT', 'Europe/Moscow') +AS parseDateTimeBestEffort +``` + +Sonuç: + +``` text +┌─parseDateTimeBestEffort─┐ +│ 2018-08-18 10:22:16 │ +└─────────────────────────┘ +``` + +Sorgu: + +``` sql +SELECT parseDateTimeBestEffort('1284101485') +AS parseDateTimeBestEffort +``` + +Sonuç: + +``` text +┌─parseDateTimeBestEffort─┐ +│ 2015-07-07 12:04:41 │ +└─────────────────────────┘ +``` + +Sorgu: + +``` sql +SELECT parseDateTimeBestEffort('2018-12-12 10:12:12') +AS parseDateTimeBestEffort +``` + +Sonuç: + +``` text +┌─parseDateTimeBestEffort─┐ +│ 2018-12-12 10:12:12 │ +└─────────────────────────┘ +``` + +Sorgu: + +``` sql +SELECT parseDateTimeBestEffort('10 20:19') +``` + +Sonuç: + +``` text +┌─parseDateTimeBestEffort('10 20:19')─┐ +│ 2000-01-10 20:19:00 │ +└─────────────────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- \[ISO 8601 announcement by @xkcd\](https://xkcd.com/1179/) +- [RFC 1123](https://tools.ietf.org/html/rfc1123) +- [toDate](#todate) +- [toDateTime](#todatetime) + +## parseDateTimeBestEffortOrNull {#parsedatetimebesteffortornull} + +İçin aynı [parseDateTimeBestEffort](#parsedatetimebesteffort) işlenemeyen bir tarih biçimiyle karşılaştığında null döndürmesi dışında. + +## parseDateTimeBestEffortOrZero {#parsedatetimebesteffortorzero} + +İçin aynı [parseDateTimeBestEffort](#parsedatetimebesteffort) bunun dışında, işlenemeyen bir tarih biçimiyle karşılaştığında sıfır tarih veya sıfır tarih saati döndürür. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/type_conversion_functions/) diff --git a/docs/tr/sql_reference/functions/url_functions.md b/docs/tr/sql_reference/functions/url_functions.md new file mode 100644 index 00000000000..47f127f1667 --- /dev/null +++ b/docs/tr/sql_reference/functions/url_functions.md @@ -0,0 +1,209 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 54 +toc_title: "URL'ler ile \xE7al\u0131\u015Fma" +--- + +# URL'ler ile çalışmak için işlevler {#functions-for-working-with-urls} + +Tüm bu işlevler RFC'Yİ takip etmez. Geliştirilmiş performans için maksimum derecede basitleştirilmişlerdir. + +## Bir URL'nin bölümlerini Ayıklayan işlevler {#functions-that-extract-parts-of-a-url} + +İlgili bölüm bir URL'de yoksa, boş bir dize döndürülür. + +### protokol {#protocol} + +Protokolü bir URL'den ayıklar. + +Examples of typical returned values: http, https, ftp, mailto, tel, magnet… + +### etki {#domain} + +Ana bilgisayar adını bir URL'den ayıklar. + +``` sql +domain(url) +``` + +**Parametre** + +- `url` — URL. Type: [Dize](../../sql_reference/data_types/string.md). + +URL, bir şema ile veya şema olmadan belirtilebilir. Örnekler: + +``` text +svn+ssh://some.svn-hosting.com:80/repo/trunk +some.svn-hosting.com:80/repo/trunk +https://yandex.com/time/ +``` + +Bu örnekler için, `domain` işlev aşağıdaki sonuçları döndürür: + +``` text +some.svn-hosting.com +some.svn-hosting.com +yandex.com +``` + +**Döndürülen değerler** + +- Adı ana. ClickHouse giriş dizesini bir URL olarak ayrıştırırsa. +- Boş dize. ClickHouse giriş dizesini bir URL olarak ayrıştıramazsa. + +Tür: `String`. + +**Örnek** + +``` sql +SELECT domain('svn+ssh://some.svn-hosting.com:80/repo/trunk') +``` + +``` text +┌─domain('svn+ssh://some.svn-hosting.com:80/repo/trunk')─┐ +│ some.svn-hosting.com │ +└────────────────────────────────────────────────────────┘ +``` + +### domainWithoutWWW {#domainwithoutwww} + +Etki alanını döndürür ve birden fazla kaldırır ‘www.’ başlangıcına, eğer var dan. + +### topLevelDomain {#topleveldomain} + +Üst düzey etki alanını bir URL'den ayıklar. + +``` sql +topLevelDomain(url) +``` + +**Parametre** + +- `url` — URL. Type: [Dize](../../sql_reference/data_types/string.md). + +URL, bir şema ile veya şema olmadan belirtilebilir. Örnekler: + +``` text +svn+ssh://some.svn-hosting.com:80/repo/trunk +some.svn-hosting.com:80/repo/trunk +https://yandex.com/time/ +``` + +**Döndürülen değerler** + +- Etki alanı adı. ClickHouse giriş dizesini bir URL olarak ayrıştırırsa. +- Boş dize. ClickHouse giriş dizesini bir URL olarak ayrıştıramazsa. + +Tür: `String`. + +**Örnek** + +``` sql +SELECT topLevelDomain('svn+ssh://www.some.svn-hosting.com:80/repo/trunk') +``` + +``` text +┌─topLevelDomain('svn+ssh://www.some.svn-hosting.com:80/repo/trunk')─┐ +│ com │ +└────────────────────────────────────────────────────────────────────┘ +``` + +### firstSignificantSubdomain {#firstsignificantsubdomain} + +Ret theur thens the “first significant subdomain”. Bu, Yandex'e özgü standart olmayan bir kavramdır.Metrica. İlk önemli alt etki alanı ise ikinci düzey bir etki alanıdır ‘com’, ‘net’, ‘org’, veya ‘co’. Aksi takdirde, üçüncü düzey bir alandır. Mesela, `firstSignificantSubdomain (‘https://news.yandex.ru/’) = ‘yandex’, firstSignificantSubdomain (‘https://news.yandex.com.tr/’) = ‘yandex’`. Listesi “insignificant” ikinci düzey etki alanları ve diğer uygulama ayrıntıları gelecekte değişebilir. + +### cutToFirstSignificantSubdomain {#cuttofirstsignificantsubdomain} + +En üst düzey alt etki alanlarını içeren etki alanının bir bölümünü döndürür. “first significant subdomain” (yukarıdaki açıklamaya bakınız). + +Mesela, `cutToFirstSignificantSubdomain('https://news.yandex.com.tr/') = 'yandex.com.tr'`. + +### yol {#path} + +Yolu döndürür. Örnek: `/top/news.html` Yol sorgu dizesini içermez. + +### pathFull {#pathfull} + +Yukarıdaki ile aynı, ancak sorgu dizesi ve parça dahil. Örnek: / top / haberler.html?Sayfa = 2 \# yorumlar + +### queryString {#querystring} + +Sorgu dizesini döndürür. Örnek: Sayfa = 1 & lr = 213. sorgu dizesi, ilk soru işaretinin yanı sıra \# ve \# sonrası her şeyi içermez. + +### parça {#fragment} + +Parça tanımlayıcısını döndürür. fragment ilk karma sembolü içermez. + +### queryStringAndFragment {#querystringandfragment} + +Sorgu dizesini ve parça tanımlayıcısını döndürür. Örnek: Sayfa = 1\#29390. + +### extractURLParameter (URL, isim) {#extracturlparameterurl-name} + +Değerini döndürür ‘name’ varsa, URL'DEKİ parametre. Aksi takdirde, boş bir dize. Bu ada sahip birçok parametre varsa, ilk oluşumu döndürür. Bu işlev, parametre adının URL'de geçirilen bağımsız değişkenle aynı şekilde kodlandığı varsayımı altında çalışır. + +### extractURLParameters (URL) {#extracturlparametersurl} + +Bir dizi döndürür name = URL parametrelerine karşılık gelen değer dizeleri. Değerler hiçbir şekilde deşifre edilmez. + +### extractURLParameterNames(URL) {#extracturlparameternamesurl} + +URL parametrelerinin adlarına karşılık gelen bir dizi ad dizesi döndürür. Değerler hiçbir şekilde deşifre edilmez. + +### URLHierarchy(URL) {#urlhierarchyurl} + +Sonunda/,? simgeleriyle kesilen URL'yi içeren bir dizi döndürür yol ve sorgu dizesinde. Ardışık ayırıcı karakterler bir olarak sayılır. Kesim, tüm ardışık ayırıcı karakterlerden sonra pozisyonda yapılır. + +### URLPathHierarchy(URL) {#urlpathhierarchyurl} + +Yukarıdaki ile aynı, ancak sonuçta protokol ve ana bilgisayar olmadan. / Eleman (kök) dahil değildir. Örnek: işlev, yandex'te URL'yi ağaç raporları uygulamak için kullanılır. Ölçü. + +``` text +URLPathHierarchy('https://example.com/browse/CONV-6788') = +[ + '/browse/', + '/browse/CONV-6788' +] +``` + +### decodeURLComponent (URL) {#decodeurlcomponenturl} + +Çözülmüş URL'yi döndürür. +Örnek: + +``` sql +SELECT decodeURLComponent('http://127.0.0.1:8123/?query=SELECT%201%3B') AS DecodedURL; +``` + +``` text +┌─DecodedURL─────────────────────────────┐ +│ http://127.0.0.1:8123/?query=SELECT 1; │ +└────────────────────────────────────────┘ +``` + +## URL'nin bir bölümünü kaldıran işlevler {#functions-that-remove-part-of-a-url} + +URL'de benzer bir şey yoksa, URL değişmeden kalır. + +### cutWWW {#cutwww} + +Birden fazla kaldırır ‘www.’ varsa, URL'nin etki alanının başından itibaren. + +### cutQueryString {#cutquerystring} + +Sorgu dizesini kaldırır. Soru işareti de kaldırılır. + +### cutFragment {#cutfragment} + +Parça tanımlayıcısını kaldırır. Sayı işareti de kaldırılır. + +### cutQueryStringAndFragment {#cutquerystringandfragment} + +Sorgu dizesini ve parça tanımlayıcısını kaldırır. Soru işareti ve sayı işareti de kaldırılır. + +### cutURLParameter (URL, isim) {#cuturlparameterurl-name} + +Kaldırır ‘name’ Varsa URL parametresi. Bu işlev, parametre adının URL'de geçirilen bağımsız değişkenle aynı şekilde kodlandığı varsayımı altında çalışır. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/url_functions/) diff --git a/docs/tr/sql_reference/functions/uuid_functions.md b/docs/tr/sql_reference/functions/uuid_functions.md new file mode 100644 index 00000000000..93969dd4640 --- /dev/null +++ b/docs/tr/sql_reference/functions/uuid_functions.md @@ -0,0 +1,122 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 53 +toc_title: "UUID ile \xE7al\u0131\u015Fma" +--- + +# UUID ile çalışmak için fonksiyonlar {#functions-for-working-with-uuid} + +UUID ile çalışmak için işlevler aşağıda listelenmiştir. + +## generateuuıdv4 {#uuid-function-generate} + +Üretir [UUID](../../sql_reference/data_types/uuid.md) -den [sürüm 4](https://tools.ietf.org/html/rfc4122#section-4.4). + +``` sql +generateUUIDv4() +``` + +**Döndürülen değer** + +UUID türü değeri. + +**Kullanım örneği** + +Bu örnek, UUID türü sütunuyla bir tablo oluşturma ve tabloya bir değer ekleme gösterir. + +``` sql +CREATE TABLE t_uuid (x UUID) ENGINE=TinyLog + +INSERT INTO t_uuid SELECT generateUUIDv4() + +SELECT * FROM t_uuid +``` + +``` text +┌────────────────────────────────────x─┐ +│ f4bf890f-f9dc-4332-ad5c-0c18e73f28e9 │ +└──────────────────────────────────────┘ +``` + +## toUUİD (x) {#touuid-x} + +Dize türü değerini UUID türüne dönüştürür. + +``` sql +toUUID(String) +``` + +**Döndürülen değer** + +UUID türü değeri. + +**Kullanım örneği** + +``` sql +SELECT toUUID('61f0c404-5cb3-11e7-907b-a6006ad3dba0') AS uuid +``` + +``` text +┌─────────────────────────────────uuid─┐ +│ 61f0c404-5cb3-11e7-907b-a6006ad3dba0 │ +└──────────────────────────────────────┘ +``` + +## UUİDStringToNum {#uuidstringtonum} + +Biçiminde 36 karakter içeren bir dize kabul eder `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx` ve bir bayt kümesi olarak döndürür [FixedString (16)](../../sql_reference/data_types/fixedstring.md). + +``` sql +UUIDStringToNum(String) +``` + +**Döndürülen değer** + +FixedString (16) + +**Kullanım örnekleri** + +``` sql +SELECT + '612f3c40-5d3b-217e-707b-6a546a3d7b29' AS uuid, + UUIDStringToNum(uuid) AS bytes +``` + +``` text +┌─uuid─────────────────────────────────┬─bytes────────────┐ +│ 612f3c40-5d3b-217e-707b-6a546a3d7b29 │ a/<@];!~p{jTj={) │ +└──────────────────────────────────────┴──────────────────┘ +``` + +## UUİDNumToString {#uuidnumtostring} + +Kabul eder bir [FixedString (16)](../../sql_reference/data_types/fixedstring.md) değer ve metin biçiminde 36 karakter içeren bir dize döndürür. + +``` sql +UUIDNumToString(FixedString(16)) +``` + +**Döndürülen değer** + +Dize. + +**Kullanım örneği** + +``` sql +SELECT + 'a/<@];!~p{jTj={)' AS bytes, + UUIDNumToString(toFixedString(bytes, 16)) AS uuid +``` + +``` text +┌─bytes────────────┬─uuid─────────────────────────────────┐ +│ a/<@];!~p{jTj={) │ 612f3c40-5d3b-217e-707b-6a546a3d7b29 │ +└──────────────────┴──────────────────────────────────────┘ +``` + +## Ayrıca bakınız {#see-also} + +- [dictGetUUİD](ext_dict_functions.md#ext_dict_functions-other) + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/uuid_function/) diff --git a/docs/tr/sql_reference/functions/ym_dict_functions.md b/docs/tr/sql_reference/functions/ym_dict_functions.md new file mode 100644 index 00000000000..46384107029 --- /dev/null +++ b/docs/tr/sql_reference/functions/ym_dict_functions.md @@ -0,0 +1,155 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 59 +toc_title: "Yandex ile \xE7al\u0131\u015Fmak.Metrica S\xF6zl\xFCkleri" +--- + +# Yandex ile çalışmak için fonksiyonlar.Metrica sözlükleri {#functions-for-working-with-yandex-metrica-dictionaries} + +Aşağıdaki işlevlerin çalışması için, sunucu yapılandırmasının tüm Yandex'i almak için yolları ve adresleri belirtmesi gerekir.Metrica sözlükler. Sözlükler, bu işlevlerden herhangi birinin ilk çağrısında yüklenir. Başvuru listeleri yüklenemiyorsa, bir özel durum atılır. + +Başvuru listeleri oluşturma hakkında daha fazla bilgi için bölüme bakın “Dictionaries”. + +## Çoklu geobazlar {#multiple-geobases} + +ClickHouse, belirli bölgelerin hangi ülkelere ait olduğu konusunda çeşitli perspektifleri desteklemek için aynı anda birden fazla alternatif jeobaz (bölgesel hiyerarşiler) ile çalışmayı destekler. + +Bu ‘clickhouse-server’ config, dosyayı bölgesel hiyerarşi ile belirtir::`/opt/geo/regions_hierarchy.txt` + +Bu dosyanın yanı sıra, yakındaki \_ sembolüne ve isme eklenen herhangi bir sonek (dosya uzantısından önce) olan dosyaları da arar. +Örneğin, dosyayı da bulacaktır `/opt/geo/regions_hierarchy_ua.txt` varsa. + +`ua` sözlük anahtarı denir. Soneksiz bir sözlük için anahtar boş bir dizedir. + +Tüm sözlükler çalışma zamanında yeniden yüklenir (buıltın\_dıctıonarıes\_reload\_ınterval yapılandırma parametresinde tanımlandığı gibi belirli sayıda saniyede bir kez veya varsayılan olarak saatte bir kez). Ancak, sunucu başladığında kullanılabilir sözlüklerin listesi bir kez tanımlanır. + +All functions for working with regions have an optional argument at the end – the dictionary key. It is referred to as the geobase. +Örnek: + +``` sql +regionToCountry(RegionID) – Uses the default dictionary: /opt/geo/regions_hierarchy.txt +regionToCountry(RegionID, '') – Uses the default dictionary: /opt/geo/regions_hierarchy.txt +regionToCountry(RegionID, 'ua') – Uses the dictionary for the 'ua' key: /opt/geo/regions_hierarchy_ua.txt +``` + +### regionToCity (id \[, geobase\]) {#regiontocityid-geobase} + +Accepts a UInt32 number – the region ID from the Yandex geobase. If this region is a city or part of a city, it returns the region ID for the appropriate city. Otherwise, returns 0. + +### regionToArea (id \[, geobase\]) {#regiontoareaid-geobase} + +Bir bölgeyi bir alana dönüştürür (geobase içinde 5 yazın). Diğer her şekilde, bu işlev aynıdır ‘regionToCity’. + +``` sql +SELECT DISTINCT regionToName(regionToArea(toUInt32(number), 'ua')) +FROM system.numbers +LIMIT 15 +``` + +``` text +┌─regionToName(regionToArea(toUInt32(number), \'ua\'))─┐ +│ │ +│ Moscow and Moscow region │ +│ St. Petersburg and Leningrad region │ +│ Belgorod region │ +│ Ivanovsk region │ +│ Kaluga region │ +│ Kostroma region │ +│ Kursk region │ +│ Lipetsk region │ +│ Orlov region │ +│ Ryazan region │ +│ Smolensk region │ +│ Tambov region │ +│ Tver region │ +│ Tula region │ +└──────────────────────────────────────────────────────┘ +``` + +### regionToDistrict (id \[, geobase\]) {#regiontodistrictid-geobase} + +Bir bölgeyi federal bir bölgeye dönüştürür (geobase içinde tip 4). Diğer her şekilde, bu işlev aynıdır ‘regionToCity’. + +``` sql +SELECT DISTINCT regionToName(regionToDistrict(toUInt32(number), 'ua')) +FROM system.numbers +LIMIT 15 +``` + +``` text +┌─regionToName(regionToDistrict(toUInt32(number), \'ua\'))─┐ +│ │ +│ Central federal district │ +│ Northwest federal district │ +│ South federal district │ +│ North Caucases federal district │ +│ Privolga federal district │ +│ Ural federal district │ +│ Siberian federal district │ +│ Far East federal district │ +│ Scotland │ +│ Faroe Islands │ +│ Flemish region │ +│ Brussels capital region │ +│ Wallonia │ +│ Federation of Bosnia and Herzegovina │ +└──────────────────────────────────────────────────────────┘ +``` + +### regionToCountry (ıd \[, geobase\]) {#regiontocountryid-geobase} + +Bir bölgeyi bir ülkeye dönüştürür. Diğer her şekilde, bu işlev aynıdır ‘regionToCity’. +Örnek: `regionToCountry(toUInt32(213)) = 225` Moskova'yı (213) Rusya'ya (225) dönüştürür. + +### regionToContinent (id \[, geobase\]) {#regiontocontinentid-geobase} + +Bir bölgeyi bir kıtaya dönüştürür. Diğer her şekilde, bu işlev aynıdır ‘regionToCity’. +Örnek: `regionToContinent(toUInt32(213)) = 10001` Moskova'yı (213) Avrasya'ya (10001) dönüştürür. + +### regionToTopContinent (\#regiontotopcontinent) {#regiontotopcontinent-regiontotopcontinent} + +Bölgenin hiyerarşisinde en yüksek kıtayı bulur. + +**Sözdizimi** + +``` sql +regionToTopContinent(id[, geobase]); +``` + +**Parametre** + +- `id` — Region ID from the Yandex geobase. [Uİnt32](../../sql_reference/data_types/int_uint.md). +- `geobase` — Dictionary key. See [Çoklu Geobazlar](#multiple-geobases). [Dize](../../sql_reference/data_types/string.md). İsteğe bağlı. + +**Döndürülen değer** + +- Üst düzey kıtanın tanımlayıcısı (bölgeler hiyerarşisine tırmandığınızda ikincisi). +- 0, yoksa. + +Tür: `UInt32`. + +### regionToPopulation (id \[, geobase\]) {#regiontopopulationid-geobase} + +Bir bölge için nüfusu alır. +Nüfus geobase ile dosyalarda kaydedilebilir. Bölümüne bakınız “External dictionaries”. +Bölge için nüfus kaydedilmezse, 0 döndürür. +Yandex geobase'de, nüfus alt bölgeler için kaydedilebilir, ancak üst bölgeler için kaydedilemez. + +### regionİn (lhs, rhs \[, geobase\]) {#regioninlhs-rhs-geobase} + +Olup olmadığını denetler bir ‘lhs’ bölge bir ‘rhs’ bölge. Aitse 1'e eşit bir Uİnt8 numarası veya ait değilse 0 döndürür. +The relationship is reflexive – any region also belongs to itself. + +### regionHierarchy (id \[, geobase\]) {#regionhierarchyid-geobase} + +Accepts a UInt32 number – the region ID from the Yandex geobase. Returns an array of region IDs consisting of the passed region and all parents along the chain. +Örnek: `regionHierarchy(toUInt32(213)) = [213,1,3,225,10001,10000]`. + +### regionToName (id \[, lang\]) {#regiontonameid-lang} + +Accepts a UInt32 number – the region ID from the Yandex geobase. A string with the name of the language can be passed as a second argument. Supported languages are: ru, en, ua, uk, by, kz, tr. If the second argument is omitted, the language ‘ru’ is used. If the language is not supported, an exception is thrown. Returns a string – the name of the region in the corresponding language. If the region with the specified ID doesn't exist, an empty string is returned. + +`ua` ve `uk` hem Ukrayna demek. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/ym_dict_functions/) diff --git a/docs/tr/sql_reference/index.md b/docs/tr/sql_reference/index.md new file mode 100644 index 00000000000..25b886b9c9d --- /dev/null +++ b/docs/tr/sql_reference/index.md @@ -0,0 +1,18 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "SQL ba\u015Fvurusu" +toc_hidden: true +toc_priority: 28 +toc_title: "gizlenmi\u015F" +--- + +# SQL başvurusu {#sql-reference} + +- [SELECT](statements/select.md) +- [INSERT INTO](statements/insert_into.md) +- [CREATE](statements/create.md) +- [ALTER](statements/alter.md#query_language_queries_alter) +- [Diğer sorgu türleri](statements/misc.md) + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/) diff --git a/docs/tr/sql_reference/operators.md b/docs/tr/sql_reference/operators.md new file mode 100644 index 00000000000..63100e9e9ea --- /dev/null +++ b/docs/tr/sql_reference/operators.md @@ -0,0 +1,277 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 37 +toc_title: "Operat\xF6rler" +--- + +# Operatörler {#operators} + +ClickHouse onların öncelik, öncelik ve ilişkilendirme göre sorgu ayrıştırma aşamasında karşılık gelen işlevlere işleçleri dönüştürür. + +## Erişim Operatörleri {#access-operators} + +`a[N]` – Access to an element of an array. The `arrayElement(a, N)` işlev. + +`a.N` – Access to a tuple element. The `tupleElement(a, N)` işlev. + +## Sayısal Olumsuzlama Operatörü {#numeric-negation-operator} + +`-a` – The `negate (a)` işlev. + +## Çarpma ve bölme operatörleri {#multiplication-and-division-operators} + +`a * b` – The `multiply (a, b)` işlev. + +`a / b` – The `divide(a, b)` işlev. + +`a % b` – The `modulo(a, b)` işlev. + +## Toplama ve çıkarma operatörleri {#addition-and-subtraction-operators} + +`a + b` – The `plus(a, b)` işlev. + +`a - b` – The `minus(a, b)` işlev. + +## Karşılaştırma Operatörleri {#comparison-operators} + +`a = b` – The `equals(a, b)` işlev. + +`a == b` – The `equals(a, b)` işlev. + +`a != b` – The `notEquals(a, b)` işlev. + +`a <> b` – The `notEquals(a, b)` işlev. + +`a <= b` – The `lessOrEquals(a, b)` işlev. + +`a >= b` – The `greaterOrEquals(a, b)` işlev. + +`a < b` – The `less(a, b)` işlev. + +`a > b` – The `greater(a, b)` işlev. + +`a LIKE s` – The `like(a, b)` işlev. + +`a NOT LIKE s` – The `notLike(a, b)` işlev. + +`a BETWEEN b AND c` – The same as `a >= b AND a <= c`. + +`a NOT BETWEEN b AND c` – The same as `a < b OR a > c`. + +## Veri kümeleriyle çalışmak için operatörler {#operators-for-working-with-data-sets} + +*Görmek [Operatör İNLERDE](statements/select.md#select-in-operators).* + +`a IN ...` – The `in(a, b)` işlev. + +`a NOT IN ...` – The `notIn(a, b)` işlev. + +`a GLOBAL IN ...` – The `globalIn(a, b)` işlev. + +`a GLOBAL NOT IN ...` – The `globalNotIn(a, b)` işlev. + +## Tarih ve Saatlerle çalışmak için operatörler {#operators-datetime} + +### EXTRACT {#operator-extract} + +``` sql +EXTRACT(part FROM date); +``` + +Belirli bir tarihten parçaları ayıklayın. Örneğin, belirli bir tarihten bir ay veya bir zamandan bir saniye alabilirsiniz. + +Bu `part` parametre almak için tarihin hangi bölümünü belirtir. Aşağıdaki değerler kullanılabilir: + +- `DAY` — The day of the month. Possible values: 1–31. +- `MONTH` — The number of a month. Possible values: 1–12. +- `YEAR` — The year. +- `SECOND` — The second. Possible values: 0–59. +- `MINUTE` — The minute. Possible values: 0–59. +- `HOUR` — The hour. Possible values: 0–23. + +Bu `part` parametre büyük / küçük harf duyarsızdır. + +Bu `date` parametre, işlenecek tarihi veya saati belirtir. Ya [Tarihli](../sql_reference/data_types/date.md) veya [DateTime](../sql_reference/data_types/datetime.md) türü desteklenir. + +Örnekler: + +``` sql +SELECT EXTRACT(DAY FROM toDate('2017-06-15')); +SELECT EXTRACT(MONTH FROM toDate('2017-06-15')); +SELECT EXTRACT(YEAR FROM toDate('2017-06-15')); +``` + +Aşağıdaki örnekte bir tablo oluşturuyoruz ve içine bir değer ekliyoruz `DateTime` tür. + +``` sql +CREATE TABLE test.Orders +( + OrderId UInt64, + OrderName String, + OrderDate DateTime +) +ENGINE = Log; +``` + +``` sql +INSERT INTO test.Orders VALUES (1, 'Jarlsberg Cheese', toDateTime('2008-10-11 13:23:44')); +``` + +``` sql +SELECT + toYear(OrderDate) AS OrderYear, + toMonth(OrderDate) AS OrderMonth, + toDayOfMonth(OrderDate) AS OrderDay, + toHour(OrderDate) AS OrderHour, + toMinute(OrderDate) AS OrderMinute, + toSecond(OrderDate) AS OrderSecond +FROM test.Orders; +``` + +``` text +┌─OrderYear─┬─OrderMonth─┬─OrderDay─┬─OrderHour─┬─OrderMinute─┬─OrderSecond─┐ +│ 2008 │ 10 │ 11 │ 13 │ 23 │ 44 │ +└───────────┴────────────┴──────────┴───────────┴─────────────┴─────────────┘ +``` + +Daha fazla örnek görebilirsiniz [testler](https://github.com/ClickHouse/ClickHouse/blob/master/tests/queries/0_stateless/00619_extract.sql). + +### INTERVAL {#operator-interval} + +Oluşturur bir [Aralıklı](../sql_reference/data_types/special_data_types/interval.md)- aritmetik işlemlerde kullanılması gereken tip değeri [Tarihli](../sql_reference/data_types/date.md) ve [DateTime](../sql_reference/data_types/datetime.md)- tip değerleri. + +Aralık türleri: +- `SECOND` +- `MINUTE` +- `HOUR` +- `DAY` +- `WEEK` +- `MONTH` +- `QUARTER` +- `YEAR` + +!!! warning "Uyarıcı" + Farklı tiplere sahip aralıklar birleştirilemez. Gibi ifadeler kullanamazsınız `INTERVAL 4 DAY 1 HOUR`. Aralıkların, örneğin aralığın en küçük birimine eşit veya daha küçük olan birimlerdeki aralıkları belirtin, `INTERVAL 25 HOUR`. Aşağıdaki örnekte olduğu gibi ardışık işlemleri kullanabilirsiniz. + +Örnek: + +``` sql +SELECT now() AS current_date_time, current_date_time + INTERVAL 4 DAY + INTERVAL 3 HOUR +``` + +``` text +┌───current_date_time─┬─plus(plus(now(), toIntervalDay(4)), toIntervalHour(3))─┐ +│ 2019-10-23 11:16:28 │ 2019-10-27 14:16:28 │ +└─────────────────────┴────────────────────────────────────────────────────────┘ +``` + +**Ayrıca Bakınız** + +- [Aralıklı](../sql_reference/data_types/special_data_types/interval.md) veri türü +- [toİnterval](../sql_reference/functions/type_conversion_functions.md#function-tointerval) tip dönüştürme işlevleri + +## Mantıksal Olumsuzlama Operatörü {#logical-negation-operator} + +`NOT a` – The `not(a)` işlev. + +## Mantıksal ve operatör {#logical-and-operator} + +`a AND b` – The`and(a, b)` işlev. + +## Mantıksal veya operatör {#logical-or-operator} + +`a OR b` – The `or(a, b)` işlev. + +## Koşullu Operatör {#conditional-operator} + +`a ? b : c` – The `if(a, b, c)` işlev. + +Not: + +Koşullu işleç B ve c değerlerini hesaplar, ardından a koşulunun karşılanıp karşılanmadığını kontrol eder ve ardından karşılık gelen değeri döndürür. Eğer `b` veya `C` is an [arrayJoin()](../sql_reference/functions/array_join.md#functions_arrayjoin) işlev, her satır ne olursa olsun çoğaltılır “a” koşul. + +## Koşullu İfade {#operator_case} + +``` sql +CASE [x] + WHEN a THEN b + [WHEN ... THEN ...] + [ELSE c] +END +``` + +Eğer `x` belirtilen sonra `transform(x, [a, ...], [b, ...], c)` function is used. Otherwise – `multiIf(a, b, ..., c)`. + +Eğer herhangi bir `ELSE c` ifadedeki yan tümce, varsayılan değer `NULL`. + +Bu `transform` fonksiyonu ile çalışmıyor `NULL`. + +## Birleştirme Operatörü {#concatenation-operator} + +`s1 || s2` – The `concat(s1, s2) function.` + +## Lambda Oluşturma Operatörü {#lambda-creation-operator} + +`x -> expr` – The `lambda(x, expr) function.` + +Parantez oldukları için aşağıdaki operatörler bir önceliğe sahip değildir: + +## Dizi Oluşturma Operatörü {#array-creation-operator} + +`[x1, ...]` – The `array(x1, ...) function.` + +## Tuple Oluşturma Operatörü {#tuple-creation-operator} + +`(x1, x2, ...)` – The `tuple(x2, x2, ...) function.` + +## İlişkisellik {#associativity} + +Tüm ikili operatörler ilişkisellikten ayrıldı. Mesela, `1 + 2 + 3` dönüştür toülür `plus(plus(1, 2), 3)`. +Bazen bu beklediğiniz gibi çalışmaz. Mesela, `SELECT 4 > 2 > 3` 0 ile sonuç willlanır. + +Verimlilik için, `and` ve `or` işlevler herhangi bir sayıda bağımsız değişkeni kabul eder. İlgili zincirler `AND` ve `OR` operatörler bu işlevlerin tek bir çağrısına dönüştürülür. + +## İçin kontrol `NULL` {#checking-for-null} + +ClickHouse destekler `IS NULL` ve `IS NOT NULL` operatörler. + +### IS NULL {#operator-is-null} + +- İçin [Nullable](../sql_reference/data_types/nullable.md) türü değerleri `IS NULL` operatör döner: + - `1` değeri ise `NULL`. + - `0` başka. +- Diğer değerler için, `IS NULL` operatör her zaman döner `0`. + + + +``` sql +SELECT x+100 FROM t_null WHERE y IS NULL +``` + +``` text +┌─plus(x, 100)─┐ +│ 101 │ +└──────────────┘ +``` + +### IS NOT NULL {#is-not-null} + +- İçin [Nullable](../sql_reference/data_types/nullable.md) türü değerleri `IS NOT NULL` operatör döner: + - `0` değeri ise `NULL`. + - `1` başka. +- Diğer değerler için, `IS NOT NULL` operatör her zaman döner `1`. + + + +``` sql +SELECT * FROM t_null WHERE y IS NOT NULL +``` + +``` text +┌─x─┬─y─┐ +│ 2 │ 3 │ +└───┴───┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/operators/) diff --git a/docs/tr/sql_reference/statements/alter.md b/docs/tr/sql_reference/statements/alter.md new file mode 100644 index 00000000000..b61a3784af9 --- /dev/null +++ b/docs/tr/sql_reference/statements/alter.md @@ -0,0 +1,504 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 36 +toc_title: ALTER +--- + +## ALTER {#query_language_queries_alter} + +Bu `ALTER` sorgu yalnızca için desteklenir `*MergeTree` tablo gibi `Merge`ve`Distributed`. Sorgunun çeşitli varyasyonları vardır. + +### Sütun Manipülasyonları {#column-manipulations} + +Tablo yapısını değiştirme. + +``` sql +ALTER TABLE [db].name [ON CLUSTER cluster] ADD|DROP|CLEAR|COMMENT|MODIFY COLUMN ... +``` + +Sorguda, bir veya daha fazla virgülle ayrılmış eylemlerin bir listesini belirtin. +Her eylem bir sütun üzerinde bir işlemdir. + +Aşağıdaki eylemler desteklenir: + +- [ADD COLUMN](#alter_add-column) — Adds a new column to the table. +- [DROP COLUMN](#alter_drop-column) — Deletes the column. +- [CLEAR COLUMN](#alter_clear-column) — Resets column values. +- [COMMENT COLUMN](#alter_comment-column) — Adds a text comment to the column. +- [MODIFY COLUMN](#alter_modify-column) — Changes column's type, default expression and TTL. + +Bu eylemler aşağıda ayrıntılı olarak açıklanmıştır. + +#### ADD COLUMN {#alter_add-column} + +``` sql +ADD COLUMN [IF NOT EXISTS] name [type] [default_expr] [codec] [AFTER name_after] +``` + +Belirtilen tabloya yeni bir sütun ekler `name`, `type`, [`codec`](create.md#codecs) ve `default_expr` (bkz [Varsayılan ifadeler](create.md#create-default-values)). + +Eğer... `IF NOT EXISTS` yan tümcesi dahil, sütun zaten varsa sorgu bir hata döndürmez. Belirtir specifyseniz `AFTER name_after` (başka bir sütunun adı), sütun tablo sütunları listesinde belirtilen sonra eklenir. Aksi takdirde, sütun tablonun sonuna eklenir. Bir tablonun başına bir sütun eklemek için bir yol olduğunu unutmayın. Bir eylem zinciri için, `name_after` önceki eylemlerden birine eklenen bir sütunun adı olabilir. + +Bir sütun eklemek, verilerle herhangi bir işlem yapmadan tablo yapısını değiştirir. Sonra veriler diskte görünmüyor `ALTER`. Tablodan okurken bir sütun için veri eksikse, varsayılan değerlerle doldurulur (varsa, varsayılan ifadeyi gerçekleştirerek veya sıfır veya boş dizeler kullanarak). Sütun, veri parçalarını birleştirdikten sonra diskte görünür (bkz. [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md)). + +Bu yaklaşım bize tamamlamak için izin verir `ALTER` eski verilerin hacmini arttırmadan anında sorgulayın. + +Örnek: + +``` sql +ALTER TABLE visits ADD COLUMN browser String AFTER user_id +``` + +#### DROP COLUMN {#alter_drop-column} + +``` sql +DROP COLUMN [IF EXISTS] name +``` + +Sütun adı ile siler `name`. Eğer... `IF EXISTS` yan tümcesi belirtilir, sütun yoksa sorgu bir hata döndürmez. + +Dosya sisteminden veri siler. Bu, tüm dosyaları sildiğinden, sorgu neredeyse anında tamamlanır. + +Örnek: + +``` sql +ALTER TABLE visits DROP COLUMN browser +``` + +#### CLEAR COLUMN {#alter_clear-column} + +``` sql +CLEAR COLUMN [IF EXISTS] name IN PARTITION partition_name +``` + +Belirtilen bölüm için bir sütundaki tüm verileri sıfırlar. Bölümdeki bölüm adını ayarlama hakkında daha fazla bilgi edinin [Bölüm ifadesi nasıl belirlenir](#alter-how-to-specify-part-expr). + +Eğer... `IF EXISTS` yan tümcesi belirtilir, sütun yoksa sorgu bir hata döndürmez. + +Örnek: + +``` sql +ALTER TABLE visits CLEAR COLUMN browser IN PARTITION tuple() +``` + +#### COMMENT COLUMN {#alter_comment-column} + +``` sql +COMMENT COLUMN [IF EXISTS] name 'comment' +``` + +Sütuna bir yorum ekler. Eğer... `IF EXISTS` yan tümcesi belirtilir, sütun yoksa sorgu bir hata döndürmez. + +Her sütunun bir yorumu olabilir. Sütun için bir yorum zaten varsa, yeni bir yorum önceki yorumun üzerine yazar. + +Yorumlar saklanır `comment_expression` tarafından döndürülen sütun [DESCRIBE TABLE](misc.md#misc-describe-table) sorgu. + +Örnek: + +``` sql +ALTER TABLE visits COMMENT COLUMN browser 'The table shows the browser used for accessing the site.' +``` + +#### MODIFY COLUMN {#alter_modify-column} + +``` sql +MODIFY COLUMN [IF EXISTS] name [type] [default_expr] [TTL] +``` + +Bu sorgu değişiklikleri `name` sütun özellikleri: + +- Tür + +- Varsayılan ifade + +- TTL + + For examples of columns TTL modifying, see [Column TTL](../engines/table_engines/mergetree_family/mergetree.md#mergetree-column-ttl). + +Eğer... `IF EXISTS` yan tümcesi belirtilir, sütun yoksa sorgu bir hata döndürmez. + +Türü değiştirirken, değerler sanki [toType](../../sql_reference/functions/type_conversion_functions.md) fonksiyonlar onlara uygulandı. Yalnızca varsayılan ifade değiştirilirse, sorgu karmaşık bir şey yapmaz ve neredeyse anında tamamlanır. + +Örnek: + +``` sql +ALTER TABLE visits MODIFY COLUMN browser Array(String) +``` + +Changing the column type is the only complex action – it changes the contents of files with data. For large tables, this may take a long time. + +Birkaç işlem aşaması vardır: + +- Geçici (yeni) dosyaları değiştirilmiş verilerle hazırlama. +- Eski dosyaları yeniden adlandırma. +- Geçici (yeni) dosyaları eski adlara yeniden adlandırma. +- Eski dosyaları silme. + +Sadece ilk aşama zaman alır. Bu aşamada bir hata varsa, veriler değişmez. +Ardışık aşamalardan biri sırasında bir hata varsa, veriler el ile geri yüklenebilir. Eski dosyalar dosya sisteminden silindi, ancak yeni dosyaların verileri diske yazılmadı ve kaybolduysa istisnadır. + +Bu `ALTER` sütunları değiştirmek için sorgu çoğaltılır. Talimatlar ZooKeeper kaydedilir, daha sonra her kopya bunları uygular. Tüm `ALTER` sorgular aynı sırada çalıştırılır. Sorgu, diğer yinelemeler üzerinde tamamlanması uygun eylemleri bekler. Ancak, yinelenen bir tablodaki sütunları değiştirmek için bir sorgu kesilebilir ve tüm eylemler zaman uyumsuz olarak gerçekleştirilir. + +#### Sorgu sınırlamalarını değiştir {#alter-query-limitations} + +Bu `ALTER` sorgu oluşturmak ve iç içe veri yapıları, ancak tüm iç içe veri yapıları ayrı öğeleri (sütunlar) silmenizi sağlar. İç içe geçmiş bir veri yapısı eklemek için, aşağıdaki gibi bir ada sahip sütunlar ekleyebilirsiniz `name.nested_name` ve türü `Array(T)`. İç içe geçmiş bir veri yapısı, noktadan önce aynı öneki olan bir ada sahip birden çok dizi sütununa eşdeğerdir. + +Birincil anahtardaki veya örnekleme anahtarındaki sütunları silmek için destek yoktur. `ENGINE` ifade). Birincil anahtarda bulunan sütunların türünü değiştirmek, yalnızca bu değişiklik verilerin değiştirilmesine neden olmazsa mümkündür (örneğin, bir numaraya değer eklemenize veya bir türden değiştirmenize izin verilir `DateTime` -e doğru `UInt32`). + +Eğer... `ALTER` sorgu, ihtiyacınız olan tablo değişikliklerini yapmak için yeterli değildir, yeni bir tablo oluşturabilir, verileri kullanarak kopyalayabilirsiniz. [INSERT SELECT](insert_into.md#insert_query_insert-select) sorgu, daha sonra tabloları kullanarak geçiş [RENAME](misc.md#misc_operations-rename) sorgu ve eski tabloyu silin. Kullanabilirsiniz [clickhouse-fotokopi makinesi](../../operations/utilities/clickhouse-copier.md) bir alternatif olarak `INSERT SELECT` sorgu. + +Bu `ALTER` sorgu tüm okur ve tablo için yazar engeller. Başka bir deyişle, Eğer uzun `SELECT` zamanda çalışıyor `ALTER` sorgu `ALTER` sorgu tamamlanmasını bekleyecektir. Aynı zamanda, aynı tablodaki tüm yeni sorgular bu sırada bekleyecektir `ALTER` çalışıyor. + +Verileri kendileri saklamayan tablolar için (örneğin `Merge` ve `Distributed`), `ALTER` sadece tablo yapısını değiştirir ve alt tabloların yapısını değiştirmez. Örneğin, ALTER for a çalıştırırken `Distributed` tablo, ayrıca çalıştırmak gerekir `ALTER` tüm uzak sunuculardaki tablolar için. + +### Anahtar İfadelerle Manipülasyonlar {#manipulations-with-key-expressions} + +Aşağıdaki komut desteklenir: + +``` sql +MODIFY ORDER BY new_expression +``` + +Sadece tablolar için çalışır [`MergeTree`](../../engines/table_engines/mergetree_family/mergetree.md) aile (dahil +[çoğaltıyordu](../../engines/table_engines/mergetree_family/replication.md) Tablolar). Komutu değiştirir +[sıralama anahtarı](../../engines/table_engines/mergetree_family/mergetree.md) tablonun +-e doğru `new_expression` (bir ifade veya ifadelerin bir tuple). Birincil anahtar aynı kalır. + +Komut, yalnızca meta verileri değiştirdiği bir anlamda hafiftir. Veri parçası özelliği tutmak için +satırlar sıralama anahtarı ifadesi tarafından sıralanır varolan sütunları içeren ifadeler ekleyemezsiniz +sıralama anahtarına (yalnızca sütun tarafından eklenen `ADD COLUMN` aynı komut `ALTER` sorgu). + +### Veri Atlama Endeksleri İle Manipülasyonlar {#manipulations-with-data-skipping-indices} + +Sadece tablolar için çalışır [`*MergeTree`](../../engines/table_engines/mergetree_family/mergetree.md) aile (dahil +[çoğaltıyordu](../../engines/table_engines/mergetree_family/replication.md) Tablolar). Aşağıdaki işlemler +mevcuttur: + +- `ALTER TABLE [db].name ADD INDEX name expression TYPE type GRANULARITY value AFTER name [AFTER name2]` - Tablolar meta dizin açıklama ekler. + +- `ALTER TABLE [db].name DROP INDEX name` - Tablolar meta dizin açıklama kaldırır ve diskten dizin dosyalarını siler. + +Bu komutlar, yalnızca meta verileri değiştirdikleri veya dosyaları kaldırdıkları bir anlamda hafiftir. +Ayrıca, çoğaltılırlar (ZooKeeper aracılığıyla indeks meta verilerini senkronize etme). + +### Kısıtlamalar İle Manipülasyonlar {#manipulations-with-constraints} + +Daha fazla görmek [kısıtlamalar](create.md#constraints) + +Kısıtlamalar eklenebilir veya aşağıdaki sözdizimi kullanılarak silinebilir: + +``` sql +ALTER TABLE [db].name ADD CONSTRAINT constraint_name CHECK expression; +ALTER TABLE [db].name DROP CONSTRAINT constraint_name; +``` + +Sorgular eklemek veya hemen işlenir, böylece tablodan kısıtlamaları hakkında meta verileri kaldırın. + +Kısıtlama kontrolü *idam edilm willeyecek* eklen .mişse mevcut ver .ilerde + +Çoğaltılmış tablolardaki tüm değişiklikler Zookeeper'a yayınlanır, bu nedenle diğer kopyalara uygulanır. + +### Bölümler ve parçalar ile manipülasyonlar {#alter_manipulations-with-partitions} + +Aşağıdaki işlemler ile [bölümler](../../engines/table_engines/mergetree_family/custom_partitioning_key.md) mevcuttur: + +- [DETACH PARTITION](#alter_detach-partition) – Moves a partition to the `detached` dizin ve unutun. +- [DROP PARTITION](#alter_drop-partition) – Deletes a partition. +- [ATTACH PART\|PARTITION](#alter_attach-partition) – Adds a part or partition from the `detached` tabloya dizin. +- [ATTACH PARTITION FROM](#alter_attach-partition-from) – Copies the data partition from one table to another and adds. +- [REPLACE PARTITION](#alter_replace-partition) - Veri bölümünü bir tablodan diğerine kopyalar ve değiştirir. +- [MOVE PARTITION TO TABLE](#alter_move_to_table-partition) (\#alter\_move\_to\_table-partition) - veri bölümünü bir tablodan diğerine taşıyın. +- [CLEAR COLUMN IN PARTITION](#alter_clear-column-partition) - Bir bölümdeki belirtilen sütunun değerini sıfırlar. +- [CLEAR INDEX IN PARTITION](#alter_clear-index-partition) - Bir bölümde belirtilen ikincil dizini sıfırlar. +- [FREEZE PARTITION](#alter_freeze-partition) – Creates a backup of a partition. +- [FETCH PARTITION](#alter_fetch-partition) – Downloads a partition from another server. +- [MOVE PARTITION\|PART](#alter_move-partition) – Move partition/data part to another disk or volume. + + + +#### Bölüm ayırmak {\#alter\_detach-bölüm} {#detach-partition-alter-detach-partition} + +``` sql +ALTER TABLE table_name DETACH PARTITION partition_expr +``` + +Belirtilen bölüm için tüm verileri `detached` dizin. Sunucu, yok gibi ayrılmış veri Bölümü hakkında unutur. Sunucu, bu verileri siz yapana kadar bilmeyecektir. [ATTACH](#alter_attach-partition) sorgu. + +Örnek: + +``` sql +ALTER TABLE visits DETACH PARTITION 201901 +``` + +Bir bölümdeki bölüm ifadesini ayarlama hakkında bilgi edinin [Bölüm ifadesi nasıl belirlenir](#alter-how-to-specify-part-expr). + +Sorgu yürütüldükten sonra, veri ile istediğiniz her şeyi yapabilirsiniz `detached` directory — delete it from the file system, or just leave it. + +This query is replicated – it moves the data to the `detached` tüm kopyalarda dizin. Bu sorguyu yalnızca bir lider yinelemesinde yürütebileceğinizi unutmayın. Bir kopya bir lider olup olmadığını öğrenmek için `SELECT` sorgu için [sistem.yinelemeler](../../operations/system_tables.md#system_tables-replicas) Tablo. Alternatif olarak, bir yapmak daha kolaydır `DETACH` tüm yinelemelerde sorgu - tüm yinelemeler, lider yinelemesi dışında bir özel durum oluşturur. + +#### DROP PARTITION {#alter_drop-partition} + +``` sql +ALTER TABLE table_name DROP PARTITION partition_expr +``` + +Belirtilen bölümü tablodan siler. Bu sorgu bölümü etkin olarak etiketler ve verileri tamamen yaklaşık 10 dakika içinde siler. + +Bir bölümdeki bölüm ifadesini ayarlama hakkında bilgi edinin [Bölüm ifadesi nasıl belirlenir](#alter-how-to-specify-part-expr). + +The query is replicated – it deletes data on all replicas. + +#### DROP DETACHED PARTITION\|PART {#alter_drop-detached} + +``` sql +ALTER TABLE table_name DROP DETACHED PARTITION|PART partition_expr +``` + +Belirtilen bölümü veya belirtilen bölümün tüm bölümlerini kaldırır `detached`. +Bir bölümdeki bölüm ifadesini ayarlama hakkında daha fazla bilgi edinin [Bölüm ifadesi nasıl belirlenir](#alter-how-to-specify-part-expr). + +#### ATTACH PARTITION\|PART {#alter_attach-partition} + +``` sql +ALTER TABLE table_name ATTACH PARTITION|PART partition_expr +``` + +Tablodan veri ekler `detached` dizin. Tüm bir bölüm veya ayrı bir bölüm için veri eklemek mümkündür. Örnekler: + +``` sql +ALTER TABLE visits ATTACH PARTITION 201901; +ALTER TABLE visits ATTACH PART 201901_2_2_0; +``` + +Bir bölümdeki bölüm ifadesini ayarlama hakkında daha fazla bilgi edinin [Bölüm ifadesi nasıl belirlenir](#alter-how-to-specify-part-expr). + +Bu sorgu çoğaltılır. Çoğaltma başlatıcısı, veri olup olmadığını denetler. `detached` dizin. Veri varsa, sorgu bütünlüğünü denetler. Her şey doğruysa, sorgu verileri tabloya ekler. Diğer tüm yinelemeler, çoğaltma başlatıcısından verileri karşıdan yükleyin. + +Böylece veri koyabilirsiniz `detached` bir kopya üzerinde dizin ve `ALTER ... ATTACH` tüm yinelemelerde tabloya eklemek için sorgu. + +#### ATTACH PARTITION FROM {#alter_attach-partition-from} + +``` sql +ALTER TABLE table2 ATTACH PARTITION partition_expr FROM table1 +``` + +Bu sorgu, veri bölümünü `table1` -e doğru `table2` exsisting için veri ekler `table2`. Verilerin silinmeyeceğini unutmayın `table1`. + +Sorgunun başarıyla çalışması için aşağıdaki koşulların karşılanması gerekir: + +- Her iki tablo da aynı yapıya sahip olmalıdır. +- Her iki tablo da aynı bölüm anahtarına sahip olmalıdır. + +#### REPLACE PARTITION {#alter_replace-partition} + +``` sql +ALTER TABLE table2 REPLACE PARTITION partition_expr FROM table1 +``` + +Bu sorgu, veri bölümünü `table1` -e doğru `table2` ve mevcut bölümün yerini alır `table2`. Verilerin silinmeyeceğini unutmayın `table1`. + +Sorgunun başarıyla çalışması için aşağıdaki koşulların karşılanması gerekir: + +- Her iki tablo da aynı yapıya sahip olmalıdır. +- Her iki tablo da aynı bölüm anahtarına sahip olmalıdır. + +#### MOVE PARTITION TO TABLE {#alter_move_to_table-partition} + +``` sql +ALTER TABLE table_source MOVE PARTITION partition_expr TO TABLE table_dest +``` + +Bu sorgu, veri bölümünü `table_source` -e doğru `table_dest` verileri silme ile `table_source`. + +Sorgunun başarıyla çalışması için aşağıdaki koşulların karşılanması gerekir: + +- Her iki tablo da aynı yapıya sahip olmalıdır. +- Her iki tablo da aynı bölüm anahtarına sahip olmalıdır. +- Her iki tablo da aynı motor ailesi olmalıdır. (çoğaltılmış veya çoğaltılmamış) +- Her iki tablo da aynı depolama ilkesine sahip olmalıdır. + +#### CLEAR COLUMN IN PARTITION {#alter_clear-column-partition} + +``` sql +ALTER TABLE table_name CLEAR COLUMN column_name IN PARTITION partition_expr +``` + +Bir bölümdeki belirtilen sütundaki tüm değerleri sıfırlar. Eğer... `DEFAULT` bir tablo oluştururken yan tümcesi belirlendi, bu sorgu sütun değerini belirtilen varsayılan değere ayarlar. + +Örnek: + +``` sql +ALTER TABLE visits CLEAR COLUMN hour in PARTITION 201902 +``` + +#### FREEZE PARTITION {#alter_freeze-partition} + +``` sql +ALTER TABLE table_name FREEZE [PARTITION partition_expr] +``` + +Bu sorgu, belirtilen bir bölümün yerel yedeğini oluşturur. Eğer... `PARTITION` yan tümcesi atlandı, sorgu aynı anda tüm bölümlerin yedeğini oluşturur. + +!!! note "Not" + Tüm yedekleme işlemi sunucuyu durdurmadan gerçekleştirilir. + +Eski tarz tablolar için bölüm adının önekini belirtebileceğinizi unutmayın (örneğin, ‘2019’)- daha sonra sorgu tüm ilgili bölümler için yedek oluşturur. Bir bölümdeki bölüm ifadesini ayarlama hakkında bilgi edinin [Bölüm ifadesi nasıl belirlenir](#alter-how-to-specify-part-expr). + +Yürütme sırasında, bir veri anlık görüntüsü için sorgu, bir tablo verilerine sabit bağlantılar oluşturur. Hardlinks dizine yerleştirilir `/var/lib/clickhouse/shadow/N/...`, nere: + +- `/var/lib/clickhouse/` yapılandırmada belirtilen çalışma ClickHouse dizinidir. +- `N` yedeklemenin artımlı sayısıdır. + +!!! note "Not" + Kullanıyorsanız [bir tablodaki veri depolama için disk kümesi](../../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-multiple-volumes), bu `shadow/N` dizin tarafından eşleşen veri parçalarını depolamak, her diskte görünür `PARTITION` ifade. + +Dizinlerin aynı yapısı, içinde olduğu gibi yedek içinde oluşturulur `/var/lib/clickhouse/`. Sorgu gerçekleştirir ‘chmod’ tüm dosyalar için, onlara yazmayı yasaklamak. + +Yedeklemeyi oluşturduktan sonra, verileri `/var/lib/clickhouse/shadow/` uzak sunucuya ve sonra yerel sunucudan silin. Not `ALTER t FREEZE PARTITION` sorgu çoğaltılmaz. Yalnızca yerel sunucuda yerel bir yedekleme oluşturur. + +Sorgu neredeyse anında yedekleme oluşturur (ancak önce geçerli sorguları ilgili tabloya çalışmayı bitirmek için bekler). + +`ALTER TABLE t FREEZE PARTITION` tablo meta verilerini değil, yalnızca verileri kopyalar. Tablo meta verilerinin yedeğini almak için dosyayı kopyalayın `/var/lib/clickhouse/metadata/database/table.sql` + +Bir yedekten veri geri yüklemek için aşağıdakileri yapın: + +1. Yoksa tablo oluşturun. Sorguyu görüntülemek için kullanın .sql dosyası (değiştir `ATTACH` içinde ile `CREATE`). +2. Veri kopyalama `data/database/table/` yedekleme içindeki dizin `/var/lib/clickhouse/data/database/table/detached/` dizin. +3. Koşmak `ALTER TABLE t ATTACH PARTITION` verileri bir tabloya eklemek için sorgular. + +Yedeklemeden geri yükleme, sunucuyu durdurmayı gerektirmez. + +Yedekleme ve geri yükleme verileri hakkında daha fazla bilgi için bkz: [Veri Yedekleme](../../operations/backup.md) bölme. + +#### CLEAR INDEX IN PARTITION {#alter_clear-index-partition} + +``` sql +ALTER TABLE table_name CLEAR INDEX index_name IN PARTITION partition_expr +``` + +Sorgu benzer çalışır `CLEAR COLUMN`, ancak bir sütun verileri yerine bir dizini sıfırlar. + +#### FETCH PARTITION {#alter_fetch-partition} + +``` sql +ALTER TABLE table_name FETCH PARTITION partition_expr FROM 'path-in-zookeeper' +``` + +Başka bir sunucudan bir bölüm indirir. Bu sorgu yalnızca çoğaltılmış tablolar için çalışır. + +Sorgu aşağıdakileri yapar: + +1. Bölümü belirtilen parçadan indirir. İçinde ‘path-in-zookeeper’ zookeeper içinde shard için bir yol belirtmeniz gerekir. +2. Sonra sorgu indirilen verileri `detached` directory of the `table_name` Tablo. Kullan... [ATTACH PARTITION\|PART](#alter_attach-partition) tabloya veri eklemek için sorgu. + +Mesela: + +``` sql +ALTER TABLE users FETCH PARTITION 201902 FROM '/clickhouse/tables/01-01/visits'; +ALTER TABLE users ATTACH PARTITION 201902; +``` + +Not thate that: + +- Bu `ALTER ... FETCH PARTITION` sorgu çoğaltılmaz. Bu bölüm için yerleştirir `detached` yalnızca yerel sunucuda dizin. +- Bu `ALTER TABLE ... ATTACH` sorgu çoğaltılır. Verileri tüm yinelemelere ekler. Veriler, kopyalardan birine eklenir. `detached` dizin ve diğerlerine - komşu kopyalardan. + +İndirmeden önce, sistem bölümün olup olmadığını ve tablo yapısının eşleşip eşleşmediğini kontrol eder. En uygun yineleme, sağlıklı yinelemeler otomatik olarak seçilir. + +Sorgu çağrılsa da `ALTER TABLE`, tablo yapısını değiştirmez ve tabloda bulunan verileri hemen değiştirmez. + +#### MOVE PARTITION\|PART {#alter_move-partition} + +Bölümleri veya veri parçalarını başka bir birime veya diske taşır. `MergeTree`- motor masaları. Görmek [Veri depolama için birden fazla blok cihazı kullanma](../../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-multiple-volumes). + +``` sql +ALTER TABLE table_name MOVE PARTITION|PART partition_expr TO DISK|VOLUME 'disk_name' +``` + +Bu `ALTER TABLE t MOVE` sorgu: + +- Çoğaltılamaz, çünkü farklı çoğaltmalar farklı depolama ilkelerine sahip olabilir. +- Belirtilen disk veya birim yapılandırılmamışsa bir hata döndürür. Depolama ilkesinde belirtilen veri taşıma koşulları uygulanamazsa, sorgu da bir hata döndürür. +- Durumda bir hata döndürebilir, taşınacak veriler zaten bir arka plan işlemi tarafından taşındığında, eşzamanlı `ALTER TABLE t MOVE` sorgu veya arka plan veri birleştirme sonucu. Bir kullanıcı bu durumda herhangi bir ek eylem gerçekleştirmemelidir. + +Örnek: + +``` sql +ALTER TABLE hits MOVE PART '20190301_14343_16206_438' TO VOLUME 'slow' +ALTER TABLE hits MOVE PARTITION '2019-09-01' TO DISK 'fast_ssd' +``` + +#### Bölüm İfadesi Nasıl Ayarlanır {#alter-how-to-specify-part-expr} + +Bölüm ifadesini şu şekilde belirtebilirsiniz `ALTER ... PARTITION` farklı şekillerde sorgular: + +- Bu gibi bir değer `partition` sütun `system.parts` Tablo. Mesela, `ALTER TABLE visits DETACH PARTITION 201901`. +- Tablo sütunundan ifade olarak. Sabitler ve sabit ifadeler desteklenir. Mesela, `ALTER TABLE visits DETACH PARTITION toYYYYMM(toDate('2019-01-25'))`. +- Bölüm kimliğini kullanma. Partition ID, dosya sistemindeki ve Zookeeper'daki bölümlerin adları olarak kullanılan bölümün (mümkünse insan tarafından okunabilir) bir dize tanımlayıcısıdır. Bölüm kimliği belirtilmelidir `PARTITION ID` fık .ra, tek tırnak içinde. Mesela, `ALTER TABLE visits DETACH PARTITION ID '201901'`. +- İn the [ALTER ATTACH PART](#alter_attach-partition) ve [DROP DETACHED PART](#alter_drop-detached) sorgu, bir parçanın adını belirtmek için, bir değer ile dize literal kullanın `name` sütun [sistem.detached\_parts](../../operations/system_tables.md#system_tables-detached_parts) Tablo. Mesela, `ALTER TABLE visits ATTACH PART '201901_1_1_0'`. + +Bölüm belirtilirken tırnak kullanımı bölüm ifadesi türüne bağlıdır. Örneğin, için `String` yazın, adını tırnak içinde belirtmeniz gerekir (`'`). İçin `Date` ve `Int*` türleri hiçbir tırnak gereklidir. + +Eski stil tablolar için, bölümü bir sayı olarak belirtebilirsiniz `201901` veya bir dize `'201901'`. Yeni stil tabloları için sözdizimi türleri ile daha sıkı (değerleri giriş biçimi için ayrıştırıcı benzer). + +Yukarıdaki tüm kurallar için de geçerlidir [OPTIMIZE](misc.md#misc_operations-optimize) sorgu. Bölümlenmemiş bir tabloyu en iyi duruma getirirken tek bölümü belirtmeniz gerekiyorsa, ifadeyi ayarlayın `PARTITION tuple()`. Mesela: + +``` sql +OPTIMIZE TABLE table_not_partitioned PARTITION tuple() FINAL; +``` + +Örnekleri `ALTER ... PARTITION` sorgular testlerde gösterilmiştir [`00502_custom_partitioning_local`](https://github.com/ClickHouse/ClickHouse/blob/master/tests/queries/0_stateless/00502_custom_partitioning_local.sql) ve [`00502_custom_partitioning_replicated_zookeeper`](https://github.com/ClickHouse/ClickHouse/blob/master/tests/queries/0_stateless/00502_custom_partitioning_replicated_zookeeper.sql). + +### Tablo TTL ile manipülasyonlar {#manipulations-with-table-ttl} + +Değiştirebilirsiniz [tablo TTL](../../engines/table_engines/mergetree_family/mergetree.md#mergetree-table-ttl) aşağıdaki formun bir isteği ile: + +``` sql +ALTER TABLE table-name MODIFY TTL ttl-expression +``` + +### Alter sorgularının eşzamanlılığı {#synchronicity-of-alter-queries} + +Replicatable olmayan tablolar için, tüm `ALTER` sorgular eşzamanlı olarak gerçekleştirilir. Replicatable tablolar için, sorgu yalnızca uygun eylemler için yönergeler ekler `ZooKeeper` ve eylemlerin kendileri mümkün olan en kısa sürede gerçekleştirilir. Ancak, sorgu tüm yinelemeler üzerinde tamamlanması için bu eylemleri bekleyebilir. + +İçin `ALTER ... ATTACH|DETACH|DROP` sorgular, kullanabilirsiniz `replication_alter_partitions_sync` bekleyen kurmak için ayarlama. +Olası değerler: `0` – do not wait; `1` – only wait for own execution (default); `2` – wait for all. + +### Mutasyonlar {#alter-mutations} + +Mutasyonlar, bir tablodaki satırların değiştirilmesine veya silinmesine izin veren bir alter query varyantıdır. Standart aksine `UPDATE` ve `DELETE` nokta veri değişikliklerine yönelik sorgular, mutasyonlar, bir tablodaki çok sayıda satırı değiştiren ağır işlemler için tasarlanmıştır. İçin desteklenen `MergeTree` çoğaltma desteği olan motorlar da dahil olmak üzere tablo motorları ailesi. + +Varolan tablolar olduğu gibi mutasyonlar için hazırdır(dönüştürme gerekmez), ancak ilk mutasyon bir tabloya uygulandıktan sonra Meta Veri formatı önceki sunucu sürümleriyle uyumsuz hale gelir ve önceki bir sürüme geri dönmek imkansız hale gelir. + +Şu anda mevcut komutlar: + +``` sql +ALTER TABLE [db.]table DELETE WHERE filter_expr +``` + +Bu `filter_expr` tip olmalıdır `UInt8`. Sorgu, bu ifadenin sıfır olmayan bir değer aldığı tablodaki satırları siler. + +``` sql +ALTER TABLE [db.]table UPDATE column1 = expr1 [, ...] WHERE filter_expr +``` + +Bu `filter_expr` tip olmalıdır `UInt8`. Bu sorgu, belirtilen sütunların değerlerini, satırlardaki karşılık gelen ifadelerin değerlerine güncelleştirir. `filter_expr` sıfır olmayan bir değer alır. Değerleri kullanarak sütun türüne döküm `CAST` operatör. Birincil veya bölüm anahtarının hesaplanmasında kullanılan sütunları güncelleştirme desteklenmiyor. + +``` sql +ALTER TABLE [db.]table MATERIALIZE INDEX name IN PARTITION partition_name +``` + +Sorgu ikincil dizini yeniden oluşturur `name` bölümünde `partition_name`. + +Bir sorgu virgülle ayrılmış birkaç komut içerebilir. + +\* MergeTree tabloları mutasyonları için tüm veri parçalarını yeniden yazarak yürütün. Atomiklik yoktur-parçalar, hazır oldukları anda mutasyona uğramış parçalar için ikame edilir ve bir `SELECT` bir mutasyon sırasında yürütülmeye başlayan sorgu, henüz mutasyona uğramamış olan parçalardan gelen verilerle birlikte mutasyona uğramış olan parçalardan gelen verileri görecektir. + +Mutasyonlar tamamen yaratılış sırasına göre sıralanır ve her bir parçaya bu sırayla uygulanır. Mutasyonlar da kısmen ekler ile sıralanır-mutasyon gönderilmeden önce tabloya eklenen veriler mutasyona uğrayacak ve bundan sonra eklenen veriler mutasyona uğramayacaktır. Mutasyonların ekleri hiçbir şekilde engellemediğini unutmayın. + +Mutasyon girişi eklendikten hemen sonra bir mutasyon sorgusu döner(çoğaltılmış tablolar Zookeeper'a, çoğaltılmamış tablolar için-dosya sistemine). Mutasyonun kendisi sistem profili ayarlarını kullanarak eşzamansız olarak yürütür. Mutasyonların ilerlemesini izlemek için kullanabilirsiniz [`system.mutations`](../../operations/system_tables.md#system_tables-mutations) Tablo. Başarıyla gönderilen BIR mutasyon, ClickHouse sunucuları yeniden başlatılmış olsa bile yürütmeye devam edecektir. Gönderildikten sonra mutasyonu geri almanın bir yolu yoktur, ancak mutasyon herhangi bir nedenle sıkışmışsa, [`KILL MUTATION`](misc.md#kill-mutation) sorgu. + +Bitmiş mutasyonlar için girişler hemen silinmez (korunmuş girişlerin sayısı, `finished_mutations_to_keep` depolama motoru parametresi). Eski mutasyon girişleri silinir. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/alter/) diff --git a/docs/tr/sql_reference/statements/create.md b/docs/tr/sql_reference/statements/create.md new file mode 100644 index 00000000000..5479034ad98 --- /dev/null +++ b/docs/tr/sql_reference/statements/create.md @@ -0,0 +1,305 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 35 +toc_title: CREATE +--- + +# Sorgu oluştur {#create-queries} + +## CREATE DATABASE {#query-language-create-database} + +Veritabanı oluşturur. + +``` sql +CREATE DATABASE [IF NOT EXISTS] db_name [ON CLUSTER cluster] [ENGINE = engine(...)] +``` + +### Yanlar {#clauses} + +- `IF NOT EXISTS` + Eğer... `db_name` veritabanı zaten var, daha sonra ClickHouse yeni bir veritabanı oluşturmuyor ve: + + - If yan tümcesi belirtilmişse bir istisna atmaz. + - Bir istisna atar if yan tümcesi belirtilmemiş. + +- `ON CLUSTER` + ClickHouse oluşturur `db_name` belirtilen bir kümenin tüm sunucularında veritabanı. + +- `ENGINE` + + - [MySQL](../../engines/database_engines/mysql.md) + Uzak MySQL sunucusundan veri almanızı sağlar. + Varsayılan olarak, ClickHouse kendi kullanır [Veritabanı Altyapısı](../../engines/database_engines/index.md). + +## CREATE TABLE {#create-table-query} + +Bu `CREATE TABLE` sorgu çeşitli formlara sahip olabilir. + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1] [compression_codec] [TTL expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2] [compression_codec] [TTL expr2], + ... +) ENGINE = engine +``` + +Adlı bir tablo oluşturur ‘name’ in the ‘db’ veritabanı veya geçerli veritabanı ise ‘db’ küme değil, parantez içinde belirtilen yapı ve ‘engine’ motor. +Tablonun yapısı sütun açıklamalarının bir listesidir. Dizinler altyapısı tarafından destekleniyorsa, tablo altyapısı için parametreler olarak gösterilir. + +Bir sütun açıklaması `name type` en basit durumda. Örnek: `RegionID UInt32`. +İfadeler varsayılan değerler için de tanımlanabilir (aşağıya bakın). + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name AS [db2.]name2 [ENGINE = engine] +``` + +Başka bir tablo ile aynı yapıya sahip bir tablo oluşturur. Tablo için farklı bir motor belirtebilirsiniz. Motor belirtilmemişse, aynı motor için olduğu gibi kullanılacaktır `db2.name2` Tablo. + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name AS table_function() +``` + +Yapısı ve veri tarafından döndürülen bir tablo oluşturur. [tablo fonksiyonu](../table_functions/index.md). + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name ENGINE = engine AS SELECT ... +``` + +Sonucu gibi bir yapıya sahip bir tablo oluşturur `SELECT` Sorgu, ile ‘engine’ motor ve SELECT verilerle doldurur. + +Her durumda, eğer `IF NOT EXISTS` tablo zaten varsa, sorgu bir hata döndürmez. Bu durumda, sorgu hiçbir şey yapmaz. + +Sonra başka maddeler olabilir `ENGINE` sorguda yan tümcesi. Açıklamalarda tabloların nasıl oluşturulacağına ilişkin ayrıntılı belgelere bakın [masa motorları](../../engines/table_engines/index.md#table_engines). + +### Varsayılan Değerler {#create-default-values} + +Sütun açıklaması, aşağıdaki yollardan biriyle varsayılan değer için bir ifade belirtebilir:`DEFAULT expr`, `MATERIALIZED expr`, `ALIAS expr`. +Örnek: `URLDomain String DEFAULT domain(URL)`. + +Varsayılan değer için bir ifade tanımlanmamışsa, varsayılan değerler sayılar için sıfırlar, dizeler için boş dizeler, diziler için boş diziler ve `0000-00-00` tarihler için veya `0000-00-00 00:00:00` zamanla tarihler için. Boş alanlar desteklenmez. + +Varsayılan ifade tanımlanmışsa, sütun türü isteğe bağlıdır. Açıkça tanımlanmış bir tür yoksa, varsayılan ifade türü kullanılır. Örnek: `EventDate DEFAULT toDate(EventTime)` – the ‘Date’ türü için kullanılacak ‘EventDate’ sütun. + +Veri türü ve varsayılan ifade açıkça tanımlanırsa, bu ifade type casting işlevleri kullanılarak belirtilen türe aktarılır. Örnek: `Hits UInt32 DEFAULT 0` aynı şeyi ifade eder `Hits UInt32 DEFAULT toUInt32(0)`. + +Default expressions may be defined as an arbitrary expression from table constants and columns. When creating and changing the table structure, it checks that expressions don't contain loops. For INSERT, it checks that expressions are resolvable – that all columns they can be calculated from have been passed. + +`DEFAULT expr` + +Normal varsayılan değer. INSERT sorgusu karşılık gelen sütunu belirtmezse, ilgili ifadeyi hesaplayarak doldurulur. + +`MATERIALIZED expr` + +Somut ifade. Böyle bir sütun INSERT için belirtilemez, çünkü her zaman hesaplanır. +Sütun listesi olmayan bir ekleme için bu sütunlar dikkate alınmaz. +Buna ek olarak, bir SELECT sorgusunda Yıldız İşareti kullanıldığında bu sütun değiştirilmez. Bu, dökümü kullanarak elde edilen değişmezi korumaktır `SELECT *` sütun listesini belirtmeden INSERT kullanarak tabloya geri eklenebilir. + +`ALIAS expr` + +Eşanlamlı sözcük. Böyle bir sütun tabloda hiç depolanmaz. +Değerleri bir tabloya eklenemez ve bir SELECT sorgusunda Yıldız İşareti kullanılırken değiştirilmez. +Sorgu ayrıştırma sırasında diğer ad genişletilirse, seçimlerde kullanılabilir. + +Yeni sütunlar eklemek için ALTER sorgusunu kullanırken, bu sütunlar için eski veriler yazılmaz. Bunun yerine, yeni sütunlar için değerleri olmayan eski verileri okurken, ifadeler varsayılan olarak anında hesaplanır. Ancak, ifadeleri çalıştırmak sorguda belirtilmeyen farklı sütunlar gerektiriyorsa, bu sütunlar ayrıca okunur, ancak yalnızca buna ihtiyaç duyan veri blokları için okunur. + +Bir tabloya yeni bir sütun eklerseniz, ancak daha sonra varsayılan ifadesini değiştirirseniz, eski veriler için kullanılan değerler değişir (değerlerin diskte depolanmadığı veriler için). Arka plan birleştirmeleri çalıştırırken, birleştirme parçalarından birinde eksik olan sütunların verileri birleştirilmiş parçaya yazıldığını unutmayın. + +İç içe geçmiş veri yapılarındaki öğeler için varsayılan değerleri ayarlamak mümkün değildir. + +### Kısıtlamalar {#constraints} + +Sütun açıklamaları kısıtlamaları ile birlikte tanımlanabilir: + +``` sql +CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster] +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1] [compression_codec] [TTL expr1], + ... + CONSTRAINT constraint_name_1 CHECK boolean_expr_1, + ... +) ENGINE = engine +``` + +`boolean_expr_1` herhangi bir Boole ifadesi ile olabilir. Tablo için kısıtlamalar tanımlanırsa, her biri her satır için kontrol edilir `INSERT` query. If any constraint is not satisfied — server will raise an exception with constraint name and checking expression. + +Büyük miktarda kısıtlama eklemek, büyük `INSERT` sorgular. + +### TTL ifadesi {#ttl-expression} + +Değerler için depolama süresini tanımlar. Sadece MergeTree-family tabloları için belirtilebilir. Ayrıntılı açıklama için, bkz. [Sütunlar ve tablolar için TTL](../../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-ttl). + +### Sütun Sıkıştırma Kodekleri {#codecs} + +Varsayılan olarak, ClickHouse `lz4` sıkıştırma yöntemi. İçin `MergeTree`- motor ailesi varsayılan sıkıştırma yöntemini değiştirebilirsiniz [sıkıştırma](../../operations/server_configuration_parameters/settings.md#server-settings-compression) bir sunucu yapılandırması bölümü. Her bir sütun için sıkıştırma yöntemini de tanımlayabilirsiniz. `CREATE TABLE` sorgu. + +``` sql +CREATE TABLE codec_example +( + dt Date CODEC(ZSTD), + ts DateTime CODEC(LZ4HC), + float_value Float32 CODEC(NONE), + double_value Float64 CODEC(LZ4HC(9)) + value Float32 CODEC(Delta, ZSTD) +) +ENGINE = +... +``` + +Bir codec bileşeni belirtilmişse, varsayılan codec bileşeni geçerli değildir. Kodekler bir boru hattında birleştirilebilir, örneğin, `CODEC(Delta, ZSTD)`. Projeniz için en iyi codec kombinasyonunu seçmek için, Altınlıkta açıklanana benzer kriterler geçirin [ClickHouse verimliliğini artırmak için yeni Kodlamalar](https://www.altinity.com/blog/2019/7/new-encodings-to-improve-clickhouse) makale. + +!!! warning "Uyarıcı" + ClickHouse veritabanı dosyalarını harici yardımcı programlarla açamazsınız `lz4`. Bunun yerine, özel kullanın [clickhouse-kompresör](https://github.com/ClickHouse/ClickHouse/tree/master/programs/compressor) program. + +Sıkıştırma Aşağıdaki tablo motorları için desteklenir: + +- [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md) aile. Sütun sıkıştırma kodeklerini destekler ve varsayılan sıkıştırma yöntemini seçerek [sıkıştırma](../../operations/server_configuration_parameters/settings.md#server-settings-compression) ayarlar. +- [Günlük](../../engines/table_engines/log_family/log_family.md) aile. Kullanır `lz4` sıkıştırma yöntemi varsayılan olarak ve sütun sıkıştırma codec destekler. +- [Koymak](../../engines/table_engines/special/set.md). Yalnızca varsayılan sıkıştırmayı destekledi. +- [Katmak](../../engines/table_engines/special/join.md). Yalnızca varsayılan sıkıştırmayı destekledi. + +ClickHouse ortak amaçlı codec ve özel codec destekler. + +#### Özel Kodekler {#create-query-specialized-codecs} + +Bu kodekler, verilerin belirli özelliklerini kullanarak sıkıştırmayı daha etkili hale getirmek için tasarlanmıştır. Bu kodeklerden bazıları verileri kendileri sıkıştırmaz. Bunun yerine, verileri ortak bir amaç için hazırlarlar codec, bu hazırlık olmadan daha iyi sıkıştırır. + +Özel kodekler: + +- `Delta(delta_bytes)` — Compression approach in which raw values are replaced by the difference of two neighboring values, except for the first value that stays unchanged. Up to `delta_bytes` delta değerlerini saklamak için kullanılır, böylece `delta_bytes` ham değerlerin maksimum boyutudur. Olası `delta_bytes` değerler: 1, 2, 4, 8. İçin varsayılan değer `delta_bytes` oluyor `sizeof(type)` 1, 2, 4 veya 8'e eşitse. Diğer tüm durumlarda, 1. +- `DoubleDelta` — Calculates delta of deltas and writes it in compact binary form. Optimal compression rates are achieved for monotonic sequences with a constant stride, such as time series data. Can be used with any fixed-width type. Implements the algorithm used in Gorilla TSDB, extending it to support 64-bit types. Uses 1 extra bit for 32-byte deltas: 5-bit prefixes instead of 4-bit prefixes. For additional information, see Compressing Time Stamps in [Gorilla: Hızlı, Ölçeklenebilir, Bellek İçi Zaman Serisi Veritabanı](http://www.vldb.org/pvldb/vol8/p1816-teller.pdf). +- `Gorilla` — Calculates XOR between current and previous value and writes it in compact binary form. Efficient when storing a series of floating point values that change slowly, because the best compression rate is achieved when neighboring values are binary equal. Implements the algorithm used in Gorilla TSDB, extending it to support 64-bit types. For additional information, see Compressing Values in [Gorilla: Hızlı, Ölçeklenebilir, Bellek İçi Zaman Serisi Veritabanı](http://www.vldb.org/pvldb/vol8/p1816-teller.pdf). +- `T64` — Compression approach that crops unused high bits of values in integer data types (including `Enum`, `Date` ve `DateTime`). Algoritmasının her adımında, codec 64 değerden oluşan bir blok alır, 64x64 bit matrisine koyar, aktarır, kullanılmayan değer bitlerini kırpar ve gerisini bir dizi olarak döndürür. Kullanılmayan bitler, sıkıştırmanın kullanıldığı tüm veri bölümündeki maksimum ve minimum değerler arasında farklılık göstermeyen bitlerdir. + +`DoubleDelta` ve `Gorilla` kodekler, Gorilla TSDB'DE sıkıştırma algoritmasının bileşenleri olarak kullanılır. Gorilla yaklaşımı, zaman damgaları ile yavaş yavaş değişen değerler dizisi olduğunda senaryolarda etkilidir. Zaman damgaları tarafından etkili bir şekilde sıkıştırılır `DoubleDelta` codec ve değerler etkin bir şekilde sıkıştırılır `Gorilla` codec. Örneğin, etkili bir şekilde saklanan bir tablo elde etmek için, aşağıdaki yapılandırmada oluşturabilirsiniz: + +``` sql +CREATE TABLE codec_example +( + timestamp DateTime CODEC(DoubleDelta), + slow_values Float32 CODEC(Gorilla) +) +ENGINE = MergeTree() +``` + +#### Ortak Amaç {#create-query-common-purpose-codecs} + +Cod codecsec codecs'ler: + +- `NONE` — No compression. +- `LZ4` — Lossless [veri sıkıştırma algoritması](https://github.com/lz4/lz4) varsayılan olarak kullanılır. Lz4 hızlı sıkıştırma uygular. +- `LZ4HC[(level)]` — LZ4 HC (high compression) algorithm with configurable level. Default level: 9. Setting `level <= 0` varsayılan düzeyi uygular. Olası seviyeleri: \[1, 12\]. Önerilen seviye aralığı: \[4, 9\]. +- `ZSTD[(level)]` — [Zstd sıkıştırma algoritması](https://en.wikipedia.org/wiki/Zstandard) yapılandırılabilir ile `level`. Olası seviyeler: \[1, 22\]. Varsayılan değer: 1. + +Yüksek Sıkıştırma seviyeleri asimetrik senaryolar için kullanışlıdır, örneğin bir kez sıkıştırın, tekrar tekrar sıkıştırın. Daha yüksek seviyeler daha iyi sıkıştırma ve daha yüksek CPU kullanımı anlamına gelir. + +## Geçici Tablolar {#temporary-tables} + +ClickHouse aşağıdaki özelliklere sahip geçici tabloları destekler: + +- Bağlantı kaybolursa da dahil olmak üzere oturum sona erdiğinde geçici tablolar kaybolur. +- Geçici bir tablo yalnızca bellek altyapısını kullanır. +- DB geçici bir tablo için belirtilemez. Veritabanları dışında oluşturulur. +- Tüm küme sunucularında dağıtılmış DDL sorgusu ile geçici bir tablo oluşturmak imkansız (kullanarak `ON CLUSTER`): bu tablo yalnızca geçerli oturumda bulunur. +- Geçici bir tablo başka bir ile aynı ada sahip ve bir sorgu DB belirtmeden tablo adını belirtir, geçici tablo kullanılır. +- Dağıtılmış sorgu işleme için bir sorguda kullanılan geçici tablolar uzak sunuculara geçirilir. + +Geçici bir tablo oluşturmak için aşağıdaki sözdizimini kullanın: + +``` sql +CREATE TEMPORARY TABLE [IF NOT EXISTS] table_name +( + name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1], + name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2], + ... +) +``` + +Çoğu durumda, geçici tablolar el ile oluşturulmaz, ancak bir sorgu için veya dağıtılmış için dış verileri kullanırken `(GLOBAL) IN`. Daha fazla bilgi için uygun bölümlere bakın + +İle tabloları kullanmak mümkündür [Motor = bellek](../../engines/table_engines/special/memory.md) geçici tablolar yerine. + +## Dağıtılmış DDL sorguları (küme yan tümcesinde) {#distributed-ddl-queries-on-cluster-clause} + +Bu `CREATE`, `DROP`, `ALTER`, ve `RENAME` sorgular, bir kümede dağıtılmış yürütmeyi destekler. +Örneğin, aşağıdaki sorgu oluşturur `all_hits` `Distributed` her ana bilgisayarda tablo `cluster`: + +``` sql +CREATE TABLE IF NOT EXISTS all_hits ON CLUSTER cluster (p Date, i Int32) ENGINE = Distributed(cluster, default, hits) +``` + +Bu sorguları doğru bir şekilde çalıştırmak için, her ana bilgisayarın aynı küme tanımına sahip olması gerekir (senkronizasyon yapılandırmalarını basitleştirmek için zookeeper'dan değiştirmeleri kullanabilirsiniz). Ayrıca ZooKeeper sunucularına bağlanmaları gerekir. +Bazı ana bilgisayarlar şu anda mevcut olmasa bile, sorgunun yerel sürümü sonunda kümedeki her ana bilgisayarda uygulanır. Tek bir ana makine içinde sorguları yürütme sırası garanti edilir. + +## CREATE VIEW {#create-view} + +``` sql +CREATE [MATERIALIZED] VIEW [IF NOT EXISTS] [db.]table_name [TO[db.]name] [ENGINE = engine] [POPULATE] AS SELECT ... +``` + +Bir görünüm oluşturur. İki tür görüş vardır: normal ve SOMUTLAŞTIRILMIŞ. + +Normal görünümler herhangi bir veri depolamaz, ancak başka bir tablodan bir okuma gerçekleştirir. Başka bir deyişle, normal bir görünüm kaydedilmiş bir sorgudan başka bir şey değildir. Bir görünümden okurken, bu kaydedilmiş sorgu FROM yan tümcesinde bir alt sorgu olarak kullanılır. + +Örnek olarak, bir görünüm oluşturduğunuzu varsayalım: + +``` sql +CREATE VIEW view AS SELECT ... +``` + +ve bir sorgu yazdı: + +``` sql +SELECT a, b, c FROM view +``` + +Bu sorgu, alt sorguyu kullanmaya tam olarak eşdeğerdir: + +``` sql +SELECT a, b, c FROM (SELECT ...) +``` + +Materialized görünümler, ilgili SELECT sorgusu tarafından dönüştürülmüş verileri depolar. + +Olmadan hayata bir görünüm oluştururken `TO [db].[table]`, you must specify ENGINE – the table engine for storing data. + +İle somutlaştırılmış bir görünüm oluştururken `TO [db].[table]`, kullanma mustmalısınız `POPULATE`. + +Materialized görünüm aşağıdaki gibi düzenlenmiştir: SELECT belirtilen tabloya veri eklerken, eklenen verilerin bir kısmı bu SELECT sorgusu tarafından dönüştürülür ve sonuç görünümde eklenir. + +Doldur belirtirseniz, varolan tablo verilerini oluştururken görünümde, sanki bir `CREATE TABLE ... AS SELECT ...` . Aksi takdirde, sorgu yalnızca görünümü oluşturduktan sonra tabloya eklenen verileri içerir. Görünüm oluşturma sırasında tabloya eklenen veriler EKLENMEYECEĞİNDEN, doldur kullanmanızı önermiyoruz. + +A `SELECT` sorgu içerebilir `DISTINCT`, `GROUP BY`, `ORDER BY`, `LIMIT`… Note that the corresponding conversions are performed independently on each block of inserted data. For example, if `GROUP BY` ayarlanır, veri ekleme sırasında toplanır, ancak yalnızca tek bir eklenen veri paketi içinde toplanır. Veriler daha fazla toplanmayacaktır. Özel durum, bağımsız olarak veri toplama, gibi gerçekleştiren bir motor kullanırken olur `SummingMergeTree`. + +Yürütme `ALTER` somut görünümlerle ilgili sorgular tam olarak geliştirilmemiştir, bu nedenle rahatsız edici olabilirler. Eğer hayata görünüm inşaat kullanıyorsa `TO [db.]name` yapabilirsiniz `DETACH` the view, run `ALTER` hedef tablo için ve sonra `ATTACH` daha önce müstakil (`DETACH`) görünüm. + +Görünümler normal tablolarla aynı görünür. Örneğin, bunlar sonucu listelenir `SHOW TABLES` sorgu. + +Görünümleri silmek için ayrı bir sorgu yok. Bir görünümü silmek için şunları kullanın `DROP TABLE`. + +## CREATE DICTIONARY {#create-dictionary-query} + +``` sql +CREATE DICTIONARY [IF NOT EXISTS] [db.]dictionary_name [ON CLUSTER cluster] +( + key1 type1 [DEFAULT|EXPRESSION expr1] [HIERARCHICAL|INJECTIVE|IS_OBJECT_ID], + key2 type2 [DEFAULT|EXPRESSION expr2] [HIERARCHICAL|INJECTIVE|IS_OBJECT_ID], + attr1 type2 [DEFAULT|EXPRESSION expr3], + attr2 type2 [DEFAULT|EXPRESSION expr4] +) +PRIMARY KEY key1, key2 +SOURCE(SOURCE_NAME([param1 value1 ... paramN valueN])) +LAYOUT(LAYOUT_NAME([param_name param_value])) +LIFETIME([MIN val1] MAX val2) +``` + +Oluşturuyor [dış sözlük](../../sql_reference/dictionaries/external_dictionaries/external_dicts.md) verilen ile [yapılı](../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_structure.md), [kaynaklı](../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_sources.md), [düzen](../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_layout.md) ve [ömür](../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_lifetime.md). + +Dış sözlük yapısı özniteliklerden oluşur. Sözlük öznitelikleri tablo sütunlarına benzer şekilde belirtilir. Tek gerekli öznitelik özelliği türüdür, diğer tüm özelliklerin varsayılan değerleri olabilir. + +Sözlüğe bağlı olarak [düzen](../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_layout.md) bir veya daha fazla öznitelik sözlük anahtarları olarak belirtilebilir. + +Daha fazla bilgi için, bkz. [Dış Söz Dictionarieslükler](../../sql_reference/dictionaries/external_dictionaries/external_dicts.md) bölme. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/create/) diff --git a/docs/tr/sql_reference/statements/index.md b/docs/tr/sql_reference/statements/index.md new file mode 100644 index 00000000000..0298948b26e --- /dev/null +++ b/docs/tr/sql_reference/statements/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: Deyimler +toc_priority: 31 +--- + + diff --git a/docs/tr/sql_reference/statements/insert_into.md b/docs/tr/sql_reference/statements/insert_into.md new file mode 100644 index 00000000000..1aafdc368e9 --- /dev/null +++ b/docs/tr/sql_reference/statements/insert_into.md @@ -0,0 +1,80 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 34 +toc_title: INSERT INTO +--- + +## INSERT {#insert} + +Veri ekleme. + +Temel sorgu biçimi: + +``` sql +INSERT INTO [db.]table [(c1, c2, c3)] VALUES (v11, v12, v13), (v21, v22, v23), ... +``` + +Sorgu eklemek için sütunların bir listesini belirtebilirsiniz `[(c1, c2, c3)]`. Bu durumda, sütunların geri kalanı ile doldurulur: + +- Hesaplanan değerler `DEFAULT` tablo tanımında belirtilen ifadeler. +- Sıfırlar ve boş dizeler, eğer `DEFAULT` ifadeler tanımlanmamıştır. + +Eğer [strict\_ınsert\_defaults = 1](../../operations/settings/settings.md), sahip olmayan sütunlar `DEFAULT` tanımlanan sorguda listelenmelidir. + +Veri herhangi bir İNSERT geçirilebilir [biçimli](../../interfaces/formats.md#formats) ClickHouse tarafından desteklenmektedir. Biçim sorguda açıkça belirtilmelidir: + +``` sql +INSERT INTO [db.]table [(c1, c2, c3)] FORMAT format_name data_set +``` + +For example, the following query format is identical to the basic version of INSERT … VALUES: + +``` sql +INSERT INTO [db.]table [(c1, c2, c3)] FORMAT Values (v11, v12, v13), (v21, v22, v23), ... +``` + +ClickHouse, veriden önce tüm boşlukları ve bir satır beslemesini (varsa) kaldırır. Bir sorgu oluştururken, sorgu işleçlerinden sonra verileri yeni bir satıra koymanızı öneririz (veriler boşluklarla başlarsa bu önemlidir). + +Örnek: + +``` sql +INSERT INTO t FORMAT TabSeparated +11 Hello, world! +22 Qwerty +``` + +Komut satırı istemcisini veya HTTP arabirimini kullanarak verileri sorgudan ayrı olarak ekleyebilirsiniz. Daha fazla bilgi için bölüme bakın “[Arabirimler](../../interfaces/index.md#interfaces)”. + +### Kısıtlamalar {#constraints} + +Tablo varsa [kısıtlamalar](create.md#constraints), their expressions will be checked for each row of inserted data. If any of those constraints is not satisfied — server will raise an exception containing constraint name and expression, the query will be stopped. + +### Sonuçları Ekleme `SELECT` {#insert_query_insert-select} + +``` sql +INSERT INTO [db.]table [(c1, c2, c3)] SELECT ... +``` + +Sütunlar, SELECT yan tümcesindeki konumlarına göre eşleştirilir. Ancak, SELECT ifadesi ve INSERT için tablo adları farklı olabilir. Gerekirse, tip döküm yapılır. + +Değerler dışındaki veri biçimlerinin hiçbiri, aşağıdaki gibi ifadelere değerler ayarlamasına izin vermez `now()`, `1 + 2` ve bu yüzden. Değerler biçimi, ifadelerin sınırlı kullanımına izin verir, ancak bu önerilmez, çünkü bu durumda verimsiz kod yürütme için kullanılır. + +Veri bölümlerini değiştirmek için diğer sorgular desteklenmiyor: `UPDATE`, `DELETE`, `REPLACE`, `MERGE`, `UPSERT`, `INSERT UPDATE`. +Ancak, eski verileri kullanarak silebilirsiniz `ALTER TABLE ... DROP PARTITION`. + +`FORMAT` yan tümcesi sorgu sonunda belirtilmelidir eğer `SELECT` yan tümcesi tablo işlevi içerir [girdi()](../table_functions/input.md). + +### Performans Konuları {#performance-considerations} + +`INSERT` giriş verilerini birincil anahtarla sıralar ve bunları bir bölüm anahtarı ile bölümlere ayırır. Bir kerede birkaç bölüme veri eklerseniz, bu veri tabanının performansını önemli ölçüde azaltabilir. `INSERT` sorgu. Bunu önlemek için: + +- Bir seferde 100.000 satır gibi oldukça büyük gruplar halinde veri ekleyin. +- Clickhouse'a yüklemeden önce verileri bir bölüm anahtarıyla gruplandırın. + +Eğer performans azalmaz: + +- Veri gerçek zamanlı olarak eklenir. +- Genellikle zamana göre sıralanır veri yükleyin. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/insert_into/) diff --git a/docs/tr/sql_reference/statements/misc.md b/docs/tr/sql_reference/statements/misc.md new file mode 100644 index 00000000000..689fc8cd77d --- /dev/null +++ b/docs/tr/sql_reference/statements/misc.md @@ -0,0 +1,252 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 39 +toc_title: "Di\u011Fer" +--- + +# Çeşitli Sorgular {#miscellaneous-queries} + +## ATTACH {#attach} + +Bu sorgu tam olarak aynıdır `CREATE`, ama + +- Kelime yerine `CREATE` kelime kullanır `ATTACH`. +- Sorgu diskte veri oluşturmaz, ancak verilerin zaten uygun yerlerde olduğunu ve yalnızca tablo hakkında bilgi sunucuya eklediğini varsayar. + Bir ekleme sorgusu çalıştırdıktan sonra, sunucu tablonun varlığı hakkında bilgi sahibi olacaktır. + +Tablo daha önce ayrılmış olsaydı (`DETACH`), yapısının bilindiği anlamına gelir, yapıyı tanımlamadan steno kullanabilirsiniz. + +``` sql +ATTACH TABLE [IF NOT EXISTS] [db.]name [ON CLUSTER cluster] +``` + +Bu sorgu, sunucu başlatılırken kullanılır. Sunucu, tablo meta verilerini dosyalar olarak depolar `ATTACH` başlangıçta çalıştığı sorgular (sunucuda açıkça oluşturulan sistem tabloları hariç). + +## CHECK TABLE {#check-table} + +Tablodaki verilerin bozuk olup olmadığını denetler. + +``` sql +CHECK TABLE [db.]name +``` + +Bu `CHECK TABLE` sorgu, gerçek dosya boyutlarını sunucuda depolanan beklenen değerlerle karşılaştırır. Dosya boyutları depolanan değerlerle eşleşmiyorsa, verilerin bozuk olduğu anlamına gelir. Bu, örneğin, sorgu yürütme sırasında bir sistem çökmesine neden olabilir. + +Sorgu yanıtı içerir `result` tek satırlı sütun. Satır bir değere sahiptir +[Boeanoleanean](../../sql_reference/data_types/boolean.md) tür: + +- 0-tablodaki veriler bozuk. +- 1 - veri bütünlüğünü korur. + +Bu `CHECK TABLE` sorgu Aşağıdaki tablo motorlarını destekler: + +- [Günlük](../../engines/table_engines/log_family/log.md) +- [TinyLog](../../engines/table_engines/log_family/tinylog.md) +- [StripeLog](../../engines/table_engines/log_family/stripelog.md) +- [MergeTree ailesi](../../engines/table_engines/mergetree_family/mergetree.md) + +Başka bir tablo motorları ile tablolar üzerinde gerçekleştirilen bir özel duruma neden olur. + +Motor fromlardan `*Log` aile başarısızlık otomatik veri kurtarma sağlamaz. Kullan... `CHECK TABLE` veri kaybını zamanında izlemek için sorgu. + +İçin `MergeTree` aile motorları, `CHECK TABLE` sorgu, yerel sunucudaki bir tablonun her bir veri bölümü için bir kontrol durumunu gösterir. + +**Veri bozuksa** + +Tablo bozuksa, bozuk olmayan verileri başka bir tabloya kopyalayabilirsiniz. Bunu yapmak için : + +1. Bozuk tablo ile aynı yapıya sahip yeni bir tablo oluşturun. Bunu yapmak için sorguyu yürütün `CREATE TABLE AS `. +2. Ayarla... [max\_threads](../../operations/settings/settings.md#settings-max_threads) bir sonraki sorguyu tek bir iş parçacığında işlemek için 1 değeri. Bunu yapmak için sorguyu çalıştırın `SET max_threads = 1`. +3. Sorgu yürütme `INSERT INTO SELECT * FROM `. Bu istek bozuk olmayan verileri bozuk tablodan başka bir tabloya kopyalar. Yalnızca bozuk parçadan önceki veriler kopyalanır. +4. Yeniden Başlat `clickhouse-client` sıfırlamak için `max_threads` değer. + +## DESCRIBE TABLE {#misc-describe-table} + +``` sql +DESC|DESCRIBE TABLE [db.]table [INTO OUTFILE filename] [FORMAT format] +``` + +Aşağıdaki döndürür `String` sütun tipi: + +- `name` — Column name. +- `type`— Column type. +- `default_type` — Clause that is used in [varsayılan ifade](create.md#create-default-values) (`DEFAULT`, `MATERIALIZED` veya `ALIAS`). Varsayılan ifade belirtilmemişse, sütun boş bir dize içerir. +- `default_expression` — Value specified in the `DEFAULT` yan. +- `comment_expression` — Comment text. + +İç içe veri yapıları çıktı “expanded” biçimli. Her sütun ayrı ayrı gösterilir, bir noktadan sonra adı ile. + +## DETACH {#detach} + +Hakkında bilgi siler ‘name’ sunucudan tablo. Sunucu, tablonun varlığını bilmeyi durdurur. + +``` sql +DETACH TABLE [IF EXISTS] [db.]name [ON CLUSTER cluster] +``` + +Bu tablonun veri veya meta verileri silmez. Bir sonraki sunucu lansmanında, sunucu meta verileri okuyacak ve tablo hakkında tekrar bilgi edinecektir. +Benzer şekilde, bir “detached” tablo kullanılarak yeniden eklenebilir `ATTACH` sorgu (bunlar için depolanan meta verilere sahip olmayan sistem tabloları hariç). + +Hiç yok... `DETACH DATABASE` sorgu. + +## DROP {#drop} + +Bu sorgu iki türü vardır: `DROP DATABASE` ve `DROP TABLE`. + +``` sql +DROP DATABASE [IF EXISTS] db [ON CLUSTER cluster] +``` + +İçindeki tüm tabloları siler ‘db’ veritabanı, daha sonra siler ‘db’ veritabanı kendisi. +Eğer `IF EXISTS` belirtilen, veritabanı yoksa bir hata döndürmez. + +``` sql +DROP [TEMPORARY] TABLE [IF EXISTS] [db.]name [ON CLUSTER cluster] +``` + +Tabloyu siler. +Eğer `IF EXISTS` belirtilmişse, tablo yoksa veya veritabanı yoksa bir hata döndürmez. + + DROP DICTIONARY [IF EXISTS] [db.]name + +Sözlük Delets. +Eğer `IF EXISTS` belirtilmişse, tablo yoksa veya veritabanı yoksa bir hata döndürmez. + +## EXISTS {#exists} + +``` sql +EXISTS [TEMPORARY] [TABLE|DICTIONARY] [db.]name [INTO OUTFILE filename] [FORMAT format] +``` + +Bir tek döndürür `UInt8`- tek değeri içeren sütun yazın `0` tablo veya veritabanı yoksa veya `1` tablo belirtilen veritabanında varsa. + +## KILL QUERY {#kill-query} + +``` sql +KILL QUERY [ON CLUSTER cluster] + WHERE + [SYNC|ASYNC|TEST] + [FORMAT format] +``` + +Şu anda çalışan sorguları zorla sonlandırmaya çalışır. +Sonlandırılacak sorgular sistemden seçilir.tanımlanan kriterleri kullanarak işlemler tablosu `WHERE` fıkra ofsı `KILL` sorgu. + +Örnekler: + +``` sql +-- Forcibly terminates all queries with the specified query_id: +KILL QUERY WHERE query_id='2-857d-4a57-9ee0-327da5d60a90' + +-- Synchronously terminates all queries run by 'username': +KILL QUERY WHERE user='username' SYNC +``` + +Salt okunur kullanıcılar yalnızca kendi sorgularını durdurabilir. + +Varsayılan olarak, sorguların zaman uyumsuz sürümü kullanılır (`ASYNC`), sorguların durduğuna dair onay beklemez. + +Senkron versiyonu (`SYNC`) tüm sorguların durmasını bekler ve durduğunda her işlem hakkında bilgi görüntüler. +Yanıt içerir `kill_status` aşağıdaki değerleri alabilen sütun: + +1. ‘finished’ – The query was terminated successfully. +2. ‘waiting’ – Waiting for the query to end after sending it a signal to terminate. +3. The other values ​​explain why the query can't be stopped. + +Bir test sorgusu (`TEST`) yalnızca kullanıcının haklarını denetler ve durdurulacak sorguların bir listesini görüntüler. + +## KILL MUTATION {#kill-mutation} + +``` sql +KILL MUTATION [ON CLUSTER cluster] + WHERE + [TEST] + [FORMAT format] +``` + +İptal etmek ve kaldırmak için çalışır [mutasyonlar](alter.md#alter-mutations) şu anda yürütülüyor. İptal etmek için mutationsasyonlar seçilir [`system.mutations`](../../operations/system_tables.md#system_tables-mutations) tablo tarafından belirtilen filtreyi kullanarak `WHERE` fıkra ofsı `KILL` sorgu. + +Bir test sorgusu (`TEST`) yalnızca kullanıcının haklarını denetler ve durdurulacak sorguların bir listesini görüntüler. + +Örnekler: + +``` sql +-- Cancel and remove all mutations of the single table: +KILL MUTATION WHERE database = 'default' AND table = 'table' + +-- Cancel the specific mutation: +KILL MUTATION WHERE database = 'default' AND table = 'table' AND mutation_id = 'mutation_3.txt' +``` + +The query is useful when a mutation is stuck and cannot finish (e.g. if some function in the mutation query throws an exception when applied to the data contained in the table). + +Mutasyon tarafından yapılan değişiklikler geri alınmaz. + +## OPTIMIZE {#misc_operations-optimize} + +``` sql +OPTIMIZE TABLE [db.]name [ON CLUSTER cluster] [PARTITION partition | PARTITION ID 'partition_id'] [FINAL] [DEDUPLICATE] +``` + +Bu sorgu, bir tablo altyapısı ile tablolar için veri parçaları planlanmamış birleştirme başlatmaya çalışır. [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md) aile. + +Bu `OPTMIZE` sorgu için de desteklenmektedir [MaterializedView](../../engines/table_engines/special/materializedview.md) ve... [Arabellek](../../engines/table_engines/special/buffer.md) motorlar. Diğer tablo motorları desteklenmiyor. + +Ne zaman `OPTIMIZE` ile kullanılır [ReplicatedMergeTree](../../engines/table_engines/mergetree_family/replication.md) Tablo motorları ailesi, ClickHouse birleştirme için bir görev oluşturur ve tüm düğümlerde yürütülmeyi bekler (eğer `replication_alter_partitions_sync` ayar etkinse) ' dir. + +- Eğer `OPTIMIZE` herhangi bir nedenle bir birleştirme gerçekleştirmez, müşteriye bildirmez. Bildirimleri etkinleştirmek için [optimize\_throw\_if\_noop](../../operations/settings/settings.md#setting-optimize_throw_if_noop) ayar. +- Belirtir aseniz bir `PARTITION`, sadece belirtilen bölüm optimize edilmiştir. [Bölüm ifadesi nasıl ayarlanır](alter.md#alter-how-to-specify-part-expr). +- Belirtir specifyseniz `FINAL`, optimizasyon, tüm veriler zaten bir parçada olsa bile gerçekleştirilir. +- Belirtir specifyseniz `DEDUPLICATE`, sonra tamamen aynı satırlar tekilleştirilecektir (tüm sütunlar karşılaştırılır), sadece MergeTree motoru için anlamlıdır. + +!!! warning "Uyarıcı" + `OPTIMIZE` Düzelt canemiyorum “Too many parts” hatasız. + +## RENAME {#misc_operations-rename} + +Bir veya daha fazla tabloyu yeniden adlandırır. + +``` sql +RENAME TABLE [db11.]name11 TO [db12.]name12, [db21.]name21 TO [db22.]name22, ... [ON CLUSTER cluster] +``` + +Tüm tablolar genel kilitleme altında yeniden adlandırılır. Tabloları yeniden adlandırma hafif bir işlemdir. İÇİN'DEN sonra başka bir veritabanı belirttiyseniz, tablo bu veritabanına taşınacaktır. Ancak, veritabanlarına sahip dizinlerin aynı dosya sisteminde bulunması gerekir (aksi takdirde bir hata döndürülür). + +## SET {#query-set} + +``` sql +SET param = value +``` + +Atıyor `value` to the `param` [ayar](../../operations/settings/index.md) geçerli oturum için. Değiştiremezsiniz [sunucu ayarları](../../operations/server_configuration_parameters/index.md) bu şekilde. + +Belirtilen ayarlar profilindeki tüm değerleri tek bir sorguda da ayarlayabilirsiniz. + +``` sql +SET profile = 'profile-name-from-the-settings-file' +``` + +Daha fazla bilgi için, bkz. [Ayarlar](../../operations/settings/settings.md). + +## TRUNCATE {#truncate} + +``` sql +TRUNCATE TABLE [IF EXISTS] [db.]name [ON CLUSTER cluster] +``` + +Bir tablodaki tüm verileri kaldırır. Fık thera ne zaman `IF EXISTS` tablo yoksa, sorgu bir hata döndürür. + +Bu `TRUNCATE` sorgu için desteklenmiyor [Görünüm](../../engines/table_engines/special/view.md), [Dosya](../../engines/table_engines/special/file.md), [URL](../../engines/table_engines/special/url.md) ve [Boş](../../engines/table_engines/special/null.md) masa motorları. + +## USE {#use} + +``` sql +USE db +``` + +Oturum için geçerli veritabanını ayarlamanızı sağlar. +Geçerli veritabanı, veritabanı sorguda tablo adından önce bir nokta ile açıkça tanımlanmamışsa, tabloları aramak için kullanılır. +Bir oturum kavramı olmadığından, bu sorgu HTTP protokolünü kullanırken yapılamaz. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/misc/) diff --git a/docs/tr/sql_reference/statements/select.md b/docs/tr/sql_reference/statements/select.md new file mode 100644 index 00000000000..287a8029ee9 --- /dev/null +++ b/docs/tr/sql_reference/statements/select.md @@ -0,0 +1,610 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 33 +toc_title: SELECT +--- + +# Select Queries sözdizimi {#select-queries-syntax} + +`SELECT` veri alma gerçekleştirir. + +``` sql +[WITH expr_list|(subquery)] +SELECT [DISTINCT] expr_list +[FROM [db.]table | (subquery) | table_function] [FINAL] +[SAMPLE sample_coeff] +[ARRAY JOIN ...] +[GLOBAL] [ANY|ALL] [INNER|LEFT|RIGHT|FULL|CROSS] [OUTER] JOIN (subquery)|table USING columns_list +[PREWHERE expr] +[WHERE expr] +[GROUP BY expr_list] [WITH TOTALS] +[HAVING expr] +[ORDER BY expr_list] +[LIMIT [offset_value, ]n BY columns] +[LIMIT [n, ]m] +[UNION ALL ...] +[INTO OUTFILE filename] +[FORMAT format] +``` + +Tüm yan tümceleri isteğe bağlıdır, hemen sonra ifadelerin gerekli listesi hariç seçin. +Aşağıdaki yan tümceleri sorgu yürütme konveyör hemen hemen aynı sırada açıklanmıştır. + +Sorgu atlarsa `DISTINCT`, `GROUP BY` ve `ORDER BY` CLA andus Andes and the `IN` ve `JOIN` alt sorgular, sorgu o (1) RAM miktarını kullanarak tamamen akış işlenecektir. +Aksi takdirde, uygun kısıtlamalar belirtilmezse, sorgu çok fazla RAM tüketebilir: `max_memory_usage`, `max_rows_to_group_by`, `max_rows_to_sort`, `max_rows_in_distinct`, `max_bytes_in_distinct`, `max_rows_in_set`, `max_bytes_in_set`, `max_rows_in_join`, `max_bytes_in_join`, `max_bytes_before_external_sort`, `max_bytes_before_external_group_by`. Daha fazla bilgi için bölüme bakın “Settings”. Harici sıralama (geçici tabloları bir diske kaydetme) ve harici toplama kullanmak mümkündür. `The system does not have "merge join"`. + +### Fık WİTHRA ile {#with-clause} + +Bu bölüm, ortak tablo ifadeleri için destek sağlar ([CTE](https://en.wikipedia.org/wiki/Hierarchical_and_recursive_queries_in_SQL)), bazı sınırlamalar ile: +1. Özyinelemeli sorgular desteklenmiyor +2. Alt sorgu bölüm ile birlikte kullanıldığında, sonuç tam olarak bir satır ile skaler olmalıdır +3. İfadenin sonuçları alt sorgularda kullanılamaz +WITH yan tümcesi ifadeleri sonuçları SELECT yan tümcesi içinde kullanılabilir. + +Örnek 1: Sabit ifadeyi aşağıdaki gibi kullanma “variable” + +``` sql +WITH '2019-08-01 15:23:00' as ts_upper_bound +SELECT * +FROM hits +WHERE + EventDate = toDate(ts_upper_bound) AND + EventTime <= ts_upper_bound +``` + +Örnek 2: SELECT yan tümcesi sütun listesinden toplam(bayt) ifade sonucunu çıkarma + +``` sql +WITH sum(bytes) as s +SELECT + formatReadableSize(s), + table +FROM system.parts +GROUP BY table +ORDER BY s +``` + +Örnek 3: skaler alt sorgu sonuçlarını kullanma + +``` sql +/* this example would return TOP 10 of most huge tables */ +WITH + ( + SELECT sum(bytes) + FROM system.parts + WHERE active + ) AS total_disk_usage +SELECT + (sum(bytes) / total_disk_usage) * 100 AS table_disk_usage, + table +FROM system.parts +GROUP BY table +ORDER BY table_disk_usage DESC +LIMIT 10 +``` + +Örnek 4: alt sorguda ifadeyi yeniden kullanma +Alt sorgularda ifade kullanımı için geçerli sınırlama için bir geçici çözüm olarak çoğaltabilirsiniz. + +``` sql +WITH ['hello'] AS hello +SELECT + hello, + * +FROM +( + WITH ['hello'] AS hello + SELECT hello +) +``` + +``` text +┌─hello─────┬─hello─────┐ +│ ['hello'] │ ['hello'] │ +└───────────┴───────────┘ +``` + +### Fık FROMRAS FROMINDAN {#select-from} + +FROM yan tümcesi atlanırsa, veriler `system.one` Tablo. +Bu `system.one` tablo tam olarak bir satır içerir (bu tablo diğer Dbms'lerde bulunan çift tablo ile aynı amacı yerine getirir). + +Bu `FROM` yan tümcesi veri okumak için kaynak belirtir: + +- Tablo +- Alt sorgu +- [Tablo fonksiyonu](../table_functions/index.md) + +`ARRAY JOIN` ve düzenli `JOIN` ayrıca dahil edilebilir (aşağıya bakınız). + +Bunun yerine bir tablo, `SELECT` alt sorgu parantez içinde belirtilebilir. +Standart SQL aksine, bir eşanlamlı bir alt sorgudan sonra belirtilmesi gerekmez. + +Bir sorguyu yürütmek için, sorguda listelenen tüm sütunlar uygun tablodan ayıklanır. Dış sorgu için gerekli olmayan tüm sütunlar alt sorgulardan atılır. +Bir sorgu herhangi bir sütun listelemezse (örneğin, `SELECT count() FROM t`), satır sayısını hesaplamak için yine de tablodan bir sütun çıkarılır (en küçük olanı tercih edilir). + +#### Son değiştirici {#select-from-final} + +Tablolardan veri seçerken uygulanabilir [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md)- motor ailesi dışında `GraphiteMergeTree`. Ne zaman `FINAL` belirtilen, ClickHouse sonucu döndürmeden önce verileri tam olarak birleştirir ve böylece verilen tablo altyapısı için birleştirmeler sırasında gerçekleşen tüm veri dönüşümlerini gerçekleştirir. + +Ayrıca için desteklenen: +- [Çoğaltıyordu](../../engines/table_engines/mergetree_family/replication.md) sürümleri `MergeTree` motorlar. +- [Görünüm](../../engines/table_engines/special/view.md), [Arabellek](../../engines/table_engines/special/buffer.md), [Dağılı](../../engines/table_engines/special/distributed.md), ve [MaterializedView](../../engines/table_engines/special/materializedview.md) üzerinden oluşturul ,maları koşuluyla diğer motorlar üzerinde çalışan motorlar `MergeTree`- motor masaları. + +Kullanan sorgular `FINAL` olmayan benzer sorgular kadar hızlı Yürüt ,ülür, çünkü: + +- Sorgu tek bir iş parçacığında yürütülür ve veri sorgu yürütme sırasında birleştirilir. +- İle sorgular `FINAL` sorguda belirtilen sütunlara ek olarak birincil anahtar sütunlarını okuyun. + +Çoğu durumda, kullanmaktan kaçının `FINAL`. + +### Örnek Madde {#select-sample-clause} + +Bu `SAMPLE` yan tümcesi yaklaşık sorgu işleme için izin verir. + +Veri örneklemesi etkinleştirildiğinde, sorgu tüm veriler üzerinde değil, yalnızca belirli bir veri kesirinde (örnek) gerçekleştirilir. Örneğin, tüm ziyaretler için istatistikleri hesaplamanız gerekiyorsa, sorguyu tüm ziyaretlerin 1/10 kesirinde yürütmek ve ardından sonucu 10 ile çarpmak yeterlidir. + +Yaklaşık sorgu işleme aşağıdaki durumlarda yararlı olabilir: + +- Sıkı zamanlama gereksinimleriniz olduğunda (\<100ms gibi), ancak bunları karşılamak için ek donanım kaynaklarının maliyetini haklı çıkaramazsınız. +- Ham verileriniz doğru olmadığında, yaklaşım kaliteyi belirgin şekilde düşürmez. +- İş gereksinimleri yaklaşık sonuçları hedef alır (maliyet etkinliği için veya kesin sonuçları premium kullanıcılara pazarlamak için). + +!!! note "Not" + Örneklemeyi yalnızca aşağıdaki tablolarla kullanabilirsiniz: [MergeTree](../../engines/table_engines/mergetree_family/mergetree.md) tablo oluşturma sırasında örnekleme ifadesi belirtilmişse (bkz [MergeTree motoru](../../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-creating-a-table)). + +Veri örneklemesinin özellikleri aşağıda listelenmiştir: + +- Veri örneklemesi deterministik bir mekanizmadır. Aynı sonucu `SELECT .. SAMPLE` sorgu her zaman aynıdır. +- Örnekleme, farklı tablolar için sürekli olarak çalışır. Tek bir örnekleme anahtarına sahip tablolar için, aynı katsayıya sahip bir örnek her zaman olası verilerin aynı alt kümesini seçer. Örneğin, kullanıcı kimlikleri örneği, farklı tablolardan olası tüm kullanıcı kimliklerinin aynı alt kümesine sahip satırları alır. Bu, örneği alt sorgularda kullanabileceğiniz anlamına gelir. [IN](#select-in-operators) yan. Ayrıca, kullanarak örnekleri katılabilir [JOIN](#select-join) yan. +- Örnekleme, bir diskten daha az veri okumayı sağlar. Örnekleme anahtarını doğru belirtmeniz gerektiğini unutmayın. Daha fazla bilgi için, bkz. [MergeTree tablosu oluşturma](../../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-creating-a-table). + +İçin `SAMPLE` yan tümcesi aşağıdaki sözdizimi desteklenir: + +| SAMPLE Clause Syntax | Açıklama | +|----------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| +| `SAMPLE k` | Burada `k` 0'dan 1'e kadar olan sayıdır.
Sorgu üzerinde yürütülür `k` verilerin kesir. Mesela, `SAMPLE 0.1` sorguyu verilerin %10'unda çalıştırır. [Daha fazla bilgi edinin](#select-sample-k) | +| `SAMPLE n` | Burada `n` yeterince büyük bir tamsayıdır.
Sorgu en az bir örnek üzerinde yürütülür `n` satırlar (ancak bundan önemli ölçüde daha fazla değil). Mesela, `SAMPLE 10000000` sorguyu en az 10.000.000 satır çalıştırır. [Daha fazla bilgi edinin](#select-sample-n) | +| `SAMPLE k OFFSET m` | Burada `k` ve `m` 0'dan 1'e kadar olan sayılardır.
Sorgu bir örnek üzerinde yürütülür `k` verilerin kesir. Örnek için kullanılan veriler, `m` bölme. [Daha fazla bilgi edinin](#select-sample-offset) | + +#### SAMPLE K {#select-sample-k} + +Burada `k` 0'dan 1'e kadar olan sayıdır (hem kesirli hem de ondalık gösterimler desteklenir). Mesela, `SAMPLE 1/2` veya `SAMPLE 0.5`. + +İn a `SAMPLE k` fık ,ra, örnek alınır `k` verilerin kesir. Örnek aşağıda gösterilmiştir: + +``` sql +SELECT + Title, + count() * 10 AS PageViews +FROM hits_distributed +SAMPLE 0.1 +WHERE + CounterID = 34 +GROUP BY Title +ORDER BY PageViews DESC LIMIT 1000 +``` + +Bu örnekte, sorgu 0.1 (%10) veri örneği üzerinde yürütülür. Toplam fonksiyonların değerleri otomatik olarak düzeltilmez, bu nedenle yaklaşık bir sonuç elde etmek için, değer `count()` elle 10 ile çarpılır. + +#### SAMPLE N {#select-sample-n} + +Burada `n` yeterince büyük bir tamsayıdır. Mesela, `SAMPLE 10000000`. + +Bu durumda, sorgu en az bir örnek üzerinde yürütülür `n` satırlar (ancak bundan önemli ölçüde daha fazla değil). Mesela, `SAMPLE 10000000` sorguyu en az 10.000.000 satır çalıştırır. + +Veri okuma için minimum birim bir granül olduğundan (boyutu `index_granularity` ayar), granülün boyutundan çok daha büyük bir örnek ayarlamak mantıklıdır. + +Kullanırken `SAMPLE n` yan tümce, verilerin hangi göreli yüzde işlendiğini bilmiyorsunuz. Yani toplam fonksiyonların çarpılması gereken katsayıyı bilmiyorsunuz. Kullan... `_sample_factor` sanal sütun yaklaşık sonucu almak için. + +Bu `_sample_factor` sütun dinamik olarak hesaplanan göreli katsayıları içerir. Bu sütun otomatik olarak oluşturulduğunda [oluşturmak](../../engines/table_engines/mergetree_family/mergetree.md#table_engine-mergetree-creating-a-table) belirtilen örnekleme anahtarına sahip bir tablo. Kullanım örnekleri `_sample_factor` sütun aşağıda gösterilmiştir. + +Masayı düşünelim `visits`, site ziyaretleri ile ilgili istatistikleri içerir. İlk örnek, sayfa görünümlerinin sayısını nasıl hesaplayacağınızı gösterir: + +``` sql +SELECT sum(PageViews * _sample_factor) +FROM visits +SAMPLE 10000000 +``` + +Bir sonraki örnek, toplam ziyaret sayısını nasıl hesaplayacağınızı gösterir: + +``` sql +SELECT sum(_sample_factor) +FROM visits +SAMPLE 10000000 +``` + +Aşağıdaki örnek, ortalama oturum süresinin nasıl hesaplanacağını göstermektedir. Ortalama değerleri hesaplamak için göreli katsayıyı kullanmanız gerekmediğini unutmayın. + +``` sql +SELECT avg(Duration) +FROM visits +SAMPLE 10000000 +``` + +#### SAMPLE K OFFSET M {#select-sample-offset} + +Burada `k` ve `m` 0'dan 1'e kadar olan sayılardır. Örnekler aşağıda gösterilmiştir. + +**Örnek 1** + +``` sql +SAMPLE 1/10 +``` + +Bu örnekte, örnek tüm verilerin 1/10'udur: + +`[++------------]` + +**Örnek 2** + +``` sql +SAMPLE 1/10 OFFSET 1/2 +``` + +Burada, verilerin ikinci yarısından %10'luk bir örnek alınır. + +`[------++------]` + +### Dizi Jo JOİNİN yan tüm Clausecesi {#select-array-join-clause} + +Yürüt allowsmeyi sağlar `JOIN` bir dizi veya iç içe veri yapısı ile. Niyet benzer [arrayJoin](../../sql_reference/functions/array_join.md#functions_arrayjoin) işlev, ancak işlevselliği daha geniştir. + +``` sql +SELECT +FROM +[LEFT] ARRAY JOIN +[WHERE|PREWHERE ] +... +``` + +Yalnızca bir tek belirtebilirsiniz `ARRAY JOIN` bir sorguda yan tümcesi. + +Sorgu yürütme sırası çalışırken en iyi duruma getirilmiştir `ARRAY JOIN`. Rağmen `ARRAY JOIN` her zaman önce belirtilmelidir `WHERE/PREWHERE` fık ,ra, daha önce de yapılabilir `WHERE/PREWHERE` (sonuç bu maddede gerekliyse) veya tamamladıktan sonra (hesaplamaların hacmini azaltmak için). İşlem sırası sorgu iyileştiricisi tarafından denetlenir. + +Desteklenen türleri `ARRAY JOIN` aşağıda listelenmiştir: + +- `ARRAY JOIN` - Bu durumda, boş diziler sonucu dahil değildir `JOIN`. +- `LEFT ARRAY JOIN` Bunun sonucu `JOIN` boş dizilere sahip satırlar içerir. Boş bir dizinin değeri, dizi öğesi türü için varsayılan değere ayarlanır (genellikle 0, boş dize veya NULL). + +Aşağıdaki örnekler kullanımını göstermektedir `ARRAY JOIN` ve `LEFT ARRAY JOIN` yanlar. Bir tablo oluşturalım [Dizi](../../sql_reference/data_types/array.md) sütun yazın ve içine değerler ekleyin: + +``` sql +CREATE TABLE arrays_test +( + s String, + arr Array(UInt8) +) ENGINE = Memory; + +INSERT INTO arrays_test +VALUES ('Hello', [1,2]), ('World', [3,4,5]), ('Goodbye', []); +``` + +``` text +┌─s───────────┬─arr─────┐ +│ Hello │ [1,2] │ +│ World │ [3,4,5] │ +│ Goodbye │ [] │ +└─────────────┴─────────┘ +``` + +Aşağıdaki örnek kullanır `ARRAY JOIN` yan: + +``` sql +SELECT s, arr +FROM arrays_test +ARRAY JOIN arr; +``` + +``` text +┌─s─────┬─arr─┐ +│ Hello │ 1 │ +│ Hello │ 2 │ +│ World │ 3 │ +│ World │ 4 │ +│ World │ 5 │ +└───────┴─────┘ +``` + +Sonraki örnek kullanımlar `LEFT ARRAY JOIN` yan: + +``` sql +SELECT s, arr +FROM arrays_test +LEFT ARRAY JOIN arr; +``` + +``` text +┌─s───────────┬─arr─┐ +│ Hello │ 1 │ +│ Hello │ 2 │ +│ World │ 3 │ +│ World │ 4 │ +│ World │ 5 │ +│ Goodbye │ 0 │ +└─────────────┴─────┘ +``` + +#### Takma Ad Kullanma {#using-aliases} + +Bir dizi için bir diğer ad belirtilebilir `ARRAY JOIN` yan. Bu durumda, bir dizi öğesine bu diğer adla erişilebilir, ancak dizinin kendisine özgün adla erişilir. Örnek: + +``` sql +SELECT s, arr, a +FROM arrays_test +ARRAY JOIN arr AS a; +``` + +``` text +┌─s─────┬─arr─────┬─a─┐ +│ Hello │ [1,2] │ 1 │ +│ Hello │ [1,2] │ 2 │ +│ World │ [3,4,5] │ 3 │ +│ World │ [3,4,5] │ 4 │ +│ World │ [3,4,5] │ 5 │ +└───────┴─────────┴───┘ +``` + +Takma adlar kullanarak şunları yapabilirsiniz `ARRAY JOIN` harici bir dizi ile. Mesela: + +``` sql +SELECT s, arr_external +FROM arrays_test +ARRAY JOIN [1, 2, 3] AS arr_external; +``` + +``` text +┌─s───────────┬─arr_external─┐ +│ Hello │ 1 │ +│ Hello │ 2 │ +│ Hello │ 3 │ +│ World │ 1 │ +│ World │ 2 │ +│ World │ 3 │ +│ Goodbye │ 1 │ +│ Goodbye │ 2 │ +│ Goodbye │ 3 │ +└─────────────┴──────────────┘ +``` + +Birden çok diziler virgülle ayrılmış olabilir `ARRAY JOIN` yan. Bu durumda, `JOIN` onlarla aynı anda gerçekleştirilir (doğrudan toplam, kartezyen ürün değil). Tüm dizilerin aynı boyuta sahip olması gerektiğini unutmayın. Örnek: + +``` sql +SELECT s, arr, a, num, mapped +FROM arrays_test +ARRAY JOIN arr AS a, arrayEnumerate(arr) AS num, arrayMap(x -> x + 1, arr) AS mapped; +``` + +``` text +┌─s─────┬─arr─────┬─a─┬─num─┬─mapped─┐ +│ Hello │ [1,2] │ 1 │ 1 │ 2 │ +│ Hello │ [1,2] │ 2 │ 2 │ 3 │ +│ World │ [3,4,5] │ 3 │ 1 │ 4 │ +│ World │ [3,4,5] │ 4 │ 2 │ 5 │ +│ World │ [3,4,5] │ 5 │ 3 │ 6 │ +└───────┴─────────┴───┴─────┴────────┘ +``` + +Aşağıdaki örnek kullanır [arrayEnumerate](../../sql_reference/functions/array_functions.md#array_functions-arrayenumerate) işlev: + +``` sql +SELECT s, arr, a, num, arrayEnumerate(arr) +FROM arrays_test +ARRAY JOIN arr AS a, arrayEnumerate(arr) AS num; +``` + +``` text +┌─s─────┬─arr─────┬─a─┬─num─┬─arrayEnumerate(arr)─┐ +│ Hello │ [1,2] │ 1 │ 1 │ [1,2] │ +│ Hello │ [1,2] │ 2 │ 2 │ [1,2] │ +│ World │ [3,4,5] │ 3 │ 1 │ [1,2,3] │ +│ World │ [3,4,5] │ 4 │ 2 │ [1,2,3] │ +│ World │ [3,4,5] │ 5 │ 3 │ [1,2,3] │ +└───────┴─────────┴───┴─────┴─────────────────────┘ +``` + +#### İç içe veri yapısı ile dizi birleştirme {#array-join-with-nested-data-structure} + +`ARRAY`Jo "in " ile de çalışır [iç içe veri yapıları](../../sql_reference/data_types/nested_data_structures/nested.md). Örnek: + +``` sql +CREATE TABLE nested_test +( + s String, + nest Nested( + x UInt8, + y UInt32) +) ENGINE = Memory; + +INSERT INTO nested_test +VALUES ('Hello', [1,2], [10,20]), ('World', [3,4,5], [30,40,50]), ('Goodbye', [], []); +``` + +``` text +┌─s───────┬─nest.x──┬─nest.y─────┐ +│ Hello │ [1,2] │ [10,20] │ +│ World │ [3,4,5] │ [30,40,50] │ +│ Goodbye │ [] │ [] │ +└─────────┴─────────┴────────────┘ +``` + +``` sql +SELECT s, `nest.x`, `nest.y` +FROM nested_test +ARRAY JOIN nest; +``` + +``` text +┌─s─────┬─nest.x─┬─nest.y─┐ +│ Hello │ 1 │ 10 │ +│ Hello │ 2 │ 20 │ +│ World │ 3 │ 30 │ +│ World │ 4 │ 40 │ +│ World │ 5 │ 50 │ +└───────┴────────┴────────┘ +``` + +İç içe geçmiş veri yapılarının adlarını belirtirken `ARRAY JOIN` anlam aynıdır `ARRAY JOIN` içerdiği tüm dizi öğeleri ile. Örnekler aşağıda listelenmiştir: + +``` sql +SELECT s, `nest.x`, `nest.y` +FROM nested_test +ARRAY JOIN `nest.x`, `nest.y`; +``` + +``` text +┌─s─────┬─nest.x─┬─nest.y─┐ +│ Hello │ 1 │ 10 │ +│ Hello │ 2 │ 20 │ +│ World │ 3 │ 30 │ +│ World │ 4 │ 40 │ +│ World │ 5 │ 50 │ +└───────┴────────┴────────┘ +``` + +Bu varyasyon da mantıklı: + +``` sql +SELECT s, `nest.x`, `nest.y` +FROM nested_test +ARRAY JOIN `nest.x`; +``` + +``` text +┌─s─────┬─nest.x─┬─nest.y─────┐ +│ Hello │ 1 │ [10,20] │ +│ Hello │ 2 │ [10,20] │ +│ World │ 3 │ [30,40,50] │ +│ World │ 4 │ [30,40,50] │ +│ World │ 5 │ [30,40,50] │ +└───────┴────────┴────────────┘ +``` + +Bir diğer ad, iç içe geçmiş bir veri yapısı için kullanılabilir. `JOIN` sonuç veya kaynak dizi. Örnek: + +``` sql +SELECT s, `n.x`, `n.y`, `nest.x`, `nest.y` +FROM nested_test +ARRAY JOIN nest AS n; +``` + +``` text +┌─s─────┬─n.x─┬─n.y─┬─nest.x──┬─nest.y─────┐ +│ Hello │ 1 │ 10 │ [1,2] │ [10,20] │ +│ Hello │ 2 │ 20 │ [1,2] │ [10,20] │ +│ World │ 3 │ 30 │ [3,4,5] │ [30,40,50] │ +│ World │ 4 │ 40 │ [3,4,5] │ [30,40,50] │ +│ World │ 5 │ 50 │ [3,4,5] │ [30,40,50] │ +└───────┴─────┴─────┴─────────┴────────────┘ +``` + +Kullanma örneği [arrayEnumerate](../../sql_reference/functions/array_functions.md#array_functions-arrayenumerate) işlev: + +``` sql +SELECT s, `n.x`, `n.y`, `nest.x`, `nest.y`, num +FROM nested_test +ARRAY JOIN nest AS n, arrayEnumerate(`nest.x`) AS num; +``` + +``` text +┌─s─────┬─n.x─┬─n.y─┬─nest.x──┬─nest.y─────┬─num─┐ +│ Hello │ 1 │ 10 │ [1,2] │ [10,20] │ 1 │ +│ Hello │ 2 │ 20 │ [1,2] │ [10,20] │ 2 │ +│ World │ 3 │ 30 │ [3,4,5] │ [30,40,50] │ 1 │ +│ World │ 4 │ 40 │ [3,4,5] │ [30,40,50] │ 2 │ +│ World │ 5 │ 50 │ [3,4,5] │ [30,40,50] │ 3 │ +└───────┴─────┴─────┴─────────┴────────────┴─────┘ +``` + +### Jo {#select-join} + +Verileri normal olarak birleştirir [SQL JOIN](https://en.wikipedia.org/wiki/Join_(SQL)) anlama. + +!!! info "Not" + İlgili [ARRAY JOIN](#select-array-join-clause). + +``` sql +SELECT +FROM +[GLOBAL] [ANY|ALL] [INNER|LEFT|RIGHT|FULL|CROSS] [OUTER] JOIN +(ON )|(USING ) ... +``` + +Tablo adları yerine belirtilebilir `` ve ``. Bu eşdeğerdir `SELECT * FROM table` alt sorgu, tablonun sahip olduğu özel bir durum dışında [Katmak](../../engines/table_engines/special/join.md) engine – an array prepared for joining. + +#### Desteklenen Türleri `JOIN` {#select-join-types} + +- `INNER JOIN` (veya `JOIN`) +- `LEFT JOIN` (veya `LEFT OUTER JOIN`) +- `RIGHT JOIN` (veya `RIGHT OUTER JOIN`) +- `FULL JOIN` (veya `FULL OUTER JOIN`) +- `CROSS JOIN` (veya `,` ) + +Standarda bakın [SQL JOIN](https://en.wikipedia.org/wiki/Join_(SQL)) açıklama. + +#### Çoklu birleştirme {#multiple-join} + +Sorguları gerçekleştiren ClickHouse, çoklu tablo birleşimlerini iki tablo birleşimlerinin sırasına yeniden yazar. Örneğin, JOIN ClickHouse için dört tablo varsa birinci ve ikinci katılır, ardından üçüncü tablo ile sonuç katılır ve son adımda dördüncü bir katılır. + +Bir sorgu içeriyorsa `WHERE` yan tümcesi, ClickHouse Ara birleştirme aracılığıyla bu yan tümcesi filtreleri pushdown çalışır. Filtreyi her Ara birleşime uygulayamazsa, tüm birleşimler tamamlandıktan sonra clickhouse filtreleri uygular. + +Biz tavsiye `JOIN ON` veya `JOIN USING` sorguları oluşturmak için sözdizimi. Mesela: + +``` sql +SELECT * FROM t1 JOIN t2 ON t1.a = t2.a JOIN t3 ON t1.a = t3.a +``` + +Virgülle ayrılmış tablo listelerini kullanabilirsiniz. `FROM` yan. Mesela: + +``` sql +SELECT * FROM t1, t2, t3 WHERE t1.a = t2.a AND t1.a = t3.a +``` + +Bu sözdizimleri karıştırmayın. + +ClickHouse virgülle sözdizimini doğrudan desteklemez, bu yüzden bunları kullanmanızı önermiyoruz. Algoritma, sorguyu şu şekilde yeniden yazmaya çalışır: `CROSS JOIN` ve `INNER JOIN` yan tümceleri ve sonra sorgu işleme devam eder. Sorguyu yeniden yazarken, ClickHouse performansı ve bellek tüketimini en iyi duruma getirmeye çalışır. Varsayılan olarak, ClickHouse virgülleri bir `INNER JOIN` CLA anduse and conver andts `INNER JOIN` -e doğru `CROSS JOIN` algoritma bunu garanti edemez zaman `INNER JOIN` gerekli verileri döndürür. + +#### Katılık {#select-join-strictness} + +- `ALL` — If the right table has several matching rows, ClickHouse creates a [Kartezyen ürün](https://en.wikipedia.org/wiki/Cartesian_product) eşleşen satırlardan. Bu standart `JOIN` SQL davranış. +- `ANY` — If the right table has several matching rows, only the first one found is joined. If the right table has only one matching row, the results of queries with `ANY` ve `ALL` anahtar kelimeler aynıdır. +- `ASOF` — For joining sequences with a non-exact match. `ASOF JOIN` kullanım aşağıda açıklanmıştır. + +**ASOF JOIN kullanımı** + +`ASOF JOIN` tam olarak eşleşmeyen kayıtlara katılmanız gerektiğinde kullanışlıdır. + +İçin tablolar `ASOF JOIN` sıralı bir sıra sütunu olmalıdır. Bu sütun bir tabloda tek başına olamaz ve veri türlerinden biri olmalıdır: `UInt32`, `UInt64`, `Float32`, `Float64`, `Date`, ve `DateTime`. + +Sözdizimi `ASOF JOIN ... ON`: + +``` sql +SELECT expressions_list +FROM table_1 +ASOF LEFT JOIN table_2 +ON equi_cond AND closest_match_cond +``` + +Herhangi bir sayıda eşitlik koşulunu ve tam olarak en yakın eşleşme koşulunu kullanabilirsiniz. Mesela, `SELECT count() FROM table_1 ASOF LEFT JOIN table_2 ON table_1.a == table_2.b AND table_2.t <= table_1.t`. + +En yakın maç için desteklenen koşullar: `>`, `>=`, `<`, `<=`. + +Sözdizimi `ASOF JOIN ... USING`: + +``` sql +SELECT expressions_list +FROM table_1 +ASOF JOIN table_2 +USING (equi_column1, ... equi_columnN, asof_column) +``` + +`ASOF JOIN` kullanma `equi_columnX` eşit onliğe katılma ve `asof_column` ile en yakın maça katılmak için `table_1.asof_column >= table_2.asof_column` koşul. Bu `asof_column` sütun her zaman sonuncusu `USING` yan. + +Örneğin, aşağıdaki tabloları göz önünde bulundurun: + +\`\`\` Metin +table\_1 table\_2 + +olay / ev\_time / user\_id olay / ev\_time / user\_id diff --git a/docs/tr/sql_reference/statements/show.md b/docs/tr/sql_reference/statements/show.md new file mode 100644 index 00000000000..155b28886d9 --- /dev/null +++ b/docs/tr/sql_reference/statements/show.md @@ -0,0 +1,105 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 38 +toc_title: SHOW +--- + +# Sorguları göster {#show-queries} + +## SHOW CREATE TABLE {#show-create-table} + +``` sql +SHOW CREATE [TEMPORARY] [TABLE|DICTIONARY] [db.]table [INTO OUTFILE filename] [FORMAT format] +``` + +Bir tek döndürür `String`-tür ‘statement’ column, which contains a single value – the `CREATE` belirtilen nesneyi oluşturmak için kullanılan sorgu. + +## SHOW DATABASES {#show-databases} + +``` sql +SHOW DATABASES [INTO OUTFILE filename] [FORMAT format] +``` + +Tüm veritabanlarının bir listesini yazdırır. +Bu sorgu ile aynıdır `SELECT name FROM system.databases [INTO OUTFILE filename] [FORMAT format]`. + +## SHOW PROCESSLIST {#show-processlist} + +``` sql +SHOW PROCESSLIST [INTO OUTFILE filename] [FORMAT format] +``` + +İçeriği verir [sistem.işleyişler](../../operations/system_tables.md#system_tables-processes) şu anda işlenmekte olan sorguların bir listesini içeren tablo, hariç `SHOW PROCESSLIST` sorgular. + +Bu `SELECT * FROM system.processes` sorgu, geçerli tüm sorgular hakkında veri döndürür. + +İpucu (konsolda Yürüt): + +``` bash +$ watch -n1 "clickhouse-client --query='SHOW PROCESSLIST'" +``` + +## SHOW TABLES {#show-tables} + +Tablo listesini görüntüler. + +``` sql +SHOW [TEMPORARY] TABLES [{FROM | IN} ] [LIKE '' | WHERE expr] [LIMIT ] [INTO OUTFILE ] [FORMAT ] +``` + +Eğer... `FROM` yan tümcesi belirtilmemiş, sorgu geçerli veritabanından tabloların listesini döndürür. + +Aynı sonuçları elde edebilirsiniz `SHOW TABLES` aşağıdaki şekilde sorgu: + +``` sql +SELECT name FROM system.tables WHERE database = [AND name LIKE ] [LIMIT ] [INTO OUTFILE ] [FORMAT ] +``` + +**Örnek** + +Aşağıdaki sorgu, tablo listesinden ilk iki satırı seçer. `system` adları içeren veritabanı `co`. + +``` sql +SHOW TABLES FROM system LIKE '%co%' LIMIT 2 +``` + +``` text +┌─name───────────────────────────┐ +│ aggregate_function_combinators │ +│ collations │ +└────────────────────────────────┘ +``` + +## SHOW DICTIONARIES {#show-dictionaries} + +Bir listesini görüntüler [dış söz dictionarieslükler](../../sql_reference/dictionaries/external_dictionaries/external_dicts.md). + +``` sql +SHOW DICTIONARIES [FROM ] [LIKE ''] [LIMIT ] [INTO OUTFILE ] [FORMAT ] +``` + +Eğer... `FROM` yan tümcesi belirtilmemiş, sorgu geçerli veritabanından sözlükler listesini döndürür. + +Aynı sonuçları elde edebilirsiniz `SHOW DICTIONARIES` aşağıdaki şekilde sorgu: + +``` sql +SELECT name FROM system.dictionaries WHERE database = [AND name LIKE ] [LIMIT ] [INTO OUTFILE ] [FORMAT ] +``` + +**Örnek** + +Aşağıdaki sorgu, tablo listesinden ilk iki satırı seçer. `system` adları içeren veritabanı `reg`. + +``` sql +SHOW DICTIONARIES FROM db LIKE '%reg%' LIMIT 2 +``` + +``` text +┌─name─────────┐ +│ regions │ +│ region_names │ +└──────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/show/) diff --git a/docs/tr/sql_reference/statements/system.md b/docs/tr/sql_reference/statements/system.md new file mode 100644 index 00000000000..761f6e77737 --- /dev/null +++ b/docs/tr/sql_reference/statements/system.md @@ -0,0 +1,113 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 37 +toc_title: SYSTEM +--- + +# Sistem sorguları {#query-language-system} + +- [RELOAD DICTIONARIES](#query_language-system-reload-dictionaries) +- [RELOAD DICTIONARY](#query_language-system-reload-dictionary) +- [DROP DNS CACHE](#query_language-system-drop-dns-cache) +- [DROP MARK CACHE](#query_language-system-drop-mark-cache) +- [FLUSH LOGS](#query_language-system-flush_logs) +- [RELOAD CONFIG](#query_language-system-reload-config) +- [SHUTDOWN](#query_language-system-shutdown) +- [KILL](#query_language-system-kill) +- [STOP DISTRIBUTED SENDS](#query_language-system-stop-distributed-sends) +- [FLUSH DISTRIBUTED](#query_language-system-flush-distributed) +- [START DISTRIBUTED SENDS](#query_language-system-start-distributed-sends) +- [STOP MERGES](#query_language-system-stop-merges) +- [START MERGES](#query_language-system-start-merges) + +## RELOAD DICTIONARIES {#query_language-system-reload-dictionaries} + +Daha önce başarıyla yüklenen tüm sözlükleri yeniden yükler. +Varsayılan olarak, sözlükler tembel yüklenir (bkz [dictionaries\_lazy\_load](../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-dictionaries_lazy_load)), bu nedenle başlangıçta otomatik olarak yüklenmek yerine, dictGet işlevi aracılığıyla ilk erişimde başlatılır veya ENGİNE = Dictionary ile tablolardan seçim yapılır. Bu `SYSTEM RELOAD DICTIONARIES` sorgu bu sözlükleri yeniden yükler (yüklü). +Her zaman döner `Ok.` sözlük güncellemesinin sonucu ne olursa olsun. + +## Sözlük Dictionary\_name yeniden yükle {#query_language-system-reload-dictionary} + +Tamamen bir sözlük reloads `dictionary_name`, sözlük durumuna bakılmaksızın (LOADED / NOT\_LOADED / FAİLED). +Her zaman döner `Ok.` ne olursa olsun sözlük güncelleme sonucu. +Sözlüğün durumu sorgulanarak kontrol edilebilir `system.dictionaries` Tablo. + +``` sql +SELECT name, status FROM system.dictionaries; +``` + +## DROP DNS CACHE {#query_language-system-drop-dns-cache} + +Clickhouse'un iç DNS önbelleğini sıfırlar. Bazen (eski ClickHouse sürümleri için) altyapıyı değiştirirken (başka bir ClickHouse sunucusunun IP adresini veya sözlükler tarafından kullanılan sunucuyu değiştirirken) bu komutu kullanmak gerekir. + +Daha uygun (otomatik) önbellek yönetimi için bkz: disable\_internal\_dns\_cache, dns\_cache\_update\_period parametreleri. + +## DROP MARK CACHE {#query_language-system-drop-mark-cache} + +İşaret önbelleğini sıfırlar. ClickHouse ve performans testlerinin geliştirilmesinde kullanılır. + +## FLUSH LOGS {#query_language-system-flush_logs} + +Flushes buffers of log messages to system tables (e.g. system.query\_log). Allows you to not wait 7.5 seconds when debugging. + +## RELOAD CONFIG {#query_language-system-reload-config} + +ClickHouse yapılandırmasını yeniden yükler. Yapılandırma ZooKeeeper saklandığında kullanılır. + +## SHUTDOWN {#query_language-system-shutdown} + +Normalde Clickhouse'u kapatır (gibi `service clickhouse-server stop` / `kill {$pid_clickhouse-server}`) + +## KILL {#query_language-system-kill} + +ClickHouse işlemini iptal eder (gibi `kill -9 {$ pid_clickhouse-server}`) + +## Dağıtılmış Tabloları Yönetme {#query-language-system-distributed} + +ClickHouse yönetebilir [dağılı](../../engines/table_engines/special/distributed.md) Tablolar. Bir kullanıcı bu tablolara veri eklediğinde, ClickHouse önce küme düğümlerine gönderilmesi gereken verilerin bir sırası oluşturur, sonra zaman uyumsuz olarak gönderir. İle kuyruk işleme yönetebilirsiniz [STOP DISTRIBUTED SENDS](#query_language-system-stop-distributed-sends), [FLUSH DISTRIBUTED](#query_language-system-flush-distributed), ve [START DISTRIBUTED SENDS](#query_language-system-start-distributed-sends) sorgular. Ayrıca, dağıtılmış verileri eşzamanlı olarak `insert_distributed_sync` ayar. + +### STOP DISTRIBUTED SENDS {#query_language-system-stop-distributed-sends} + +Dağıtılmış tablolara veri eklerken arka plan veri dağıtımını devre dışı bırakır. + +``` sql +SYSTEM STOP DISTRIBUTED SENDS [db.] +``` + +### FLUSH DISTRIBUTED {#query_language-system-flush-distributed} + +Küme düğümlerine eşzamanlı olarak veri göndermek için Clickhouse'u zorlar. Herhangi bir düğüm kullanılamıyorsa, ClickHouse bir özel durum atar ve sorgu yürütülmesini durdurur. Tüm düğümler tekrar çevrimiçi olduğunda gerçekleşecek olan başarılı olana kadar sorguyu yeniden deneyebilirsiniz. + +``` sql +SYSTEM FLUSH DISTRIBUTED [db.] +``` + +### START DISTRIBUTED SENDS {#query_language-system-start-distributed-sends} + +Dağıtılmış tablolara veri eklerken arka plan veri dağıtımını etkinleştirir. + +``` sql +SYSTEM START DISTRIBUTED SENDS [db.] +``` + +### STOP MERGES {#query_language-system-stop-merges} + +MergeTree ailesindeki tablolar için arka plan birleşmelerini durdurma imkanı sağlar: + +``` sql +SYSTEM STOP MERGES [[db.]merge_tree_family_table_name] +``` + +!!! note "Not" + `DETACH / ATTACH` tablo, daha önce tüm MergeTree tabloları için birleştirmeler durdurulduğunda bile tablo için arka plan birleştirmelerini başlatır. + +### START MERGES {#query_language-system-start-merges} + +MergeTree ailesindeki tablolar için arka plan birleştirmelerini başlatma imkanı sağlar: + +``` sql +SYSTEM START MERGES [[db.]merge_tree_family_table_name] +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/system/) diff --git a/docs/tr/sql_reference/syntax.md b/docs/tr/sql_reference/syntax.md new file mode 100644 index 00000000000..a7d725fe696 --- /dev/null +++ b/docs/tr/sql_reference/syntax.md @@ -0,0 +1,187 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 31 +toc_title: "S\xF6zdizimi" +--- + +# Sözdizimi {#syntax} + +Sistemde iki tür ayrıştırıcı vardır: tam SQL ayrıştırıcısı (özyinelemeli bir iniş ayrıştırıcısı) ve veri biçimi ayrıştırıcısı (hızlı akış ayrıştırıcısı). +Dışında her durumda `INSERT` sorgu, sadece tam SQL ayrıştırıcı kullanılır. +Bu `INSERT` sorgu her iki ayrıştırıcıyı da kullanır: + +``` sql +INSERT INTO t VALUES (1, 'Hello, world'), (2, 'abc'), (3, 'def') +``` + +Bu `INSERT INTO t VALUES` parça tam ayrıştırıcı tarafından ayrıştırılır ve veriler `(1, 'Hello, world'), (2, 'abc'), (3, 'def')` hızlı akış ayrıştırıcısı tarafından ayrıştırılır. Ayrıca kullanarak veriler için tam ayrıştırıcı açabilirsiniz [ınput\_format\_values\_interpret\_expressions](../operations/settings/settings.md#settings-input_format_values_interpret_expressions) ayar. Ne zaman `input_format_values_interpret_expressions = 1`, ClickHouse önce hızlı akış ayrıştırıcısı ile değerleri ayrıştırmaya çalışır. Başarısız olursa, ClickHouse veriler için tam ayrıştırıcıyı kullanmaya çalışır ve bir SQL gibi davranır [ifade](#syntax-expressions). + +Veri herhangi bir biçime sahip olabilir. Bir sorgu alındığında, sunucu daha fazla hesaplar [max\_query\_size](../operations/settings/settings.md#settings-max_query_size) istek bayt RAM (varsayılan olarak, 1 MB) ve geri kalanı akış ayrıştırılır. +Bu büyük sorunları önlemek için izin verir `INSERT` sorgular. + +Kullanırken `Values` biçim içinde bir `INSERT` sorgu, verilerin bir ifadedeki ifadelerle aynı şekilde ayrıştırıldığı görünebilir `SELECT` sorgu, ancak bu doğru değil. Bu `Values` biçim çok daha sınırlıdır. + +Bu makalenin geri kalanı tam çözümleyici kapsar. Biçim ayrıştırıcıları hakkında daha fazla bilgi için bkz: [Biçimliler](../interfaces/formats.md) bölme. + +## Alanlar {#spaces} + +Sözdizimsel yapılar arasında (bir sorgunun başlangıcı ve sonu dahil) herhangi bir sayıda boşluk simgesi olabilir. Boşluk sembolleri boşluk, sekme, satır beslemesi, CR ve form beslemesini içerir. + +## Yorumlar {#comments} + +ClickHouse, SQL stili ve C stili yorumlarını destekler. +SQL tarzı yorumlar ile başlar `--` ve hattın sonuna kadar devam, bir boşluk sonra `--` atlanmış olabilir. +C-style dan `/*` -e doğru `*/`ve çok satırlı olabilir, boşluklar da gerekli değildir. + +## Kelimeler {#syntax-keywords} + +Anahtar kelimeler karşılık geldiğinde büyük / küçük harf duyarsızdır: + +- SQL standardı. Mesela, `SELECT`, `select` ve `SeLeCt` hepsi geçerlidir. +- Bazı popüler DBMS'DE (MySQL veya Postgres) uygulama. Mesela, `DateTime` ile aynıdır `datetime`. + +Veri türü adı büyük / küçük harf duyarlı olup olmadığını denetlenebilir `system.data_type_families` Tablo. + +Standart SQL'İN aksine, diğer tüm anahtar kelimeler (işlev adları dahil) şunlardır **büyük küçük harf duyarlı**. + +Anahtar kelimeler ayrılmış değildir; sadece karşılık gelen bağlamda bu şekilde ele alınır. Kullanıyorsanız [tanıtıcılar](#syntax-identifiers) anahtar kelimelerle aynı ada sahip olarak, bunları çift tırnak veya backticks içine alın. Örneğin, sorgu `SELECT "FROM" FROM table_name` tablo geçerli ise `table_name` adı ile sütun vardır `"FROM"`. + +## Tanıtıcılar {#syntax-identifiers} + +Tanımlay areıcılar: + +- Küme, veritabanı, tablo, bölüm ve sütun adları. +- İşlevler. +- Veri türleri. +- [İfade takma adları](#syntax-expression_aliases). + +Tanımlayıcılar alıntılanabilir veya alıntılanamaz. İkincisi tercih edilir. + +Alıntılanmamış tanımlayıcılar regex ile eşleşmelidir `^[a-zA-Z_][0-9a-zA-Z_]*$` ve eşit olamaz [kelimeler](#syntax-keywords). Örnekler: `x, _1, X_y__Z123_.` + +Tanımlayıcıları anahtar kelimelerle aynı şekilde kullanmak istiyorsanız veya tanımlayıcılarda başka semboller kullanmak istiyorsanız, örneğin çift tırnak işaretleri veya backticks kullanarak alıntı yapın, `"id"`, `` `id` ``. + +## Harfler {#literals} + +Sayısal, dize, bileşik ve `NULL` harfler. + +### Sayısal {#numeric} + +Sayısal literal ayrıştırılmaya çalışılıyor: + +- İlk olarak, 64-bit imzalı bir sayı olarak, [strtoull](https://en.cppreference.com/w/cpp/string/byte/strtoul) işlev. +- Başarısız olursa, 64-bit imzasız bir sayı olarak, [strtoll](https://en.cppreference.com/w/cpp/string/byte/strtol) işlev. +- Başarısız olursa, kayan noktalı sayı olarak [strtod](https://en.cppreference.com/w/cpp/string/byte/strtof) işlev. +- Aksi takdirde, bir hata döndürür. + +Hazır bilgi değeri, değerin sığdığı en küçük türe sahiptir. +Örneğin, 1 olarak ayrıştırılır `UInt8`, ancak 256 olarak ayrıştırılır `UInt16`. Daha fazla bilgi için, bkz. [Veri türleri](../sql_reference/data_types/index.md). + +Örnekler: `1`, `18446744073709551615`, `0xDEADBEEF`, `01`, `0.1`, `1e100`, `-1e-100`, `inf`, `nan`. + +### Dize {#syntax-string-literal} + +Tek tırnak yalnızca dize değişmezleri desteklenir. Kapalı karakterler ters eğik çizgi kaçabilir. Aşağıdaki kaçış dizileri karşılık gelen özel bir değere sahiptir: `\b`, `\f`, `\r`, `\n`, `\t`, `\0`, `\a`, `\v`, `\xHH`. Diğer tüm durumlarda, çıkış dizileri biçiminde `\c`, nere `c` herhangi bir karakter, dönüştürülür `c`. Bu dizileri kullanabileceğiniz anlamına gelir `\'`ve`\\`. Değeri olacak [Dize](../sql_reference/data_types/string.md) tür. + +Dize değişmezlerinde, en azından kaçmanız gerekir `'` ve `\`. Tek tırnak tek Alıntı ile kaçabilir, değişmez `'It\'s'` ve `'It''s'` eşittir. + +### Bileşik {#compound} + +Diziler köşeli parantez ile inşa edilmiştir `[1, 2, 3]`. Nuples yuvarlak parantez ile inşa edilmiştir `(1, 'Hello, world!', 2)`. +Teknik olarak bunlar değişmezler değil, sırasıyla dizi oluşturma işleci ve tuple oluşturma işleci ile ifadeler. +Bir dizi en az bir öğeden oluşmalı ve bir tuple en az iki öğeye sahip olmalıdır. +İçinde tuples göründüğünde ayrı bir durum var `IN` CLA ause of a `SELECT` sorgu. Sorgu sonuçları tuples içerebilir, ancak tuples bir veritabanına kaydedilemez (tablolar hariç [Bellek](../engines/table_engines/special/memory.md) motor). + +### NULL {#null-literal} + +Değerin eksik olduğunu gösterir. + +Saklamak için `NULL` bir tablo alanında, bu olmalıdır [Nullable](../sql_reference/data_types/nullable.md) tür. + +Veri formatına bağlı olarak (giriş veya çıkış), `NULL` farklı bir temsili olabilir. Daha fazla bilgi için belgelere bakın [veri formatları](../interfaces/formats.md#formats). + +İşleme için birçok nüans var `NULL`. Örneğin, bir karşılaştırma işleminin argümanlarından en az biri ise `NULL`, bu işlemin sonucu da `NULL`. Aynı şey çarpma, toplama ve diğer işlemler için de geçerlidir. Daha fazla bilgi için her işlem için belgeleri okuyun. + +Sorgularda, kontrol edebilirsiniz `NULL` kullanarak [IS NULL](operators.md#operator-is-null) ve [IS NOT NULL](operators.md) operatörler ve ilgili fonksiyonlar `isNull` ve `isNotNull`. + +## İşlevler {#functions} + +İşlev çağrıları, yuvarlak parantez içinde bir argüman listesi (muhtemelen boş) olan bir tanımlayıcı gibi yazılır. Standart SQL'İN aksine, boş bir argüman listesi için bile parantezler gereklidir. Örnek: `now()`. +Düzenli ve agrega işlevleri vardır (bkz. “Aggregate functions”). Bazı toplama işlevleri parantez içinde iki bağımsız değişken listesi içerebilir. Örnek: `quantile (0.9) (x)`. Bu toplama fonksiyonları denir “parametric” fonksiyonlar ve ilk listedeki argümanlar çağrılır “parameters”. Parametresiz toplama işlevlerinin sözdizimi, normal işlevlerle aynıdır. + +## Operatörler {#operators} + +Operatörler, sorgu ayrıştırma sırasında önceliklerini ve ilişkilendirmelerini dikkate alarak karşılık gelen işlevlerine dönüştürülür. +Örneğin, ifade `1 + 2 * 3 + 4` dönüştür toülür `plus(plus(1, multiply(2, 3)), 4)`. + +## Veri türleri ve veritabanı tablosu motorları {#data_types-and-database-table-engines} + +Veri türleri ve tablo motorları `CREATE` sorgu tanımlayıcıları veya işlevleri aynı şekilde yazılır. Başka bir deyişle, parantez içinde bir argüman listesi içerebilir veya içermeyebilir. Daha fazla bilgi için bölümlere bakın “Data types,” “Table engines,” ve “CREATE”. + +## İfade Takma Adları {#syntax-expression_aliases} + +Diğer ad, sorgudaki ifade için kullanıcı tanımlı bir addır. + +``` sql +expr AS alias +``` + +- `AS` — The keyword for defining aliases. You can define the alias for a table name or a column name in a `SELECT` kullanmadan fık thera `AS` kelime. + + For example, `SELECT table_name_alias.column_name FROM table_name table_name_alias`. + + In the [CAST](sql_reference/functions/type_conversion_functions.md#type_conversion_function-cast) function, the `AS` keyword has another meaning. See the description of the function. + +- `expr` — Any expression supported by ClickHouse. + + For example, `SELECT column_name * 2 AS double FROM some_table`. + +- `alias` — Name for `expr`. Takma adlar ile uyumlu olmalıdır [tanıtıcılar](#syntax-identifiers) sözdizimi. + + For example, `SELECT "table t".column_name FROM table_name AS "table t"`. + +### Kullanımı ile ilgili notlar {#notes-on-usage} + +Diğer adlar bir sorgu veya alt sorgu için geneldir ve herhangi bir ifade için sorgunun herhangi bir bölümünde bir diğer ad tanımlayabilirsiniz. Mesela, `SELECT (1 AS n) + 2, n`. + +Diğer adlar alt sorgularda ve alt sorgular arasında görünmez. Örneğin, sorgu yürütülürken `SELECT (SELECT sum(b.a) + num FROM b) - a.a AS num FROM a` ClickHouse istisna oluşturur `Unknown identifier: num`. + +Sonuç sütunları için bir diğer ad tanımlanmışsa `SELECT` bir alt sorgunun yan tümcesi, bu sütunlar dış sorguda görülebilir. Mesela, `SELECT n + m FROM (SELECT 1 AS n, 2 AS m)`. + +Sütun veya tablo adlarıyla aynı olan diğer adlara dikkat edin. Aşağıdaki örneği ele alalım: + +``` sql +CREATE TABLE t +( + a Int, + b Int +) +ENGINE = TinyLog() +``` + +``` sql +SELECT + argMax(a, b), + sum(b) AS b +FROM t +``` + +``` text +Received exception from server (version 18.14.17): +Code: 184. DB::Exception: Received from localhost:9000, 127.0.0.1. DB::Exception: Aggregate function sum(b) is found inside another aggregate function in query. +``` + +Bu örnekte, tablo ilan ettik `t` sütun ile `b`. Ardından, veri seçerken, `sum(b) AS b` takma ad. Takma adlar küresel olduğundan, ClickHouse literal yerine `b` ifad theesinde `argMax(a, b)` ifad theesiyle `sum(b)`. Bu ikame istisnaya neden oldu. + +## Yıldız işareti {#asterisk} + +İn a `SELECT` sorgu, bir yıldız ifadesinin yerini alabilir. Daha fazla bilgi için bölüme bakın “SELECT”. + +## İfadeler {#syntax-expressions} + +Bir ifade, bir işlev, tanımlayıcı, değişmez, bir operatörün uygulaması, parantez içindeki ifade, alt sorgu veya yıldız işaretidir. Ayrıca bir takma ad içerebilir. +İfadelerin listesi, virgülle ayrılmış bir veya daha fazla ifadedir. +Fonksiyonlar ve operatörler, sırayla, argüman olarak ifadelere sahip olabilirler. + +[Orijinal makale](https://clickhouse.tech/docs/en/sql_reference/syntax/) diff --git a/docs/tr/sql_reference/table_functions/file.md b/docs/tr/sql_reference/table_functions/file.md new file mode 100644 index 00000000000..67d67ccd7cd --- /dev/null +++ b/docs/tr/sql_reference/table_functions/file.md @@ -0,0 +1,121 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 37 +toc_title: Dosya +--- + +# Dosya {#file} + +Bir dosyadan bir tablo oluşturur. Bu tablo işlevi benzer [url](url.md) ve [hdf'ler](hdfs.md) biri. + +``` sql +file(path, format, structure) +``` + +**Giriş parametreleri** + +- `path` — The relative path to the file from [user\_files\_path](../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-user_files_path). Readonly modunda glob'ları takip eden dosya desteğine giden yol: `*`, `?`, `{abc,def}` ve `{N..M}` nerede `N`, `M` — numbers, \``'abc', 'def'` — strings. +- `format` — The [biçimli](../../interfaces/formats.md#formats) dosya. +- `structure` — Structure of the table. Format `'column1_name column1_type, column2_name column2_type, ...'`. + +**Döndürülen değer** + +Belirtilen dosyada veri okumak veya yazmak için belirtilen yapıya sahip bir tablo. + +**Örnek** + +Ayar `user_files_path` ve dosyanın içeriği `test.csv`: + +``` bash +$ grep user_files_path /etc/clickhouse-server/config.xml + /var/lib/clickhouse/user_files/ + +$ cat /var/lib/clickhouse/user_files/test.csv + 1,2,3 + 3,2,1 + 78,43,45 +``` + +Tablo fromdan`test.csv` ve ondan ilk iki satır seçimi: + +``` sql +SELECT * +FROM file('test.csv', 'CSV', 'column1 UInt32, column2 UInt32, column3 UInt32') +LIMIT 2 +``` + +``` text +┌─column1─┬─column2─┬─column3─┐ +│ 1 │ 2 │ 3 │ +│ 3 │ 2 │ 1 │ +└─────────┴─────────┴─────────┘ +``` + +``` sql +-- getting the first 10 lines of a table that contains 3 columns of UInt32 type from a CSV file +SELECT * FROM file('test.csv', 'CSV', 'column1 UInt32, column2 UInt32, column3 UInt32') LIMIT 10 +``` + +**Yolda Globs** + +Birden çok yol bileşenleri globs olabilir. İşlenmek için dosya var olmalı ve tüm yol deseniyle eşleşmelidir (sadece sonek veya önek değil). + +- `*` — Substitutes any number of any characters except `/` boş dize dahil. +- `?` — Substitutes any single character. +- `{some_string,another_string,yet_another_one}` — Substitutes any of strings `'some_string', 'another_string', 'yet_another_one'`. +- `{N..M}` — Substitutes any number in range from N to M including both borders. + +İle yapılar `{}` benzer olan [uzaktan masa fonksiyonu](../../sql_reference/table_functions/remote.md)). + +**Örnek** + +1. Aşağıdaki göreli yollara sahip birkaç dosyamız olduğunu varsayalım: + +- ‘some\_dir/some\_file\_1’ +- ‘some\_dir/some\_file\_2’ +- ‘some\_dir/some\_file\_3’ +- ‘another\_dir/some\_file\_1’ +- ‘another\_dir/some\_file\_2’ +- ‘another\_dir/some\_file\_3’ + +1. Bu dosyalardaki satır miktarını sorgula: + + + +``` sql +SELECT count(*) +FROM file('{some,another}_dir/some_file_{1..3}', 'TSV', 'name String, value UInt32') +``` + +1. Bu iki dizinin tüm dosyalarındaki satır miktarını sorgula: + + + +``` sql +SELECT count(*) +FROM file('{some,another}_dir/*', 'TSV', 'name String, value UInt32') +``` + +!!! warning "Uyarıcı" + Dosya listenizde önde gelen sıfırlar içeren sayı aralıkları varsa, her basamak için parantez içeren yapıyı ayrı ayrı kullanın veya kullanın `?`. + +**Örnek** + +Adlı dosy thealardan verileri sorgu thelamak `file000`, `file001`, … , `file999`: + +``` sql +SELECT count(*) +FROM file('big_dir/file{0..9}{0..9}{0..9}', 'CSV', 'name String, value UInt32') +``` + +## Sanal Sütunlar {#virtual-columns} + +- `_path` — Path to the file. +- `_file` — Name of the file. + +**Ayrıca Bakınız** + +- [Sanal sütunlar](https://clickhouse.tech/docs/en/operations/table_engines/#table_engines-virtual_columns) + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/file/) diff --git a/docs/tr/sql_reference/table_functions/generate.md b/docs/tr/sql_reference/table_functions/generate.md new file mode 100644 index 00000000000..f9fc1fc9b21 --- /dev/null +++ b/docs/tr/sql_reference/table_functions/generate.md @@ -0,0 +1,45 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 47 +toc_title: generateRandom +--- + +# generateRandom {#generaterandom} + +Verilen şema ile rastgele veri üretir. +Test tablolarını verilerle doldurmaya izin verir. +Dışında tabloda saklanabilir tüm veri türlerini destekler `LowCardinality` ve `AggregateFunction`. + +``` sql +generateRandom('name TypeName[, name TypeName]...', [, 'random_seed'[, 'max_string_length'[, 'max_array_length']]]); +``` + +**Parametre** + +- `name` — Name of corresponding column. +- `TypeName` — Type of corresponding column. +- `limit` — Number of rows to generate. +- `max_array_length` — Maximum array length for all generated arrays. Defaults to `10`. +- `max_string_length` — Maximum string length for all generated strings. Defaults to `10`. +- `random_seed` — Specify random seed manually to produce stable results. If NULL — seed is randomly generated. + +**Döndürülen Değer** + +Istenen şema ile bir tablo nesnesi. + +## Kullanım Örneği {#usage-example} + +``` sql +SELECT * FROM generateRandom('a Array(Int8), d Decimal32(4), c Tuple(DateTime64(3), UUID)', 1, 10, 2); +``` + +``` text +┌─a────────┬────────────d─┬─c──────────────────────────────────────────────────────────────────┐ +│ [77] │ -124167.6723 │ ('2061-04-17 21:59:44.573','3f72f405-ec3e-13c8-44ca-66ef335f7835') │ +│ [32,110] │ -141397.7312 │ ('1979-02-09 03:43:48.526','982486d1-5a5d-a308-e525-7bd8b80ffa73') │ +│ [68] │ -67417.0770 │ ('2080-03-12 14:17:31.269','110425e5-413f-10a6-05ba-fa6b3e929f15') │ +└──────────┴──────────────┴────────────────────────────────────────────────────────────────────┘ +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/generate/) diff --git a/docs/tr/sql_reference/table_functions/hdfs.md b/docs/tr/sql_reference/table_functions/hdfs.md new file mode 100644 index 00000000000..e15d721135a --- /dev/null +++ b/docs/tr/sql_reference/table_functions/hdfs.md @@ -0,0 +1,104 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 45 +toc_title: hdf'ler +--- + +# hdf'ler {#hdfs} + +Hdfs'deki dosyalardan bir tablo oluşturur. Bu tablo işlevi benzer [url](url.md) ve [Dosya](file.md) biri. + +``` sql +hdfs(URI, format, structure) +``` + +**Giriş parametreleri** + +- `URI` — The relative URI to the file in HDFS. Path to file support following globs in readonly mode: `*`, `?`, `{abc,def}` ve `{N..M}` nerede `N`, `M` — numbers, \``'abc', 'def'` — strings. +- `format` — The [biçimli](../../interfaces/formats.md#formats) dosya. +- `structure` — Structure of the table. Format `'column1_name column1_type, column2_name column2_type, ...'`. + +**Döndürülen değer** + +Belirtilen dosyada veri okumak veya yazmak için belirtilen yapıya sahip bir tablo. + +**Örnek** + +Tablo fromdan `hdfs://hdfs1:9000/test` ve ondan ilk iki satır seçimi: + +``` sql +SELECT * +FROM hdfs('hdfs://hdfs1:9000/test', 'TSV', 'column1 UInt32, column2 UInt32, column3 UInt32') +LIMIT 2 +``` + +``` text +┌─column1─┬─column2─┬─column3─┐ +│ 1 │ 2 │ 3 │ +│ 3 │ 2 │ 1 │ +└─────────┴─────────┴─────────┘ +``` + +**Yolda Globs** + +Birden çok yol bileşenleri globs olabilir. İşlenmek için dosya var olmalı ve tüm yol deseniyle eşleşmelidir (sadece sonek veya önek değil). + +- `*` — Substitutes any number of any characters except `/` boş dize dahil. +- `?` — Substitutes any single character. +- `{some_string,another_string,yet_another_one}` — Substitutes any of strings `'some_string', 'another_string', 'yet_another_one'`. +- `{N..M}` — Substitutes any number in range from N to M including both borders. + +İle yapılar `{}` benzer olan [uzaktan masa fonksiyonu](../../sql_reference/table_functions/remote.md)). + +**Örnek** + +1. HDFS'DE aşağıdaki Urı'lere sahip birkaç dosyamız olduğunu varsayalım: + +- ‘hdfs://hdfs1:9000/some\_dir/some\_file\_1’ +- ‘hdfs://hdfs1:9000/some\_dir/some\_file\_2’ +- ‘hdfs://hdfs1:9000/some\_dir/some\_file\_3’ +- ‘hdfs://hdfs1:9000/another\_dir/some\_file\_1’ +- ‘hdfs://hdfs1:9000/another\_dir/some\_file\_2’ +- ‘hdfs://hdfs1:9000/another\_dir/some\_file\_3’ + +1. Bu dosyalardaki satır miktarını sorgula: + + + +``` sql +SELECT count(*) +FROM hdfs('hdfs://hdfs1:9000/{some,another}_dir/some_file_{1..3}', 'TSV', 'name String, value UInt32') +``` + +1. Bu iki dizinin tüm dosyalarındaki satır miktarını sorgula: + + + +``` sql +SELECT count(*) +FROM hdfs('hdfs://hdfs1:9000/{some,another}_dir/*', 'TSV', 'name String, value UInt32') +``` + +!!! warning "Uyarıcı" + Dosya listenizde önde gelen sıfırlar içeren sayı aralıkları varsa, her basamak için parantez içeren yapıyı ayrı ayrı kullanın veya kullanın `?`. + +**Örnek** + +Adlı dosy thealardan verileri sorgu thelamak `file000`, `file001`, … , `file999`: + +``` sql +SELECT count(*) +FROM hdfs('hdfs://hdfs1:9000/big_dir/file{0..9}{0..9}{0..9}', 'CSV', 'name String, value UInt32') +``` + +## Sanal Sütunlar {#virtual-columns} + +- `_path` — Path to the file. +- `_file` — Name of the file. + +**Ayrıca Bakınız** + +- [Sanal sütunlar](https://clickhouse.tech/docs/en/operations/table_engines/#table_engines-virtual_columns) + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/hdfs/) diff --git a/docs/tr/sql_reference/table_functions/index.md b/docs/tr/sql_reference/table_functions/index.md new file mode 100644 index 00000000000..3108903713f --- /dev/null +++ b/docs/tr/sql_reference/table_functions/index.md @@ -0,0 +1,38 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: "Tablo Fonksiyonlar\u0131" +toc_priority: 34 +toc_title: "Giri\u015F" +--- + +# Tablo Fonksiyonları {#table-functions} + +Tablo işlevleri tabloları oluşturmak için yöntemlerdir. + +Tablo işlevlerini kullanabilirsiniz: + +- [FROM](../statements/select.md#select-from) fıkra ofsı `SELECT` sorgu. + + The method for creating a temporary table that is available only in the current query. The table is deleted when the query finishes. + +- [Tablo oluştur \](../statements/create.md#create-table-query) sorgu. + + It's one of the methods of creating a table. + +!!! warning "Uyarıcı" + Eğer tablo işlevlerini kullanamazsınız [allow\_ddl](../../operations/settings/permissions_for_queries.md#settings_allow_ddl) ayarı devre dışı. + +| İşlev | Açıklama | +|--------------------------|-----------------------------------------------------------------------------------------------------------------------------| +| [Dosya](file.md) | Oluşturur bir [Dosya](../../engines/table_engines/special/file.md)- motor masası. | +| [birleştirmek](merge.md) | Oluşturur bir [Birleştirmek](../../engines/table_engines/special/merge.md)- motor masası. | +| [şiir](numbers.md) | Tamsayı sayılarla dolu tek bir sütun içeren bir tablo oluşturur. | +| [uzak](remote.md) | Oluşturmadan uzak sunuculara erişmenizi sağlar. [Dağılı](../../engines/table_engines/special/distributed.md)- motor masası. | +| [url](url.md) | Oluşturur bir [Url](../../engines/table_engines/special/url.md)- motor masası. | +| [mysql](mysql.md) | Oluşturur bir [MySQL](../../engines/table_engines/integrations/mysql.md)- motor masası. | +| [jdbc](jdbc.md) | Oluşturur bir [JDBC](../../engines/table_engines/integrations/jdbc.md)- motor masası. | +| [odbc](odbc.md) | Oluşturur bir [ODBC](../../engines/table_engines/integrations/odbc.md)- motor masası. | +| [hdf'ler](hdfs.md) | Oluşturur bir [HDFS](../../engines/table_engines/integrations/hdfs.md)- motor masası. | + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/) diff --git a/docs/tr/sql_reference/table_functions/input.md b/docs/tr/sql_reference/table_functions/input.md new file mode 100644 index 00000000000..5639e05eb81 --- /dev/null +++ b/docs/tr/sql_reference/table_functions/input.md @@ -0,0 +1,47 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 46 +toc_title: girdi +--- + +# girdi {#input} + +`input(structure)` - etkin bir şekilde dönüştürmek ve veri eklemek sağlar tablo fonksiyonu gönderilen +başka bir yapıya sahip tabloya verilen yapıya sahip sunucu. + +`structure` - aşağıdaki formatta sunucuya gönderilen verilerin yapısı `'column1_name column1_type, column2_name column2_type, ...'`. +Mesela, `'id UInt32, name String'`. + +Bu işlev yalnızca kullanılabilir `INSERT SELECT` sorgu ve sadece bir kez ama aksi takdirde sıradan tablo işlevi gibi davranır +(örneğin, alt sorguda vb.kullanılabilir.). + +Veri sıradan gibi herhangi bir şekilde gönderilebilir `INSERT` sorgu ve herhangi bir kullanılabilir geçti [biçimli](../../interfaces/formats.md#formats) +bu sorgu sonunda belirtilmelidir (sıradan aksine `INSERT SELECT`). + +Bu işlevin ana özelliği, sunucu istemciden veri aldığında aynı anda onu dönüştürmesidir +ifadeler listesine göre `SELECT` yan tümcesi ve hedef tabloya ekler. Geçici tablo +aktarılan tüm veriler ile oluşturulmaz. + +**Örnekler** + +- L letet the `test` tablo aşağıdaki yapıya sahiptir `(a String, b String)` + ve veri `data.csv` farklı bir yapıya sahiptir `(col1 String, col2 Date, col3 Int32)`. Insert sorgusu + bu verileri `data.csv` içine `test` eşzamanlı dönüşüm ile tablo şöyle görünüyor: + + + +``` bash +$ cat data.csv | clickhouse-client --query="INSERT INTO test SELECT lower(col1), col3 * col3 FROM input('col1 String, col2 Date, col3 Int32') FORMAT CSV"; +``` + +- Eğer `data.csv` aynı yapının verilerini içerir `test_structure` tablo olarak `test` sonra bu iki sorgu eşittir: + + + +``` bash +$ cat data.csv | clickhouse-client --query="INSERT INTO test FORMAT CSV" +$ cat data.csv | clickhouse-client --query="INSERT INTO test SELECT * FROM input('test_structure') FORMAT CSV" +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/input/) diff --git a/docs/tr/sql_reference/table_functions/jdbc.md b/docs/tr/sql_reference/table_functions/jdbc.md new file mode 100644 index 00000000000..451fdefc013 --- /dev/null +++ b/docs/tr/sql_reference/table_functions/jdbc.md @@ -0,0 +1,29 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 43 +toc_title: jdbc +--- + +# jdbc {#table-function-jdbc} + +`jdbc(jdbc_connection_uri, schema, table)` - JDBC sürücüsü ile bağlı döner tablo. + +Bu tablo işlevi ayrı gerektirir `clickhouse-jdbc-bridge` program çalıştırılacak. +Bu (sorgulanan uzak tablonun DDL dayalı) null türleri destekler. + +**Örnekler** + +``` sql +SELECT * FROM jdbc('jdbc:mysql://localhost:3306/?user=root&password=root', 'schema', 'table') +``` + +``` sql +SELECT * FROM jdbc('mysql://localhost:3306/?user=root&password=root', 'schema', 'table') +``` + +``` sql +SELECT * FROM jdbc('datasource://mysql-local', 'schema', 'table') +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/jdbc/) diff --git a/docs/tr/sql_reference/table_functions/merge.md b/docs/tr/sql_reference/table_functions/merge.md new file mode 100644 index 00000000000..67e1355383c --- /dev/null +++ b/docs/tr/sql_reference/table_functions/merge.md @@ -0,0 +1,14 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 38 +toc_title: "birle\u015Ftirmek" +--- + +# birleştirmek {#merge} + +`merge(db_name, 'tables_regexp')` – Creates a temporary Merge table. For more information, see the section “Table engines, Merge”. + +Tablo yapısı, normal ifadeyle eşleşen ilk tablodan alınır. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/merge/) diff --git a/docs/tr/sql_reference/table_functions/mysql.md b/docs/tr/sql_reference/table_functions/mysql.md new file mode 100644 index 00000000000..aee7311dc56 --- /dev/null +++ b/docs/tr/sql_reference/table_functions/mysql.md @@ -0,0 +1,86 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 42 +toc_title: mysql +--- + +# mysql {#mysql} + +Veriyor `SELECT` uzak bir MySQL sunucusunda depolanan veriler üzerinde gerçekleştirilecek sorgular. + +``` sql +mysql('host:port', 'database', 'table', 'user', 'password'[, replace_query, 'on_duplicate_clause']); +``` + +**Parametre** + +- `host:port` — MySQL server address. + +- `database` — Remote database name. + +- `table` — Remote table name. + +- `user` — MySQL user. + +- `password` — User password. + +- `replace_query` — Flag that converts `INSERT INTO` için sorgular `REPLACE INTO`. Eğer `replace_query=1`, sorgu değiştirilir. + +- `on_duplicate_clause` — The `ON DUPLICATE KEY on_duplicate_clause` eklenen ifade `INSERT` sorgu. + + Example: `INSERT INTO t (c1,c2) VALUES ('a', 2) ON DUPLICATE KEY UPDATE c2 = c2 + 1`, where `on_duplicate_clause` is `UPDATE c2 = c2 + 1`. See the MySQL documentation to find which `on_duplicate_clause` you can use with the `ON DUPLICATE KEY` clause. + + To specify `on_duplicate_clause` you need to pass `0` to the `replace_query` parameter. If you simultaneously pass `replace_query = 1` and `on_duplicate_clause`, ClickHouse generates an exception. + +Basit `WHERE` gibi maddeler `=, !=, >, >=, <, <=` şu anda MySQL sunucusunda yürütülür. + +Geri kalan şartlar ve `LIMIT` örnekleme kısıtlaması, yalnızca MySQL sorgusu bittikten sonra Clickhouse'da yürütülür. + +**Döndürülen Değer** + +Orijinal MySQL tablosu ile aynı sütunlara sahip bir tablo nesnesi. + +## Kullanım Örneği {#usage-example} + +MySQL tablo: + +``` text +mysql> CREATE TABLE `test`.`test` ( + -> `int_id` INT NOT NULL AUTO_INCREMENT, + -> `int_nullable` INT NULL DEFAULT NULL, + -> `float` FLOAT NOT NULL, + -> `float_nullable` FLOAT NULL DEFAULT NULL, + -> PRIMARY KEY (`int_id`)); +Query OK, 0 rows affected (0,09 sec) + +mysql> insert into test (`int_id`, `float`) VALUES (1,2); +Query OK, 1 row affected (0,00 sec) + +mysql> select * from test; ++------+----------+-----+----------+ +| int_id | int_nullable | float | float_nullable | ++------+----------+-----+----------+ +| 1 | NULL | 2 | NULL | ++------+----------+-----+----------+ +1 row in set (0,00 sec) +``` + +Clickhouse'dan veri seçme: + +``` sql +SELECT * FROM mysql('localhost:3306', 'test', 'test', 'bayonet', '123') +``` + +``` text +┌─int_id─┬─int_nullable─┬─float─┬─float_nullable─┐ +│ 1 │ ᴺᵁᴸᴸ │ 2 │ ᴺᵁᴸᴸ │ +└────────┴──────────────┴───────┴────────────────┘ +``` + +## Ayrıca Bakınız {#see-also} + +- [Bu ‘MySQL’ masa motoru](../../engines/table_engines/integrations/mysql.md) +- [Harici sözlük kaynağı olarak MySQL kullanma](../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_sources.md#dicts-external_dicts_dict_sources-mysql) + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/mysql/) diff --git a/docs/tr/sql_reference/table_functions/numbers.md b/docs/tr/sql_reference/table_functions/numbers.md new file mode 100644 index 00000000000..45ca2f5f45d --- /dev/null +++ b/docs/tr/sql_reference/table_functions/numbers.md @@ -0,0 +1,30 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 39 +toc_title: "\u015Fiir" +--- + +# şiir {#numbers} + +`numbers(N)` – Returns a table with the single ‘number’ 0'dan n-1'e kadar tamsayılar içeren sütun (Uİnt64). +`numbers(N, M)` - Tek bir tablo döndürür ‘number’ n'den (n + M - 1) tamsayıları içeren sütun (Uİnt64). + +Benzer `system.numbers` tablo, ardışık değerleri test etmek ve üretmek için kullanılabilir, `numbers(N, M)` daha verimli `system.numbers`. + +Aşağıdaki sorgular eşdeğerdir: + +``` sql +SELECT * FROM numbers(10); +SELECT * FROM numbers(0, 10); +SELECT * FROM system.numbers LIMIT 10; +``` + +Örnekler: + +``` sql +-- Generate a sequence of dates from 2010-01-01 to 2010-12-31 +select toDate('2010-01-01') + number as d FROM numbers(365); +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/numbers/) diff --git a/docs/tr/sql_reference/table_functions/odbc.md b/docs/tr/sql_reference/table_functions/odbc.md new file mode 100644 index 00000000000..d250ce21311 --- /dev/null +++ b/docs/tr/sql_reference/table_functions/odbc.md @@ -0,0 +1,108 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 44 +toc_title: odbc +--- + +# odbc {#table-functions-odbc} + +Üzerinden bağlanan tabloyu döndürür [ODBC](https://en.wikipedia.org/wiki/Open_Database_Connectivity). + +``` sql +odbc(connection_settings, external_database, external_table) +``` + +Parametre: + +- `connection_settings` — Name of the section with connection settings in the `odbc.ini` Dosya. +- `external_database` — Name of a database in an external DBMS. +- `external_table` — Name of a table in the `external_database`. + +ODBC bağlantılarını güvenli bir şekilde uygulamak için ClickHouse ayrı bir program kullanır `clickhouse-odbc-bridge`. ODBC sürücüsü doğrudan yüklenmişse `clickhouse-server`, sürücü sorunları ClickHouse sunucu çökmesine neden olabilir. ClickHouse otomatik olarak başlar `clickhouse-odbc-bridge` gerekli olduğunda. ODBC Köprüsü programı aynı paketten yüklenir `clickhouse-server`. + +Alanları ile `NULL` dış tablodaki değerler, temel veri türü için varsayılan değerlere dönüştürülür. Örneğin, uzak bir MySQL tablo alanı `INT NULL` yazın 0'a dönüştürülür (ClickHouse için varsayılan değer `Int32` veri türü). + +## Kullanım örneği {#usage-example} + +**ODBC üzerinden yerel MySQL kurulumundan veri alma** + +Bu örnek Ubuntu Linux 18.04 ve MySQL server 5.7 için kontrol edilir. + +UnixODBC ve MySQL Connector yüklü olduğundan emin olun. + +Varsayılan olarak (paketlerden yüklüyse), ClickHouse kullanıcı olarak başlar `clickhouse`. Bu nedenle, bu kullanıcıyı MySQL sunucusunda oluşturmanız ve yapılandırmanız gerekir. + +``` bash +$ sudo mysql +``` + +``` sql +mysql> CREATE USER 'clickhouse'@'localhost' IDENTIFIED BY 'clickhouse'; +mysql> GRANT ALL PRIVILEGES ON *.* TO 'clickhouse'@'clickhouse' WITH GRANT OPTION; +``` + +Sonra bağlantıyı yapılandırın `/etc/odbc.ini`. + +``` bash +$ cat /etc/odbc.ini +[mysqlconn] +DRIVER = /usr/local/lib/libmyodbc5w.so +SERVER = 127.0.0.1 +PORT = 3306 +DATABASE = test +USERNAME = clickhouse +PASSWORD = clickhouse +``` + +Kullanarak bağlantıyı kontrol edebilirsiniz `isql` unixodbc yüklemesinden yardımcı program. + +``` bash +$ isql -v mysqlconn ++-------------------------+ +| Connected! | +| | +... +``` + +MySQL tablo: + +``` text +mysql> CREATE TABLE `test`.`test` ( + -> `int_id` INT NOT NULL AUTO_INCREMENT, + -> `int_nullable` INT NULL DEFAULT NULL, + -> `float` FLOAT NOT NULL, + -> `float_nullable` FLOAT NULL DEFAULT NULL, + -> PRIMARY KEY (`int_id`)); +Query OK, 0 rows affected (0,09 sec) + +mysql> insert into test (`int_id`, `float`) VALUES (1,2); +Query OK, 1 row affected (0,00 sec) + +mysql> select * from test; ++------+----------+-----+----------+ +| int_id | int_nullable | float | float_nullable | ++------+----------+-----+----------+ +| 1 | NULL | 2 | NULL | ++------+----------+-----+----------+ +1 row in set (0,00 sec) +``` + +Clickhouse'daki MySQL tablosundan veri alma: + +``` sql +SELECT * FROM odbc('DSN=mysqlconn', 'test', 'test') +``` + +``` text +┌─int_id─┬─int_nullable─┬─float─┬─float_nullable─┐ +│ 1 │ 0 │ 2 │ 0 │ +└────────┴──────────────┴───────┴────────────────┘ +``` + +## Ayrıca Bakınız {#see-also} + +- [ODBC harici sözlükler](../../sql_reference/dictionaries/external_dictionaries/external_dicts_dict_sources.md#dicts-external_dicts_dict_sources-odbc) +- [ODBC tablo motoru](../../engines/table_engines/integrations/odbc.md). + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/jdbc/) diff --git a/docs/tr/sql_reference/table_functions/remote.md b/docs/tr/sql_reference/table_functions/remote.md new file mode 100644 index 00000000000..58c4154643c --- /dev/null +++ b/docs/tr/sql_reference/table_functions/remote.md @@ -0,0 +1,83 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 40 +toc_title: uzak +--- + +# uzaktan, remoteSecure {#remote-remotesecure} + +Oluşturmadan uzak sunuculara erişmenizi sağlar. `Distributed` Tablo. + +İmzalar: + +``` sql +remote('addresses_expr', db, table[, 'user'[, 'password']]) +remote('addresses_expr', db.table[, 'user'[, 'password']]) +``` + +`addresses_expr` – An expression that generates addresses of remote servers. This may be just one server address. The server address is `host:port` ya da sadece `host`. Ana bilgisayar sunucu adı veya IPv4 veya IPv6 adresi olarak belirtilebilir. Köşeli parantez içinde bir IPv6 adresi belirtilir. Bağlantı noktası, uzak sunucudaki TCP bağlantı noktasıdır. Bağlantı noktası atlanırsa, kullanır `tcp_port` sunucunun yapılandırma dosyasından (varsayılan olarak, 9000). + +!!! important "Önemli" + Bir IPv6 adresi için bağlantı noktası gereklidir. + +Örnekler: + +``` text +example01-01-1 +example01-01-1:9000 +localhost +127.0.0.1 +[::]:9000 +[2a02:6b8:0:1111::11]:9000 +``` + +Birden çok Adres virgülle ayrılmış olabilir. Bu durumda, ClickHouse dağıtılmış işleme kullanır, bu nedenle sorguyu belirtilen tüm adreslere gönderir (farklı verilerle kırıklar gibi). + +Örnek: + +``` text +example01-01-1,example01-02-1 +``` + +İfadenin bir kısmı kıvırcık parantez içinde belirtilebilir. Önceki örnek aşağıdaki gibi yazılabilir: + +``` text +example01-0{1,2}-1 +``` + +Kıvırcık parantez iki nokta (negatif olmayan tamsayılar) ile ayrılmış bir sayı aralığı içerebilir. Bu durumda, Aralık, shard adresleri üreten bir değer kümesine genişletilir. İlk sayı sıfır ile başlarsa, değerler aynı sıfır hizalamasıyla oluşturulur. Önceki örnek aşağıdaki gibi yazılabilir: + +``` text +example01-{01..02}-1 +``` + +Birden fazla kıvırcık parantez çiftiniz varsa, ilgili kümelerin doğrudan ürününü oluşturur. + +Adresler ve kıvırcık parantez içindeki adreslerin parçaları boru sembolü (\|) ile ayrılabilir. Bu durumda, karşılık gelen Adres kümeleri yinelemeler olarak yorumlanır ve sorgu ilk sağlıklı yinelemeye gönderilir. Ancak, yinelemeler şu anda ayarlanmış sırayla yinelenir [dengeleme](../../operations/settings/settings.md) ayar. + +Örnek: + +``` text +example01-{01..02}-{1|2} +``` + +Bu örnek, her birinin iki kopyası olan iki parçayı belirtir. + +Oluşturulan Adres sayısı bir sabit tarafından sınırlıdır. Şu anda bu 1000 Adres. + +Kullanarak `remote` tablo işlevi, bir `Distributed` tablo, çünkü bu durumda, her istek için sunucu bağlantısı yeniden kurulur. Buna ek olarak, ana bilgisayar adları ayarlanmışsa, adlar giderilir ve çeşitli yinelemelerle çalışırken hatalar sayılmaz. Çok sayıda sorgu işlerken, her zaman `Distributed` masa vaktinden önce, ve kullanmayın `remote` tablo işlevi. + +Bu `remote` tablo işlevi aşağıdaki durumlarda yararlı olabilir: + +- Veri karşılaştırma, hata ayıklama ve sınama için belirli bir sunucuya erişme. +- Araştırma amaçlı çeşitli ClickHouse kümeleri arasındaki sorgular. +- El ile yapılan seyrek dağıtılmış istekler. +- Sunucu kümesinin her seferinde yeniden tanımlandığı dağıtılmış istekler. + +Kullanıcı belirtilmemişse, `default` kullanılır. +Parola belirtilmezse, boş bir parola kullanılır. + +`remoteSecure` - aynı `remote` but with secured connection. Default port — [tcp\_port\_secure](../../operations/server_configuration_parameters/settings.md#server_configuration_parameters-tcp_port_secure) yapılandırma veya 9440'ten. + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/remote/) diff --git a/docs/tr/sql_reference/table_functions/url.md b/docs/tr/sql_reference/table_functions/url.md new file mode 100644 index 00000000000..bb841fd344c --- /dev/null +++ b/docs/tr/sql_reference/table_functions/url.md @@ -0,0 +1,26 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 41 +toc_title: url +--- + +# url {#url} + +`url(URL, format, structure)` - oluşturulan bir tablo döndürür `URL` verilen ile +`format` ve `structure`. + +Kabul edebilen URL - HTTP veya HTTPS sunucu adresi `GET` ve / veya `POST` istemler. + +biçimli - [biçimli](../../interfaces/formats.md#formats) verilerin. + +yapı-tablo yapısı `'UserID UInt64, Name String'` biçimli. Sütun adlarını ve türlerini belirler. + +**Örnek** + +``` sql +-- getting the first 3 lines of a table that contains columns of String and UInt32 type from HTTP-server which answers in CSV format. +SELECT * FROM url('http://127.0.0.1:12345/', CSV, 'column1 String, column2 UInt32') LIMIT 3 +``` + +[Orijinal makale](https://clickhouse.tech/docs/en/query_language/table_functions/url/) diff --git a/docs/tr/whats_new/changelog/2017.md b/docs/tr/whats_new/changelog/2017.md new file mode 100644 index 00000000000..2f31be7f6de --- /dev/null +++ b/docs/tr/whats_new/changelog/2017.md @@ -0,0 +1,268 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 79 +toc_title: '2017' +--- + +### ClickHouse sürüm 1.1.54327, 2017-12-21 {#clickhouse-release-1-1-54327-2017-12-21} + +Bu sürüm önceki sürüm 1.1.54318 için hata düzeltmeleri içerir: + +- Veri kaybına yol açabilir çoğaltma Olası yarış koşulu ile Sabit hata. Bu sorun sürümleri 1.1.54310 ve 1.1.54318 etkiler. Bu sürümlerden birini çoğaltılmış tablolarla kullanırsanız, güncelleştirme önerilir. Bu sorun, aşağıdaki gibi uyarı iletilerindeki günlüklerde gösterilir `Part ... from own log doesn't exist.` Bu iletileri günlüklerde görmeseniz bile sorun geçerlidir. + +### ClickHouse sürümü 1.1.54318, 2017-11-30 {#clickhouse-release-1-1-54318-2017-11-30} + +Bu sürüm önceki sürüm 1.1.54310 için hata düzeltmeleri içerir: + +- SummingMergeTree motorunda birleştirmeler sırasında hatalı satır silme işlemleri düzeltildi +- Unreplicated MergeTree motorlarında bir bellek sızıntısı düzeltildi +- MergeTree motorlarında sık sık eklerle sabit performans düşüşü +- Çoğaltma kuyruğunun çalışmayı durdurmasına neden olan bir sorun giderildi +- Sunucu günlüklerinin sabit rotasyonu ve arşivlenmesi + +### ClickHouse sürümü 1.1.54310, 2017-11-01 {#clickhouse-release-1-1-54310-2017-11-01} + +#### Yenilik: {#new-features} + +- Tablo motorları MergeTree ailesi için özel bölümleme anahtarı. +- [Kafka](https://clickhouse.yandex/docs/en/operations/table_engines/kafka/) masa motoru. +- Yükleme için destek eklendi [CatBoost](https://catboost.yandex/) modelleri ve ClickHouse saklanan verilere uygulayarak. +- UTC olmayan tamsayı uzaklıklar ile saat dilimleri için destek eklendi. +- Zaman aralıklarıyla aritmetik işlemler için destek eklendi. +- Tarih ve DateTime türleri için değer aralığı 2105 yılına genişletilir. +- Add theed the `CREATE MATERIALIZED VIEW x TO y` sorgu (materyalleştirilmiş bir görünümün verilerini depolamak için varolan bir tabloyu belirtir). +- Add theed the `ATTACH TABLE` argüman olmadan sorgu. +- Bir SummingMergeTree tablosunda-Map biten adları ile iç içe sütunlar için işleme mantığı için ayıklandı sumMap toplama işlevi. Şimdi bu tür sütunları açıkça belirtebilirsiniz. +- IP trie sözlüğünün maksimum boyutu 128M girişlerine yükseltilir. +- GetSizeOfEnumType işlevi eklendi. +- SumWithOverflow toplama işlevi eklendi. +- Cap'n Proto giriş biçimi için destek eklendi. +- Artık zstd algoritmasını kullanırken sıkıştırma seviyesini özelleştirebilirsiniz. + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes} + +- Bellek dışında bir motor ile geçici tablolar oluşturulmasına izin verilmez. +- View veya MaterializedView altyapısı ile tabloların açık oluşturulmasına izin verilmez. +- Tablo oluşturma sırasında yeni bir onay örnekleme anahtar ifadesinin birincil anahtara dahil edildiğini doğrular. + +#### Hata düzeltmeleri: {#bug-fixes} + +- Sabit hangups zaman eşzamanlı bir dağıtılmış tabloya ekleme. +- Sabit atomik olmayan ekleme ve çoğaltılmış tablolarda parçaların çıkarılması. +- Materialized görünümüne eklenen veriler gereksiz tekilleştirme tabi değildir. +- Yerel yinelemenin geciktiği ve uzak yinelemelerin kullanılamadığı dağıtılmış bir tabloya bir sorgu yürütmek artık bir hataya neden olmaz. +- Kullanıcıların erişim izinlerine ihtiyacı yoktur `default` veritabanı artık geçici tablolar oluşturmak için. +- Bağımsız değişkenler olmadan dizi türünü belirtirken çökmesini düzeltildi. +- Sunucu günlüklerini içeren disk birimi dolu olduğunda sabit hangups. +- Unix döneminin ilk haftası için toRelativeWeekNum işlevinde bir taşma düzeltildi. + +#### İyileştirmeler oluşturun: {#build-improvements} + +- Birkaç üçüncü taraf Kütüphanesi (özellikle Poco) güncellendi ve git alt modüllerine dönüştürüldü. + +### ClickHouse sürümü 1.1.54304, 2017-10-19 {#clickhouse-release-1-1-54304-2017-10-19} + +#### Yenilik: {#new-features-1} + +- Yerel protokolde TLS desteği (etkinleştirmek, ayarlamak için `tcp_ssl_port` içinde `config.xml` ). + +#### Hata düzeltmeleri: {#bug-fixes-1} + +- `ALTER` çoğaltılmış tablolar için şimdi en kısa sürede çalışmaya başlamak çalışır. +- Ayarı ile veri okurken çökmesini sabit `preferred_block_size_bytes=0.` +- Sabit çöker `clickhouse-client` bas whenarken `Page Down` +- Bazı karmaşık sorguların doğru yorumlanması `GLOBAL IN` ve `UNION ALL` +- `FREEZE PARTITION` her zaman atomik olarak çalışır. +- Boş posta istekleri şimdi 411 koduyla bir yanıt döndürür. +- Gibi ifadeler için sabit yorumlama hataları `CAST(1 AS Nullable(UInt8)).` +- Okurken bir hata düzeltildi `Array(Nullable(String))` Col fromum fromns from `MergeTree` Tablolar. +- Gibi sorguları ayrıştırırken sabit çökmesini `SELECT dummy AS dummy, dummy AS b` +- Kullanıcılar geçersiz ile doğru güncellenir `users.xml` +- Yürütülebilir bir sözlük sıfır olmayan bir yanıt kodu döndürdüğünde doğru işleme. + +### ClickHouse yayın 1.1.54292, 2017-09-20 {#clickhouse-release-1-1-54292-2017-09-20} + +#### Yenilik: {#new-features-2} + +- Add theed the `pointInPolygon` koordinat düzleminde koordinatlarla çalışmak için işlev. +- Add theed the `sumMap` benzer dizilerin toplamını hesaplamak için toplama işlevi `SummingMergeTree`. +- Add theed the `trunc` işlev. Yuvarlama fonksiyonlarının geliştirilmiş performansı (`round`, `floor`, `ceil`, `roundToExp2`) ve nasıl çalıştıklarının mantığını düzeltti. Mantığını değiştirdi `roundToExp2` kesirler ve negatif sayılar için işlev. +- ClickHouse yürütülebilir dosyası artık libc sürümüne daha az bağımlıdır. Aynı ClickHouse yürütülebilir dosya Linux sistemleri çok çeşitli çalıştırabilirsiniz. Derlenmiş sorguları kullanırken hala bir bağımlılık var (ayar ile `compile = 1` , varsayılan olarak kullanılmaz). +- Sorguların dinamik derlenmesi için gereken süreyi azalttı. + +#### Hata düzeltmeleri: {#bug-fixes-2} + +- Bazen üretilen bir hata düzeltildi `part ... intersects previous part` mesajlar ve kopya tutarlılığı zayıfladı. +- ZooKeeper kapatma sırasında kullanılamıyorsa sunucunun kilitlenmesine neden olan bir hata düzeltildi. +- Kopyaları geri yüklerken aşırı günlüğü kaldırıldı. +- Birlik tüm uygulamasında bir hata düzeltildi. +- Bir bloktaki ilk sütun dizi türüne sahipse, concat işlevinde bir hata düzeltildi. +- İlerleme şimdi sistemde doğru görüntülenir.tablo birleştirir. + +### ClickHouse yayın 1.1.54289, 2017-09-13 {#clickhouse-release-1-1-54289-2017-09-13} + +#### Yenilik: {#new-features-3} + +- `SYSTEM` sunucu yönetimi için sorgular: `SYSTEM RELOAD DICTIONARY`, `SYSTEM RELOAD DICTIONARIES`, `SYSTEM DROP DNS CACHE`, `SYSTEM SHUTDOWN`, `SYSTEM KILL`. +- Dizilerle çalışmak için işlevler eklendi: `concat`, `arraySlice`, `arrayPushBack`, `arrayPushFront`, `arrayPopBack`, `arrayPopFront`. +- Katma `root` ve `identity` ZooKeeper yapılandırması için parametreler. Bu, aynı ZooKeeper kümesinde tek tek kullanıcıları izole etmenizi sağlar. +- Toplam fonksiyonları eklendi `groupBitAnd`, `groupBitOr`, ve `groupBitXor` (uyumluluk için, isimler altında da mevcuttur `BIT_AND`, `BIT_OR`, ve `BIT_XOR`). +- Dış sözlükler dosya sisteminde bir soket belirterek Mysql'den yüklenebilir. +- Harici sözlükler SSL üzerinden MySQL yüklenebilir (`ssl_cert`, `ssl_key`, `ssl_ca` parametre). +- Add theed the `max_network_bandwidth_for_user` kullanıcı başına sorgular için genel bant genişliği kullanımını kısıtlamak için ayarlama. +- İçin destek `DROP TABLE` geçici tablolar için. +- Okuma desteği `DateTime` Unix zaman damgası biçimindeki değerler `CSV` ve `JSONEachRow` biçimliler. +- Dağıtılmış sorgularda gecikmeli yinelemeler artık varsayılan olarak dışlanır (varsayılan eşik 5 dakikadır). +- FIFO kilitleme sırasında kullanılır ALTER: bir ALTER sorgusu sürekli çalışan sorgular için süresiz olarak engellenmez. +- Seçeneği ayarlamak için `umask` yapılandırma dosyasında. +- İle sorgular için geliştirilmiş performans `DISTINCT` . + +#### Hata düzeltmeleri: {#bug-fixes-3} + +- ZooKeeper eski düğümleri silme işlemi geliştirildi. Daha önce, eski düğümler bazen çok sık ekler varsa silinmedi, bu da sunucunun diğer şeylerin yanı sıra kapanması için yavaş olmasına neden oldu. +- ZooKeeper bağlantı için ana seçerken sabit randomizasyon. +- Çoğaltma localhost ise, dağıtılmış sorgularda gecikmiş kopyaların dışlanması düzeltildi. +- Bir veri parçası bir hata düzeltildi `ReplicatedMergeTree` tablo çalıştırdıktan sonra kırık olabilir `ALTER MODIFY` bir element üzerinde `Nested` yapılı. +- SELECT sorgularına neden olabilecek bir hata düzeltildi “hang”. +- Dağıtılmış DDL sorguları için iyileştirmeler. +- Sorgu düzeltildi `CREATE TABLE ... AS `. +- Çık themaz theı Çöz thedü `ALTER ... CLEAR COLUMN IN PARTITION` sorgu için `Buffer` Tablolar. +- İçin geçersiz varsayılan değer düzeltildi `Enum` kullanırken s (minimum yerine 0) `JSONEachRow` ve `TSKV` biçimliler. +- Bir sözlük ile bir sözlük kullanırken zombi süreçlerinin görünümünü çözdü `executable` kaynaklı. +- Kafa sorgusu için sabit segfault. + +#### ClickHouse geliştirmek ve birleştirmek için geliştirilmiş iş akışı: {#improved-workflow-for-developing-and-assembling-clickhouse} + +- Kullanabilirsiniz `pbuilder` ClickHouse inşa etmek. +- Kullanabilirsiniz `libc++` yerine `libstdc++` Linux üzerine inşa edilmiştir. +- Statik kod analiz araçlarını kullanma talimatları eklendi: `Coverage`, `clang-tidy`, `cppcheck`. + +#### Yükseltme yaparken lütfen unutmayın: {#please-note-when-upgrading} + +- MergeTree ayarı için artık daha yüksek bir varsayılan değer var `max_bytes_to_merge_at_max_space_in_pool` (bayt olarak birleştirilecek veri parçalarının maksimum toplam boyutu): 100 Gib'den 150 Gib'e yükseldi. Bu, disk Alt Sisteminde artan bir yüke neden olabilecek sunucu yükseltmesinden sonra çalışan büyük birleştirmelere neden olabilir. Sunucuda kullanılabilir boş alan, çalışan birleştirmelerin toplam miktarının iki katından azsa, bu, diğer tüm birleştirmelerin, küçük veri parçalarının birleştirmeleri de dahil olmak üzere çalışmayı durdurmasına neden olur. Sonuç olarak, INSERT sorguları iletiyle başarısız olur “Merges are processing significantly slower than inserts.” Kullan... `SELECT * FROM system.merges` durumu izlemek için sorgu. Ayrıca kontrol edebilirsiniz `DiskSpaceReservedForMerge` metr theik `system.metrics` tablo veya Grafit. Bunu düzeltmek için hiçbir şey yapmanıza gerek yoktur, çünkü büyük birleşimler bittikten sonra sorun kendiliğinden çözülür. Bu kabul edilemez bulursanız, önceki değeri geri yükleyebilirsiniz `max_bytes_to_merge_at_max_space_in_pool` ayar. Bunu yapmak için, gidin config bölümünde.xml, set ``` ``107374182400 ``` ve sunucuyu yeniden başlatın. + +### ClickHouse sürümü 1.1.54284, 2017-08-29 {#clickhouse-release-1-1-54284-2017-08-29} + +- Bu, önceki 1.1.54282 sürümü için bir hata düzeltme sürümüdür. Bu ZooKeeper parçalar dizininde sızıntıları giderir. + +### ClickHouse yayın 1.1.54282, 2017-08-23 {#clickhouse-release-1-1-54282-2017-08-23} + +Bu sürüm önceki sürüm 1.1.54276 için hata düzeltmeleri içerir: + +- Sabit `DB::Exception: Assertion violation: !_path.empty()` dağıtılmış bir tabloya eklerken. +- Giriş verileri'; ' ile başlarsa RowBinary biçiminde eklerken ayrıştırma düzeltildi. +- Errors during runtime compilation of certain aggregate functions (e.g. `groupArray()`). + +### ClickHouse Yayın 1.1.54276, 2017-08-16 {#clickhouse-release-1-1-54276-2017-08-16} + +#### Yenilik: {#new-features-4} + +- Bir seçme sorgusu için bölüm ile isteğe bağlı eklendi. Örnek sorgu: `WITH 1+1 AS a SELECT a, a*a` +- INSERT, dağıtılmış bir tabloda eşzamanlı olarak gerçekleştirilebilir: Tamam, yalnızca tüm veriler tüm parçalara kaydedildikten sonra döndürülür. Bu ayar tarafından etkinleştirilir ınsert\_distributed\_sync = 1. +- 16 baytlık tanımlayıcılarla çalışmak için UUID veri türü eklendi. +- Tablo ile uyumluluk için CHAR, FLOAT ve diğer türlerin takma adları eklendi. +- Sayılara zaman dönüştürmek için fonksiyonları toYYYYMM, toYYYYMMDD ve toYYYYMMDDhhmmss eklendi. +- Kümelenmiş DDL sorguları için sunucuları tanımlamak için IP adreslerini (ana bilgisayar adı ile birlikte) kullanabilirsiniz. +- İşlevde sabit olmayan argümanlar ve negatif uzaklıklar için destek eklendi `substring(str, pos, len).` +- İçin max\_size parametresi eklendi `groupArray(max_size)(column)` toplama işlevi ve performansını optimize etti. + +#### Ana değişiklikler: {#main-changes} + +- Güvenlik iyileştirmeleri: tüm sunucu dosyaları 0640 izinleriyle oluşturulur (üzerinden değiştirilebilir config parametresi). +- Geçersiz sözdizimi ile sorgular için geliştirilmiş hata mesajları. +- MergeTree verilerinin büyük bölümlerini birleştirirken bellek tüketimini önemli ölçüde azalttı ve performansı artırdı. +- ReplacingMergeTree motoru için veri birleştirmelerinin performansını önemli ölçüde artırdı. +- Birden çok kaynak ekler birleştirerek dağıtılmış bir tablodan zaman uyumsuz ekler için geliştirilmiş performans. Bu işlevi etkinleştirmek için distributed\_directory\_monitor\_batch\_ınserts = 1 ayarını kullanın. + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-1} + +- Toplam durumların ikili biçimini değiştirdi `groupArray(array_column)` diziler için fonksiyonlar. + +#### Değişikliklerin tam listesi: {#complete-list-of-changes} + +- Add theed the `output_format_json_quote_denormals` json formatında nan ve ınf değerleri çıktısı sağlayan ayar. +- Dağıtılmış bir tablodan okurken optimize edilmiş akış tahsisi. +- Değer değişmezse ayarlar salt okunur modda yapılandırılabilir. +- Preferred\_block\_size\_bytes ayarında belirtilen blok boyutu üzerindeki kısıtlamaları karşılamak için mergetree motorunun tamsayı olmayan granüllerini alma yeteneği eklendi. Amaç, RAM tüketimini azaltmak ve büyük sütunlu tablolardan gelen sorguları işlerken önbellek konumunu arttırmaktır. +- Gibi ifadeler içeren dizinlerin verimli kullanımı `toStartOfHour(x)` gibi koşullar için `toStartOfHour(x) op сonstexpr.` +- MergeTree motorları için yeni ayarlar eklendi (yapılandırmada merge\_tree bölümü.xml): + - replicated\_deduplication\_window\_seconds yinelenen tablolar ekler tekilleştirme için izin verilen saniye sayısını ayarlar. + - cleanup\_delay\_period, eski verileri kaldırmak için temizleme işleminin ne sıklıkta başlatılacağını ayarlar. + - replicated\_can\_become\_leader, bir kopyanın lider olmasını (ve birleştirme atamasını) engelleyebilir. +- Hızlandırılmış Temizleme ZooKeeper eski verileri kaldırmak için. +- Kümelenmiş DDL sorguları için birden fazla iyileştirme ve düzeltme. Özellikle ilgi çekici olan yeni ayardır distributed\_ddl\_task\_timeout, kümedeki sunuculardan bir yanıt beklemek için zamanı sınırlar. Tüm ana bilgisayarlarda bir ddl isteği gerçekleştirilmediyse, bir yanıt bir zaman aşımı hatası içerir ve bir zaman uyumsuz modunda bir istek yürütülür. +- Sunucu günlüklerinde yığın izlerinin geliştirilmiş gösterimi. +- Add theed the “none” sıkıştırma yöntemi için değer. +- Yapılandırmada birden çok dictionaries\_config bölümünü kullanabilirsiniz.xml. +- Bu dosya sisteminde bir soket üzerinden MySQL bağlanmak mümkündür. +- Sistem.parçalar tablosu, bayt cinsinden işaretlerin boyutu hakkında bilgi içeren yeni bir sütuna sahiptir. + +#### Hata düzeltmeleri: {#bug-fixes-4} + +- Bir birleştirme tablosu kullanarak dağıtılmış tablolar artık bir koşulla bir SELECT sorgusu için doğru şekilde çalışır. `_table` alan. +- Veri parçalarını kontrol ederken ReplicatedMergeTree nadir bir yarış durumu düzeltildi. +- Sabit Olası donma “leader election” bir sunucu başlatırken. +- Veri kaynağının yerel bir kopyasını kullanırken max\_replica\_delay\_for\_distributed\_queries ayarı göz ardı edildi. Bu sorun giderildi. +- Sabit yanlış davranış `ALTER TABLE CLEAR COLUMN IN PARTITION` varolan olmayan bir sütunu temizlemeye çalışırken. +- Boş diziler veya dizeleri kullanırken multiİf işlevinde bir istisna düzeltildi. +- Sabit aşırı bellek ayırmaları yerel biçimi serisini kaldırırken. +- Trie sözlüklerin sabit yanlış otomatik güncelleme. +- Örnek kullanırken bir birleştirme tablosundan bir GROUP BY yan tümcesi ile sorguları çalıştırırken bir özel durum düzeltildi. +- Distributed\_aggregation\_memory\_efficient = 1 kullanırken grup çökmesi düzeltildi. +- Şimdi veritabanını belirtebilirsiniz.ın ve JOİN sağ tarafında tablo. +- Paralel toplama için çok fazla iplik kullanıldı. Bu sorun giderildi. +- Sabit nasıl “if” işlev FixedString argümanları ile çalışır. +- 0 ağırlığında kırıkları için dağıtılmış bir tablodan yanlış çalıştı seçin. Bu sorun giderildi. +- Çalışma `CREATE VIEW IF EXISTS no longer causes crashes.` +- Sabit yanlış davranış input\_format\_skip\_unknown\_fields=1 ayarlanır ve negatif sayılar vardır. +- Sabit bir sonsuz döngü içinde `dictGetHierarchy()` sözlükte bazı geçersiz veriler varsa işlev. +- Sabit `Syntax error: unexpected (...)` bir In veya JOIN yan tümcesi ve birleştirme tablolarındaki alt sorgularla dağıtılmış sorguları çalıştırırken hatalar. +- Sözlük tablolarından bir seçme sorgusunun yanlış yorumlanması düzeltildi. +- Sabit “Cannot mremap” 2 milyardan fazla öğe içeren ın ve JOIN yan tümcelerinde diziler kullanılırken hata oluştu. +- Kaynak olarak MySQL ile sözlükler için yük devretme düzeltildi. + +#### ClickHouse geliştirmek ve birleştirmek için geliştirilmiş iş akışı: {#improved-workflow-for-developing-and-assembling-clickhouse-1} + +- Yapılar Arcadia'da monte edilebilir. +- Clickhouse'u derlemek için gcc 7'yi kullanabilirsiniz. +- Ccache+distcc kullanarak paralel yapılar artık daha hızlı. + +### ClickHouse yayın 1.1.54245, 2017-07-04 {#clickhouse-release-1-1-54245-2017-07-04} + +#### Yenilik: {#new-features-5} + +- Dağıtılmış DDL (örneğin, `CREATE TABLE ON CLUSTER`) +- Çoğaltılan sorgu `ALTER TABLE CLEAR COLUMN IN PARTITION.` +- Sözlük tabloları için motor (bir tablo şeklinde sözlük verilerine erişim). +- Sözlük veritabanı motoru (bu tür veritabanı otomatik olarak bağlı tüm dış sözlükler için sözlük tabloları vardır). +- Kaynağa bir istek göndererek sözlükteki güncellemeleri kontrol edebilirsiniz. +- Nitelikli sütun adları +- Çift tırnak işaretleri kullanarak tanımlayıcıları alıntı. +- HTTP arabirimindeki oturumlar. +- Çoğaltılmış bir tablo için en iyi duruma getirme sorgusu yalnızca lider üzerinde çalışabilir. + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-2} + +- Kaldırıldı set GLOBAL. + +#### Küçük değişiklikler: {#minor-changes} + +- Şimdi bir uyarı tetiklendikten sonra günlük tam yığın izleme yazdırır. +- Başlangıçta hasarlı / ekstra veri parçalarının sayısının doğrulanmasını rahatlattı(çok fazla yanlış pozitif vardı). + +#### Hata düzeltmeleri: {#bug-fixes-5} + +- Kötü bir bağlantı düzeltildi “sticking” dağıtılmış bir tabloya eklerken. +- GLOBAL IN şimdi dağıtılmış bir tabloya bakan bir birleştirme tablosundan bir sorgu için çalışır. +- Bir Google Compute Engine sanal makinesinde yanlış sayıda çekirdek tespit edildi. Bu sorun giderildi. +- Önbelleğe alınmış harici sözlüklerin yürütülebilir bir kaynağının nasıl çalıştığındaki değişiklikler. +- Null karakter içeren dizelerin karşılaştırması düzeltildi. +- Float32 birincil anahtar alanlarının sabitler ile karşılaştırılması düzeltildi. +- Önceden, bir alanın boyutunun yanlış bir tahmini, aşırı büyük tahsisatlara neden olabilir. +- Alter kullanarak bir tabloya eklenen null bir sütun sorgularken bir kilitlenme düzeltildi. +- Satır sayısı sınırdan az ise, null bir sütuna göre sıralama yaparken bir kilitlenme düzeltildi. +- Yalnızca sabit değerlerden oluşan alt sorgu ile bir sipariş düzeltildi. +- Daha önce, çoğaltılmış bir tablo başarısız bir bırakma tablosundan sonra geçersiz durumda kalabilir. +- Boş sonuçları olan skaler alt sorgular için takma adlar artık kaybolmaz. +- Şimdi derleme kullanılan bir sorgu .so dosyası zarar görürse bir hata ile başarısız değil. diff --git a/docs/tr/whats_new/changelog/2018.md b/docs/tr/whats_new/changelog/2018.md new file mode 100644 index 00000000000..884c1725bbd --- /dev/null +++ b/docs/tr/whats_new/changelog/2018.md @@ -0,0 +1,1063 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 78 +toc_title: '2018' +--- + +## ClickHouse sürümü 18.16 {#clickhouse-release-18-16} + +### ClickHouse sürümü 18.16.1, 2018-12-21 {#clickhouse-release-18-16-1-2018-12-21} + +#### Hata düzeltmeleri: {#bug-fixes} + +- ODBC kaynağı ile sözlükleri güncelleme ile ilgili sorunlara yol açan bir hata düzeltildi. [\#3825](https://github.com/ClickHouse/ClickHouse/issues/3825), [\#3829](https://github.com/ClickHouse/ClickHouse/issues/3829) +- Toplama işlevlerinin JIT derlemesi artık LowCardinality sütunlarıyla çalışır. [\#3838](https://github.com/ClickHouse/ClickHouse/issues/3838) + +#### Geliştirmeler: {#improvements} + +- Add theed the `low_cardinality_allow_in_native_format` ayar (varsayılan: etkin). Devre dışı bırakıldığında, LOWCARDİNALİTY sütunları, SELECT sorguları için sıradan sütunlara dönüştürülür ve INSERT sorguları için sıradan sütunlar beklenir. [\#3879](https://github.com/ClickHouse/ClickHouse/pull/3879) + +#### İyileştirmeler oluşturun: {#build-improvements} + +- MacOS ve ARM üzerine inşa için düzeltmeler. + +### ClickHouse yayın 18.16.0, 2018-12-14 {#clickhouse-release-18-16-0-2018-12-14} + +#### Yenilik: {#new-features} + +- `DEFAULT` ifadeler, yarı yapılandırılmış giriş biçimlerinde veri yüklenirken eksik alanlar için değerlendirilir (`JSONEachRow`, `TSKV`). Özelliği ile etkin `insert_sample_with_metadata` ayar. [\#3555](https://github.com/ClickHouse/ClickHouse/pull/3555) +- Bu `ALTER TABLE` sorgu şimdi var `MODIFY ORDER BY` bir tablo sütunu eklerken veya kaldırırken sıralama anahtarını değiştirme eylemi. Bu tablolar için yararlıdır `MergeTree` bu sıralama anahtarına dayalı olarak birleştirilirken ek görevler gerçekleştiren aile `SummingMergeTree`, `AggregatingMergeTree` ve bu yüzden. [\#3581](https://github.com/ClickHouse/ClickHouse/pull/3581) [\#3755](https://github.com/ClickHouse/ClickHouse/pull/3755) +- Tablolar için `MergeTree` aile, şimdi farklı bir sıralama anahtarı belirtebilirsiniz (`ORDER BY` ve dizin (`PRIMARY KEY`). Sıralama anahtarı dizin daha uzun olabilir. [\#3581](https://github.com/ClickHouse/ClickHouse/pull/3581) +- Add theed the `hdfs` tablo fonksiyonu ve `HDFS` hdfs'ye veri içe ve dışa aktarmak için tablo motoru. [chenxing-xc](https://github.com/ClickHouse/ClickHouse/pull/3617) +- Base64 ile çalışmak için fonksiyonlar eklendi: `base64Encode`, `base64Decode`, `tryBase64Decode`. [Alexander Krasheninnikov](https://github.com/ClickHouse/ClickHouse/pull/3350) +- Şimdi hassasiyetini yapılandırmak için bir parametre kullanabilirsiniz `uniqCombined` toplama işlevi (HyperLogLog hücrelerinin sayısını seçin). [\#3406](https://github.com/ClickHouse/ClickHouse/pull/3406) +- Add theed the `system.contributors` ClickHouse taahhüt yapılan herkesin adlarını içeren tablo. [\#3452](https://github.com/ClickHouse/ClickHouse/pull/3452) +- Bölüm için ihmal yeteneği eklendi `ALTER TABLE ... FREEZE` tüm bölümleri bir kerede yedeklemek için sorgu. [\#3514](https://github.com/ClickHouse/ClickHouse/pull/3514) +- Katma `dictGet` ve `dictGetOrDefault` dönüş değeri türünü belirtmeyi gerektirmeyen işlevler. Tür sözlük açıklamasından otomatik olarak belirlenir. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/3564) +- Şimdi tablo açıklamasında bir sütun için yorum belirtmek ve kullanarak değiştirebilirsiniz `ALTER`. [\#3377](https://github.com/ClickHouse/ClickHouse/pull/3377) +- Okuma için desteklenir `Join` basit tuşlarla tabloları yazın. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/3728) +- Şimdi seçenekleri belirtebilirsiniz `join_use_nulls`, `max_rows_in_join`, `max_bytes_in_join`, ve `join_overflow_mode` oluştururken bir `Join` tablo yazın. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/3728) +- Add theed the `joinGet` kullan allowsmanıza olanak sağlayan bir işlev `Join` bir sözlük gibi tablo yazın. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/3728) +- Add theed the `partition_key`, `sorting_key`, `primary_key`, ve `sampling_key` Col theum thens to the `system.tables` tablo tuşları hakkında bilgi vermek için tablo. [\#3609](https://github.com/ClickHouse/ClickHouse/pull/3609) +- Add theed the `is_in_partition_key`, `is_in_sorting_key`, `is_in_primary_key`, ve `is_in_sampling_key` Col theum thens to the `system.columns` Tablo. [\#3609](https://github.com/ClickHouse/ClickHouse/pull/3609) +- Add theed the `min_time` ve `max_time` Col theum thens to the `system.parts` Tablo. Bölümleme anahtarı aşağıdakilerden oluşan bir ifade olduğunda bu sütunlar doldurulur `DateTime` sütun. [Emmanuel Donin de Rosière](https://github.com/ClickHouse/ClickHouse/pull/3800) + +#### Hata düzeltmeleri: {#bug-fixes-1} + +- Düzeltmeler ve performans iyileştirmeleri için `LowCardinality` veri türü. `GROUP BY` kullanım `LowCardinality(Nullable(...))`. Değerlerini almak `extremes`. Yüksek mertebeden fonksiyonların işlenmesi. `LEFT ARRAY JOIN`. Dağılı `GROUP BY`. Dönen işlevler `Array`. Yürütme `ORDER BY`. Yazma `Distributed` tablolar (nicelulu). Geriye dönük uyumluluk için `INSERT` uygulayan eski istemcilerden gelen sorgular `Native` protokol. İçin destek `LowCardinality` için `JOIN`. Tek bir akışta çalışırken geliştirilmiş performans. [\#3823](https://github.com/ClickHouse/ClickHouse/pull/3823) [\#3803](https://github.com/ClickHouse/ClickHouse/pull/3803) [\#3799](https://github.com/ClickHouse/ClickHouse/pull/3799) [\#3769](https://github.com/ClickHouse/ClickHouse/pull/3769) [\#3744](https://github.com/ClickHouse/ClickHouse/pull/3744) [\#3681](https://github.com/ClickHouse/ClickHouse/pull/3681) [\#3651](https://github.com/ClickHouse/ClickHouse/pull/3651) [\#3649](https://github.com/ClickHouse/ClickHouse/pull/3649) [\#3641](https://github.com/ClickHouse/ClickHouse/pull/3641) [\#3632](https://github.com/ClickHouse/ClickHouse/pull/3632) [\#3568](https://github.com/ClickHouse/ClickHouse/pull/3568) [\#3523](https://github.com/ClickHouse/ClickHouse/pull/3523) [\#3518](https://github.com/ClickHouse/ClickHouse/pull/3518) +- Sabit nasıl `select_sequential_consistency` seçenek çalışır. Daha önce, bu ayar etkinleştirildiğinde, bazen yeni bir bölüme yazmaya başladıktan sonra tamamlanmamış bir sonuç döndürüldü. [\#2863](https://github.com/ClickHouse/ClickHouse/pull/2863) +- DDL yürütülürken veritabanları doğru belirtilir `ON CLUSTER` sorgular ve `ALTER UPDATE/DELETE`. [\#3772](https://github.com/ClickHouse/ClickHouse/pull/3772) [\#3460](https://github.com/ClickHouse/ClickHouse/pull/3460) +- Veritabanları doğru bir görünüm içinde alt sorgular için belirtilir. [\#3521](https://github.com/ClickHouse/ClickHouse/pull/3521) +- Bir hata düzeltildi `PREWHERE` ile `FINAL` için `VersionedCollapsingMergeTree`. [7167bfd7](https://github.com/ClickHouse/ClickHouse/commit/7167bfd7b365538f7a91c4307ad77e552ab4e8c1) +- Şimdi kullanabilirsiniz `KILL QUERY` henüz başlatılmamış olan sorguları iptal etmek için, tablonun kilitlenmesini bekliyorlar. [\#3517](https://github.com/ClickHouse/ClickHouse/pull/3517) +- Saatlerin gece yarısı geri hareket ettirilmesi durumunda düzeltilmiş tarih ve saat hesaplamaları (bu İran'da olur ve Moskova'da 1981'den 1983'e kadar olur). Önceden, bu, gerekenden bir gün önce sıfırlanma süresine yol açtı ve ayrıca tarih ve saatin metin biçiminde yanlış biçimlendirilmesine neden oldu. [\#3819](https://github.com/ClickHouse/ClickHouse/pull/3819) +- Bazı durumlarda sabit hatalar `VIEW` ve veritabanını atlayan alt sorgular. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/3521) +- Aynı anda bir yarıştan okurken bir yarış durumu düzeltildi `MATERIALIZED VIEW` ve Silme bir `MATERIALIZED VIEW` nedeniyle değil kilitleme iç `MATERIALIZED VIEW`. [\#3404](https://github.com/ClickHouse/ClickHouse/pull/3404) [\#3694](https://github.com/ClickHouse/ClickHouse/pull/3694) +- Hata düzeltildi `Lock handler cannot be nullptr.` [\#3689](https://github.com/ClickHouse/ClickHouse/pull/3689) +- Sabit sorgu işleme zaman `compile_expressions` seçenek etkindir (varsayılan olarak etkindir). Gibi Nondeterministic sabit ifadeler `now` işlev artık açılmıyor. [\#3457](https://github.com/ClickHouse/ClickHouse/pull/3457) +- Sabit olmayan bir ölçek argümanı belirtilirken bir kilitlenme düzeltildi `toDecimal32/64/128` işlevler. +- Bir dizi eklemeye çalışırken bir hata düzeltildi `NULL` element inler `Values` bir sütuna Biçimlendir türü `Array` olarak `Nullable` (eğer `input_format_values_interpret_expressions` = 1). [\#3487](https://github.com/ClickHouse/ClickHouse/pull/3487) [\#3503](https://github.com/ClickHouse/ClickHouse/pull/3503) +- Sabit sürekli hata günlüğü `DDLWorker` ZooKeeper mevcut değilse. [8f50c620](https://github.com/ClickHouse/ClickHouse/commit/8f50c620334988b28018213ec0092fe6423847e2) +- Sabit dönüş türü için `quantile*` gelen fonksiyonlar `Date` ve `DateTime` argüman türleri. [\#3580](https://github.com/ClickHouse/ClickHouse/pull/3580) +- Sabit `WITH` Ifade olmadan basit bir takma ad belirtirse yan tümcesi. [\#3570](https://github.com/ClickHouse/ClickHouse/pull/3570) +- Adlandırılmış alt sorgular ve nitelikli sütun adları ile sorguların sabit işleme `enable_optimize_predicate_expression` etkindir. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/3588) +- Hata düzeltildi `Attempt to attach to nullptr thread group` maddi görüşlerle çalışırken. [Marek Vavruša](https://github.com/ClickHouse/ClickHouse/pull/3623) +- Belirli yanlış argümanları iletirken bir kilitlenme düzeltildi `arrayReverse` işlev. [73e3a7b6](https://github.com/ClickHouse/ClickHouse/commit/73e3a7b662161d6005e7727d8a711b930386b871) +- Tampon taş theması Düzelt theildi `extractURLParameter` işlev. Geliştirilmiş performans. Sıfır bayt içeren dizelerin doğru işlenmesi eklendi. [141e9799](https://github.com/ClickHouse/ClickHouse/commit/141e9799e49201d84ea8e951d1bed4fb6d3dacb5) +- Sabit tampon taşması `lowerUTF8` ve `upperUTF8` işlevler. Üzerinde bu işlevleri yürütmek için yeteneği kaldırıldı `FixedString` bağımsız değişkenleri yazın. [\#3662](https://github.com/ClickHouse/ClickHouse/pull/3662) +- Silerken nadir bir yarış durumu düzeltildi `MergeTree` Tablolar. [\#3680](https://github.com/ClickHouse/ClickHouse/pull/3680) +- Okuma sırasında bir yarış durumu düzeltildi `Buffer` tablolar ve aynı anda performans `ALTER` veya `DROP` hedef masalarda. [\#3719](https://github.com/ClickHouse/ClickHouse/pull/3719) +- Sabit bir segfault eğer `max_temporary_non_const_columns` sınır aşıldı. [\#3788](https://github.com/ClickHouse/ClickHouse/pull/3788) + +#### Geliştirmeler: {#improvements-1} + +- Sunucu için işlenmiş yapılandırma dosyalarını yazmaz `/etc/clickhouse-server/` dizin. Bunun yerine, onları kaydeder `preprocessed_configs` içindeki dizin `path`. Bu demektir `/etc/clickhouse-server/` dizin için yazma erişimi yok `clickhouse` güvenliği artıran kullanıcı. [\#2443](https://github.com/ClickHouse/ClickHouse/pull/2443) +- Bu `min_merge_bytes_to_use_direct_io` seçenek varsayılan olarak 10 GiB olarak ayarlanır. Mergetree ailesinden tabloların büyük bölümlerini oluşturan bir birleştirme gerçekleştirilir `O_DIRECT` aşırı sayfa önbellek tahliyesini önleyen mod. [\#3504](https://github.com/ClickHouse/ClickHouse/pull/3504) +- Hızlandırılmış sunucu, çok sayıda tablo olduğunda başlar. [\#3398](https://github.com/ClickHouse/ClickHouse/pull/3398) +- Bir bağlantı havuzu ve HTTP eklendi `Keep-Alive` yinelemeler arasındaki bağlantılar için. [\#3594](https://github.com/ClickHouse/ClickHouse/pull/3594) +- Sorgu sözdizimi geçersiz ise, `400 Bad Request` kod iade edilir `HTTP` arabirim (500 daha önce iade edildi). [31bc680a](https://github.com/ClickHouse/ClickHouse/commit/31bc680ac5f4bb1d0360a8ba4696fa84bb47d6ab) +- Bu `join_default_strictness` option is set to `ALL` uyumluluk için varsayılan olarak. [120e2cbe](https://github.com/ClickHouse/ClickHouse/commit/120e2cbe2ff4fbad626c28042d9b28781c805afe) +- Kaldırılan günlüğü `stderr` şuradan `re2` geçersiz veya karmaşık düzenli ifadeler için kütüphane. [\#3723](https://github.com/ClickHouse/ClickHouse/pull/3723) +- İçin eklendi `Kafka` tablo altyapısı: kafka'dan okumaya başlamadan önce abonelikleri denetler; tablo için kafka\_max\_block\_size ayarı. [Marek Vavruša](https://github.com/ClickHouse/ClickHouse/pull/3396) +- Bu `cityHash64`, `farmHash64`, `metroHash64`, `sipHash64`, `halfMD5`, `murmurHash2_32`, `murmurHash2_64`, `murmurHash3_32`, ve `murmurHash3_64` işlevler artık herhangi bir sayıda bağımsız değişken ve bağımsız değişkenler için tuples şeklinde çalışır. [\#3451](https://github.com/ClickHouse/ClickHouse/pull/3451) [\#3519](https://github.com/ClickHouse/ClickHouse/pull/3519) +- Bu `arrayReverse` işlev artık herhangi bir dizi türü ile çalışır. [73e3a7b6](https://github.com/ClickHouse/ClickHouse/commit/73e3a7b662161d6005e7727d8a711b930386b871) +- İsteğe bağlı bir parametre eklendi: yuva boyutu için `timeSlots` işlev. [Kirill Shvakov](https://github.com/ClickHouse/ClickHouse/pull/3724) +- İçin `FULL` ve `RIGHT JOIN`, bu `max_block_size` ayar, sağ tablodan birleştirilmemiş veri akışı için kullanılır. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/3699) +- Add theed the `--secure` komut satırı parametresi `clickhouse-benchmark` ve `clickhouse-performance-test` TLS'Yİ etkinleştirmek için. [\#3688](https://github.com/ClickHouse/ClickHouse/pull/3688) [\#3690](https://github.com/ClickHouse/ClickHouse/pull/3690) +- Tür dönüştürme zaman yapısı bir `Buffer` tür tablo hedef tablonun yapısıyla eşleşmiyor. [Vitaly Baranov](https://github.com/ClickHouse/ClickHouse/pull/3603) +- Add theed the `tcp_keep_alive_timeout` belirtilen zaman aralığı için hareketsizlikten sonra canlı tutma paketlerini etkinleştirme seçeneği. [\#3441](https://github.com/ClickHouse/ClickHouse/pull/3441) +- Bölüm anahtarı için değerlerin gereksiz alıntı kaldırıldı `system.parts` tablo tek bir sütundan oluşuyorsa. [\#3652](https://github.com/ClickHouse/ClickHouse/pull/3652) +- Modulo fonksiyonu için çalışır `Date` ve `DateTime` veri türleri. [\#3385](https://github.com/ClickHouse/ClickHouse/pull/3385) +- İçin eş anlamlı eklendi `POWER`, `LN`, `LCASE`, `UCASE`, `REPLACE`, `LOCATE`, `SUBSTR`, ve `MID` işlevler. [\#3774](https://github.com/ClickHouse/ClickHouse/pull/3774) [\#3763](https://github.com/ClickHouse/ClickHouse/pull/3763) Bazı işlev adları, SQL standardı ile uyumluluk için büyük / küçük harf duyarsızdır. Sözdizimsel şeker eklendi `SUBSTRING(expr FROM start FOR length)` SQL ile uyumluluk için. [\#3804](https://github.com/ClickHouse/ClickHouse/pull/3804) +- Yeteneği eklendi `mlock` karşılık gelen bellek sayfaları `clickhouse-server` bellek yetersiz zorla önlemek için yürütülebilir kod. Bu özellik varsayılan olarak devre dışıdır. [\#3553](https://github.com/ClickHouse/ClickHouse/pull/3553) +- Okuma sırasında geliştirilmiş performans `O_DIRECT` (ile `min_bytes_to_use_direct_io` seçeneği etkin). [\#3405](https://github.com/ClickHouse/ClickHouse/pull/3405) +- Geliştirilmiş performans `dictGet...OrDefault` sabit anahtar bağımsız değişkeni ve sabit olmayan bir varsayılan bağımsız değişken için işlev. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/3563) +- Bu `firstSignificantSubdomain` işlev artık etki alanlarını işler `gov`, `mil`, ve `edu`. [Igor Hatarist](https://github.com/ClickHouse/ClickHouse/pull/3601) Geliştirilmiş performans. [\#3628](https://github.com/ClickHouse/ClickHouse/pull/3628) +- Başlangıç için özel ortam değişkenlerini belirleme yeteneği `clickhouse-server` kullanarak `SYS-V init.d` tanım bylayarak script `CLICKHOUSE_PROGRAM_ENV` içinde `/etc/default/clickhouse`. + [Pavlo Bashynskyi](https://github.com/ClickHouse/ClickHouse/pull/3612) +- Clickhouse-server init komut dosyası için doğru dönüş kodu. [\#3516](https://github.com/ClickHouse/ClickHouse/pull/3516) +- Bu `system.metrics` tablo şimdi var `VersionInteger` metr andik ve `system.build_options` eklenen satır var `VERSION_INTEGER`, ClickHouse sürümünün sayısal formunu içeren, örneğin `18016000`. [\#3644](https://github.com/ClickHouse/ClickHouse/pull/3644) +- Karşılaştırma yeteneği kaldırıldı `Date` gibi olası hataları önlemek için bir sayı ile yazın `date = 2018-12-17`, tarih etrafında tırnak yanlışlıkla ihmal nerede. [\#3687](https://github.com/ClickHouse/ClickHouse/pull/3687) +- Durumsal işlevlerin davranışı gibi düzeltildi `rowNumberInAllBlocks`. Daha önce sorgu analizi sırasında başlatma nedeniyle bir sayı daha büyük olan bir sonuç çıkardılar. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/3729) +- Eğer... `force_restore_data` dosya silinemez, bir hata mesajı görüntülenir. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/3794) + +#### İyileştirmeler oluşturun: {#build-improvements-1} + +- Güncelleme `jemalloc` olası bir bellek sızıntısını gideren kitaplık. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/3557) +- İle profil profilingleme `jemalloc` hata ayıklama yapıları için varsayılan olarak etkindir. [2cc82f5c](https://github.com/ClickHouse/ClickHouse/commit/2cc82f5cbe266421cd4c1165286c2c47e5ffcb15) +- Yalnızca entegrasyon testlerini çalıştırma yeteneği eklendi `Docker` sistemde yüklü. [\#3650](https://github.com/ClickHouse/ClickHouse/pull/3650) +- Select sorgularında fuzz ifade testi eklendi. [\#3442](https://github.com/ClickHouse/ClickHouse/pull/3442) +- Daha fazla yarış koşullarını tespit etmek için paralel ve rastgele sırayla fonksiyonel testler gerçekleştiren taahhütler için bir stres testi eklendi. [\#3438](https://github.com/ClickHouse/ClickHouse/pull/3438) +- Bir Docker görüntüsünde clickhouse-server başlatmak için yöntem geliştirildi. [Elghazal Ahmed](https://github.com/ClickHouse/ClickHouse/pull/3663) +- Bir Docker görüntüsü için, dosyaları kullanarak veritabanlarını başlatmak için destek eklendi `/docker-entrypoint-initdb.d` dizin. [Konstantin Lebedev](https://github.com/ClickHouse/ClickHouse/pull/3695) +- Arm üzerine inşa için düzeltmeler. [\#3709](https://github.com/ClickHouse/ClickHouse/pull/3709) + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes} + +- Karşılaştırma yeteneği kaldırıldı `Date` bir sayı ile yazın. Yerine `toDate('2018-12-18') = 17883`, açık tür dönüştürme kullanmanız gerekir `= toDate(17883)` [\#3687](https://github.com/ClickHouse/ClickHouse/pull/3687) + +## ClickHouse sürümü 18.14 {#clickhouse-release-18-14} + +### ClickHouse yayın 18.14.19, 2018-12-19 {#clickhouse-release-18-14-19-2018-12-19} + +#### Hata düzeltmeleri: {#bug-fixes-2} + +- ODBC kaynağı ile sözlükleri güncelleme ile ilgili sorunlara yol açan bir hata düzeltildi. [\#3825](https://github.com/ClickHouse/ClickHouse/issues/3825), [\#3829](https://github.com/ClickHouse/ClickHouse/issues/3829) +- DDL yürütülürken veritabanları doğru belirtilir `ON CLUSTER` sorgular. [\#3460](https://github.com/ClickHouse/ClickHouse/pull/3460) +- Sabit bir segfault eğer `max_temporary_non_const_columns` sınır aşıldı. [\#3788](https://github.com/ClickHouse/ClickHouse/pull/3788) + +#### İyileştirmeler oluşturun: {#build-improvements-2} + +- Arm üzerine inşa için düzeltmeler. + +### ClickHouse yayın 18.14.18, 2018-12-04 {#clickhouse-release-18-14-18-2018-12-04} + +#### Hata düzeltmeleri: {#bug-fixes-3} + +- Sabit hata `dictGet...` tip sözlükler için işlev `range`, argümanlardan biri sabit ve diğeri değilse. [\#3751](https://github.com/ClickHouse/ClickHouse/pull/3751) +- Mesajlara neden olan Sabit hata `netlink: '...': attribute type 1 has an invalid length` Linux çekirdeği günlüğüne yazdırılmak üzere, bu sadece Linux çekirdeğinin yeterince taze sürümlerinde gerçekleşiyordu. [\#3749](https://github.com/ClickHouse/ClickHouse/pull/3749) +- Fonksiyon sabit segfault `empty` argüman için `FixedString` tür. [Daniel, Dao Quang Minh.](https://github.com/ClickHouse/ClickHouse/pull/3703) +- Büyük bir değer kullanırken sabit aşırı bellek ayırma `max_query_size` ayar (bir bellek yığını `max_query_size` bayt bir kerede önceden tahsis edildi). [\#3720](https://github.com/ClickHouse/ClickHouse/pull/3720) + +#### Yapı değişiklikleri: {#build-changes} + +- OS paketlerinden sürüm 7 LLVM/Clang kütüphaneleri ile sabit yapı (bu kütüphaneler çalışma zamanı sorgu derleme için kullanılır). [\#3582](https://github.com/ClickHouse/ClickHouse/pull/3582) + +### ClickHouse yayın 18.14.17, 2018-11-30 {#clickhouse-release-18-14-17-2018-11-30} + +#### Hata düzeltmeleri: {#bug-fixes-4} + +- ODBC köprü işlemi ana sunucu işlemi ile sonlandırmak değil sabit durumlar. [\#3642](https://github.com/ClickHouse/ClickHouse/pull/3642) +- Sabit senkron ekleme içine `Distributed` uzak tablonun sütun listesinden farklı bir sütun listesi içeren tablo. [\#3673](https://github.com/ClickHouse/ClickHouse/pull/3673) +- Bir MergeTree tablosunu düşürürken bir kazaya yol açabilecek nadir bir yarış durumu düzeltildi. [\#3643](https://github.com/ClickHouse/ClickHouse/pull/3643) +- Sorgu iş parçacığı oluşturma ile başarısız olduğunda bir sorgu kilitlenme düzeltildi `Resource temporarily unavailable` hatasız. [\#3643](https://github.com/ClickHouse/ClickHouse/pull/3643) +- Sabit ayrıştırma `ENGINE` fık thera ne zaman `CREATE AS table` sözdizimi kullanıldı ve `ENGINE` fık thera daha önce belirt theilmişti `AS table` (hata, belirtilen motoru yok saymakla sonuçlandı). [\#3692](https://github.com/ClickHouse/ClickHouse/pull/3692) + +### ClickHouse yayın 18.14.15, 2018-11-21 {#clickhouse-release-18-14-15-2018-11-21} + +#### Hata düzeltmeleri: {#bug-fixes-5} + +- Bellek yığınının boyutu, türün sütununu seri hale getirirken fazla tahmin edildi `Array(String)` bu yol açar “Memory limit exceeded” hatasızlar. Sorun 18.12.13 sürümünde ortaya çıktı. [\#3589](https://github.com/ClickHouse/ClickHouse/issues/3589) + +### ClickHouse yayın 18.14.14, 2018-11-20 {#clickhouse-release-18-14-14-2018-11-20} + +#### Hata düzeltmeleri: {#bug-fixes-6} + +- Sabit `ON CLUSTER` küme güvenli (bayrak) olarak yapılandırıldığında sorgular ``). [\#3599](https://github.com/ClickHouse/ClickHouse/pull/3599) + +#### Yapı değişiklikleri: {#build-changes-1} + +- Sabit sorunlar (sistemden llvm-7, macos) [\#3582](https://github.com/ClickHouse/ClickHouse/pull/3582) + +### ClickHouse yayın 18.14.13, 2018-11-08 {#clickhouse-release-18-14-13-2018-11-08} + +#### Hata düzeltmeleri: {#bug-fixes-7} + +- Sabit `Block structure mismatch in MergingSorted stream` hatasız. [\#3162](https://github.com/ClickHouse/ClickHouse/issues/3162) +- Sabit `ON CLUSTER` küme yapılandırmasında güvenli bağlantıların açık olması durumunda sorgular ( `` bayrak). [\#3465](https://github.com/ClickHouse/ClickHouse/pull/3465) +- Kullanılan sorgularda bir hata düzeltildi `SAMPLE`, `PREWHERE` ve alias sütunları. [\#3543](https://github.com/ClickHouse/ClickHouse/pull/3543) +- Sabit bir nadir `unknown compression method` hata ne zaman `min_bytes_to_use_direct_io` ayar etkinleştirildi. [3544](https://github.com/ClickHouse/ClickHouse/pull/3544) + +#### Performans iyileştirmeleri: {#performance-improvements} + +- Sorguların sabit performans gerilemesi `GROUP BY` AMD EPYC işlemciler üzerinde yürütülürken uint16 veya tarih türü sütunların. [Igor Lapko](https://github.com/ClickHouse/ClickHouse/pull/3512) +- Uzun dizeleri işleyen sorguların sabit performans gerilemesi. [\#3530](https://github.com/ClickHouse/ClickHouse/pull/3530) + +#### İyileştirmeler oluşturun: {#build-improvements-3} + +- Arcadia yapı basitleştirilmesi için iyileştirmeler. [\#3475](https://github.com/ClickHouse/ClickHouse/pull/3475), [\#3535](https://github.com/ClickHouse/ClickHouse/pull/3535) + +### ClickHouse yayın 18.14.12, 2018-11-02 {#clickhouse-release-18-14-12-2018-11-02} + +#### Hata düzeltmeleri: {#bug-fixes-8} + +- İki isimsiz alt sorgu katılmadan bir kilitlenme düzeltildi. [\#3505](https://github.com/ClickHouse/ClickHouse/pull/3505) +- Hatalı sorgular oluşturma sabit (boş `WHERE` yan tümcesi) dış veritabanlarını sorgularken. [hotid](https://github.com/ClickHouse/ClickHouse/pull/3477) +- ODBC sözlüklerinde yanlış bir zaman aşımı değeri kullanılarak düzeltildi. [Marek Vavruša](https://github.com/ClickHouse/ClickHouse/pull/3511) + +### ClickHouse yayın 18.14.11, 2018-10-29 {#clickhouse-release-18-14-11-2018-10-29} + +#### Hata düzeltmeleri: {#bug-fixes-9} + +- Hata düzeltildi `Block structure mismatch in UNION stream: different number of columns` sınır sorgularında. [\#2156](https://github.com/ClickHouse/ClickHouse/issues/2156) +- İç içe geçmiş yapılar içinde diziler içeren tablolarda veri birleştirirken sabit hatalar. [\#3397](https://github.com/ClickHouse/ClickHouse/pull/3397) +- Sabit yanlış sorgu sonuçları eğer `merge_tree_uniform_read_distribution` ayar devre dışı (varsayılan: etkin). [\#3429](https://github.com/ClickHouse/ClickHouse/pull/3429) +- Yerel formatta dağıtılmış bir tabloya ekler üzerinde bir hata düzeltildi. [\#3411](https://github.com/ClickHouse/ClickHouse/issues/3411) + +### ClickHouse yayın 18.14.10, 2018-10-23 {#clickhouse-release-18-14-10-2018-10-23} + +- Bu `compile_expressions` ayar (ifadelerin JIT derlemesi) varsayılan olarak devre dışıdır. [\#3410](https://github.com/ClickHouse/ClickHouse/pull/3410) +- Bu `enable_optimize_predicate_expression` ayar varsayılan olarak devre dışıdır. + +### ClickHouse yayın 18.14.9, 2018-10-16 {#clickhouse-release-18-14-9-2018-10-16} + +#### Yenilik: {#new-features-1} + +- Bu `WITH CUBE` değiştirici için `GROUP BY` (alternatif sözdizimi `GROUP BY CUBE(...)` ayrıca kullanılabilir) vardır. [\#3172](https://github.com/ClickHouse/ClickHouse/pull/3172) +- Add theed the `formatDateTime` işlev. [Alexandr Krasheninnikov](https://github.com/ClickHouse/ClickHouse/pull/2770) +- Add theed the `JDBC` masa motoru ve `jdbc` tablo işlevi (clickhouse-jdbc-bridge yüklenmesini gerektirir). [Alexandr Krasheninnikov](https://github.com/ClickHouse/ClickHouse/pull/3210) +- ISO hafta numarası ile çalışmak için fonksiyonlar eklendi: `toISOWeek`, `toISOYear`, `toStartOfISOYear`, ve `toDayOfYear`. [\#3146](https://github.com/ClickHouse/ClickHouse/pull/3146) +- Şimdi kullanabilirsiniz `Nullable` Col forum forns for `MySQL` ve `ODBC` Tablolar. [\#3362](https://github.com/ClickHouse/ClickHouse/pull/3362) +- İç içe geçmiş veri yapıları, iç içe geçmiş nesneler olarak okunabilir `JSONEachRow` biçimli. Add theed the `input_format_import_nested_json` ayar. [Veloman Yunkan](https://github.com/ClickHouse/ClickHouse/pull/3144) +- Paralel işleme birçok kişi için kullanılabilir `MATERIALIZED VIEW`s veri eklerken. Görmek `parallel_view_processing` ayar. [Marek Vavruša](https://github.com/ClickHouse/ClickHouse/pull/3208) +- Add theed the `SYSTEM FLUSH LOGS` sorgu (sistem tablolarına zorla günlük basması gibi `query_log`) [\#3321](https://github.com/ClickHouse/ClickHouse/pull/3321) +- Şimdi önceden tanımlanmış kullanabilirsiniz `database` ve `table` bildirirken makrolar `Replicated` Tablolar. [\#3251](https://github.com/ClickHouse/ClickHouse/pull/3251) +- Okuma yeteneği eklendi `Decimal` mühendislik notasyonunda değerleri yazın (on yetkilerini gösterir). [\#3153](https://github.com/ClickHouse/ClickHouse/pull/3153) + +#### Deneysel özellikler: {#experimental-features} + +- GROUP BY CLA clauseuse for `LowCardinality data types.` [\#3138](https://github.com/ClickHouse/ClickHouse/pull/3138) +- İçin ifadelerin optimize hesaplama `LowCardinality data types.` [\#3200](https://github.com/ClickHouse/ClickHouse/pull/3200) + +#### Geliştirmeler: {#improvements-2} + +- İle sorgular için önemli ölçüde azaltılmış bellek tüketimi `ORDER BY` ve `LIMIT`. Görmek `max_bytes_before_remerge_sort` ayar. [\#3205](https://github.com/ClickHouse/ClickHouse/pull/3205) +- Yokluğ theunda `JOIN` (`LEFT`, `INNER`, …), `INNER JOIN` kabul edilir. [\#3147](https://github.com/ClickHouse/ClickHouse/pull/3147) +- Nitelikli yıldız işaretleri ile sorgularda düzgün çalışır `JOIN`. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/3202) +- Bu `ODBC` table engine doğru bir uzak veritabanı SQL lehçesinde tanımlayıcıları alıntı yöntemi seçer. [Alexandr Krasheninnikov](https://github.com/ClickHouse/ClickHouse/pull/3210) +- Bu `compile_expressions` ayar (ifadelerin JIT derlemesi) varsayılan olarak etkindir. +- Varsa eşzamanlı damla veritabanı/tablo için sabit davranış ve varsa veritabanı/tablo oluşturun. Daha önce, bir `CREATE DATABASE ... IF NOT EXISTS` sorgu hata iletisi döndürebilir “File … already exists” ve `CREATE TABLE ... IF NOT EXISTS` ve `DROP TABLE IF EXISTS` sorgular dönebilir `Table ... is creating or attaching right now`. [\#3101](https://github.com/ClickHouse/ClickHouse/pull/3101) +- MySQL veya ODBC tablolarından sorgularken sabit bir sağ yarıya sahip ifadelerde ve ifadelerde uzak sunucuya geçirilir. [\#3182](https://github.com/ClickHouse/ClickHouse/pull/3182) +- MySQL ve ODBC tablolarından sorgularken bir WHERE yan tümcesinde sabit ifadelerle karşılaştırmalar uzak sunucuya geçirilir. Önceden, sadece sabitler ile karşılaştırmalar geçirildi. [\#3182](https://github.com/ClickHouse/ClickHouse/pull/3182) +- Terminalde satır genişliğinin doğru hesaplanması `Pretty` hiyeroglifli dizeler de dahil olmak üzere formatlar. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/3257). +- `ON CLUSTER` için belirt forilebilir `ALTER UPDATE` sorgular. +- Verileri okumak için geliştirilmiş performans `JSONEachRow` biçimli. [\#3332](https://github.com/ClickHouse/ClickHouse/pull/3332) +- İçin eş anlamlı eklendi `LENGTH` ve `CHARACTER_LENGTH` uyumluluk için fonksiyonlar. Bu `CONCAT` işlev artık büyük / küçük harfe duyarlı değildir. [\#3306](https://github.com/ClickHouse/ClickHouse/pull/3306) +- Add theed the `TIMESTAMP` eşanlamlı `DateTime` tür. [\#3390](https://github.com/ClickHouse/ClickHouse/pull/3390) +- Günlük satırı bir sorgu ile ilişkili olmasa bile, sunucu günlüklerinde query\_id için ayrılmış alan her zaman vardır. Bu, sunucu metin günlüklerini üçüncü taraf araçlarla Ayrıştırmayı kolaylaştırır. +- Gigabayt bir tamsayı sonraki düzeyini aştığında, bir sorgu tarafından bellek tüketimi kaydedilir. [\#3205](https://github.com/ClickHouse/ClickHouse/pull/3205) +- Yerel protokolü kullanan istemci kitaplığı sunucu ekleme sorgusu için beklediğinden daha az sütun yanlışlıkla gönderdiğinde durum için uyumluluk modu eklendi. Bu senaryo, clickhouse-cpp kitaplığını kullanırken mümkün oldu. Daha önce, bu senaryo sunucunun çökmesine neden oldu. [\#3171](https://github.com/ClickHouse/ClickHouse/pull/3171) +- Kullanıcı tanımlı bir ifade içinde `clickhouse-copier` şimdi kullanabilirsiniz `partition_key` alias (kaynak tablo bölümüne göre ek filtreleme için). Bu, bölümleme şeması kopyalama sırasında değişirse, ancak yalnızca biraz değişirse yararlıdır. [\#3166](https://github.com/ClickHouse/ClickHouse/pull/3166) +- Bu iş akışı `Kafka` motor, yüksek yüklerde veri okuma hızını otomatik olarak azaltmak için bir arka plan iş parçacığı havuzuna taşındı. [Marek Vavruša](https://github.com/ClickHouse/ClickHouse/pull/3215). +- Okuma desteği `Tuple` ve `Nested` gibi yapıların değerleri `struct` in the `Cap'n'Proto format`. [Marek Vavruša](https://github.com/ClickHouse/ClickHouse/pull/3216) +- İçin en üst düzey etki alanlarının listesi `firstSignificantSubdomain` işlev artık etki alanını içerir `biz`. [decaseal](https://github.com/ClickHouse/ClickHouse/pull/3219) +- Dış sözlüklerin yapılandırmasında, `null_value` varsayılan veri türü değeri olarak yorumlanır. [\#3330](https://github.com/ClickHouse/ClickHouse/pull/3330) +- İçin destek `intDiv` ve `intDivOrZero` fonksiyonlar için `Decimal`. [b48402e8](https://github.com/ClickHouse/ClickHouse/commit/b48402e8712e2b9b151e0eef8193811d433a1264) +- İçin destek `Date`, `DateTime`, `UUID`, ve `Decimal` anahtar olarak türleri `sumMap` toplama işlevi. [\#3281](https://github.com/ClickHouse/ClickHouse/pull/3281) +- İçin destek `Decimal` harici sözlüklerde veri türü. [\#3324](https://github.com/ClickHouse/ClickHouse/pull/3324) +- İçin destek `Decimal` veri türü `SummingMergeTree` Tablolar. [\#3348](https://github.com/ClickHouse/ClickHouse/pull/3348) +- İçin uzmanlık eklendi `UUID` içinde `if`. [\#3366](https://github.com/ClickHouse/ClickHouse/pull/3366) +- Sayısı azal thedı `open` ve `close` bir gelen okurken sistem çağrıları `MergeTree table`. [\#3283](https://github.com/ClickHouse/ClickHouse/pull/3283) +- A `TRUNCATE TABLE` sorgu (sorgu için lider yineleme geçirilir) herhangi bir yineleme üzerinde çalıştırılabilir. [Kirill Shvakov](https://github.com/ClickHouse/ClickHouse/pull/3375) + +#### Hata düzeltmeleri: {#bug-fixes-10} + +- İle bir sorun düzeltildi `Dictionary` için tablolar `range_hashed` sözlükler. Bu hata 18.12.17 sürümünde oluştu. [\#1702](https://github.com/ClickHouse/ClickHouse/pull/1702) +- Yüklerken bir hata düzeltildi `range_hashed` söz dictionarieslükler (mesaj `Unsupported type Nullable (...)`). Bu hata 18.12.17 sürümünde oluştu. [\#3362](https://github.com/ClickHouse/ClickHouse/pull/3362) +- Sabit hatalar `pointInPolygon` birbirine yakın bulunan çok sayıda köşe ile çokgenler için yanlış hesaplamaların birikmesi nedeniyle işlev. [\#3331](https://github.com/ClickHouse/ClickHouse/pull/3331) [\#3341](https://github.com/ClickHouse/ClickHouse/pull/3341) +- Veri parçalarını birleştirdikten sonra, elde edilen parçanın sağlama toplamı, başka bir kopyadaki aynı birleştirme sonucundan farklıysa, birleştirme sonucu silinir ve veri kısmı diğer kopyadan indirilir (bu doğru davranıştır). Ancak, veri bölümünü indirdikten sonra, parçanın zaten var olduğu bir hata nedeniyle çalışma kümesine eklenemedi(çünkü veri kısmı birleşmeden sonra bir miktar gecikmeyle silindi). Bu, aynı verileri indirmek için döngüsel girişimlere yol açtı. [\#3194](https://github.com/ClickHouse/ClickHouse/pull/3194) +- Sorgularla toplam bellek tüketiminin yanlış hesaplanması düzeltildi (yanlış hesaplama nedeniyle, `max_memory_usage_for_all_queries` ayar yanlış çalıştı ve `MemoryTracking` metrik yanlış bir değere sahipti). Bu hata, 18.12.13 sürümünde oluştu. [Marek Vavruša](https://github.com/ClickHouse/ClickHouse/pull/3344) +- İşlevselliğini sabit `CREATE TABLE ... ON CLUSTER ... AS SELECT ...` Bu hata, 18.12.13 sürümünde oluştu. [\#3247](https://github.com/ClickHouse/ClickHouse/pull/3247) +- İçin veri yapılarının sabit gereksiz hazırlanması `JOIN`eğer sorgu başlatan sunucuda s `JOIN` yalnızca uzak sunucularda gerçekleştirilir. [\#3340](https://github.com/ClickHouse/ClickHouse/pull/3340) +- Sabit hatalar `Kafka` motor: verileri okumaya başladığınızda istisnalardan sonra kilitlenmeler ve tamamlandıktan sonra kilitler [Marek Vavruša](https://github.com/ClickHouse/ClickHouse/pull/3215). +- İçin `Kafka` tablolar, isteğe bağlı `schema` parametre geç notilm (edi (şema `Cap'n'Proto` biçimli). [Vojtech Splichal](https://github.com/ClickHouse/ClickHouse/pull/3150) +- ZooKeeper sunucularının topluluğu, bağlantıyı kabul eden ancak el sıkışmaya yanıt vermek yerine hemen kapatan sunuculara sahipse, ClickHouse başka bir sunucuya bağlanmayı seçer. Daha önce, bu hata üretti `Cannot read all data. Bytes read: 0. Bytes expected: 4.` ve sunucu başlatılamadı. [8218cf3a](https://github.com/ClickHouse/ClickHouse/commit/8218cf3a5f39a43401953769d6d12a0bb8d29da9) +- Zookeeper sunucularının topluluğu, DNS sorgusunun bir hata döndürdüğü sunucular içeriyorsa, bu sunucular yoksayılır. [17b8e209](https://github.com/ClickHouse/ClickHouse/commit/17b8e209221061325ad7ba0539f03c6e65f87f29) +- Arasında sabit tip dönüşüm `Date` ve `DateTime` veri eklerken `VALUES` biçim (eğer `input_format_values_interpret_expressions = 1`). Daha önce, dönüşüm Unix dönem zamanındaki gün sayısının sayısal değeri ile Unix zaman damgası arasında gerçekleştirildi ve bu da beklenmedik sonuçlara yol açtı. [\#3229](https://github.com/ClickHouse/ClickHouse/pull/3229) +- Arasında düzeltilmiş tip dönüşümü `Decimal` ve tam sayı. [\#3211](https://github.com/ClickHouse/ClickHouse/pull/3211) +- Sabit hatalar `enable_optimize_predicate_expression` ayar. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/3231) +- Varsayılan olmayan bir CSV ayırıcı kullanılıyorsa, kayan noktalı sayılarla CSV formatında bir ayrıştırma hatası düzeltildi `;` [\#3155](https://github.com/ClickHouse/ClickHouse/pull/3155) +- Sabit `arrayCumSumNonNegative` fonksiyon (akümülatör sıfırdan az ise negatif değerler biriktirmez). [Aleksey Studnev](https://github.com/ClickHouse/ClickHouse/pull/3163) +- Sabit nasıl `Merge` tablolar üstünde çalışır `Distributed` kullanırken tablolar `PREWHERE`. [\#3165](https://github.com/ClickHouse/ClickHouse/pull/3165) +- Hata düzeltmeleri `ALTER UPDATE` sorgu. +- Sabit hatalar `odbc` 18.12 sürümünde görünen tablo işlevi. [\#3197](https://github.com/ClickHouse/ClickHouse/pull/3197) +- İle toplama fonksiyon operationlarının çalışmasını sabit `StateArray` birleştiriciler. [\#3188](https://github.com/ClickHouse/ClickHouse/pull/3188) +- Bir bölme sırasında bir kilitlenme düzeltildi `Decimal` sıfır değeri. [69dd6609](https://github.com/ClickHouse/ClickHouse/commit/69dd6609193beb4e7acd3e6ad216eca0ccfb8179) +- Kullanarak işlemler için sabit çıktı türleri `Decimal` ve tamsayı argümanları. [\#3224](https://github.com/ClickHouse/ClickHouse/pull/3224) +- Sırasında segfault sabit `GROUP BY` üzerinde `Decimal128`. [3359ba06](https://github.com/ClickHouse/ClickHouse/commit/3359ba06c39fcd05bfdb87d6c64154819621e13a) +- Bu `log_query_threads` ayar (sorgu yürütme her iş parçacığı hakkında bilgi günlüğe kaydetme) şimdi yalnızca `log_queries` (sorgularla ilgili bilgileri günlüğe kaydetme) seçeneği 1 olarak ayarlanır. Sin thece the `log_query_threads` seçenek varsayılan olarak etkindir, sorgu günlüğü devre dışı bırakılmış olsa bile iş parçacıkları hakkında bilgi daha önce günlüğe kaydedildi. [\#3241](https://github.com/ClickHouse/ClickHouse/pull/3241) +- Quantiles toplama fonksiyonunun dağıtılmış işleminde bir hata düzeltildi (hata mesajı `Not found column quantile...`). [292a8855](https://github.com/ClickHouse/ClickHouse/commit/292a885533b8e3b41ce8993867069d14cbd5a664) +- Aynı anda sürüm 18.12.17 sunucuları ve eski sunuculardan oluşan bir küme üzerinde çalışırken uyumluluk sorunu düzeltildi. Hem sabit hem de sabit olmayan uzunluktaki GROUP BY anahtarlarıyla dağıtılmış sorgular için, toplanacak büyük miktarda veri varsa, döndürülen veriler her zaman tam olarak toplanmadı (iki farklı satır aynı toplama anahtarlarını içeriyordu). [\#3254](https://github.com/ClickHouse/ClickHouse/pull/3254) +- Değiştirmelerin sabit kullanımı `clickhouse-performance-test`, sorgu testte bildirilen değiştirmelerin yalnızca bir kısmını içeriyorsa. [\#3263](https://github.com/ClickHouse/ClickHouse/pull/3263) +- Kullanırken bir hata düzeltildi `FINAL` ile `PREWHERE`. [\#3298](https://github.com/ClickHouse/ClickHouse/pull/3298) +- Kullanırken bir hata düzeltildi `PREWHERE` sırasında eklenen sütun overların üzerinde `ALTER`. [\#3298](https://github.com/ClickHouse/ClickHouse/pull/3298) +- Olmaması için bir çek eklendi `arrayJoin` için `DEFAULT` ve `MATERIALIZED` ifadeler. Önceden, `arrayJoin` veri eklerken bir hataya yol açtı. [\#3337](https://github.com/ClickHouse/ClickHouse/pull/3337) +- Olmaması için bir çek eklendi `arrayJoin` in a `PREWHERE` yan. Daha önce, bu gibi mesajlara yol açtı `Size ... doesn't match` veya `Unknown compression method` sorguları yürütürken. [\#3357](https://github.com/ClickHouse/ClickHouse/pull/3357) +- Değiştirilen optimizasyon ve eşitlik değerlendirmelerinden karşılık gelen ifadeyle zincirler sonra nadir durumlarda ortaya çıkabilecek sabit segfault. [liuyimin-bytedance](https://github.com/ClickHouse/ClickHouse/pull/3339) +- İçin küçük düzeltmeler `clickhouse-benchmark`: daha önce, istemci bilgileri sunucuya gönderilmedi; şimdi yürütülen sorguların sayısı kapatılırken ve yineleme sayısını sınırlamak için daha doğru hesaplanır. [\#3351](https://github.com/ClickHouse/ClickHouse/pull/3351) [\#3352](https://github.com/ClickHouse/ClickHouse/pull/3352) + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-1} + +- Kaldır theılan `allow_experimental_decimal_type` seçenek. Bu `Decimal` veri türü varsayılan kullanım için kullanılabilir. [\#3329](https://github.com/ClickHouse/ClickHouse/pull/3329) + +## ClickHouse sürümü 18.12 {#clickhouse-release-18-12} + +### ClickHouse yayın 18.12.17, 2018-09-16 {#clickhouse-release-18-12-17-2018-09-16} + +#### Yenilik: {#new-features-2} + +- `invalidate_query` (bir dış sözlük güncelleştirilmesi gerekip gerekmediğini denetlemek için bir sorgu belirtmek için yeteneği) `clickhouse` kaynaklı. [\#3126](https://github.com/ClickHouse/ClickHouse/pull/3126) +- Kullanma yeteneği eklendi `UInt*`, `Int*`, ve `DateTime` veri türleri (birlikte `Date` type) as a `range_hashed` aralıkların sınırlarını tanımlayan dış sözlük anahtarı. Şimdi `NULL` açık bir aralık belirlemek için kullanılabilir. [Vasily Nemkov](https://github.com/ClickHouse/ClickHouse/pull/3123) +- Bu `Decimal` şimdi yazın destekler `var*` ve `stddev*` toplama fonksiyonları. [\#3129](https://github.com/ClickHouse/ClickHouse/pull/3129) +- Bu `Decimal` tip artık matematiksel fonksiyonları destekliyor (`exp`, `sin` ve böyle devam eder.) [\#3129](https://github.com/ClickHouse/ClickHouse/pull/3129) +- Bu `system.part_log` tablo şimdi var `partition_id` sütun. [\#3089](https://github.com/ClickHouse/ClickHouse/pull/3089) + +#### Hata düzeltmeleri: {#bug-fixes-11} + +- `Merge` şimdi düzgün çalışıyor `Distributed` Tablolar. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/3159) +- Sabit uyumsuzluk (gereksiz bağımlılık `glibc` sürüm) bu Clickhouse'u çalıştırmayı imkansız hale getirdi `Ubuntu Precise` ve eski sürümleri. Uyumsuzluk 18.12.13 sürümünde ortaya çıktı. [\#3130](https://github.com/ClickHouse/ClickHouse/pull/3130) +- Sabit hatalar `enable_optimize_predicate_expression` ayar. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/3107) +- 18.12.13'ten önceki sürümlerde bir kopya kümesiyle çalışırken ve aynı anda daha yeni bir sürüme sahip bir sunucuda bir tablonun yeni bir kopyasını oluştururken ortaya çıkan geriye dönük uyumluluğa sahip küçük bir sorun düzeltildi (mesajda gösterilir `Can not clone replica, because the ... updated to new ClickHouse version`, mantıklı, ama olmamalı). [\#3122](https://github.com/ClickHouse/ClickHouse/pull/3122) + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-2} + +- Bu `enable_optimize_predicate_expression` seçenek varsayılan olarak etkindir (oldukça iyimser olan). Sütun adları için arama için ilgili sorgu çözümleme hataları oluşursa, ayarla `enable_optimize_predicate_expression` 0'a. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/3107) + +### ClickHouse yayın 18.12.14, 2018-09-13 {#clickhouse-release-18-12-14-2018-09-13} + +#### Yenilik: {#new-features-3} + +- İçin destek eklendi `ALTER UPDATE` sorgular. [\#3035](https://github.com/ClickHouse/ClickHouse/pull/3035) +- Add theed the `allow_ddl` kullanıcının DDL sorgularına erişimini kısıtlayan seçenek. [\#3104](https://github.com/ClickHouse/ClickHouse/pull/3104) +- Add theed the `min_merge_bytes_to_use_direct_io` seçeneği için `MergeTree` birleştirmenin toplam boyutu için bir eşik ayarlamanıza izin veren motorlar(eşiğin üstünde olduğunda, veri parçası dosyaları o\_direct kullanılarak işlenecektir). [\#3117](https://github.com/ClickHouse/ClickHouse/pull/3117) +- Bu `system.merges` sistem tablosu şimdi içerir `partition_id` sütun. [\#3099](https://github.com/ClickHouse/ClickHouse/pull/3099) + +#### Geliştirmeler {#improvements-3} + +- Bir veri parçası mutasyon sırasında değişmeden kalırsa, yinelemeler tarafından indirilmez. [\#3103](https://github.com/ClickHouse/ClickHouse/pull/3103) +- Otomatik tamamlama ile çalışırken ayarların adları için kullanılabilir `clickhouse-client`. [\#3106](https://github.com/ClickHouse/ClickHouse/pull/3106) + +#### Hata düzeltmeleri: {#bug-fixes-12} + +- Elemanları olan dizilerin boyutları için bir kontrol eklendi `Nested` eklerken alanları yazın. [\#3118](https://github.com/ClickHouse/ClickHouse/pull/3118) +- İle harici sözlükler güncellenmesi bir hata düzeltildi `ODBC` kaynak ve `hashed` depolama. Bu hata, 18.12.13 sürümünde oluştu. +- Bir sorgudan geçici bir tablo oluştururken bir kilitlenme düzeltildi `IN` koşul. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/3098) +- Olabilecek diziler için toplam işlevlerde bir hata düzeltildi `NULL` öğeler. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/3097) + +### ClickHouse yayın 18.12.13, 2018-09-10 {#clickhouse-release-18-12-13-2018-09-10} + +#### Yenilik: {#new-features-4} + +- Add theed the `DECIMAL(digits, scale)` veri türü (`Decimal32(scale)`, `Decimal64(scale)`, `Decimal128(scale)`). Etkinleştirmek için ayarı kullanın `allow_experimental_decimal_type`. [\#2846](https://github.com/ClickHouse/ClickHouse/pull/2846) [\#2970](https://github.com/ClickHouse/ClickHouse/pull/2970) [\#3008](https://github.com/ClickHouse/ClickHouse/pull/3008) [\#3047](https://github.com/ClickHouse/ClickHouse/pull/3047) +- Yeni `WITH ROLLUP` değiştirici için `GROUP BY` (alternatif sözdizimi: `GROUP BY ROLLUP(...)`). [\#2948](https://github.com/ClickHouse/ClickHouse/pull/2948) +- JOIN ile sorgularda, yıldız karakteri SQL standardına uygun olarak tüm tablolardaki sütunların bir listesine genişletir. Ayarlayarak eski davranışı geri yükleyebilirsiniz `asterisk_left_columns_only` kullanıcı yapılandırma düzeyinde 1'e. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2787) +- Tablo fonksiyonları ile katılmak için destek eklendi. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2907) +- Clickhouse-client sekmesine basarak otomatik tamamlama. [Sergey Shcherbin](https://github.com/ClickHouse/ClickHouse/pull/2447) +- CTRL + C clickhouse-client girilen bir sorguyu temizler. [\#2877](https://github.com/ClickHouse/ClickHouse/pull/2877) +- Add theed the `join_default_strictness` ayar (değerler: `"`, `'any'`, `'all'`). Bu belirtmemenizi sağlar `ANY` veya `ALL` için `JOIN`. [\#2982](https://github.com/ClickHouse/ClickHouse/pull/2982) +- Sorgu işleme ile ilgili sunucu günlüğünün her satırı sorgu kimliğini gösterir. [\#2482](https://github.com/ClickHouse/ClickHouse/pull/2482) +- Artık clickhouse-client'da sorgu yürütme günlükleri alabilirsiniz ( `send_logs_level` ayar). Dağıtılmış sorgu işleme ile günlükleri tüm sunuculardan basamaklandırılır. [\#2482](https://github.com/ClickHouse/ClickHouse/pull/2482) +- Bu `system.query_log` ve `system.processes` (`SHOW PROCESSLIST`) bir sorgu çalıştırdığınızda tablolar artık tüm değiştirilen ayarları hakkında bilgi var (iç içe geçmiş yapısı `Settings` veriler). Add theed the `log_query_settings` ayar. [\#2482](https://github.com/ClickHouse/ClickHouse/pull/2482) +- Bu `system.query_log` ve `system.processes` tablolar artık sorgu yürütülmesine katılan iş parçacığı sayısı hakkında bilgi gösterir (bkz. `thread_numbers` sütun). [\#2482](https://github.com/ClickHouse/ClickHouse/pull/2482) +- Katma `ProfileEvents` ağ üzerinden okuma ve yazma ve diske okuma ve yazma için harcanan zamanı, ağ hatalarının sayısını ve ağ bant genişliği sınırlı olduğunda bekleyen harcanan zamanı ölçen sayaçlar. [\#2482](https://github.com/ClickHouse/ClickHouse/pull/2482) +- Katma `ProfileEvents`rusage gelen ((bekle zaman G/Ç hakkında daha fazla bilgi edinmek için bu kullanım, CPU zamanı bekle ve veri miktarını okuma ve kaydedilen, sayfa önbelleği olan ve olmayan) kullanıcı alanı ve çekirdek, sayfa hataları ve bağlam anahtarlarının yanı sıra taskstats ölçülerine CPU kullanımı hakkında bilgi almak için onları kullanabilirsiniz) sistem ölçümlerini içeren sayaçları. [\#2482](https://github.com/ClickHouse/ClickHouse/pull/2482) +- Bu `ProfileEvents` sayaçlar, genel olarak ve her sorgu için ve ayrıca sorguya göre kaynak tüketimini ayrıntılı olarak profillemenize izin veren her sorgu yürütme iş parçacığı için uygulanır. [\#2482](https://github.com/ClickHouse/ClickHouse/pull/2482) +- Add theed the `system.query_thread_log` her sorgu yürütme iş parçacığı hakkında bilgi içeren tablo. Add theed the `log_query_threads` ayar. [\#2482](https://github.com/ClickHouse/ClickHouse/pull/2482) +- Bu `system.metrics` ve `system.events` tablolar artık yerleşik belgelere sahiptir. [\#3016](https://github.com/ClickHouse/ClickHouse/pull/3016) +- Add theed the `arrayEnumerateDense` işlev. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2975) +- Add theed the `arrayCumSumNonNegative` ve `arrayDifference` işlevler. [Aleksey Studnev](https://github.com/ClickHouse/ClickHouse/pull/2942) +- Add theed the `retention` toplama işlevi. [Sundy Li](https://github.com/ClickHouse/ClickHouse/pull/2887) +- Artık Plus operatörünü kullanarak toplama işlevlerinin durumlarını ekleyebilir (birleştirebilirsiniz) ve toplama işlevlerinin durumlarını negatif olmayan bir sabitle çarpabilirsiniz. [\#3062](https://github.com/ClickHouse/ClickHouse/pull/3062) [\#3034](https://github.com/ClickHouse/ClickHouse/pull/3034) +- Mergetree ailesindeki tablolar artık sanal sütuna sahip `_partition_id`. [\#3089](https://github.com/ClickHouse/ClickHouse/pull/3089) + +#### Deneysel özellikler: {#experimental-features-1} + +- Add theed the `LowCardinality(T)` veri türü. Bu veri türü otomatik olarak yerel bir değer sözlüğü oluşturur ve sözlüğü açmadan veri işlemeye izin verir. [\#2830](https://github.com/ClickHouse/ClickHouse/pull/2830) +- JIT derlenmiş işlevlerin bir önbellek ve derlemeden önce kullanım sayısı için bir sayaç eklendi. JIT derleme ifadeleri için `compile_expressions` ayar. [\#2990](https://github.com/ClickHouse/ClickHouse/pull/2990) [\#3077](https://github.com/ClickHouse/ClickHouse/pull/3077) + +#### Geliştirmeler: {#improvements-4} + +- Terkedilmiş yinelemeler olduğunda çoğaltma günlüğünün sınırsız birikimi ile ilgili sorun giderildi. Uzun bir gecikme ile kopyaları için etkili bir kurtarma modu eklendi. +- Geliştirilmiş performans `GROUP BY` bunlardan biri dize ve diğerleri sabit uzunlukta olduğunda birden fazla toplama alanı ile. +- Kullanırken geliştirilmiş performans `PREWHERE` ve ifad ofelerin örtülü olarak aktar ofılmasıyla `PREWHERE`. +- Metin formatları için geliştirilmiş ayrıştırma performansı (`CSV`, `TSV`). [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2977) [\#2980](https://github.com/ClickHouse/ClickHouse/pull/2980) +- İkili biçimlerde okuma dizeleri ve diziler geliştirilmiş performans. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2955) +- Sorgular için artan performans ve azaltılmış bellek tüketimi `system.tables` ve `system.columns` tek bir sunucuda çok sayıda tablo olduğunda. [\#2953](https://github.com/ClickHouse/ClickHouse/pull/2953) +- Bir hataya neden olan büyük bir sorgu akışı durumunda bir performans sorunu düzeltildi ( `_dl_addr` fonksiyon görünür `perf top`, ancak sunucu çok fazla CPU kullanmıyor). [\#2938](https://github.com/ClickHouse/ClickHouse/pull/2938) +- Koşullar Görünüm içine atılır (ne zaman `enable_optimize_predicate_expression` etkin) değildir. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2907) +- İçin işlevsellik geliştirmeleri `UUID` veri türü. [\#3074](https://github.com/ClickHouse/ClickHouse/pull/3074) [\#2985](https://github.com/ClickHouse/ClickHouse/pull/2985) +- Bu `UUID` veri türü-Simyacı sözlüklerde desteklenir. [\#2822](https://github.com/ClickHouse/ClickHouse/pull/2822) +- Bu `visitParamExtractRaw` işlev iç içe geçmiş yapılarla düzgün çalışır. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2974) +- Ne zaman `input_format_skip_unknown_fields` ayarı etkin, nesne alanları `JSONEachRow` biçim doğru atlanır. [BlahGeek](https://github.com/ClickHouse/ClickHouse/pull/2958) +- İçin... `CASE` koşullarla ifade, şimdi atlayabilirsiniz `ELSE` eşdeğer olan `ELSE NULL`. [\#2920](https://github.com/ClickHouse/ClickHouse/pull/2920) +- ZooKeeper ile çalışırken operasyon zaman aşımı artık yapılandırılabilir. [urykhy](https://github.com/ClickHouse/ClickHouse/pull/2971) +- İçin bir ofset belirtebilirsiniz `LIMIT n, m` olarak `LIMIT n OFFSET m`. [\#2840](https://github.com/ClickHouse/ClickHouse/pull/2840) +- Kullanabilirsiniz `SELECT TOP n` için alternatif olarak sözdizimi `LIMIT`. [\#2840](https://github.com/ClickHouse/ClickHouse/pull/2840) +- Sistem tablolarına yazmak için sıranın boyutunu arttırdı, böylece `SystemLog parameter queue is full` hata sık sık olmaz. +- Bu `windowFunnel` toplama işlevi artık birden çok koşulu karşılayan olayları destekler. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2801) +- Yinelenen sütunlar bir `USING` için fık forra `JOIN`. [\#3006](https://github.com/ClickHouse/ClickHouse/pull/3006) +- `Pretty` biçimlerin artık genişliğe göre sütun hizalaması üzerinde bir sınırı vardır. Kullan... `output_format_pretty_max_column_pad_width` ayar. Bir değer daha genişse, yine de bütünüyle görüntülenecektir, ancak tablodaki diğer hücreler çok geniş olmayacaktır. [\#3003](https://github.com/ClickHouse/ClickHouse/pull/3003) +- Bu `odbc` tablo işlevi artık veritabanı/şema adını belirtmenizi sağlar. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2885) +- Belirtilen bir kullanıcı adı kullanma yeteneği eklendi `clickhouse-client` yapılandırma dosyası. [Vladimir Kozbin](https://github.com/ClickHouse/ClickHouse/pull/2909) +- Bu `ZooKeeperExceptions` sayaç üç sayaçlara ayrılmıştır: `ZooKeeperUserExceptions`, `ZooKeeperHardwareExceptions`, ve `ZooKeeperOtherExceptions`. +- `ALTER DELETE` sorgular hayata görünümler için çalışır. +- Temizleme ipliğini periyodik olarak çalıştırırken randomizasyon eklendi `ReplicatedMergeTree` çok sayıda olduğunda periyodik yük ani önlemek için tablolar `ReplicatedMergeTree` Tablolar. +- İçin destek `ATTACH TABLE ... ON CLUSTER` sorgular. [\#3025](https://github.com/ClickHouse/ClickHouse/pull/3025) + +#### Hata düzeltmeleri: {#bug-fixes-13} + +- İle bir sorun düzeltildi `Dictionary` tablolar (atar `Size of offsets doesn't match size of column` veya `Unknown compression method` özel). Bu hata 18.10.3 sürümünde göründü. [\#2913](https://github.com/ClickHouse/ClickHouse/issues/2913) +- Birleştirirken bir hata düzeltildi `CollapsingMergeTree` veri parçalarından biri boşsa tablolar (bu parçalar birleştirme sırasında oluşturulur veya `ALTER DELETE` tüm veriler silindiyse) ve `vertical` birleştirme için algoritma kullanıldı. [\#3049](https://github.com/ClickHouse/ClickHouse/pull/3049) +- Sırasında bir yarış durumu düzeltildi `DROP` veya `TRUNCATE` için `Memory` eş zamanlı tablolar `SELECT`, sunucu çökmelerine neden olabilir. Bu hata 1.1.54388 sürümünde göründü. [\#3038](https://github.com/ClickHouse/ClickHouse/pull/3038) +- Takarken veri kaybı olasılığı düzeltildi `Replicated` tablolar ise `Session is expired` hata döndürülür (veri kaybı tarafından tespit edilebilir `ReplicatedDataLoss` ölçü). Bu hata 1.1.54378 sürümünde oluştu. [\#2939](https://github.com/ClickHouse/ClickHouse/pull/2939) [\#2949](https://github.com/ClickHouse/ClickHouse/pull/2949) [\#2964](https://github.com/ClickHouse/ClickHouse/pull/2964) +- Sırasında bir segfault sabit `JOIN ... ON`. [\#3000](https://github.com/ClickHouse/ClickHouse/pull/3000) +- Sütun adlarını ararken hata düzeltildi `WHERE` ifade tamamen nitelikli bir sütun adından oluşur, örneğin `WHERE table.column`. [\#2994](https://github.com/ClickHouse/ClickHouse/pull/2994) +- Sabit “Not found column” uzak bir sunucudan bir alt sorgu ile bir In ifadesinden oluşan tek bir sütun isteniyorsa, dağıtılmış sorgular yürütülürken oluşan hata. [\#3087](https://github.com/ClickHouse/ClickHouse/pull/3087) +- Sabit `Block structure mismatch in UNION stream: different number of columns` kırıklardan biri yerel ve diğeri değilse dağıtılmış sorgular için oluşan hata ve taşınmanın en iyi duruma getirilmesi `PREWHERE` tetik .lenir. [\#2226](https://github.com/ClickHouse/ClickHouse/pull/2226) [\#3037](https://github.com/ClickHouse/ClickHouse/pull/3037) [\#3055](https://github.com/ClickHouse/ClickHouse/pull/3055) [\#3065](https://github.com/ClickHouse/ClickHouse/pull/3065) [\#3073](https://github.com/ClickHouse/ClickHouse/pull/3073) [\#3090](https://github.com/ClickHouse/ClickHouse/pull/3090) [\#3093](https://github.com/ClickHouse/ClickHouse/pull/3093) +- Sabit `pointInPolygon` dışbükey olmayan poligonların belirli durumları için işlev. [\#2910](https://github.com/ClickHouse/ClickHouse/pull/2910) +- Karşılaştırırken yanlış sonuç düzeltildi `nan` tamsayılarla. [\#3024](https://github.com/ClickHouse/ClickHouse/pull/3024) +- Sabit bir hata `zlib-ng` nadir durumlarda segfault yol açabilir kütüphane. [\#2854](https://github.com/ClickHouse/ClickHouse/pull/2854) +- Bir tabloya eklerken bir bellek sızıntısı düzeltildi `AggregateFunction` sütunlar, toplama işlevinin durumu basit değilse (belleği ayrı olarak ayırır) ve tek bir ekleme isteği birden çok küçük blokla sonuçlanırsa. [\#3084](https://github.com/ClickHouse/ClickHouse/pull/3084) +- Aynı şeyi oluştururken ve silerken bir yarış durumu düzeltildi `Buffer` veya `MergeTree` aynı anda tablo. +- Tuples gibi bazı önemsiz olmayan türlerinden oluşan tuples karşılaştırırken bir segfault olasılığını düzeltildi. [\#2989](https://github.com/ClickHouse/ClickHouse/pull/2989) +- Belirli çalıştırırken bir segfault olasılığı düzeltildi `ON CLUSTER` sorgular. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2960) +- Sabit bir hata `arrayDistinct` fonksiyonu için `Nullable` dizi elemanları. [\#2845](https://github.com/ClickHouse/ClickHouse/pull/2845) [\#2937](https://github.com/ClickHouse/ClickHouse/pull/2937) +- Bu `enable_optimize_predicate_expression` seçenek şimdi doğru olan durumları destekler `SELECT *`. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2929) +- Zookeeper oturumunu yeniden başlatırken segfault düzeltildi. [\#2917](https://github.com/ClickHouse/ClickHouse/pull/2917) +- ZooKeeper ile çalışırken sabit potansiyel engelleme. +- Bir iç içe veri yapıları eklemek için sabit yanlış kod `SummingMergeTree`. +- Toplama işlevlerinin durumları için bellek ayırırken, hizalama doğru bir şekilde dikkate alınır, bu da toplama işlevlerinin durumlarını uygularken hizalama gerektiren işlemlerin kullanılmasını mümkün kılar. [chenxing-xc](https://github.com/ClickHouse/ClickHouse/pull/2808) + +#### Güvenlik düzeltme: {#security-fix} + +- ODBC veri kaynaklarının güvenli kullanımı. ODBC sürücüleri ile etkileşim ayrı bir `clickhouse-odbc-bridge` işleyiş. Üçüncü taraf ODBC sürücülerindeki hatalar artık sunucu kararlılığı veya güvenlik açıklarıyla ilgili sorunlara neden olmaz. [\#2828](https://github.com/ClickHouse/ClickHouse/pull/2828) [\#2879](https://github.com/ClickHouse/ClickHouse/pull/2879) [\#2886](https://github.com/ClickHouse/ClickHouse/pull/2886) [\#2893](https://github.com/ClickHouse/ClickHouse/pull/2893) [\#2921](https://github.com/ClickHouse/ClickHouse/pull/2921) +- Dosya yolunun yanlış doğrulanması düzeltildi `catBoostPool` tablo işlevi. [\#2894](https://github.com/ClickHouse/ClickHouse/pull/2894) +- Sistem tablolarının içeriği (`tables`, `databases`, `parts`, `columns`, `parts_columns`, `merges`, `mutations`, `replicas`, ve `replication_queue`) kullanıcının veri tabanlarına yapılandırılmış erişimine göre filtrelenir (`allow_databases`). [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2856) + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-3} + +- JOIN ile sorgularda, yıldız karakteri SQL standardına uygun olarak tüm tablolardaki sütunların bir listesine genişletir. Ayarlayarak eski davranışı geri yükleyebilirsiniz `asterisk_left_columns_only` kullanıcı yapılandırma düzeyinde 1'e. + +#### Yapı değişiklikleri: {#build-changes-2} + +- Çoğu entegrasyon testleri artık commit tarafından çalıştırılabilir. +- Kod stili kontrolleri de commit tarafından çalıştırılabilir. +- Bu `memcpy` CentOS7/Fedora üzerinde inşa ederken uygulama doğru seçilir. [Etienne Champetier](https://github.com/ClickHouse/ClickHouse/pull/2912) +- Oluşturmak için clang kullanırken, bazı uyarılar `-Weverything` düzenli ek olarak, eklenmiştir `-Wall-Wextra -Werror`. [\#2957](https://github.com/ClickHouse/ClickHouse/pull/2957) +- Yapı hata ayıklama kullanır `jemalloc` hata ayıklama seçeneği. +- ZooKeeper ile etkileşim için kütüphanenin arayüzü soyut olarak ilan edilir. [\#2950](https://github.com/ClickHouse/ClickHouse/pull/2950) + +## ClickHouse sürümü 18.10 {#clickhouse-release-18-10} + +### ClickHouse yayın 18.10.3, 2018-08-13 {#clickhouse-release-18-10-3-2018-08-13} + +#### Yenilik: {#new-features-5} + +- HTTPS çoğaltma için kullanılabilir. [\#2760](https://github.com/ClickHouse/ClickHouse/pull/2760) +- Fonksiyonları eklendi `murmurHash2_64`, `murmurHash3_32`, `murmurHash3_64`, ve `murmurHash3_128` mevcut ek olarak `murmurHash2_32`. [\#2791](https://github.com/ClickHouse/ClickHouse/pull/2791) +- ClickHouse ODBC sürücüsündeki null türleri için destek (`ODBCDriver2` çıkış biçimi). [\#2834](https://github.com/ClickHouse/ClickHouse/pull/2834) +- İçin destek `UUID` anahtar sütunlarda. + +#### Geliştirmeler: {#improvements-5} + +- Kümeler, yapılandırma dosyalarından silindiğinde sunucuyu yeniden başlatmadan kaldırılabilir. [\#2777](https://github.com/ClickHouse/ClickHouse/pull/2777) +- Dış sözlükler, yapılandırma dosyalarından kaldırıldıklarında sunucuyu yeniden başlatmadan kaldırılabilir. [\#2779](https://github.com/ClickHouse/ClickHouse/pull/2779) +- Katma `SETTINGS` için destek `Kafka` masa motoru. [Alexander Marshalov](https://github.com/ClickHouse/ClickHouse/pull/2781) +- İçin iyileştirmeler `UUID` veri türü (henüz tamamlanmadı). [\#2618](https://github.com/ClickHouse/ClickHouse/pull/2618) +- Birleştikten sonra boş parçalar için destek `SummingMergeTree`, `CollapsingMergeTree` ve `VersionedCollapsingMergeTree` motorlar. [\#2815](https://github.com/ClickHouse/ClickHouse/pull/2815) +- Tamamlanan Mut recordsasyon recordsların eski kayıtları silinir (`ALTER DELETE`). [\#2784](https://github.com/ClickHouse/ClickHouse/pull/2784) +- Add theed the `system.merge_tree_settings` Tablo. [Kirill Shvakov](https://github.com/ClickHouse/ClickHouse/pull/2841) +- Bu `system.tables` tablo artık bağımlılık sütunları var: `dependencies_database` ve `dependencies_table`. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2851) +- Add theed the `max_partition_size_to_drop` yapılandırma seçeneği. [\#2782](https://github.com/ClickHouse/ClickHouse/pull/2782) +- Add theed the `output_format_json_escape_forward_slashes` seçenek. [Alexander Bocharov](https://github.com/ClickHouse/ClickHouse/pull/2812) +- Add theed the `max_fetch_partition_retries_count` ayar. [\#2831](https://github.com/ClickHouse/ClickHouse/pull/2831) +- Add theed the `prefer_localhost_replica` yerel bir yineleme tercihini devre dışı bırakmak ve işlemler arası etkileşim olmadan yerel bir yinelemeye gitmek için ayarlama. [\#2832](https://github.com/ClickHouse/ClickHouse/pull/2832) +- Bu `quantileExact` toplama işlevi döndürür `nan` boş bir toplama durumunda `Float32` veya `Float64` koymak. [Sundy Li](https://github.com/ClickHouse/ClickHouse/pull/2855) + +#### Hata düzeltmeleri: {#bug-fixes-14} + +- ODBC için bağlantı dizesi parametrelerinin gereksiz bir şekilde kaçması kaldırıldı, bu da bağlantı kurmayı imkansız hale getirdi. Bu hata 18.6.0 sürümünde oluştu. +- İşleme mantığı düzeltildi `REPLACE PARTITION` çoğaltma sırasındaki komutlar. İki tane varsa `REPLACE` aynı bölüm için komutlar, yanlış mantık, bunlardan birinin çoğaltma kuyruğunda kalmasına ve yürütülmesine neden olabilir. [\#2814](https://github.com/ClickHouse/ClickHouse/pull/2814) +- Tüm veri parçaları boş olduğunda bir birleştirme hatası düzeltildi (birleştirme veya `ALTER DELETE` tüm veriler silindiyse). Bu hata 18.1.0 sürümünde göründü. [\#2930](https://github.com/ClickHouse/ClickHouse/pull/2930) +- Eşzamanlı için bir hata düzeltildi `Set` veya `Join`. [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2823) +- Sabit `Block structure mismatch in UNION stream: different number of columns` için oluşan hata `UNION ALL` bir alt sorgu içindeki sorgular `SELECT` sorgular yinelenen sütun adları içerir. [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2094) +- Bir MySQL sunucusuna bağlanırken bir istisna oluşursa bir bellek sızıntısı düzeltildi. +- Bir sorgu hatası durumunda sabit yanlış clickhouse-istemci yanıt kodu. +- Farklı içeren hayata görünümleri sabit yanlış davranış. [\#2795](https://github.com/ClickHouse/ClickHouse/issues/2795) + +#### Geriye dönük uyumsuz değişiklikler {#backward-incompatible-changes-4} + +- Dağıtılmış tablolar için kontrol tablosu sorguları için destek kaldırıldı. + +#### Yapı değişiklikleri: {#build-changes-3} + +- Ayırıcı değiştirildi: `jemalloc` şimdi yerine kullanılır `tcmalloc`. Bazı senaryolarda, bu hız %20'ye kadar artar. Ancak, %20'ye kadar yavaşlamış sorgular vardır. Bellek tüketimi, bazı senaryolarda geliştirilmiş kararlılık ile yaklaşık %10 oranında azaltılmıştır. Son derece rekabetçi yüklerle, userspace ve sistemdeki CPU kullanımı sadece hafif bir artış gösterir. [\#2773](https://github.com/ClickHouse/ClickHouse/pull/2773) +- Bir alt modülden libressl kullanımı. [\#1983](https://github.com/ClickHouse/ClickHouse/pull/1983) [\#2807](https://github.com/ClickHouse/ClickHouse/pull/2807) +- Bir alt modülden unixodbc kullanımı. [\#2789](https://github.com/ClickHouse/ClickHouse/pull/2789) +- Bir alt modülden mariadb-connector-c kullanımı. [\#2785](https://github.com/ClickHouse/ClickHouse/pull/2785) +- Test verilerinin kullanılabilirliğine bağlı olan depoya işlevsel test dosyaları eklendi (şimdilik, test verilerinin kendisi olmadan). + +## ClickHouse sürümü 18.6 {#clickhouse-release-18-6} + +### ClickHouse yayın 18.6.0, 2018-08-02 {#clickhouse-release-18-6-0-2018-08-02} + +#### Yenilik: {#new-features-6} + +- Sözdizimi üzerinde katılmak için ifadeler için destek eklendi: + `JOIN ON Expr([table.]column ...) = Expr([table.]column, ...) [AND Expr([table.]column, ...) = Expr([table.]column, ...) ...]` + İfade, and operatörü tarafından birleştirilen bir eşitlik zinciri olmalıdır. Eşitliğin her bir tarafı, tablolardan birinin sütunları üzerinde keyfi bir ifade olabilir. Tam sütun adlarının kullanımı desteklenir (`table.name`, `database.table.name`, `table_alias.name`, `subquery_alias.name`) doğru tablo için. [\#2742](https://github.com/ClickHouse/ClickHouse/pull/2742) +- HTTPS çoğaltma için etkinleştirilebilir. [\#2760](https://github.com/ClickHouse/ClickHouse/pull/2760) + +#### Geliştirmeler: {#improvements-6} + +- Sunucu, sürümünün düzeltme eki bileşenini istemciye geçirir. Yama sürümü bileşeni ile ilgili veriler `system.processes` ve `query_log`. [\#2646](https://github.com/ClickHouse/ClickHouse/pull/2646) + +## ClickHouse sürümü 18.5 {#clickhouse-release-18-5} + +### ClickHouse sürümü 18.5.1, 2018-07-31 {#clickhouse-release-18-5-1-2018-07-31} + +#### Yenilik: {#new-features-7} + +- Karma fonksiyonu eklendi `murmurHash2_32` [\#2756](https://github.com/ClickHouse/ClickHouse/pull/2756). + +#### Geliştirmeler: {#improvements-7} + +- Şimdi kullanabilirsiniz `from_env` [\#2741](https://github.com/ClickHouse/ClickHouse/pull/2741) ortam değişkenlerinden yapılandırma dosyalarındaki değerleri ayarlamak için öznitelik. +- Eklenen büyük / küçük harf duyarlı sürümleri `coalesce`, `ifNull`, ve `nullIf functions` [\#2752](https://github.com/ClickHouse/ClickHouse/pull/2752). + +#### Hata düzeltmeleri: {#bug-fixes-15} + +- Bir kopya başlatırken olası bir hata düzeltildi [\#2759](https://github.com/ClickHouse/ClickHouse/pull/2759). + +## ClickHouse sürümü 18.4 {#clickhouse-release-18-4} + +### ClickHouse yayın 18.4.0, 2018-07-28 {#clickhouse-release-18-4-0-2018-07-28} + +#### Yenilik: {#new-features-8} + +- Eklenen sistem tabloları: `formats`, `data_type_families`, `aggregate_function_combinators`, `table_functions`, `table_engines`, `collations` [\#2721](https://github.com/ClickHouse/ClickHouse/pull/2721). +- Bir argüman olarak bir tablo yerine bir tablo işlevini kullanma yeteneği eklendi `remote` veya `cluster table function` [\#2708](https://github.com/ClickHouse/ClickHouse/pull/2708). +- İçin destek `HTTP Basic` çoğaltma protokolünde kimlik doğrulama [\#2727](https://github.com/ClickHouse/ClickHouse/pull/2727). +- Bu `has` fonksiyon artık bir dizi sayısal bir değer için arama sağlar `Enum` değerler [Maxim Khrisanfov](https://github.com/ClickHouse/ClickHouse/pull/2699). +- Gelen okurken keyfi mesaj ayırıcılar eklemek için destek `Kafka` [Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2701). + +#### Geliştirmeler: {#improvements-8} + +- Bu `ALTER TABLE t DELETE WHERE` sorgu, where koşulundan etkilenmeyen veri bölümlerini yeniden yazmaz [\#2694](https://github.com/ClickHouse/ClickHouse/pull/2694). +- Bu `use_minimalistic_checksums_in_zookeeper` seçeneği için `ReplicatedMergeTree` tablolar varsayılan olarak etkindir. Bu ayar 1.1.54378, 2018-04-16 sürümüne eklendi. 1.1.54378'den eski sürümler artık yüklenemez. +- Koşu için destek `KILL` ve `OPTIMIZE` belirten sorgular `ON CLUSTER` [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2689). + +#### Hata düzeltmeleri: {#bug-fixes-16} + +- Hata düzeltildi `Column ... is not under an aggregate function and not in GROUP BY` bir in ifadesi ile toplama için. Bu hata 18.1.0 sürümünde göründü. ([bbdd780b](https://github.com/ClickHouse/ClickHouse/commit/bbdd780be0be06a0f336775941cdd536878dd2c2)) +- Bu bir hata düzeltildi `windowFunnel aggregate function` [Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2735). +- Bu bir hata düzeltildi `anyHeavy` toplama fonksiyonu ([a2101df2](https://github.com/ClickHouse/ClickHouse/commit/a2101df25a6a0fba99aa71f8793d762af2b801ee)) +- Kullanırken sabit sunucu çökmesi `countArray()` toplama işlevi. + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-5} + +- İçin parametreler `Kafka` motor değiştirildi `Kafka(kafka_broker_list, kafka_topic_list, kafka_group_name, kafka_format[, kafka_schema, kafka_num_consumers])` -e doğru `Kafka(kafka_broker_list, kafka_topic_list, kafka_group_name, kafka_format[, kafka_row_delimiter, kafka_schema, kafka_num_consumers])`. Tablolar kullanıyorsanız `kafka_schema` veya `kafka_num_consumers` parametreleri, elle meta dosyaları düzenlemek zorunda `path/metadata/database/table.sql` ve Ekle `kafka_row_delimiter` parametre ile `''` değer. + +## ClickHouse sürümü 18.1 {#clickhouse-release-18-1} + +### ClickHouse sürümü 18.1.0, 2018-07-23 {#clickhouse-release-18-1-0-2018-07-23} + +#### Yenilik: {#new-features-9} + +- İçin destek `ALTER TABLE t DELETE WHERE` çoğaltılmamış MergeTree tabloları için sorgu ([\#2634](https://github.com/ClickHouse/ClickHouse/pull/2634)). +- İçin keyfi türleri için destek `uniq*` agrega fonksiyonları ailesi ([\#2010](https://github.com/ClickHouse/ClickHouse/issues/2010)). +- Karşılaştırma operatörlerinde keyfi türler için destek ([\#2026](https://github.com/ClickHouse/ClickHouse/issues/2026)). +- Bu `users.xml` dosya biçiminde bir alt ağ maskesi ayarlama sağlar `10.0.0.1/255.255.255.0`. Bu, ortada sıfır olan IPv6 ağları için Maskeler kullanmak için gereklidir ([\#2637](https://github.com/ClickHouse/ClickHouse/pull/2637)). +- Add theed the `arrayDistinct` işlev ([\#2670](https://github.com/ClickHouse/ClickHouse/pull/2670)). +- SummingMergeTree altyapısı artık AggregateFunction türü sütunları ile çalışabilir ([Constantin S. Pan](https://github.com/ClickHouse/ClickHouse/pull/2566)). + +#### Geliştirmeler: {#improvements-9} + +- Sürüm sürümleri için numaralandırma düzenini değiştirdi. Şimdi ilk bölüm sürüm yılını içeriyor (A. D., Moskova saat dilimi, eksi 2000), ikinci bölüm büyük değişikliklerin sayısını içeriyor (çoğu sürüm için artar) ve üçüncü bölüm yama sürümüdür. Aksi changelog belirtilmediği sürece bültenleri hala geriye dönük uyumludur. +- Kayan noktalı sayıların bir dizeye daha hızlı dönüştürülmesi ([Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2664)). +- Ayrıştırma hataları nedeniyle bir ekleme sırasında bazı satırlar atlanmışsa (bu, `input_allow_errors_num` ve `input_allow_errors_ratio` ayarları etkin), atlanan satır sayısı şimdi sunucu günlüğüne yazılır ([Leonardo Cecchi](https://github.com/ClickHouse/ClickHouse/pull/2669)). + +#### Hata düzeltmeleri: {#bug-fixes-17} + +- Geçici tablolar için TRUNCATE komutu düzeltildi ([Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2624)). +- Yanıtı okurken bir ağ hatası olduğunda meydana gelen ZooKeeper istemci kütüphanesinde nadir bir kilitlenme düzeltildi ([c315200](https://github.com/ClickHouse/ClickHouse/commit/c315200e64b87e44bdf740707fc857d1fdf7e947)). +- Null türleri için bir döküm sırasında bir hata düzeltildi ([\#1322](https://github.com/ClickHouse/ClickHouse/issues/1322)). +- Yanlış sonuç düzeltildi `maxIntersection()` aralıkların sınırları çakıştığında işlev ([Michael Furmur](https://github.com/ClickHouse/ClickHouse/pull/2657)). +- Bir işlev argümanında or ifade zincirinin yanlış dönüşümü düzeltildi ([chenxing-xc](https://github.com/ClickHouse/ClickHouse/pull/2663)). +- İçeren sorgular için sabit performans düşüşü `IN (subquery)` başka bir alt sorgu içindeki ifadeler ([\#2571](https://github.com/ClickHouse/ClickHouse/issues/2571)). +- Bir kullanan dağıtılmış sorgularda farklı sürümleri ile sunucular arasında sabit uyumsuzluk `CAST` büyük harflerle olmayan işlev ([fe8c4d6](https://github.com/ClickHouse/ClickHouse/commit/fe8c4d64e434cacd4ceef34faa9005129f2190a5)). +- Harici bir DBMS sorguları için tanımlayıcıları alıntı eksik eklendi ([\#2635](https://github.com/ClickHouse/ClickHouse/issues/2635)). + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-6} + +- DateTime için sıfır sayısını içeren bir dize dönüştürme çalışmaz. Örnek: `SELECT toDateTime('0')`. Bu da nedeni `DateTime DEFAULT '0'` tablolarda da çalışmıyor `0` sözlüklerde. Çözüm: değiştirin `0` ile `0000-00-00 00:00:00`. + +## ClickHouse sürüm 1.1 {#clickhouse-release-1-1} + +### ClickHouse sürümü 1.1.54394, 2018-07-12 {#clickhouse-release-1-1-54394-2018-07-12} + +#### Yenilik: {#new-features-10} + +- Add theed the `histogram` toplama fonksiyonu ([Mikhail Surin](https://github.com/ClickHouse/ClickHouse/pull/2521)). +- Şimdi `OPTIMIZE TABLE ... FINAL` için bölümler belirt specifyingmeden kullanılabilir `ReplicatedMergeTree` ([Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2600)). + +#### Hata düzeltmeleri: {#bug-fixes-18} + +- Çoğaltılmış verileri gönderirken ve indirirken okumak ve yazmak için soketler için çok küçük bir zaman aşımı (bir saniye) ile ilgili bir sorun düzeltildi, bu da ağ veya diskte bir yük varsa daha büyük parçaları indirmeyi imkansız hale getirdi (parçaları indirmek için döngüsel girişimlerle sonuçlandı). Bu hata 1.1.54388 sürümünde oluştu. +- Tabloda yinelenen veri blokları eklediyseniz zookeeper chroot kullanırken sorunlar giderildi. +- Bu `has` işlev artık boş öğelere sahip bir dizi için doğru çalışıyor ([\#2115](https://github.com/ClickHouse/ClickHouse/issues/2115)). +- Bu `system.tables` tablo şimdi dağıtılmış sorgularda kullanıldığında düzgün çalışır. Bu `metadata_modification_time` ve `engine_full` sütunlar artık sanal değil. Tablodan yalnızca bu sütunlar sorgulanırsa oluşan bir hata düzeltildi. +- Sabit nasıl boş `TinyLog` tablo boş bir veri bloğu ekledikten sonra çalışır ([\#2563](https://github.com/ClickHouse/ClickHouse/issues/2563)). +- Bu `system.zookeeper` zookeeper düğümün değeri NULL ise Tablo çalışır. + +### ClickHouse sürümü 1.1.54390, 2018-07-06 {#clickhouse-release-1-1-54390-2018-07-06} + +#### Yenilik: {#new-features-11} + +- Sorgular gönderilebilir `multipart/form-data` biçim (içinde `query` alan), sorgu işleme için harici veriler de gönderilirse yararlıdır ([Olga Hvostikova](https://github.com/ClickHouse/ClickHouse/pull/2490)). +- CSV formatında veri okurken tek veya çift tırnak işleme etkinleştirmek veya devre dışı bırakmak için yeteneği eklendi. Bunu şu şekilde yapılandırabilirsiniz: `format_csv_allow_single_quotes` ve `format_csv_allow_double_quotes` ayarlar ([Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2574)). +- Şimdi `OPTIMIZE TABLE ... FINAL` olmayan çoğaltılmış varyantları için bölüm belirtmeden kullanılabilir `MergeTree` ([Amos Kuşu](https://github.com/ClickHouse/ClickHouse/pull/2599)). + +#### Geliştirmeler: {#improvements-10} + +- Geliştirilmiş performans, azaltılmış bellek tüketimi, ve doğru bellek tüketimi izleme kullanımı ile In operatör zaman bir tablo Endeksi kullanılabilir ([\#2584](https://github.com/ClickHouse/ClickHouse/pull/2584)). +- Bir veri parçası eklerken sağlama toplamlarının gereksiz denetimi kaldırıldı. Bu, çok sayıda çoğaltma olduğunda önemlidir,çünkü bu durumlarda toplam kontrol sayısı n^2'ye eşittir. +- İçin destek eklendi `Array(Tuple(...))` arg theum argumentsents for the `arrayEnumerateUniq` işlev ([\#2573](https://github.com/ClickHouse/ClickHouse/pull/2573)). +- Katma `Nullable` için destek `runningDifference` işlev ([\#2594](https://github.com/ClickHouse/ClickHouse/pull/2594)). +- Çok sayıda ifade olduğunda geliştirilmiş sorgu analizi performansı ([\#2572](https://github.com/ClickHouse/ClickHouse/pull/2572)). +- Birleştirme için veri parçalarının daha hızlı seçimi `ReplicatedMergeTree` Tablolar. ZooKeeper oturumunun daha hızlı iyileşmesi ([\#2597](https://github.com/ClickHouse/ClickHouse/pull/2597)). +- Bu `format_version.txt` için dosya `MergeTree` eksikse tablolar yeniden oluşturulur, bu da dizin yapısını dosyalar olmadan kopyaladıktan sonra ClickHouse başlatılırsa mantıklı olur ([Ciprian Hacman](https://github.com/ClickHouse/ClickHouse/pull/2593)). + +#### Hata düzeltmeleri: {#bug-fixes-19} + +- ZooKeeper ile çalışırken, sunucuyu yeniden başlatmadan önce oturumu ve readonly tablo durumlarını kurtarmayı imkansız hale getirebilecek bir hata düzeltildi. +- Oturum kesilirse eski düğümlerin silinmemesine neden olabilecek ZooKeeper ile çalışırken bir hata düzeltildi. +- Sabit bir hata `quantileTDigest` Float argümanları için işlev (bu hata 1.1.54388 sürümünde tanıtıldı) ([Mikhail Surin](https://github.com/ClickHouse/ClickHouse/pull/2553)). +- Birincil anahtar sütunu, aynı boyuttaki imzalı ve imzasız tamsayılar arasındaki türleri dönüştürmek için işlevin içinde bulunuyorsa, mergetree tabloları için dizinde bir hata düzeltildi ([\#2603](https://github.com/ClickHouse/ClickHouse/pull/2603)). +- Sabit segfault eğer `macros` kullanılır ancak yapılandırma dosyasında değildir ([\#2570](https://github.com/ClickHouse/ClickHouse/pull/2570)). +- İstemci yeniden bağlanırken varsayılan veritabanına sabit anahtarlama ([\#2583](https://github.com/ClickHouse/ClickHouse/pull/2583)). +- Ne zaman meydana gelen bir hata düzeltildi `use_index_for_in_with_subqueries` ayar devre dışı bırakıldı. + +#### Güvenlik düzeltme: {#security-fix-1} + +- Mysql'e bağlandığında dosya göndermek artık mümkün değil (`LOAD DATA LOCAL INFILE`). + +### ClickHouse sürümü 1.1.54388, 2018-06-28 {#clickhouse-release-1-1-54388-2018-06-28} + +#### Yenilik: {#new-features-12} + +- İçin destek `ALTER TABLE t DELETE WHERE` çoğaltılmış tablolar için sorgu. Add theed the `system.mutations` bu tür sorguların ilerlemesini izlemek için tablo. +- İçin destek `ALTER TABLE t [REPLACE|ATTACH] PARTITION` \*MergeTree tabloları için sorgu. +- İçin destek `TRUNCATE TABLE` sorgu ([Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2260)) +- Birkaç yeni `SYSTEM` çoğaltılmış tablolar için sorgular (`RESTART REPLICAS`, `SYNC REPLICA`, `[STOP|START] [MERGES|FETCHES|SENDS REPLICATED|REPLICATION QUEUES]`). +- MySQL motoru ve ilgili tablo fonksiyonu ile bir tabloya yazma yeteneği eklendi ([sundy-li](https://github.com/ClickHouse/ClickHouse/pull/2294)). +- Add theed the `url()` tablo fonksiyonu ve `URL` masa motoru ([Alexander Sapin](https://github.com/ClickHouse/ClickHouse/pull/2501)). +- Add theed the `windowFunnel` toplama fonksiyonu ([sundy-li](https://github.com/ClickHouse/ClickHouse/pull/2352)). +- Yeni `startsWith` ve `endsWith` dizeler için işlevler ([Vadim Plakhtinsky](https://github.com/ClickHouse/ClickHouse/pull/2429)). +- Bu `numbers()` tablo işlevi artık ofset belirtmenizi sağlar ([Kış Zhang](https://github.com/ClickHouse/ClickHouse/pull/2535)). +- Şifre için `clickhouse-client` etkileşimli olarak girilebilir. +- Sunucu günlükleri artık syslog'a gönderilebilir ([Alexander Krasheninnikov](https://github.com/ClickHouse/ClickHouse/pull/2459)). +- Paylaşılan kitaplık kaynağı ile sözlüklerde oturum açma desteği ([Alexander Sapin](https://github.com/ClickHouse/ClickHouse/pull/2472)). +- Özel CSV sınırlayıcılar için destek ([Ivan Zhukov](https://github.com/ClickHouse/ClickHouse/pull/2263)) +- Add theed the `date_time_input_format` ayar. Bu ayarı şu şekilde değiştirirseniz `'best_effort'`, DateTime değerleri biçimleri geniş bir yelpazede okunacaktır. +- Add theed the `clickhouse-obfuscator` veri gizleme için yardımcı program. Kullanım örneği: performans testlerinde kullanılan verileri yayınlama. + +#### Deneysel özellikler: {#experimental-features-2} + +- Hesaplamak için yeteneği eklendi `and` argümanlar sadece ihtiyaç duydukları yerde ([Anastasia Tsarkova](https://github.com/ClickHouse/ClickHouse/pull/2272)) +- Yerel kod JIT derleme bazı ifadeler için artık kullanılabilir ([pyos](https://github.com/ClickHouse/ClickHouse/pull/2277)). + +#### Hata düzeltmeleri: {#bug-fixes-20} + +- Yinelemeler artık bir sorgu için görünmüyor `DISTINCT` ve `ORDER BY`. +- İle sorgular `ARRAY JOIN` ve `arrayFilter` artık yanlış bir sonuç döndürmez. +- İç içe geçmiş bir yapıdan bir dizi sütunu okurken bir hata düzeltildi ([\#2066](https://github.com/ClickHouse/ClickHouse/issues/2066)). +- Gibi bir having yan tümcesi ile sorguları analiz ederken bir hata düzeltildi `HAVING tuple IN (...)`. +- Özyinelemeli takma adlarla sorguları analiz ederken bir hata düzeltildi. +- Tüm satırları filtreleyen PREWHERE bir koşul ile ReplacingMergeTree okurken bir hata düzeltildi ([\#2525](https://github.com/ClickHouse/ClickHouse/issues/2525)). +- HTTP arabirimindeki oturumları kullanırken kullanıcı profili ayarları uygulanmadı. +- Clickhouse-local'deki komut satırı parametrelerinden ayarların nasıl uygulandığı düzeltildi. +- ZooKeeper istemci kitaplığı artık sunucudan alınan oturum zaman aşımını kullanır. +- İstemci zaman aşımı daha uzun sunucu yanıt bekledi ZooKeeper istemci kütüphanesinde bir hata düzeltildi. +- Bölüm anahtar sütunlarındaki koşullarla sorgular için parçaların sabit budaması ([\#2342](https://github.com/ClickHouse/ClickHouse/issues/2342)). +- Birleşmeler şimdi mümkün `CLEAR COLUMN IN PARTITION` ([\#2315](https://github.com/ClickHouse/ClickHouse/issues/2315)). +- ODBC tablo işlevinde tür eşleme düzeltildi ([sundy-li](https://github.com/ClickHouse/ClickHouse/pull/2268)). +- Tür karşılaştır formaları Düzelt forildi `DateTime` saat dilimi ile ve olmadan ([Alexander Bocharov](https://github.com/ClickHouse/ClickHouse/pull/2400)). +- Sabit sözdizimsel ayrıştırma ve biçimlendirme `CAST` operatör. +- Dağıtılmış tablo motoru için somutlaştırılmış bir görünüme sabit ekleme ([Babacar Diassé](https://github.com/ClickHouse/ClickHouse/pull/2411)). +- Veri yazarken bir yarış durumu düzeltildi `Kafka` motor için hayata görünümleri ([Yangkuan Liu](https://github.com/ClickHouse/ClickHouse/pull/2448)). +- Uzak () tablo işlevinde sabit SSRF. +- Sabit çıkış davranışı `clickhouse-client` çok satırlı modda ([\#2510](https://github.com/ClickHouse/ClickHouse/issues/2510)). + +#### Geliştirmeler: {#improvements-11} + +- Çoğaltılmış tablolardaki arka plan görevleri artık ayrı iş parçacıkları yerine bir iş parçacığı havuzunda gerçekleştirilir ([Silviu Caragea](https://github.com/ClickHouse/ClickHouse/pull/1722)). +- Geliştirilmiş lz4 sıkıştırma performansı. +- Çok sayıda birleştirme ve alt sorgu ile sorgular için daha hızlı analiz. +- Çok fazla ağ hatası olduğunda DNS önbelleği artık otomatik olarak güncellenir. +- Çok fazla parçaya sahip olduğundan, materialized görünümlerden birine ekleme mümkün değilse, tablo ekleri artık oluşmaz. +- Olay sayaçlarındaki tutarsızlık düzeltildi `Query`, `SelectQuery`, ve `InsertQuery`. +- Gibi ifadeler `tuple IN (SELECT tuple)` tuple türleri eşleşirse izin verilir. +- Çoğaltılmış tabloları olan bir sunucu, Zookeeper'ı yapılandırmasanız bile başlayabilir. +- Mevcut CPU çekirdeklerinin sayısını hesaplarken, C gruplarındaki sınırlar şimdi dikkate alınmaktadır ([Atri Sharma](https://github.com/ClickHouse/ClickHouse/pull/2325)). +- Systemd yapılandırma dosyasında yapılandırma dizinleri için chown eklendi ([Mikhail Shiryaev](https://github.com/ClickHouse/ClickHouse/pull/2421)). + +#### Yapı değişiklikleri: {#build-changes-4} + +- Gcc8 derleyicisi yapılar için kullanılabilir. +- Alt modülden llvm oluşturma yeteneği eklendi. +- Librdkafka kütüphanesinin sürümü v0.11.4 olarak güncellendi. +- Sistem libcpuid kütüphanesini kullanma yeteneği eklendi. Kütüphane sürümü 0.4.0 olarak güncellendi. +- Vectorclass kütüphanesini kullanarak yapı düzeltildi ([Babacar Diassé](https://github.com/ClickHouse/ClickHouse/pull/2274)). +- Cmake şimdi varsayılan olarak ninja için dosyalar üretir (kullanırken olduğu gibi `-G Ninja`). +- Libtermcap yerine libtınfo kütüphanesini kullanma yeteneği eklendi ([Georgy Kondratiev](https://github.com/ClickHouse/ClickHouse/pull/2519)). +- Fedora Rawhide bir başlık dosyası çakışması düzeltildi ([\#2520](https://github.com/ClickHouse/ClickHouse/issues/2520)). + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-7} + +- Çıkar escapingıldı `Vertical` ve `Pretty*` format Andlar ve silinen `VerticalRaw` biçimli. +- 1.1.54388 (veya daha yeni) sürümüne sahip sunucular ve daha eski bir sürüme sahip sunucular dağıtılmış bir sorguda aynı anda kullanılıyorsa ve sorgunun `cast(x, 'Type')` ifade olmadan `AS` anahtar kelime ve kelime yok `cast` büyük harfle, bir istisna gibi bir mesajla atılır `Not found column cast(0, 'UInt8') in block`. Çözüm: tüm kümedeki sunucuyu güncelleyin. + +### ClickHouse sürümü 1.1.54385, 2018-06-01 {#clickhouse-release-1-1-54385-2018-06-01} + +#### Hata düzeltmeleri: {#bug-fixes-21} + +- Bazı durumlarda zookeeper işlemlerinin engellenmesine neden olan bir hata düzeltildi. + +### ClickHouse sürümü 1.1.54383, 2018-05-22 {#clickhouse-release-1-1-54383-2018-05-22} + +#### Hata düzeltmeleri: {#bug-fixes-22} + +- Bir tablo birçok yinelemeler varsa çoğaltma kuyruğunun bir yavaşlama düzeltildi. + +### ClickHouse sürümü 1.1.54381, 2018-05-14 {#clickhouse-release-1-1-54381-2018-05-14} + +#### Hata düzeltmeleri: {#bug-fixes-23} + +- ClickHouse ZooKeeper sunucusuna bağlantı kaybettiğinde ZooKeeper bir düğüm sızıntısı düzeltildi. + +### ClickHouse sürüm 1.1.54380, 2018-04-21 {#clickhouse-release-1-1-54380-2018-04-21} + +#### Yenilik: {#new-features-13} + +- Tablo fonksiyonu eklendi `file(path, format, structure)`. Örnek okuma baytları `/dev/urandom`: ``` ln -s /dev/urandom /var/lib/clickhouse/user_files/random``clickhouse-client -q "SELECT * FROM file('random', 'RowBinary', 'd UInt8') LIMIT 10" ```. + +#### Geliştirmeler: {#improvements-12} + +- Alt sorgular sarılabilir `()` sorgu okunabilirliğini artırmak için parantez. Mesela: `(SELECT 1) UNION ALL (SELECT 1)`. +- Basit `SELECT` gelen sorgular `system.processes` tablo dahil değildir `max_concurrent_queries` sınır. + +#### Hata düzeltmeleri: {#bug-fixes-24} + +- Sabit yanlış davranış `IN` operatör ne zaman seçin `MATERIALIZED VIEW`. +- Gibi ifadelerde bölüm indeksi ile sabit yanlış filtreleme `partition_key_column IN (...)`. +- Sabit yetersizlik yürütmek için `OPTIMIZE` eğer lider olmayan çoğaltma üzerinde sorgu `REANAME` masaya yapıldı. +- Yürütülürken yetkilendirme hatası düzeltildi `OPTIMIZE` veya `ALTER` olmayan bir lider çoğaltma sorgular. +- Sabit donma `KILL QUERY`. +- Saatlerin kaybına yol açan ZooKeeper istemci kütüphanesinde bir hata, dağıtılmış DDL kuyruğunun dondurulması ve boş olmayan bir çoğaltma kuyruğundaki yavaşlamalar düzeltildi `chroot` önek ZooKeeper yapılandırmasında kullanılır. + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-8} + +- Gibi ifadeler için destek kaldırıldı `(a, b) IN (SELECT (a, b))` (eşdeğer ifadeyi kullanabilirsiniz `(a, b) IN (SELECT a, b)`). Önceki sürümlerde, bu ifadeler belirsizliğe yol açtı `WHERE` filtreleme veya neden olan hatalar. + +### ClickHouse sürümü 1.1.54378, 2018-04-16 {#clickhouse-release-1-1-54378-2018-04-16} + +#### Yenilik: {#new-features-14} + +- Günlük düzeyi sunucuyu yeniden başlatmadan değiştirilebilir. +- Add theed the `SHOW CREATE DATABASE` sorgu. +- Bu `query_id` geç canilebilir `clickhouse-client` (elBroom). +- Yeni ayar: `max_network_bandwidth_for_all_users`. +- İçin destek eklendi `ALTER TABLE ... PARTITION ...` için `MATERIALIZED VIEW`. +- Sistem tablosunda sıkıştırılmamış formdaki veri parçalarının boyutu hakkında bilgi eklendi. +- Dağıtılmış tablolar için sunucudan sunucuya şifreleme desteği (`1` rep thelik thea config in ``). +- Tablo düzeyi için yapılandırma `ReplicatedMergeTree` Zookeeper saklanan veri miktarını en aza indirmek için aile: : `use_minimalistic_checksums_in_zookeeper = 1` +- Yapılandırma `clickhouse-client` istem. Varsayılan olarak, sunucu adları artık istemine çıktı. Sunucunun görünen adı değiştirilebilir. Ayrıca gönderilen `X-ClickHouse-Display-Name` HTTP Başlığı (Kirill Shvakov). +- Birden çok virgülle ayrılmış `topics` için belirt theilebilir `Kafka` motor (Tobias Adamson) +- Bir sorgu tarafından durdurulduğunda `KILL QUERY` veya `replace_running_query`, müşteri alır `Query was canceled` eksik bir sonuç yerine istisna. + +#### Geliştirmeler: {#improvements-13} + +- `ALTER TABLE ... DROP/DETACH PARTITION` sorgular, çoğaltma kuyruğunun önünde çalıştırılır. +- `SELECT ... FINAL` ve `OPTIMIZE ... FINAL` tablo tek bir veri parçası olduğunda bile kullanılabilir. +- A `query_log` el ile silindiyse tablo anında yeniden oluşturulur (Kirill Shvakov). +- Bu `lengthUTF8` fonksiyon daha hızlı çalışır (zhang2014). +- Senkron ekler geliştirilmiş performans `Distributed` Tablolar (`insert_distributed_sync = 1`) çok sayıda parça olduğunda. +- Sunucu kabul eder `send_timeout` ve `receive_timeout` istemciden ayarlar ve istemciye bağlanırken bunları uygular (bunlar ters sırada uygulanır: sunucu soketinin `send_timeout` için ayarlanır `receive_timeout` müşteriden alınan değer ve tersi). +- Asenkron ekleme için daha sağlam kilitlenme kurtarma `Distributed` Tablolar. +- Dönüş türü `countEqual` fonksiyon değiştirildi `UInt32` -e doğru `UInt64` (谢磊). + +#### Hata düzeltmeleri: {#bug-fixes-25} + +- Bir hata düzeltildi `IN` ifadenin sol tarafı olduğunda `Nullable`. +- Tuples ile birlikte kullanıldığında doğru sonuçlar şimdi döndürülür `IN` bazı tuple bileşenleri tablo dizininde olduğunda. +- Bu `max_execution_time` limit şimdi dağıtılmış sorgularla düzgün çalışır. +- Bileşik sütunların boyutunu hesaplarken sabit hatalar `system.columns` Tablo. +- Geçici bir tablo oluştururken bir hata düzeltildi `CREATE TEMPORARY TABLE IF NOT EXISTS.` +- Sabit hatalar `StorageKafka` (\#\#2075) +- Sabit sunucu, belirli toplam işlevlerin geçersiz argümanlarından çöker. +- Engellenen hata düzeltildi `DETACH DATABASE` için arka plan görevlerini durdurma sorgusu `ReplicatedMergeTree` Tablolar. +- `Too many parts` toplu materialized görünümler (\#\#2084) eklerken durum daha az olasıdır. +- Bir ikame aynı düzeyde başka bir ikame tarafından takip edilmesi gerekiyorsa, yapılandırmada değiştirmelerin düzeltilmiş özyinelemeli işleme. +- Bir oluştururken meta veri dosyasında sözdizimi düzeltildi `VIEW` bu bir sorgu ile kullanır `UNION ALL`. +- `SummingMergeTree` şimdi bir bileşik anahtar ile iç içe veri yapılarının toplamı için doğru çalışır. +- Lider seçerken bir yarış durumu olasılığı sabit `ReplicatedMergeTree` Tablolar. + +#### Yapı değişiklikleri: {#build-changes-5} + +- Yapı destekler `ninja` yerine `make` ve kullanımları `ninja` sürümleri oluşturmak için varsayılan olarak. +- Yeniden adlandırılan paketler: `clickhouse-server-base` içinde `clickhouse-common-static`; `clickhouse-server-common` içinde `clickhouse-server`; `clickhouse-common-dbg` içinde `clickhouse-common-static-dbg`. Yüklemek için kullanın `clickhouse-server clickhouse-client`. Eski adlara sahip paketler, geriye dönük uyumluluk için depolara yüklenmeye devam edecektir. + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-9} + +- Sol tarafta bir dizi belirtilmişse, bir In ifadesinin özel yorumunu kaldırıldı. Daha önce, ifade `arr IN (set)` olarak yorum waslandı “at least one `arr` element belongs to the `set`”. Yeni sürümde aynı davranışı elde etmek için şunları yazın `arrayExists(x -> x IN (set), arr)`. +- Soket seçeneğinin yanlış kullanımı devre dışı bırakıldı `SO_REUSEPORT`, poco kitaplığında varsayılan olarak yanlış etkinleştirildi. Linux'ta artık adresleri aynı anda belirtmek için herhangi bir neden olmadığını unutmayın `::` ve `0.0.0.0` for listen – use just `::`(varsayılan çekirdek yapılandırma ayarları ile) IPv4 ve IPv6 üzerinden hem bağlantı dinleme sağlar. Belirterek önceki sürümlerden davranışa da geri dönebilirsiniz `1` config. + +### ClickHouse sürümü 1.1.54370, 2018-03-16 {#clickhouse-release-1-1-54370-2018-03-16} + +#### Yenilik: {#new-features-15} + +- Add theed the `system.macros` tablo ve yapılandırma dosyası değiştirildiğinde makroların otomatik güncellenmesi. +- Add theed the `SYSTEM RELOAD CONFIG` sorgu. +- Add theed the `maxIntersections(left_col, right_col)` aynı anda kesişen aralıkların maksimum sayısını döndüren toplama işlevi `[left; right]`. Bu `maxIntersectionsPosition(left, right)` fonksiyonun başlangıcını döndürür “maximum” aralıklı. ([Michael Furmur](https://github.com/ClickHouse/ClickHouse/pull/2012)). + +#### Geliştirmeler: {#improvements-14} + +- Bir veri eklerken `Replicated` tablo, daha az istek yapılır `ZooKeeper` (ve kullanıcı düzeyinde hataların çoğu `ZooKeeper` günlük). +- Veri kümeleri için takma ad oluşturma yeteneği eklendi. Örnek: `WITH (1, 2, 3) AS set SELECT number IN set FROM system.numbers LIMIT 10`. + +#### Hata düzeltmeleri: {#bug-fixes-26} + +- Sabit `Illegal PREWHERE` birleştirme tablolarından okunurken hata `Distributed`Tablolar. +- Eğer IPv4 sadece Docker kaplarda clickhouse-server başlatmak için izin eklendi düzeltmeler. +- Sistemden okurken bir yarış durumu düzeltildi `system.parts_columns tables.` +- Bir senkron ekleme sırasında çift tamponlama kaldırıldı `Distributed` zaman aşımı için bağlantı neden olabilir tablo. +- Başlamadan önce kullanılamayan bir kopya için aşırı uzun beklemelere neden olan bir hata düzeltildi `SELECT` sorgu. +- Sabit yanlış tarihler `system.parts` Tablo. +- İmkansız bir veri eklemek için yapılan bir hata düzeltildi `Replicated` tablo ise `chroot` yapılandırmada boş değildi `ZooKeeper` küme. +- Boş bir dikey birleştirme algoritması düzeltildi `ORDER BY` Tablo. +- Uzak tablo, bu sözlük istemcisi sunucu üzerinde yoksa bile sorgular sözlük kullanma olanağı sağlandı. Bu işlevsellik 1.1.54362 sürümünde kayboldu. +- Gibi sorgular için davranışı geri `SELECT * FROM remote('server2', default.table) WHERE col IN (SELECT col2 FROM default.table)` ne zaman sağ tarafı `IN` bir uzaktan kumanda kullanmalı `default.table` yerel bir yerine. Bu davranış 1.1.54358 sürümünde bozuldu. +- Kaldırılan gereksiz hata düzeyi günlüğü `Not found column ... in block`. + +### ClickHouse Yayın 1.1.54362, 2018-03-11 {#clickhouse-release-1-1-54362-2018-03-11} + +#### Yenilik: {#new-features-16} + +- Olmadan toplama `GROUP BY` boş bir set için (örneğin `SELECT count(*) FROM table WHERE 0`) şimdi SQL standardına uygun olarak toplam işlevler için boş değerlere sahip bir satırla bir sonuç döndürür. Eski davranışı geri yüklemek için (boş bir sonuç döndürür), `empty_result_for_aggregation_by_empty_set` 1'e. +- İçin Tip dönüştürme eklendi `UNION ALL`. Farklı takma ad adlarına izin verilir `SELECT` pozisyon inlar `UNION ALL`, SQL standardına uygun olarak. +- Keyfi ifadeler desteklenir `LIMIT BY` yanlar. Daha önce, yalnızca aşağıdakilerden kaynaklanan sütunları kullanmak mümkündü `SELECT`. +- Dizini `MergeTree` tablolar şu durumlarda kullanılır `IN` birincil anahtarın sütunlarından bir ifade kümesine uygulanır. Örnek: `WHERE (UserID, EventDate) IN ((123, '2000-01-01'), ...)` (Anastasiya Tsarkova). +- Add theed the `clickhouse-copier` kümeleri ve resharding veri (beta) arasında kopyalama aracı. +- Tutarlı karma fonksiyonları eklendi: `yandexConsistentHash`, `jumpConsistentHash`, `sumburConsistentHash`. Onlar sonraki reshardings sırasında ağ trafiği miktarını azaltmak için bir sharding anahtar olarak kullanılabilir. +- Eklenen fonksiyonlar: `arrayAny`, `arrayAll`, `hasAny`, `hasAll`, `arrayIntersect`, `arrayResize`. +- Add theed the `arrayCumSum` fonksiyon (Javi Santana). +- Add theed the `parseDateTimeBestEffort`, `parseDateTimeBestEffortOrZero`, ve `parseDateTimeBestEffortOrNull` çok çeşitli Olası biçimlerde metin içeren bir dizeden datetime okumak için işlevler. +- Veriler, güncelleme sırasında harici sözlüklerden kısmen yeniden yüklenebilir (yalnızca belirtilen alanın değerinin önceki indirmeden daha büyük olduğu kayıtları yükleyin) (Arsen Hakobyan). +- Add theed the `cluster` tablo işlevi. Örnek: `cluster(cluster_name, db, table)`. Bu `remote` tablo işlevi, bir tanımlayıcı olarak belirtilirse, küme adını ilk bağımsız değişken olarak kabul edebilir. +- Bu `remote` ve `cluster` tablo fonksiyonları kullanılabilir `INSERT` sorgular. +- Add theed the `create_table_query` ve `engine_full` sanal sütunlar için `system.tables`Tablo . Bu `metadata_modification_time` sütun sanal. +- Add theed the `data_path` ve `metadata_path` sütunlar için `system.tables`ve`system.databases` tablolar ve eklenen `path` Col theum then to the `system.parts` ve `system.parts_columns` Tablolar. +- Birleştirme hakkında ek bilgi eklendi `system.part_log` Tablo. +- Keyfi bir bölümleme anahtarı için kullanılabilir `system.query_log` tablo (Kirill Shvakov). +- Bu `SHOW TABLES` sorgu şimdi de geçici tablolar gösterir. Geçici tablolar eklendi ve `is_temporary` sütun için `system.tables` (zhang2014). +- Katma `DROP TEMPORARY TABLE` ve `EXISTS TEMPORARY TABLE` sorgular (zhang2014). +- İçin destek `SHOW CREATE TABLE` geçici tablolar için (zhang2014). +- Add theed the `system_profile` iç işlemler tarafından kullanılan ayarlar için yapılandırma parametresi. +- Yükleme desteği `object_id` bir nitelik olarak `MongoDB` sözlükler (Pavel Litvinenko). +- Okuma `null` harici bir sözlük için veri yüklerken varsayılan değer olarak `MongoDB` kaynak (Pavel Litvinenko). +- Okuma `DateTime` değerleri `Values` tek tırnak işaretleri olmadan bir Unix zaman damgasından biçimlendirin. +- Yük devretme desteklenir `remote` tablo işlevleri bazı yinelemeler istenen tablo eksik olduğunda durumlar için. +- Çalıştırdığınızda yapılandırma ayarları komut satırında geçersiz kılınabilir `clickhouse-server`. Örnek: `clickhouse-server -- --logger.level=information`. +- Uygulanan `empty` fonksiyonu bir `FixedString` argüman: dize tamamen boş bayttan oluşuyorsa (zhang2014) işlev 1 döndürür. +- Add theed the `listen_try`bazı adresler dinlenemiyorsa (IPv4 veya IPv6 için engelli desteği olan sistemler için kullanışlıdır), dinleme adreslerinden en az birini bırakmadan dinlemek için yapılandırma parametresi. +- Add theed the `VersionedCollapsingMergeTree` masa motoru. +- Satır ve rasgele sayısal türleri için destek `library` sözlük kaynağı. +- `MergeTree` tablolar birincil anahtar olmadan kullanılabilir (belirtmeniz gerekir `ORDER BY tuple()`). +- A `Nullable` tipi olabilir `CAST` olmayan -`Nullable` bağımsız değişken değilse yazın `NULL`. +- `RENAME TABLE` için yapılabilir `VIEW`. +- Add theed the `throwIf` işlev. +- Add theed the `odbc_default_field_size` bir ODBC kaynağından yüklenen değerin en büyük boyutunu genişletmenizi sağlayan seçenek (varsayılan olarak, 1024'tür). +- Bu `system.processes` masa ve `SHOW PROCESSLIST` şimdi var `is_cancelled` ve `peak_memory_usage` sütun. + +#### Geliştirmeler: {#improvements-15} + +- Sonuç üzerindeki sınırlar ve kotalar artık Ara verilere uygulanmıyor `INSERT SELECT` sorgular veya `SELECT` alt sorgular. +- Daha az yanlış tetikleyici `force_restore_data` durumunu kontrol ederken `Replicated` sunucu başladığında tablolar. +- Add theed the `allow_distributed_ddl` seçenek. +- Nondeterministic işlevleri için ifadelerde izin verilmez `MergeTree` masa tuşları. +- Değiştirmeleri olan dosyalar `config.d` dizinler alfabetik sırayla yüklenir. +- Geliştirilmiş performans `arrayElement` elemanlardan biri olarak boş bir dizi ile sabit çok boyutlu bir dizi durumunda işlev. Örnek: `[[1], []][x]`. +- Sunucu, yapılandırma dosyalarını çok büyük ikamelerle (örneğin, çok büyük IP ağları listeleri) kullanırken daha hızlı başlar. +- Bir sorgu çalıştırırken, tablo değerli işlevleri bir kez çalıştırın. Önceden, `remote` ve `mysql` tablo değerli işlevler, tablo yapısını uzak bir sunucudan almak için aynı sorguyu iki kez gerçekleştirdi. +- Bu `MkDocs` belg .eleme üret .eci kullanılır. +- Bir tablo sütunu silmeye çalıştığınızda, `DEFAULT`/`MATERIALIZED` diğer sütunların ifadeleri bağlıdır, bir istisna atılır (zhang2014). +- İçin sayı 0 olarak metin biçimlerinde boş bir satır ayrıştırmak için yeteneği eklendi `Float` veri türleri. Bu özellik daha önce mevcuttu, ancak 1.1.54342 sürümünde kayboldu. +- `Enum` değerleri kullanılabilir `min`, `max`, `sum` ve diğer bazı fonksiyonlar. Bu durumlarda, karşılık gelen sayısal değerleri kullanır. Bu özellik daha önce mevcuttu, ancak 1.1.54337 sürümünde kayboldu. +- Katma `max_expanded_ast_elements` yinelemeli genişleyen takma adlar sonra AST boyutunu kısıtlamak için. + +#### Hata düzeltmeleri: {#bug-fixes-27} + +- Gereksiz sütunlar hatalı alt sorgulardan kaldırıldığında veya içeren alt sorgulardan kaldırılmadığında sabit durumlar `UNION ALL`. +- İçin birleştirir bir hata düzeltildi `ReplacingMergeTree` Tablolar. +- Sabit senkron eklemeler `Distributed` Tablolar (`insert_distributed_sync = 1`). +- Belirli kullanımlar için sabit segfault `FULL` ve `RIGHT JOIN` alt sorgularda yinelenen sütunlarla. +- Belirli kullanımlar için sabit segfault `replace_running_query` ve `KILL QUERY`. +- Sabit sipariş `source` ve `last_exception` Col theum thens in the `system.dictionaries` Tablo. +- Sabit hata zaman `DROP DATABASE` sorgu meta verileri ile dosyayı silmedi. +- Sabit `DROP DATABASE` sorgu için `Dictionary` veritabanılar. +- Sabit düşük hassasiyet `uniqHLL12` ve `uniqCombined` 100 milyondan fazla öğe için işlevler (Alex Bocharov). +- Aynı anda varsayılan açık ifadeleri hesaplamak için gerektiğinde örtülü varsayılan değerlerin hesaplanması düzeltildi `INSERT` sorgular (zhang2014). +- Bir sorgu için nadir bir durum düzeltildi `MergeTree` tablo bitiremedi (chenxing-xc). +- Bir çalışırken meydana gelen bir kilitlenme düzeltildi `CHECK` sorgu için `Distributed` tüm parçalar yerel ise tablolar (chenxing.xcc). +- Düzenli ifadeler kullanan işlevlerle hafif bir performans gerilemesi düzeltildi. +- Karmaşık ifadelerden çok boyutlu diziler oluştururken bir performans gerilemesi düzeltildi. +- Ekstra bir neden olabilecek bir hata düzeltildi `FORMAT` bir bölümde görün toecek bölüm `.sql` meta veriler içeren dosya. +- Neden bir hata düzeltildi `max_table_size_to_drop` s deleteilmeye çalış aılırken uygulanacak sınır `MATERIALIZED VIEW` açıkça belirtilen bir tabloya bakıyor. +- Eski istemcilerle sabit uyumsuzluk (eski istemciler bazen `DateTime('timezone')` anlamadıkları tür). +- Okurken bir hata düzeltildi `Nested` kullanılarak eklenen yapıların sütun elemanları `ALTER` ancak, bu sütunların koşulları taşındığında eski bölümler için boş `PREWHERE`. +- Tabloları sanal olarak filtrelerken bir hata düzeltildi `_table` sorgu columnslardaki sütunlar `Merge` Tablolar. +- Kullanırken bir hata düzeltildi `ALIAS` Col inum inns in `Distributed` Tablolar. +- Gelen toplam fonksiyonları ile sorgular için dinamik derleme imkansız hale bir hata düzeltildi `quantile` aile. +- Kullanırken çok nadir durumlarda meydana gelen sorgu yürütme boru hattında bir yarış durumu düzeltildi `Merge` çok sayıda tablo içeren tablolar ve kullanırken `GLOBAL` alt sorgular. +- Farklı boyutlarda dizileri geçerken bir kilitlenme düzeltildi `arrayReduce` birden çok bağımsız değişkenden toplam işlevleri kullanırken işlev. +- İle sorgu useların kullanılması yasaktır `UNION ALL` in a `MATERIALIZED VIEW`. +- Başlatma sırasında bir hata düzeltildi `part_log` sunucu başlatıldığında sistem tablosu (varsayılan olarak, `part_log` devre dışı) olur. + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-10} + +- Kaldır theılan `distributed_ddl_allow_replicated_alter` seçenek. Bu davranış varsayılan olarak etkindir. +- Kaldır theılan `strict_insert_defaults` ayar. Bu işlevi kullanıyorsanız, `clickhouse-feedback@yandex-team.com`. +- Kaldır theılan `UnsortedMergeTree` motor. + +### ClickHouse Yayın 1.1.54343, 2018-02-05 {#clickhouse-release-1-1-54343-2018-02-05} + +- Dağıtılmış DDL sorgularında ve dağıtılmış tabloların oluşturucularında küme adlarını tanımlamak için makro desteği eklendi: `CREATE TABLE distr ON CLUSTER '{cluster}' (...) ENGINE = Distributed('{cluster}', 'db', 'table')`. +- Şimdi gibi sorgular `SELECT ... FROM table WHERE expr IN (subquery)` kullanılarak iş arelenir `table` dizin. +- Çoğaltılmış tablolara eklerken çoğaltmaların işlenmesi geliştirildi, böylece artık çoğaltma kuyruğunun yürütülmesini yavaşlatmazlar. + +### ClickHouse Sürümü 1.1.54342, 2018-01-22 {#clickhouse-release-1-1-54342-2018-01-22} + +Bu sürüm önceki sürüm 1.1.54337 için hata düzeltmeleri içerir: + +- 1.1.54337'de bir gerileme düzeltildi: varsayılan kullanıcı salt okunur erişime sahipse, sunucu mesajla başlamayı reddediyor `Cannot create database in readonly mode`. +- 1.1.54337 bir gerileme sabit: systemd ile sistemlerde, günlükleri her zaman ne olursa olsun yapılandırma syslog yazılır; watchdog komut dosyası hala init kullanır.d. +- Docker görüntüde yanlış varsayılan yapılandırma: 1.1.54337 bir gerileme düzeltildi. +- Graphıtemergetree sabit nondeterministic davranış (günlük mesajları görebilirsiniz `Data after merge is not byte-identical to the data on another replicas`). +- Çoğaltılmış tablolara sorguyu OPTİMİZE ettikten sonra tutarsız birleştirmelere yol açabilecek bir hata düzeltildi (günlük iletilerinde görebilirsiniz `Part ... intersects the previous part`). +- (ZHANG2014 tarafından) hedef tabloda MATERİALİZED sütunlar mevcut olduğunda arabellek tabloları şimdi düzgün çalışır. +- NULL uygulanmasında bir hata düzeltildi. + +### ClickHouse Sürümü 1.1.54337, 2018-01-18 {#clickhouse-release-1-1-54337-2018-01-18} + +#### Yenilik: {#new-features-17} + +- Çok boyutlu diziler ve tuples depolanması için destek eklendi (`Tuple` veri türü) tablolarda. +- Masa fonksiyonları için destek `DESCRIBE` ve `INSERT` sorgular. Alt sorgular için destek eklendi `DESCRIBE`. Örnekler: `DESC TABLE remote('host', default.hits)`; `DESC TABLE (SELECT 1)`; `INSERT INTO TABLE FUNCTION remote('host', default.hits)`. İçin destek `INSERT INTO TABLE` ayrıca `INSERT INTO`. +- Saat dilimleri için geliştirilmiş destek. Bu `DateTime` veri türü ayrıştırma ve metin biçimlerinde biçimlendirme için kullanılan saat dilimi ile açıklamalı. Örnek: `DateTime('Europe/Moscow')`. Zaman dilimleri için işlevlerde belirtildiğinde `DateTime` bağımsız değişkenler, dönüş türü saat dilimini izler ve değer beklendiği gibi görüntülenir. +- Fonksiyonları eklendi `toTimeZone`, `timeDiff`, `toQuarter`, `toRelativeQuarterNum`. Bu `toRelativeHour`/`Minute`/`Second` fonksiyonlar bir tür değeri alabilir `Date` bir argüman olarak. Bu `now` işlev adı büyük / küçük harf duyarlıdır. +- Add theed the `toStartOfFifteenMinutes` fonksiyon (Kirill Shvakov). +- Add theed the `clickhouse format` sorguları biçimlendirme aracı. +- Add theed the `format_schema_path` configuration parameter (Marek Vavruşa). It is used for specifying a schema in `Cap'n Proto` biçimli. Şema dosyaları yalnızca belirtilen dizinde bulunabilir. +- Yapılandırma değiştirmeleri için destek eklendi (`incl` ve `conf.d`) dış sözlüklerin ve modellerin konfigürasyonu için (Pavel Yakunin). +- İçin belgeler içeren bir sütun eklendi `system.settings` tablo (Kirill Shvakov). +- Add theed the `system.parts_columns` her veri bölümünde sütun boyutları hakkında bilgi içeren tablo `MergeTree` Tablolar. +- Add theed the `system.models` yüklenen hakkında bilgi içeren tablo `CatBoost` makine öğrenme modelleri. +- Add theed the `mysql` ve `odbc` tablo fonksiyonu ve karşılık gelen `MySQL` ve `ODBC` uzak veritabanlarına erişmek için tablo motorları. Bu işlevsellik beta aşamasındadır. +- Türünde bir argüman geçme imkanı eklendi `AggregateFunction` için `groupArray` toplama işlevi (böylece bazı toplama işlevinin bir dizi durumunu oluşturabilirsiniz). +- Agrega fonksiyon birleştiricilerinin çeşitli kombinasyonlarındaki kısıtlamalar kaldırıldı. Örneğin, kullanabilirsiniz `avgForEachIf` keza `avgIfForEach` farklı davranışlara sahip toplam fonksiyonlar. +- Bu `-ForEach` toplama işlevi Birleştiricisi, birden çok bağımsız değişkenin toplama işlevleri için genişletilir. +- Toplam fonksiyonları için destek eklendi `Nullable` işlevin bir non döndürdüğü durumlarda bile argümanlar-`Nullable` sonuç (Silviu Caragea'nın katkısıyla eklendi). Örnek: `groupArray`, `groupUniqArray`, `topK`. +- Add theed the `max_client_network_bandwidth` için `clickhouse-client` (Kirill Shvakov). +- İle kullanıcılar `readonly = 2` setting are allowed to work with TEMPORARY tables (CREATE, DROP, INSERT…) (Kirill Shvakov). +- İle birden fazla tüketici kullanmak için destek eklendi `Kafka` motor. İçin genişletilmiş yapılandırma seçenekleri `Kafka` (Marek Vavruša). +- Add theed the `intExp3` ve `intExp4` işlevler. +- Add theed the `sumKahan` toplama işlevi. +- To \* Number\* ornull işlevleri eklendi, burada \* Number \* sayısal bir türdür. +- İçin destek eklendi `WITH` CLA anus anes for an `INSERT SELECT` sorgu (yazar: zhang2014). +- Eklenen ayarlar: `http_connection_timeout`, `http_send_timeout`, `http_receive_timeout`. Özellikle, bu ayarlar çoğaltma için veri parçalarını indirmek için kullanılır. Bu ayarları değiştirmek, ağ aşırı yüklenmişse daha hızlı yük devretme olanağı sağlar. +- İçin destek eklendi `ALTER` tip tablolar için `Null` (Anastasiya Tsarkova). +- Bu `reinterpretAsString` işlev, bellekte bitişik olarak depolanan tüm veri türleri için genişletilir. +- Add theed the `--silent` seçeneği için `clickhouse-local` aracı. Bu stderr yazdırma sorgu yürütme bilgi bastırır. +- Tip değerlerini okumak için destek eklendi `Date` ay ve/veya Ayın gün iki basamak (Amos kuş) yerine tek bir basamak kullanılarak belirtilen bir biçimde metinden. + +#### Performans iyileştirmeleri: {#performance-optimizations} + +- Agrega fonksiyonlarının geliştirilmiş performansı `min`, `max`, `any`, `anyLast`, `anyHeavy`, `argMin`, `argMax` dize argümanlarından. +- Fonksiyonların geliştirilmiş performansı `isInfinite`, `isFinite`, `isNaN`, `roundToExp2`. +- Ayrıştırma ve biçimlendirmenin geliştirilmiş performansı `Date` ve `DateTime` değerleri metin biçiminde yazın. +- Kayan nokta sayılarının ayrıştırılmasında geliştirilmiş performans ve hassasiyet. +- İçin bellek kullanımını azalt fortı `JOIN` sol ve sağ parçaların, içinde bulunmayan aynı adlara sahip sütunlara sahip olması durumunda `USING` . +- Agrega fonksiyonlarının geliştirilmiş performansı `varSamp`, `varPop`, `stddevSamp`, `stddevPop`, `covarSamp`, `covarPop`, `corr` hesaplama kararlılığını azaltarak. Eski fonksiyonlar isimler altında mevcuttur `varSampStable`, `varPopStable`, `stddevSampStable`, `stddevPopStable`, `covarSampStable`, `covarPopStable`, `corrStable`. + +#### Hata düzeltmeleri: {#bug-fixes-28} + +- Bir çalıştırdıktan sonra sabit veri tekilleştirme `DROP` veya `DETACH PARTITION` sorgu. Önceki sürümde, bir bölümü bırakmak ve aynı verileri tekrar eklemek işe yaramadı çünkü eklenen bloklar kopya olarak kabul edildi. +- Yanlış yorumlanmasına yol açabilecek bir hata düzeltildi `WHERE` için fık forra `CREATE MATERIALIZED VIEW` ile sorgular `POPULATE` . +- Kullanarak bir hata düzeltildi `root_path` param parametereter in the `zookeeper_servers` yapılandırma. +- Geçen sabit beklenmedik sonuçlar `Date` arg toum argumentent to `toStartOfDay` . +- Sabit `addMonths` ve `subtractMonths` fonksiyonlar ve aritmetik `INTERVAL n MONTH` sonuç bir önceki yıla sahip olduğu durumlarda. +- İçin eksik destek eklendi `UUID` için veri türü `DISTINCT` , `JOIN` , ve `uniq` agrega fonksiyonları ve dış sözlükler (Evgeniy Ivanov). İçin destek `UUID` hala eksik. +- Sabit `SummingMergeTree` satırların sıfıra toplandığı durumlarda davranış. +- İçin çeşitli düzeltmeler `Kafka` engine (Marek Vavruša). +- Sabit yanlış davranış `Join` masa motoru (Amos kuş). +- FreeBSD ve OS X altında yanlış ayırıcı davranışı düzeltildi. +- Bu `extractAll` fonksiyon artık boş eşleşmeleri destekliyor. +- Kullanımını engelleyen bir hata düzeltildi `libressl` yerine `openssl` . +- Sabit `CREATE TABLE AS SELECT` geçici tablolardan sorgu. +- Çoğaltma kuyruğunu güncelleme sabit olmayan atomicity. Bu, sunucu yeniden başlatılıncaya kadar eşlemelerin eşitlenmemesine neden olabilir. +- Sabit Olası taşma `gcd` , `lcm` ve `modulo` (`%` operatör) (Maks Skorokhod). +- `-preprocessed` dosyalar şimdi değiştirdikten sonra oluşturulur `umask` (`umask` config değişmiş) olabilir. +- Parçaların arka plan kontrol bir hata düzeltildi (`MergeTreePartChecker` ) özel bir bölüm anahtarı kullanırken. +- Tuples sabit ayrıştırma (değerleri `Tuple` veri türü) metin biçimlerinde. +- Uyumsuz türlerle ilgili geliştirilmiş hata mesajları `multiIf` , `array` ve diğer bazı fonksiyonlar. +- İçin yeniden tasarlanmış destek `Nullable` türler. Bir sunucu çökmesine yol açabilir sabit hatalar. İlgili hemen hemen tüm diğer hatalar düzeltildi `NULL` destek: INSERT SELECT yanlış tür dönüşümleri, sahip ve PREWHERE içinde Nullable için yetersiz destek, `join_use_nulls` mod, argümanlar olarak Nullable türleri `OR` operatör, vb. +- Veri türlerinin iç semantiği ile ilgili çeşitli hatalar düzeltildi. Örnekler: gereksiz toplama `Enum` type Fi fieldsel fieldsds in `SummingMergeTree` ; hizalama `Enum` yazmak `Pretty` format ,lar vb. +- Bileşik sütunların izin verilen kombinasyonları için daha sıkı kontroller. +- İçin çok büyük bir parametre belirlerken taşma düzeltildi `FixedString` veri türü. +- Bu bir hata düzeltildi `topK` genel bir durumda toplama işlevi. +- Toplam fonksiyonların n-ary varyantlarının argümanlarında dizi boyutlarının eşitliği için eksik kontrol eklendi `-Array` birleştirici. +- Bir hata düzeltildi `--pager` için `clickhouse-client` (yazar: ks1322). +- Sabit hassasiyet `exp10` işlev. +- Davranışı Düzelt theildi `visitParamExtract` belgelere daha iyi uyum için işlev. +- Yanlış veri türleri belirtildiğinde kilitlenme düzeltildi. +- Davranışı düzeltildi `DISTINCT` tüm sütunların sabitler olması durumunda. +- Kullanarak durumunda sabit sorgu biçimlendirme `tupleElement` tuple öğesi dizini olarak karmaşık bir sabit ifadeyle işlev. +- Bir hata düzeltildi `Dictionary` için tablolar `range_hashed` sözlükler. +- Sonucunda aşırı satırlara yol açan bir hata düzeltildi `FULL` ve `RIGHT JOIN` (Amos Kuşu). +- Geçici dosyaları oluştururken ve kaldırırken bir sunucu çökmesi düzeltildi `config.d` yapılandırma yeniden yükleme sırasında dizinler. +- Sabit `SYSTEM DROP DNS CACHE` sorgu: önbellek temizlendi, ancak küme düğümlerinin adresleri güncelleştirilmedi. +- Davranışı düzeltildi `MATERIALIZED VIEW` çalıştırdıktan sonra `DETACH TABLE` for the table under the view (Marek Vavruša). + +#### İyileştirmeler oluşturun: {#build-improvements-4} + +- Bu `pbuilder` aracı oluşturur için kullanılır. Yapı işlemi, yapı ana bilgisayarı ortamından neredeyse tamamen bağımsızdır. +- Farklı işletim sistemi sürümleri için tek bir yapı kullanılır. Paketler ve ikili Linux sistemleri geniş bir yelpazede ile uyumlu yapılmıştır. +- Add theed the `clickhouse-test` paket. Fonksiyonel testleri çalıştırmak için kullanılabilir. +- Kaynak tarball artık depoya yayınlanabilir. Github kullanmadan yapıyı yeniden oluşturmak için kullanılabilir. +- Travis CI ile sınırlı entegrasyon eklendi. Travis oluşturma süresi sınırları nedeniyle, yalnızca hata ayıklama yapı sınanır ve sınamaların sınırlı bir alt kümesi çalıştırılır. +- İçin destek eklendi `Cap'n'Proto` varsayılan yapı içinde. +- Dokümantasyon kaynaklarının biçimini değiştirdi `Restricted Text` -e doğru `Markdown`. +- İçin destek eklendi `systemd` (Vladimir Smirnov). Bazı işletim sistemi görüntüleri ile uyumsuzluk nedeniyle varsayılan olarak devre dışı bırakılır ve manuel olarak etkinleştirilebilir. +- Dinamik kod üretimi için, `clang` ve `lld` içine gömülü `clickhouse` ikilik. Olarak da çağr alsoıla invokedbilirler `clickhouse clang` ve `clickhouse lld` . +- GNU uzantılarının koddan kaldırılması. Etkin `-Wextra` seçenek. İle inşa ederken `clang` varsayılan değer `libc++` yerine `libstdc++`. +- Elde `clickhouse_parsers` ve `clickhouse_common_io` kütüphaneler hızlandırmak için çeşitli araçlar oluşturur. + +#### Geriye dönük uyumsuz değişiklikler: {#backward-incompatible-changes-11} + +- İşaret formatlerin biçimi `Log` içeren tabloları yazın `Nullable` sütunlar geriye dönük uyumsuz bir şekilde değiştirildi. Bu tablolar varsa, bunları dönüştürmek gerekir `TinyLog` yeni sunucu sürümünü başlatmadan önce yazın. Bunu yapmak için değiştirin `ENGINE = Log` ile `ENGINE = TinyLog` karşılık gelen `.sql` dosya içinde `metadata` dizin. Masanız yoksa `Nullable` sütun veya tablonuzun türü değilse `Log` o zaman hiçbir şey yapmanıza gerek yok. +- Kaldır theılan `experimental_allow_extended_storage_definition_syntax` ayar. Şimdi bu özellik varsayılan olarak etkindir. +- Bu `runningIncome` işlev olarak yeniden adlandırıldı `runningDifferenceStartingWithFirstvalue` karışıklığı önlemek için. +- Kaldır theılan `FROM ARRAY JOIN arr` array JOİN, tablo olmadan (Amos Bird) doğrudan FROM sonra belirtildiğinde sözdizimi. +- Kaldır theılan `BlockTabSeparated` sadece gösteri amaçlı kullanılan format. +- Toplu işlevler için durum biçimini değiştirdi `varSamp`, `varPop`, `stddevSamp`, `stddevPop`, `covarSamp`, `covarPop`, `corr`. Bu toplama işlevlerinin durumlarını tablolarda depoladıysanız ( `AggregateFunction` veri türü veya ilgili durumları ile hayata görünümleri), yazınız clickhouse-feedback@yandex-team.com. +- Önceki sunucu sürümlerinde belgelenmemiş bir özellik vardı: bir toplama işlevi parametrelere bağlıysa, yine de AggregateFunction veri türünde parametreler olmadan belirtebilirsiniz. Örnek: `AggregateFunction(quantiles, UInt64)` yerine `AggregateFunction(quantiles(0.5, 0.9), UInt64)`. Bu özellik kayboldu. Belgesiz olmasına rağmen, gelecek sürümlerde tekrar desteklemeyi planlıyoruz. +- Enum veri türleri min / max toplama işlevlerinde kullanılamaz. Bu yetenek bir sonraki sürümde iade edilecektir. + +#### Yükseltme yaparken lütfen unutmayın: {#please-note-when-upgrading} + +- Bir kümede, bazı yinelemelerin Clickhouse'un eski sürümünü çalıştırdığı ve bazılarının yeni sürümü çalıştırdığı noktada yuvarlanan bir güncelleme yaparken, çoğaltma geçici olarak durdurulur ve ileti `unknown parameter 'shard'` günlüğünde görünür. Kümenin tüm yinelemeleri güncelleştirildikten sonra çoğaltma devam eder. +- Clickhouse'un farklı sürümleri küme sunucularında çalışıyorsa, aşağıdaki işlevleri kullanarak dağıtılmış sorguların yanlış sonuçları olması olasıdır: `varSamp`, `varPop`, `stddevSamp`, `stddevPop`, `covarSamp`, `covarPop`, `corr`. Tüm küme düğümlerini güncelleştirmelisiniz. + +## [2017 için Changelog](https://github.com/ClickHouse/ClickHouse/blob/master/docs/en/changelog/2017.md) {#changelog-for-2017} diff --git a/docs/tr/whats_new/changelog/2019.md b/docs/tr/whats_new/changelog/2019.md new file mode 100644 index 00000000000..065cb822bc1 --- /dev/null +++ b/docs/tr/whats_new/changelog/2019.md @@ -0,0 +1,2074 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 77 +toc_title: '2019' +--- + +## ClickHouse sürüm v19. 17 {#clickhouse-release-v19-17} + +### ClickHouse sürümü v19.17.6. 36, 2019-12-27 {#clickhouse-release-v19-17-6-36-2019-12-27} + +#### Hata Düzeltme {#bug-fix} + +- Sıkıştırmada sabit potansiyel tampon taşması. Kötü niyetli kullanıcı, arabellekten sonra okunmasına neden olabilecek sıkıştırılmış verileri iletebilir. Bu sorun Yandex bilgi güvenliği ekibinden Eldar Zaitov tarafından bulundu. [\#8404](https://github.com/ClickHouse/ClickHouse/pull/8404) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit Olası sunucu çökmesi (`std::terminate`) sunucu, dize veri türü (UTF-8 doğrulaması gerektiren) değerleriyle json veya XML biçiminde veri gönderemez veya yazamaz veya sonuç verilerini Brotli algoritması ile sıkıştırırken veya diğer bazı nadir durumlarda. [\#8384](https://github.com/ClickHouse/ClickHouse/pull/8384) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bir clickhouse kaynak ile sabit sözlükler `VIEW`, şimdi bu tür sözlükleri okumak hataya neden olmaz `There is no query`. [\#8351](https://github.com/ClickHouse/ClickHouse/pull/8351) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Bir istemci ana bilgisayar kullanıcıları belirtilen host\_regexp tarafından izin verilip verilmediğini kontrol sabit.xml. [\#8241](https://github.com/ClickHouse/ClickHouse/pull/8241), [\#8342](https://github.com/ClickHouse/ClickHouse/pull/8342) ([Vitaly Baranov](https://github.com/vitlibar)) +- `RENAME TABLE` dağıtılmış bir tablo için artık parçalara göndermeden önce eklenen verileri içeren klasörü yeniden adlandırır. Bu, ardışık yeniden adlarla ilgili bir sorunu giderir `tableA->tableB`, `tableC->tableA`. [\#8306](https://github.com/ClickHouse/ClickHouse/pull/8306) ([tavplubix](https://github.com/tavplubix)) +- `range_hashed` DDL sorguları tarafından oluşturulan dış sözlükler artık rasgele sayısal tür aralıklarına izin verir. [\#8275](https://github.com/ClickHouse/ClickHouse/pull/8275) ([alesapin](https://github.com/alesapin)) +- Sabit `INSERT INTO table SELECT ... FROM mysql(...)` tablo işlevi. [\#8234](https://github.com/ClickHouse/ClickHouse/pull/8234) ([tavplubix](https://github.com/tavplubix)) +- Sabit segfault içinde `INSERT INTO TABLE FUNCTION file()` mevcut olmayan bir dosyaya eklerken. Şimdi bu durumda dosya oluşturulur ve daha sonra insert işlenir. [\#8177](https://github.com/ClickHouse/ClickHouse/pull/8177) ([Olga Khvostikova](https://github.com/stavrolia)) +- Birleştirilmiş bir bitmap ve bir skaler bitmap kesişen sabit bitmapAnd hatası. [\#8082](https://github.com/ClickHouse/ClickHouse/pull/8082) ([Yue Huang](https://github.com/moon03432)) +- Sabit segfault zaman `EXISTS` sorgu olmadan kullanıldı `TABLE` veya `DICTIONARY` niteleyici, tıpkı `EXISTS t`. [\#8213](https://github.com/ClickHouse/ClickHouse/pull/8213) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Fonksiyonlar için sabit dönüş tipi `rand` ve `randConstant` geçersiz argüman durumunda. Şimdi fonksiyonlar her zaman geri döner `UInt32` ve asla `Nullable(UInt32)`. [\#8204](https://github.com/ClickHouse/ClickHouse/pull/8204) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Sabit `DROP DICTIONARY IF EXISTS db.dict`, şimdi Eğer istisna atmaz `db` yok. [\#8185](https://github.com/ClickHouse/ClickHouse/pull/8185) ([Vitaly Baranov](https://github.com/vitlibar)) +- Sunucu çökmesi nedeniyle bir tablo tamamen düşmediyse, sunucu geri yüklemeyi ve yüklemeyi deneyecektir [\#8176](https://github.com/ClickHouse/ClickHouse/pull/8176) ([tavplubix](https://github.com/tavplubix)) +- İkiden fazla shard yerel tablo varsa, dağıtılmış bir tablo için önemsiz bir sayım sorgusu düzeltildi. [\#8164](https://github.com/ClickHouse/ClickHouse/pull/8164) ([小路](https://github.com/nicelulu)) +- DB::Blockstreamprofileınfo::calculateRowsBeforeLimit bir veri yarış yol Sabit hata() [\#8143](https://github.com/ClickHouse/ClickHouse/pull/8143) ([Alexander Kazakov](https://github.com/Akazz)) +- Sabit `ALTER table MOVE part` belirtilen parçayı birleştirdikten hemen sonra yürütülür, bu da belirtilen parçanın birleştirildiği bir parçanın taşınmasına neden olabilir. Şimdi belirtilen kısmı doğru hareket ettirir. [\#8104](https://github.com/ClickHouse/ClickHouse/pull/8104) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Sözlükler için ifadeler şimdi dizeler olarak belirtilebilir. Bu, ClickHouse olmayan kaynaklardan veri ayıklarken özniteliklerin hesaplanması için yararlıdır, çünkü bu ifadeler için ClickHouse olmayan sözdizimini kullanmanıza izin verir. [\#8098](https://github.com/ClickHouse/ClickHouse/pull/8098) ([alesapin](https://github.com/alesapin)) +- Çok nadir bir yarış sabit `clickhouse-copier` zxıd'de bir taşma nedeniyle. [\#8088](https://github.com/ClickHouse/ClickHouse/pull/8088) ([Ding Xiang Fei](https://github.com/dingxiangfei2009)) +- Sorgu başarısız olduktan sonra hata düzeltildi (nedeniyle “Too many simultaneous queries” örneğin) harici tablolar bilgisini okumaz ve + sonraki istek, bu bilgiyi bir sonraki sorgunun başlangıcı olarak yorumlayacak ve aşağıdaki gibi bir hataya neden olacaktır `Unknown packet from client`. [\#8084](https://github.com/ClickHouse/ClickHouse/pull/8084) ([Azat Khuzhin](https://github.com/azat)) +- Sonra null dereference kaçının “Unknown packet X from server” [\#8071](https://github.com/ClickHouse/ClickHouse/pull/8071) ([Azat Khuzhin](https://github.com/azat)) +- Tüm YBÜ yerel destek Geri Yükleme, sabit ifadeler için harmanlama uygulamak ve sisteme dil adı eklemek için yeteneği ekleyin.harmanlama tablosu. [\#8051](https://github.com/ClickHouse/ClickHouse/pull/8051) ([alesapin](https://github.com/alesapin)) +- Okuma için akış sayısı `StorageFile` ve `StorageHDFS` bellek sınırını aşmamak için artık sınırlıdır. [\#7981](https://github.com/ClickHouse/ClickHouse/pull/7981) ([alesapin](https://github.com/alesapin)) +- Sabit `CHECK TABLE` sorgu için `*MergeTree` anahtarsız tablolar. [\#7979](https://github.com/ClickHouse/ClickHouse/pull/7979) ([alesapin](https://github.com/alesapin)) +- Mutasyon olmaması durumunda bir parça adından mutasyon numarası kaldırıldı. Bu kaldırma eski sürümleri ile uyumluluk geliştirilmiş. [\#8250](https://github.com/ClickHouse/ClickHouse/pull/8250) ([alesapin](https://github.com/alesapin)) +- Mutasyonlar nedeniyle data\_version bazı ekli parçalar için atlanır hata tablo mutasyon sürümü daha büyüktür düzeltildi. [\#7812](https://github.com/ClickHouse/ClickHouse/pull/7812) ([Zhichang Yu](https://github.com/yuzhichang)) +- Başka bir cihaza taşıdıktan sonra yedek parça kopyalarıyla sunucuyu başlatmaya izin verin. [\#7810](https://github.com/ClickHouse/ClickHouse/pull/7810) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Hata düzeltildi “Sizes of columns doesn’t match” bu, toplama işlevi sütunlarını kullanırken görünebilir. [\#7790](https://github.com/ClickHouse/ClickHouse/pull/7790) ([Boris Granveaud](https://github.com/bgranvea)) +- Şimdi LİMİT BY yanında bağları ile kullanılması durumunda bir istisna atılır. Ve şimdi LİMİT ile üst kullanmak mümkündür. [\#7637](https://github.com/ClickHouse/ClickHouse/pull/7637) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Varsa sözlük yeniden yükle `invalidate_query`, güncellemeleri durdurdu ve önceki güncelleme denemelerinde bazı istisnalar. [\#8029](https://github.com/ClickHouse/ClickHouse/pull/8029) ([alesapin](https://github.com/alesapin)) + +### ClickHouse sürümü v19.17.4. 11, 2019-11-22 {#clickhouse-release-v19-17-4-11-2019-11-22} + +#### Geriye Dönük Uyumsuz Değişim {#backward-incompatible-change} + +- Daha iyi performans için skaler alt sorgu sonuçlarını depolamak için AST yerine sütun kullanma. Ayar `enable_scalar_subquery_optimization` 19.17'de eklendi ve varsayılan olarak etkinleştirildi. Gibi hat toalara yol açar [bu](https://github.com/ClickHouse/ClickHouse/issues/7851) önceki sürümlerden 19.17.2 veya 19.17.3'e yükseltme sırasında. Bu ayar, 19.17.4'te, 19.16 ve daha eski sürümlerden hatasız yükseltme yapılmasını sağlamak için varsayılan olarak devre dışı bırakıldı. [\#7392](https://github.com/ClickHouse/ClickHouse/pull/7392) ([Amos Kuşu](https://github.com/amosbird)) + +#### Yenilik {#new-feature} + +- DDL sorguları ile sözlükler oluşturma yeteneği ekleyin. [\#7360](https://github.com/ClickHouse/ClickHouse/pull/7360) ([alesapin](https://github.com/alesapin)) +- Yapmak `bloom_filter` endeks destek türü `LowCardinality` ve `Nullable` [\#7363](https://github.com/ClickHouse/ClickHouse/issues/7363) [\#7561](https://github.com/ClickHouse/ClickHouse/pull/7561) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Fonksiyon Ekle `isValidJSON` geçirilen dizenin geçerli bir json olduğunu kontrol etmek için. [\#5910](https://github.com/ClickHouse/ClickHouse/issues/5910) [\#7293](https://github.com/ClickHouse/ClickHouse/pull/7293) ([Vdimir](https://github.com/Vdimir)) +- Uygulamak `arrayCompact` işlev [\#7328](https://github.com/ClickHouse/ClickHouse/pull/7328) ([Not](https://github.com/Joeywzr)) +- Oluşturulan işlev `hex` ondalık sayılar için. Gibi çalışır `hex(reinterpretAsString())`, ancak son sıfır bayt silmez. [\#7355](https://github.com/ClickHouse/ClickHouse/pull/7355) ([Mikhail Korotov](https://github.com/millb)) +- Eklemek `arrayFill` ve `arrayReverseFill` dizideki ön / arka öğelerdeki diğer öğelerle öğeleri değiştiren işlevler. [\#7380](https://github.com/ClickHouse/ClickHouse/pull/7380) ([hcz](https://github.com/hczhcz)) +- Eklemek `CRC32IEEE()`/`CRC64()` destek [\#7480](https://github.com/ClickHouse/ClickHouse/pull/7480) ([Azat Khuzhin](https://github.com/azat)) +- Uygulamak `char` fonksiyon birine benzer [mysql](https://dev.mysql.com/doc/refman/8.0/en/string-functions.html#function_char) [\#7486](https://github.com/ClickHouse/ClickHouse/pull/7486) ([sundyli](https://github.com/sundy-li)) +- Eklemek `bitmapTransform` işlev. Değerler bir dizi için bir bit eşlem değerler dizisi dönüştüren, sonuçta yeni bir bit eşlem [\#7598](https://github.com/ClickHouse/ClickHouse/pull/7598) ([Zhichang Yu](https://github.com/yuzhichang)) +- Uyguluyordu `javaHashUTF16LE()` işlev [\#7651](https://github.com/ClickHouse/ClickHouse/pull/7651) ([achimbab](https://github.com/achimbab)) +- Eklemek `_shard_num` dağıtılmış motor için sanal sütun [\#7624](https://github.com/ClickHouse/ClickHouse/pull/7624) ([Azat Khuzhin](https://github.com/azat)) + +#### Deneysel Özellik {#experimental-feature} + +- İşlemciler için destek (yeni sorgu yürütme boru hattı) `MergeTree`. [\#7181](https://github.com/ClickHouse/ClickHouse/pull/7181) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) + +#### Hata Düzeltme {#bug-fix-1} + +- Yanlış float ayrıştırma düzeltme `Values` [\#7817](https://github.com/ClickHouse/ClickHouse/issues/7817) [\#7870](https://github.com/ClickHouse/ClickHouse/pull/7870) ([tavplubix](https://github.com/tavplubix)) +- Trace\_log etkinleştirildiğinde oluşabilecek nadir kilitlenmeyi düzeltin. [\#7838](https://github.com/ClickHouse/ClickHouse/pull/7838) ([filimonov](https://github.com/filimonov)) +- Kafka tablosu üretirken mesaj çoğaltmasını önle, ondan seçim yapan herhangi bir MVs var [\#7265](https://github.com/ClickHouse/ClickHouse/pull/7265) ([I ivanvan](https://github.com/abyss7)) +- İçin destek `Array(LowCardinality(Nullable(String)))` içinde `IN`. Gideriyor [\#7364](https://github.com/ClickHouse/ClickHouse/issues/7364) [\#7366](https://github.com/ClickHouse/ClickHouse/pull/7366) ([achimbab](https://github.com/achimbab)) +- Add hand ofling of `SQL_TINYINT` ve `SQL_BIGINT`, ve düzeltme işleme `SQL_FLOAT` ODBC köprüsünde veri kaynağı türleri. [\#7491](https://github.com/ClickHouse/ClickHouse/pull/7491) ([Denis Glazachev](https://github.com/traceon)) +- Toplama düzeltme (`avg` ve quantiles) boş ondalık sütunlar üzerinde [\#7431](https://github.com/ClickHouse/ClickHouse/pull/7431) ([Andrey Konyaev](https://github.com/akonyaev90)) +- Düzeltmek `INSERT` ile dağıtılan içine `MATERIALIZED` sütun [\#7377](https://github.com/ClickHouse/ClickHouse/pull/7377) ([Azat Khuzhin](https://github.com/azat)) +- Yapmak `MOVE PARTITION` bölümün bazı bölümleri zaten hedef disk veya birimde ise çalışın [\#7434](https://github.com/ClickHouse/ClickHouse/pull/7434) ([Vladimir Chebotarev](https://github.com/excitoon)) +- İçinde mutasyonlar sırasında oluşturulacak başarısız hardlinks ile Sabit hata `ReplicatedMergeTree` çoklu disk yapılandırmalarında. [\#7558](https://github.com/ClickHouse/ClickHouse/pull/7558) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Bütün parça değişmeden kalır ve en iyi alan başka bir diskte bulunurken bir MergeTree üzerinde bir mutasyon ile bir hata düzeltildi [\#7602](https://github.com/ClickHouse/ClickHouse/pull/7602) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Sabit hata ile `keep_free_space_ratio` disk yapılandırmasından okunmuyor [\#7645](https://github.com/ClickHouse/ClickHouse/pull/7645) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Tablo ile Fix hata sadece içerir `Tuple` karmaşık yolları olan sütunlar veya sütunlar. Düzeltiyor [7541](https://github.com/ClickHouse/ClickHouse/issues/7541). [\#7545](https://github.com/ClickHouse/ClickHouse/pull/7545) ([alesapin](https://github.com/alesapin)) +- Bellek Max\_memory\_usage sınırında arabellek altyapısı için hesap değil [\#7552](https://github.com/ClickHouse/ClickHouse/pull/7552) ([Azat Khuzhin](https://github.com/azat)) +- Son işaret kullanımını düzeltin `MergeTree` tarafından sipariş edilen tablolar `tuple()`. Nadir durumlarda yol açabilir `Can't adjust last granule` seçerken hata. [\#7639](https://github.com/ClickHouse/ClickHouse/pull/7639) ([Anton Popov](https://github.com/CurtizJ)) +- Çökmelere veya garip istisnalara yol açabilecek bağlam gerektiren eylemlerle (örneğin json için işlevler) yüklü olan mutasyonlardaki hatayı düzeltin. [\#7664](https://github.com/ClickHouse/ClickHouse/pull/7664) ([alesapin](https://github.com/alesapin)) +- Kaçan veritabanı ve tablo adlarının uyumsuzluğunu düzeltin `data/` ve `shadow/` dizinler [\#7575](https://github.com/ClickHouse/ClickHouse/pull/7575) ([Alexander Burmak](https://github.com/Alex-Burmak)) +- Support duplicated keys in RIGHT\|FULL JOINs, e.g. `ON t.x = u.x AND t.x = u.y`. Bu durumda kazayı düzeltin. [\#7586](https://github.com/ClickHouse/ClickHouse/pull/7586) ([Artem Zuikov](https://github.com/4ertus2)) +- Düzeltmek `Not found column in block` ifadeye doğru veya tam birleştirme ile katılırken. [\#7641](https://github.com/ClickHouse/ClickHouse/pull/7641) ([Artem Zuikov](https://github.com/4ertus2)) +- Sonsuz döngüyü düzeltmek için bir girişim daha `PrettySpace` biçimli [\#7591](https://github.com/ClickHouse/ClickHouse/pull/7591) ([Olga Khvostikova](https://github.com/stavrolia)) +- Hatayı düzeltin `concat` tüm argümanlar olduğunda işlev `FixedString` aynı boyutta. [\#7635](https://github.com/ClickHouse/ClickHouse/pull/7635) ([alesapin](https://github.com/alesapin)) +- S3, URL ve HDFS depolarını tanımlarken 1 argüman kullanılması durumunda sabit istisna. [\#7618](https://github.com/ClickHouse/ClickHouse/pull/7618) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Sorgu ile görünümler için Interpretersselectquery'nin kapsamını düzeltin [\#7601](https://github.com/ClickHouse/ClickHouse/pull/7601) ([Azat Khuzhin](https://github.com/azat)) + +#### Geliştirme {#improvement} + +- `Nullable` ODBC-bridge tarafından doğru işlenen sütunlar tanınan ve NULL değerleri [\#7402](https://github.com/ClickHouse/ClickHouse/pull/7402) ([Vasily Nemkov](https://github.com/Enmk)) +- Atomically dağıtılmış göndermek için geçerli toplu yazma [\#7600](https://github.com/ClickHouse/ClickHouse/pull/7600) ([Azat Khuzhin](https://github.com/azat)) +- Sorguda sütun adı için tablo algılayamazsak bir istisna atın. [\#7358](https://github.com/ClickHouse/ClickHouse/pull/7358) ([Artem Zuikov](https://github.com/4ertus2)) +- Eklemek `merge_max_block_size` ayarı için `MergeTreeSettings` [\#7412](https://github.com/ClickHouse/ClickHouse/pull/7412) ([Artem Zuikov](https://github.com/4ertus2)) +- İle sorgular `HAVING` ve olmadan `GROUP BY` sabit olarak grup varsayalım. Böyle, `SELECT 1 HAVING 1` şimdi bir sonuç döndürür. [\#7496](https://github.com/ClickHouse/ClickHouse/pull/7496) ([Amos Kuşu](https://github.com/amosbird)) +- Destek ayrıştırma `(X,)` python'a benzer tuple olarak. [\#7501](https://github.com/ClickHouse/ClickHouse/pull/7501), [\#7562](https://github.com/ClickHouse/ClickHouse/pull/7562) ([Amos Kuşu](https://github.com/amosbird)) +- Yapmak `range` işlev davranışları neredeyse pythonic gibi. [\#7518](https://github.com/ClickHouse/ClickHouse/pull/7518) ([sundyli](https://github.com/sundy-li)) +- Eklemek `constraints` tabloya sütunlar `system.settings` [\#7553](https://github.com/ClickHouse/ClickHouse/pull/7553) ([Vitaly Baranov](https://github.com/vitlibar)) +- Tcp işleyicisi için daha iyi boş biçim, böylece kullanmak mümkün `select ignore() from table format Null` clickhouse-client ile perf ölçümü için [\#7606](https://github.com/ClickHouse/ClickHouse/pull/7606) ([Amos Kuşu](https://github.com/amosbird)) +- Gibi sorgular `CREATE TABLE ... AS (SELECT (1, 2))` doğru ayrıştırılır [\#7542](https://github.com/ClickHouse/ClickHouse/pull/7542) ([hcz](https://github.com/hczhcz)) + +#### Performans İyileştirme {#performance-improvement} + +- Kısa dize anahtarları üzerinde toplama performansı artırıldı. [\#6243](https://github.com/ClickHouse/ClickHouse/pull/6243) ([Alexander Kuzmenkov](https://github.com/akuzm), [Amos Kuşu](https://github.com/amosbird)) +- Sabit yüklemler katlandıktan sonra olası optimizasyonları almak için sözdizimi/ifade analizinin başka bir geçişini çalıştırın. [\#7497](https://github.com/ClickHouse/ClickHouse/pull/7497) ([Amos Kuşu](https://github.com/amosbird)) +- Önemsiz değerlendirmek için depolama meta bilgisi kullanın `SELECT count() FROM table;` [\#7510](https://github.com/ClickHouse/ClickHouse/pull/7510) ([Amos Kuşu](https://github.com/amosbird), [alexey-milovidov](https://github.com/alexey-milovidov)) +- Vectorize işleme `arrayReduce` toplayıcı benzer `addBatch`. [\#7608](https://github.com/ClickHouse/ClickHouse/pull/7608) ([Amos Kuşu](https://github.com/amosbird)) +- Performansında küçük iyileştirmeler `Kafka` tüketim [\#7475](https://github.com/ClickHouse/ClickHouse/pull/7475) ([I ivanvan](https://github.com/abyss7)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement} + +- AARCH64 CPU mimarisine çapraz derleme için destek ekleyin. Refactor packager komut. [\#7370](https://github.com/ClickHouse/ClickHouse/pull/7370) [\#7539](https://github.com/ClickHouse/ClickHouse/pull/7539) ([I ivanvan](https://github.com/abyss7)) +- Paketleri oluştururken darwin-x86\_64 ve linux-aarch64 araç zincirlerini monte edilmiş Docker hacmine açın [\#7534](https://github.com/ClickHouse/ClickHouse/pull/7534) ([I ivanvan](https://github.com/abyss7)) +- İkili Paketleyici için Docker görüntüsünü güncelle [\#7474](https://github.com/ClickHouse/ClickHouse/pull/7474) ([I ivanvan](https://github.com/abyss7)) +- MacOS Catalina'da sabit derleme hataları [\#7585](https://github.com/ClickHouse/ClickHouse/pull/7585) ([Ernest Poletaev](https://github.com/ernestp)) +- Sorgu analizi mantığında bazı yeniden düzenleme: karmaşık sınıfı birkaç basit sınıfa ayırın. [\#7454](https://github.com/ClickHouse/ClickHouse/pull/7454) ([Artem Zuikov](https://github.com/4ertus2)) +- Submodules olmadan yapı düzeltme [\#7295](https://github.com/ClickHouse/ClickHouse/pull/7295) ([proller](https://github.com/proller)) +- İyileştirmek `add_globs` cmake dosyalarında [\#7418](https://github.com/ClickHouse/ClickHouse/pull/7418) ([Amos Kuşu](https://github.com/amosbird)) +- Kodlanmış yolları Kaldır `unwind` hedef [\#7460](https://github.com/ClickHouse/ClickHouse/pull/7460) ([Konstantin Podshumok](https://github.com/podshumok)) +- Ssl olmadan mysql formatını kullanmasına izin ver [\#7524](https://github.com/ClickHouse/ClickHouse/pull/7524) ([proller](https://github.com/proller)) + +#### Diğer {#other} + +- ClickHouse SQL lehçesi için ANTLR4 dilbilgisi eklendi [\#7595](https://github.com/ClickHouse/ClickHouse/issues/7595) [\#7596](https://github.com/ClickHouse/ClickHouse/pull/7596) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +## ClickHouse sürüm v19. 16 {#clickhouse-release-v19-16} + +#### ClickHouse yayın v19. 16. 14. 65, 2020-03-25 {#clickhouse-release-v19-16-14-65-2020-03-25} + +- Birden argümanlar (10'dan fazla) üçlü mantıksal OPs toplu hesaplamalarda bir hata düzeltildi. [\#8718](https://github.com/ClickHouse/ClickHouse/pull/8718) ([Alexander Kazakov](https://github.com/Akazz)) Bu hata düzeltme Altınity özel bir istek ile sürüm 19.16 backported edildi. + +#### ClickHouse yayın v19. 16. 14. 65, 2020-03-05 {#clickhouse-release-v19-16-14-65-2020-03-05} + +- Dağıtılmış alt sorgular uyumsuzluğunu eski CH sürümleriyle düzeltin. Düzeltiyor [\#7851](https://github.com/ClickHouse/ClickHouse/issues/7851) + [(tabplubix)](https://github.com/tavplubix) +- Yürüt whenürken `CREATE` sorgu, depolama motoru argümanlarında sabit ifadeleri katlayın. Boş veritabanı adı geçerli veritabanı ile değiştirin. Düzeltiyor [\#6508](https://github.com/ClickHouse/ClickHouse/issues/6508), [\#3492](https://github.com/ClickHouse/ClickHouse/issues/3492). Ayrıca yerel adresi kontrol edin `ClickHouseDictionarySource`. + [\#9262](https://github.com/ClickHouse/ClickHouse/pull/9262) [(tabplubix)](https://github.com/tavplubix) +- Şimdi arka plan birleşir `*MergeTree` tablo motorları ailesi depolama ilkesi hacim sırasını daha doğru bir şekilde korur. + [\#8549](https://github.com/ClickHouse/ClickHouse/pull/8549) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Veri kaybını önlemek `Kafka` nadir durumlarda istisna sonek okuduktan sonra ancak taahhütten önce gerçekleşir. Düzeltiyor [\#9378](https://github.com/ClickHouse/ClickHouse/issues/9378). İlgili: [\#7175](https://github.com/ClickHouse/ClickHouse/issues/7175) + [\#9507](https://github.com/ClickHouse/ClickHouse/pull/9507) [(filimonov)](https://github.com/filimonov) +- Kullanmaya / bırakmaya çalışırken sunucu sonlandırmasına giden hatayı düzeltin `Kafka` tablo yanlış parametrelerle oluşturuldu. Düzeltiyor [\#9494](https://github.com/ClickHouse/ClickHouse/issues/9494). Birleşiyor [\#9507](https://github.com/ClickHouse/ClickHouse/issues/9507). + [\#9513](https://github.com/ClickHouse/ClickHouse/pull/9513) [(filimonov)](https://github.com/filimonov) +- Kullanmaya izin ver `MaterializedView` yukarıdaki alt sorgularla `Kafka` Tablolar. + [\#8197](https://github.com/ClickHouse/ClickHouse/pull/8197) ([filimonov](https://github.com/filimonov)) + +#### Yenilik {#new-feature-1} + +- Eklemek `deduplicate_blocks_in_dependent_materialized_views` hayata manzaralı tablolara idempotent ekler davranışlarını kontrol etmek için Seçenek. Bu yeni özellik, altınity'den özel bir istek ile bugfix sürümüne eklendi. + [\#9070](https://github.com/ClickHouse/ClickHouse/pull/9070) [(urykhy)](https://github.com/urykhy) + +### ClickHouse sürümü v19.16.2. 2, 2019-10-30 {#clickhouse-release-v19-16-2-2-2019-10-30} + +#### Geriye Dönük Uyumsuz Değişim {#backward-incompatible-change-1} + +- Count/counİf için eksik arity doğrulama ekleyin. + [\#7095](https://github.com/ClickHouse/ClickHouse/issues/7095) + [\#7298](https://github.com/ClickHouse/ClickHouse/pull/7298) ([Vdimir](https://github.com/Vdimir)) +- Eski Kaldır `asterisk_left_columns_only` ayar (varsayılan olarak devre dışıdır). + [\#7335](https://github.com/ClickHouse/ClickHouse/pull/7335) ([Artem + Zuikov](https://github.com/4ertus2)) +- Şablon veri biçimi için Biçim dizeleri artık dosyalarda belirtilmiştir. + [\#7118](https://github.com/ClickHouse/ClickHouse/pull/7118) + ([tavplubix](https://github.com/tavplubix)) + +#### Yenilik {#new-feature-2} + +- Uint\_max büyük önemlilik hesaplamak için uniqcombined64() tanıtmak. + [\#7213](https://github.com/ClickHouse/ClickHouse/pull/7213), + [\#7222](https://github.com/ClickHouse/ClickHouse/pull/7222) ([Azat + Khuzhin](https://github.com/azat)) +- Dizi sütunlarında Bloom filtre indekslerini destekleyin. + [\#6984](https://github.com/ClickHouse/ClickHouse/pull/6984) + ([achimbab](https://github.com/achimbab)) +- Bir işlev Ekle `getMacro(name)` bu karşılık gelen değeri ile dize döndürür `` + sunucu yapılandırmasından. [\#7240](https://github.com/ClickHouse/ClickHouse/pull/7240) + ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bir HTTP kaynağına dayalı bir sözlük için iki yapılandırma seçeneği belirleyin: `credentials` ve + `http-headers`. [\#7092](https://github.com/ClickHouse/ClickHouse/pull/7092) ([Guillaume + Tassery](https://github.com/YiuRULE)) +- Yeni bir ProfileEvent Ekle `Merge` bu, başlatılan arka plan birleşimlerinin sayısını sayar. + [\#7093](https://github.com/ClickHouse/ClickHouse/pull/7093) ([Mikhail + Korotov](https://github.com/millb)) +- Tam etki alanı adı döndüren fullHostName işlevi ekleyin. + [\#7263](https://github.com/ClickHouse/ClickHouse/issues/7263) + [\#7291](https://github.com/ClickHouse/ClickHouse/pull/7291) ([sundyli](https://github.com/sundy-li)) +- Fonksiyon Ekle `arraySplit` ve `arrayReverseSplit` bir diz byiyi böl anen “cut off” + şartlar. Zaman dizisinin işlenmesinde kullanışlıdırlar. + [\#7294](https://github.com/ClickHouse/ClickHouse/pull/7294) ([hcz](https://github.com/hczhcz)) +- Multimatch işlev ailesine eşleşen tüm dizinlerin dizisini döndüren yeni işlevler ekleyin. + [\#7299](https://github.com/ClickHouse/ClickHouse/pull/7299) ([Danila. + Kutenin](https://github.com/danlark1)) +- Yeni bir veritabanı altyapısı Ekle `Lazy` bu, çok sayıda küçük günlük depolamak için optimize edilmiştir + Tablolar. [\#7171](https://github.com/ClickHouse/ClickHouse/pull/7171) ([Nikita + Vasilev](https://github.com/nikvas0)) +- Bitmap sütunları için groupBitmapAnd, - veya-Xor toplam işlevleri ekleyin. [\#7109](https://github.com/ClickHouse/ClickHouse/pull/7109) ([Zhichang + Yu](https://github.com/yuzhichang)) +- Null döndüren toplam işlev birleştiricileri-OrNull ve-OrDefault ekleyin + veya toplamak için hiçbir şey olmadığında varsayılan değerler. + [\#7331](https://github.com/ClickHouse/ClickHouse/pull/7331) + ([hcz](https://github.com/hczhcz)) +- Özel kaçan destekleyen CustomSeparated veri biçimini tanıtmak ve + sınırlayıcı kuralları. [\#7118](https://github.com/ClickHouse/ClickHouse/pull/7118) + ([tavplubix](https://github.com/tavplubix)) +- Destek Redis harici sözlük kaynağı olarak. [\#4361](https://github.com/ClickHouse/ClickHouse/pull/4361) [\#6962](https://github.com/ClickHouse/ClickHouse/pull/6962) ([comunodi](https://github.com/comunodi), [Anton + Popov](https://github.com/CurtizJ)) + +#### Hata Düzeltme {#bug-fix-2} + +- Varsa yanlış sorgu sonucunu düzeltin `WHERE IN (SELECT ...)` bölüm ve `optimize_read_in_order` oluyor + kullanılmış. [\#7371](https://github.com/ClickHouse/ClickHouse/pull/7371) ([Anton + Popov](https://github.com/CurtizJ)) +- Proje dışındaki dosyalara bağlı olarak engelli MariaDB kimlik doğrulama eklentisi. + [\#7140](https://github.com/ClickHouse/ClickHouse/pull/7140) ([Yuriy + Baranov](https://github.com/yurriy)) +- İstisnayı düzeltin `Cannot convert column ... because it is constant but values of constants are different in source and result` fonksiyonlar olduğunda nadiren olabilir `now()`, `today()`, + `yesterday()`, `randConstant()` kullanılır. + [\#7156](https://github.com/ClickHouse/ClickHouse/pull/7156) ([Nikolay + Kochetov](https://github.com/KochetovNicolai)) +- TCP yerine HTTP keep alive timeout kullanarak sabit sorunu alive timeout tutun. + [\#7351](https://github.com/ClickHouse/ClickHouse/pull/7351) ([Vasily + Nemkov](https://github.com/Enmk)) +- Groupbitmapor'da bir segmentasyon hatası düzeltildi (sorun [\#7109](https://github.com/ClickHouse/ClickHouse/issues/7109)). + [\#7289](https://github.com/ClickHouse/ClickHouse/pull/7289) ([Zhichang + Yu](https://github.com/yuzhichang)) +- Materyalize edilmiş görünümler için, tüm veriler yazıldıktan sonra Kafka için taahhüt denir. + [\#7175](https://github.com/ClickHouse/ClickHouse/pull/7175) ([I ivanvan](https://github.com/abyss7)) +- Sabit yanlış `duration_ms` değer içinde `system.part_log` Tablo. On kez kapalıydı. + [\#7172](https://github.com/ClickHouse/ClickHouse/pull/7172) ([Vladimir + Chebotarev](https://github.com/excitoon)) +- Canlı Görünüm tablosundaki çökmeyi çözmek ve tüm Canlı Görünüm testlerini yeniden etkinleştirmek için hızlı bir düzeltme. + [\#7201](https://github.com/ClickHouse/ClickHouse/pull/7201) + ([vzakaznikov](https://github.com/vzakaznikov)) +- MERGETREE parçalarının min/max dizinlerinde NULL değerleri doğru şekilde seri hale getirin. + [\#7234](https://github.com/ClickHouse/ClickHouse/pull/7234) ([İskender + Kuzmenkov](https://github.com/akuzm)) +- Sanal sütunları koymayın .tablo olarak oluşturulduğunda sql meta verileri `CREATE TABLE AS`. + [\#7183](https://github.com/ClickHouse/ClickHouse/pull/7183) ([I ivanvan](https://github.com/abyss7)) +- Segmentasyon hatasını düzeltin `ATTACH PART` sorgu. + [\#7185](https://github.com/ClickHouse/ClickHouse/pull/7185) + ([alesapin](https://github.com/alesapin)) +- Alt sorgularda boş ve boş optimizasyonu ile verilen bazı sorgular için yanlış sonucu düzeltin + INNER/RIGHT JOIN. [\#7284](https://github.com/ClickHouse/ClickHouse/pull/7284) ([Nikolay + Kochetov](https://github.com/KochetovNicolai)) +- Live VİEW getHeader() yönteminde AddressSanitizer hatası düzeltildi. + [\#7271](https://github.com/ClickHouse/ClickHouse/pull/7271) + ([vzakaznikov](https://github.com/vzakaznikov)) + +#### Geliştirme {#improvement-1} + +- Queue\_wait\_max\_ms bekleme durumunda bir ileti ekleme gerçekleşir. + [\#7390](https://github.com/ClickHouse/ClickHouse/pull/7390) ([Azat + Khuzhin](https://github.com/azat)) +- Yapılan ayar `s3_min_upload_part_size` masa seviyesi. + [\#7059](https://github.com/ClickHouse/ClickHouse/pull/7059) ([Vladimir + Chebotarev](https://github.com/excitoon)) +- STORAGEFACTORY TTL kontrol edin. [\#7304](https://github.com/ClickHouse/ClickHouse/pull/7304) + ([sundyli](https://github.com/sundy-li)) +- Kısmi birleştirme birleşiminde Squash sol blokları (optimizasyon). + [\#7122](https://github.com/ClickHouse/ClickHouse/pull/7122) ([Artem + Zuikov](https://github.com/4ertus2)) +- Çoğaltılmış tablo motorlarının mutasyonlarında deterministik olmayan işlevlere izin vermeyin, çünkü bu + kopyaları arasındaki tutarsızlıkları tanıtabilir. + [\#7247](https://github.com/ClickHouse/ClickHouse/pull/7247) ([İskender + Kazakov](https://github.com/Akazz)) +- Özel durum yığını izini dizeye dönüştürürken bellek izleyicisini devre dışı bırakın. Bu kaybı önleyebilir + Tür hata mesaj oflarının `Memory limit exceeded` neden olan sunucuda `Attempt to read after eof` istemci üzerinde istisna. [\#7264](https://github.com/ClickHouse/ClickHouse/pull/7264) + ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Çeşitli biçim geliştirmeleri. Gideriyor + [\#6033](https://github.com/ClickHouse/ClickHouse/issues/6033), + [\#2633](https://github.com/ClickHouse/ClickHouse/issues/2633), + [\#6611](https://github.com/ClickHouse/ClickHouse/issues/6611), + [\#6742](https://github.com/ClickHouse/ClickHouse/issues/6742) + [\#7215](https://github.com/ClickHouse/ClickHouse/pull/7215) + ([tavplubix](https://github.com/tavplubix)) +- ClickHouse sola dönüştürülebilir olmayan In işlecinin sağ tarafındaki değerleri yok sayar + side type. Make it work properly for compound types – Array and Tuple. + [\#7283](https://github.com/ClickHouse/ClickHouse/pull/7283) ([İskender + Kuzmenkov](https://github.com/akuzm)) +- ASOF JOİN için eksik eşitsizlikleri destekleyin. Daha az veya eşit varyant ve katı katılmak mümkündür + sözdiziminde asof sütunu için daha büyük ve daha az varyant. + [\#7282](https://github.com/ClickHouse/ClickHouse/pull/7282) ([Artem + Zuikov](https://github.com/4ertus2)) +- Kısmi birleştirme birleşimini Optimize edin. [\#7070](https://github.com/ClickHouse/ClickHouse/pull/7070) + ([Artem Zuikov](https://github.com/4ertus2)) +- UNİQCOMBİNED işlevlerinde 98 k'dan fazla bellek kullanmayın. + [\#7236](https://github.com/ClickHouse/ClickHouse/pull/7236), + [\#7270](https://github.com/ClickHouse/ClickHouse/pull/7270) ([Azat + Khuzhin](https://github.com/azat)) +- Partialmergejoin diskteki sağ birleştirme tablosunun parçalarını yıkayın (yeterli değilse + bellek). Gerektiğinde verileri geri yükleyin. [\#7186](https://github.com/ClickHouse/ClickHouse/pull/7186) + ([Artem Zuikov](https://github.com/4ertus2)) + +#### Performans İyileştirme {#performance-improvement-1} + +- Veri çoğaltma kaçınarak const argümanları ile joinget hızlandırın. + [\#7359](https://github.com/ClickHouse/ClickHouse/pull/7359) ([Amos + Kuş](https://github.com/amosbird)) +- Alt sorgu boşsa erken dönün. + [\#7007](https://github.com/ClickHouse/ClickHouse/pull/7007) ([小路](https://github.com/nicelulu)) +- Değerlerdeki SQL ifadesinin ayrıştırılmasını Optimize edin. + [\#6781](https://github.com/ClickHouse/ClickHouse/pull/6781) + ([tavplubix](https://github.com/tavplubix)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-1} + +- Mac OS için çapraz derleme için bazı katkılar devre dışı bırakın. + [\#7101](https://github.com/ClickHouse/ClickHouse/pull/7101) ([I ivanvan](https://github.com/abyss7)) +- Clickhouse\_common\_ıo için pocoxml ile eksik bağlantı ekleyin. + [\#7200](https://github.com/ClickHouse/ClickHouse/pull/7200) ([Azat + Khuzhin](https://github.com/azat)) +- Clickhouse-test'te birden fazla test filtresi argümanını kabul edin. + [\#7226](https://github.com/ClickHouse/ClickHouse/pull/7226) ([İskender + Kuzmenkov](https://github.com/akuzm)) +- Kol için musl ve jemalloc'u etkinleştirin. [\#7300](https://github.com/ClickHouse/ClickHouse/pull/7300) + ([Amos Kuşu](https://github.com/amosbird)) +- Katma `--client-option` parametre için `clickhouse-test` müşteriye ek parametreler aktarmak için. + [\#7277](https://github.com/ClickHouse/ClickHouse/pull/7277) ([Nikolay + Kochetov](https://github.com/KochetovNicolai)) +- Rpm paket yükseltmesinde mevcut yapılandırmaları koruyun. + [\#7103](https://github.com/ClickHouse/ClickHouse/pull/7103) + ([filimonov](https://github.com/filimonov)) +- PVS tarafından tespit edilen hataları düzeltin. [\#7153](https://github.com/ClickHouse/ClickHouse/pull/7153) ([Artem + Zuikov](https://github.com/4ertus2)) +- Darwin için yapı düzeltin. [\#7149](https://github.com/ClickHouse/ClickHouse/pull/7149) + ([I ivanvan](https://github.com/abyss7)) +- glibc 2.29 uyumluluk. [\#7142](https://github.com/ClickHouse/ClickHouse/pull/7142) ([Amos + Kuş](https://github.com/amosbird)) +- Dh\_clean potansiyel kaynak dosyaları dokunmaz emin olun. + [\#7205](https://github.com/ClickHouse/ClickHouse/pull/7205) ([Amos + Kuş](https://github.com/amosbird)) +- Altınity rpm'den güncellerken çakışmayı önlemeye çalışın-ayrı olarak paketlenmiş yapılandırma dosyası vardır + clickhouse-sunucu-ortak. [\#7073](https://github.com/ClickHouse/ClickHouse/pull/7073) + ([filimonov](https://github.com/filimonov)) +- Daha hızlı yeniden oluşturmak için bazı başlık dosyalarını Optimize edin. + [\#7212](https://github.com/ClickHouse/ClickHouse/pull/7212), + [\#7231](https://github.com/ClickHouse/ClickHouse/pull/7231) ([İskender + Kuzmenkov](https://github.com/akuzm)) +- Tarih ve DateTime için performans testleri ekleyin. [\#7332](https://github.com/ClickHouse/ClickHouse/pull/7332) ([Vasily + Nemkov](https://github.com/Enmk)) +- Deterministik olmayan mutasyonlar içeren bazı testleri düzeltin. + [\#7132](https://github.com/ClickHouse/ClickHouse/pull/7132) ([İskender + Kazakov](https://github.com/Akazz)) +- MemorySanitizer ile CI için yapı ekleyin. [\#7066](https://github.com/ClickHouse/ClickHouse/pull/7066) + ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Metricstransmitter başlatılmamış değerleri kullanmaktan kaçının. + [\#7158](https://github.com/ClickHouse/ClickHouse/pull/7158) ([Azat + Khuzhin](https://github.com/azat)) +- MemorySanitizer tarafından bulunan alanlarda bazı sorunları düzeltin. + [\#7135](https://github.com/ClickHouse/ClickHouse/pull/7135), + [\#7179](https://github.com/ClickHouse/ClickHouse/pull/7179) ([İskender + Kuzmenkov](https://github.com/akuzm)), [\#7376](https://github.com/ClickHouse/ClickHouse/pull/7376) + ([Amos Kuşu](https://github.com/amosbird)) +- Murmurhash32'de tanımsız davranışı düzeltin. [\#7388](https://github.com/ClickHouse/ClickHouse/pull/7388) ([Amos + Kuş](https://github.com/amosbird)) +- Storagesınfostream tanımsız davranışı düzeltin. [\#7384](https://github.com/ClickHouse/ClickHouse/pull/7384) + ([tavplubix](https://github.com/tavplubix)) +- Harici veritabanı motorları (MySQL, ODBC, JDBC) için katlama sabit sabit ifadeler. Önceki + sürümler birden fazla sabit ifade için çalışmadı ve Tarih için hiç çalışmadı, + DateTime ve UUID. Bu düzeltmeler [\#7245](https://github.com/ClickHouse/ClickHouse/issues/7245) + [\#7252](https://github.com/ClickHouse/ClickHouse/pull/7252) + ([alexey-milovidov](https://github.com/alexey-milovidov)) +- No\_users\_thread değişkenine erişirken canlı görünümde ThreadSanitizer veri yarışı hatası düzeltildi. + [\#7353](https://github.com/ClickHouse/ClickHouse/pull/7353) + ([vzakaznikov](https://github.com/vzakaznikov)) +- Libcommon'daki malloc sembollerinden kurtulun + [\#7134](https://github.com/ClickHouse/ClickHouse/pull/7134), + [\#7065](https://github.com/ClickHouse/ClickHouse/pull/7065) ([Amos + Kuş](https://github.com/amosbird)) +- Tüm kitaplıkları devre dışı bırakmak için genel bayrak ENABLE\_LİBRARİES ekleyin. + [\#7063](https://github.com/ClickHouse/ClickHouse/pull/7063) + ([proller](https://github.com/proller)) + +#### Kod temizleme {#code-cleanup} + +- Sözlükler için DDL'YE hazırlanmak için yapılandırma deposunu genelleştirin. [\#7155](https://github.com/ClickHouse/ClickHouse/pull/7155) + ([alesapin](https://github.com/alesapin)) +- Herhangi bir anlamsal olmadan sözlükler DDL için ayrıştırıcı. + [\#7209](https://github.com/ClickHouse/ClickHouse/pull/7209) + ([alesapin](https://github.com/alesapin)) +- Bölünmüş ParserCreateQuery farklı küçük ayrıştırıcılar içine. + [\#7253](https://github.com/ClickHouse/ClickHouse/pull/7253) + ([alesapin](https://github.com/alesapin)) +- Küçük refactoring ve dış sözlükler yakın yeniden adlandırma. + [\#7111](https://github.com/ClickHouse/ClickHouse/pull/7111) + ([alesapin](https://github.com/alesapin)) +- Refactor bazı kod rol tabanlı erişim kontrolü için hazırlamak. [\#7235](https://github.com/ClickHouse/ClickHouse/pull/7235) ([Vitaly. + Baranov](https://github.com/vitlibar)) +- Veritabanında bazı geliştirmelersıradan kod. + [\#7086](https://github.com/ClickHouse/ClickHouse/pull/7086) ([Nikita + Vasilev](https://github.com/nikvas0)) +- Karma tabloların find() ve emplace() yöntemlerinde yineleyiciler kullanmayın. + [\#7026](https://github.com/ClickHouse/ClickHouse/pull/7026) ([İskender + Kuzmenkov](https://github.com/akuzm)) +- Parametre kökü boş olmadığında getmultiplevaluesfromconfig'i düzeltin. [\#7374](https://github.com/ClickHouse/ClickHouse/pull/7374) + ([Mikhail Korotov](https://github.com/millb)) +- Bazı kopyala yapıştır (TemporaryFile ve TemporaryFileStream) kaldırın) + [\#7166](https://github.com/ClickHouse/ClickHouse/pull/7166) ([Artem + Zuikov](https://github.com/4ertus2)) +- Geliştirilmiş kod okunabilirliği biraz (`MergeTreeData::getActiveContainingPart`). + [\#7361](https://github.com/ClickHouse/ClickHouse/pull/7361) ([Vladimir + Chebotarev](https://github.com/excitoon)) +- Yerel nesneler kullanan tüm zamanlanmış işleri bekleyin, eğer `ThreadPool::schedule(...)` atmalar + özel. Adlandırmak `ThreadPool::schedule(...)` -e doğru `ThreadPool::scheduleOrThrowOnError(...)` ve + atabileceği açık hale getirmek için yorumları düzeltin. + [\#7350](https://github.com/ClickHouse/ClickHouse/pull/7350) + ([tavplubix](https://github.com/tavplubix)) + +## ClickHouse sürümü 19.15 {#clickhouse-release-19-15} + +### ClickHouse sürümü 19.15.4.10, 2019-10-31 {#clickhouse-release-19-15-4-10-2019-10-31} + +#### Hata Düzeltme {#bug-fix-3} + +- SQL\_TINYINT ve SQL\_BIGINT işleme eklendi ve ODBC Köprüsü SQL\_FLOAT veri kaynağı türlerinin işlenmesini düzeltin. + [\#7491](https://github.com/ClickHouse/ClickHouse/pull/7491) ([Denis Glazachev](https://github.com/traceon)) +- Taşıma bölümünde hedef disk veya birim üzerinde bazı parçaların olmasına izin verilir. + [\#7434](https://github.com/ClickHouse/ClickHouse/pull/7434) ([Vladimir Chebotarev](https://github.com/excitoon)) +- ODBC köprüsü aracılığıyla null sütunlarda sabit NULL değerleri. + [\#7402](https://github.com/ClickHouse/ClickHouse/pull/7402) ([Vasily Nemkov](https://github.com/Enmk)) +- SOMUTLAŞTIRILMIŞ sütunlarla dağıtılmış yerel olmayan düğüme sabit ekleme. + [\#7377](https://github.com/ClickHouse/ClickHouse/pull/7377) ([Azat Khuzhin](https://github.com/azat)) +- Sabit fonksiyon getMultipleValuesFromConfig. + [\#7374](https://github.com/ClickHouse/ClickHouse/pull/7374) ([Mikhail Korotov](https://github.com/millb)) +- TCP yerine HTTP keep alive timeout kullanarak sabit sorunu alive timeout tutun. + [\#7351](https://github.com/ClickHouse/ClickHouse/pull/7351) ([Vasily Nemkov](https://github.com/Enmk)) +- Tüm işlerin istisnada bitmesini bekleyin (nadir segfault'ları düzeltir). + [\#7350](https://github.com/ClickHouse/ClickHouse/pull/7350) ([tavplubix](https://github.com/tavplubix)) +- Kafka tabloya eklerken MVs için itmeyin. + [\#7265](https://github.com/ClickHouse/ClickHouse/pull/7265) ([I ivanvan](https://github.com/abyss7)) +- İstisna yığını için bellek izleyicisini devre dışı bırakın. + [\#7264](https://github.com/ClickHouse/ClickHouse/pull/7264) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Harici veritabanı için sorgu dönüştürme sabit kötü kod. + [\#7252](https://github.com/ClickHouse/ClickHouse/pull/7252) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Metricstransmitter başlatılmamış değerleri kullanmaktan kaçının. + [\#7158](https://github.com/ClickHouse/ClickHouse/pull/7158) ([Azat Khuzhin](https://github.com/azat)) +- Testler için makrolarla örnek yapılandırma eklendi ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse sürümü 19.15.3.6, 2019-10-09 {#clickhouse-release-19-15-3-6-2019-10-09} + +#### Hata Düzeltme {#bug-fix-4} + +- Karma sözlükte sabit bad\_variant. + ([alesapin](https://github.com/alesapin)) +- Bölüm sorgu Ekle segmentasyon hatası ile hata düzeltildi. + ([alesapin](https://github.com/alesapin)) +- Sabit zaman hesaplama `MergeTreeData`. + ([Vladimir Chebotarev](https://github.com/excitoon)) +- Yazma tamamlandıktan sonra açıkça Kafka'ya taahhüt edin. + [\#7175](https://github.com/ClickHouse/ClickHouse/pull/7175) ([I ivanvan](https://github.com/abyss7)) +- MERGETREE parçalarının min/max dizinlerinde NULL değerleri doğru şekilde seri hale getirin. + [\#7234](https://github.com/ClickHouse/ClickHouse/pull/7234) ([Alexander Kuzmenkov](https://github.com/akuzm)) + +### ClickHouse sürümü 19.15.2.2, 2019-10-01 {#clickhouse-release-19-15-2-2-2019-10-01} + +#### Yenilik {#new-feature-3} + +- Katmanlı depolama: MergeTree motoru ile tablolar için birden fazla depolama birimleri kullanmak için destek. Yeni verileri SSD'DE saklamak ve eski verileri otomatik olarak HDD'ye taşımak mümkündür. ([örnek](https://clickhouse.github.io/clickhouse-presentations/meetup30/new_features/#12)). [\#4918](https://github.com/ClickHouse/ClickHouse/pull/4918) ([Igr](https://github.com/ObjatieGroba)) [\#6489](https://github.com/ClickHouse/ClickHouse/pull/6489) ([alesapin](https://github.com/alesapin)) +- Tablo fonksiyonu Ekle `input` gelen verileri okumak için `INSERT SELECT` sorgu. [\#5450](https://github.com/ClickHouse/ClickHouse/pull/5450) ([palasonic1](https://github.com/palasonic1)) [\#6832](https://github.com/ClickHouse/ClickHouse/pull/6832) ([Anton Popov](https://github.com/CurtizJ)) +- Add a `sparse_hashed` sözlük düzeni, bu işlevsel olarak eşdeğerdir `hashed` düzen, ancak daha fazla bellek verimli. Daha yavaş değer alma pahasına yaklaşık iki kat daha az bellek kullanır. [\#6894](https://github.com/ClickHouse/ClickHouse/pull/6894) ([Azat Khuzhin](https://github.com/azat)) +- Sözlüklere erişim için kullanıcıların listesini tanımlama yeteneğini uygular. Sadece geçerli bağlı veritabanı kullanarak. [\#6907](https://github.com/ClickHouse/ClickHouse/pull/6907) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Eklemek `LIMIT` seçeneği `SHOW` sorgu. [\#6944](https://github.com/ClickHouse/ClickHouse/pull/6944) ([Philipp Malkovsky](https://github.com/malkfilipp)) +- Eklemek `bitmapSubsetLimit(bitmap, range_start, limit)` en küçük alt kümesini döndüren işlev `limit` küm valuesedeki değer smallerlerden daha küçük olmayan değerler `range_start`. [\#6957](https://github.com/ClickHouse/ClickHouse/pull/6957) ([Zhichang Yu](https://github.com/yuzhichang)) +- Eklemek `bitmapMin` ve `bitmapMax` işlevler. [\#6970](https://github.com/ClickHouse/ClickHouse/pull/6970) ([Zhichang Yu](https://github.com/yuzhichang)) +- Fonksiyon Ekle `repeat` ile ilgili [sayı-6648](https://github.com/ClickHouse/ClickHouse/issues/6648) [\#6999](https://github.com/ClickHouse/ClickHouse/pull/6999) ([flynn](https://github.com/ucasFL)) + +#### Deneysel Özellik {#experimental-feature-1} + +- Geçerli boru hattını değiştirmeyen birleştirme birleştirme varyantını (bellekte) uygulayın. Sonuç kısmen birleştirme anahtarına göre sıralanır. Koymak `partial_merge_join = 1` bu özelliği kullanmak için. Birleştirme birleştirme hala geliştirme aşamasındadır. [\#6940](https://github.com/ClickHouse/ClickHouse/pull/6940) ([Artem Zuikov](https://github.com/4ertus2)) +- Eklemek `S3` motor ve masa fonksiyonu. Hala geliştirme aşamasında (henüz kimlik doğrulama desteği yok). [\#5596](https://github.com/ClickHouse/ClickHouse/pull/5596) ([Vladimir Chebotarev](https://github.com/excitoon)) + +#### Geliştirme {#improvement-2} + +- Kafka'dan okunan her mesaj atomik olarak eklenir. Bu, Kafka engine ile bilinen hemen hemen tüm sorunları çözer. [\#6950](https://github.com/ClickHouse/ClickHouse/pull/6950) ([I ivanvan](https://github.com/abyss7)) +- Dağıtılmış sorguların yerine çalışma için iyileştirmeler. Kurtarma süresini kısaltın, ayrıca şimdi yapılandırılabilir ve görülebilir `system.clusters`. [\#6399](https://github.com/ClickHouse/ClickHouse/pull/6399) ([Vasily Nemkov](https://github.com/Enmk)) +- Doğrudan Enums için sayısal değerleri destekleyin `IN` bölme. \#6766 [\#6941](https://github.com/ClickHouse/ClickHouse/pull/6941) ([dimarub2000](https://github.com/dimarub2000)) +- Destek (isteğe bağlı, varsayılan olarak devre dışı) URL depolama yönlendirir. [\#6914](https://github.com/ClickHouse/ClickHouse/pull/6914) ([makroll](https://github.com/maqroll)) +- Eski bir sürümü olan istemci bir sunucuya bağlandığında bilgi iletisi ekleyin. [\#6893](https://github.com/ClickHouse/ClickHouse/pull/6893) ([Philipp Malkovsky](https://github.com/malkfilipp)) +- Dağıtılmış tablolarda veri göndermek için maksimum geri dönüş uyku süresi sınırını kaldırın [\#6895](https://github.com/ClickHouse/ClickHouse/pull/6895) ([Azat Khuzhin](https://github.com/azat)) +- Grafit kümülatif değerleri ile profil olayları (sayaçlar) göndermek için yeteneği ekleyin. Altında etkinleştir canilebilir `` server inda `config.xml`. [\#6969](https://github.com/ClickHouse/ClickHouse/pull/6969) ([Azat Khuzhin](https://github.com/azat)) +- Otomatik döküm türü Ekle `T` -e doğru `LowCardinality(T)` veri türü sütununa eklerken `LowCardinality(T)` HTTP üzerinden yerel formatta. [\#6891](https://github.com/ClickHouse/ClickHouse/pull/6891) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Fonksiyonu kullanma yeteneği ekleyin `hex` kullanmadan `reinterpretAsString` için `Float32`, `Float64`. [\#7024](https://github.com/ClickHouse/ClickHouse/pull/7024) ([Mikhail Korotov](https://github.com/millb)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-2} + +- Hata ayıklama bilgisi ile clickhouse ikili için gdb-ındex ekleyin. Bu başlangıç süresini hızlandıracaktır `gdb`. [\#6947](https://github.com/ClickHouse/ClickHouse/pull/6947) ([alesapin](https://github.com/alesapin)) +- Kullanan yamalı dpkg-deb ile deb ambalajını hızlandırın `pigz`. [\#6960](https://github.com/ClickHouse/ClickHouse/pull/6960) ([alesapin](https://github.com/alesapin)) +- Koymak `enable_fuzzing = 1` tüm proje kodu libfuzzer enstrümantasyon etkinleştirmek için. [\#7042](https://github.com/ClickHouse/ClickHouse/pull/7042) ([kyprizel](https://github.com/kyprizel)) +- CI bölünmüş yapı duman testi ekleyin. [\#7061](https://github.com/ClickHouse/ClickHouse/pull/7061) ([alesapin](https://github.com/alesapin)) +- MemorySanitizer ile CI için yapı ekleyin. [\#7066](https://github.com/ClickHouse/ClickHouse/pull/7066) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Değişmek `libsparsehash` ile `sparsehash-c11` [\#6965](https://github.com/ClickHouse/ClickHouse/pull/6965) ([Azat Khuzhin](https://github.com/azat)) + +#### Hata Düzeltme {#bug-fix-5} + +- Büyük tablolarda karmaşık anahtarlar üzerinde endeks analizi sabit performans düşüşü. Bu düzeltmeler \# 6924. [\#7075](https://github.com/ClickHouse/ClickHouse/pull/7075) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kafka boş konudan seçerken segfaults'a neden olan mantıksal hatayı düzeltin. [\#6909](https://github.com/ClickHouse/ClickHouse/pull/6909) ([I ivanvan](https://github.com/abyss7)) +- Çok erken MySQL bağlantısını düzeltin `MySQLBlockInputStream.cpp`. [\#6882](https://github.com/ClickHouse/ClickHouse/pull/6882) ([Clément Rodriguez](https://github.com/clemrodriguez)) +- Çok eski Linux çekirdekleri için geri destek (düzeltme [\#6841](https://github.com/ClickHouse/ClickHouse/issues/6841)) [\#6853](https://github.com/ClickHouse/ClickHouse/pull/6853) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Olası veri kaybını düzeltin `insert select` giriş akışında boş blok durumunda sorgu. \#6834 \#6862 [\#6911](https://github.com/ClickHouse/ClickHouse/pull/6911) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Fonksiyon için düzeltme `АrrayEnumerateUniqRanked` params boş diziler ile [\#6928](https://github.com/ClickHouse/ClickHouse/pull/6928) ([proller](https://github.com/proller)) +- Dizi birleşimleri ve genel alt sorgularla karmaşık sorguları düzeltin. [\#6934](https://github.com/ClickHouse/ClickHouse/pull/6934) ([I ivanvan](https://github.com/abyss7)) +- Düzeltmek `Unknown identifier` birden fazla birleşim ile ORDER BY ve GROUP BY hatası [\#7022](https://github.com/ClickHouse/ClickHouse/pull/7022) ([Artem Zuikov](https://github.com/4ertus2)) +- Sabit `MSan` fonksiyonu çalıştırırken uyarı `LowCardinality` değişken. [\#7062](https://github.com/ClickHouse/ClickHouse/pull/7062) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) + +#### Geriye Dönük Uyumsuz Değişim {#backward-incompatible-change-2} + +- Bitmap'in seri hale getirme biçimi değiştirildi \* performansı artırmak için toplama işlevi durumları. Önceki sürümlerden bitmap\* seri hale getirilmiş durumları okunamıyor. [\#6908](https://github.com/ClickHouse/ClickHouse/pull/6908) ([Zhichang Yu](https://github.com/yuzhichang)) + +## ClickHouse sürümü 19.14 {#clickhouse-release-19-14} + +### ClickHouse sürümü 19.14.7.15, 2019-10-02 {#clickhouse-release-19-14-7-15-2019-10-02} + +#### Hata Düzeltme {#bug-fix-6} + +- Bu sürüm aynı zamanda 19.11.12.69 tüm hata düzeltmeleri içerir. +- 19.14 ve önceki sürümleri arasında dağıtılmış sorgular için sabit uyumluluk. Bu düzeltmeler [\#7068](https://github.com/ClickHouse/ClickHouse/issues/7068). [\#7069](https://github.com/ClickHouse/ClickHouse/pull/7069) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse sürümü 19.14.6.12, 2019-09-19 {#clickhouse-release-19-14-6-12-2019-09-19} + +#### Hata Düzeltme {#bug-fix-7} + +- Fonksiyon için düzeltme `АrrayEnumerateUniqRanked` params boş diziler ile. [\#6928](https://github.com/ClickHouse/ClickHouse/pull/6928) ([proller](https://github.com/proller)) +- Sorgularda sabit alt sorgu adı `ARRAY JOIN` ve `GLOBAL IN subquery` takma ad ile. Belirtilirse, dış tablo adı için alt sorgu takma adını kullanın. [\#6934](https://github.com/ClickHouse/ClickHouse/pull/6934) ([I ivanvan](https://github.com/abyss7)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-3} + +- Düzeltmek [çırpan](https://clickhouse-test-reports.s3.yandex.net/6944/aab95fd5175a513413c7395a73a82044bdafb906/functional_stateless_tests_(debug).html) test `00715_fetch_merged_or_mutated_part_zookeeper` mutasyonların uygulanmasını beklemek zorunda olduğu için bir kabuk komut dosyasına yeniden yazarak. [\#6977](https://github.com/ClickHouse/ClickHouse/pull/6977) ([Alexander Kazakov](https://github.com/Akazz)) +- Fonksiyon sabit UBSan ve MemSan hatası `groupUniqArray` emtpy dizi argümanı ile. Bu boş yerleştirerek neden oldu `PaddedPODArray` sıfır hücre değeri için yapıcı çağrılmadığı için karma tabloya sıfır hücre. [\#6937](https://github.com/ClickHouse/ClickHouse/pull/6937) ([Amos Kuşu](https://github.com/amosbird)) + +### ClickHouse sürümü 19.14.3.3, 2019-09-10 {#clickhouse-release-19-14-3-3-2019-09-10} + +#### Yenilik {#new-feature-4} + +- `WITH FILL` değiştirici için `ORDER BY`. (devam [\#5069](https://github.com/ClickHouse/ClickHouse/issues/5069)) [\#6610](https://github.com/ClickHouse/ClickHouse/pull/6610) ([Anton Popov](https://github.com/CurtizJ)) +- `WITH TIES` değiştirici için `LIMIT`. (devam [\#5069](https://github.com/ClickHouse/ClickHouse/issues/5069)) [\#6610](https://github.com/ClickHouse/ClickHouse/pull/6610) ([Anton Popov](https://github.com/CurtizJ)) +- Ayrıştırılmamış `NULL` NULL olarak değişmez (eğer ayar `format_csv_unquoted_null_literal_as_null=1`). Bu alanın veri türü null değilse, null alanları varsayılan değerlerle başlatın (eğer ayar `input_format_null_as_default=1`). [\#5990](https://github.com/ClickHouse/ClickHouse/issues/5990) [\#6055](https://github.com/ClickHouse/ClickHouse/pull/6055) ([tavplubix](https://github.com/tavplubix)) +- Tablo işlevlerinin yollarındaki joker karakterler için destek `file` ve `hdfs`. Yol joker karakterler içeriyorsa, tablo salt okunur olacaktır. Kullanım örneği: `select * from hdfs('hdfs://hdfs1:9000/some_dir/another_dir/*/file{0..9}{0..9}')` ve `select * from file('some_dir/{some_file,another_file,yet_another}.tsv', 'TSV', 'value UInt32')`. [\#6092](https://github.com/ClickHouse/ClickHouse/pull/6092) ([Olga Khvostikova](https://github.com/stavrolia)) +- Yeni `system.metric_log` değerleri depo tablelayan tablo `system.events` ve `system.metrics` belirtilen zaman aralığı ile. [\#6363](https://github.com/ClickHouse/ClickHouse/issues/6363) [\#6467](https://github.com/ClickHouse/ClickHouse/pull/6467) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) [\#6530](https://github.com/ClickHouse/ClickHouse/pull/6530) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- ClickHouse metin günlükleri yazmak için izin ver `system.text_log` Tablo. [\#6037](https://github.com/ClickHouse/ClickHouse/issues/6037) [\#6103](https://github.com/ClickHouse/ClickHouse/pull/6103) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) [\#6164](https://github.com/ClickHouse/ClickHouse/pull/6164) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yığın izlerinde özel sembolleri göster (bu, elf dosyalarının sembol tablolarını ayrıştırma yoluyla yapılır). Hata ayıklama bilgisi varsa yığın izlerinde dosya ve satır numarası hakkında bilgi eklendi. Programda mevcut indeksleme sembolleri ile Speedup sembol adı arama. İç gözlem için yeni SQL işlevleri eklendi: `demangle` ve `addressToLine`. Yeniden adlandırılan işlev `symbolizeAddress` -e doğru `addressToSymbol` tutarlılık için. İşlev `addressToSymbol` performans nedenleriyle karıştırılmış adını döndürür ve uygulamak zorunda `demangle`. Ayar eklendi `allow_introspection_functions` varsayılan olarak kapalı olan. [\#6201](https://github.com/ClickHouse/ClickHouse/pull/6201) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tablo fonksiyonu `values` (adı büyük / küçük harf duyarsız). Bu okumak için izin verir `VALUES` önerilen liste [\#5984](https://github.com/ClickHouse/ClickHouse/issues/5984). Örnek: `SELECT * FROM VALUES('a UInt64, s String', (1, 'one'), (2, 'two'), (3, 'three'))`. [\#6217](https://github.com/ClickHouse/ClickHouse/issues/6217). [\#6209](https://github.com/ClickHouse/ClickHouse/pull/6209) ([dimarub2000](https://github.com/dimarub2000)) +- Depolama ayarlarını değiştirmek için bir yetenek eklendi. Sözdizimi: `ALTER TABLE MODIFY SETTING = `. [\#6366](https://github.com/ClickHouse/ClickHouse/pull/6366) [\#6669](https://github.com/ClickHouse/ClickHouse/pull/6669) [\#6685](https://github.com/ClickHouse/ClickHouse/pull/6685) ([alesapin](https://github.com/alesapin)) +- Müstakil parçaların çıkarılması için destek. Sözdizimi: `ALTER TABLE DROP DETACHED PART ''`. [\#6158](https://github.com/ClickHouse/ClickHouse/pull/6158) ([tavplubix](https://github.com/tavplubix)) +- Tablo kısıtlamaları. Ekleme sırasında kontrol edilecek tablo tanımına kısıtlama eklemenize izin verir. [\#5273](https://github.com/ClickHouse/ClickHouse/pull/5273) ([Gleb Novikov](https://github.com/NanoBjorn)) [\#6652](https://github.com/ClickHouse/ClickHouse/pull/6652) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Basamaklı hayata görünümler için Suppport. [\#6324](https://github.com/ClickHouse/ClickHouse/pull/6324) ([Amos Kuşu](https://github.com/amosbird)) +- Her sorgu yürütme iş parçacığı saniyede bir örnek için varsayılan olarak sorgu profiler'ı açın. [\#6283](https://github.com/ClickHouse/ClickHouse/pull/6283) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Giriş biçimi `ORC`. [\#6454](https://github.com/ClickHouse/ClickHouse/pull/6454) [\#6703](https://github.com/ClickHouse/ClickHouse/pull/6703) ([akonyaev90](https://github.com/akonyaev90)) +- İki yeni fonksiyon eklendi: `sigmoid` ve `tanh` (bu makine öğrenme uygulamaları için yararlıdır). [\#6254](https://github.com/ClickHouse/ClickHouse/pull/6254) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İşlev `hasToken(haystack, token)`, `hasTokenCaseInsensitive(haystack, token)` verilen jetonun samanlıkta olup olmadığını kontrol etmek için. Token, iki alfasayısal olmayan ASCII karakteri (veya samanlığın sınırları) arasında maksimum uzunlukta bir alt dizedir. Token sabit bir dize olmalıdır. Tokenbf\_v1 Endeksi uzmanlaşma tarafından desteklenmektedir. [\#6596](https://github.com/ClickHouse/ClickHouse/pull/6596), [\#6662](https://github.com/ClickHouse/ClickHouse/pull/6662) ([Vasily Nemkov](https://github.com/Enmk)) +- Yeni fonksiyon `neighbor(value, offset[, default_value])`. Bir veri bloğunda sütun içindeki önceki / sonraki değere ulaşmayı sağlar. [\#5925](https://github.com/ClickHouse/ClickHouse/pull/5925) ([Alex Krash](https://github.com/alex-krash)) [6685365ab8c5b74f9650492c88a012596eb1b0c6](https://github.com/ClickHouse/ClickHouse/commit/6685365ab8c5b74f9650492c88a012596eb1b0c6) [341e2e4587a18065c2da1ca888c73389f48ce36c](https://github.com/ClickHouse/ClickHouse/commit/341e2e4587a18065c2da1ca888c73389f48ce36c) [Alexey Milovidov](https://github.com/alexey-milovidov) +- Bir işlev oluşturuldu `currentUser()`, yetkili kullanıcının giriş dönen. Add aliased al aliasias `user()` MySQL ile uyumluluk için. [\#6470](https://github.com/ClickHouse/ClickHouse/pull/6470) ([Alex Krash](https://github.com/alex-krash)) +- Yeni toplama fonksiyonları `quantilesExactInclusive` ve `quantilesExactExclusive` hangi teklif edildi [\#5885](https://github.com/ClickHouse/ClickHouse/issues/5885). [\#6477](https://github.com/ClickHouse/ClickHouse/pull/6477) ([dimarub2000](https://github.com/dimarub2000)) +- İşlev `bitmapRange(bitmap, range_begin, range_end)` hangi döner yeni set ile belirtilen aralığı (dahil değil `range_end`). [\#6314](https://github.com/ClickHouse/ClickHouse/pull/6314) ([Zhichang Yu](https://github.com/yuzhichang)) +- İşlev `geohashesInBox(longitude_min, latitude_min, longitude_max, latitude_max, precision)` hangi verilen alanı kapsayan geohash-kutuları hassas uzun dizeleri dizisi oluşturur. [\#6127](https://github.com/ClickHouse/ClickHouse/pull/6127) ([Vasily Nemkov](https://github.com/Enmk)) +- INSERT query ile destek uygulamak `Kafka` Tablolar. [\#6012](https://github.com/ClickHouse/ClickHouse/pull/6012) ([I ivanvan](https://github.com/abyss7)) +- İçin destek eklendi `_partition` ve `_timestamp` Kafka motoruna sanal sütunlar. [\#6400](https://github.com/ClickHouse/ClickHouse/pull/6400) ([I ivanvan](https://github.com/abyss7)) +- Hassas verileri kaldırma imkanı `query_log`, sunucu günlükleri, regexp tabanlı kurallar ile işlem listesi. [\#5710](https://github.com/ClickHouse/ClickHouse/pull/5710) ([filimonov](https://github.com/filimonov)) + +#### Deneysel Özellik {#experimental-feature-2} + +- Giriş ve çıkış Veri formatı `Template`. Bu giriş ve çıkış için özel biçim dizesi belirtmek için izin verir. [\#4354](https://github.com/ClickHouse/ClickHouse/issues/4354) [\#6727](https://github.com/ClickHouse/ClickHouse/pull/6727) ([tavplubix](https://github.com/tavplubix)) +- Uygulanması `LIVE VIEW` başlangıçta önerilen tablolar [\#2898](https://github.com/ClickHouse/ClickHouse/pull/2898) hazırlıklı olarak [\#3925](https://github.com/ClickHouse/ClickHouse/issues/3925), ve daha sonra güncellendi [\#5541](https://github.com/ClickHouse/ClickHouse/issues/5541). Görmek [\#5541](https://github.com/ClickHouse/ClickHouse/issues/5541) detaylı açıklama için. [\#5541](https://github.com/ClickHouse/ClickHouse/issues/5541) ([vzakaznikov](https://github.com/vzakaznikov)) [\#6425](https://github.com/ClickHouse/ClickHouse/pull/6425) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) [\#6656](https://github.com/ClickHouse/ClickHouse/pull/6656) ([vzakaznikov](https://github.com/vzakaznikov) Not bu `LIVE VIEW` özellik sonraki sürümlerinde kaldırılabilir. + +#### Hata Düzeltme {#bug-fix-8} + +- Bu sürüm aynı zamanda 19.13 ve 19.11 tüm hata düzeltmeleri içerir. +- Tablo atlama endeksleri ve dikey birleştirme gerçekleştiğinde segmentasyon hatasını düzeltin. [\#6723](https://github.com/ClickHouse/ClickHouse/pull/6723) ([alesapin](https://github.com/alesapin)) +- Önemsiz olmayan sütun varsayılanlarıyla sütun başına TTL'Yİ düzeltin. Daha önce kuvvet durumunda `OPTIMIZE ... FINAL` sorgu, süresi dolmuş değerler, kullanıcı tarafından belirtilen sütun varsayılanları yerine tür varsayılanları ile değiştirildi. [\#6796](https://github.com/ClickHouse/ClickHouse/pull/6796) ([Anton Popov](https://github.com/CurtizJ)) +- Normal sunucu yeniden başlatmada Kafka mesajları çoğaltma sorununu düzeltin. [\#6597](https://github.com/ClickHouse/ClickHouse/pull/6597) ([I ivanvan](https://github.com/abyss7)) +- Kafka mesajlarını okurken sabit sonsuz döngü. Tüketiciyi abonelikte hiç duraklatmayın/devam ettirmeyin - aksi takdirde bazı senaryolarda süresiz olarak duraklatılabilir. [\#6354](https://github.com/ClickHouse/ClickHouse/pull/6354) ([I ivanvan](https://github.com/abyss7)) +- Düzeltmek `Key expression contains comparison between inconvertible types` istisna içinde `bitmapContains` işlev. [\#6136](https://github.com/ClickHouse/ClickHouse/issues/6136) [\#6146](https://github.com/ClickHouse/ClickHouse/issues/6146) [\#6156](https://github.com/ClickHouse/ClickHouse/pull/6156) ([dimarub2000](https://github.com/dimarub2000)) +- Etkin olan segfault'u düzeltin `optimize_skip_unused_shards` ve kayıp sharding anahtarı. [\#6384](https://github.com/ClickHouse/ClickHouse/pull/6384) ([Anton Popov](https://github.com/CurtizJ)) +- Bellek bozulmasına yol açabilecek mutasyonlarda yanlış kod düzeltildi. Adresin okunması ile sabit segfault `0x14c0` bu eşzamanlı nedeniyle happed olabilir `DROP TABLE` ve `SELECT` itibaren `system.parts` veya `system.parts_columns`. Mutasyon sorgularının hazırlanmasında sabit yarış durumu. Sabit kilitlenme neden `OPTIMIZE` çoğaltılmış tablolar ve değiştirir gibi eşzamanlı değişiklik işlemleri. [\#6514](https://github.com/ClickHouse/ClickHouse/pull/6514) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- MySQL arayüzü kaldırıldı ekstra ayrıntılı günlüğü [\#6389](https://github.com/ClickHouse/ClickHouse/pull/6389) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Boolean ayarlarını ayrıştırma yeteneğini döndürür ‘true’ ve ‘false’ yapılandırma dosyasında. [\#6278](https://github.com/ClickHouse/ClickHouse/pull/6278) ([alesapin](https://github.com/alesapin)) +- Çökmeyi düzeltin `quantile` ve `median` fonksiyonu üzerinde `Nullable(Decimal128)`. [\#6378](https://github.com/ClickHouse/ClickHouse/pull/6378) ([Artem Zuikov](https://github.com/4ertus2)) +- Tarafından iade edilen Olası eksik sonuç düzeltildi `SELECT` ile sorgu `WHERE` birincil anahtarda durum, Float türüne dönüşüm içeriyordu. Bu Monotonluk yanlış kontrol neden oldu `toFloat` işlev. [\#6248](https://github.com/ClickHouse/ClickHouse/issues/6248) [\#6374](https://github.com/ClickHouse/ClickHouse/pull/6374) ([dimarub2000](https://github.com/dimarub2000)) +- Kontrol `max_expanded_ast_elements` mutasyonlar için ayarlama. Sonra açık mutasyonlar `TRUNCATE TABLE`. [\#6205](https://github.com/ClickHouse/ClickHouse/pull/6205) ([Kış Zhang](https://github.com/zhang2014)) +- İle kullanıldığında anahtar sütunlar için birleştirme sonuçlarını düzeltin `join_use_nulls`. Sütun varsayılanları yerine Boşları ekleyin. [\#6249](https://github.com/ClickHouse/ClickHouse/pull/6249) ([Artem Zuikov](https://github.com/4ertus2)) +- Dikey birleştirme ve değiştirme ile atlama endeksleri için düzeltin. Fix for `Bad size of marks file` özel. [\#6594](https://github.com/ClickHouse/ClickHouse/issues/6594) [\#6713](https://github.com/ClickHouse/ClickHouse/pull/6713) ([alesapin](https://github.com/alesapin)) +- Nadir kazayı düzeltin `ALTER MODIFY COLUMN` ve birleştirilmiş/değiştirilmiş parçalardan biri boş olduğunda dikey birleştirme (0 satır) [\#6746](https://github.com/ClickHouse/ClickHouse/issues/6746) [\#6780](https://github.com/ClickHouse/ClickHouse/pull/6780) ([alesapin](https://github.com/alesapin)) +- Dönüşüm Sabit hata `LowCardinality` yazmak `AggregateFunctionFactory`. Bu düzeltmeler [\#6257](https://github.com/ClickHouse/ClickHouse/issues/6257). [\#6281](https://github.com/ClickHouse/ClickHouse/pull/6281) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Yanlış davranışı ve olası segfault'ları düzeltin `topK` ve `topKWeighted` toplu fonksiyonlar. [\#6404](https://github.com/ClickHouse/ClickHouse/pull/6404) ([Anton Popov](https://github.com/CurtizJ)) +- Sabit güvensiz kod etrafında `getIdentifier` işlev. [\#6401](https://github.com/ClickHouse/ClickHouse/issues/6401) [\#6409](https://github.com/ClickHouse/ClickHouse/pull/6409) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- MySQL Tel protokolünde Sabit hata (ClickHouse form MySQL istemcisine bağlanırken kullanılır). Yığın arabellek taşması nedeniyle `PacketPayloadWriteBuffer`. [\#6212](https://github.com/ClickHouse/ClickHouse/pull/6212) ([Yuriy Baranov](https://github.com/yurriy)) +- Sabit bellek sızıntısı `bitmapSubsetInRange` işlev. [\#6819](https://github.com/ClickHouse/ClickHouse/pull/6819) ([Zhichang Yu](https://github.com/yuzhichang)) +- Granülerlik değişiminden sonra mutasyon yürütüldüğünde nadir hatayı düzeltin. [\#6816](https://github.com/ClickHouse/ClickHouse/pull/6816) ([alesapin](https://github.com/alesapin)) +- Varsayılan olarak tüm alanlarla protobuf iletisine izin ver. [\#6132](https://github.com/ClickHouse/ClickHouse/pull/6132) ([Vitaly Baranov](https://github.com/vitlibar)) +- İle bir hatayı gidermek `nullIf` fonksiyonu zaman biz göndermek bir `NULL` ikinci argüman üzerinde argüman. [\#6446](https://github.com/ClickHouse/ClickHouse/pull/6446) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Sonsuz bellek tüketimine yol açan dize alanları ile karmaşık anahtar önbellek sözlüklerinde yanlış bellek ayırma/ayırma ile nadir hatayı düzeltin (bellek sızıntısı gibi görünüyor). Dize boyutu sekizden (8, 16, 32, vb.) başlayarak iki güç olduğunda hata çoğalır. [\#6447](https://github.com/ClickHouse/ClickHouse/pull/6447) ([alesapin](https://github.com/alesapin)) +- İstisnaya neden olan küçük dizilerde sabit goril kodlaması `Cannot write after end of buffer`. [\#6398](https://github.com/ClickHouse/ClickHouse/issues/6398) [\#6444](https://github.com/ClickHouse/ClickHouse/pull/6444) ([Vasily Nemkov](https://github.com/Enmk)) +- Birleşimlerde null olmayan türleri kullanmasına izin ver `join_use_nulls` etkin. [\#6705](https://github.com/ClickHouse/ClickHouse/pull/6705) ([Artem Zuikov](https://github.com/4ertus2)) +- Sakatlamak `Poco::AbstractConfiguration` sorguda yer değiştirmeler `clickhouse-client`. [\#6706](https://github.com/ClickHouse/ClickHouse/pull/6706) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kilitlenmeyi önlemek `REPLACE PARTITION`. [\#6677](https://github.com/ClickHouse/ClickHouse/pull/6677) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kullanım `arrayReduce` sabit argümanlar için segfault yol açabilir. [\#6242](https://github.com/ClickHouse/ClickHouse/issues/6242) [\#6326](https://github.com/ClickHouse/ClickHouse/pull/6326) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Replica sonra geri yüklenmişse görünebilecek tutarsız parçaları düzeltin `DROP PARTITION`. [\#6522](https://github.com/ClickHouse/ClickHouse/issues/6522) [\#6523](https://github.com/ClickHouse/ClickHouse/pull/6523) ([tavplubix](https://github.com/tavplubix)) +- Sabit asmak `JSONExtractRaw` işlev. [\#6195](https://github.com/ClickHouse/ClickHouse/issues/6195) [\#6198](https://github.com/ClickHouse/ClickHouse/pull/6198) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yanlış atlama endeksleri seri hale getirme ve adaptif tanecikli toplama ile hatayı düzeltin. [\#6594](https://github.com/ClickHouse/ClickHouse/issues/6594). [\#6748](https://github.com/ClickHouse/ClickHouse/pull/6748) ([alesapin](https://github.com/alesapin)) +- Düzeltmek `WITH ROLLUP` ve `WITH CUBE` değiştiriciler `GROUP BY` iki seviyeli toplama ile. [\#6225](https://github.com/ClickHouse/ClickHouse/pull/6225) ([Anton Popov](https://github.com/CurtizJ)) +- Adaptif tanecikli ikincil endeksler işaretleri yazma ile hatayı düzeltin. [\#6126](https://github.com/ClickHouse/ClickHouse/pull/6126) ([alesapin](https://github.com/alesapin)) +- Sunucu başlatma sırasında başlatma sırasını düzeltin. Beri `StorageMergeTree::background_task_handle` içinde Başlat isılmıştır `startup()` bu `MergeTreeBlockOutputStream::write()` başlatmadan önce kullanmayı deneyebilir. Eğer başlatıldı ise sadece kontrol. [\#6080](https://github.com/ClickHouse/ClickHouse/pull/6080) ([I ivanvan](https://github.com/abyss7)) +- Bir hata ile tamamlanan önceki okuma işleminden veri arabelleğini temizleme. [\#6026](https://github.com/ClickHouse/ClickHouse/pull/6026) ([Nikolay](https://github.com/bopohaa)) +- Çoğaltılan \* MergeTree tablo için yeni bir çoğaltma oluştururken adaptif taneciklik sağlayan Fix hata. [\#6394](https://github.com/ClickHouse/ClickHouse/issues/6394) [\#6452](https://github.com/ClickHouse/ClickHouse/pull/6452) ([alesapin](https://github.com/alesapin)) +- İstisna durumunda sunucu başlatma sırasında Olası kilitlenme düzeltildi `libunwind` başlatılmamış erişim sırasında istisna sırasında `ThreadStatus` yapılı. [\#6456](https://github.com/ClickHouse/ClickHouse/pull/6456) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Çökmeyi düzeltin `yandexConsistentHash` işlev. Fuzz testi ile bulundu. [\#6304](https://github.com/ClickHouse/ClickHouse/issues/6304) [\#6305](https://github.com/ClickHouse/ClickHouse/pull/6305) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sunucu aşırı ve küresel iş parçacığı havuzu tam yakın olduğunda sorguları asılı olasılığı düzeltildi. Dağıtılmış sorgular, her bir parçaya bağlantı başına bir iş parçacığı ayırdığından, çok sayıda parçaya (yüzlerce) sahip kümelerde daha yüksek şansa sahiptir. Örneğin, bir küme 330 kırıkları 30 eşzamanlı dağıtılmış sorgu işleme, bu sorun yeniden oluşturabilir. Bu sorun, 19.2'den başlayarak tüm sürümleri etkiler. [\#6301](https://github.com/ClickHouse/ClickHouse/pull/6301) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit mantık `arrayEnumerateUniqRanked` işlev. [\#6423](https://github.com/ClickHouse/ClickHouse/pull/6423) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sembol tablosunu çözerken segfault'u düzeltin. [\#6603](https://github.com/ClickHouse/ClickHouse/pull/6603) ([Amos Kuşu](https://github.com/amosbird)) +- Döküm sabit alakasız istisna `LowCardinality(Nullable)` to not-Nullable column in case if it doesn't contain Nulls (e.g. in query like `SELECT CAST(CAST('Hello' AS LowCardinality(Nullable(String))) AS String)`. [\#6094](https://github.com/ClickHouse/ClickHouse/issues/6094) [\#6119](https://github.com/ClickHouse/ClickHouse/pull/6119) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Kaldırılan ekstra açıklamadan alıntı `system.settings` Tablo. [\#6696](https://github.com/ClickHouse/ClickHouse/issues/6696) [\#6699](https://github.com/ClickHouse/ClickHouse/pull/6699) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Olası kilitlenmeyi önlemek `TRUNCATE` çoğaltılan tablonun. [\#6695](https://github.com/ClickHouse/ClickHouse/pull/6695) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Anahtarı sıralama sırasına göre okumayı düzeltin. [\#6189](https://github.com/ClickHouse/ClickHouse/pull/6189) ([Anton Popov](https://github.com/CurtizJ)) +- Düzeltmek `ALTER TABLE ... UPDATE` ile tablolar için sorgu `enable_mixed_granularity_parts=1`. [\#6543](https://github.com/ClickHouse/ClickHouse/pull/6543) ([alesapin](https://github.com/alesapin)) +- Tarafından açılan hatayı düzeltin [\#4405](https://github.com/ClickHouse/ClickHouse/pull/4405) (19.4.0'dan beri). Herhangi bir sütunu sorgulamadığımızda Mergetree tabloları üzerinden dağıtılmış tablolara sorgularda çoğaltır (`SELECT 1`). [\#6236](https://github.com/ClickHouse/ClickHouse/pull/6236) ([alesapin](https://github.com/alesapin)) +- İmzalı türün imzasız türe tamsayı bölümünde sabit taşma. Davranış tam olarak C veya C++ dilinde (tamsayı promosyon kuralları) olduğu gibi şaşırtıcı olabilir. Büyük imzalı numarayı büyük imzasız numaraya bölerken veya tam tersi durumda taşmanın hala mümkün olduğunu lütfen unutmayın (ancak bu durum daha az olağandır). Sorun tüm sunucu sürümlerinde mevcuttu. [\#6214](https://github.com/ClickHouse/ClickHouse/issues/6214) [\#6233](https://github.com/ClickHouse/ClickHouse/pull/6233) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Limit maksimum uyku süresi için kısma zaman `max_execution_speed` veya `max_execution_speed_bytes` ayar .lanmıştır. Gibi sabit yanlış hatalar `Estimated query execution time (inf seconds) is too long`. [\#5547](https://github.com/ClickHouse/ClickHouse/issues/5547) [\#6232](https://github.com/ClickHouse/ClickHouse/pull/6232) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kullanma ile ilgili sabit sorunlar `MATERIALIZED` sütunlar ve Takma adlar `MaterializedView`. [\#448](https://github.com/ClickHouse/ClickHouse/issues/448) [\#3484](https://github.com/ClickHouse/ClickHouse/issues/3484) [\#3450](https://github.com/ClickHouse/ClickHouse/issues/3450) [\#2878](https://github.com/ClickHouse/ClickHouse/issues/2878) [\#2285](https://github.com/ClickHouse/ClickHouse/issues/2285) [\#3796](https://github.com/ClickHouse/ClickHouse/pull/3796) ([Amos Kuşu](https://github.com/amosbird)) [\#6316](https://github.com/ClickHouse/ClickHouse/pull/6316) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Düzeltmek `FormatFactory` işlemci olarak uygulanmayan giriş akışları için davranış. [\#6495](https://github.com/ClickHouse/ClickHouse/pull/6495) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Sabit yazım hatası. [\#6631](https://github.com/ClickHouse/ClickHouse/pull/6631) ([Alex Ryndin](https://github.com/alexryndin)) +- Hata iletisinde yazım hatası (is -\> are ). [\#6839](https://github.com/ClickHouse/ClickHouse/pull/6839) ([Denis Zhuravlev](https://github.com/den-crane)) +- Tür bir virgül içeriyorsa, sütun listesinin dizeden ayrıştırılması sırasında hata düzeltildi (bu sorun AŞAĞIDAKİLERLE ilgiliydi `File`, `URL`, `HDFS` depolamalar) [\#6217](https://github.com/ClickHouse/ClickHouse/issues/6217). [\#6209](https://github.com/ClickHouse/ClickHouse/pull/6209) ([dimarub2000](https://github.com/dimarub2000)) + +#### Güvenlik Düzeltme {#security-fix} + +- Bu sürüm aynı zamanda 19.13 ve 19.11 tüm hata güvenlik düzeltmeleri içerir. +- SQL ayrıştırıcısında yığın taşması nedeniyle sunucu çökmesine neden olmak için fabrikasyon bir sorgu olasılığı düzeltildi. Birleştirme ve dağıtılmış tablolarda yığın taşması olasılığı, alt sorguları içeren satır düzeyinde güvenlik için somutlaştırılmış görünümler ve koşullar düzeltildi. [\#6433](https://github.com/ClickHouse/ClickHouse/pull/6433) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Geliştirme {#improvement-3} + +- İçin üçlü mantığın doğru uygulanması `AND/OR`. [\#6048](https://github.com/ClickHouse/ClickHouse/pull/6048) ([Alexander Kazakov](https://github.com/Akazz)) +- Şimdi değerler ve süresi dolmuş TTL ile satırlar sonra kaldırılacak `OPTIMIZE ... FINAL` query from old parts without TTL infos or with outdated TTL infos, e.g. after `ALTER ... MODIFY TTL` sorgu. Eklenen sorgular `SYSTEM STOP/START TTL MERGES` izin vermek/izin vermek için tüm birleştirmelerde TTL ve filtre süresi dolmuş değerleri ile birleşmeleri atayın. [\#6274](https://github.com/ClickHouse/ClickHouse/pull/6274) ([Anton Popov](https://github.com/CurtizJ)) +- Imkanı kullanarak istemci için ClickHouse geçmiş dosyasının konumunu değiştirmek için `CLICKHOUSE_HISTORY_FILE` en .v. [\#6840](https://github.com/ClickHouse/ClickHouse/pull/6840) ([filimonov](https://github.com/filimonov)) +- Kaldırmak `dry_run` 'dan bayrak `InterpreterSelectQuery`. … [\#6375](https://github.com/ClickHouse/ClickHouse/pull/6375) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Destek `ASOF JOIN` ile `ON` bölme. [\#6211](https://github.com/ClickHouse/ClickHouse/pull/6211) ([Artem Zuikov](https://github.com/4ertus2)) +- Mutasyonlar ve çoğaltma için Atlama dizinlerinin daha iyi desteği. İçin destek `MATERIALIZE/CLEAR INDEX ... IN PARTITION` sorgu. `UPDATE x = x` sütun kullanan tüm indeksleri yeniden hesaplar `x`. [\#5053](https://github.com/ClickHouse/ClickHouse/pull/5053) ([Nikita Vasilev](https://github.com/nikvas0)) +- İzin ver `ATTACH` canlı görünümler (örneğin, sunucu başlangıçta) ne olursa olsun `allow_experimental_live_view` ayar. [\#6754](https://github.com/ClickHouse/ClickHouse/pull/6754) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sorgu profiler tarafından toplanan yığın izlemeleri için sorgu profiler kendisi tarafından oluşturulan yığın çerçeveleri içermez. [\#6250](https://github.com/ClickHouse/ClickHouse/pull/6250) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Şimdi tablo fonksiyonları `values`, `file`, `url`, `hdfs` ALİAS sütunları için destek var. [\#6255](https://github.com/ClickHouse/ClickHouse/pull/6255) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Eğer bir istisna atmak `config.d` dosya, yapılandırma dosyası olarak ilgili kök öğeye sahip değildir. [\#6123](https://github.com/ClickHouse/ClickHouse/pull/6123) ([dimarub2000](https://github.com/dimarub2000)) +- İçin özel durum iletisinde ekstra bilgi Yazdır `no space left on device`. [\#6182](https://github.com/ClickHouse/ClickHouse/issues/6182), [\#6252](https://github.com/ClickHouse/ClickHouse/issues/6252) [\#6352](https://github.com/ClickHouse/ClickHouse/pull/6352) ([tavplubix](https://github.com/tavplubix)) +- Bir kırıkları belirlerken `Distributed` bir okuma sorgusu tarafından kapsanacak tablo (için `optimize_skip_unused_shards` = 1) ClickHouse şimdi her ikisinden de koşulları kontrol eder `prewhere` ve `where` select deyimi yan tümceleri. [\#6521](https://github.com/ClickHouse/ClickHouse/pull/6521) ([Alexander Kazakov](https://github.com/Akazz)) +- Etkin `SIMDJSON` avx2 olmayan ancak sse 4.2 ve PCLMUL komut seti ile makineler için. [\#6285](https://github.com/ClickHouse/ClickHouse/issues/6285) [\#6320](https://github.com/ClickHouse/ClickHouse/pull/6320) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- ClickHouse olmadan dosya sistemleri üzerinde çalışabilir `O_DIRECT` ek ayar yapmadan destek (ZFS ve BtrFS gibi). [\#4449](https://github.com/ClickHouse/ClickHouse/issues/4449) [\#6730](https://github.com/ClickHouse/ClickHouse/pull/6730) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Destek son alt sorgu için yüklemi aşağı itin. [\#6120](https://github.com/ClickHouse/ClickHouse/pull/6120) ([TCeason](https://github.com/TCeason)) [\#6162](https://github.com/ClickHouse/ClickHouse/pull/6162) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İyileştirmek `JOIN ON` anahtarlar çıkarma [\#6131](https://github.com/ClickHouse/ClickHouse/pull/6131) ([Artem Zuikov](https://github.com/4ertus2)) +- Güncel `SIMDJSON`. [\#6285](https://github.com/ClickHouse/ClickHouse/issues/6285). [\#6306](https://github.com/ClickHouse/ClickHouse/pull/6306) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İçin en küçük sütunun seçilmesini Optimize edin `SELECT count()` sorgu. [\#6344](https://github.com/ClickHouse/ClickHouse/pull/6344) ([Amos Kuşu](https://github.com/amosbird)) +- Katma `strict` param parametereter in `windowFunnel()`. Ne zaman `strict` ayarlanırsa, `windowFunnel()` yalnızca benzersiz değerler için koşulları uygular. [\#6548](https://github.com/ClickHouse/ClickHouse/pull/6548) ([achimbab](https://github.com/achimbab)) +- Daha güvenli arayüzü `mysqlxx::Pool`. [\#6150](https://github.com/ClickHouse/ClickHouse/pull/6150) ([avasiliev](https://github.com/avasiliev)) +- Seçenekler satır boyutu ile yürütülürken `--help` seçenek şimdi terminal boyutuna karşılık gelir. [\#6590](https://github.com/ClickHouse/ClickHouse/pull/6590) ([dimarub2000](https://github.com/dimarub2000)) +- Sakatlamak “read in order” anahtarsız toplama için optimizasyon. [\#6599](https://github.com/ClickHouse/ClickHouse/pull/6599) ([Anton Popov](https://github.com/CurtizJ)) +- İçin HTTP durum kodu `INCORRECT_DATA` ve `TYPE_MISMATCH` hata kodları varsayılan olarak değiştirildi `500 Internal Server Error` -e doğru `400 Bad Request`. [\#6271](https://github.com/ClickHouse/ClickHouse/pull/6271) ([Alexander Rodin](https://github.com/a-rodin)) +- Birleştirme nesnesini taşı `ExpressionAction` için `AnalyzedJoin`. `ExpressionAnalyzer` ve `ExpressionAction` hakkında bilmiyorum `Join` sınıf artık. Mantığı giz bylidir `AnalyzedJoin` ifface. [\#6801](https://github.com/ClickHouse/ClickHouse/pull/6801) ([Artem Zuikov](https://github.com/4ertus2)) +- Kırıklardan biri localhost olduğunda ancak sorgu ağ bağlantısı üzerinden gönderildiğinde dağıtılmış sorguların Olası kilitlenmesi düzeltildi. [\#6759](https://github.com/ClickHouse/ClickHouse/pull/6759) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Birden çok tablonun semantik değişti `RENAME` Olası kilitlenmeleri önlemek için. [\#6757](https://github.com/ClickHouse/ClickHouse/issues/6757). [\#6756](https://github.com/ClickHouse/ClickHouse/pull/6756) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bellekte tam paket yükü yüklenmesini önlemek için yeniden yazılan MySQL uyumluluk sunucusu. Her bağlantı için bellek tüketiminin yaklaşık olarak azalması `2 * DBMS_DEFAULT_BUFFER_SIZE` (okuma / yazma tamponları). [\#5811](https://github.com/ClickHouse/ClickHouse/pull/5811) ([Yuriy Baranov](https://github.com/yurriy)) +- Sorgu semantiği hakkında hiçbir şey bilmek zorunda olmayan ayrıştırıcıdan AST alias yorumlama mantığını taşıyın. [\#6108](https://github.com/ClickHouse/ClickHouse/pull/6108) ([Artem Zuikov](https://github.com/4ertus2)) +- Biraz daha güvenli ayrıştırma `NamesAndTypesList`. [\#6408](https://github.com/ClickHouse/ClickHouse/issues/6408). [\#6410](https://github.com/ClickHouse/ClickHouse/pull/6410) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- `clickhouse-copier`: Kullanımına izin ver `where_condition` config ile `partition_key` bölüm varlığını kontrol etmek için sorgudaki diğer ad (daha önce yalnızca veri sorgularını okumada kullanıldı). [\#6577](https://github.com/ClickHouse/ClickHouse/pull/6577) ([proller](https://github.com/proller)) +- İsteğe bağlı mesaj argümanı eklendi `throwIf`. ([\#5772](https://github.com/ClickHouse/ClickHouse/issues/5772)) [\#6329](https://github.com/ClickHouse/ClickHouse/pull/6329) ([Vdimir](https://github.com/Vdimir)) +- Ekleme verilerini gönderirken sunucu istisnası şimdi istemcide de işleniyor. [\#5891](https://github.com/ClickHouse/ClickHouse/issues/5891) [\#6711](https://github.com/ClickHouse/ClickHouse/pull/6711) ([dimarub2000](https://github.com/dimarub2000)) +- Bir metrik eklendi `DistributedFilesToInsert` bu, dağıtılmış tablolarla uzak sunuculara göndermek için seçilen dosya sistemindeki toplam dosya sayısını gösterir. Sayı tüm parçalar arasında toplanır. [\#6600](https://github.com/ClickHouse/ClickHouse/pull/6600) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Birleş ofimlerin çoğunu taşı `ExpressionAction/ExpressionAnalyzer` -e doğru `AnalyzedJoin`. [\#6785](https://github.com/ClickHouse/ClickHouse/pull/6785) ([Artem Zuikov](https://github.com/4ertus2)) +- Tsan'ı Düzeltin [uyarıcı](https://clickhouse-test-reports.s3.yandex.net/6399/c1c1d1daa98e199e620766f1bd06a5921050a00d/functional_stateful_tests_(thread).html) ‘lock-order-inversion’. [\#6740](https://github.com/ClickHouse/ClickHouse/pull/6740) ([Vasily Nemkov](https://github.com/Enmk)) +- Linux yetenekleri eksikliği hakkında daha iyi bilgi mesajları. İle önemli hataları günlüğe kaydetme “fatal” seviye, bu daha kolay bulmak için yapacak `system.text_log`. [\#6441](https://github.com/ClickHouse/ClickHouse/pull/6441) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sırasında bellek kullanımını kısıtlamak için diske geçici veri damping etkinleştirdiğinizde `GROUP BY`, `ORDER BY`, boş disk alanını kontrol etmedi. Düzeltme yeni bir ayar Ekle `min_free_disk_space`, boş disk alanı daha küçük olduğunda eşik, sorgu durur ve atar `ErrorCodes::NOT_ENOUGH_SPACE`. [\#6678](https://github.com/ClickHouse/ClickHouse/pull/6678) ([Weiqing Xu](https://github.com/weiqxu)) [\#6691](https://github.com/ClickHouse/ClickHouse/pull/6691) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İş parçacığı tarafından özyinelemeli rwlock kaldırıldı. Hiçbir anlam ifade etmiyor, çünkü iş parçacıkları sorgular arasında yeniden kullanılıyor. `SELECT` sorgu bir iş parçacığında bir kilit edinebilir, başka bir iş parçacığından bir kilit tutabilir ve ilk iş parçacığından çıkabilir. Aynı zamanda, ilk iş parçacığı tarafından yeniden kullanılabilir `DROP` sorgu. Bu yanlış yol açacaktır “Attempt to acquire exclusive lock recursively” iletiler. [\#6771](https://github.com/ClickHouse/ClickHouse/pull/6771) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bölme `ExpressionAnalyzer.appendJoin()`. Bir yer hazırlayın `ExpressionAnalyzer` için `MergeJoin`. [\#6524](https://github.com/ClickHouse/ClickHouse/pull/6524) ([Artem Zuikov](https://github.com/4ertus2)) +- Katma `mysql_native_password` MySQL uyumluluk sunucusuna kimlik doğrulama eklentisi. [\#6194](https://github.com/ClickHouse/ClickHouse/pull/6194) ([Yuriy Baranov](https://github.com/yurriy)) +- Daha az sayıda `clock_gettime` aramalar; hata ayıklama / sürüm arasındaki sabit ABİ uyumluluğu `Allocator` (önemsiz konu). [\#6197](https://github.com/ClickHouse/ClickHouse/pull/6197) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Taşınmak `collectUsedColumns` itibaren `ExpressionAnalyzer` -e doğru `SyntaxAnalyzer`. `SyntaxAnalyzer` yapıyor `required_source_columns` şimdi kendisi. [\#6416](https://github.com/ClickHouse/ClickHouse/pull/6416) ([Artem Zuikov](https://github.com/4ertus2)) +- Ayar Ekle `joined_subquery_requires_alias` alt seçimler ve tablo işlevleri için takma adlar istemek için `FROM` that more than one table is present (i.e. queries with JOINs). [\#6733](https://github.com/ClickHouse/ClickHouse/pull/6733) ([Artem Zuikov](https://github.com/4ertus2)) +- Ayıklamak `GetAggregatesVisitor` sınıf fromından `ExpressionAnalyzer`. [\#6458](https://github.com/ClickHouse/ClickHouse/pull/6458) ([Artem Zuikov](https://github.com/4ertus2)) +- `system.query_log`: veri türünü değiştir `type` sütun için `Enum`. [\#6265](https://github.com/ClickHouse/ClickHouse/pull/6265) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Statik bağlama `sha256_password` kimlik doğrulama eklentisi. [\#6512](https://github.com/ClickHouse/ClickHouse/pull/6512) ([Yuriy Baranov](https://github.com/yurriy)) +- Ayar için ekstra bağımlılıktan kaçının `compile` çalışmak. Önceki sürümlerde, kullanıcı gibi hata alabilirsiniz `cannot open crti.o`, `unable to find library -lc` vb. [\#6309](https://github.com/ClickHouse/ClickHouse/pull/6309) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kötü amaçlı kopyadan gelebilecek girdinin daha fazla doğrulaması. [\#6303](https://github.com/ClickHouse/ClickHouse/pull/6303) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Şimdi `clickhouse-obfuscator` dosya mevcuttur `clickhouse-client` paket. Önceki sürümlerde şu şekilde mevcuttu `clickhouse obfuscator` (boşluk ile). [\#5816](https://github.com/ClickHouse/ClickHouse/issues/5816) [\#6609](https://github.com/ClickHouse/ClickHouse/pull/6609) ([dimarub2000](https://github.com/dimarub2000)) +- Farklı sırayla en az iki tablo ve tablolardan birinde DDL işlemi gerçekleştiren başka bir sorgu okumak en az iki sorgu olduğunda sabit kilitlenme. Başka bir çok nadir kilitlenme düzeltildi. [\#6764](https://github.com/ClickHouse/ClickHouse/pull/6764) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Katma `os_thread_ids` sütun için `system.processes` ve `system.query_log` daha iyi hata ayıklama olanakları için. [\#6763](https://github.com/ClickHouse/ClickHouse/pull/6763) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- PHP mysqlnd uzantısı hataları için bir geçici çözüm `sha256_password` varsayılan kimlik doğrulama eklentisi olarak kullanılır ( [\#6031](https://github.com/ClickHouse/ClickHouse/issues/6031)). [\#6113](https://github.com/ClickHouse/ClickHouse/pull/6113) ([Yuriy Baranov](https://github.com/yurriy)) +- Değiştirilen nullability sütunlarıyla gereksiz yeri kaldırın. [\#6693](https://github.com/ClickHouse/ClickHouse/pull/6693) ([Artem Zuikov](https://github.com/4ertus2)) +- Set default value of `queue_max_wait_ms` sıfıra, çünkü mevcut değer (beş saniye) hiçbir anlam ifade etmiyor. Bu ayarların herhangi bir kullanımı olduğunda nadir durumlar vardır. Eklenen ayarlar `replace_running_query_max_wait_ms`, `kafka_max_wait_ms` ve `connection_pool_max_wait_ms` anlam ayrımı için. [\#6692](https://github.com/ClickHouse/ClickHouse/pull/6692) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Ayıklamak `SelectQueryExpressionAnalyzer` itibaren `ExpressionAnalyzer`. Seçilmemiş sorgular için sonuncusu tutun. [\#6499](https://github.com/ClickHouse/ClickHouse/pull/6499) ([Artem Zuikov](https://github.com/4ertus2)) +- Giriş ve çıkış formatlarını çoğaltarak kaldırıldı. [\#6239](https://github.com/ClickHouse/ClickHouse/pull/6239) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Kullanıcının geçersiz kılmasına izin ver `poll_interval` ve `idle_connection_timeout` bağlantı ayarları. [\#6230](https://github.com/ClickHouse/ClickHouse/pull/6230) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- `MergeTree` şimdi ek bir seçenek var `ttl_only_drop_parts` (varsayılan olarak devre dışı) parçaların kısmi budamasını önlemek için, böylece bir parçadaki tüm satırların süresi dolduğunda tamamen düştüler. [\#6191](https://github.com/ClickHouse/ClickHouse/pull/6191) ([Sergi Vladykin](https://github.com/svladykin)) +- Tür set dizin işlevleri için denetler. Fonksiyon yanlış bir türe sahipse istisna atın. Bu UBSan ile fuzz testini düzeltir. [\#6511](https://github.com/ClickHouse/ClickHouse/pull/6511) ([Nikita Vasilev](https://github.com/nikvas0)) + +#### Performans İyileştirme {#performance-improvement-2} + +- İle Optimize sorguları `ORDER BY expressions` fık ,ra, nerede `expressions` sıralama anahtarı ile çakışan önek var `MergeTree` Tablolar. Bu optimizasyon tarafından kontrol edilir `optimize_read_in_order` ayar. [\#6054](https://github.com/ClickHouse/ClickHouse/pull/6054) [\#6629](https://github.com/ClickHouse/ClickHouse/pull/6629) ([Anton Popov](https://github.com/CurtizJ)) +- Parça yükleme ve çıkarma sırasında birden fazla diş kullanmasına izin verin. [\#6372](https://github.com/ClickHouse/ClickHouse/issues/6372) [\#6074](https://github.com/ClickHouse/ClickHouse/issues/6074) [\#6438](https://github.com/ClickHouse/ClickHouse/pull/6438) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Toplu işlev durumlarının güncellenmesi için uygulanan toplu varyant. Performans avantaj .larına yol açabilir. [\#6435](https://github.com/ClickHouse/ClickHouse/pull/6435) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kullanım `FastOps` fonksiyonlar için kütüphane `exp`, `log`, `sigmoid`, `tanh`. FastOps Michael Parakhin (Yandex CTO) bir hızlı vektör matematik kütüphanesidir. Geliştirilmiş performans `exp` ve `log` fonksiyonları fazla 6 kez. İşlev `exp` ve `log` itibaren `Float32` argüman geri dönecek `Float32` (önceki sürümlerde her zaman geri dönerler `Float64`). Şimdi `exp(nan)` dön mayebilir `inf`. Sonucu `exp` ve `log` fonksiyonlar, gerçek cevaba en yakın makine temsil edilebilir numarası olmayabilir. [\#6254](https://github.com/ClickHouse/ClickHouse/pull/6254) ([alexey-milovidov](https://github.com/alexey-milovidov)) Fastops çalışmasını sağlamak için Danila Kutenin varyantını kullanma [\#6317](https://github.com/ClickHouse/ClickHouse/pull/6317) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Ardışık anahtar optimizasyonunu devre dışı bırak `UInt8/16`. [\#6298](https://github.com/ClickHouse/ClickHouse/pull/6298) [\#6701](https://github.com/ClickHouse/ClickHouse/pull/6701) ([akuzm](https://github.com/akuzm)) +- Geliştirilmiş performans `simdjson` içinde dinamik tahs ofis ridat ridtan Kurtul ofarak kütüphane `ParsedJson::Iterator`. [\#6479](https://github.com/ClickHouse/ClickHouse/pull/6479) ([Vitaly Baranov](https://github.com/vitlibar)) +- Bellek ayırırken ön hata sayfaları `mmap()`. [\#6667](https://github.com/ClickHouse/ClickHouse/pull/6667) ([akuzm](https://github.com/akuzm)) +- Performans hatasını düzeltin `Decimal` karşılaştırma. [\#6380](https://github.com/ClickHouse/ClickHouse/pull/6380) ([Artem Zuikov](https://github.com/4ertus2)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-4} + +- Derleyici (çalışma zamanı şablonu örneği) kaldırın, çünkü performansı kazandık. [\#6646](https://github.com/ClickHouse/ClickHouse/pull/6646) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Gcc-9'daki performansın daha izole bir şekilde bozulmasını göstermek için performans testi eklendi. [\#6302](https://github.com/ClickHouse/ClickHouse/pull/6302) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Eklenen tablo fonksiyonu `numbers_mt`, çok iş parçacıklı sürümü olan `numbers`. Karma fonksiyonları ile güncellenmiş performans testleri. [\#6554](https://github.com/ClickHouse/ClickHouse/pull/6554) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Karşılaştırma modu `clickhouse-benchmark` [\#6220](https://github.com/ClickHouse/ClickHouse/issues/6220) [\#6343](https://github.com/ClickHouse/ClickHouse/pull/6343) ([dimarub2000](https://github.com/dimarub2000)) +- Yığın izlerini yazdırmak için en iyi çaba. Ayrıca eklendi `SIGPROF` çalışan bir iş parçacığının yığın izini yazdırmak için hata ayıklama sinyali olarak. [\#6529](https://github.com/ClickHouse/ClickHouse/pull/6529) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Her fonksiyon kendi dosyasında, Bölüm 10. [\#6321](https://github.com/ClickHouse/ClickHouse/pull/6321) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İki katına çıkar const `TABLE_IS_READ_ONLY`. [\#6566](https://github.com/ClickHouse/ClickHouse/pull/6566) ([filimonov](https://github.com/filimonov)) +- İçin biçimlendirme değişiklikleri `StringHashMap` PR [\#5417](https://github.com/ClickHouse/ClickHouse/issues/5417). [\#6700](https://github.com/ClickHouse/ClickHouse/pull/6700) ([akuzm](https://github.com/akuzm)) +- Birleştirme oluşturma için daha iyi alt sorgu `ExpressionAnalyzer`. [\#6824](https://github.com/ClickHouse/ClickHouse/pull/6824) ([Artem Zuikov](https://github.com/4ertus2)) +- Gereksiz bir koşulu kaldırın (PVS Studio tarafından bulunur). [\#6775](https://github.com/ClickHouse/ClickHouse/pull/6775) ([akuzm](https://github.com/akuzm)) +- İçin karma tablo arayüzünü ayırın `ReverseIndex`. [\#6672](https://github.com/ClickHouse/ClickHouse/pull/6672) ([akuzm](https://github.com/akuzm)) +- Ayarların yeniden düzenlenmesi. [\#6689](https://github.com/ClickHouse/ClickHouse/pull/6689) ([alesapin](https://github.com/alesapin)) +- İçin yorum ekle `set` dizin fonksiyonları. [\#6319](https://github.com/ClickHouse/ClickHouse/pull/6319) ([Nikita Vasilev](https://github.com/nikvas0)) +- Linux'ta hata ayıklama sürümünde oom puanını artırın. [\#6152](https://github.com/ClickHouse/ClickHouse/pull/6152) ([akuzm](https://github.com/akuzm)) +- HDFS ha şimdi hata ayıklama yapısında çalışıyor. [\#6650](https://github.com/ClickHouse/ClickHouse/pull/6650) ([Weiqing Xu](https://github.com/weiqxu)) +- Bir test eklendi `transform_query_for_external_database`. [\#6388](https://github.com/ClickHouse/ClickHouse/pull/6388) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kafka tablosu için birden fazla somutlaştırılmış görünüm için test ekleyin. [\#6509](https://github.com/ClickHouse/ClickHouse/pull/6509) ([I ivanvan](https://github.com/abyss7)) +- Daha iyi bir yapı şeması yapın. [\#6500](https://github.com/ClickHouse/ClickHouse/pull/6500) ([I ivanvan](https://github.com/abyss7)) +- Sabit `test_external_dictionaries` kök olmayan kullanıcı altında çalıştırılması durumunda entegrasyon. [\#6507](https://github.com/ClickHouse/ClickHouse/pull/6507) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Yazılı paketlerin toplam boyutu aştığında hata çoğalır `DBMS_DEFAULT_BUFFER_SIZE`. [\#6204](https://github.com/ClickHouse/ClickHouse/pull/6204) ([Yuriy Baranov](https://github.com/yurriy)) +- İçin bir test eklendi `RENAME` tablo yarış durumu [\#6752](https://github.com/ClickHouse/ClickHouse/pull/6752) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Ayarlarda veri yarışından kaçının `KILL QUERY`. [\#6753](https://github.com/ClickHouse/ClickHouse/pull/6753) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bir önbellek sözlüğü ile hataları işlemek için entegrasyon testi ekleyin. [\#6755](https://github.com/ClickHouse/ClickHouse/pull/6755) ([Vitaly Baranov](https://github.com/vitlibar)) +- Mac OS'de elf nesne dosyalarının ayrıştırılmasını devre dışı bırakın, çünkü mantıklı değil. [\#6578](https://github.com/ClickHouse/ClickHouse/pull/6578) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Changelog jeneratörünü daha iyi hale getirmeye çalışın. [\#6327](https://github.com/ClickHouse/ClickHouse/pull/6327) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Ekleme `-Wshadow` GCC'YE geçin. [\#6325](https://github.com/ClickHouse/ClickHouse/pull/6325) ([kreuzerkrieg](https://github.com/kreuzerkrieg)) +- İçin eski kod kaldırıldı `mimalloc` destek. [\#6715](https://github.com/ClickHouse/ClickHouse/pull/6715) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- `zlib-ng` x86 yeteneklerini belirler ve bu bilgiyi genel değişkenlere kaydeder. Bu, aynı anda farklı iş parçacıkları tarafından yapılabilen defalteınit çağrısında yapılır. Çok iş parçacıklı yazılardan kaçınmak için, kitaplık başlangıcında yapın. [\#6141](https://github.com/ClickHouse/ClickHouse/pull/6141) ([akuzm](https://github.com/akuzm)) +- İçinde gider wasilen bir hata için regresyon testi [\#5192](https://github.com/ClickHouse/ClickHouse/issues/5192). [\#6147](https://github.com/ClickHouse/ClickHouse/pull/6147) ([Bakhtiyor Ruziev](https://github.com/theruziev)) +- Sabit MSan raporu. [\#6144](https://github.com/ClickHouse/ClickHouse/pull/6144) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Düzeltme çırparak TTL testi. [\#6782](https://github.com/ClickHouse/ClickHouse/pull/6782) ([Anton Popov](https://github.com/CurtizJ)) +- Sabit yanlış veri yarışı `MergeTreeDataPart::is_frozen` alan. [\#6583](https://github.com/ClickHouse/ClickHouse/pull/6583) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Fuzz testinde sabit zaman aşımları. Önceki sürümde, sorguda yanlış hangup bulmayı başardı `SELECT * FROM numbers_mt(gccMurmurHash(''))`. [\#6582](https://github.com/ClickHouse/ClickHouse/pull/6582) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Hata ayıklama kontrolleri eklendi `static_cast` sütunların. [\#6581](https://github.com/ClickHouse/ClickHouse/pull/6581) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Resmi RPM paketlerinde Oracle Linux için destek. [\#6356](https://github.com/ClickHouse/ClickHouse/issues/6356) [\#6585](https://github.com/ClickHouse/ClickHouse/pull/6585) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Değiştirilen json perftests `once` -e doğru `loop` tür. [\#6536](https://github.com/ClickHouse/ClickHouse/pull/6536) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- `odbc-bridge.cpp` tanımlıyor `main()` bu yüzden dahil edilmemelidir `clickhouse-lib`. [\#6538](https://github.com/ClickHouse/ClickHouse/pull/6538) ([Orivej Desh](https://github.com/orivej)) +- Çarpışma testi `FULL|RIGHT JOIN` sağ tablonun tuşlarında boş alanlar var. [\#6362](https://github.com/ClickHouse/ClickHouse/pull/6362) ([Artem Zuikov](https://github.com/4ertus2)) +- Her ihtimale karşı takma adların genişletilmesiyle ilgili sınır için bir test eklendi. [\#6442](https://github.com/ClickHouse/ClickHouse/pull/6442) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Anahtar fromlı `boost::filesystem` -e doğru `std::filesystem` uygun olan yerlerde. [\#6253](https://github.com/ClickHouse/ClickHouse/pull/6253) [\#6385](https://github.com/ClickHouse/ClickHouse/pull/6385) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Web sitesine RPM paketleri eklendi. [\#6251](https://github.com/ClickHouse/ClickHouse/pull/6251) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit için bir test Ekle `Unknown identifier` istisna içinde `IN` bölme. [\#6708](https://github.com/ClickHouse/ClickHouse/pull/6708) ([Artem Zuikov](https://github.com/4ertus2)) +- Basitleştirmek `shared_ptr_helper` çünkü insanlar bunu anlamakta zorluk çekiyorlar. [\#6675](https://github.com/ClickHouse/ClickHouse/pull/6675) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit Gorilla ve DoubleDelta codec için performans testleri eklendi. [\#6179](https://github.com/ClickHouse/ClickHouse/pull/6179) ([Vasily Nemkov](https://github.com/Enmk)) +- Entegrasyon testini bölün `test_dictionaries` 4 ayrı test içine. [\#6776](https://github.com/ClickHouse/ClickHouse/pull/6776) ([Vitaly Baranov](https://github.com/vitlibar)) +- Pvs-Studio uyarısını düzeltin `PipelineExecutor`. [\#6777](https://github.com/ClickHouse/ClickHouse/pull/6777) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Kullanmasına izin ver `library` asan ile sözlük kaynağı. [\#6482](https://github.com/ClickHouse/ClickHouse/pull/6482) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- PRs listesinden changelog oluşturmak için seçenek eklendi. [\#6350](https://github.com/ClickHouse/ClickHouse/pull/6350) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Lock the `TinyLog` depolama okurken. [\#6226](https://github.com/ClickHouse/ClickHouse/pull/6226) ([akuzm](https://github.com/akuzm)) +- CI kırık symlinks için kontrol edin. [\#6634](https://github.com/ClickHouse/ClickHouse/pull/6634) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İçin zaman aşımını artırın “stack overflow” hata ayıklama yapı uzun zaman alabilir, çünkü sınayın. [\#6637](https://github.com/ClickHouse/ClickHouse/pull/6637) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Çift whitespaces için bir çek eklendi. [\#6643](https://github.com/ClickHouse/ClickHouse/pull/6643) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Düzeltmek `new/delete` bellek izleme zaman sanitizers ile inşa. İzleme net değil. Sadece testlerde bellek sınırı istisnalarını önler. [\#6450](https://github.com/ClickHouse/ClickHouse/pull/6450) ([Artem Zuikov](https://github.com/4ertus2)) +- Bağlantı sırasında tanımlanmamış sembollerin kontrolünü geri etkinleştirin. [\#6453](https://github.com/ClickHouse/ClickHouse/pull/6453) ([I ivanvan](https://github.com/abyss7)) +- Yeniden inşa etmekten kaçının `hyperscan` hergün. [\#6307](https://github.com/ClickHouse/ClickHouse/pull/6307) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit UBSan raporu `ProtobufWriter`. [\#6163](https://github.com/ClickHouse/ClickHouse/pull/6163) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Uyumlu olmadığı için sanitizers ile sorgu profiler kullanmak için izin vermeyin. [\#6769](https://github.com/ClickHouse/ClickHouse/pull/6769) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Zamanlayıcı tarafından başarısız olduktan sonra bir sözlüğü yeniden yüklemek için test ekleyin. [\#6114](https://github.com/ClickHouse/ClickHouse/pull/6114) ([Vitaly Baranov](https://github.com/vitlibar)) +- Tutarsızlığı düzeltin `PipelineExecutor::prepareProcessor` argüman türü. [\#6494](https://github.com/ClickHouse/ClickHouse/pull/6494) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Kötü Urı'ler için bir test eklendi. [\#6493](https://github.com/ClickHouse/ClickHouse/pull/6493) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Daha fazla kontrol eklendi `CAST` işlev. Bu, bulanık testte segmentasyon hatası hakkında daha fazla bilgi almalıdır. [\#6346](https://github.com/ClickHouse/ClickHouse/pull/6346) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Katma `gcc-9` güçlendirmek `docker/builder` yerel olarak görüntü oluşturan konteyner. [\#6333](https://github.com/ClickHouse/ClickHouse/pull/6333) ([Gleb Novikov](https://github.com/NanoBjorn)) +- Birincil anahtar için Test `LowCardinality(String)`. [\#5044](https://github.com/ClickHouse/ClickHouse/issues/5044) [\#6219](https://github.com/ClickHouse/ClickHouse/pull/6219) ([dimarub2000](https://github.com/dimarub2000)) +- Yavaş yığın izleri yazdırma etkilenen sabit testler. [\#6315](https://github.com/ClickHouse/ClickHouse/pull/6315) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kilitlenme için bir test durumu ekleyin `groupUniqArray` sabit içinde [\#6029](https://github.com/ClickHouse/ClickHouse/pull/6029). [\#4402](https://github.com/ClickHouse/ClickHouse/issues/4402) [\#6129](https://github.com/ClickHouse/ClickHouse/pull/6129) ([akuzm](https://github.com/akuzm)) +- Sabit endeks mutasyonlar testleri. [\#6645](https://github.com/ClickHouse/ClickHouse/pull/6645) ([Nikita Vasilev](https://github.com/nikvas0)) +- Performans testinde, çalıştırmadığımız sorgular için sorgu günlüğünü okuma. [\#6427](https://github.com/ClickHouse/ClickHouse/pull/6427) ([akuzm](https://github.com/akuzm)) +- Materialized görünüm şimdi şüpheli düşük kardinalite türleri hakkında ayar ne olursa olsun herhangi bir düşük kardinalite türleri ile oluşturulabilir. [\#6428](https://github.com/ClickHouse/ClickHouse/pull/6428) ([Olga Khvostikova](https://github.com/stavrolia)) +- İçin güncel testslenmiş testler `send_logs_level` ayar. [\#6207](https://github.com/ClickHouse/ClickHouse/pull/6207) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Gcc-8.2 altında yapı düzeltin. [\#6196](https://github.com/ClickHouse/ClickHouse/pull/6196) ([Max Akhmedov](https://github.com/zlobober)) +- Dahili libc++ile yapı düzeltin. [\#6724](https://github.com/ClickHouse/ClickHouse/pull/6724) ([I ivanvan](https://github.com/abyss7)) +- Paylaşılan yapıyı düzeltin `rdkafka` kitaplık [\#6101](https://github.com/ClickHouse/ClickHouse/pull/6101) ([I ivanvan](https://github.com/abyss7)) +- Mac OS build için düzeltmeler (eksik). [\#6390](https://github.com/ClickHouse/ClickHouse/pull/6390) ([alexey-milovidov](https://github.com/alexey-milovidov)) [\#6429](https://github.com/ClickHouse/ClickHouse/pull/6429) ([alex-zaitsev](https://github.com/alex-zaitsev)) +- Düzeltmek “splitted” yapmak. [\#6618](https://github.com/ClickHouse/ClickHouse/pull/6618) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Diğer yapı düzeltmeleri: [\#6186](https://github.com/ClickHouse/ClickHouse/pull/6186) ([Amos Kuşu](https://github.com/amosbird)) [\#6486](https://github.com/ClickHouse/ClickHouse/pull/6486) [\#6348](https://github.com/ClickHouse/ClickHouse/pull/6348) ([vxider](https://github.com/Vxider)) [\#6744](https://github.com/ClickHouse/ClickHouse/pull/6744) ([I ivanvan](https://github.com/abyss7)) [\#6016](https://github.com/ClickHouse/ClickHouse/pull/6016) [\#6421](https://github.com/ClickHouse/ClickHouse/pull/6421) [\#6491](https://github.com/ClickHouse/ClickHouse/pull/6491) ([proller](https://github.com/proller)) + +#### Geriye Dönük Uyumsuz Değişim {#backward-incompatible-change-3} + +- Kaldırıldı nadiren kullanılan tablo fonksiyonu `catBoostPool` ve depolama `CatBoostPool`. Bu tablo işlevini kullandıysanız, lütfen e-posta yazınız `clickhouse-feedback@yandex-team.com`. CatBoost entegrasyonunun devam ettiğini ve destekleneceğini unutmayın. [\#6279](https://github.com/ClickHouse/ClickHouse/pull/6279) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sakatlamak `ANY RIGHT JOIN` ve `ANY FULL JOIN` varsayılan olarak. Koymak `any_join_distinct_right_table_keys` bunları etkinleştirmek için ayarlama. [\#5126](https://github.com/ClickHouse/ClickHouse/issues/5126) [\#6351](https://github.com/ClickHouse/ClickHouse/pull/6351) ([Artem Zuikov](https://github.com/4ertus2)) + +## ClickHouse sürümü 19.13 {#clickhouse-release-19-13} + +### ClickHouse sürümü 19.13.6.51, 2019-10-02 {#clickhouse-release-19-13-6-51-2019-10-02} + +#### Hata Düzeltme {#bug-fix-9} + +- Bu sürüm aynı zamanda 19.11.12.69 tüm hata düzeltmeleri içerir. + +### ClickHouse sürümü 19.13.5.44, 2019-09-20 {#clickhouse-release-19-13-5-44-2019-09-20} + +#### Hata Düzeltme {#bug-fix-10} + +- Bu sürüm aynı zamanda 19.14.6.12 tüm hata düzeltmeleri içerir. +- Yürütülürken tablonun Olası tutarsız durumu düzeltildi `DROP` zookeeper erişilebilir değilken çoğaltılmış tablo için sorgu. [\#6045](https://github.com/ClickHouse/ClickHouse/issues/6045) [\#6413](https://github.com/ClickHouse/ClickHouse/pull/6413) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Storagemerge'de veri yarışı için düzeltme [\#6717](https://github.com/ClickHouse/ClickHouse/pull/6717) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Soketten sonsuz recv yol açar sorgu profiler tanıtılan Fix hata. [\#6386](https://github.com/ClickHouse/ClickHouse/pull/6386) ([alesapin](https://github.com/alesapin)) +- Çalışırken aşırı CPU kullanımını düzeltin `JSONExtractRaw` bir Boole değeri üzerinde işlev. [\#6208](https://github.com/ClickHouse/ClickHouse/pull/6208) ([Vitaly Baranov](https://github.com/vitlibar)) +- Gerçekleşmiş görünüme iterken gerilemeyi düzeltir. [\#6415](https://github.com/ClickHouse/ClickHouse/pull/6415) ([I ivanvan](https://github.com/abyss7)) +- Tablo fonksiyonu `url` güvenlik açığı saldırganın istekte rasgele HTTP üstbilgileri enjekte etmesine izin vermişti. Bu konu tarafından bulundu [Nikita Tikhomirov](https://github.com/NSTikhomirov). [\#6466](https://github.com/ClickHouse/ClickHouse/pull/6466) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İşe yaramaz düzeltmek `AST` set dizini kontrol edin. [\#6510](https://github.com/ClickHouse/ClickHouse/issues/6510) [\#6651](https://github.com/ClickHouse/ClickHouse/pull/6651) ([Nikita Vasilev](https://github.com/nikvas0)) +- Sabit ayrıştırma `AggregateFunction` sorguya gömülü değerler. [\#6575](https://github.com/ClickHouse/ClickHouse/issues/6575) [\#6773](https://github.com/ClickHouse/ClickHouse/pull/6773) ([Zhichang Yu](https://github.com/yuzhichang)) +- Sabit yanlış davranış `trim` fonksiyonlar aile. [\#6647](https://github.com/ClickHouse/ClickHouse/pull/6647) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse sürümü 19.13.4.32, 2019-09-10 {#clickhouse-release-19-13-4-32-2019-09-10} + +#### Hata Düzeltme {#bug-fix-11} + +- Bu sürüm aynı zamanda 19.11.9.52 ve 19.11.10.54 tüm hata güvenlik düzeltmeleri içerir. +- Sabit veri yarışı `system.parts` masa ve `ALTER` sorgu. [\#6245](https://github.com/ClickHouse/ClickHouse/issues/6245) [\#6513](https://github.com/ClickHouse/ClickHouse/pull/6513) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Akışlarda sabit eşleşmeyen başlık, örnek ve prewhere ile boş dağıtılmış tablodan okuma durumunda oldu. [\#6167](https://github.com/ClickHouse/ClickHouse/issues/6167) ([Lixiang Qian](https://github.com/fancyqlx)) [\#6823](https://github.com/ClickHouse/ClickHouse/pull/6823) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Kullanırken sabit çökme `IN` bir tuple ile bir alt sorgu ile yan tümce. [\#6125](https://github.com/ClickHouse/ClickHouse/issues/6125) [\#6550](https://github.com/ClickHouse/ClickHouse/pull/6550) ([tavplubix](https://github.com/tavplubix)) +- Aynı sütun adlarıyla durumu düzeltin `GLOBAL JOIN ON` bölme. [\#6181](https://github.com/ClickHouse/ClickHouse/pull/6181) ([Artem Zuikov](https://github.com/4ertus2)) +- Türleri döküm yaparken çökmeyi düzeltin `Decimal` bu onu desteklemiyor. Bunun yerine istisna atın. [\#6297](https://github.com/ClickHouse/ClickHouse/pull/6297) ([Artem Zuikov](https://github.com/4ertus2)) +- Sabit çökme `extractAll()` işlev. [\#6644](https://github.com/ClickHouse/ClickHouse/pull/6644) ([Artem Zuikov](https://github.com/4ertus2)) +- İçin sorgu dönüşümü `MySQL`, `ODBC`, `JDBC` tablo işlevleri artık düzgün çalışıyor `SELECT WHERE` birden fazla sorgu `AND` ifadeler. [\#6381](https://github.com/ClickHouse/ClickHouse/issues/6381) [\#6676](https://github.com/ClickHouse/ClickHouse/pull/6676) ([dimarub2000](https://github.com/dimarub2000)) +- MySQL 8 entegrasyonu için önceki beyan kontrolleri eklendi. [\#6569](https://github.com/ClickHouse/ClickHouse/pull/6569) ([Rafael David Tinoco](https://github.com/rafaeldtinoco)) + +#### Güvenlik Düzeltme {#security-fix-1} + +- Dekompresyon aşamasında kodeklerdeki iki güvenlik açığını düzeltin (kötü niyetli kullanıcı, dekompresyonda tampon taşmasına yol açacak sıkıştırılmış verileri üretebilir). [\#6670](https://github.com/ClickHouse/ClickHouse/pull/6670) ([Artem Zuikov](https://github.com/4ertus2)) + +### ClickHouse sürümü 19.13.3.26, 2019-08-22 {#clickhouse-release-19-13-3-26-2019-08-22} + +#### Hata Düzeltme {#bug-fix-12} + +- Düzeltmek `ALTER TABLE ... UPDATE` ile tablolar için sorgu `enable_mixed_granularity_parts=1`. [\#6543](https://github.com/ClickHouse/ClickHouse/pull/6543) ([alesapin](https://github.com/alesapin)) +- Bir tuple ile bir alt sorgu ile yan tümcesinde kullanırken npe düzeltin. [\#6125](https://github.com/ClickHouse/ClickHouse/issues/6125) [\#6550](https://github.com/ClickHouse/ClickHouse/pull/6550) ([tavplubix](https://github.com/tavplubix)) +- Eski bir kopya canlı hale gelirse, yine de açılan bölüm tarafından kaldırılan veri parçalarına sahip olabileceği sorunu düzeltildi. [\#6522](https://github.com/ClickHouse/ClickHouse/issues/6522) [\#6523](https://github.com/ClickHouse/ClickHouse/pull/6523) ([tavplubix](https://github.com/tavplubix)) +- CSV ayrıştırma ile ilgili sorun giderildi [\#6426](https://github.com/ClickHouse/ClickHouse/issues/6426) [\#6559](https://github.com/ClickHouse/ClickHouse/pull/6559) ([tavplubix](https://github.com/tavplubix)) +- Sistemde sabit veri yarışı.parçalar tablo ve alter sorgu. Bu düzeltmeler [\#6245](https://github.com/ClickHouse/ClickHouse/issues/6245). [\#6513](https://github.com/ClickHouse/ClickHouse/pull/6513) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bellek bozulmasına yol açabilecek mutasyonlarda yanlış kod düzeltildi. Adresin okunması ile sabit segfault `0x14c0` bu eşzamanlı nedeniyle happed olabilir `DROP TABLE` ve `SELECT` itibaren `system.parts` veya `system.parts_columns`. Mutasyon sorgularının hazırlanmasında sabit yarış durumu. Sabit kilitlenme neden `OPTIMIZE` çoğaltılmış tablolar ve değiştirir gibi eşzamanlı değişiklik işlemleri. [\#6514](https://github.com/ClickHouse/ClickHouse/pull/6514) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sonra sabit olası veri kaybı `ALTER DELETE` tabloda dizin atlama ile sorgu. [\#6224](https://github.com/ClickHouse/ClickHouse/issues/6224) [\#6282](https://github.com/ClickHouse/ClickHouse/pull/6282) ([Nikita Vasilev](https://github.com/nikvas0)) + +#### Güvenlik Düzeltme {#security-fix-2} + +- Saldırganın Zookeeper'a yazma erişimi varsa ve Clickhouse'un çalıştığı ağdan kullanılabilen özel sunucuyu çalıştırabiliyorsa, ClickHouse replica olarak hareket edecek ve Zookeeper'a kaydedecek özel olarak oluşturulmuş kötü amaçlı sunucu oluşturabilir. Başka bir çoğaltma, kötü amaçlı kopyadan veri bölümünü getirdiğinde, clickhouse-Server'ı dosya sistemindeki keyfi yola yazmaya zorlayabilir. Yandex'teki bilgi güvenliği ekibi Eldar Zaitov tarafından bulundu. [\#6247](https://github.com/ClickHouse/ClickHouse/pull/6247) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse sürümü 19.13.2.19, 2019-08-14 {#clickhouse-release-19-13-2-19-2019-08-14} + +#### Yenilik {#new-feature-5} + +- Sorgu düzeyinde örnekleme profiler. [Örnek](https://gist.github.com/alexey-milovidov/92758583dd41c24c360fdb8d6a4da194). [\#4247](https://github.com/ClickHouse/ClickHouse/issues/4247) ([laplab](https://github.com/laplab)) [\#6124](https://github.com/ClickHouse/ClickHouse/pull/6124) ([alexey-milovidov](https://github.com/alexey-milovidov)) [\#6250](https://github.com/ClickHouse/ClickHouse/pull/6250) [\#6283](https://github.com/ClickHouse/ClickHouse/pull/6283) [\#6386](https://github.com/ClickHouse/ClickHouse/pull/6386) +- Sütunların bir listesini belirtmek için izin ver `COLUMNS('regexp')` daha sofistike bir varyantı gibi çalışan ifade `*` Yıldız işareti. [\#5951](https://github.com/ClickHouse/ClickHouse/pull/5951) ([mfridental](https://github.com/mfridental)), ([alexey-milovidov](https://github.com/alexey-milovidov)) +- `CREATE TABLE AS table_function()` artık mümkün [\#6057](https://github.com/ClickHouse/ClickHouse/pull/6057) ([dimarub2000](https://github.com/dimarub2000)) +- Stokastik Gradyan iniş için Adam optimizer varsayılan olarak kullanılır `stochasticLinearRegression()` ve `stochasticLogisticRegression()` agrega fonksiyonları, çünkü neredeyse herhangi bir ayar yapmadan iyi kalite gösterir. [\#6000](https://github.com/ClickHouse/ClickHouse/pull/6000) ([Quid37](https://github.com/Quid37)) +- Added functions for working with the сustom week number [\#5212](https://github.com/ClickHouse/ClickHouse/pull/5212) ([Andy Yang](https://github.com/andyyzh)) +- `RENAME` sorgular artık tüm depolarla çalışır. [\#5953](https://github.com/ClickHouse/ClickHouse/pull/5953) ([I ivanvan](https://github.com/abyss7)) +- Şimdi istemci ayarlayarak istenilen düzeyde sunucudan günlükleri almak `send_logs_level` sunucu ayarlarında belirtilen günlük düzeyine bakılmaksızın. [\#5964](https://github.com/ClickHouse/ClickHouse/pull/5964) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) + +#### Geriye Dönük Uyumsuz Değişim {#backward-incompatible-change-4} + +- Ayar `input_format_defaults_for_omitted_fields` varsayılan olarak etkinleştirilir. Dağıtılmış tablolardaki ekler bu ayarın kümede aynı olması gerekir (güncellemeyi çalıştırmadan önce ayarlamanız gerekir). Atlanmış alanlar için karmaşık varsayılan ifadelerin hesaplanmasını sağlar `JSONEachRow` ve `CSV*` biçimliler. Beklenen davranış olmalı, ancak ihmal edilebilir performans farkına yol açabilir. [\#6043](https://github.com/ClickHouse/ClickHouse/pull/6043) ([Artem Zuikov](https://github.com/4ertus2)), [\#5625](https://github.com/ClickHouse/ClickHouse/pull/5625) ([akuzm](https://github.com/akuzm)) + +#### Deneysel özellikler {#experimental-features} + +- Yeni sorgu işleme boru hattı. Kullanmak `experimental_use_processors=1` etkinleştirmek için Seçenek. Kendi sorun için kullanın. [\#4914](https://github.com/ClickHouse/ClickHouse/pull/4914) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) + +#### Hata Düzeltme {#bug-fix-13} + +- Kafka entegrasyonu bu sürümde düzeltildi. +- Sabit `DoubleDelta` kodlama `Int64` büyük için `DoubleDelta` değerler, geliştirilmiş `DoubleDelta` rastgele veri için kodlama `Int32`. [\#5998](https://github.com/ClickHouse/ClickHouse/pull/5998) ([Vasily Nemkov](https://github.com/Enmk)) +- Sabit aşırı tahmin `max_rows_to_read` eğer ayar `merge_tree_uniform_read_distribution` 0 olarak ayarlanır. [\#6019](https://github.com/ClickHouse/ClickHouse/pull/6019) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Geliştirme {#improvement-4} + +- Eğer bir istisna atar `config.d` dosya, yapılandırma dosyası olarak ilgili kök öğeye sahip değil [\#6123](https://github.com/ClickHouse/ClickHouse/pull/6123) ([dimarub2000](https://github.com/dimarub2000)) + +#### Performans İyileştirme {#performance-improvement-3} + +- Getirmek `count()`. Şimdi en küçük sütunu kullanır (mümkünse). [\#6028](https://github.com/ClickHouse/ClickHouse/pull/6028) ([Amos Kuşu](https://github.com/amosbird)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-5} + +- Performans testlerinde bellek kullanımını bildirin. [\#5899](https://github.com/ClickHouse/ClickHouse/pull/5899) ([akuzm](https://github.com/akuzm)) +- Harici yapı ile Düzeltme `libcxx` [\#6010](https://github.com/ClickHouse/ClickHouse/pull/6010) ([I ivanvan](https://github.com/abyss7)) +- Paylaşılan yapıyı düzeltin `rdkafka` kitaplık [\#6101](https://github.com/ClickHouse/ClickHouse/pull/6101) ([I ivanvan](https://github.com/abyss7)) + +## ClickHouse yayın 19.11 {#clickhouse-release-19-11} + +### ClickHouse sürümü 19.11.13.74, 2019-11-01 {#clickhouse-release-19-11-13-74-2019-11-01} + +#### Hata Düzeltme {#bug-fix-14} + +- Sabit nadir kazasında `ALTER MODIFY COLUMN` ve birleştirilmiş/değiştirilmiş parçalardan biri boş olduğunda dikey birleştirme (0 satır). [\#6780](https://github.com/ClickHouse/ClickHouse/pull/6780) ([alesapin](https://github.com/alesapin)) +- Manuel güncelleme `SIMDJSON`. Bu sahte json teşhis mesajları ile stderr dosyalarının Olası sel giderir. [\#7548](https://github.com/ClickHouse/ClickHouse/pull/7548) ([Alexander Kazakov](https://github.com/Akazz)) +- Sabit hata ile `mrk` Mut fileasyonlar için dosya uzantısı ([alesapin](https://github.com/alesapin)) + +### ClickHouse yayın 19.11.12.69, 2019-10-02 {#clickhouse-release-19-11-12-69-2019-10-02} + +#### Hata Düzeltme {#bug-fix-15} + +- Büyük tablolarda karmaşık anahtarlar üzerinde endeks analizi sabit performans düşüşü. Bu düzeltmeler [\#6924](https://github.com/ClickHouse/ClickHouse/issues/6924). [\#7075](https://github.com/ClickHouse/ClickHouse/pull/7075) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Dağıtılmış motorlu tablolarda veri gönderirken nadir SIGSEGV'DEN kaçının (`Failed to send batch: file with index XXXXX is absent`). [\#7032](https://github.com/ClickHouse/ClickHouse/pull/7032) ([Azat Khuzhin](https://github.com/azat)) +- Düzeltmek `Unknown identifier` birden fazla birleşim ile. Bu düzeltmeler [\#5254](https://github.com/ClickHouse/ClickHouse/issues/5254). [\#7022](https://github.com/ClickHouse/ClickHouse/pull/7022) ([Artem Zuikov](https://github.com/4ertus2)) + +### ClickHouse sürümü 19.11.11.57, 2019-09-13 {#clickhouse-release-19-11-11-57-2019-09-13} + +- Kafka boş konudan seçerken segfaults'a neden olan mantıksal hatayı düzeltin. [\#6902](https://github.com/ClickHouse/ClickHouse/issues/6902) [\#6909](https://github.com/ClickHouse/ClickHouse/pull/6909) ([I ivanvan](https://github.com/abyss7)) +- Fonksiyon için düzeltme `АrrayEnumerateUniqRanked` params boş diziler ile. [\#6928](https://github.com/ClickHouse/ClickHouse/pull/6928) ([proller](https://github.com/proller)) + +### ClickHouse sürümü 19.11.10.54, 2019-09-10 {#clickhouse-release-19-11-10-54-2019-09-10} + +#### Hata Düzeltme {#bug-fix-16} + +- Tüm bölümler için hepsini bir kerede işlemek için Kafka mesajları için uzaklıkları manuel olarak saklayın. Potansiyel çoğaltmayı giderir “one consumer - many partitions” senaryo. [\#6872](https://github.com/ClickHouse/ClickHouse/pull/6872) ([I ivanvan](https://github.com/abyss7)) + +### ClickHouse yayın 19.11.9.52, 2019-09-6 {#clickhouse-release-19-11-9-52-2019-09-6} + +- Önbellek sözlüklerde hata işleme geliştirin. [\#6737](https://github.com/ClickHouse/ClickHouse/pull/6737) ([Vitaly Baranov](https://github.com/vitlibar)) +- Fonksiyonu Sabit hata `arrayEnumerateUniqRanked`. [\#6779](https://github.com/ClickHouse/ClickHouse/pull/6779) ([proller](https://github.com/proller)) +- Düzeltmek `JSONExtract` bir ayıklarken işlev `Tuple` JSON dan. [\#6718](https://github.com/ClickHouse/ClickHouse/pull/6718) ([Vitaly Baranov](https://github.com/vitlibar)) +- Sonra sabit olası veri kaybı `ALTER DELETE` tabloda dizin atlama ile sorgu. [\#6224](https://github.com/ClickHouse/ClickHouse/issues/6224) [\#6282](https://github.com/ClickHouse/ClickHouse/pull/6282) ([Nikita Vasilev](https://github.com/nikvas0)) +- Sabit performans testi. [\#6392](https://github.com/ClickHouse/ClickHouse/pull/6392) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Parke: Boolean sütunlarını okumayı düzeltin. [\#6579](https://github.com/ClickHouse/ClickHouse/pull/6579) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit yanlış davranış `nullIf` sabit argümanlar için işlev. [\#6518](https://github.com/ClickHouse/ClickHouse/pull/6518) ([Guillaume Tassery](https://github.com/YiuRULE)) [\#6580](https://github.com/ClickHouse/ClickHouse/pull/6580) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Normal sunucu yeniden başlatmada Kafka mesajları çoğaltma sorununu düzeltin. [\#6597](https://github.com/ClickHouse/ClickHouse/pull/6597) ([I ivanvan](https://github.com/abyss7)) +- Uzun zaman bir sorun düzeltildi `ALTER UPDATE` veya `ALTER DELETE` düzenli birleştirmelerin çalışmasını engelleyebilir. Yeterli boş iş parçacığı yoksa mutasyonların yürütülmesini önleyin. [\#6502](https://github.com/ClickHouse/ClickHouse/issues/6502) [\#6617](https://github.com/ClickHouse/ClickHouse/pull/6617) ([tavplubix](https://github.com/tavplubix)) +- İşleme ile Sabit hata “timezone” sunucu yapılandırma dosyasında. [\#6709](https://github.com/ClickHouse/ClickHouse/pull/6709) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kafka testlerini düzeltin. [\#6805](https://github.com/ClickHouse/ClickHouse/pull/6805) ([I ivanvan](https://github.com/abyss7)) + +#### Güvenlik Düzeltme {#security-fix-3} + +- Saldırganın Zookeeper'a yazma erişimi varsa ve Clickhouse'un çalıştığı ağdan kullanılabilen özel sunucuyu çalıştırabiliyorsa, ClickHouse replica olarak hareket edecek ve Zookeeper'a kaydedecek özel olarak oluşturulmuş kötü amaçlı sunucu oluşturabilir. Başka bir çoğaltma, kötü amaçlı kopyadan veri bölümünü getirdiğinde, clickhouse-Server'ı dosya sistemindeki keyfi yola yazmaya zorlayabilir. Yandex'teki bilgi güvenliği ekibi Eldar Zaitov tarafından bulundu. [\#6247](https://github.com/ClickHouse/ClickHouse/pull/6247) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse sürümü 19.11.8.46, 2019-08-22 {#clickhouse-release-19-11-8-46-2019-08-22} + +#### Hata Düzeltme {#bug-fix-17} + +- Düzeltmek `ALTER TABLE ... UPDATE` ile tablolar için sorgu `enable_mixed_granularity_parts=1`. [\#6543](https://github.com/ClickHouse/ClickHouse/pull/6543) ([alesapin](https://github.com/alesapin)) +- Bir tuple ile bir alt sorgu ile yan tümcesinde kullanırken npe düzeltin. [\#6125](https://github.com/ClickHouse/ClickHouse/issues/6125) [\#6550](https://github.com/ClickHouse/ClickHouse/pull/6550) ([tavplubix](https://github.com/tavplubix)) +- Eski bir kopya canlı hale gelirse, yine de açılan bölüm tarafından kaldırılan veri parçalarına sahip olabileceği sorunu düzeltildi. [\#6522](https://github.com/ClickHouse/ClickHouse/issues/6522) [\#6523](https://github.com/ClickHouse/ClickHouse/pull/6523) ([tavplubix](https://github.com/tavplubix)) +- CSV ayrıştırma ile ilgili sorun giderildi [\#6426](https://github.com/ClickHouse/ClickHouse/issues/6426) [\#6559](https://github.com/ClickHouse/ClickHouse/pull/6559) ([tavplubix](https://github.com/tavplubix)) +- Sistemde sabit veri yarışı.parçalar tablo ve alter sorgu. Bu düzeltmeler [\#6245](https://github.com/ClickHouse/ClickHouse/issues/6245). [\#6513](https://github.com/ClickHouse/ClickHouse/pull/6513) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bellek bozulmasına yol açabilecek mutasyonlarda yanlış kod düzeltildi. Adresin okunması ile sabit segfault `0x14c0` bu eşzamanlı nedeniyle happed olabilir `DROP TABLE` ve `SELECT` itibaren `system.parts` veya `system.parts_columns`. Mutasyon sorgularının hazırlanmasında sabit yarış durumu. Sabit kilitlenme neden `OPTIMIZE` çoğaltılmış tablolar ve değiştirir gibi eşzamanlı değişiklik işlemleri. [\#6514](https://github.com/ClickHouse/ClickHouse/pull/6514) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse sürümü 19.11.7.40, 2019-08-14 {#clickhouse-release-19-11-7-40-2019-08-14} + +#### Hata düzeltme {#bug-fix-18} + +- Kafka entegrasyonu bu sürümde düzeltildi. +- Kullanırken segfault'u düzeltin `arrayReduce` sürekli argümanlar için. [\#6326](https://github.com/ClickHouse/ClickHouse/pull/6326) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit `toFloat()` Monotonluk. [\#6374](https://github.com/ClickHouse/ClickHouse/pull/6374) ([dimarub2000](https://github.com/dimarub2000)) +- Etkin olan segfault'u düzeltin `optimize_skip_unused_shards` ve kayıp sharding anahtarı. [\#6384](https://github.com/ClickHouse/ClickHouse/pull/6384) ([CurtizJ](https://github.com/CurtizJ)) +- Sabit mantık `arrayEnumerateUniqRanked` işlev. [\#6423](https://github.com/ClickHouse/ClickHouse/pull/6423) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- MySQL işleyicisinden ekstra ayrıntılı günlük kaydı kaldırıldı. [\#6389](https://github.com/ClickHouse/ClickHouse/pull/6389) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yanlış davranışı ve olası segfault'ları düzeltin `topK` ve `topKWeighted` toplu fonksiyonlar. [\#6404](https://github.com/ClickHouse/ClickHouse/pull/6404) ([CurtizJ](https://github.com/CurtizJ)) +- Sanal sütunları göstermeyin `system.columns` Tablo. Bu geriye dönük uyumluluk için gereklidir. [\#6406](https://github.com/ClickHouse/ClickHouse/pull/6406) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Karmaşık anahtar önbellek sözlüğünde dize alanları için bellek tahsisi ile hatayı düzeltin. [\#6447](https://github.com/ClickHouse/ClickHouse/pull/6447) ([alesapin](https://github.com/alesapin)) +- İçin yeni bir çoğaltma oluştururken uyarlamalı ayrıntıyı etkinleştirerek hatayı düzeltin `Replicated*MergeTree` Tablo. [\#6452](https://github.com/ClickHouse/ClickHouse/pull/6452) ([alesapin](https://github.com/alesapin)) +- Kafka mesajlarını okurken sonsuz döngüyü düzeltin. [\#6354](https://github.com/ClickHouse/ClickHouse/pull/6354) ([abyss7](https://github.com/abyss7)) +- SQL ayrıştırıcısında yığın taşması ve yığın taşması olasılığı nedeniyle sunucu çökmesine neden olmak için fabrikasyon bir sorgu olasılığı düzeltildi `Merge` ve `Distributed` Tablolar [\#6433](https://github.com/ClickHouse/ClickHouse/pull/6433) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Küçük dizilerde sabit goril kodlama hatası. [\#6444](https://github.com/ClickHouse/ClickHouse/pull/6444) ([Enmk](https://github.com/Enmk)) + +#### Geliştirme {#improvement-5} + +- Kullanıcının geçersiz kılmasına izin ver `poll_interval` ve `idle_connection_timeout` bağlantı ayarları. [\#6230](https://github.com/ClickHouse/ClickHouse/pull/6230) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse sürümü 19.11.5.28, 2019-08-05 {#clickhouse-release-19-11-5-28-2019-08-05} + +#### Hata düzeltme {#bug-fix-19} + +- Sunucu aşırı yüklendiğinde sorguları asılı olasılığı düzeltildi. [\#6301](https://github.com/ClickHouse/ClickHouse/pull/6301) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- YANDEXCONSİSTENTHASH işlevinde FPE'Yİ düzeltin. Bu düzeltmeler [\#6304](https://github.com/ClickHouse/ClickHouse/issues/6304). [\#6126](https://github.com/ClickHouse/ClickHouse/pull/6126) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Dönüşüm Sabit hata `LowCardinality` yazmak `AggregateFunctionFactory`. Bu düzeltmeler [\#6257](https://github.com/ClickHouse/ClickHouse/issues/6257). [\#6281](https://github.com/ClickHouse/ClickHouse/pull/6281) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Ayrıştırmayı düzeltin `bool` ayarlar `true` ve `false` yapılandırma dosyalarındaki dizeler. [\#6278](https://github.com/ClickHouse/ClickHouse/pull/6278) ([alesapin](https://github.com/alesapin)) +- Sorgularda uyumsuz akış başlıklarıyla nadir hatayı düzeltin `Distributed` masa üstü `MergeTree` tablo parça `WHERE` MOV toes to `PREWHERE`. [\#6236](https://github.com/ClickHouse/ClickHouse/pull/6236) ([alesapin](https://github.com/alesapin)) +- İmzalı türün imzasız türe tamsayı bölümünde sabit taşma. Bu düzeltmeler [\#6214](https://github.com/ClickHouse/ClickHouse/issues/6214). [\#6233](https://github.com/ClickHouse/ClickHouse/pull/6233) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Geriye Dönük Uyumsuz Değişim {#backward-incompatible-change-5} + +- `Kafka` hala kırık. + +### ClickHouse sürümü 19.11.4.24, 2019-08-01 {#clickhouse-release-19-11-4-24-2019-08-01} + +#### Hata Düzeltme {#bug-fix-20} + +- Adaptif tanecikli ikincil endeksler işaretleri yazma ile hatayı düzeltin. [\#6126](https://github.com/ClickHouse/ClickHouse/pull/6126) ([alesapin](https://github.com/alesapin)) +- Düzeltmek `WITH ROLLUP` ve `WITH CUBE` değiştiriciler `GROUP BY` iki seviyeli toplama ile. [\#6225](https://github.com/ClickHouse/ClickHouse/pull/6225) ([Anton Popov](https://github.com/CurtizJ)) +- Sabit asmak `JSONExtractRaw` işlev. Sabit [\#6195](https://github.com/ClickHouse/ClickHouse/issues/6195) [\#6198](https://github.com/ClickHouse/ClickHouse/pull/6198) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- ExternalLoader::reloadOutdated () içinde segfault Fix. [\#6082](https://github.com/ClickHouse/ClickHouse/pull/6082) ([Vitaly Baranov](https://github.com/vitlibar)) +- Sunucu dinleme soketlerini kapatabilir, ancak kapanmaz ve kalan sorguları sunmaya devam edebilir. İki çalışan clickhouse-server süreçleri ile sona erebilir. Bazen, sunucu bir hata döndürebilir `bad_function_call` kalan sorgular için. [\#6231](https://github.com/ClickHouse/ClickHouse/pull/6231) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- ODBC, MySQL, ClickHouse ve HTTP üzerinden harici sözlüklerin ilk yüklenmesi için güncelleme alanında işe yaramaz ve yanlış durum düzeltildi. Bu düzeltmeler [\#6069](https://github.com/ClickHouse/ClickHouse/issues/6069) [\#6083](https://github.com/ClickHouse/ClickHouse/pull/6083) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Döküm sabit alakasız istisna `LowCardinality(Nullable)` to not-Nullable column in case if it doesn't contain Nulls (e.g. in query like `SELECT CAST(CAST('Hello' AS LowCardinality(Nullable(String))) AS String)`. [\#6094](https://github.com/ClickHouse/ClickHouse/issues/6094) [\#6119](https://github.com/ClickHouse/ClickHouse/pull/6119) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Deterministik olmayan sonucu düzeltin “uniq” aşırı nadir durumlarda toplama fonksiyonu. Hata tüm ClickHouse sürümlerinde mevcuttu. [\#6058](https://github.com/ClickHouse/ClickHouse/pull/6058) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Segfault biz fonksiyonu üzerinde biraz fazla yüksek CIDR ayarladığınızda `IPv6CIDRToRange`. [\#6068](https://github.com/ClickHouse/ClickHouse/pull/6068) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Sunucu birçok farklı bağlamdan birçok istisna attığında sabit küçük bellek sızıntısı. [\#6144](https://github.com/ClickHouse/ClickHouse/pull/6144) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tüketici abonelikten önce duraklatıldığında ve daha sonra devam etmediğinde durumu düzeltin. [\#6075](https://github.com/ClickHouse/ClickHouse/pull/6075) ([I ivanvan](https://github.com/abyss7)) Kafka'nın bu sürümde bozulduğunu unutmayın. +- Bir hatayla tamamlanan önceki okuma işleminden Kafka veri arabelleğini temizleme [\#6026](https://github.com/ClickHouse/ClickHouse/pull/6026) ([Nikolay](https://github.com/bopohaa)) Kafka'nın bu sürümde bozulduğunu unutmayın. +- Beri `StorageMergeTree::background_task_handle` içinde Başlat isılmıştır `startup()` bu `MergeTreeBlockOutputStream::write()` başlatmadan önce kullanmayı deneyebilir. Eğer başlatıldı ise sadece kontrol. [\#6080](https://github.com/ClickHouse/ClickHouse/pull/6080) ([I ivanvan](https://github.com/abyss7)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-6} + +- Resmi eklendi `rpm` paketler. [\#5740](https://github.com/ClickHouse/ClickHouse/pull/5740) ([proller](https://github.com/proller)) ([alesapin](https://github.com/alesapin)) +- Oluşturmak için bir yetenek ekleyin `.rpm` ve `.tgz` paketleri ile `packager` komut. [\#5769](https://github.com/ClickHouse/ClickHouse/pull/5769) ([alesapin](https://github.com/alesapin)) +- İçin düzeltmeler “Arcadia” sistemi oluşturmak. [\#6223](https://github.com/ClickHouse/ClickHouse/pull/6223) ([proller](https://github.com/proller)) + +#### Geriye Dönük Uyumsuz Değişim {#backward-incompatible-change-6} + +- `Kafka` bu sürümde bozuldu. + +### ClickHouse sürümü 19.11.3.11, 2019-07-18 {#clickhouse-release-19-11-3-11-2019-07-18} + +#### Yenilik {#new-feature-6} + +- Hazırlanan ifadeler için destek eklendi. [\#5331](https://github.com/ClickHouse/ClickHouse/pull/5331/) ([İskender](https://github.com/sanych73)) [\#5630](https://github.com/ClickHouse/ClickHouse/pull/5630) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- `DoubleDelta` ve `Gorilla` sütun kodekleri [\#5600](https://github.com/ClickHouse/ClickHouse/pull/5600) ([Vasily Nemkov](https://github.com/Enmk)) +- Katma `os_thread_priority` kontrol etmeyi sağlayan ayar “nice” dinamik zamanlama önceliğini ayarlamak için OS tarafından kullanılan sorgu işleme iş parçacıklarının değeri. Bu gerektirir `CAP_SYS_NICE` yetenekleri çalışmak. Bu uygular [\#5858](https://github.com/ClickHouse/ClickHouse/issues/5858) [\#5909](https://github.com/ClickHouse/ClickHouse/pull/5909) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Uygulamak `_topic`, `_offset`, `_key` Kafka motoru için sütunlar [\#5382](https://github.com/ClickHouse/ClickHouse/pull/5382) ([I ivanvan](https://github.com/abyss7)) Kafka'nın bu sürümde bozulduğunu unutmayın. +- Toplama fonksiyonu birleştirici Ekle `-Resample` [\#5590](https://github.com/ClickHouse/ClickHouse/pull/5590) ([hcz](https://github.com/hczhcz)) +- Toplama fonksiyonları `groupArrayMovingSum(win_size)(x)` ve `groupArrayMovingAvg(win_size)(x)`, pencere boyutu sınırlaması olan veya olmayan hareketli toplamı/AVG'yi hesaplar. [\#5595](https://github.com/ClickHouse/ClickHouse/pull/5595) ([ınv2004](https://github.com/inv2004)) +- Synonim Ekle `arrayFlatten` \<-\> `flatten` [\#5764](https://github.com/ClickHouse/ClickHouse/pull/5764) ([hcz](https://github.com/hczhcz)) +- Intergate H3 fonksiyonu `geoToH3` Uber gelen. [\#4724](https://github.com/ClickHouse/ClickHouse/pull/4724) ([Remen Ivan](https://github.com/BHYCHIK)) [\#5805](https://github.com/ClickHouse/ClickHouse/pull/5805) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Hata Düzeltme {#bug-fix-21} + +- Zaman uyumsuz güncelleştirme ile DNS önbelleğini uygulayın. Ayrı iş parçacığı tüm ana bilgisayarları çözer ve DNS önbelleğini nokta (ayar) ile günceller `dns_cache_update_period`). Ana bilgisayarların IP'si sık sık değiştiğinde yardımcı olmalıdır. [\#5857](https://github.com/ClickHouse/ClickHouse/pull/5857) ([Anton Popov](https://github.com/CurtizJ)) +- Segfault'u düzeltin `Delta` 32 bit boyutundan daha küçük değerlere sahip sütunları etkileyen codec bileşeni. Hata rastgele bellek bozulmasına yol açtı. [\#5786](https://github.com/ClickHouse/ClickHouse/pull/5786) ([alesapin](https://github.com/alesapin)) +- TTL fix segfault blok fiziksel olmayan sütunlarla birleştirme. [\#5819](https://github.com/ClickHouse/ClickHouse/pull/5819) ([Anton Popov](https://github.com/CurtizJ)) +- Parçanın kontrol edilmesinde nadir hatayı düzeltin `LowCardinality` sütun. Önceden `checkDataPart` her zaman ile parçası için başarısız `LowCardinality` sütun. [\#5832](https://github.com/ClickHouse/ClickHouse/pull/5832) ([alesapin](https://github.com/alesapin)) +- Sunucu iş parçacığı havuzu dolduğunda bağlantıları asılı kaçının. Bağlantılar için önemlidir `remote` uzun bağlantı zaman aşımı olduğunda, tablo işlevi veya kopyaları olmayan bir parçaya bağlantılar. Bu düzeltmeler [\#5878](https://github.com/ClickHouse/ClickHouse/issues/5878) [\#5881](https://github.com/ClickHouse/ClickHouse/pull/5881) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit argümanlar için destek `evalMLModel` işlev. Bu düzeltmeler [\#5817](https://github.com/ClickHouse/ClickHouse/issues/5817) [\#5820](https://github.com/ClickHouse/ClickHouse/pull/5820) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- ClickHouse varsayılan saat dilimini belirlediğinde sorun giderildi `UCT` yerine `UTC`. Bu düzeltmeler [\#5804](https://github.com/ClickHouse/ClickHouse/issues/5804). [\#5828](https://github.com/ClickHouse/ClickHouse/pull/5828) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit tampon underflow içinde `visitParamExtractRaw`. Bu düzeltmeler [\#5901](https://github.com/ClickHouse/ClickHouse/issues/5901) [\#5902](https://github.com/ClickHouse/ClickHouse/pull/5902) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Şimdi dağıtılmış `DROP/ALTER/TRUNCATE/OPTIMIZE ON CLUSTER` sorgular doğrudan lider çoğaltma üzerinde yürütülür. [\#5757](https://github.com/ClickHouse/ClickHouse/pull/5757) ([alesapin](https://github.com/alesapin)) +- Düzeltmek `coalesce` için `ColumnConst` ile `ColumnNullable` + ilgili değişiklikler. [\#5755](https://github.com/ClickHouse/ClickHouse/pull/5755) ([Artem Zuikov](https://github.com/4ertus2)) +- Fix the `ReadBufferFromKafkaConsumer` böylece sonra yeni mesajlar okumaya devam ediyor `commit()` daha önce durmuş olsa bile [\#5852](https://github.com/ClickHouse/ClickHouse/pull/5852) ([I ivanvan](https://github.com/abyss7)) +- Düzeltmek `FULL` ve `RIGHT` Üzerinde katılırken sonuçları katılın `Nullable` sağ tablodaki tuşlar. [\#5859](https://github.com/ClickHouse/ClickHouse/pull/5859) ([Artem Zuikov](https://github.com/4ertus2)) +- Düşük öncelikli sorguların sonsuz uyku Olası düzeltme. [\#5842](https://github.com/ClickHouse/ClickHouse/pull/5842) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bazı sorguların query\_log'da görünmemesine neden olan Yarış durumunu düzeltin `SYSTEM FLUSH LOGS` sorgu. [\#5456](https://github.com/ClickHouse/ClickHouse/issues/5456) [\#5685](https://github.com/ClickHouse/ClickHouse/pull/5685) ([Anton Popov](https://github.com/CurtizJ)) +- Sabit `heap-use-after-free` Clustercopier'de asan uyarısı, zaten kaldırılmış fotokopi nesnesini kullanmaya çalışan saatin neden olduğu. [\#5871](https://github.com/ClickHouse/ClickHouse/pull/5871) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Sabit yanlış `StringRef` bazı uygulamalar tarafından döndürülen işaretçi `IColumn::deserializeAndInsertFromArena`. Bu hata sadece birim testlerini etkiledi. [\#5973](https://github.com/ClickHouse/ClickHouse/pull/5973) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Aynı ad sütunlarını maskeleme kaynak ve ara dizi birleştirme sütunlarını önleyin. [\#5941](https://github.com/ClickHouse/ClickHouse/pull/5941) ([Artem Zuikov](https://github.com/4ertus2)) +- Insert Fix ve MySQL stil tanımlayıcı Alıntı ile MySQL motoruna sorgu seçin. [\#5704](https://github.com/ClickHouse/ClickHouse/pull/5704) ([Kış Zhang](https://github.com/zhang2014)) +- Şimdi `CHECK TABLE` sorgu MergeTree engine ailesi ile çalışabilir. Her bir parça için (veya simplier motorları durumunda dosya) varsa kontrol durumunu ve mesajı döndürür. Ayrıca, kırık bir parçanın getirilmesinde hatayı düzeltin. [\#5865](https://github.com/ClickHouse/ClickHouse/pull/5865) ([alesapin](https://github.com/alesapin)) +- Split\_shared\_libraries çalışma zamanını düzeltme [\#5793](https://github.com/ClickHouse/ClickHouse/pull/5793) ([Danila Kutenin](https://github.com/danlark1)) +- Sabit zaman dilimi başlatma `/etc/localtime` göreceli bir sembolik bağ gibi mi `../usr/share/zoneinfo/Europe/Moscow` [\#5922](https://github.com/ClickHouse/ClickHouse/pull/5922) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- clickhouse-fotokopi makinesi: kullanımı düzeltin-kapatmadan sonra ücretsiz [\#5752](https://github.com/ClickHouse/ClickHouse/pull/5752) ([proller](https://github.com/proller)) +- Güncel `simdjson`. Sıfır bayt ile bazı geçersiz JSONs başarıyla ayrıştırmak sorunu düzeltildi. [\#5938](https://github.com/ClickHouse/ClickHouse/pull/5938) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sistem günlüklerinin kapatılmasını düzeltin [\#5802](https://github.com/ClickHouse/ClickHouse/pull/5802) ([Anton Popov](https://github.com/CurtizJ)) +- Invalidate\_query'deki koşul bir sözlüğe bağlı olduğunda askıda kalmayı düzeltin. [\#6011](https://github.com/ClickHouse/ClickHouse/pull/6011) ([Vitaly Baranov](https://github.com/vitlibar)) + +#### Geliştirme {#improvement-6} + +- Küme yapılandırmasında çözümlenemeyen adreslere izin ver. Onlar kullanılamaz kabul ve her bağlantı girişimi çözmek için çalışılacaktır. Bu özellikle Kubernetes için yararlıdır. Bu düzeltmeler [\#5714](https://github.com/ClickHouse/ClickHouse/issues/5714) [\#5924](https://github.com/ClickHouse/ClickHouse/pull/5924) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Boş TCP bağlantılarını kapatın (varsayılan olarak bir saat zaman aşımı ile). Bu, her sunucuda birden çok dağıtılmış tablo bulunan büyük kümeler için özellikle önemlidir, çünkü her sunucu bir bağlantı havuzunu diğer her sunucuya saklayabilir ve en yüksek sorgu eşzamanlılığından sonra bağlantılar duracaktır. Bu düzeltmeler [\#5879](https://github.com/ClickHouse/ClickHouse/issues/5879) [\#5880](https://github.com/ClickHouse/ClickHouse/pull/5880) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Daha kaliteli `topK` işlev. Yeni öğenin daha büyük bir ağırlığı varsa, son öğeyi kaldırmak için SavingSpace set davranışını değiştirdi. [\#5833](https://github.com/ClickHouse/ClickHouse/issues/5833) [\#5850](https://github.com/ClickHouse/ClickHouse/pull/5850) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Etki alanlarıyla çalışmak için URL işlevleri artık şema olmadan tamamlanmamış URL'ler için çalışabilir [\#5725](https://github.com/ClickHouse/ClickHouse/pull/5725) ([alesapin](https://github.com/alesapin)) +- Checksums eklendi `system.parts_columns` Tablo. [\#5874](https://github.com/ClickHouse/ClickHouse/pull/5874) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Katma `Enum` veri türü için bir synonim olarak `Enum8` veya `Enum16`. [\#5886](https://github.com/ClickHouse/ClickHouse/pull/5886) ([dimarub2000](https://github.com/dimarub2000)) +- Tam bit transpose varyantı için `T64` codec. İle daha iyi sıkıştırma yol açabilir `zstd`. [\#5742](https://github.com/ClickHouse/ClickHouse/pull/5742) ([Artem Zuikov](https://github.com/4ertus2)) +- Cond conditionition on `startsWith` fonksiyon şimdi birincil anahtar kullanır. Bu düzeltmeler [\#5310](https://github.com/ClickHouse/ClickHouse/issues/5310) ve [\#5882](https://github.com/ClickHouse/ClickHouse/issues/5882) [\#5919](https://github.com/ClickHouse/ClickHouse/pull/5919) ([dimarub2000](https://github.com/dimarub2000)) +- Kullanmasına izin ver `clickhouse-copier` boş veritabanı adı izin vererek çapraz çoğaltma küme topolojisi ile. [\#5745](https://github.com/ClickHouse/ClickHouse/pull/5745) ([nvartolomei](https://github.com/nvartolomei)) +- Kullanmak `UTC` olmadan bir sistemde varsayılan zaman dilimi olarak `tzdata` (e.g. bare Docker container). Before this patch, error message `Could not determine local time zone` yazdırıldı ve sunucu veya istemci başlatmayı reddetti. [\#5827](https://github.com/ClickHouse/ClickHouse/pull/5827) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Fonksiyonda kayan nokta argümanı için geri destek döndü `quantileTiming` geriye dönük uyumluluk için. [\#5911](https://github.com/ClickHouse/ClickHouse/pull/5911) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Hata iletilerinde hangi tablonun eksik olduğunu göster. [\#5768](https://github.com/ClickHouse/ClickHouse/pull/5768) ([I ivanvan](https://github.com/abyss7)) +- Çeşitli kullanıcılar tarafından aynı query\_id ile sorgu çalıştırmasına izin verme [\#5430](https://github.com/ClickHouse/ClickHouse/pull/5430) ([proller](https://github.com/proller)) +- Grafite metrikleri göndermek için daha sağlam kod. Uzun çoklu sırasında bile çalışacaktır `RENAME TABLE` işleyiş. [\#5875](https://github.com/ClickHouse/ClickHouse/pull/5875) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- ThreadPool yürütme için bir görev zamanlayamıyor, daha bilgilendirici hata iletileri görüntülenir. Bu düzeltmeler [\#5305](https://github.com/ClickHouse/ClickHouse/issues/5305) [\#5801](https://github.com/ClickHouse/ClickHouse/pull/5801) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Ngramsearch'i daha sezgisel olarak tersine çevirmek [\#5807](https://github.com/ClickHouse/ClickHouse/pull/5807) ([Danila Kutenin](https://github.com/danlark1)) +- HDFS engine builder'da kullanıcı ayrıştırma Ekle [\#5946](https://github.com/ClickHouse/ClickHouse/pull/5946) ([akonyaev90](https://github.com/akonyaev90)) +- Güncelleme varsayılan değeri `max_ast_elements parameter` [\#5933](https://github.com/ClickHouse/ClickHouse/pull/5933) ([Artem Konovalov](https://github.com/izebit)) +- Eski ayarlar kavramı eklendi. Eski ayar `allow_experimental_low_cardinality_type` hiçbir etkisi ile kullanılabilir. [0f15c01c6802f7ce1a1494c12c846be8c98944cd](https://github.com/ClickHouse/ClickHouse/commit/0f15c01c6802f7ce1a1494c12c846be8c98944cd) [Alexey Milovidov](https://github.com/alexey-milovidov) + +#### Performans İyileştirme {#performance-improvement-4} + +- İş parçacıklarının daha düzgün dağılımı için birleştirme tablosundan seçilecek akış sayısını artırın. Ayar eklendi `max_streams_multiplier_for_merge_tables`. Bu düzeltmeler [\#5797](https://github.com/ClickHouse/ClickHouse/issues/5797) [\#5915](https://github.com/ClickHouse/ClickHouse/pull/5915) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-7} + +- Clickhouse'un farklı sürümleriyle istemci-sunucu etkileşimi için geriye dönük uyumluluk testi ekleyin. [\#5868](https://github.com/ClickHouse/ClickHouse/pull/5868) ([alesapin](https://github.com/alesapin)) +- Her taahhüt ve çekme isteğinde Test kapsamı bilgileri. [\#5896](https://github.com/ClickHouse/ClickHouse/pull/5896) ([alesapin](https://github.com/alesapin)) +- Özel ayırıcılarımızı desteklemek için adres dezenfektanı ile işbirliği yapın (`Arena` ve `ArenaWithFreeLists`) daha iyi hata ayıklama için “use-after-free” hatasızlar. [\#5728](https://github.com/ClickHouse/ClickHouse/pull/5728) ([akuzm](https://github.com/akuzm)) +- Değiştirmek [Llvm libunwind uygulaması](https://github.com/llvm-mirror/libunwind) C++ özel durum işleme ve yığın izleri yazdırma için [\#4828](https://github.com/ClickHouse/ClickHouse/pull/4828) ([Nikita Lapkov](https://github.com/laplab)) +- \- Weverything'den iki uyarı daha ekleyin [\#5923](https://github.com/ClickHouse/ClickHouse/pull/5923) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bellek dezenfektanı ile ClickHouse oluşturmak için izin verin. [\#3949](https://github.com/ClickHouse/ClickHouse/pull/3949) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit ubsan raporu hakkında `bitTest` fuzz testinde işlev. [\#5943](https://github.com/ClickHouse/ClickHouse/pull/5943) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Docker: kimlik doğrulaması gerektiren bir ClickHouse örneğini başlatmak için olasılık eklendi. [\#5727](https://github.com/ClickHouse/ClickHouse/pull/5727) ([Korviakov Andrey](https://github.com/shurshun)) +- Librdkafka'yı 1.1.0 sürümüne güncelleyin [\#5872](https://github.com/ClickHouse/ClickHouse/pull/5872) ([I ivanvan](https://github.com/abyss7)) +- Entegrasyon testleri için genel zaman aşımı ekleyin ve test kodunda bazılarını devre dışı bırakın. [\#5741](https://github.com/ClickHouse/ClickHouse/pull/5741) ([alesapin](https://github.com/alesapin)) +- Bazı iş parçacıklarını düzeltinnitizer arızaları. [\#5854](https://github.com/ClickHouse/ClickHouse/pull/5854) ([akuzm](https://github.com/akuzm)) +- Bu `--no-undefined` seçenek, bağlayıcıyı, bağlantı sırasında varoluş için tüm dış adları denetlemeye zorlar. Bölünmüş yapı modunda kütüphaneler arasındaki gerçek bağımlılıkları izlemek çok yararlıdır. [\#5855](https://github.com/ClickHouse/ClickHouse/pull/5855) ([I ivanvan](https://github.com/abyss7)) +- İçin performans testi eklendi [\#5797](https://github.com/ClickHouse/ClickHouse/issues/5797) [\#5914](https://github.com/ClickHouse/ClickHouse/pull/5914) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Gcc-7 ile sabit uyumluluk. [\#5840](https://github.com/ClickHouse/ClickHouse/pull/5840) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Gcc-9 için destek eklendi. Bu düzeltmeler [\#5717](https://github.com/ClickHouse/ClickHouse/issues/5717) [\#5774](https://github.com/ClickHouse/ClickHouse/pull/5774) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Libunwind yanlış bağlanabilir Sabit hata. [\#5948](https://github.com/ClickHouse/ClickHouse/pull/5948) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- PVS-Studio tarafından bulunan birkaç uyarı düzeltildi. [\#5921](https://github.com/ClickHouse/ClickHouse/pull/5921) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İçin ilk destek eklendi `clang-tidy` statik analiz cihazı. [\#5806](https://github.com/ClickHouse/ClickHouse/pull/5806) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- BSD/Linux endian makrolarını dönüştürme( ‘be64toh’ ve ‘htobe64’) Mac OS X eşdeğentser thelerine [\#5785](https://github.com/ClickHouse/ClickHouse/pull/5785) ([Fu Ch Chenen](https://github.com/fredchenbj)) +- Geliştirilmiş entegrasyon testleri kılavuzu. [\#5796](https://github.com/ClickHouse/ClickHouse/pull/5796) ([Vladimir Chebotarev](https://github.com/excitoon)) +- MacOSX + gcc9'da yapı sabitleme [\#5822](https://github.com/ClickHouse/ClickHouse/pull/5822) ([filimonov](https://github.com/filimonov)) +- Sabit bir nokta yazım hatası düzeltin: aggreAGte - \> agrega. [\#5753](https://github.com/ClickHouse/ClickHouse/pull/5753) ([akuzm](https://github.com/akuzm)) +- Freebsd yapısını düzeltin [\#5760](https://github.com/ClickHouse/ClickHouse/pull/5760) ([proller](https://github.com/proller)) +- Web sitesine deneysel YouTube kanalına bağlantı Ekle [\#5845](https://github.com/ClickHouse/ClickHouse/pull/5845) ([Ivan Blinkov](https://github.com/blinkov)) +- Cmake: kapsama bayrakları için Seçenek Ekle: WİTH\_COVERAGE [\#5776](https://github.com/ClickHouse/ClickHouse/pull/5776) ([proller](https://github.com/proller)) +- Bazı satır içi Podarray'ın başlangıç boyutunu düzeltin. [\#5787](https://github.com/ClickHouse/ClickHouse/pull/5787) ([akuzm](https://github.com/akuzm)) +- clickhouse-sunucu.postınst: centos 6 için işletim sistemi algılamasını düzeltin [\#5788](https://github.com/ClickHouse/ClickHouse/pull/5788) ([proller](https://github.com/proller)) +- Arch linux paketi üretimi eklendi. [\#5719](https://github.com/ClickHouse/ClickHouse/pull/5719) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Split Common/config.libs tarafından h (dbms) [\#5715](https://github.com/ClickHouse/ClickHouse/pull/5715) ([proller](https://github.com/proller)) +- İçin düzeltmeler “Arcadia” yapı platformu [\#5795](https://github.com/ClickHouse/ClickHouse/pull/5795) ([proller](https://github.com/proller)) +- Alışılmamış yapı için düzeltmeler (gcc9, alt modül yok) [\#5792](https://github.com/ClickHouse/ClickHouse/pull/5792) ([proller](https://github.com/proller)) +- Hata eğilimli olduğu kanıtlanmış olduğu için unalignedstore'da açık tip gerektirir [\#5791](https://github.com/ClickHouse/ClickHouse/pull/5791) ([akuzm](https://github.com/akuzm)) +- Düzeltmeler MacOS yapı [\#5830](https://github.com/ClickHouse/ClickHouse/pull/5830) ([filimonov](https://github.com/filimonov)) +- Burada istendiği gibi, daha büyük veri kümesine sahip yeni JIT özelliği ile ilgili performans testi [\#5263](https://github.com/ClickHouse/ClickHouse/issues/5263) [\#5887](https://github.com/ClickHouse/ClickHouse/pull/5887) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Stres testinde durumsal testler çalıştırın [12693e568722f11e19859742f56428455501fd2a](https://github.com/ClickHouse/ClickHouse/commit/12693e568722f11e19859742f56428455501fd2a) ([alesapin](https://github.com/alesapin)) + +#### Geriye Dönük Uyumsuz Değişim {#backward-incompatible-change-7} + +- `Kafka` bu sürümde bozuldu. +- Etkinleştirmek `adaptive_index_granularity` = Yeni için varsayılan olarak 10MB `MergeTree` Tablolar. 19.11 + sürümünde yeni MergeTree tabloları oluşturduysanız, 19.6'dan önceki sürümlere düşürme imkansız olacaktır. [\#5628](https://github.com/ClickHouse/ClickHouse/pull/5628) ([alesapin](https://github.com/alesapin)) +- Yandex tarafından kullanılan eski belgesiz gömülü sözlükler kaldırıldı.Metrica. İşlev `OSIn`, `SEIn`, `OSToRoot`, `SEToRoot`, `OSHierarchy`, `SEHierarchy` artık kullanılamaz. Bu işlevleri kullanıyorsanız, e-posta yazın clickhouse-feedback@yandex-team.com. not: son anda bu işlevleri bir süre tutmaya karar verdik. [\#5780](https://github.com/ClickHouse/ClickHouse/pull/5780) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +## ClickHouse yayın 19.10 {#clickhouse-release-19-10} + +### ClickHouse sürümü 19.10.1.5, 2019-07-12 {#clickhouse-release-19-10-1-5-2019-07-12} + +#### Yenilik {#new-feature-7} + +- Yeni sütun codec Ekle: `T64`. (U)IntX/EnumX/Data(Time)/DecimalX sütunları için yapılmıştır. Sabit veya küçük Aralık değerlerine sahip sütunlar için iyi olmalıdır. Codec kendisi büyütmek veya yeniden sıkıştırma olmadan veri türünü küçültmek sağlar. [\#5557](https://github.com/ClickHouse/ClickHouse/pull/5557) ([Artem Zuikov](https://github.com/4ertus2)) +- Veritabanı Altyapısı Ekle `MySQL` uzak MySQL sunucusundaki tüm tabloları görüntülemenize izin veren [\#5599](https://github.com/ClickHouse/ClickHouse/pull/5599) ([Kış Zhang](https://github.com/zhang2014)) +- `bitmapContains` uygulanış. 2x daha hızlı `bitmapHasAny` ikinci bit eşlem bir öğe içeriyorsa. [\#5535](https://github.com/ClickHouse/ClickHouse/pull/5535) ([Zhichang Yu](https://github.com/yuzhichang)) +- İçin destek `crc32` işlev (tam olarak MySQL veya PHP'DE olduğu gibi davranışla). Bir karma işlevine ihtiyacınız varsa kullanmayın. [\#5661](https://github.com/ClickHouse/ClickHouse/pull/5661) ([Remen Ivan](https://github.com/BHYCHIK)) +- Uyguluyordu `SYSTEM START/STOP DISTRIBUTED SENDS` zaman uyumsuz ekler içine denetlemek için sorgular `Distributed` Tablolar. [\#4935](https://github.com/ClickHouse/ClickHouse/pull/4935) ([Kış Zhang](https://github.com/zhang2014)) + +#### Hata Düzeltme {#bug-fix-22} + +- Mutasyonları yürütürken birleştirme sınırları için sorgu yürütme sınırlarını ve en fazla parça boyutunu yoksayın. [\#5659](https://github.com/ClickHouse/ClickHouse/pull/5659) ([Anton Popov](https://github.com/CurtizJ)) +- Normal blokların tekilleştirilmesine (son derece nadir) ve yinelenen blokların eklenmesine (daha sık) yol açabilecek hatayı düzeltin. [\#5549](https://github.com/ClickHouse/ClickHouse/pull/5549) ([alesapin](https://github.com/alesapin)) +- Fonksiyonun düzeltilmesi `arrayEnumerateUniqRanked` boş dizilere sahip argümanlar için [\#5559](https://github.com/ClickHouse/ClickHouse/pull/5559) ([proller](https://github.com/proller)) +- Herhangi bir mesaj yoklamak niyetiyle olmadan Kafka konulara abone etmeyin. [\#5698](https://github.com/ClickHouse/ClickHouse/pull/5698) ([I ivanvan](https://github.com/abyss7)) +- Ayar yap `join_use_nulls` Nullable içinde olamaz türleri için hiçbir etkisi olsun [\#5700](https://github.com/ClickHouse/ClickHouse/pull/5700) ([Olga Khvostikova](https://github.com/stavrolia)) +- Sabit `Incorrect size of index granularity` hatasızlar [\#5720](https://github.com/ClickHouse/ClickHouse/pull/5720) ([coraxster](https://github.com/coraxster)) +- Float'ı ondalık dönüştürme taşmasına düzeltin [\#5607](https://github.com/ClickHouse/ClickHouse/pull/5607) ([coraxster](https://github.com/coraxster)) +- Floş tampon zaman `WriteBufferFromHDFS`'In yıkıcı denir. Bu düzeltmeler içine yazma `HDFS`. [\#5684](https://github.com/ClickHouse/ClickHouse/pull/5684) ([Xindong Peng](https://github.com/eejoin)) + +#### Geliştirme {#improvement-7} + +- Boş hücreleri tedavi edin `CSV` varsayılan değerler olarak zaman ayarı `input_format_defaults_for_omitted_fields` etkindir. [\#5625](https://github.com/ClickHouse/ClickHouse/pull/5625) ([akuzm](https://github.com/akuzm)) +- Harici sözlüklerin engellenmeyen yüklenmesi. [\#5567](https://github.com/ClickHouse/ClickHouse/pull/5567) ([Vitaly Baranov](https://github.com/vitlibar)) +- Ayarlara göre önceden kurulmuş bağlantılar için Ağ zaman aşımları dinamik olarak değiştirilebilir. [\#4558](https://github.com/ClickHouse/ClickHouse/pull/4558) ([Konstantin Podshumok](https://github.com/podshumok)) +- Kullanım “public\_suffix\_list” fonksiyonlar için `firstSignificantSubdomain`, `cutToFirstSignificantSubdomain`. Tarafından oluşturulan mükemmel bir karma tablo kullanıyor `gperf` dosyadan oluşturulan bir liste ile: https://publicsuffix.org/list/public\_suffix\_list.dat. (örneğin, şimdi etki alanını tanıyoruz `ac.uk` olmayan önemli). [\#5030](https://github.com/ClickHouse/ClickHouse/pull/5030) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Kabul edilen `IPv6` sistem tablolarında veri türü; Birleşik istemci bilgi sütunları `system.processes` ve `system.query_log` [\#5640](https://github.com/ClickHouse/ClickHouse/pull/5640) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- MySQL uyumluluk protokolü ile bağlantılar için oturumları kullanma. \#5476 [\#5646](https://github.com/ClickHouse/ClickHouse/pull/5646) ([Yuriy Baranov](https://github.com/yurriy)) +- Destek daha fazla `ALTER` sorgular `ON CLUSTER`. [\#5593](https://github.com/ClickHouse/ClickHouse/pull/5593) [\#5613](https://github.com/ClickHouse/ClickHouse/pull/5613) ([sundyli](https://github.com/sundy-li)) +- Destek `` bölümünde `clickhouse-local` yapılandırma dosyası. [\#5540](https://github.com/ClickHouse/ClickHouse/pull/5540) ([proller](https://github.com/proller)) +- Sorgu çalıştırmasına izin ver `remote` tablo fonksiyonu `clickhouse-local` [\#5627](https://github.com/ClickHouse/ClickHouse/pull/5627) ([proller](https://github.com/proller)) + +#### Performans İyileştirme {#performance-improvement-5} + +- Mergetree sütunların sonunda son işareti yazma imkanı ekleyin. İşe yaramaz önlemek için tablo veri aralığı anahtarları için okuma sağlar. Yalnızca uyarlamalı dizin parçalı yapı kullanımda ise etkinleştirilir. [\#5624](https://github.com/ClickHouse/ClickHouse/pull/5624) ([alesapin](https://github.com/alesapin)) +- Sayısını azaltarak çok yavaş dosya sistemlerinde mergetree tabloları geliştirilmiş performans `stat` syscalls. [\#5648](https://github.com/ClickHouse/ClickHouse/pull/5648) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sürüm 19.6 tanıtıldı MergeTree tablolardan okuma sabit performans düşüşü. Düzeltmeler \# 5631. [\#5633](https://github.com/ClickHouse/ClickHouse/pull/5633) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-8} + +- Uyguluyordu `TestKeeper` test için kullanılan ZooKeeper arayüzünün bir uygulaması olarak [\#5643](https://github.com/ClickHouse/ClickHouse/pull/5643) ([alexey-milovidov](https://github.com/alexey-milovidov)) ([levushkin aleksej](https://github.com/alexey-milovidov)) +- Bundan sonra `.sql` testler rasgele veritabanı ile paralel olarak, sunucu tarafından izole çalıştırılabilir. Onları daha hızlı çalıştırmanıza, özel sunucu yapılandırmaları ile yeni testler eklemenize ve farklı testlerin birbirini etkilemediğinden emin olmanızı sağlar. [\#5554](https://github.com/ClickHouse/ClickHouse/pull/5554) ([I ivanvan](https://github.com/abyss7)) +- Kaldırmak `` ve `` performans test fromlerinden [\#5672](https://github.com/ClickHouse/ClickHouse/pull/5672) ([Olga Khvostikova](https://github.com/stavrolia)) +- Sabit “select\_format” performans testi için `Pretty` biçimliler [\#5642](https://github.com/ClickHouse/ClickHouse/pull/5642) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +## ClickHouse sürüm 19.9 {#clickhouse-release-19-9} + +### ClickHouse yayın 19.9.3.31, 2019-07-05 {#clickhouse-release-19-9-3-31-2019-07-05} + +#### Hata Düzeltme {#bug-fix-23} + +- 32 bit boyutundan daha küçük değerlere sahip sütunları etkileyen Delta codec'te segfault'u düzeltin. Hata rastgele bellek bozulmasına yol açtı. [\#5786](https://github.com/ClickHouse/ClickHouse/pull/5786) ([alesapin](https://github.com/alesapin)) +- LowCardinality sütunu ile parçanın kontrol nadir hata düzeltin. [\#5832](https://github.com/ClickHouse/ClickHouse/pull/5832) ([alesapin](https://github.com/alesapin)) +- TTL fix segfault blok fiziksel olmayan sütunlarla birleştirme. [\#5819](https://github.com/ClickHouse/ClickHouse/pull/5819) ([Anton Popov](https://github.com/CurtizJ)) +- Düşük öncelikli sorguların potansiyel sonsuz uykusunu düzeltin. [\#5842](https://github.com/ClickHouse/ClickHouse/pull/5842) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Clickhouse'un varsayılan saat dilimini UTC yerine UCT olarak nasıl belirlediğini düzeltin. [\#5828](https://github.com/ClickHouse/ClickHouse/pull/5828) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Lider çoğaltma önce takipçi çoğaltma üzerinde küme sorguları üzerinde dağıtılmış damla/ALTER/TRUNCATE/OPTİMİZE yürütme hakkında Fix hata. Şimdi doğrudan lider kopya üzerinde idam edilecektir. [\#5757](https://github.com/ClickHouse/ClickHouse/pull/5757) ([alesapin](https://github.com/alesapin)) +- Bazı sorgular anında sistem floş günlükleri sorgu sonra query\_log görünmeyebilir neden yarış durumu, düzeltin. [\#5685](https://github.com/ClickHouse/ClickHouse/pull/5685) ([Anton Popov](https://github.com/CurtizJ)) +- Sabit argümanlar için eksik destek eklendi `evalMLModel` işlev. [\#5820](https://github.com/ClickHouse/ClickHouse/pull/5820) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse sürümü 19.9.2.4, 2019-06-24 {#clickhouse-release-19-9-2-4-2019-06-24} + +#### Yenilik {#new-feature-8} + +- Dondurulmuş parçalar hakkında bilgi Yazdır `system.parts` Tablo. [\#5471](https://github.com/ClickHouse/ClickHouse/pull/5471) ([proller](https://github.com/proller)) +- Clickhouse'da istemci şifresini sor-argümanlarda ayarlanmamışsa tty üzerinde istemci Başlat [\#5092](https://github.com/ClickHouse/ClickHouse/pull/5092) ([proller](https://github.com/proller)) +- Uygulamak `dictGet` ve `dictGetOrDefault` ondalık türleri için fonksiyonlar. [\#5394](https://github.com/ClickHouse/ClickHouse/pull/5394) ([Artem Zuikov](https://github.com/4ertus2)) + +#### Geliştirme {#improvement-8} + +- Debian init: servis durdurma zaman aşımı Ekle [\#5522](https://github.com/ClickHouse/ClickHouse/pull/5522) ([proller](https://github.com/proller)) +- Lowcardinality için şüpheli türlerle tablo oluşturmak için varsayılan olarak yasaklanan ayar Ekle [\#5448](https://github.com/ClickHouse/ClickHouse/pull/5448) ([Olga Khvostikova](https://github.com/stavrolia)) +- Regresyon işlevleri, işlevde durum olarak kullanılmadığında model ağırlıklarını döndürür `evalMLMethod`. [\#5411](https://github.com/ClickHouse/ClickHouse/pull/5411) ([Quid37](https://github.com/Quid37)) +- Regresyon yöntemlerini yeniden adlandırın ve geliştirin. [\#5492](https://github.com/ClickHouse/ClickHouse/pull/5492) ([Quid37](https://github.com/Quid37)) +- Dize arayanların daha net arayüzleri. [\#5586](https://github.com/ClickHouse/ClickHouse/pull/5586) ([Danila Kutenin](https://github.com/danlark1)) + +#### Hata Düzeltme {#bug-fix-24} + +- Kafka'daki potansiyel veri kaybını düzeltin [\#5445](https://github.com/ClickHouse/ClickHouse/pull/5445) ([I ivanvan](https://github.com/abyss7)) +- Potansiyel sonsuz döngüyü düzeltin `PrettySpace` sıfır sütun ile çağrıldığında Biçimlendir [\#5560](https://github.com/ClickHouse/ClickHouse/pull/5560) ([Olga Khvostikova](https://github.com/stavrolia)) +- Doğrusal modellerde sabit uint32 taşma hatası. Const olmayan model argümanı için eval ML modeline izin verin. [\#5516](https://github.com/ClickHouse/ClickHouse/pull/5516) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- `ALTER TABLE ... DROP INDEX IF EXISTS ...` sağlanan dizin yoksa bir özel durum yükseltmek değil [\#5524](https://github.com/ClickHouse/ClickHouse/pull/5524) ([Gleb Novikov](https://github.com/NanoBjorn)) +- Segfault ile Düzeltme `bitmapHasAny` skaler alt sorguda [\#5528](https://github.com/ClickHouse/ClickHouse/pull/5528) ([Zhichang Yu](https://github.com/yuzhichang)) +- Sabit hata çoğaltma bağlantı havuzu DNS önbellek düştü bile, ana bilgisayarı çözmek için yeniden deneme değil. [\#5534](https://github.com/ClickHouse/ClickHouse/pull/5534) ([alesapin](https://github.com/alesapin)) +- Sabit `ALTER ... MODIFY TTL` ReplicatedMergeTree üzerinde. [\#5539](https://github.com/ClickHouse/ClickHouse/pull/5539) ([Anton Popov](https://github.com/CurtizJ)) +- SOMUTLAŞTIRILMIŞ sütun ile dağıtılmış tabloya ekleme düzeltin [\#5429](https://github.com/ClickHouse/ClickHouse/pull/5429) ([Azat Khuzhin](https://github.com/azat)) +- Birleştirme depolama alanını keserken hatalı ayırma düzeltildi [\#5437](https://github.com/ClickHouse/ClickHouse/pull/5437) ([TCeason](https://github.com/TCeason)) +- Tzdata paketinin son sürümlerinde bazı dosyalar artık sembolik bağlardır. Varsayılan zaman dilimini tespit etmek için geçerli mekanizma bozulur ve bazı zaman dilimleri için yanlış isimler verir. Şimdi en azından saat dilimi adını, sağlanırsa TZ içeriğine zorlarız. [\#5443](https://github.com/ClickHouse/ClickHouse/pull/5443) ([I ivanvan](https://github.com/abyss7)) +- Toplamı sabit iğneler en az 16KB uzun olduğunda MultiVolnitsky searcher ile bazı son derece nadir durumlarda düzeltin. Algoritma cevapsız veya yanlış sonuca yol açabilir önceki sonuçları overwrote `multiSearchAny`. [\#5588](https://github.com/ClickHouse/ClickHouse/pull/5588) ([Danila Kutenin](https://github.com/danlark1)) +- ExternalData istekleri için ayarlar ClickHouse ayarlarını kullanamadığında sorunu düzeltin. Ayrıca, şimdilik, ayarlar `date_time_input_format` ve `low_cardinality_allow_in_native_format` adların belirsizliği nedeniyle kullanılamaz (dış verilerde tablo biçimi olarak yorumlanabilir ve sorguda bir ayar olabilir). [\#5455](https://github.com/ClickHouse/ClickHouse/pull/5455) ([Danila Kutenin](https://github.com/danlark1)) +- Parçaları Zookeeper onları düşürmeden sadece FS kaldırıldı hata düzeltin. [\#5520](https://github.com/ClickHouse/ClickHouse/pull/5520) ([alesapin](https://github.com/alesapin)) +- MySQL protokolünden hata ayıklama günlüğü kaldırma [\#5478](https://github.com/ClickHouse/ClickHouse/pull/5478) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- DDL sorgu işleme sırasında znonode atla [\#5489](https://github.com/ClickHouse/ClickHouse/pull/5489) ([Azat Khuzhin](https://github.com/azat)) +- Fix mix `UNION ALL` sonuç sütun türü. Tutarsız veri ve sonuç sütunlarının sütun türleri olan durumlar vardı. [\#5503](https://github.com/ClickHouse/ClickHouse/pull/5503) ([Artem Zuikov](https://github.com/4ertus2)) +- Yanlış tamsayılar üzerinde bir istisna atmak `dictGetT` çökme yerine işlevler. [\#5446](https://github.com/ClickHouse/ClickHouse/pull/5446) ([Artem Zuikov](https://github.com/4ertus2)) +- Karma sözlük için yanlış element\_count ve load\_factor Fix `system.dictionaries` Tablo. [\#5440](https://github.com/ClickHouse/ClickHouse/pull/5440) ([Azat Khuzhin](https://github.com/azat)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-9} + +- Olmadan sabit yapı `Brotli` HTTP sıkıştırma desteği (`ENABLE_BROTLI=OFF` cmake değişkeni). [\#5521](https://github.com/ClickHouse/ClickHouse/pull/5521) ([Anton Yuzhaninov](https://github.com/citrin)) +- Kükreyen dahil.kükreyen/kükreyen olarak h.sa [\#5523](https://github.com/ClickHouse/ClickHouse/pull/5523) ([Orivej Desh](https://github.com/orivej)) +- Hyperscan'daki gcc9 uyarılarını düzeltin (\#line yönergesi kötüdür!) [\#5546](https://github.com/ClickHouse/ClickHouse/pull/5546) ([Danila Kutenin](https://github.com/danlark1)) +- Gcc-9 ile derlerken tüm uyarıları düzeltin. Bazı contrib sorunları düzeltin. Gcc9 ICE'Yİ düzeltin ve bugzilla'ya gönderin. [\#5498](https://github.com/ClickHouse/ClickHouse/pull/5498) ([Danila Kutenin](https://github.com/danlark1)) +- Lld ile sabit bağlantı [\#5477](https://github.com/ClickHouse/ClickHouse/pull/5477) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sözlüklerde kullanılmayan uzmanlıkları kaldırma [\#5452](https://github.com/ClickHouse/ClickHouse/pull/5452) ([Artem Zuikov](https://github.com/4ertus2)) +- Farklı dosya türleri için tabloları biçimlendirme ve ayrıştırma için iyileştirme performans testleri [\#5497](https://github.com/ClickHouse/ClickHouse/pull/5497) ([Olga Khvostikova](https://github.com/stavrolia)) +- Paralel test çalışması için düzeltmeler [\#5506](https://github.com/ClickHouse/ClickHouse/pull/5506) ([proller](https://github.com/proller)) +- Docker: clickhouse-test'ten yapılandırmaları kullanın [\#5531](https://github.com/ClickHouse/ClickHouse/pull/5531) ([proller](https://github.com/proller)) +- FreeBSD için derlemeyi düzeltin [\#5447](https://github.com/ClickHouse/ClickHouse/pull/5447) ([proller](https://github.com/proller)) +- Yükseltme boost için 1.70 [\#5570](https://github.com/ClickHouse/ClickHouse/pull/5570) ([proller](https://github.com/proller)) +- Yapı clickhouse'u submodule olarak düzeltin [\#5574](https://github.com/ClickHouse/ClickHouse/pull/5574) ([proller](https://github.com/proller)) +- Jsonextract performans testlerini geliştirin [\#5444](https://github.com/ClickHouse/ClickHouse/pull/5444) ([Vitaly Baranov](https://github.com/vitlibar)) + +## ClickHouse yayın 19.8 {#clickhouse-release-19-8} + +### ClickHouse yayın 19.8.3.8, 2019-06-11 {#clickhouse-release-19-8-3-8-2019-06-11} + +#### Yenilik {#new-features} + +- Json ile çalışmak için fonksiyonlar eklendi [\#4686](https://github.com/ClickHouse/ClickHouse/pull/4686) ([hcz](https://github.com/hczhcz)) [\#5124](https://github.com/ClickHouse/ClickHouse/pull/5124). ([Vitaly Baranov](https://github.com/vitlibar)) +- Bir çok dilde var olan bir basename işlevine benzer bir davranışa sahip bir işlev basename ekleyin (`os.path.basename` PY inth inon'da, `basename` in PHP, etc…). Work with both an UNIX-like path or a Windows path. [\#5136](https://github.com/ClickHouse/ClickHouse/pull/5136) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Katma `LIMIT n, m BY` veya `LIMIT m OFFSET n BY` limit BY yan tümcesi için n ofset ayarlamak için sözdizimi. [\#5138](https://github.com/ClickHouse/ClickHouse/pull/5138) ([Anton Popov](https://github.com/CurtizJ)) +- Yeni veri türü eklendi `SimpleAggregateFunction`, bir ışık toplama ile sütunlara sahip olmasını sağlar `AggregatingMergeTree`. Bu sadece aşağıdaki gibi basit işlevlerle kullanılabilir `any`, `anyLast`, `sum`, `min`, `max`. [\#4629](https://github.com/ClickHouse/ClickHouse/pull/4629) ([Boris Granveaud](https://github.com/bgranvea)) +- Fonksiyonda sabit olmayan argümanlar için destek eklendi `ngramDistance` [\#5198](https://github.com/ClickHouse/ClickHouse/pull/5198) ([Danila Kutenin](https://github.com/danlark1)) +- Eklenen fonksiyonlar `skewPop`, `skewSamp`, `kurtPop` ve `kurtSamp` sıra eğriliği, örnek eğrilik, kurtozis ve örnek kurtozis sırasıyla hesaplamak için. [\#5200](https://github.com/ClickHouse/ClickHouse/pull/5200) ([hcz](https://github.com/hczhcz)) +- Destek yeniden adlandırma işlemi için `MaterializeView` depolama. [\#5209](https://github.com/ClickHouse/ClickHouse/pull/5209) ([Guillaume Tassery](https://github.com/YiuRULE)) +- MySQL istemcisini kullanarak Clickhouse'a bağlanmayı sağlayan sunucu eklendi. [\#4715](https://github.com/ClickHouse/ClickHouse/pull/4715) ([Yuriy Baranov](https://github.com/yurriy)) +- Eklemek `toDecimal*OrZero` ve `toDecimal*OrNull` işlevler. [\#5291](https://github.com/ClickHouse/ClickHouse/pull/5291) ([Artem Zuikov](https://github.com/4ertus2)) +- Destek ondalık türleri fonksiyonları: `quantile`, `quantiles`, `median`, `quantileExactWeighted`, `quantilesExactWeighted`, medianExactWeighted. [\#5304](https://github.com/ClickHouse/ClickHouse/pull/5304) ([Artem Zuikov](https://github.com/4ertus2)) +- Katma `toValidUTF8` function, which replaces all invalid UTF-8 characters by replacement character � (U+FFFD). [\#5322](https://github.com/ClickHouse/ClickHouse/pull/5322) ([Danila Kutenin](https://github.com/danlark1)) +- Katma `format` işlev. Argümanlarda listelenen dizelerle sabit desen (basitleştirilmiş Python biçim deseni) biçimlendirme. [\#5330](https://github.com/ClickHouse/ClickHouse/pull/5330) ([Danila Kutenin](https://github.com/danlark1)) +- Katma `system.detached_parts` ayrılmış bölümleri hakkında bilgi içeren tablo `MergeTree` Tablolar. [\#5353](https://github.com/ClickHouse/ClickHouse/pull/5353) ([akuzm](https://github.com/akuzm)) +- Katma `ngramSearch` iğne ve Samanlık arasındaki simetrik olmayan farkı hesaplamak için işlev. [\#5418](https://github.com/ClickHouse/ClickHouse/pull/5418)[\#5422](https://github.com/ClickHouse/ClickHouse/pull/5422) ([Danila Kutenin](https://github.com/danlark1)) +- Temel makine öğrenimi yöntemlerinin (stokastik doğrusal regresyon ve lojistik regresyon) agrega fonksiyonları arayüzünü kullanarak uygulanması. Model ağırlıklarını güncellemek için farklı stratejilere sahiptir (basit Gradyan iniş, momentum yöntemi, Nesterov yöntemi). Ayrıca özel boyuttaki mini partileri de destekler. [\#4943](https://github.com/ClickHouse/ClickHouse/pull/4943) ([Quid37](https://github.com/Quid37)) +- Uygulanması `geohashEncode` ve `geohashDecode` işlevler. [\#5003](https://github.com/ClickHouse/ClickHouse/pull/5003) ([Vasily Nemkov](https://github.com/Enmk)) +- Toplama fonksiyonu eklendi `timeSeriesGroupSum`, hangi zaman damgası hizalama değil örnek farklı zaman serileri toplayabilir. İki örnek zaman damgası arasında doğrusal enterpolasyon kullanacak ve daha sonra zaman serilerini birlikte toplayacaktır. Toplama fonksiyonu eklendi `timeSeriesGroupRateSum`, zaman serisi ve daha sonra toplam oranları birlikte oranını hesaplar. [\#4542](https://github.com/ClickHouse/ClickHouse/pull/4542) ([Yangkuan Liu](https://github.com/LiuYangkuan)) +- Eklenen fonksiyonlar `IPv4CIDRtoIPv4Range` ve `IPv6CIDRtoIPv6Range` bir CIDR kullanarak alt ağdaki bir IP için alt ve üst sınırları hesaplamak için. [\#5095](https://github.com/ClickHouse/ClickHouse/pull/5095) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Etkin ayar ile HTTP kullanarak bir sorgu gönderdiğimizde bir X-ClickHouse-Summary Başlığı ekleyin `send_progress_in_http_headers`. Sorguda kaç satır ve bayt eklendiği gibi ek bilgilerle birlikte, x-ClickHouse-Progress'in olağan bilgilerini döndürün. [\#5116](https://github.com/ClickHouse/ClickHouse/pull/5116) ([Guillaume Tassery](https://github.com/YiuRULE)) + +#### Geliştirmeler {#improvements} + +- Katma `max_parts_in_total` bölüm anahtarı \#5166 güvenli olmayan belirtimini engelleyen mergetree ailesi tabloları (varsayılan: 100 000) için ayarlama. [\#5171](https://github.com/ClickHouse/ClickHouse/pull/5171) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- `clickhouse-obfuscator`: ilk tohum sütun adı, sütun konumu ile birleştirerek tek tek sütunlar için tohum türetmek. Bu, veri kümelerini birden çok ilgili tablolarla dönüştürmek için tasarlanmıştır, böylece tablolar dönüşümden sonra birleştirilebilir kalır. [\#5178](https://github.com/ClickHouse/ClickHouse/pull/5178) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Eklenen fonksiyonlar `JSONExtractRaw`, `JSONExtractKeyAndValues`. Yeniden adlandırılan işlevler `jsonExtract` -e doğru `JSONExtract`. Bir şeyler ters gittiğinde bu işlevler muhabir değerleri döndürür, değil `NULL`. Modifiye fonksiyonu `JSONExtract`, şimdi son parametresinden dönüş türünü alır ve nullables enjekte etmez. Avx2 talimatlarının mevcut olmaması durumunda Rapidjson'a geri dönüş uygulandı. Simdjson KÜTÜPHANESİ yeni bir sürüme güncellendi. [\#5235](https://github.com/ClickHouse/ClickHouse/pull/5235) ([Vitaly Baranov](https://github.com/vitlibar)) +- Şimdi `if` ve `multiIf` fonksiyonlar koşulun güvenmeyin `Nullable`, ancak SQL uyumluluğu için şubelere güvenin. [\#5238](https://github.com/ClickHouse/ClickHouse/pull/5238) ([Jian Wu.](https://github.com/janplus)) +- `In` yüklemi şimdi üretir `Null` sonucu `Null` gibi girdi `Equal` işlev. [\#5152](https://github.com/ClickHouse/ClickHouse/pull/5152) ([Jian Wu.](https://github.com/janplus)) +- Kafka'dan her (flush\_interval / poll\_timeout) satır sayısını zaman sınırını kontrol edin. Bu, Kafka tüketicisinden okumayı daha sık kırmaya ve üst düzey akışların zaman sınırlarını kontrol etmeye izin verir [\#5249](https://github.com/ClickHouse/ClickHouse/pull/5249) ([I ivanvan](https://github.com/abyss7)) +- Paketlenmiş SASL ile bağlantı RDKAFKA. SASL SCRAM kimlik doğrulamasını kullanmasına izin vermelidir [\#5253](https://github.com/ClickHouse/ClickHouse/pull/5253) ([I ivanvan](https://github.com/abyss7)) +- Tüm birleşimler için rowreflist'in toplu sürümü. [\#5267](https://github.com/ClickHouse/ClickHouse/pull/5267) ([Artem Zuikov](https://github.com/4ertus2)) +- clickhouse-sunucu: daha bilgilendirici dinleme hata mesajları. [\#5268](https://github.com/ClickHouse/ClickHouse/pull/5268) ([proller](https://github.com/proller)) +- Clickhouse destek sözlükler-fonksiyonlar için fotokopi `` [\#5270](https://github.com/ClickHouse/ClickHouse/pull/5270) ([proller](https://github.com/proller)) +- Yeni ayar Ekle `kafka_commit_every_batch` Kafka'nın taahhüt politikasını düzenlemek. + Taahhüt modunu ayarlamanıza izin verir: her mesaj Partisi işlendikten sonra veya tüm blok depolamaya yazıldıktan sonra. Bazı mesajları kaybetmek veya bazı aşırı durumlarda iki kez okumak arasında bir takas. [\#5308](https://github.com/ClickHouse/ClickHouse/pull/5308) ([I ivanvan](https://github.com/abyss7)) +- Yapmak `windowFunnel` diğer imzasız tamsayı türlerini destekleyin. [\#5320](https://github.com/ClickHouse/ClickHouse/pull/5320) ([sundyli](https://github.com/sundy-li)) +- Sanal sütunun gölgesine izin ver `_table` birleştirme motorunda. [\#5325](https://github.com/ClickHouse/ClickHouse/pull/5325) ([I ivanvan](https://github.com/abyss7)) +- Yapmak `sequenceMatch` toplu işlevler diğer imzasız tamsayı türlerini destekler [\#5339](https://github.com/ClickHouse/ClickHouse/pull/5339) ([sundyli](https://github.com/sundy-li)) +- Sağlama toplamı uyuşmazlığı büyük olasılıkla donanım hatalarından kaynaklanıyorsa daha iyi hata iletileri. [\#5355](https://github.com/ClickHouse/ClickHouse/pull/5355) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Altta yatan tabloların örneklemeyi desteklediğini kontrol edin `StorageMerge` [\#5366](https://github.com/ClickHouse/ClickHouse/pull/5366) ([I ivanvan](https://github.com/abyss7)) +- Сlose MySQL connections after their usage in external dictionaries. It is related to issue \#893. [\#5395](https://github.com/ClickHouse/ClickHouse/pull/5395) ([Clément Rodriguez](https://github.com/clemrodriguez)) +- MySQL Wire protokolünün iyileştirmeleri. MySQLWire biçiminin adını değiştirdi. Rsa\_free çağırmak için RAII kullanma. Bağlam oluşturulamıyorsa SSL'Yİ devre dışı bırakma. [\#5419](https://github.com/ClickHouse/ClickHouse/pull/5419) ([Yuriy Baranov](https://github.com/yurriy)) +- clickhouse-client: allow to run with unaccessable history file (read-only, no disk space, file is directory, …). [\#5431](https://github.com/ClickHouse/ClickHouse/pull/5431) ([proller](https://github.com/proller)) +- Dağıtılmış tablolara zaman uyumsuz ekler sorgu ayarlarını saygı. [\#4936](https://github.com/ClickHouse/ClickHouse/pull/4936) ([TCeason](https://github.com/TCeason)) +- Yeniden adlandırılan işlevler `leastSqr` -e doğru `simpleLinearRegression`, `LinearRegression` -e doğru `linearRegression`, `LogisticRegression` -e doğru `logisticRegression`. [\#5391](https://github.com/ClickHouse/ClickHouse/pull/5391) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) + +#### Performans İyileştirmeleri {#performance-improvements} + +- Parallelize işleme parçaları olmayan çoğaltılmış MergeTree tabloları alter değiştirme sorgu. [\#4639](https://github.com/ClickHouse/ClickHouse/pull/4639) ([Ivan Kush](https://github.com/IvanKush)) +- Düzenli ifadeler çıkarma optimizasyonlar. [\#5193](https://github.com/ClickHouse/ClickHouse/pull/5193) [\#5191](https://github.com/ClickHouse/ClickHouse/pull/5191) ([Danila Kutenin](https://github.com/danlark1)) +- Yalnızca joın on bölümünde kullanılıyorsa, sonucu birleştirmek için doğru joın anahtar sütunu eklemeyin. [\#5260](https://github.com/ClickHouse/ClickHouse/pull/5260) ([Artem Zuikov](https://github.com/4ertus2)) +- İlk boş yanıttan sonra Kafka tamponunu dondurun. Bu birden invokations önler `ReadBuffer::next()` bazı satır ayrıştırma akışlarında boş sonuç için. [\#5283](https://github.com/ClickHouse/ClickHouse/pull/5283) ([I ivanvan](https://github.com/abyss7)) +- `concat` birden çok argüman için işlev optimizasyonu. [\#5357](https://github.com/ClickHouse/ClickHouse/pull/5357) ([Danila Kutenin](https://github.com/danlark1)) +- Query optimisation. Allow push down IN statement while rewriting commа/cross join into inner one. [\#5396](https://github.com/ClickHouse/ClickHouse/pull/5396) ([Artem Zuikov](https://github.com/4ertus2)) +- Daha hızlı dekompresyona sahip olmak için lz4 uygulamamızı referansla yükseltin. [\#5070](https://github.com/ClickHouse/ClickHouse/pull/5070) ([Danila Kutenin](https://github.com/danlark1)) +- Uygulanan MSD radix sıralama (kxsort dayalı) ve kısmi sıralama. [\#5129](https://github.com/ClickHouse/ClickHouse/pull/5129) ([Evgenii Pravda](https://github.com/kvinty)) + +#### Hata Düzeltmeleri {#bug-fixes} + +- Fix itme birleştirme ile sütunlar gerektirir [\#5192](https://github.com/ClickHouse/ClickHouse/pull/5192) ([Kış Zhang](https://github.com/zhang2014)) +- ClickHouse systemd tarafından çalıştırıldığında Sabit hata, komut `sudo service clickhouse-server forcerestart` beklendiği gibi çalışmadı. [\#5204](https://github.com/ClickHouse/ClickHouse/pull/5204) ([proller](https://github.com/proller)) +- Datapartsexchange'deki http hata kodlarını düzeltin (9009 bağlantı noktasındaki ınterserver http Sunucusu, hatalarda bile her zaman 200 kodunu döndürdü). [\#5216](https://github.com/ClickHouse/ClickHouse/pull/5216) ([proller](https://github.com/proller)) +- Max\_small\_string\_size daha uzun dize için SimpleAggregateFunction Fix [\#5311](https://github.com/ClickHouse/ClickHouse/pull/5311) ([Azat Khuzhin](https://github.com/azat)) +- İçin hatayı Düzelt fixin `Decimal` -e doğru `Nullable(Decimal)` içinde dönüşüm. (Farklı ölçekler dahil) ondalık dönüşümler diğer ondalık destekleyin. [\#5350](https://github.com/ClickHouse/ClickHouse/pull/5350) ([Artem Zuikov](https://github.com/4ertus2)) +- Yanlış hesaplama yol simdjson kütüphanesinde sabit FPU clobbering `uniqHLL` ve `uniqCombined` toplama fonksiyonu ve matematik fonksiyonları gibi `log`. [\#5354](https://github.com/ClickHouse/ClickHouse/pull/5354) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Json işlevlerinde karışık const / nonconst durumlarda sabit taşıma. [\#5435](https://github.com/ClickHouse/ClickHouse/pull/5435) ([Vitaly Baranov](https://github.com/vitlibar)) +- Düzeltmek `retention` işlev. Şimdi bir veri satırında tatmin eden tüm koşullar veri durumuna eklenir. [\#5119](https://github.com/ClickHouse/ClickHouse/pull/5119) ([小路](https://github.com/nicelulu)) +- Sonuç türünü düzeltme `quantileExact` ondalık sayılarla. [\#5304](https://github.com/ClickHouse/ClickHouse/pull/5304) ([Artem Zuikov](https://github.com/4ertus2)) + +#### Belge {#documentation} + +- İçin belgeleri tercüme `CollapsingMergeTree` Çin. [\#5168](https://github.com/ClickHouse/ClickHouse/pull/5168) ([张风啸](https://github.com/AlexZFX)) +- Tablo motorları ile ilgili bazı belgeleri çince'ye çevirin. + [\#5134](https://github.com/ClickHouse/ClickHouse/pull/5134) + [\#5328](https://github.com/ClickHouse/ClickHouse/pull/5328) + ([Nev leeer lee](https://github.com/neverlee)) + +#### Yapı / Test / Ambalaj Geliştirmeleri {#buildtestingpackaging-improvements} + +- Olası kullanım sonrası ücretsiz gösteren bazı dezenfektan raporlarını düzeltin.[\#5139](https://github.com/ClickHouse/ClickHouse/pull/5139) [\#5143](https://github.com/ClickHouse/ClickHouse/pull/5143) [\#5393](https://github.com/ClickHouse/ClickHouse/pull/5393) ([I ivanvan](https://github.com/abyss7)) +- Kolaylık sağlamak için performans testlerini ayrı dizinlerden çıkarın. [\#5158](https://github.com/ClickHouse/ClickHouse/pull/5158) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yanlış performans testlerini düzeltin. [\#5255](https://github.com/ClickHouse/ClickHouse/pull/5255) ([alesapin](https://github.com/alesapin)) +- Donanım Sorunlarını ayıklamak için bit flips'in neden olduğu sağlama toplamlarını hesaplamak için bir araç eklendi. [\#5334](https://github.com/ClickHouse/ClickHouse/pull/5334) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Runner betiğini daha kullanışlı hale getirin. [\#5340](https://github.com/ClickHouse/ClickHouse/pull/5340)[\#5360](https://github.com/ClickHouse/ClickHouse/pull/5360) ([filimonov](https://github.com/filimonov)) +- Performans testlerinin nasıl yazılacağı konusunda küçük talimatlar ekleyin. [\#5408](https://github.com/ClickHouse/ClickHouse/pull/5408) ([alesapin](https://github.com/alesapin)) +- Performans testlerinde create, fill ve drop sorgularında değişiklik yapma yeteneği ekleme [\#5367](https://github.com/ClickHouse/ClickHouse/pull/5367) ([Olga Khvostikova](https://github.com/stavrolia)) + +## ClickHouse yayın 19.7 {#clickhouse-release-19-7} + +### ClickHouse yayın 19.7.5.29, 2019-07-05 {#clickhouse-release-19-7-5-29-2019-07-05} + +#### Hata Düzeltme {#bug-fix-25} + +- JOIN ile bazı sorgularda performans gerilemesini düzeltin. [\#5192](https://github.com/ClickHouse/ClickHouse/pull/5192) ([Kış Zhang](https://github.com/zhang2014)) + +### ClickHouse yayın 19.7.5.27, 2019-06-09 {#clickhouse-release-19-7-5-27-2019-06-09} + +#### Yenilik {#new-features-1} + +- Bitmap ile ilgili işlevler eklendi `bitmapHasAny` ve `bitmapHasAll` benzer `hasAny` ve `hasAll` diziler için fonksiyonlar. [\#5279](https://github.com/ClickHouse/ClickHouse/pull/5279) ([Sergi Vladykin](https://github.com/svladykin)) + +#### Hata Düzeltmeleri {#bug-fixes-1} + +- Segfault'u düzeltin `minmax` Null değeri ile dizin. [\#5246](https://github.com/ClickHouse/ClickHouse/pull/5246) ([Nikita Vasilev](https://github.com/nikvas0)) +- Tüm giriş sütunlarını LİMİT olarak gerekli çıktı olarak işaretleyin. Düzelt itiyor ‘Not found column’ bazı dağıtılmış sorgularda hata. [\#5407](https://github.com/ClickHouse/ClickHouse/pull/5407) ([Constantin S. Pan](https://github.com/kvap)) +- Düzeltmek “Column ‘0’ already exists” er errorror in `SELECT .. PREWHERE` ÖNTAN columnımlı süt onunda [\#5397](https://github.com/ClickHouse/ClickHouse/pull/5397) ([proller](https://github.com/proller)) +- Düzeltmek `ALTER MODIFY TTL` sorgu üzerinde `ReplicatedMergeTree`. [\#5539](https://github.com/ClickHouse/ClickHouse/pull/5539/commits) ([Anton Popov](https://github.com/CurtizJ)) +- Kafka tüketiciler başlatmak için başarısız olduğunda sunucu çökmesine etmeyin. [\#5285](https://github.com/ClickHouse/ClickHouse/pull/5285) ([I ivanvan](https://github.com/abyss7)) +- Sabit bitmap işlevleri yanlış sonuç üretir. [\#5359](https://github.com/ClickHouse/ClickHouse/pull/5359) ([Andy Yang](https://github.com/andyyzh)) +- Karma sözlük için element\_count'u düzeltin (çiftleri dahil etmeyin) [\#5440](https://github.com/ClickHouse/ClickHouse/pull/5440) ([Azat Khuzhin](https://github.com/azat)) +- Ortam değişkeni TZ içeriğini saat dilimi adı olarak kullanın. Bazı durumlarda varsayılan zaman dilimini doğru bir şekilde tespit etmeye yardımcı olur.[\#5443](https://github.com/ClickHouse/ClickHouse/pull/5443) ([I ivanvan](https://github.com/abyss7)) +- Tamsayıları dönüştürmeye çalışmayın `dictGetT` fonksiyonlar, çünkü düzgün çalışmıyor. Bunun yerine bir istisna atın. [\#5446](https://github.com/ClickHouse/ClickHouse/pull/5446) ([Artem Zuikov](https://github.com/4ertus2)) +- Harici ayarları düzeltinveri HTTP isteği. [\#5455](https://github.com/ClickHouse/ClickHouse/pull/5455) ([Danila. + Kutenin](https://github.com/danlark1)) +- Parçaları Zookeeper onları düşürmeden sadece FS kaldırıldı hata düzeltin. [\#5520](https://github.com/ClickHouse/ClickHouse/pull/5520) ([alesapin](https://github.com/alesapin)) +- Segmentasyon hatasını düzeltin `bitmapHasAny` işlev. [\#5528](https://github.com/ClickHouse/ClickHouse/pull/5528) ([Zhichang Yu](https://github.com/yuzhichang)) +- Sabit hata çoğaltma bağlantı havuzu DNS önbellek düştü bile, ana bilgisayarı çözmek için yeniden deneme değil. [\#5534](https://github.com/ClickHouse/ClickHouse/pull/5534) ([alesapin](https://github.com/alesapin)) +- Sabit `DROP INDEX IF EXISTS` sorgu. Şimdi `ALTER TABLE ... DROP INDEX IF EXISTS ...` sağlanan dizin yoksa, sorgu bir özel durum oluşturmaz. [\#5524](https://github.com/ClickHouse/ClickHouse/pull/5524) ([Gleb Novikov](https://github.com/NanoBjorn)) +- Birliği tüm supertype sütununu düzeltin. Tutarsız veri ve sonuç sütunlarının sütun türleri olan durumlar vardı. [\#5503](https://github.com/ClickHouse/ClickHouse/pull/5503) ([Artem Zuikov](https://github.com/4ertus2)) +- DDL sorgu işleme sırasında znonode atlayın. Başka bir düğüm, görev sırasındaki znode'u kaldırmadan önce, + bunu işlemedi, ancak zaten çocukların listesini al, DDLWorker iş parçacığını sonlandıracak. [\#5489](https://github.com/ClickHouse/ClickHouse/pull/5489) ([Azat Khuzhin](https://github.com/azat)) +- Somutlaştırılmış sütun ile dağıtılmış() tabloya Ekle düzeltin. [\#5429](https://github.com/ClickHouse/ClickHouse/pull/5429) ([Azat Khuzhin](https://github.com/azat)) + +### ClickHouse yayın 19.7.3.9, 2019-05-30 {#clickhouse-release-19-7-3-9-2019-05-30} + +#### Yenilik {#new-features-2} + +- Kullanıcı tarafından belirtilebilecek bir ayar aralığını sınırlamaya izin verin. + Bu kısıtlamalar kullanıcı ayarları profilinde ayarlanabilir. + [\#4931](https://github.com/ClickHouse/ClickHouse/pull/4931) ([Vitaly. + Baranov](https://github.com/vitlibar)) +- İşlevin ikinci bir sürümünü ekleyin `groupUniqArray` isteğe bağlı + `max_size` elde edilen dizinin boyutunu sınırlayan parametre. Bu + davranış benzer `groupArray(max_size)(x)` işlev. + [\#5026](https://github.com/ClickHouse/ClickHouse/pull/5026) ([Guillaume + Tassery](https://github.com/YiuRULE)) +- Tsvwithnames / CSVWithNames giriş dosya formatları için, sütun sırası şimdi olabilir + dosya başlığından belirlenir. Bu tarafından kontrol edilir + `input_format_with_names_use_header` parametre. + [\#5081](https://github.com/ClickHouse/ClickHouse/pull/5081) + ([İskender](https://github.com/Akazz)) + +#### Hata Düzeltmeleri {#bug-fixes-2} + +- Birleştirme sırasında uncompressed\_cache + JOİN ile kilitlenme (\#5197) + [\#5133](https://github.com/ClickHouse/ClickHouse/pull/5133) ([Danila. + Kutenin](https://github.com/danlark1)) +- Sistem tablolarına bir clickhouse-istemci sorgusunda segmentasyon hatası. \#5066 + [\#5127](https://github.com/ClickHouse/ClickHouse/pull/5127) + ([I ivanvan](https://github.com/abyss7)) +- KafkaEngine üzerinden ağır yükte veri kaybı (\#4736) + [\#5080](https://github.com/ClickHouse/ClickHouse/pull/5080) + ([I ivanvan](https://github.com/abyss7)) +- Sistemden en az iki seçmeyi içeren UNION ile bir sorgu yürütülürken gerçekleşebilecek çok nadir veri yarışı durumu düzeltildi.sütunlar, sistem.tablolar, sistem.parçalar, sistem.parts\_tables veya birleştirme ailesinin tabloları ve ilgili tabloların sütunlarının aynı anda değiştirilmesi. [\#5189](https://github.com/ClickHouse/ClickHouse/pull/5189) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Performans İyileştirmeleri {#performance-improvements-1} + +- Tek bir sayısal sütuna göre sıralama için radix sıralamasını kullanın `ORDER BY` olarak + `LIMIT`. [\#5106](https://github.com/ClickHouse/ClickHouse/pull/5106), + [\#4439](https://github.com/ClickHouse/ClickHouse/pull/4439) + ([Evgenii Pravda](https://github.com/kvinty), + [alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Belge {#documentation-1} + +- Bazı tablo motorları için belgeleri Çince'ye çevirin. + [\#5107](https://github.com/ClickHouse/ClickHouse/pull/5107), + [\#5094](https://github.com/ClickHouse/ClickHouse/pull/5094), + [\#5087](https://github.com/ClickHouse/ClickHouse/pull/5087) + ([张风啸](https://github.com/AlexZFX)), + [\#5068](https://github.com/ClickHouse/ClickHouse/pull/5068) ([asla + lee](https://github.com/neverlee)) + +#### Yapı / Test / Ambalaj Geliştirmeleri {#buildtestingpackaging-improvements-1} + +- UTF-8 karakterlerini düzgün bir şekilde yazdırın `clickhouse-test`. + [\#5084](https://github.com/ClickHouse/ClickHouse/pull/5084) + ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Her zaman öneri yüklemek için clickhouse-client için komut satırı parametresi ekleyin + veriler. [\#5102](https://github.com/ClickHouse/ClickHouse/pull/5102) + ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bazı PVS-Studio uyarılarını çözün. + [\#5082](https://github.com/ClickHouse/ClickHouse/pull/5082) + ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Güncelleme LZ4 [\#5040](https://github.com/ClickHouse/ClickHouse/pull/5040) ([Danila. + Kutenin](https://github.com/danlark1)) +- Yaklaşan çekme isteği \#5030 için gereksinimleri oluşturmak için gperf ekleyin. + [\#5110](https://github.com/ClickHouse/ClickHouse/pull/5110) + ([proller](https://github.com/proller)) + +## ClickHouse yayın 19.6 {#clickhouse-release-19-6} + +### ClickHouse yayın 19.6.3.18, 2019-06-13 {#clickhouse-release-19-6-3-18-2019-06-13} + +#### Hata Düzeltmeleri {#bug-fixes-3} + +- Tablo işlevlerinden sorgular için koşul pushdown sabit `mysql` ve `odbc` ve ilgili masa motorları. Bu düzeltmeler \# 3540 ve \# 2384. [\#5313](https://github.com/ClickHouse/ClickHouse/pull/5313) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Zookeeper kilitlenme Fix. [\#5297](https://github.com/ClickHouse/ClickHouse/pull/5297) ([github1youlc](https://github.com/github1youlc)) +- CSV'DE alıntı ondalık sayılara izin ver. [\#5284](https://github.com/ClickHouse/ClickHouse/pull/5284) ([Artem Zuikov](https://github.com/4ertus2) +- Float Inf/Nan'dan ondalık sayılara dönüştürmeye izin verme (istisna atma). [\#5282](https://github.com/ClickHouse/ClickHouse/pull/5282) ([Artem Zuikov](https://github.com/4ertus2)) +- Yeniden adlandırma sorgusunda veri yarışını düzeltin. [\#5247](https://github.com/ClickHouse/ClickHouse/pull/5247) ([Kış Zhang](https://github.com/zhang2014)) +- Lfalloc'u geçici olarak devre dışı bırakın. Lfalloc kullanımı, UncompressedCache tahsis edilmesinde ve yüksek yüklü sunuculardaki sorguların çökmesine neden olan bir çok MAP\_FAİLED'E yol açabilir. [cfdba93](https://github.com/ClickHouse/ClickHouse/commit/cfdba938ce22f16efeec504f7f90206a515b1280)([Danila Kutenin](https://github.com/danlark1)) + +### ClickHouse yayın 19.6.2.11, 2019-05-13 {#clickhouse-release-19-6-2-11-2019-05-13} + +#### Yenilik {#new-features-3} + +- Sütunlar ve tablolar için TTL ifadeleri. [\#4212](https://github.com/ClickHouse/ClickHouse/pull/4212) ([Anton Popov](https://github.com/CurtizJ)) +- İçin destek eklendi `brotli` http yanıtları için sıkıştırma (Accept-Encoding: br) [\#4388](https://github.com/ClickHouse/ClickHouse/pull/4388) ([Mikhail](https://github.com/fandyushin)) +- Yeni fonksiyon eklendi `isValidUTF8` bir bayt kümesinin doğru utf-8 kodlanmış olup olmadığını kontrol etmek için. [\#4934](https://github.com/ClickHouse/ClickHouse/pull/4934) ([Danila Kutenin](https://github.com/danlark1)) +- Yeni Yük Dengeleme ilkesi Ekle `first_or_random` bu, belirtilen ilk ana bilgisayara sorgular gönderir ve erişilemezse, rasgele ana bilgisayarlara sorgular gönderir. Çapraz çoğaltma topoloji kurulumları için kullanışlıdır. [\#5012](https://github.com/ClickHouse/ClickHouse/pull/5012) ([nvartolomei](https://github.com/nvartolomei)) + +#### Deneysel Özellikler {#experimental-features-1} + +- Ayar Ekle `index_granularity_bytes` (adaptive ındex granularity) MergeTree\* tablolar ailesi için. [\#4826](https://github.com/ClickHouse/ClickHouse/pull/4826) ([alesapin](https://github.com/alesapin)) + +#### Geliştirmeler {#improvements-1} + +- Fonksiyon için sabit olmayan ve negatif boyut ve uzunluk argümanları için destek eklendi `substringUTF8`. [\#4989](https://github.com/ClickHouse/ClickHouse/pull/4989) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sol joın sağ tablo, sol tablo sağ joın ve her iki tablo tam joın push-aşağı devre dışı bırakın. Bu, bazı durumlarda yanlış birleştirme sonuçlarını düzeltir. [\#4846](https://github.com/ClickHouse/ClickHouse/pull/4846) ([I ivanvan](https://github.com/abyss7)) +- `clickhouse-copier`: otomatik yükleme görev yapılandırması `--task-file` seçenek [\#4876](https://github.com/ClickHouse/ClickHouse/pull/4876) ([proller](https://github.com/proller)) +- Depolama Fabrikası ve masa fonksiyonları Fabrikası için yazım hataları işleyicisi eklendi. [\#4891](https://github.com/ClickHouse/ClickHouse/pull/4891) ([Danila Kutenin](https://github.com/danlark1)) +- Alt sorgular olmadan birden fazla birleşim için yıldız işaretlerini ve nitelikli yıldız işaretlerini destekleyin [\#4898](https://github.com/ClickHouse/ClickHouse/pull/4898) ([Artem Zuikov](https://github.com/4ertus2)) +- Eksik sütun hata mesajını daha kullanıcı dostu hale getirin. [\#4915](https://github.com/ClickHouse/ClickHouse/pull/4915) ([Artem Zuikov](https://github.com/4ertus2)) + +#### Performans İyileştirmeleri {#performance-improvements-2} + +- ASOF JOİN önemli hızlanma [\#4924](https://github.com/ClickHouse/ClickHouse/pull/4924) ([Martijn Bakker](https://github.com/Gladdy)) + +#### Geriye Dönük Uyumsuz Değişiklikler {#backward-incompatible-changes} + +- HTTP Başlığı `Query-Id` olarak değiştirildi `X-ClickHouse-Query-Id` tutarlılık için. [\#4972](https://github.com/ClickHouse/ClickHouse/pull/4972) ([Mikhail](https://github.com/fandyushin)) + +#### Hata Düzeltmeleri {#bug-fixes-4} + +- Sabit potansiyel boş işaretçi dereference `clickhouse-copier`. [\#4900](https://github.com/ClickHouse/ClickHouse/pull/4900) ([proller](https://github.com/proller)) +- JOİN + ARRAY JOİN ile sorguda Sabit hata [\#4938](https://github.com/ClickHouse/ClickHouse/pull/4938) ([Artem Zuikov](https://github.com/4ertus2)) +- Bir sözlük engine=Dictionary ile bir veritabanı üzerinden başka bir sözlüğe bağlı olduğunda sunucunun başlangıcında asılı sabit. [\#4962](https://github.com/ClickHouse/ClickHouse/pull/4962) ([Vitaly Baranov](https://github.com/vitlibar)) +- Partially fix distributed\_product\_mode = local. It's possible to allow columns of local tables in where/having/order by/… via table aliases. Throw exception if table does not have alias. There's not possible to access to the columns without table aliases yet. [\#4986](https://github.com/ClickHouse/ClickHouse/pull/4986) ([Artem Zuikov](https://github.com/4ertus2)) +- Potansiyel olarak yanlış sonucu düzeltin `SELECT DISTINCT` ile `JOIN` [\#5001](https://github.com/ClickHouse/ClickHouse/pull/5001) ([Artem Zuikov](https://github.com/4ertus2)) +- Sistemden en az iki seçmeyi içeren UNION ile bir sorgu yürütülürken gerçekleşebilecek çok nadir veri yarışı durumu düzeltildi.sütunlar, sistem.tablolar, sistem.parçalar, sistem.parts\_tables veya birleştirme ailesinin tabloları ve ilgili tabloların sütunlarının aynı anda değiştirilmesi. [\#5189](https://github.com/ClickHouse/ClickHouse/pull/5189) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Yapı / Test / Ambalaj Geliştirmeleri {#buildtestingpackaging-improvements-2} + +- Farklı ana bilgisayarda clickhouse-server çalıştırırken sabit test hataları [\#4713](https://github.com/ClickHouse/ClickHouse/pull/4713) ([Vasily Nemkov](https://github.com/Enmk)) +- clickhouse-test: tty olmayan ortamda renk kontrol dizilerini devre dışı bırakın. [\#4937](https://github.com/ClickHouse/ClickHouse/pull/4937) ([alesapin](https://github.com/alesapin)) +- clickhouse-test: herhangi bir test veritabanını kullanmasına izin ver (Kaldır `test.` mümkün olduğu yerde yeterlilik) [\#5008](https://github.com/ClickHouse/ClickHouse/pull/5008) ([proller](https://github.com/proller)) +- Ubsan hatalarını düzeltin [\#5037](https://github.com/ClickHouse/ClickHouse/pull/5037) ([Vitaly Baranov](https://github.com/vitlibar)) +- Yandex LFAlloc, Segfault'ları daha güvenilir yakalamak için MarkCache ve UncompressedCache verilerini farklı şekillerde ayırmak için Clickhouse'a eklendi [\#4995](https://github.com/ClickHouse/ClickHouse/pull/4995) ([Danila Kutenin](https://github.com/danlark1)) +- Python util backports ve changelogs ile yardımcı olmak için. [\#4949](https://github.com/ClickHouse/ClickHouse/pull/4949) ([I ivanvan](https://github.com/abyss7)) + +## ClickHouse sürümü 19.5 {#clickhouse-release-19-5} + +### ClickHouse yayın 19.5.4.22, 2019-05-13 {#clickhouse-release-19-5-4-22-2019-05-13} + +#### Hata düzeltmeleri {#bug-fixes-5} + +- Bitmap sabit Olası kazasında \* fonksiyonlar [\#5220](https://github.com/ClickHouse/ClickHouse/pull/5220) [\#5228](https://github.com/ClickHouse/ClickHouse/pull/5228) ([Andy Yang](https://github.com/andyyzh)) +- Sistemden en az iki seçmeyi içeren UNION ile bir sorgu yürütülürken gerçekleşebilecek çok nadir veri yarışı durumu düzeltildi.sütunlar, sistem.tablolar, sistem.parçalar, sistem.parts\_tables veya birleştirme ailesinin tabloları ve ilgili tabloların sütunlarının aynı anda değiştirilmesi. [\#5189](https://github.com/ClickHouse/ClickHouse/pull/5189) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit hata `Set for IN is not created yet in case of using single LowCardinality column in the left part of IN`. Bu hata, lowcardinality sütunu birincil anahtarın bir parçasıysa oldu. \#5031 [\#5154](https://github.com/ClickHouse/ClickHouse/pull/5154) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Tutma işlevinin değiştirilmesi: bir satır hem ilk hem de n. koşulu yerine getirirse, veri durumuna yalnızca ilk tatmin edilen koşul eklenir. Şimdi bir veri satırında tatmin eden tüm koşullar veri durumuna eklenir. [\#5119](https://github.com/ClickHouse/ClickHouse/pull/5119) ([小路](https://github.com/nicelulu)) + +### ClickHouse yayın 19.5.3.8, 2019-04-18 {#clickhouse-release-19-5-3-8-2019-04-18} + +#### Hata düzeltmeleri {#bug-fixes-6} + +- Sabit ayar türü `max_partitions_per_insert_block` boolean'dan Uint64'e. [\#5028](https://github.com/ClickHouse/ClickHouse/pull/5028) ([Muhammed Hüseyin Sekhavat](https://github.com/mhsekhavat)) + +### ClickHouse yayın 19.5.2.6, 2019-04-15 {#clickhouse-release-19-5-2-6-2019-04-15} + +#### Yenilik {#new-features-4} + +- [Hyperscan](https://github.com/intel/hyperscan) çoklu düzenli ifade eşleştirme eklendi (fonksiyonlar `multiMatchAny`, `multiMatchAnyIndex`, `multiFuzzyMatchAny`, `multiFuzzyMatchAnyIndex`). [\#4780](https://github.com/ClickHouse/ClickHouse/pull/4780), [\#4841](https://github.com/ClickHouse/ClickHouse/pull/4841) ([Danila Kutenin](https://github.com/danlark1)) +- `multiSearchFirstPosition` işlevi eklendi. [\#4780](https://github.com/ClickHouse/ClickHouse/pull/4780) ([Danila Kutenin](https://github.com/danlark1)) +- Tablolar için satır başına önceden tanımlanmış ifade filtresini uygulayın. [\#4792](https://github.com/ClickHouse/ClickHouse/pull/4792) ([I ivanvan](https://github.com/abyss7)) +- Bloom filtrelerine dayalı endeksleri atlama veri yeni bir tür (için kullanılabilir `equal`, `in` ve `like` işlevler). [\#4499](https://github.com/ClickHouse/ClickHouse/pull/4499) ([Nikita Vasilev](https://github.com/nikvas0)) +- Katma `ASOF JOIN` bilinen en son değere katılan sorguları çalıştırmaya izin verir. [\#4774](https://github.com/ClickHouse/ClickHouse/pull/4774) [\#4867](https://github.com/ClickHouse/ClickHouse/pull/4867) [\#4863](https://github.com/ClickHouse/ClickHouse/pull/4863) [\#4875](https://github.com/ClickHouse/ClickHouse/pull/4875) ([Martijn Bakker](https://github.com/Gladdy), [Artem Zuikov](https://github.com/4ertus2)) +- Birden fazla yeniden yaz `COMMA JOIN` -e doğru `CROSS JOIN`. Sonra onları yeniden yaz `INNER JOIN` mümkünse. [\#4661](https://github.com/ClickHouse/ClickHouse/pull/4661) ([Artem Zuikov](https://github.com/4ertus2)) + +#### Geliştirme {#improvement-9} + +- `topK` ve `topKWeighted` Şimdi özel destekler `loadFactor` (düzeltmeler sorunu [\#4252](https://github.com/ClickHouse/ClickHouse/issues/4252)). [\#4634](https://github.com/ClickHouse/ClickHouse/pull/4634) ([Kirill Danshin](https://github.com/kirillDanshin)) +- Kullanmasına izin ver `parallel_replicas_count > 1` örnekleme olmadan tablolar için bile (ayar sadece onlar için göz ardı edilir). Önceki sürümlerde istisna yol oldu. [\#4637](https://github.com/ClickHouse/ClickHouse/pull/4637) ([Alexey Elymanov](https://github.com/digitalist)) +- İçin destek `CREATE OR REPLACE VIEW`. Bir görünüm oluşturmak veya tek bir deyimde yeni bir tanım ayarlamak için izin ver. [\#4654](https://github.com/ClickHouse/ClickHouse/pull/4654) ([Boris Granveaud](https://github.com/bgranvea)) +- `Buffer` tablo motoru şimdi destekler `PREWHERE`. [\#4671](https://github.com/ClickHouse/ClickHouse/pull/4671) ([Yangkuan Liu](https://github.com/LiuYangkuan)) +- Zookeeper içinde meta veri olmadan çoğaltılmış tablo başlatmak için yeteneği ekleyin `readonly` modu. [\#4691](https://github.com/ClickHouse/ClickHouse/pull/4691) ([alesapin](https://github.com/alesapin)) +- Clickhouse-client ilerleme çubuğunun sabit titreme. Kullanırken sorun en dikkat çekiciydi `FORMAT Null` akış sorguları ile. [\#4811](https://github.com/ClickHouse/ClickHouse/pull/4811) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İle işlevleri devre dışı bırakmak için izin ver `hyperscan` potansiyel olarak aşırı ve kontrolsüz kaynak kullanımını sınırlamak için kullanıcı bazında kütüphane. [\#4816](https://github.com/ClickHouse/ClickHouse/pull/4816) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tüm hatalarda sürüm numarası günlüğü ekleyin. [\#4824](https://github.com/ClickHouse/ClickHouse/pull/4824) ([proller](https://github.com/proller)) +- Kısıtlama eklendi `multiMatch` içine sığacak şekilde dize boyutu gerektiren işlevler `unsigned int`. Ayrıca bağımsız değişken sayısı sınırı eklendi `multiSearch` işlevler. [\#4834](https://github.com/ClickHouse/ClickHouse/pull/4834) ([Danila Kutenin](https://github.com/danlark1)) +- Hyperscan çizik alanı ve hata işleme geliştirilmiş kullanımı. [\#4866](https://github.com/ClickHouse/ClickHouse/pull/4866) ([Danila Kutenin](https://github.com/danlark1)) +- Doldurma `system.graphite_detentions` bir tablo yapılandırmasından `*GraphiteMergeTree` motor tabloları. [\#4584](https://github.com/ClickHouse/ClickHouse/pull/4584) ([Mikhail f. Shiryaev](https://github.com/Felixoid)) +- Adlandırmak `trigramDistance` fonksiyonu için `ngramDistance` ve daha fazla fonksiyon ekleyin `CaseInsensitive` ve `UTF`. [\#4602](https://github.com/ClickHouse/ClickHouse/pull/4602) ([Danila Kutenin](https://github.com/danlark1)) +- Geliştirilmiş veri endeksleri hesaplama atlama. [\#4640](https://github.com/ClickHouse/ClickHouse/pull/4640) ([Nikita Vasilev](https://github.com/nikvas0)) +- Sıradan tutmak, `DEFAULT`, `MATERIALIZED` ve `ALIAS` tek bir listedeki sütunlar (düzeltmeler sorunu [\#2867](https://github.com/ClickHouse/ClickHouse/issues/2867)). [\#4707](https://github.com/ClickHouse/ClickHouse/pull/4707) ([Alex Zatelepin](https://github.com/ztlpn)) + +#### Hata Düzeltme {#bug-fix-26} + +- Önlemek `std::terminate` bellek ayırma hatası durumunda. Şimdi `std::bad_alloc` istisna beklendiği gibi atılır. [\#4665](https://github.com/ClickHouse/ClickHouse/pull/4665) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tampondan capnproto okumasını düzeltir. Bazen dosyalar HTTP tarafından başarıyla yüklenmedi. [\#4674](https://github.com/ClickHouse/ClickHouse/pull/4674) ([Vladislav](https://github.com/smirnov-vs)) +- Hatayı Düzelt `Unknown log entry type: 0` sonra `OPTIMIZE TABLE FINAL` sorgu. [\#4683](https://github.com/ClickHouse/ClickHouse/pull/4683) ([Amos Kuşu](https://github.com/amosbird)) +- Yanlış argümanlar `hasAny` veya `hasAll` fonksiyonlar segfault yol açabilir. [\#4698](https://github.com/ClickHouse/ClickHouse/pull/4698) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yürütme sırasında kilitlenme oluşabilir `DROP DATABASE dictionary` sorgu. [\#4701](https://github.com/ClickHouse/ClickHouse/pull/4701) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tanımsız davranışı düzeltin `median` ve `quantile` işlevler. [\#4702](https://github.com/ClickHouse/ClickHouse/pull/4702) ([hcz](https://github.com/hczhcz)) +- Sıkıştırma seviyesi algılamasını ne zaman düzeltin `network_compression_method` küçük harfle. V19. 1'de kırık. [\#4706](https://github.com/ClickHouse/ClickHouse/pull/4706) ([proller](https://github.com/proller)) +- Sabit ceh ofalet `UTC` ayar (düzeltmeler sorunu [\#4658](https://github.com/ClickHouse/ClickHouse/issues/4658)). [\#4718](https://github.com/ClickHouse/ClickHouse/pull/4718) ([proller](https://github.com/proller)) +- Düzeltmek `histogram` fonksiyon davranışı ile `Distributed` Tablolar. [\#4741](https://github.com/ClickHouse/ClickHouse/pull/4741) ([olegkv](https://github.com/olegkv)) +- Sabit tsan raporu `destroy of a locked mutex`. [\#4742](https://github.com/ClickHouse/ClickHouse/pull/4742) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Nedeniyle sistem günlükleri kullanımında yarış durumuna kapatma sabit TSan raporu. Part\_log etkinleştirildiğinde kapatma sırasında sabit potansiyel kullanım sonrası serbest. [\#4758](https://github.com/ClickHouse/ClickHouse/pull/4758) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Parçaları tekrar kontrol edin `ReplicatedMergeTreeAlterThread` hata durumunda. [\#4772](https://github.com/ClickHouse/ClickHouse/pull/4772) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Ara toplama işlev durumlarındaki aritmetik işlemler sabit argümanlar (alt sorgu sonuçları gibi) için çalışmadı. [\#4776](https://github.com/ClickHouse/ClickHouse/pull/4776) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Her zaman meta veri sütun adlarını backquote. Aksi takdirde, adlandırılmış sütunlu bir tablo oluşturmak imkansızdır `index` (sunucu hatalı biçimlendirilmiş nedeniyle yeniden başlatılmaz `ATTACH` metadata sorgu). [\#4782](https://github.com/ClickHouse/ClickHouse/pull/4782) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Çökmeyi düzeltin `ALTER ... MODIFY ORDER BY` üzerinde `Distributed` Tablo. [\#4790](https://github.com/ClickHouse/ClickHouse/pull/4790) ([TCeason](https://github.com/TCeason)) +- Segfault'u düzeltin `JOIN ON` ile etkin `enable_optimize_predicate_expression`. [\#4794](https://github.com/ClickHouse/ClickHouse/pull/4794) ([Kış Zhang](https://github.com/zhang2014)) +- Kafka'dan bir protobuf mesajı tükettikten sonra yabancı bir satır ekleyerek hatayı düzeltin. [\#4808](https://github.com/ClickHouse/ClickHouse/pull/4808) ([Vitaly Baranov](https://github.com/vitlibar)) +- 'Nin çökmesini düzeltin `JOIN` null olmayan vs null sütun üzerinde. Düzeltmek `NULLs` sağ tuş inlarda `ANY JOIN` + `join_use_nulls`. [\#4815](https://github.com/ClickHouse/ClickHouse/pull/4815) ([Artem Zuikov](https://github.com/4ertus2)) +- Segmentasyon hatasını düzeltin `clickhouse-copier`. [\#4835](https://github.com/ClickHouse/ClickHouse/pull/4835) ([proller](https://github.com/proller)) +- Sabit yarış durumu `SELECT` itibaren `system.tables` tablo aynı anda yeniden adlandırılırsa veya değiştirilirse. [\#4836](https://github.com/ClickHouse/ClickHouse/pull/4836) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Zaten eskimiş olan veri bölümünü getirirken sabit veri yarışı. [\#4839](https://github.com/ClickHouse/ClickHouse/pull/4839) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sırasında meydana gelebilecek sabit nadir veri yarışı `RENAME` MergeTree ailesinin tablo. [\#4844](https://github.com/ClickHouse/ClickHouse/pull/4844) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Fonksiyonda sabit segmentasyon hatası `arrayIntersect`. Fonksiyon karışık sabit ve sıradan argümanlarla çağrılırsa segmentasyon hatası olabilir. [\#4847](https://github.com/ClickHouse/ClickHouse/pull/4847) ([Lixiang Qian](https://github.com/fancyqlx)) +- Sabit okuma `Array(LowCardinality)` sütun nadir durumda, sütun uzun bir boş diziler dizisi içerdiğinde. [\#4850](https://github.com/ClickHouse/ClickHouse/pull/4850) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Çökmeyi düzeltin `FULL/RIGHT JOIN` biz nullable vs değil nullable üzerinde katılırken. [\#4855](https://github.com/ClickHouse/ClickHouse/pull/4855) ([Artem Zuikov](https://github.com/4ertus2)) +- Düzeltmek `No message received` kopyaları arasındaki parçaları getirirken istisna. [\#4856](https://github.com/ClickHouse/ClickHouse/pull/4856) ([alesapin](https://github.com/alesapin)) +- Sabit `arrayIntersect` tek dizide birkaç tekrarlanan değerler durumunda işlev yanlış sonuç. [\#4871](https://github.com/ClickHouse/ClickHouse/pull/4871) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Eşzamanlı sırasında bir yarış durumunu düzeltin `ALTER COLUMN` bir sunucu çökmesine neden olabilecek sorgular (düzeltmeler sorunu [\#3421](https://github.com/ClickHouse/ClickHouse/issues/3421)). [\#4592](https://github.com/ClickHouse/ClickHouse/pull/4592) ([Alex Zatelepin](https://github.com/ztlpn)) +- Yanlış sonucu düzeltin `FULL/RIGHT JOIN` const sütunu ile. [\#4723](https://github.com/ClickHouse/ClickHouse/pull/4723) ([Artem Zuikov](https://github.com/4ertus2)) +- Çiftleri düzeltin `GLOBAL JOIN` yıldız işareti ile. [\#4705](https://github.com/ClickHouse/ClickHouse/pull/4705) ([Artem Zuikov](https://github.com/4ertus2)) +- Parametre kesintisini düzeltin `ALTER MODIFY` of Col ofum ofn `CODEC` sütun türü belirtilmediğinde. [\#4883](https://github.com/ClickHouse/ClickHouse/pull/4883) ([alesapin](https://github.com/alesapin)) +- İşlevler `cutQueryStringAndFragment()` ve `queryStringAndFragment()` şimdi ne zaman doğru çalışıyor `URL` bir parça ve hiçbir sorgu içerir. [\#4894](https://github.com/ClickHouse/ClickHouse/pull/4894) ([Vitaly Baranov](https://github.com/vitlibar)) +- Ayarlarken nadir hatayı düzeltin `min_bytes_to_use_direct_io` iş parçacığı sütun dosyasında geriye aramak zorunda olduğunda oluşan sıfırdan büyüktür. [\#4897](https://github.com/ClickHouse/ClickHouse/pull/4897) ([alesapin](https://github.com/alesapin)) +- Toplama işlevleri için yanlış argüman türlerini düzeltin `LowCardinality` argümanlar (düzeltmeler sorunu [\#4919](https://github.com/ClickHouse/ClickHouse/issues/4919)). [\#4922](https://github.com/ClickHouse/ClickHouse/pull/4922) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Yanlış isim kalifikasyonunu düzeltin `GLOBAL JOIN`. [\#4969](https://github.com/ClickHouse/ClickHouse/pull/4969) ([Artem Zuikov](https://github.com/4ertus2)) +- Düzeltme fonksiyonu `toISOWeek` 1970 yılı için sonuç. [\#4988](https://github.com/ClickHouse/ClickHouse/pull/4988) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Düzeltmek `DROP`, `TRUNCATE` ve `OPTIMIZE` sorgular, çoğaltma, dosya üzerinde `ON CLUSTER` için `ReplicatedMergeTree*` tablolar aile. [\#4991](https://github.com/ClickHouse/ClickHouse/pull/4991) ([alesapin](https://github.com/alesapin)) + +#### Geriye Dönük Uyumsuz Değişim {#backward-incompatible-change-8} + +- Ayarı yeniden adlandır `insert_sample_with_metadata` ayarlamak `input_format_defaults_for_omitted_fields`. [\#4771](https://github.com/ClickHouse/ClickHouse/pull/4771) ([Artem Zuikov](https://github.com/4ertus2)) +- Ayar eklendi `max_partitions_per_insert_block` (varsayılan değer 100 ile). Eklenen blok daha fazla sayıda bölüm içeriyorsa, bir özel durum atılır. Sınırı kaldırmak istiyorsanız 0 olarak ayarlayın (önerilmez). [\#4845](https://github.com/ClickHouse/ClickHouse/pull/4845) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Çoklu arama işlevleri yeniden adlandırıldı (`multiPosition` -e doğru `multiSearchAllPositions`, `multiSearch` -e doğru `multiSearchAny`, `firstMatch` -e doğru `multiSearchFirstIndex`). [\#4780](https://github.com/ClickHouse/ClickHouse/pull/4780) ([Danila Kutenin](https://github.com/danlark1)) + +#### Performans İyileştirme {#performance-improvement-6} + +- Birçok İğne veya birçok benzer bigrams ile sorgular için yaklaşık %5-10 arama iyileştirme vererek, inlining tarafından volnitsky searcher Optimize edin. [\#4862](https://github.com/ClickHouse/ClickHouse/pull/4862) ([Danila Kutenin](https://github.com/danlark1)) +- Ayarlarken performans sorununu düzeltin `use_uncompressed_cache` önbellekte bulunan tüm okuma verileri göründüğünde ortaya çıkan sıfırdan büyüktür. [\#4913](https://github.com/ClickHouse/ClickHouse/pull/4913) ([alesapin](https://github.com/alesapin)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-10} + +- Sertleştirme hata ayıklama yapı: daha ayrıntılı bellek eşlemeleri ve ASLR; ışareti önbellek ve dizin için bellek koruması ekleyin. Bu ASan ve MSan bunu yapamaz durumda daha fazla bellek stomping hata bulmanızı sağlar. [\#4632](https://github.com/ClickHouse/ClickHouse/pull/4632) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Cmake değişkenleri için destek Ekle `ENABLE_PROTOBUF`, `ENABLE_PARQUET` ve `ENABLE_BROTLI` yukarıdaki özellikleri etkinleştirmeye / devre dışı bırakmaya izin verir (librdkafka, mysql, vb.için yapabileceğimiz gibi). [\#4669](https://github.com/ClickHouse/ClickHouse/pull/4669) ([Silviu Caragea](https://github.com/silviucpp)) +- Bazı sorgular test çalıştırıldıktan sonra asılırsa, işlem listesi ve tüm iş parçacıklarının stacktraces yazdırmak için yeteneği ekleyin. [\#4675](https://github.com/ClickHouse/ClickHouse/pull/4675) ([alesapin](https://github.com/alesapin)) +- Yeniden deneme Ekle `Connection loss` er errorror in `clickhouse-test`. [\#4682](https://github.com/ClickHouse/ClickHouse/pull/4682) ([alesapin](https://github.com/alesapin)) +- Vagrant ile freebsd build ekleyin ve packager komut dosyasına iş parçacığı sanitizer ile oluşturun. [\#4712](https://github.com/ClickHouse/ClickHouse/pull/4712) [\#4748](https://github.com/ClickHouse/ClickHouse/pull/4748) ([alesapin](https://github.com/alesapin)) +- Şimdi kullanıcı kullanıcı için şifre istedi `'default'` kurulum sırasında. [\#4725](https://github.com/ClickHouse/ClickHouse/pull/4725) ([proller](https://github.com/proller)) +- İçinde uyarı bastır warningmak `rdkafka` kitaplık. [\#4740](https://github.com/ClickHouse/ClickHouse/pull/4740) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Ssl olmadan oluşturma yeteneğine izin ver. [\#4750](https://github.com/ClickHouse/ClickHouse/pull/4750) ([proller](https://github.com/proller)) +- Clickhouse-sunucu görüntüsünü özel bir kullanıcıdan başlatmanın bir yolunu ekleyin. [\#4753](https://github.com/ClickHouse/ClickHouse/pull/4753) ([Mikhail f. Shiryaev](https://github.com/Felixoid)) +- Contrib Boost'u 1.69'a yükseltin. [\#4793](https://github.com/ClickHouse/ClickHouse/pull/4793) ([proller](https://github.com/proller)) +- Kullanımını devre dışı bırak `mremap` iplik dezenfektanı ile derlendiğinde. Şaşırtıcı bir şekilde, TSan kesişmiyor `mremap` (kes doesmesine rağmen `mmap`, `munmap`) bu yanlış pozitiflere yol açar. Durumsal testlerde sabit TSan raporu. [\#4859](https://github.com/ClickHouse/ClickHouse/pull/4859) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- HTTP arayüzü üzerinden biçim şemasını kullanarak test denetimi ekleyin. [\#4864](https://github.com/ClickHouse/ClickHouse/pull/4864) ([Vitaly Baranov](https://github.com/vitlibar)) + +## ClickHouse sürüm 19.4 {#clickhouse-release-19-4} + +### ClickHouse yayın 19.4.4.33, 2019-04-17 {#clickhouse-release-19-4-4-33-2019-04-17} + +#### Hata Düzeltmeleri {#bug-fixes-7} + +- Önlemek `std::terminate` bellek ayırma hatası durumunda. Şimdi `std::bad_alloc` istisna beklendiği gibi atılır. [\#4665](https://github.com/ClickHouse/ClickHouse/pull/4665) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tampondan capnproto okumasını düzeltir. Bazen dosyalar HTTP tarafından başarıyla yüklenmedi. [\#4674](https://github.com/ClickHouse/ClickHouse/pull/4674) ([Vladislav](https://github.com/smirnov-vs)) +- Hatayı Düzelt `Unknown log entry type: 0` sonra `OPTIMIZE TABLE FINAL` sorgu. [\#4683](https://github.com/ClickHouse/ClickHouse/pull/4683) ([Amos Kuşu](https://github.com/amosbird)) +- Yanlış argümanlar `hasAny` veya `hasAll` fonksiyonlar segfault yol açabilir. [\#4698](https://github.com/ClickHouse/ClickHouse/pull/4698) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yürütme sırasında kilitlenme oluşabilir `DROP DATABASE dictionary` sorgu. [\#4701](https://github.com/ClickHouse/ClickHouse/pull/4701) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tanımsız davranışı düzeltin `median` ve `quantile` işlevler. [\#4702](https://github.com/ClickHouse/ClickHouse/pull/4702) ([hcz](https://github.com/hczhcz)) +- Sıkıştırma seviyesi algılamasını ne zaman düzeltin `network_compression_method` küçük harfle. V19. 1'de kırık. [\#4706](https://github.com/ClickHouse/ClickHouse/pull/4706) ([proller](https://github.com/proller)) +- Sabit ceh ofalet `UTC` ayar (düzeltmeler sorunu [\#4658](https://github.com/ClickHouse/ClickHouse/issues/4658)). [\#4718](https://github.com/ClickHouse/ClickHouse/pull/4718) ([proller](https://github.com/proller)) +- Düzeltmek `histogram` fonksiyon davranışı ile `Distributed` Tablolar. [\#4741](https://github.com/ClickHouse/ClickHouse/pull/4741) ([olegkv](https://github.com/olegkv)) +- Sabit tsan raporu `destroy of a locked mutex`. [\#4742](https://github.com/ClickHouse/ClickHouse/pull/4742) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Nedeniyle sistem günlükleri kullanımında yarış durumuna kapatma sabit TSan raporu. Part\_log etkinleştirildiğinde kapatma sırasında sabit potansiyel kullanım sonrası serbest. [\#4758](https://github.com/ClickHouse/ClickHouse/pull/4758) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Parçaları tekrar kontrol edin `ReplicatedMergeTreeAlterThread` hata durumunda. [\#4772](https://github.com/ClickHouse/ClickHouse/pull/4772) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Ara toplama işlev durumlarındaki aritmetik işlemler sabit argümanlar (alt sorgu sonuçları gibi) için çalışmadı. [\#4776](https://github.com/ClickHouse/ClickHouse/pull/4776) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Her zaman meta veri sütun adlarını backquote. Aksi takdirde, adlandırılmış sütunlu bir tablo oluşturmak imkansızdır `index` (sunucu hatalı biçimlendirilmiş nedeniyle yeniden başlatılmaz `ATTACH` metadata sorgu). [\#4782](https://github.com/ClickHouse/ClickHouse/pull/4782) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Çökmeyi düzeltin `ALTER ... MODIFY ORDER BY` üzerinde `Distributed` Tablo. [\#4790](https://github.com/ClickHouse/ClickHouse/pull/4790) ([TCeason](https://github.com/TCeason)) +- Segfault'u düzeltin `JOIN ON` ile etkin `enable_optimize_predicate_expression`. [\#4794](https://github.com/ClickHouse/ClickHouse/pull/4794) ([Kış Zhang](https://github.com/zhang2014)) +- Kafka'dan bir protobuf mesajı tükettikten sonra yabancı bir satır ekleyerek hatayı düzeltin. [\#4808](https://github.com/ClickHouse/ClickHouse/pull/4808) ([Vitaly Baranov](https://github.com/vitlibar)) +- Segmentasyon hatasını düzeltin `clickhouse-copier`. [\#4835](https://github.com/ClickHouse/ClickHouse/pull/4835) ([proller](https://github.com/proller)) +- Sabit yarış durumu `SELECT` itibaren `system.tables` tablo aynı anda yeniden adlandırılırsa veya değiştirilirse. [\#4836](https://github.com/ClickHouse/ClickHouse/pull/4836) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Zaten eskimiş olan veri bölümünü getirirken sabit veri yarışı. [\#4839](https://github.com/ClickHouse/ClickHouse/pull/4839) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sırasında meydana gelebilecek sabit nadir veri yarışı `RENAME` MergeTree ailesinin tablo. [\#4844](https://github.com/ClickHouse/ClickHouse/pull/4844) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Fonksiyonda sabit segmentasyon hatası `arrayIntersect`. Fonksiyon karışık sabit ve sıradan argümanlarla çağrılırsa segmentasyon hatası olabilir. [\#4847](https://github.com/ClickHouse/ClickHouse/pull/4847) ([Lixiang Qian](https://github.com/fancyqlx)) +- Sabit okuma `Array(LowCardinality)` sütun nadir durumda, sütun uzun bir boş diziler dizisi içerdiğinde. [\#4850](https://github.com/ClickHouse/ClickHouse/pull/4850) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Düzeltmek `No message received` kopyaları arasındaki parçaları getirirken istisna. [\#4856](https://github.com/ClickHouse/ClickHouse/pull/4856) ([alesapin](https://github.com/alesapin)) +- Sabit `arrayIntersect` tek dizide birkaç tekrarlanan değerler durumunda işlev yanlış sonuç. [\#4871](https://github.com/ClickHouse/ClickHouse/pull/4871) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Eşzamanlı sırasında bir yarış durumunu düzeltin `ALTER COLUMN` bir sunucu çökmesine neden olabilecek sorgular (düzeltmeler sorunu [\#3421](https://github.com/ClickHouse/ClickHouse/issues/3421)). [\#4592](https://github.com/ClickHouse/ClickHouse/pull/4592) ([Alex Zatelepin](https://github.com/ztlpn)) +- Parametre kesintisini düzeltin `ALTER MODIFY` of Col ofum ofn `CODEC` sütun türü belirtilmediğinde. [\#4883](https://github.com/ClickHouse/ClickHouse/pull/4883) ([alesapin](https://github.com/alesapin)) +- İşlevler `cutQueryStringAndFragment()` ve `queryStringAndFragment()` şimdi ne zaman doğru çalışıyor `URL` bir parça ve hiçbir sorgu içerir. [\#4894](https://github.com/ClickHouse/ClickHouse/pull/4894) ([Vitaly Baranov](https://github.com/vitlibar)) +- Ayarlarken nadir hatayı düzeltin `min_bytes_to_use_direct_io` iş parçacığı sütun dosyasında geriye aramak zorunda olduğunda oluşan sıfırdan büyüktür. [\#4897](https://github.com/ClickHouse/ClickHouse/pull/4897) ([alesapin](https://github.com/alesapin)) +- Toplama işlevleri için yanlış argüman türlerini düzeltin `LowCardinality` argümanlar (düzeltmeler sorunu [\#4919](https://github.com/ClickHouse/ClickHouse/issues/4919)). [\#4922](https://github.com/ClickHouse/ClickHouse/pull/4922) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Düzeltme fonksiyonu `toISOWeek` 1970 yılı için sonuç. [\#4988](https://github.com/ClickHouse/ClickHouse/pull/4988) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Düzeltmek `DROP`, `TRUNCATE` ve `OPTIMIZE` sorgular, çoğaltma, dosya üzerinde `ON CLUSTER` için `ReplicatedMergeTree*` tablolar aile. [\#4991](https://github.com/ClickHouse/ClickHouse/pull/4991) ([alesapin](https://github.com/alesapin)) + +#### Geliştirmeler {#improvements-2} + +- Sıradan tutmak, `DEFAULT`, `MATERIALIZED` ve `ALIAS` tek bir listedeki sütunlar (düzeltmeler sorunu [\#2867](https://github.com/ClickHouse/ClickHouse/issues/2867)). [\#4707](https://github.com/ClickHouse/ClickHouse/pull/4707) ([Alex Zatelepin](https://github.com/ztlpn)) + +### ClickHouse yayın 19.4.3.11, 2019-04-02 {#clickhouse-release-19-4-3-11-2019-04-02} + +#### Hata Düzeltmeleri {#bug-fixes-8} + +- Çökmeyi düzeltin `FULL/RIGHT JOIN` biz nullable vs değil nullable üzerinde katılırken. [\#4855](https://github.com/ClickHouse/ClickHouse/pull/4855) ([Artem Zuikov](https://github.com/4ertus2)) +- Segmentasyon hatasını düzeltin `clickhouse-copier`. [\#4835](https://github.com/ClickHouse/ClickHouse/pull/4835) ([proller](https://github.com/proller)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-11} + +- Clickhouse-sunucu görüntüsünü özel bir kullanıcıdan başlatmanın bir yolunu ekleyin. [\#4753](https://github.com/ClickHouse/ClickHouse/pull/4753) ([Mikhail f. Shiryaev](https://github.com/Felixoid)) + +### ClickHouse sürümü 19.4.2.7, 2019-03-30 {#clickhouse-release-19-4-2-7-2019-03-30} + +#### Hata Düzeltmeleri {#bug-fixes-9} + +- Sabit okuma `Array(LowCardinality)` sütun nadir durumda, sütun uzun bir boş diziler dizisi içerdiğinde. [\#4850](https://github.com/ClickHouse/ClickHouse/pull/4850) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) + +### ClickHouse yayın 19.4.1.3, 2019-03-19 {#clickhouse-release-19-4-1-3-2019-03-19} + +#### Hata Düzeltmeleri {#bug-fixes-10} + +- Her ikisini de içeren sabit uzak sorgular `LIMIT BY` ve `LIMIT`. Daha önce `LIMIT BY` ve `LIMIT` uzak sorgu için kullanıldı, `LIMIT` daha önce olabilirdi `LIMIT BY`, çok filtrelenmiş sonuca yol açtı. [\#4708](https://github.com/ClickHouse/ClickHouse/pull/4708) ([Constantin S. Pan](https://github.com/kvap)) + +### ClickHouse yayın 19.4.0.49, 2019-03-09 {#clickhouse-release-19-4-0-49-2019-03-09} + +#### Yenilik {#new-features-5} + +- İçin tam destek eklendi `Protobuf` biçim (giriş ve çıkış, iç içe veri yapıları). [\#4174](https://github.com/ClickHouse/ClickHouse/pull/4174) [\#4493](https://github.com/ClickHouse/ClickHouse/pull/4493) ([Vitaly Baranov](https://github.com/vitlibar)) +- Kükreyen bitmapler ile bitmap fonksiyonları eklendi. [\#4207](https://github.com/ClickHouse/ClickHouse/pull/4207) ([Andy Yang](https://github.com/andyyzh)) [\#4568](https://github.com/ClickHouse/ClickHouse/pull/4568) ([Vitaly Baranov](https://github.com/vitlibar)) +- Parke formatı desteği. [\#4448](https://github.com/ClickHouse/ClickHouse/pull/4448) ([proller](https://github.com/proller)) +- Bulanık dize karşılaştırması için N-gram mesafesi eklendi. R dilinde q-gram ölçümlerine benzer. [\#4466](https://github.com/ClickHouse/ClickHouse/pull/4466) ([Danila Kutenin](https://github.com/danlark1)) +- Özel toplama ve tutma kalıplarından grafit toplaması için kuralları birleştirin. [\#4426](https://github.com/ClickHouse/ClickHouse/pull/4426) ([Mikhail f. Shiryaev](https://github.com/Felixoid)) +- Katma `max_execution_speed` ve `max_execution_speed_bytes` kaynak kullanımını sınırlamak için. Katma `min_execution_speed_bytes` Tamam tolayacak ayar `min_execution_speed`. [\#4430](https://github.com/ClickHouse/ClickHouse/pull/4430) ([Kış Zhang](https://github.com/zhang2014)) +- Uygulanan işlev `flatten`. [\#4555](https://github.com/ClickHouse/ClickHouse/pull/4555) [\#4409](https://github.com/ClickHouse/ClickHouse/pull/4409) ([alexey-milovidov](https://github.com/alexey-milovidov), [kzon](https://github.com/kzon)) +- Eklenen fonksiyonlar `arrayEnumerateDenseRanked` ve `arrayEnumerateUniqRanked` (sanki `arrayEnumerateUniq` ancak, çok boyutlu dizilerin içine bakmak için dizi derinliğini ince ayarlamaya izin verir). [\#4475](https://github.com/ClickHouse/ClickHouse/pull/4475) ([proller](https://github.com/proller)) [\#4601](https://github.com/ClickHouse/ClickHouse/pull/4601) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Multiple JOINS with some restrictions: no asterisks, no complex aliases in ON/WHERE/GROUP BY/… [\#4462](https://github.com/ClickHouse/ClickHouse/pull/4462) ([Artem Zuikov](https://github.com/4ertus2)) + +#### Hata Düzeltmeleri {#bug-fixes-11} + +- Bu sürüm aynı zamanda 19.3 ve 19.1 tüm hata düzeltmeleri içerir. +- Veri atlama endekslerinde Sabit hata: İNSERTTEN sonra granüllerin sırası yanlıştı. [\#4407](https://github.com/ClickHouse/ClickHouse/pull/4407) ([Nikita Vasilev](https://github.com/nikvas0)) +- Sabit `set` Ind Forex for `Nullable` ve `LowCardinality` sütun. Ondan önce, `set` ile ind withex `Nullable` veya `LowCardinality` sütun hataya yol açtı `Data type must be deserialized with multiple streams` seçerken. [\#4594](https://github.com/ClickHouse/ClickHouse/pull/4594) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Update\_time'ı tam olarak doğru şekilde ayarlayın `executable` sözlük güncelleme. [\#4551](https://github.com/ClickHouse/ClickHouse/pull/4551) ([Tema Novikov](https://github.com/temoon)) +- 19.3'te kırık ilerleme çubuğunu düzeltin. [\#4627](https://github.com/ClickHouse/ClickHouse/pull/4627) ([filimonov](https://github.com/filimonov)) +- Belirli durumlarda bellek bölgesi küçüldüğünde Memorytracker'ın tutarsız değerleri düzeltildi. [\#4619](https://github.com/ClickHouse/ClickHouse/pull/4619) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- ThreadPool sabit tanımsız davranış. [\#4612](https://github.com/ClickHouse/ClickHouse/pull/4612) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Mesajla çok nadir bir kaza düzeltildi `mutex lock failed: Invalid argument` bu, bir MERGETREE tablosu bir SELECT ile aynı anda bırakıldığında gerçekleşebilir. [\#4608](https://github.com/ClickHouse/ClickHouse/pull/4608) ([Alex Zatelepin](https://github.com/ztlpn)) +- ODBC sürücüsü ile uyumluluk `LowCardinality` veri türü. [\#4381](https://github.com/ClickHouse/ClickHouse/pull/4381) ([proller](https://github.com/proller)) +- FreeBSD: için düzeltme `AIOcontextPool: Found io_event with unknown id 0` hatasız. [\#4438](https://github.com/ClickHouse/ClickHouse/pull/4438) ([urgordeadbeef](https://github.com/urgordeadbeef)) +- `system.part_log` tablo yapılandırmaya bakılmaksızın oluşturuldu. [\#4483](https://github.com/ClickHouse/ClickHouse/pull/4483) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tanımsız davranışı düzeltin `dictIsIn` önbellek sözlükler için işlev. [\#4515](https://github.com/ClickHouse/ClickHouse/pull/4515) ([alesapin](https://github.com/alesapin)) +- Fixed a deadlock when a SELECT query locks the same table multiple times (e.g. from different threads or when executing multiple subqueries) and there is a concurrent DDL query. [\#4535](https://github.com/ClickHouse/ClickHouse/pull/4535) ([Alex Zatelepin](https://github.com/ztlpn)) +- Biz kendi elde edene kadar varsayılan olarak compile\_expressions devre dışı bırakın `llvm` contrib ve ile test edebilirsiniz `clang` ve `asan`. [\#4579](https://github.com/ClickHouse/ClickHouse/pull/4579) ([alesapin](https://github.com/alesapin)) +- Önlemek `std::terminate` ne zaman `invalidate_query` için `clickhouse` dış sözlük kaynağı yanlış resultset döndürdü (boş veya birden fazla satır veya birden fazla sütun). Sabit sorun ne zaman `invalidate_query` ne olursa olsun her beş saniyede yapıldı `lifetime`. [\#4583](https://github.com/ClickHouse/ClickHouse/pull/4583) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kilitlenme önlemek zaman `invalidate_query` ile bir sözlük için `clickhouse` kaynak içeren oldu `system.dictionaries` tablo veya `Dictionaries` veritabanı (nadir durum). [\#4599](https://github.com/ClickHouse/ClickHouse/pull/4599) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Çapraz için düzeltmeler boş nerede ile katılmak. [\#4598](https://github.com/ClickHouse/ClickHouse/pull/4598) ([Artem Zuikov](https://github.com/4ertus2)) +- Fonksiyon sabit segfault “replicate” sabit argüman geçirildiğinde. [\#4603](https://github.com/ClickHouse/ClickHouse/pull/4603) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yükleme doktoru ile Lambda işlevini düzeltin. [\#4408](https://github.com/ClickHouse/ClickHouse/pull/4408) ([Kış Zhang](https://github.com/zhang2014)) +- Birden çok düzeltmeleri katıldı. [\#4595](https://github.com/ClickHouse/ClickHouse/pull/4595) ([Artem Zuikov](https://github.com/4ertus2)) + +#### Geliştirmeler {#improvements-3} + +- Sağ tablo sütunları için JOİN on bölümündeki takma adları destekleyin. [\#4412](https://github.com/ClickHouse/ClickHouse/pull/4412) ([Artem Zuikov](https://github.com/4ertus2)) +- Birden fazla sonuç subselects kullanılacak doğru sonucu ismi Katıldı. Düz takma adları kaynak adları ile sonuç olarak değiştirin. [\#4474](https://github.com/ClickHouse/ClickHouse/pull/4474) ([Artem Zuikov](https://github.com/4ertus2)) +- Birleştirilmiş ifadeler için aşağı itme mantığını geliştirin. [\#4387](https://github.com/ClickHouse/ClickHouse/pull/4387) ([I ivanvan](https://github.com/abyss7)) + +#### Performans İyileştirmeleri {#performance-improvements-3} + +- Geliştirilmiş sezgisel “move to PREWHERE” optimizasyon. [\#4405](https://github.com/ClickHouse/ClickHouse/pull/4405) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- 8-bit ve 16-bit anahtarlar için HashTable API kullanan uygun arama tabloları kullanın. [\#4536](https://github.com/ClickHouse/ClickHouse/pull/4536) ([Amos Kuşu](https://github.com/amosbird)) +- Dize karşılaştırma geliştirilmiş performans. [\#4564](https://github.com/ClickHouse/ClickHouse/pull/4564) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Ayrı bir iş parçacığında dağıtılmış DDL kuyruğunu temizleme, böylece dağıtılmış DDL görevlerini işleyen ana döngüyü yavaşlatmaz. [\#4502](https://github.com/ClickHouse/ClickHouse/pull/4502) ([Alex Zatelepin](https://github.com/ztlpn)) +- Ne zaman `min_bytes_to_use_direct_io` 1 olarak ayarlanır, her dosya O\_DİRECT modu ile açılmamıştır, çünkü okunacak veri boyutu bazen sıkıştırılmış bir bloğun boyutuna göre hafife alınmıştır. [\#4526](https://github.com/ClickHouse/ClickHouse/pull/4526) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-12} + +- Clang-9 için destek eklendi [\#4604](https://github.com/ClickHouse/ClickHouse/pull/4604) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yanlış Düzelt `__asm__` talimatlar (tekrar) [\#4621](https://github.com/ClickHouse/ClickHouse/pull/4621) ([Konstantin Podshumok](https://github.com/podshumok)) +- Ayarları belirtmek için yeteneği ekleyin `clickhouse-performance-test` komut satırından. [\#4437](https://github.com/ClickHouse/ClickHouse/pull/4437) ([alesapin](https://github.com/alesapin)) +- Entegrasyon testlerine sözlükler testleri ekleyin. [\#4477](https://github.com/ClickHouse/ClickHouse/pull/4477) ([alesapin](https://github.com/alesapin)) +- Otomatik performans testlerine web sitesinde kriter sorguları eklendi. [\#4496](https://github.com/ClickHouse/ClickHouse/pull/4496) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- `xxhash.h` harici lz4'te mevcut değildir, çünkü bir uygulama ayrıntısıdır ve sembolleri ile adlandır `XXH_NAMESPACE` makro. Lz4 harici olduğunda, xxHash da harici olmalı ve bağımlıların buna bağlanması gerekir. [\#4495](https://github.com/ClickHouse/ClickHouse/pull/4495) ([Orivej Desh](https://github.com/orivej)) +- Sabit bir durumda zaman `quantileTiming` toplama işlevi, negatif veya kayan nokta argümanı ile çağrılabilir (bu, tanımsız davranış dezenfektanı ile fuzz testini düzeltir). [\#4506](https://github.com/ClickHouse/ClickHouse/pull/4506) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yazım hatası düzeltme. [\#4531](https://github.com/ClickHouse/ClickHouse/pull/4531) ([sdk2](https://github.com/sdk2)) +- Mac'te derlemeyi düzeltin. [\#4371](https://github.com/ClickHouse/ClickHouse/pull/4371) ([Vitaly Baranov](https://github.com/vitlibar)) +- FreeBSD ve çeşitli sıradışı yapı yapılandırmaları için düzeltmeler oluşturun. [\#4444](https://github.com/ClickHouse/ClickHouse/pull/4444) ([proller](https://github.com/proller)) + +## ClickHouse sürümü 19.3 {#clickhouse-release-19-3} + +### ClickHouse yayın 19.3.9.1, 2019-04-02 {#clickhouse-release-19-3-9-1-2019-04-02} + +#### Hata Düzeltmeleri {#bug-fixes-12} + +- Çökmeyi düzeltin `FULL/RIGHT JOIN` biz nullable vs değil nullable üzerinde katılırken. [\#4855](https://github.com/ClickHouse/ClickHouse/pull/4855) ([Artem Zuikov](https://github.com/4ertus2)) +- Segmentasyon hatasını düzeltin `clickhouse-copier`. [\#4835](https://github.com/ClickHouse/ClickHouse/pull/4835) ([proller](https://github.com/proller)) +- Sabit okuma `Array(LowCardinality)` sütun nadir durumda, sütun uzun bir boş diziler dizisi içerdiğinde. [\#4850](https://github.com/ClickHouse/ClickHouse/pull/4850) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-13} + +- Özel bir kullanıcıdan clickhouse-server görüntüsünü başlatmak için bir yol ekleyin [\#4753](https://github.com/ClickHouse/ClickHouse/pull/4753) ([Mikhail f. Shiryaev](https://github.com/Felixoid)) + +### ClickHouse yayın 19.3.7, 2019-03-12 {#clickhouse-release-19-3-7-2019-03-12} + +#### Hata düzeltmeleri {#bug-fixes-13} + +- \#3920'de Sabit hata. Bu hata kendisini rasgele önbellek bozulması (mesajlar) olarak gösterir `Unknown codec family code`, `Cannot seek through file`) ve segfaults. Bu hata ilk olarak 19.1 sürümünde ortaya çıktı ve 19.1.10 ve 19.3.6'ya kadar olan sürümlerde mevcut. [\#4623](https://github.com/ClickHouse/ClickHouse/pull/4623) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse yayın 19.3.6, 2019-03-02 {#clickhouse-release-19-3-6-2019-03-02} + +#### Hata düzeltmeleri {#bug-fixes-14} + +- Bir iş parçacığı havuzunda 1000'den fazla iş parçacığı olduğunda, `std::terminate` iş parçacığı çıkışında meydana gelebilir. [Azat Khuzhin](https://github.com/azat) [\#4485](https://github.com/ClickHouse/ClickHouse/pull/4485) [\#4505](https://github.com/ClickHouse/ClickHouse/pull/4505) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Şimdi oluşturmak mümkün `ReplicatedMergeTree*` varsayılanları olmayan sütunlarda yorumlar içeren tablolar ve yorum ve varsayılanları olmayan sütun kodekleri içeren tablolar. Ayrıca codec karşılaştırmasını düzeltin. [\#4523](https://github.com/ClickHouse/ClickHouse/pull/4523) ([alesapin](https://github.com/alesapin)) +- Dizi veya tuple ile katılmak sabit kazasında. [\#4552](https://github.com/ClickHouse/ClickHouse/pull/4552) ([Artem Zuikov](https://github.com/4ertus2)) +- Clickhouse sabit kazasında-mesaj ile fotokopi `ThreadStatus not created`. [\#4540](https://github.com/ClickHouse/ClickHouse/pull/4540) ([Artem Zuikov](https://github.com/4ertus2)) +- Dağıtılmış DDL kullanılmışsa, sunucu kapanmasında sabit kapatma. [\#4472](https://github.com/ClickHouse/ClickHouse/pull/4472) ([Alex Zatelepin](https://github.com/ztlpn)) +- Yanlış sütun numaraları, 10'dan büyük sayı ile sütunlar için ayrıştırma metin biçimi hakkında hata iletisinde yazdırıldı. [\#4484](https://github.com/ClickHouse/ClickHouse/pull/4484) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Yapı / Test / Ambalaj Geliştirmeleri {#buildtestingpackaging-improvements-3} + +- Avx etkin sabit yapı. [\#4527](https://github.com/ClickHouse/ClickHouse/pull/4527) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Genişletilmiş muhasebe ve IO muhasebesini, derlendiği çekirdek yerine iyi bilinen sürüme göre etkinleştirin. [\#4541](https://github.com/ClickHouse/ClickHouse/pull/4541) ([nvartolomei](https://github.com/nvartolomei)) +- Core\_dump ayarını atlamaya izin ver.size\_limit, limit set başarısız olursa atmak yerine uyarı. [\#4473](https://github.com/ClickHouse/ClickHouse/pull/4473) ([proller](https://github.com/proller)) +- Kaldır theılan `inline` tags of `void readBinary(...)` içinde `Field.cpp`. Ayrıca birleştirilmiş gereksiz `namespace DB` Bloklar. [\#4530](https://github.com/ClickHouse/ClickHouse/pull/4530) ([hcz](https://github.com/hczhcz)) + +### ClickHouse yayın 19.3.5, 2019-02-21 {#clickhouse-release-19-3-5-2019-02-21} + +#### Hata düzeltmeleri {#bug-fixes-15} + +- Büyük http ekleme sorguları işleme ile Sabit hata. [\#4454](https://github.com/ClickHouse/ClickHouse/pull/4454) ([alesapin](https://github.com/alesapin)) +- Yanlış uygulama nedeniyle eski sürümlerle geriye dönük uyumsuzluk düzeltildi `send_logs_level` ayar. [\#4445](https://github.com/ClickHouse/ClickHouse/pull/4445) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tablo fonksiyonunun geriye dönük uyumsuzluğu düzeltildi `remote` sütun yorumları ile tanıtıldı. [\#4446](https://github.com/ClickHouse/ClickHouse/pull/4446) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse yayın 19.3.4, 2019-02-16 {#clickhouse-release-19-3-4-2019-02-16} + +#### Geliştirmeler {#improvements-4} + +- Yaparken tablo dizin boyutu bellek sınırları için hesaplandı değil `ATTACH TABLE` sorgu. Bir tablo müstakil sonra eklenemez olasılığını Kaçınılması. [\#4396](https://github.com/ClickHouse/ClickHouse/pull/4396) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Zookeeper'dan alınan maksimum dize ve dizi boyutu üzerindeki sınırı hafifçe yükseltti. Bu artan boyutu ile çalışmaya devam sağlar `CLIENT_JVMFLAGS=-Djute.maxbuffer=...` ZooKeeper üzerinde. [\#4398](https://github.com/ClickHouse/ClickHouse/pull/4398) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Zaten kendi kuyruğunda düğümlerin çok sayıda olsa bile terk edilmiş çoğaltma onarmak için izin verin. [\#4399](https://github.com/ClickHouse/ClickHouse/pull/4399) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bir gerekli argüman Ekle `SET` dizin (en fazla saklanan satır numarası). [\#4386](https://github.com/ClickHouse/ClickHouse/pull/4386) ([Nikita Vasilev](https://github.com/nikvas0)) + +#### Hata Düzeltmeleri {#bug-fixes-16} + +- Sabit `WITH ROLLUP` tek grup için sonuç `LowCardinality` anahtar. [\#4384](https://github.com/ClickHouse/ClickHouse/pull/4384) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Set dizinindeki Sabit hata (daha fazlasını içeriyorsa bir granül bırakarak `max_rows` satırlar). [\#4386](https://github.com/ClickHouse/ClickHouse/pull/4386) ([Nikita Vasilev](https://github.com/nikvas0)) +- Bir sürü FreeBSD yapı düzeltmesi. [\#4397](https://github.com/ClickHouse/ClickHouse/pull/4397) ([proller](https://github.com/proller)) +- Aynı takma ad içeren alt sorgularla sorgularda sabit takma ad değiştirme (sorun [\#4110](https://github.com/ClickHouse/ClickHouse/issues/4110)). [\#4351](https://github.com/ClickHouse/ClickHouse/pull/4351) ([Artem Zuikov](https://github.com/4ertus2)) + +#### Yapı / Test / Ambalaj Geliştirmeleri {#buildtestingpackaging-improvements-4} + +- Çalıştırmak için yeteneği ekleyin `clickhouse-server` docker ımage vatansız testler için. [\#4347](https://github.com/ClickHouse/ClickHouse/pull/4347) ([Vasily Nemkov](https://github.com/Enmk)) + +### ClickHouse yayın 19.3.3, 2019-02-13 {#clickhouse-release-19-3-3-2019-02-13} + +#### Yenilik {#new-features-6} + +- Add theed the `KILL MUTATION` bazı nedenlerle sıkışmış olan mutasyonların giderilmesine izin veren ifade. Katma `latest_failed_part`, `latest_fail_time`, `latest_fail_reason` alanlar için `system.mutations` daha kolay sorun giderme için tablo. [\#4287](https://github.com/ClickHouse/ClickHouse/pull/4287) ([Alex Zatelepin](https://github.com/ztlpn)) +- Toplama fonksiyonu eklendi `entropy` Shannon entropisini hesaplar. [\#4238](https://github.com/ClickHouse/ClickHouse/pull/4238) ([Quid37](https://github.com/Quid37)) +- Sorguları göndermek için yeteneği eklendi `INSERT INTO tbl VALUES (....` yarat withoutmadan sunucuya `query` ve `data` parçalar. [\#4301](https://github.com/ClickHouse/ClickHouse/pull/4301) ([alesapin](https://github.com/alesapin)) +- Genel uygulama `arrayWithConstant` işlevi eklendi. [\#4322](https://github.com/ClickHouse/ClickHouse/pull/4322) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Uyguluyordu `NOT BETWEEN` karşılaştırma operatörü. [\#4228](https://github.com/ClickHouse/ClickHouse/pull/4228) ([Dmitry Naumov](https://github.com/nezed)) +- Uygulamak `sumMapFiltered` değerlerin toplanacağı anahtar sayısını sınırlayabilmek için `sumMap`. [\#4129](https://github.com/ClickHouse/ClickHouse/pull/4129) ([Léo Ercolanelli](https://github.com/ercolanelli-leo)) +- Desteği eklendi `Nullable` yazmak `mysql` tablo işlevi. [\#4198](https://github.com/ClickHouse/ClickHouse/pull/4198) ([Emmanuel Donin de Rosière](https://github.com/edonin)) +- İçinde keyfi sabit ifadeler için destek `LIMIT` yan. [\#4246](https://github.com/ClickHouse/ClickHouse/pull/4246) ([k3box](https://github.com/k3box)) +- Katma `topKWeighted` (imzasız tamsayı) ağırlığı ile ek argüman alır toplama işlevi. [\#4245](https://github.com/ClickHouse/ClickHouse/pull/4245) ([Andrew Golman](https://github.com/andrewgolman)) +- `StorageJoin` şimdi destekler `join_any_take_last_row` aynı anahtarın varolan değerlerinin üzerine yazmayı sağlayan ayar. [\#3973](https://github.com/ClickHouse/ClickHouse/pull/3973) ([Amos Kuşu](https://github.com/amosbird) +- Eklendi fonksiyonu `toStartOfInterval`. [\#4304](https://github.com/ClickHouse/ClickHouse/pull/4304) ([Vitaly Baranov](https://github.com/vitlibar)) +- Katma `RowBinaryWithNamesAndTypes` biçimli. [\#4200](https://github.com/ClickHouse/ClickHouse/pull/4200) ([Oleg V. Kozlyuk](https://github.com/DarkWanderer)) +- Katma `IPv4` ve `IPv6` veri türleri. Daha etkili uygulamalar `IPv*` işlevler. [\#3669](https://github.com/ClickHouse/ClickHouse/pull/3669) ([Vasily Nemkov](https://github.com/Enmk)) +- Eklendi fonksiyonu `toStartOfTenMinutes()`. [\#4298](https://github.com/ClickHouse/ClickHouse/pull/4298) ([Vitaly Baranov](https://github.com/vitlibar)) +- Katma `Protobuf` çıkış biçimi. [\#4005](https://github.com/ClickHouse/ClickHouse/pull/4005) [\#4158](https://github.com/ClickHouse/ClickHouse/pull/4158) ([Vitaly Baranov](https://github.com/vitlibar)) +- Veri içe aktarma (ekler) için HTTP arayüzü için brotli desteği eklendi. [\#4235](https://github.com/ClickHouse/ClickHouse/pull/4235) ([Mikhail](https://github.com/fandyushin)) +- Kullanıcı işlev adına yazım hatası yaparken veya komut satırı istemcisinde yazarken ipuçları eklendi. [\#4239](https://github.com/ClickHouse/ClickHouse/pull/4239) ([Danila Kutenin](https://github.com/danlark1)) +- Katma `Query-Id` sunucunun HTTP yanıt başlığına. [\#4231](https://github.com/ClickHouse/ClickHouse/pull/4231) ([Mikhail](https://github.com/fandyushin)) + +#### Deneysel özellikler {#experimental-features-2} + +- Katma `minmax` ve `set` MergeTree tablo motorları ailesi için veri atlama endeksleri. [\#4143](https://github.com/ClickHouse/ClickHouse/pull/4143) ([Nikita Vasilev](https://github.com/nikvas0)) +- Eklenen dönüşüm `CROSS JOIN` -e doğru `INNER JOIN` mümkünse. [\#4221](https://github.com/ClickHouse/ClickHouse/pull/4221) [\#4266](https://github.com/ClickHouse/ClickHouse/pull/4266) ([Artem Zuikov](https://github.com/4ertus2)) + +#### Hata Düzeltmeleri {#bug-fixes-17} + +- Sabit `Not found column` yinelenen sütunlar için `JOIN ON` bölme. [\#4279](https://github.com/ClickHouse/ClickHouse/pull/4279) ([Artem Zuikov](https://github.com/4ertus2)) +- Yapmak `START REPLICATED SENDS` komut Başlat çoğaltılmış gönderir. [\#4229](https://github.com/ClickHouse/ClickHouse/pull/4229) ([nvartolomei](https://github.com/nvartolomei)) +- Sabit toplam fonksiyonları yürütme ile `Array(LowCardinality)` değişkenler. [\#4055](https://github.com/ClickHouse/ClickHouse/pull/4055) ([KochetovNicolai](https://github.com/KochetovNicolai)) +- Yaparken yanlış davranış düzeltildi `INSERT ... SELECT ... FROM file(...)` sorgu ve dosya var `CSVWithNames` veya `TSVWIthNames` biçim ve ilk veri satırı eksik. [\#4297](https://github.com/ClickHouse/ClickHouse/pull/4297) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sözlük mevcut değilse sözlük yeniden sabit kazasında. Bu hata 19.1.6'da ortaya çıktı. [\#4188](https://github.com/ClickHouse/ClickHouse/pull/4188) ([proller](https://github.com/proller)) +- Sabit `ALL JOIN` sağ tabloda çiftleri ile. [\#4184](https://github.com/ClickHouse/ClickHouse/pull/4184) ([Artem Zuikov](https://github.com/4ertus2)) +- Sabit segmentasyon hatası `use_uncompressed_cache=1` ve yanlış sıkıştırılmamış boyutta istisna. Bu hata 19.1.6'da ortaya çıktı. [\#4186](https://github.com/ClickHouse/ClickHouse/pull/4186) ([alesapin](https://github.com/alesapin)) +- Sabit `compile_expressions` büyük (ınt16'dan daha fazla) tarihlerin karşılaştırılması ile hata. [\#4341](https://github.com/ClickHouse/ClickHouse/pull/4341) ([alesapin](https://github.com/alesapin)) +- Tablo işlevinden seçerken sabit sonsuz döngü `numbers(0)`. [\#4280](https://github.com/ClickHouse/ClickHouse/pull/4280) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yüklem optimizasyonunu geçici olarak devre dışı bırak `ORDER BY`. [\#3890](https://github.com/ClickHouse/ClickHouse/pull/3890) ([Kış Zhang](https://github.com/zhang2014)) +- Sabit `Illegal instruction` eski CPU'larda base64 işlevlerini kullanırken hata. Bu hata yalnızca ClickHouse gcc-8 ile derlendiğinde yeniden üretildi. [\#4275](https://github.com/ClickHouse/ClickHouse/pull/4275) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit `No message received` TLS bağlantısı üzerinden PostgreSQL ODBC sürücüsü ile etkileşimde bulunurken hata. MySQL ODBC sürücüsü kullanırken de segfault giderir. [\#4170](https://github.com/ClickHouse/ClickHouse/pull/4170) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit yanlış sonuç ne zaman `Date` ve `DateTime` argümanlar koşullu operatörün dallarında kullanılır (işlev `if`). Fonksiyon için genel durum eklendi `if`. [\#4243](https://github.com/ClickHouse/ClickHouse/pull/4243) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- ClickHouse sözlükler şimdi içinde yük `clickhouse` işleyiş. [\#4166](https://github.com/ClickHouse/ClickHouse/pull/4166) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit kilitlenme zaman `SELECT` ile bir tablo fromdan `File` motor sonra yeniden denendi `No such file or directory` hatasız. [\#4161](https://github.com/ClickHouse/ClickHouse/pull/4161) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Seçerken sabit yarış durumu `system.tables` verebilir `table doesn't exist` hatasız. [\#4313](https://github.com/ClickHouse/ClickHouse/pull/4313) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- `clickhouse-client` etkileşimli modda çalıştırıldıysa, komut satırı önerileri için veri yüklerken çıkışta segfault yapabilir. [\#4317](https://github.com/ClickHouse/ClickHouse/pull/4317) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İçeren mutasyonların yürütülmesi bir hata düzeltildi `IN` operatörler yanlış sonuçlar üretiyordu. [\#4099](https://github.com/ClickHouse/ClickHouse/pull/4099) ([Alex Zatelepin](https://github.com/ztlpn)) +- Sabit hata: bir veritabanı varsa `Dictionary` motor, tüm sözlükler sunucu başlangıçta yüklemeye zorlanır ve localhost'tan ClickHouse kaynağı olan bir sözlük varsa, sözlük yüklenemez. [\#4255](https://github.com/ClickHouse/ClickHouse/pull/4255) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sistem günlükleri sunucu kapatma yeniden oluşturmak için denendiğinde hata düzeltildi. [\#4254](https://github.com/ClickHouse/ClickHouse/pull/4254) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Doğru türü doğru şekilde döndürün ve kilitleri düzgün şekilde tutun `joinGet` işlev. [\#4153](https://github.com/ClickHouse/ClickHouse/pull/4153) ([Amos Kuşu](https://github.com/amosbird)) +- Katma `sumMapWithOverflow` işlev. [\#4151](https://github.com/ClickHouse/ClickHouse/pull/4151) ([Léo Ercolanelli](https://github.com/ercolanelli-leo)) +- Sabit segfault ile `allow_experimental_multiple_joins_emulation`. [52de2c](https://github.com/ClickHouse/ClickHouse/commit/52de2cd927f7b5257dd67e175f0a5560a48840d0) ([Artem Zuikov](https://github.com/4ertus2)) +- Yanlış ile Sabit hata `Date` ve `DateTime` karşılaştırma. [\#4237](https://github.com/ClickHouse/ClickHouse/pull/4237) ([valexey](https://github.com/valexey)) +- Tanımsız davranış sanitizer altında sabit fuzz testi: eklendi parametre tipi kontrol için `quantile*Weighted` fonksiyonlar ailesi. [\#4145](https://github.com/ClickHouse/ClickHouse/pull/4145) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Eski veri parçalarının çıkarılması ile başarısız olabilir sabit nadir yarış durumu `File not found` hatasız. [\#4378](https://github.com/ClickHouse/ClickHouse/pull/4378) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Eksik /etc/clickhouse-server/config ile paketi yükleyin.xml. [\#4343](https://github.com/ClickHouse/ClickHouse/pull/4343) ([proller](https://github.com/proller)) + +#### Yapı / Test / Ambalaj Geliştirmeleri {#buildtestingpackaging-improvements-5} + +- Debian paketi: yapılandırmaya göre /etc/clickhouse-server/preprocessed bağlantısını düzeltin. [\#4205](https://github.com/ClickHouse/ClickHouse/pull/4205) ([proller](https://github.com/proller)) +- FreeBSD için çeşitli yapı düzeltmeleri. [\#4225](https://github.com/ClickHouse/ClickHouse/pull/4225) ([proller](https://github.com/proller)) +- Perftest'te tablolar oluşturma, doldurma ve bırakma yeteneği eklendi. [\#4220](https://github.com/ClickHouse/ClickHouse/pull/4220) ([alesapin](https://github.com/alesapin)) +- Yinelenen kontrol etmek için bir komut dosyası eklendi içerir. [\#4326](https://github.com/ClickHouse/ClickHouse/pull/4326) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Performans testinde dizin sorguları çalıştırmak için yeteneği eklendi. [\#4264](https://github.com/ClickHouse/ClickHouse/pull/4264) ([alesapin](https://github.com/alesapin)) +- Hata ayıklama sembolleri ile paket yüklü olması önerilir. [\#4274](https://github.com/ClickHouse/ClickHouse/pull/4274) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Performansın yeniden düzenlenmesi-test. Daha iyi günlüğü ve sinyalleri işleme. [\#4171](https://github.com/ClickHouse/ClickHouse/pull/4171) ([alesapin](https://github.com/alesapin)) +- Anonimleştirilmiş yandex'e dokümanlar eklendi.Metrika veri setleri. [\#4164](https://github.com/ClickHouse/ClickHouse/pull/4164) ([alesapin](https://github.com/alesapin)) +- Аdded tool for converting an old month-partitioned part to the custom-partitioned format. [\#4195](https://github.com/ClickHouse/ClickHouse/pull/4195) ([Alex Zatelepin](https://github.com/ztlpn)) +- S3'te iki veri kümesi hakkında dokümanlar eklendi. [\#4144](https://github.com/ClickHouse/ClickHouse/pull/4144) ([alesapin](https://github.com/alesapin)) +- Çekme istekleri açıklamasından changelog oluşturan komut dosyası eklendi. [\#4169](https://github.com/ClickHouse/ClickHouse/pull/4169) [\#4173](https://github.com/ClickHouse/ClickHouse/pull/4173) ([KochetovNicolai](https://github.com/KochetovNicolai)) ([KochetovNicolai](https://github.com/KochetovNicolai)) +- ClickHouse için kukla modülü eklendi. [\#4182](https://github.com/ClickHouse/ClickHouse/pull/4182) ([Maxim Fedotov](https://github.com/MaxFedotov)) +- Bir grup belgesiz işlev için dokümanlar eklendi. [\#4168](https://github.com/ClickHouse/ClickHouse/pull/4168) ([Kış Zhang](https://github.com/zhang2014)) +- Arm yapı düzeltmeleri. [\#4210](https://github.com/ClickHouse/ClickHouse/pull/4210)[\#4306](https://github.com/ClickHouse/ClickHouse/pull/4306) [\#4291](https://github.com/ClickHouse/ClickHouse/pull/4291) ([proller](https://github.com/proller)) ([proller](https://github.com/proller)) +- Sözlük testleri artık çalıştırmak mümkün `ctest`. [\#4189](https://github.com/ClickHouse/ClickHouse/pull/4189) ([proller](https://github.com/proller)) +- Şimdi `/etc/ssl` SSL sertifikaları ile varsayılan dizin olarak kullanılır. [\#4167](https://github.com/ClickHouse/ClickHouse/pull/4167) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Başlangıçta SSE ve AVX talimat kontrol eklendi. [\#4234](https://github.com/ClickHouse/ClickHouse/pull/4234) ([Igr](https://github.com/igron99)) +- İnit betiği, başlayana kadar sunucuyu bekleyecektir. [\#4281](https://github.com/ClickHouse/ClickHouse/pull/4281) ([proller](https://github.com/proller)) + +#### Geriye Dönük Uyumsuz Değişiklikler {#backward-incompatible-changes-1} + +- Kaldırıyordu `allow_experimental_low_cardinality_type` ayar. `LowCardinality` veri türleri üretime hazırdır. [\#4323](https://github.com/ClickHouse/ClickHouse/pull/4323) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kullanılabilir bellek miktarına göre işaretle önbellek boyutunu ve sıkıştırılmamış önbellek boyutunu azaltın. [\#4240](https://github.com/ClickHouse/ClickHouse/pull/4240) ([Lopatin Konstantin](https://github.com/k-lopatin) +- Eklenen anahtar kelime `INDEX` içinde `CREATE TABLE` sorgu. Adı olan bir sütun `index` backticks veya çift tırnak ile alıntı olmalıdır: `` `index` ``. [\#4143](https://github.com/ClickHouse/ClickHouse/pull/4143) ([Nikita Vasilev](https://github.com/nikvas0)) +- `sumMap` şimdi taşma yerine sonuç türünü tanıtın. Eskiler `sumMap` davranış kullanılarak elde edilebilir `sumMapWithOverflow` işlev. [\#4151](https://github.com/ClickHouse/ClickHouse/pull/4151) ([Léo Ercolanelli](https://github.com/ercolanelli-leo)) + +#### Performans İyileştirmeleri {#performance-improvements-4} + +- `std::sort` yerine göre `pdqsort` olmadan sorgular için `LIMIT`. [\#4236](https://github.com/ClickHouse/ClickHouse/pull/4236) ([Evgenii Pravda](https://github.com/kvinty)) +- Şimdi sunucu, genel iş parçacığı havuzundan iş parçacıklarını yeniden kullanır. Bu, bazı köşe durumlarda performansı etkiler. [\#4150](https://github.com/ClickHouse/ClickHouse/pull/4150) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Geliştirmeler {#improvements-5} + +- FreeBSD için AIO desteği uygulandı. [\#4305](https://github.com/ClickHouse/ClickHouse/pull/4305) ([urgordeadbeef](https://github.com/urgordeadbeef)) +- `SELECT * FROM a JOIN b USING a, b` şimdi geri dön `a` ve `b` sadece sol tablodan sütunlar. [\#4141](https://github.com/ClickHouse/ClickHouse/pull/4141) ([Artem Zuikov](https://github.com/4ertus2)) +- Vermek `-C` olarak çalışmak için müşterinin seçeneği `-c` seçenek. [\#4232](https://github.com/ClickHouse/ClickHouse/pull/4232) ([syominsergey](https://github.com/syominsergey)) +- Şimdi seçenek `--password` değer olmadan kullanılan stdın'den şifre gerektirir. [\#4230](https://github.com/ClickHouse/ClickHouse/pull/4230) ([BSD\_Conqueror](https://github.com/bsd-conqueror)) +- İçeren dize değişmezleri unescaped metacharacters eklendi vurgulama `LIKE` ifadeler veya regexps. [\#4327](https://github.com/ClickHouse/ClickHouse/pull/4327) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İstemci soketi kaybolursa HTTP salt okunur sorgularının iptal edilmesi eklendi. [\#4213](https://github.com/ClickHouse/ClickHouse/pull/4213) ([nvartolomei](https://github.com/nvartolomei)) +- Şimdi sunucu, istemci bağlantılarını canlı tutmak için ilerlemeyi bildiriyor. [\#4215](https://github.com/ClickHouse/ClickHouse/pull/4215) ([I ivanvan](https://github.com/abyss7)) +- Sorgu ile OPTİMİZE etmek için biraz daha iyi mesaj `optimize_throw_if_noop` ayar Etkin. [\#4294](https://github.com/ClickHouse/ClickHouse/pull/4294) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Desteği eklendi `--version` clickhouse sunucusu için Seçenek. [\#4251](https://github.com/ClickHouse/ClickHouse/pull/4251) ([Lopatin Konstantin](https://github.com/k-lopatin)) +- Katma `--help/-h` seçeneği `clickhouse-server`. [\#4233](https://github.com/ClickHouse/ClickHouse/pull/4233) ([Yuriy Baranov](https://github.com/yurriy)) +- Toplam işlev durumu sonucu ile skaler alt sorgular için destek eklendi. [\#4348](https://github.com/ClickHouse/ClickHouse/pull/4348) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Geliştirilmiş sunucu kapatma süresi ve bekleme süresini değiştirir. [\#4372](https://github.com/ClickHouse/ClickHouse/pull/4372) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sisteme replicated\_can\_become\_leader ayarı hakkında bilgi eklendi.yinelemeler ve çoğaltma lider olmaya çalışmayacaksa günlüğü ekleyin. [\#4379](https://github.com/ClickHouse/ClickHouse/pull/4379) ([Alex Zatelepin](https://github.com/ztlpn)) + +## ClickHouse sürümü 19.1 {#clickhouse-release-19-1} + +### ClickHouse sürümü 19.1.14, 2019-03-14 {#clickhouse-release-19-1-14-2019-03-14} + +- Sabit hata `Column ... queried more than once` bu ayar eğer gerçekleşebilir `asterisk_left_columns_only` kullanılması durumunda 1 olarak ayarlanır `GLOBAL JOIN` ile `SELECT *` (nadir bir durum). Sorun 19.3 ve daha yeni sürümlerde mevcut değil. [6bac7d8d](https://github.com/ClickHouse/ClickHouse/pull/4692/commits/6bac7d8d11a9b0d6de0b32b53c47eb2f6f8e7062) ([Artem Zuikov](https://github.com/4ertus2)) + +### ClickHouse sürümü 19.1.13, 2019-03-12 {#clickhouse-release-19-1-13-2019-03-12} + +Bu sürüm, 19.3.7 ile tam olarak aynı yamalar kümesini içerir. + +### ClickHouse sürümü 19.1.10, 2019-03-03 {#clickhouse-release-19-1-10-2019-03-03} + +Bu sürüm, 19.3.6 ile tam olarak aynı yamalar kümesini içerir. + +## ClickHouse sürümü 19.1 {#clickhouse-release-19-1-1} + +### ClickHouse sürümü 19.1.9, 2019-02-21 {#clickhouse-release-19-1-9-2019-02-21} + +#### Hata düzeltmeleri {#bug-fixes-18} + +- Yanlış uygulama nedeniyle eski sürümlerle geriye dönük uyumsuzluk düzeltildi `send_logs_level` ayar. [\#4445](https://github.com/ClickHouse/ClickHouse/pull/4445) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tablo fonksiyonunun geriye dönük uyumsuzluğu düzeltildi `remote` sütun yorumları ile tanıtıldı. [\#4446](https://github.com/ClickHouse/ClickHouse/pull/4446) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse sürümü 19.1.8, 2019-02-16 {#clickhouse-release-19-1-8-2019-02-16} + +#### Hata Düzeltmeleri {#bug-fixes-19} + +- Eksik /etc/clickhouse-server/config ile paketi yükleyin.xml. [\#4343](https://github.com/ClickHouse/ClickHouse/pull/4343) ([proller](https://github.com/proller)) + +## ClickHouse sürümü 19.1 {#clickhouse-release-19-1-2} + +### ClickHouse sürümü 19.1.7, 2019-02-15 {#clickhouse-release-19-1-7-2019-02-15} + +#### Hata Düzeltmeleri {#bug-fixes-20} + +- Doğru türü doğru şekilde döndürün ve kilitleri düzgün şekilde tutun `joinGet` işlev. [\#4153](https://github.com/ClickHouse/ClickHouse/pull/4153) ([Amos Kuşu](https://github.com/amosbird)) +- Sistem günlükleri sunucu kapatma yeniden oluşturmak için denendiğinde hata düzeltildi. [\#4254](https://github.com/ClickHouse/ClickHouse/pull/4254) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit hata: bir veritabanı varsa `Dictionary` motor, tüm sözlükler sunucu başlangıçta yüklemeye zorlanır ve localhost'tan ClickHouse kaynağı olan bir sözlük varsa, sözlük yüklenemez. [\#4255](https://github.com/ClickHouse/ClickHouse/pull/4255) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İçeren mutasyonların yürütülmesi bir hata düzeltildi `IN` operatörler yanlış sonuçlar üretiyordu. [\#4099](https://github.com/ClickHouse/ClickHouse/pull/4099) ([Alex Zatelepin](https://github.com/ztlpn)) +- `clickhouse-client` etkileşimli modda çalıştırıldıysa, komut satırı önerileri için veri yüklerken çıkışta segfault yapabilir. [\#4317](https://github.com/ClickHouse/ClickHouse/pull/4317) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Seçerken sabit yarış durumu `system.tables` verebilir `table doesn't exist` hatasız. [\#4313](https://github.com/ClickHouse/ClickHouse/pull/4313) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit kilitlenme zaman `SELECT` ile bir tablo fromdan `File` motor sonra yeniden denendi `No such file or directory` hatasız. [\#4161](https://github.com/ClickHouse/ClickHouse/pull/4161) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bir sorun düzeltildi: yerel ClickHouse sözlükleri TCP üzerinden yüklenir, ancak işlem içinde yüklenmelidir. [\#4166](https://github.com/ClickHouse/ClickHouse/pull/4166) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit `No message received` TLS bağlantısı üzerinden PostgreSQL ODBC sürücüsü ile etkileşimde bulunurken hata. MySQL ODBC sürücüsü kullanırken de segfault giderir. [\#4170](https://github.com/ClickHouse/ClickHouse/pull/4170) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yüklem optimizasyonunu geçici olarak devre dışı bırak `ORDER BY`. [\#3890](https://github.com/ClickHouse/ClickHouse/pull/3890) ([Kış Zhang](https://github.com/zhang2014)) +- Tablo işlevinden seçerken sabit sonsuz döngü `numbers(0)`. [\#4280](https://github.com/ClickHouse/ClickHouse/pull/4280) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit `compile_expressions` büyük (ınt16'dan daha fazla) tarihlerin karşılaştırılması ile hata. [\#4341](https://github.com/ClickHouse/ClickHouse/pull/4341) ([alesapin](https://github.com/alesapin)) +- Sabit segmentasyon hatası `uncompressed_cache=1` ve yanlış sıkıştırılmamış boyutta istisna. [\#4186](https://github.com/ClickHouse/ClickHouse/pull/4186) ([alesapin](https://github.com/alesapin)) +- Sabit `ALL JOIN` sağ tabloda çiftleri ile. [\#4184](https://github.com/ClickHouse/ClickHouse/pull/4184) ([Artem Zuikov](https://github.com/4ertus2)) +- Yaparken yanlış davranış düzeltildi `INSERT ... SELECT ... FROM file(...)` sorgu ve dosya var `CSVWithNames` veya `TSVWIthNames` biçim ve ilk veri satırı eksik. [\#4297](https://github.com/ClickHouse/ClickHouse/pull/4297) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit toplam fonksiyonları yürütme ile `Array(LowCardinality)` değişkenler. [\#4055](https://github.com/ClickHouse/ClickHouse/pull/4055) ([KochetovNicolai](https://github.com/KochetovNicolai)) +- Debian paketi: yapılandırmaya göre /etc/clickhouse-server/preprocessed bağlantısını düzeltin. [\#4205](https://github.com/ClickHouse/ClickHouse/pull/4205) ([proller](https://github.com/proller)) +- Tanımsız davranış sanitizer altında sabit fuzz testi: eklendi parametre tipi kontrol için `quantile*Weighted` fonksiyonlar ailesi. [\#4145](https://github.com/ClickHouse/ClickHouse/pull/4145) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yapmak `START REPLICATED SENDS` komut Başlat çoğaltılmış gönderir. [\#4229](https://github.com/ClickHouse/ClickHouse/pull/4229) ([nvartolomei](https://github.com/nvartolomei)) +- Sabit `Not found column` join on bölümündeki yinelenen sütunlar için. [\#4279](https://github.com/ClickHouse/ClickHouse/pull/4279) ([Artem Zuikov](https://github.com/4ertus2)) +- Şimdi `/etc/ssl` SSL sertifikaları ile varsayılan dizin olarak kullanılır. [\#4167](https://github.com/ClickHouse/ClickHouse/pull/4167) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sözlük mevcut değilse sözlük yeniden sabit kazasında. [\#4188](https://github.com/ClickHouse/ClickHouse/pull/4188) ([proller](https://github.com/proller)) +- Yanlış ile Sabit hata `Date` ve `DateTime` karşılaştırma. [\#4237](https://github.com/ClickHouse/ClickHouse/pull/4237) ([valexey](https://github.com/valexey)) +- Sabit yanlış sonuç ne zaman `Date` ve `DateTime` argümanlar koşullu operatörün dallarında kullanılır (işlev `if`). Fonksiyon için genel durum eklendi `if`. [\#4243](https://github.com/ClickHouse/ClickHouse/pull/4243) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +### ClickHouse sürümü 19.1.6, 2019-01-24 {#clickhouse-release-19-1-6-2019-01-24} + +#### Yenilik {#new-features-7} + +- Tablolar için sütun sıkıştırma codec başına özel. [\#3899](https://github.com/ClickHouse/ClickHouse/pull/3899) [\#4111](https://github.com/ClickHouse/ClickHouse/pull/4111) ([alesapin](https://github.com/alesapin), [Kış Zhang](https://github.com/zhang2014), [Anatoly](https://github.com/Sindbag)) +- Eklendi sıkıştırma codec `Delta`. [\#4052](https://github.com/ClickHouse/ClickHouse/pull/4052) ([alesapin](https://github.com/alesapin)) +- İzin ver `ALTER` sıkıştırma codec. [\#4054](https://github.com/ClickHouse/ClickHouse/pull/4054) ([alesapin](https://github.com/alesapin)) +- Eklenen fonksiyonlar `left`, `right`, `trim`, `ltrim`, `rtrim`, `timestampadd`, `timestampsub` SQL standart uyumluluk için. [\#3826](https://github.com/ClickHouse/ClickHouse/pull/3826) ([Ivan Blinkov](https://github.com/blinkov)) +- Yazma desteği `HDFS` tablolar ve `hdfs` tablo işlevi. [\#4084](https://github.com/ClickHouse/ClickHouse/pull/4084) ([alesapin](https://github.com/alesapin)) +- Büyük samanlıkta birden fazla sabit dizeleri aramak için fonksiyonlar eklendi: `multiPosition`, `multiSearch` ,`firstMatch` ayrıca ile `-UTF8`, `-CaseInsensitive`, ve `-CaseInsensitiveUTF8` varyantlar. [\#4053](https://github.com/ClickHouse/ClickHouse/pull/4053) ([Danila Kutenin](https://github.com/danlark1)) +- Kullanılmayan parçaların budaması `SELECT` sharding anahtarına göre sorgu filtreleri (ayar `optimize_skip_unused_shards`). [\#3851](https://github.com/ClickHouse/ClickHouse/pull/3851) ([Gleb Kanterov](https://github.com/kanterov), [I ivanvan](https://github.com/abyss7)) +- Vermek `Kafka` blok başına bazı ayrıştırma hatalarını görmezden gelmek için motor. [\#4094](https://github.com/ClickHouse/ClickHouse/pull/4094) ([I ivanvan](https://github.com/abyss7)) +- İçin destek eklendi `CatBoost` multiclass modelleri değerlendirme. İşlev `modelEvaluate` multiclass modelleri için sınıf başına ham tahminleri ile tuple döndürür. `libcatboostmodel.so` ile inşa edilmelidir [\#607](https://github.com/catboost/catboost/pull/607). [\#3959](https://github.com/ClickHouse/ClickHouse/pull/3959) ([KochetovNicolai](https://github.com/KochetovNicolai)) +- Eklenen fonksiyonlar `filesystemAvailable`, `filesystemFree`, `filesystemCapacity`. [\#4097](https://github.com/ClickHouse/ClickHouse/pull/4097) ([Boris Granveaud](https://github.com/bgranvea)) +- Karma fonksiyonları eklendi `xxHash64` ve `xxHash32`. [\#3905](https://github.com/ClickHouse/ClickHouse/pull/3905) ([filimonov](https://github.com/filimonov)) +- Katma `gccMurmurHash` aynı karma tohumu kullanan karma işlevi (GCC aromalı üfürüm hash) [gcc](https://github.com/gcc-mirror/gcc/blob/41d6b10e96a1de98e90a7c0378437c3255814b16/libstdc%2B%2B-v3/include/bits/functional_hash.h#L191) [\#4000](https://github.com/ClickHouse/ClickHouse/pull/4000) ([sundyli](https://github.com/sundy-li)) +- Karma fonksiyonları eklendi `javaHash`, `hiveHash`. [\#3811](https://github.com/ClickHouse/ClickHouse/pull/3811) ([shangshujie365](https://github.com/shangshujie365)) +- Eklenen tablo fonksiyonu `remoteSecure`. Fonksiyonu olarak çalışır `remote`, ancak güvenli bağlantı kullanır. [\#4088](https://github.com/ClickHouse/ClickHouse/pull/4088) ([proller](https://github.com/proller)) + +#### Deneysel özellikler {#experimental-features-3} + +- Birden fazla Katıl emımlı em emülasyon eklendi (`allow_experimental_multiple_joins_emulation` ayar). [\#3946](https://github.com/ClickHouse/ClickHouse/pull/3946) ([Artem Zuikov](https://github.com/4ertus2)) + +#### Hata Düzeltmeleri {#bug-fixes-21} + +- Yapmak `compiled_expression_cache_size` bellek tüketimini azaltmak için varsayılan olarak sınırlı ayarı. [\#4041](https://github.com/ClickHouse/ClickHouse/pull/4041) ([alesapin](https://github.com/alesapin)) +- Çoğaltılmış tabloların değiştirmelerini gerçekleştiren iş parçacıklarında ve zookeeper'dan yapılandırmayı güncelleyen iş parçacıklarında hangup'lara yol açan bir hatayı düzeltin. [\#2947](https://github.com/ClickHouse/ClickHouse/issues/2947) [\#3891](https://github.com/ClickHouse/ClickHouse/issues/3891) [\#3934](https://github.com/ClickHouse/ClickHouse/pull/3934) ([Alex Zatelepin](https://github.com/ztlpn)) +- Dağıtılmış bir ALTER görevi yürütürken bir yarış durumu düzeltildi. Yarış durumu, görevi yürütmeye çalışan birden fazla kopyaya ve bir ZooKeeper hatasıyla başarısız olan tüm kopyalara yol açtı. [\#3904](https://github.com/ClickHouse/ClickHouse/pull/3904) ([Alex Zatelepin](https://github.com/ztlpn)) +- Bir hatayı düzeltin `from_zk` zookeeper zaman aşımına uğradıktan sonra yapılandırma öğeleri yenilenmedi. [\#2947](https://github.com/ClickHouse/ClickHouse/issues/2947) [\#3947](https://github.com/ClickHouse/ClickHouse/pull/3947) ([Alex Zatelepin](https://github.com/ztlpn)) +- IPv4 alt ağ maskeleri için yanlış önek ile hatayı düzeltin. [\#3945](https://github.com/ClickHouse/ClickHouse/pull/3945) ([alesapin](https://github.com/alesapin)) +- Sabit kaza (`std::terminate`) nadir durumlarda, tükenmiş kaynaklar nedeniyle yeni bir iş parçacığı oluşturulamazsa. [\#3956](https://github.com/ClickHouse/ClickHouse/pull/3956) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Fix hata ne zaman `remote` In için yanlış kısıtlamalar kullanıldığında tablo işlevi yürütme `getStructureOfRemoteTable`. [\#4009](https://github.com/ClickHouse/ClickHouse/pull/4009) ([alesapin](https://github.com/alesapin)) +- Netlink soketleri sızıntısını düzeltin. Hiçbir zaman silinmedikleri bir havuza yerleştirildiler ve tüm geçerli soketler kullanımda olduğunda yeni bir iş parçacığının başlangıcında yeni soketler oluşturuldu. [\#4017](https://github.com/ClickHouse/ClickHouse/pull/4017) ([Alex Zatelepin](https://github.com/ztlpn)) +- Kapanış ile hatayı düzeltin `/proc/self/fd` tüm fds'den önceki dizin okundu `/proc` çatal sonra `odbc-bridge` alt işlem. [\#4120](https://github.com/ClickHouse/ClickHouse/pull/4120) ([alesapin](https://github.com/alesapin)) +- Birincil anahtarda kullanım dizesi durumunda uint monotonik dönüşüm için sabit dize. [\#3870](https://github.com/ClickHouse/ClickHouse/pull/3870) ([Kış Zhang](https://github.com/zhang2014)) +- Tamsayı dönüşüm fonksiyonu Monotonluk hesaplanmasında Sabit hata. [\#3921](https://github.com/ClickHouse/ClickHouse/pull/3921) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit segfault içinde `arrayEnumerateUniq`, `arrayEnumerateDense` bazı geçersiz argümanlar durumunda işlevler. [\#3909](https://github.com/ClickHouse/ClickHouse/pull/3909) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- STORAGEMERGE'DE ub'yi düzeltin. [\#3910](https://github.com/ClickHouse/ClickHouse/pull/3910) ([Amos Kuşu](https://github.com/amosbird)) +- Fonksiyonlarda sabit segfault `addDays`, `subtractDays`. [\#3913](https://github.com/ClickHouse/ClickHouse/pull/3913) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit hata: fonksiyonlar `round`, `floor`, `trunc`, `ceil` tamsayı argümanı ve büyük negatif ölçekte yürütüldüğünde sahte sonuç döndürebilir. [\#3914](https://github.com/ClickHouse/ClickHouse/pull/3914) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tarafından uyarılan bir hata düzeltildi ‘kill query sync’ bu da bir çekirdek çöplüğüne yol açar. [\#3916](https://github.com/ClickHouse/ClickHouse/pull/3916) ([muVulDeePecker](https://github.com/fancyqlx)) +- Boş çoğaltma kuyruğundan sonra uzun gecikmeyle hatayı düzeltin. [\#3928](https://github.com/ClickHouse/ClickHouse/pull/3928) [\#3932](https://github.com/ClickHouse/ClickHouse/pull/3932) ([alesapin](https://github.com/alesapin)) +- İle tabloya ekleme durumunda sabit aşırı bellek kullanımı `LowCardinality` birincil anahtar. [\#3955](https://github.com/ClickHouse/ClickHouse/pull/3955) ([KochetovNicolai](https://github.com/KochetovNicolai)) +- Sabit `LowCardinality` için serileştirme `Native` boş diziler durumunda format. [\#3907](https://github.com/ClickHouse/ClickHouse/issues/3907) [\#4011](https://github.com/ClickHouse/ClickHouse/pull/4011) ([KochetovNicolai](https://github.com/KochetovNicolai)) +- Tek LowCardinality sayısal sütun tarafından dıstınct kullanırken yanlış sonuç düzeltildi. [\#3895](https://github.com/ClickHouse/ClickHouse/issues/3895) [\#4012](https://github.com/ClickHouse/ClickHouse/pull/4012) ([KochetovNicolai](https://github.com/KochetovNicolai)) +- LowCardinality anahtarı ile sabit özel toplama (durumunda `compile` ayar etkinse) ' dir. [\#3886](https://github.com/ClickHouse/ClickHouse/pull/3886) ([KochetovNicolai](https://github.com/KochetovNicolai)) +- Çoğaltılmış tablo sorguları için kullanıcı ve şifre iletimini düzeltin. [\#3957](https://github.com/ClickHouse/ClickHouse/pull/3957) ([alesapin](https://github.com/alesapin)) ([小路](https://github.com/nicelulu)) +- Sözlükleri yeniden yüklerken sözlük veritabanındaki tabloları listelerken oluşabilecek çok nadir yarış durumu düzeltildi. [\#3970](https://github.com/ClickHouse/ClickHouse/pull/3970) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Toplaması veya küp ile kullanıldığında yanlış sonuç düzeltildi. [\#3756](https://github.com/ClickHouse/ClickHouse/issues/3756) [\#3837](https://github.com/ClickHouse/ClickHouse/pull/3837) ([Sam Chou](https://github.com/reflection)) +- Sorgu için sabit sütun takma adları `JOIN ON` sözdizimi ve dağıtılmış tablolar. [\#3980](https://github.com/ClickHouse/ClickHouse/pull/3980) ([Kış Zhang](https://github.com/zhang2014)) +- Dahili uygulamada Sabit hata `quantileTDigest` (Artem Vakhrushev tarafından bulundu). Bu hata hiçbir zaman Clickhouse'da olmaz ve yalnızca ClickHouse kod tabanını doğrudan bir kütüphane olarak kullananlar için geçerlidir. [\#3935](https://github.com/ClickHouse/ClickHouse/pull/3935) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Geliştirmeler {#improvements-6} + +- İçin destek `IF NOT EXISTS` içinde `ALTER TABLE ADD COLUMN` ile birlikte ifadeler `IF EXISTS` içinde `DROP/MODIFY/CLEAR/COMMENT COLUMN`. [\#3900](https://github.com/ClickHouse/ClickHouse/pull/3900) ([Boris Granveaud](https://github.com/bgranvea)) +- İşlev `parseDateTimeBestEffort`: format desteği `DD.MM.YYYY`, `DD.MM.YY`, `DD-MM-YYYY`, `DD-Mon-YYYY`, `DD/Month/YYYY` ve benzeri. [\#3922](https://github.com/ClickHouse/ClickHouse/pull/3922) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- `CapnProtoInputStream` şimdi pürüzlü yapıları destekleyin. [\#4063](https://github.com/ClickHouse/ClickHouse/pull/4063) ([Odin Hultgren Van Der Horst](https://github.com/Miniwoffer)) +- Kullanılabilirlik iyileştirme: sunucu işleminin veri dizininin sahibinden başlatıldığı bir kontrol eklendi. Veriler kök olmayan kullanıcıya aitse, sunucunun kökünden başlatılmasına izin vermeyin. [\#3785](https://github.com/ClickHouse/ClickHouse/pull/3785) ([sergey-v-galtsev](https://github.com/sergey-v-galtsev)) +- Birleştirme ile sorguların analizi sırasında gerekli sütunları kontrol etmenin daha iyi mantığı. [\#3930](https://github.com/ClickHouse/ClickHouse/pull/3930) ([Artem Zuikov](https://github.com/4ertus2)) +- Tek bir sunucuda çok sayıda dağıtılmış tablo durumunda bağlantı sayısını azalttı. [\#3726](https://github.com/ClickHouse/ClickHouse/pull/3726) ([Kış Zhang](https://github.com/zhang2014)) +- Desteklenen toplamlar için satır `WITH TOTALS` ODBC sürücüsü için sorgu. [\#3836](https://github.com/ClickHouse/ClickHouse/pull/3836) ([Maksim Koritckiy](https://github.com/nightweb)) +- Kullanmasına izin `Enum`eğer fonksiyon içinde tamsayılar olarak s. [\#3875](https://github.com/ClickHouse/ClickHouse/pull/3875) ([I ivanvan](https://github.com/abyss7)) +- Katma `low_cardinality_allow_in_native_format` ayar. Devre dışı bırakılırsa, kullanmayın `LowCadrinality` yazmak `Native` biçimli. [\#3879](https://github.com/ClickHouse/ClickHouse/pull/3879) ([KochetovNicolai](https://github.com/KochetovNicolai)) +- Daha düşük bellek kullanımı için derlenmiş ifadeler önbelleğinden bazı gereksiz nesneleri kaldırıldı. [\#4042](https://github.com/ClickHouse/ClickHouse/pull/4042) ([alesapin](https://github.com/alesapin)) +- Add check that `SET send_logs_level = 'value'` sorgu uygun değeri kabul eder. [\#3873](https://github.com/ClickHouse/ClickHouse/pull/3873) ([Sabyanin Maxim](https://github.com/s-mx)) +- Sabit veri türü türü dönüştürme işlevleri kontrol edin. [\#3896](https://github.com/ClickHouse/ClickHouse/pull/3896) ([Kış Zhang](https://github.com/zhang2014)) + +#### Performans İyileştirmeleri {#performance-improvements-5} + +- MergeTree ayarı ekleme `use_minimalistic_part_header_in_zookeeper`. Etkinse, çoğaltılmış tablolar kompakt parça meta verilerini tek parça znode depolar. Bu, ZooKeeper anlık görüntü boyutunu önemli ölçüde azaltabilir (özellikle tablolarda çok fazla sütun varsa). Bu ayarı etkinleştirdikten sonra, desteklemeyen bir sürüme indiremeyeceğinizi unutmayın. [\#3960](https://github.com/ClickHouse/ClickHouse/pull/3960) ([Alex Zatelepin](https://github.com/ztlpn)) +- İşlevler için DFA tabanlı bir uygulama ekleyin `sequenceMatch` ve `sequenceCount` durumda desen zaman içermez. [\#4004](https://github.com/ClickHouse/ClickHouse/pull/4004) ([Léo Ercolanelli](https://github.com/ercolanelli-leo)) +- Tam sayı serileştirme için performans iyileştirme. [\#3968](https://github.com/ClickHouse/ClickHouse/pull/3968) ([Amos Kuşu](https://github.com/amosbird)) +- Sıfır sol dolgu PODArray böylece -1 öğesi her zaman geçerli ve sıfırlanır. Ofsetlerin dalsız hesaplanması için kullanılır. [\#3920](https://github.com/ClickHouse/ClickHouse/pull/3920) ([Amos Kuşu](https://github.com/amosbird)) +- Döndürüyordu `jemalloc` performans düşüşüne yol sürüm. [\#4018](https://github.com/ClickHouse/ClickHouse/pull/4018) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Geriye Dönük Uyumsuz Değişiklikler {#backward-incompatible-changes-2} + +- Kaldırılan belgesiz özellik `ALTER MODIFY PRIMARY KEY` çünkü onun yerini aldı. `ALTER MODIFY ORDER BY` komut. [\#3887](https://github.com/ClickHouse/ClickHouse/pull/3887) ([Alex Zatelepin](https://github.com/ztlpn)) +- Kaldırılan işlev `shardByHash`. [\#3833](https://github.com/ClickHouse/ClickHouse/pull/3833) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Türün sonucu ile skaler alt sorguları kullanmayı yasaklayın `AggregateFunction`. [\#3865](https://github.com/ClickHouse/ClickHouse/pull/3865) ([I ivanvan](https://github.com/abyss7)) + +#### Yapı / Test / Ambalaj Geliştirmeleri {#buildtestingpackaging-improvements-6} + +- PowerPC için destek eklendi (`ppc64le`) yapmak. [\#4132](https://github.com/ClickHouse/ClickHouse/pull/4132) ([Danila Kutenin](https://github.com/danlark1)) +- Duruma göre fonksiyonel testlerin ortak kullanılabilir veri kümesi üzerinde çalışır. [\#3969](https://github.com/ClickHouse/ClickHouse/pull/3969) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sunucu ile başlatılamıyor Sabit hata `bash: /usr/bin/clickhouse-extract-from-config: Operation not permitted` Docker veya systemd-nspawn içindeki mesaj. [\#4136](https://github.com/ClickHouse/ClickHouse/pull/4136) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Güncel `rdkafka` kütüphane v1.0.0-RC5 için. Ham c arayüzü yerine cppkafka kullanılır. [\#4025](https://github.com/ClickHouse/ClickHouse/pull/4025) ([I ivanvan](https://github.com/abyss7)) +- Güncel `mariadb-client` kitaplık. UBSan tarafından bulunan sorunlardan biri düzeltildi. [\#3924](https://github.com/ClickHouse/ClickHouse/pull/3924) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- UBSan için bazı düzeltmeler oluşturur. [\#3926](https://github.com/ClickHouse/ClickHouse/pull/3926) [\#3021](https://github.com/ClickHouse/ClickHouse/pull/3021) [\#3948](https://github.com/ClickHouse/ClickHouse/pull/3948) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- UBSan yapı ile testlerin başına taahhüt ishal eklendi. +- PVS-Studio statik analyzer başına taahhüt ishal eklendi. +- PVS-Studio tarafından bulunan sabit hatalar. [\#4013](https://github.com/ClickHouse/ClickHouse/pull/4013) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit glibc uyumluluk sorunları. [\#4100](https://github.com/ClickHouse/ClickHouse/pull/4100) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Docker resimlerini 18.10'a taşıyın ve glibc \>= 2.28 için uyumluluk dosyası ekleyin [\#3965](https://github.com/ClickHouse/ClickHouse/pull/3965) ([alesapin](https://github.com/alesapin)) +- Kullanıcı sunucu Docker görüntü dizinleri chown istemiyorsanız env değişken ekleyin. [\#3967](https://github.com/ClickHouse/ClickHouse/pull/3967) ([alesapin](https://github.com/alesapin)) +- Gelen uyar theıların en etkin `-Weverything` çınlama içinde. Etkin `-Wpedantic`. [\#3986](https://github.com/ClickHouse/ClickHouse/pull/3986) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sadece clang 8'de bulunan birkaç uyarı daha eklendi. [\#3993](https://github.com/ClickHouse/ClickHouse/pull/3993) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bağlanmak `libLLVM` paylaşılan bağlantı kullanırken bireysel LLVM libs yerine. [\#3989](https://github.com/ClickHouse/ClickHouse/pull/3989) ([Orivej Desh](https://github.com/orivej)) +- Test görüntüleri için sanitizer değişkenleri eklendi. [\#4072](https://github.com/ClickHouse/ClickHouse/pull/4072) ([alesapin](https://github.com/alesapin)) +- `clickhouse-server` debian paketi tavsiye edecek `libcap2-bin` kullanmak için paket `setcap` yetenekleri ayarlamak için bir araç. Bu isteğe bağlıdır. [\#4093](https://github.com/ClickHouse/ClickHouse/pull/4093) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Geliştirilmiş derleme süresi, sabit içerir. [\#3898](https://github.com/ClickHouse/ClickHouse/pull/3898) ([proller](https://github.com/proller)) +- Karma fonksiyonlar için performans testleri eklendi. [\#3918](https://github.com/ClickHouse/ClickHouse/pull/3918) ([filimonov](https://github.com/filimonov)) +- Sabit döngüsel kütüphane bağımlılıkları. [\#3958](https://github.com/ClickHouse/ClickHouse/pull/3958) ([proller](https://github.com/proller)) +- Düşük kullanılabilir bellek ile geliştirilmiş derleme. [\#4030](https://github.com/ClickHouse/ClickHouse/pull/4030) ([proller](https://github.com/proller)) +- Performans düşüşünü yeniden oluşturmak için test betiği eklendi `jemalloc`. [\#4036](https://github.com/ClickHouse/ClickHouse/pull/4036) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yorumlarda ve dize değişmezlerinde sabit yazım hataları `dbms`. [\#4122](https://github.com/ClickHouse/ClickHouse/pull/4122) ([maiha](https://github.com/maiha)) +- Yorumlarda sabit yazım hataları. [\#4089](https://github.com/ClickHouse/ClickHouse/pull/4089) ([Evgenii Pravda](https://github.com/kvinty)) + +## [2018 için Changelog](https://github.com/ClickHouse/ClickHouse/blob/master/docs/en/changelog/2018.md) {#changelog-for-2018} diff --git a/docs/tr/whats_new/changelog/index.md b/docs/tr/whats_new/changelog/index.md new file mode 100644 index 00000000000..5f446b526c7 --- /dev/null +++ b/docs/tr/whats_new/changelog/index.md @@ -0,0 +1,668 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: Changelog +toc_priority: 74 +toc_title: '2020' +--- + +## ClickHouse sürüm v20. 3 {#clickhouse-release-v20-3} + +### ClickHouse yayın v20.3. 4. 10, 2020-03-20 {#clickhouse-release-v20-3-4-10-2020-03-20} + +#### Hata Düzeltme {#bug-fix} + +- Bu sürüm ayrıca 20.1.8.41 tüm hata düzeltmeleri içerir +- Eksik düzeltme `rows_before_limit_at_least` http üzerinden sorgular için (işlemciler boru hattı ile). Bu düzeltmeler [\#9730](https://github.com/ClickHouse/ClickHouse/issues/9730). [\#9757](https://github.com/ClickHouse/ClickHouse/pull/9757) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) + +### ClickHouse yayın v20.3. 3. 6, 2020-03-17 {#clickhouse-release-v20-3-3-6-2020-03-17} + +#### Hata Düzeltme {#bug-fix-1} + +- Bu sürüm ayrıca 20.1.7.38 tüm hata düzeltmeleri içerir +- Kullanıcı önceki sürümde mutasyonlar yürüttüyse, çoğaltmanın çalışmasına izin vermeyen bir çoğaltmada hatayı düzeltin. Bu düzeltmeler [\#9645](https://github.com/ClickHouse/ClickHouse/issues/9645). [\#9652](https://github.com/ClickHouse/ClickHouse/pull/9652) ([alesapin](https://github.com/alesapin)). 20.3 sürümünü tekrar geriye dönük uyumlu hale getirir. +- Ayar Ekle `use_compact_format_in_distributed_parts_names` hangi dosyaları yazmak için izin verir `INSERT` içine sorgular `Distributed` daha kompakt formatlı tablo. Bu düzeltmeler [\#9647](https://github.com/ClickHouse/ClickHouse/issues/9647). [\#9653](https://github.com/ClickHouse/ClickHouse/pull/9653) ([alesapin](https://github.com/alesapin)). 20.3 sürümünü tekrar geriye dönük uyumlu hale getirir. + +### ClickHouse yayın v20.3. 2. 1, 2020-03-12 {#clickhouse-release-v20-3-2-1-2020-03-12} + +#### Geriye Dönük Uyumsuz Değişim {#backward-incompatible-change} + +- Sorunu düzelt fixedildi `file name too long` için veri gönderirken `Distributed` çok sayıda çoğaltma için tablolar. Çoğaltma kimlik bilgileri sunucu günlüğüne maruz sorunu düzeltildi. Diskteki dizin adı biçimi değiştirildi `[shard{shard_index}[_replica{replica_index}]]`. [\#8911](https://github.com/ClickHouse/ClickHouse/pull/8911) ([Mikhail Korotov](https://github.com/millb)) Yeni sürüme yükselttikten sonra, eski sunucu sürümü yeni dizin biçimini tanımadığı için manuel müdahale olmadan düşüremezsiniz. Downgrade yapmak istiyorsanız, ilgili dizinleri eski biçime el ile yeniden adlandırmanız gerekir. Bu değişiklik yalnızca zaman uyumsuz kullandıysanız geçerlidir `INSERT`s to `Distributed` Tablolar. 20.3.3 sürümünde, yeni formatı kademeli olarak etkinleştirmenize izin verecek bir ayar sunacağız. +- Mutasyon komutları için çoğaltma günlük girişlerinin biçimini değiştirdi. Yeni sürümü yüklemeden önce eski mutasyonların işlenmesini beklemeniz gerekir. +- Stacktraces döker basit bellek profiler uygulamak `system.trace_log` her n bayt yumuşak ayırma sınırı üzerinde [\#8765](https://github.com/ClickHouse/ClickHouse/pull/8765) ([I ivanvan](https://github.com/abyss7)) [\#9472](https://github.com/ClickHouse/ClickHouse/pull/9472) ([alexey-milovidov](https://github.com/alexey-milovidov) Olan ) sütun `system.trace_log` 'den değiştirildi `timer_type` -e doğru `trace_type`. Bu, üçüncü taraf performans analizi ve flamegraph işleme araçlarında değişiklikler gerektirecektir. +- İç iş parçacığı numarası yerine her yerde OS iş parçacığı kimliğini kullanın. Bu düzeltmeler [\#7477](https://github.com/ClickHouse/ClickHouse/issues/7477) Yaş `clickhouse-client` sunucu ne zaman ayarı gönderme günlükleri alınamıyor `send_logs_level` yapılandırılmış günlük iletilerinin adları ve türleri değiştirildiğinden etkindir. Öte yandan, farklı sunucu sürümleri birbirine farklı türlerde günlükleri gönderebilir. Kullan whenmay theınca `send_logs_level` ayar, umursamamalısın. [\#8954](https://github.com/ClickHouse/ClickHouse/pull/8954) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kaldırmak `indexHint` işlev [\#9542](https://github.com/ClickHouse/ClickHouse/pull/9542) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kaldırmak `findClusterIndex`, `findClusterValue` işlevler. Bu düzeltmeler [\#8641](https://github.com/ClickHouse/ClickHouse/issues/8641). Bu işlevleri kullanıyorsanız, bir e-posta gönderin `clickhouse-feedback@yandex-team.com` [\#9543](https://github.com/ClickHouse/ClickHouse/pull/9543) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Şimdi sütun oluşturmak veya sütun eklemek için izin verilmez `SELECT` varsayılan ifade olarak alt sorgu. [\#9481](https://github.com/ClickHouse/ClickHouse/pull/9481) ([alesapin](https://github.com/alesapin)) +- JOİN alt sorgular için takma adlar gerektirir. [\#9274](https://github.com/ClickHouse/ClickHouse/pull/9274) ([Artem Zuikov](https://github.com/4ertus2)) +- Gelişmiş `ALTER MODIFY/ADD` sorgu mantığı. Şimdi yapamazsın `ADD` türü olmayan sütun, `MODIFY` varsayılan ifade sütun türünü değiştirmez ve `MODIFY` tür varsayılan ifade değerini kaybetmez. Düzeltiyor [\#8669](https://github.com/ClickHouse/ClickHouse/issues/8669). [\#9227](https://github.com/ClickHouse/ClickHouse/pull/9227) ([alesapin](https://github.com/alesapin)) +- Günlük yapılandırma değişiklikleri uygulamak için yeniden başlatılması için sunucu gerektirir. Bu, sunucunun silinmiş bir günlük dosyasına oturum açtığı hatayı önlemek için geçici bir geçici çözümdür (bkz. [\#8696](https://github.com/ClickHouse/ClickHouse/issues/8696)). [\#8707](https://github.com/ClickHouse/ClickHouse/pull/8707) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Ayar `experimental_use_processors` varsayılan olarak etkinleştirilir. Bu ayar, yeni sorgu potansiyel kullanımını sağlar. Bu dahili refactoring ve görünür bir değişiklik beklemiyoruz. Eğer herhangi bir sorun göreceksiniz, sıfır geri ayarlayın. [\#8768](https://github.com/ClickHouse/ClickHouse/pull/8768) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Yenilik {#new-feature} + +- Eklemek `Avro` ve `AvroConfluent` giriş / çıkış biçimleri [\#8571](https://github.com/ClickHouse/ClickHouse/pull/8571) ([Andrew Onyshchuk](https://github.com/oandrew)) [\#8957](https://github.com/ClickHouse/ClickHouse/pull/8957) ([Andrew Onyshchuk](https://github.com/oandrew)) [\#8717](https://github.com/ClickHouse/ClickHouse/pull/8717) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Süresi dolmuş anahtarların çok iş parçacıklı ve engellenmeyen güncellemeleri `cache` sözlükler (eskileri okumak için isteğe bağlı izin ile). [\#8303](https://github.com/ClickHouse/ClickHouse/pull/8303) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Sorgu Ekle `ALTER ... MATERIALIZE TTL`. Süresi dolmuş verileri TTL ile kaldırmaya zorlayan mutasyonu çalıştırır ve TTL ile ilgili meta bilgileri tüm kısımlarda yeniden hesaplar. [\#8775](https://github.com/ClickHouse/ClickHouse/pull/8775) ([Anton Popov](https://github.com/CurtizJ)) +- Gerekirse Hashjoin'den Mergejoin'e (diskte) geçin [\#9082](https://github.com/ClickHouse/ClickHouse/pull/9082) ([Artem Zuikov](https://github.com/4ertus2)) +- Katma `MOVE PARTITION` için komut `ALTER TABLE` [\#4729](https://github.com/ClickHouse/ClickHouse/issues/4729) [\#6168](https://github.com/ClickHouse/ClickHouse/pull/6168) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Anında yapılandırma dosyasından depolama yapılandırmasını yeniden yükleme. [\#8594](https://github.com/ClickHouse/ClickHouse/pull/8594) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Değiştirmek için izin `storage_policy` daha az zengin olana. [\#8107](https://github.com/ClickHouse/ClickHouse/pull/8107) ([Vladimir Chebotarev](https://github.com/excitoon)) +- S3 depolama ve masa fonksiyonu için globs/joker karakterler için destek eklendi. [\#8851](https://github.com/ClickHouse/ClickHouse/pull/8851) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Uygulamak `bitAnd`, `bitOr`, `bitXor`, `bitNot` için `FixedString(N)` datatype. [\#9091](https://github.com/ClickHouse/ClickHouse/pull/9091) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Eklendi fonksiyonu `bitCount`. Bu düzeltmeler [\#8702](https://github.com/ClickHouse/ClickHouse/issues/8702). [\#8708](https://github.com/ClickHouse/ClickHouse/pull/8708) ([alexey-milovidov](https://github.com/alexey-milovidov)) [\#8749](https://github.com/ClickHouse/ClickHouse/pull/8749) ([ıkopylov](https://github.com/ikopylov)) +- Eklemek `generateRandom` verilen şema ile rastgele satırlar oluşturmak için tablo işlevi. Rasgele test tablosunu verilerle doldurmaya izin verir. [\#8994](https://github.com/ClickHouse/ClickHouse/pull/8994) ([Ilya Yatsishin](https://github.com/qoega)) +- `JSONEachRowFormat`: destek özel durumda zaman nesneleri üst düzey dizi içine. [\#8860](https://github.com/ClickHouse/ClickHouse/pull/8860) ([Kruglov Pavel](https://github.com/Avogar)) +- Şimdi bir sütun oluşturmak mümkün `DEFAULT` varsayılan bir sütuna bağlı olan ifade `ALIAS` ifade. [\#9489](https://github.com/ClickHouse/ClickHouse/pull/9489) ([alesapin](https://github.com/alesapin)) +- Belirtmek için izin ver `--limit` kaynak veri boyutundan daha fazla `clickhouse-obfuscator`. Veri farklı rastgele tohum ile kendini tekrar edecektir. [\#9155](https://github.com/ClickHouse/ClickHouse/pull/9155) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Katma `groupArraySample` fonksiyonu (benzer `groupArray`) rezervuar örnekleme algoritması ile. [\#8286](https://github.com/ClickHouse/ClickHouse/pull/8286) ([Amos Kuşu](https://github.com/amosbird)) +- Şimdi güncelleme kuyruğunun boyutunu izleyebilirsiniz `cache`/`complex_key_cache` sistem metrikleri aracılığıyla sözlükler. [\#9413](https://github.com/ClickHouse/ClickHouse/pull/9413) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Crlf'yi CSV çıkış biçiminde bir hat ayırıcı olarak ayarlamaya izin ver `output_format_csv_crlf_end_of_line` 1 set [\#8934](https://github.com/ClickHouse/ClickHouse/pull/8934) [\#8935](https://github.com/ClickHouse/ClickHouse/pull/8935) [\#8963](https://github.com/ClickHouse/ClickHouse/pull/8963) ([Mikhail Korotov](https://github.com/millb)) +- Daha fazla işlev uygulamak [H3](https://github.com/uber/h3) API: `h3GetBaseCell`, `h3HexAreaM2`, `h3IndexesAreNeighbors`, `h3ToChildren`, `h3ToString` ve `stringToH3` [\#8938](https://github.com/ClickHouse/ClickHouse/pull/8938) ([Nico Mandery](https://github.com/nmandery)) +- Yeni ayar tanıt introducedıldı: `max_parser_depth` maksimum yığın boyutunu kontrol etmek ve büyük karmaşık sorgulara izin vermek. Bu düzeltmeler [\#6681](https://github.com/ClickHouse/ClickHouse/issues/6681) ve [\#7668](https://github.com/ClickHouse/ClickHouse/issues/7668). [\#8647](https://github.com/ClickHouse/ClickHouse/pull/8647) ([Maxim Smirnov](https://github.com/qMBQx8GH)) +- Ayar ekleme `force_optimize_skip_unused_shards` kullanılmayan parçaların atlanması mümkün değilse atma ayarı [\#8805](https://github.com/ClickHouse/ClickHouse/pull/8805) ([Azat Khuzhin](https://github.com/azat)) +- Göndermek için veri depolamak için birden fazla Disk/birim yapılandırmaya izin ver `Distributed` motor [\#8756](https://github.com/ClickHouse/ClickHouse/pull/8756) ([Azat Khuzhin](https://github.com/azat)) +- Destek depolama politikası (``) geçici veri depolamak için. [\#8750](https://github.com/ClickHouse/ClickHouse/pull/8750) ([Azat Khuzhin](https://github.com/azat)) +- Katma `X-ClickHouse-Exception-Code` Özel durum veri göndermeden önce atıldı, ayarlanmış http üstbilgisi. Bu uygular [\#4971](https://github.com/ClickHouse/ClickHouse/issues/4971). [\#8786](https://github.com/ClickHouse/ClickHouse/pull/8786) ([Mikhail Korotov](https://github.com/millb)) +- Eklendi fonksiyonu `ifNotFinite`. Bu sadece sözdizimsel bir şeker: `ifNotFinite(x, y) = isFinite(x) ? x : y`. [\#8710](https://github.com/ClickHouse/ClickHouse/pull/8710) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Katma `last_successful_update_time` sütun içinde `system.dictionaries` Tablo [\#9394](https://github.com/ClickHouse/ClickHouse/pull/9394) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Eklemek `blockSerializedSize` işlev (sıkıştırma olmadan diskte boyut) [\#8952](https://github.com/ClickHouse/ClickHouse/pull/8952) ([Azat Khuzhin](https://github.com/azat)) +- Fonksiyon Ekle `moduloOrZero` [\#9358](https://github.com/ClickHouse/ClickHouse/pull/9358) ([hcz](https://github.com/hczhcz)) +- Eklenen sistem tabloları `system.zeros` ve `system.zeros_mt` yanı sıra masal fonksiyonları `zeros()` ve `zeros_mt()`. Tablolar (ve tablo işlevleri) adı ile tek sütun içerir `zero` ve tip `UInt8`. Bu sütun sıfır içerir. Birçok satır oluşturmak için en hızlı yöntem olarak test amaçları için gereklidir. Bu düzeltmeler [\#6604](https://github.com/ClickHouse/ClickHouse/issues/6604) [\#9593](https://github.com/ClickHouse/ClickHouse/pull/9593) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) + +#### Deneysel Özellik {#experimental-feature} + +- Yeni kompakt parça formatı ekleyin `MergeTree`- tüm sütunların tek bir dosyada saklandığı aile tabloları. Küçük ve sık insertlerin performansını artırmaya yardımcı olur. Eski biçim (sütun başına bir dosya) şimdi geniş olarak adlandırılır. Veri depolama biçimi ayarları tarafından kontrol edilir `min_bytes_for_wide_part` ve `min_rows_for_wide_part`. [\#8290](https://github.com/ClickHouse/ClickHouse/pull/8290) ([Anton Popov](https://github.com/CurtizJ)) +- S3 depolama için destek `Log`, `TinyLog` ve `StripeLog` Tablolar. [\#8862](https://github.com/ClickHouse/ClickHouse/pull/8862) ([Pavel Kovalenko](https://github.com/Jokser)) + +#### Hata Düzeltme {#bug-fix-2} + +- Günlük mesajlarında sabit tutarsız whitespaces. [\#9322](https://github.com/ClickHouse/ClickHouse/pull/9322) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İsimsiz dizilerin dizilerinin tablo oluşturulmasında iç içe geçmiş yapılar olarak düzleştirildiği hatayı düzeltin. [\#8866](https://github.com/ClickHouse/ClickHouse/pull/8866) ([achulkov2](https://github.com/achulkov2)) +- Sorunu ne zaman düzeltildi “Too many open files” glob deseniyle eşleşen çok fazla dosya varsa hata oluşabilir `File` tablo veya `file` tablo işlevi. Şimdi dosyalar tembel açılır. Bu düzeltmeler [\#8857](https://github.com/ClickHouse/ClickHouse/issues/8857) [\#8861](https://github.com/ClickHouse/ClickHouse/pull/8861) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bırak geçici tablo şimdi sadece geçici tablo düşer. [\#8907](https://github.com/ClickHouse/ClickHouse/pull/8907) ([Vitaly Baranov](https://github.com/vitlibar)) +- Sunucuyu kapattığımızda veya bir tabloyu AYIRDIĞIMIZDA/EKLEDİĞİMİZDE eski bölümü kaldırın. [\#8602](https://github.com/ClickHouse/ClickHouse/pull/8602) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Varsayılan diskin boş alanı nasıl hesapladığı için `data` dizin. Boş alan miktarı doğru hesaplanmazsa sorunu düzeltildi `data` dizin ayrı bir cihaza monte edilir (nadir durum). Bu düzeltmeler [\#7441](https://github.com/ClickHouse/ClickHouse/issues/7441) [\#9257](https://github.com/ClickHouse/ClickHouse/pull/9257) ([Mikhail Korotov](https://github.com/millb)) +- In () ınside ile virgül (çapraz) birleşmesine izin ver. [\#9251](https://github.com/ClickHouse/ClickHouse/pull/9251) ([Artem Zuikov](https://github.com/4ertus2)) +- WHERE bölümünde operatör gibi \[değil\] varsa, iç BİRLEŞİME çapraz yeniden yazmaya izin verin. [\#9229](https://github.com/ClickHouse/ClickHouse/pull/9229) ([Artem Zuikov](https://github.com/4ertus2)) +- Sonra olası yanlış sonucu düzeltin `GROUP BY` etkin ayarı ile `distributed_aggregation_memory_efficient`. Düzeltiyor [\#9134](https://github.com/ClickHouse/ClickHouse/issues/9134). [\#9289](https://github.com/ClickHouse/ClickHouse/pull/9289) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Bulunan anahtarlar önbellek sözlüklerinin metriklerinde cevapsız olarak sayıldı. [\#9411](https://github.com/ClickHouse/ClickHouse/pull/9411) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Çoğaltma protokolü uyumsuzluğunu düzeltme [\#8598](https://github.com/ClickHouse/ClickHouse/issues/8598). [\#9412](https://github.com/ClickHouse/ClickHouse/pull/9412) ([alesapin](https://github.com/alesapin)) +- Sabit yarış durumu `queue_task_handle` başlangıçta `ReplicatedMergeTree` Tablolar. [\#9552](https://github.com/ClickHouse/ClickHouse/pull/9552) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Belirteç `NOT` işe yar inamadı `SHOW TABLES NOT LIKE` sorgu [\#8727](https://github.com/ClickHouse/ClickHouse/issues/8727) [\#8940](https://github.com/ClickHouse/ClickHouse/pull/8940) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Fonksiyona Aralık kontrolü eklendi `h3EdgeLengthM`. Bu kontrol olmadan, arabellek taşması mümkündür. [\#8945](https://github.com/ClickHouse/ClickHouse/pull/8945) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Birden argümanlar (10'dan fazla) üçlü mantıksal OPs toplu hesaplamalarda bir hata düzeltildi. [\#8718](https://github.com/ClickHouse/ClickHouse/pull/8718) ([Alexander Kazakov](https://github.com/Akazz)) +- Segfaults'a yol açabilecek prewhere optimizasyonunun hatasını düzeltin veya `Inconsistent number of columns got from MergeTreeRangeReader` özel. [\#9024](https://github.com/ClickHouse/ClickHouse/pull/9024) ([Anton Popov](https://github.com/CurtizJ)) +- Beklenmeyen düzeltme `Timeout exceeded while reading from socket` zaman aşımı gerçekten aşıldı ve sorgu profiler etkinleştirildiğinde önce güvenli bağlantıda rasgele olur özel durum. Ayrıca ekleyin `connect_timeout_with_failover_secure_ms` ayarlar (varsayılan 100 MS), hangi benzer `connect_timeout_with_failover_ms`, ancak güvenli bağlantılar için kullanılır (çünkü SSL el sıkışması normal TCP bağlantısından daha yavaştır) [\#9026](https://github.com/ClickHouse/ClickHouse/pull/9026) ([tavplubix](https://github.com/tavplubix)) +- Mutasyon ile devlet asmak olabilir mutasyonlar sonuçlandırılması ile Fix hata `parts_to_do=0` ve `is_done=0`. [\#9022](https://github.com/ClickHouse/ClickHouse/pull/9022) ([alesapin](https://github.com/alesapin)) +- İle Yeni herhangi bir birleştirme mantığı kullanın `partial_merge_join` ayar. Yapmak mümkün `ANY|ALL|SEMI LEFT` ve `ALL INNER` ile birleş joinsir `partial_merge_join=1` şimdi. [\#8932](https://github.com/ClickHouse/ClickHouse/pull/8932) ([Artem Zuikov](https://github.com/4ertus2)) +- Shard şimdi bir istisna atmak yerine başlatıcıdan gelen ayarları shard'ın constaintlerine sıkıştırıyor. Bu düzeltme, başka bir kısıtlamalarla bir parçaya sorgular göndermeye izin verir. [\#9447](https://github.com/ClickHouse/ClickHouse/pull/9447) ([Vitaly Baranov](https://github.com/vitlibar)) +- Sabit bellek yönetimi sorunu `MergeTreeReadPool`. [\#8791](https://github.com/ClickHouse/ClickHouse/pull/8791) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Düzeltmek `toDecimal*OrNull()` dize ile çağrıldığında işlevler ailesi `e`. Düzeltiyor [\#8312](https://github.com/ClickHouse/ClickHouse/issues/8312) [\#8764](https://github.com/ClickHouse/ClickHouse/pull/8764) ([Artem Zuikov](https://github.com/4ertus2)) +- Emin olun `FORMAT Null` istemciye hiçbir veri gönderir. [\#8767](https://github.com/ClickHouse/ClickHouse/pull/8767) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Bu zaman damgasını düzeltin `LiveViewBlockInputStream` güncellenmeyecek. `LIVE VIEW` deneysel bir özelliktir. [\#8644](https://github.com/ClickHouse/ClickHouse/pull/8644) ([vxider](https://github.com/Vxider)) [\#8625](https://github.com/ClickHouse/ClickHouse/pull/8625) ([vxider](https://github.com/Vxider)) +- Sabit `ALTER MODIFY TTL` eski TTL ifadelerini silmeye izin vermeyen yanlış davranış. [\#8422](https://github.com/ClickHouse/ClickHouse/pull/8422) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Mergetreeındexset sabit UBSan raporu. Bu düzeltmeler [\#9250](https://github.com/ClickHouse/ClickHouse/issues/9250) [\#9365](https://github.com/ClickHouse/ClickHouse/pull/9365) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Davranışı Düzelt theildi `match` ve `extract` haystack sıfır bayt olduğunda işlevler. Haystack sabit olduğunda davranış yanlıştı. Bu düzeltmeler [\#9160](https://github.com/ClickHouse/ClickHouse/issues/9160) [\#9163](https://github.com/ClickHouse/ClickHouse/pull/9163) ([alexey-milovidov](https://github.com/alexey-milovidov)) [\#9345](https://github.com/ClickHouse/ClickHouse/pull/9345) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Apache Avro 3. parti kütüphanesinde yıkıcıdan atmaktan kaçının. [\#9066](https://github.com/ClickHouse/ClickHouse/pull/9066) ([Andrew Onyshchuk](https://github.com/oandrew)) +- Bir toplu işlem yoklama `Kafka` kısmen verilerde deliklere yol açabilir. [\#8876](https://github.com/ClickHouse/ClickHouse/pull/8876) ([filimonov](https://github.com/filimonov)) +- Düzeltmek `joinGet` null dönüş türleri ile. https://github.com/ClickHouse/ClickHouse/issues/8919 [\#9014](https://github.com/ClickHouse/ClickHouse/pull/9014) ([Amos Kuşu](https://github.com/amosbird)) +- Sıkıştırıldığında veri uyumsuzluğunu düzeltin `T64` codec. [\#9016](https://github.com/ClickHouse/ClickHouse/pull/9016) ([Artem Zuikov](https://github.com/4ertus2)) Veri türü kimliklerini düzeltin `T64` etkilenen sürümlerde yanlış (de)sıkıştırmaya yol açan sıkıştırma codec bileşeni. [\#9033](https://github.com/ClickHouse/ClickHouse/pull/9033) ([Artem Zuikov](https://github.com/4ertus2)) +- Ayar Ekle `enable_early_constant_folding` ve hatalara yol açan bazı durumlarda devre dışı bırakın. [\#9010](https://github.com/ClickHouse/ClickHouse/pull/9010) ([Artem Zuikov](https://github.com/4ertus2)) +- Pushdown predicate optimizer'ı görünümle düzeltin ve Testi etkinleştirin [\#9011](https://github.com/ClickHouse/ClickHouse/pull/9011) ([Kış Zhang](https://github.com/zhang2014)) +- Segfault'u düzeltin `Merge` tablo readinglardan, okuma sırasında meydana gelebilecek `File` depolamalar [\#9387](https://github.com/ClickHouse/ClickHouse/pull/9387) ([tavplubix](https://github.com/tavplubix)) +- Depolama politikası için bir kontrol eklendi `ATTACH PARTITION FROM`, `REPLACE PARTITION`, `MOVE TO TABLE`. Aksi takdirde, yeniden başlatıldıktan sonra parçanın verilerini erişilemez hale getirebilir ve Clickhouse'un başlatılmasını önleyebilir. [\#9383](https://github.com/ClickHouse/ClickHouse/pull/9383) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Tablo için ayarlanmış TTL varsa, değişiklikleri düzeltin. [\#8800](https://github.com/ClickHouse/ClickHouse/pull/8800) ([Anton Popov](https://github.com/CurtizJ)) +- Ne zaman gerçekleşebilecek yarış durumunu düzeltin `SYSTEM RELOAD ALL DICTIONARIES` bazı sözlük değiştirilirken/eklenirken/kaldırılırken yürütülür. [\#8801](https://github.com/ClickHouse/ClickHouse/pull/8801) ([Vitaly Baranov](https://github.com/vitlibar)) +- Önceki sürümlerde `Memory` Veritabanı Altyapısı boş veri yolu kullanır, böylece tablolar `path` directory (e.g. `/var/lib/clickhouse/`), not in data directory of database (e.g. `/var/lib/clickhouse/db_name`). [\#8753](https://github.com/ClickHouse/ClickHouse/pull/8753) ([tavplubix](https://github.com/tavplubix)) +- Varsayılan disk veya ilke eksik hakkında sabit yanlış günlük mesajları. [\#9530](https://github.com/ClickHouse/ClickHouse/pull/9530) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Dizi türlerinin bloom\_filter dizini için değil(has()) düzeltin. [\#9407](https://github.com/ClickHouse/ClickHouse/pull/9407) ([achimbab](https://github.com/achimbab)) +- Bir tablodaki ilk sütunlara izin ver `Log` motor takma isim ol [\#9231](https://github.com/ClickHouse/ClickHouse/pull/9231) ([I ivanvan](https://github.com/abyss7)) +- Okurken aralıkların sırasını düzeltin `MergeTree` bir iş parçacığı tablo. İstisn fromalara yol açabilir `MergeTreeRangeReader` veya yanlış sorgu sonuçları. [\#9050](https://github.com/ClickHouse/ClickHouse/pull/9050) ([Anton Popov](https://github.com/CurtizJ)) +- Yapmak `reinterpretAsFixedString` dönmek `FixedString` yerine `String`. [\#9052](https://github.com/ClickHouse/ClickHouse/pull/9052) ([Andrew Onyshchuk](https://github.com/oandrew)) +- Kullanıcı yanlış hata mesajı alabildiğinde son derece nadir durumlardan kaçının (`Success` ayrıntılı hata açıklaması yerine). [\#9457](https://github.com/ClickHouse/ClickHouse/pull/9457) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kullanırken çökmesine etmeyin `Template` boş satır şablonu ile biçimlendirin. [\#8785](https://github.com/ClickHouse/ClickHouse/pull/8785) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Sistem tabloları için meta veri dosyaları yanlış yerde oluşturulabilir [\#8653](https://github.com/ClickHouse/ClickHouse/pull/8653) ([tavplubix](https://github.com/tavplubix)) Düzeltiyor [\#8581](https://github.com/ClickHouse/ClickHouse/issues/8581). +- Önbellek sözlüğünde exception\_ptr üzerindeki veri yarışını düzeltin [\#8303](https://github.com/ClickHouse/ClickHouse/issues/8303). [\#9379](https://github.com/ClickHouse/ClickHouse/pull/9379) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Sorgu için bir özel durum atmayın `ATTACH TABLE IF NOT EXISTS`. Daha önce tablo zaten varsa atıldı, buna rağmen `IF NOT EXISTS` yan. [\#8967](https://github.com/ClickHouse/ClickHouse/pull/8967) ([Anton Popov](https://github.com/CurtizJ)) +- Özel durum mesajında eksik kapanış paren düzeltildi. [\#8811](https://github.com/ClickHouse/ClickHouse/pull/8811) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Mesajdan kaçının `Possible deadlock avoided` etkileşimli modda clickhouse-client başlangıcında. [\#9455](https://github.com/ClickHouse/ClickHouse/pull/9455) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Base64 kodlanmış değerin sonunda dolgu hatalı biçimlendirilmiş olabilir sorunu düzeltildi. Base64 kütüphanesini güncelleyin. Bu düzeltmeler [\#9491](https://github.com/ClickHouse/ClickHouse/issues/9491), yaklar [\#9492](https://github.com/ClickHouse/ClickHouse/issues/9492) [\#9500](https://github.com/ClickHouse/ClickHouse/pull/9500) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Veri kaybını önlemek `Kafka` nadir durumlarda istisna sonek okuduktan sonra ancak taahhütten önce gerçekleşir. Düzeltiyor [\#9378](https://github.com/ClickHouse/ClickHouse/issues/9378) [\#9507](https://github.com/ClickHouse/ClickHouse/pull/9507) ([filimonov](https://github.com/filimonov)) +- Sabit istisna `DROP TABLE IF EXISTS` [\#8663](https://github.com/ClickHouse/ClickHouse/pull/8663) ([Nikita Vasilev](https://github.com/nikvas0)) +- Bir kullanıcı denediğinde çökmeyi düzeltin `ALTER MODIFY SETTING` eski formatlı için `MergeTree` masa motorları ailesi. [\#9435](https://github.com/ClickHouse/ClickHouse/pull/9435) ([alesapin](https://github.com/alesapin)) +- Json ile ilgili işlevlerde Int64'e uymayan Uİnt64 numaraları için destek. Master simdjson güncelleyin. Bu düzeltmeler [\#9209](https://github.com/ClickHouse/ClickHouse/issues/9209) [\#9344](https://github.com/ClickHouse/ClickHouse/pull/9344) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kesinlikle monotinik olmayan fonksiyonel indeks kullanıldığında ters yüklemlerin sabit yürütülmesi. [\#9223](https://github.com/ClickHouse/ClickHouse/pull/9223) ([Alexander Kazakov](https://github.com/Akazz)) +- Kat trylamaya çalış trymayın `IN` sabit in `GROUP BY` [\#8868](https://github.com/ClickHouse/ClickHouse/pull/8868) ([Amos Kuşu](https://github.com/amosbird)) +- Hatayı düzeltin `ALTER DELETE` endeks bozulmasına yol açan mutasyonlar. Bu düzeltmeler [\#9019](https://github.com/ClickHouse/ClickHouse/issues/9019) ve [\#8982](https://github.com/ClickHouse/ClickHouse/issues/8982). Ayrıca son derece nadir yarış koşullarını düzeltin `ReplicatedMergeTree` `ALTER` sorgular. [\#9048](https://github.com/ClickHouse/ClickHouse/pull/9048) ([alesapin](https://github.com/alesapin)) +- Zaman ayarı `compile_expressions` etkin mi, alabilirsiniz `unexpected column` içinde `LLVMExecutableFunction` kullan whendığımızda `Nullable` tür [\#8910](https://github.com/ClickHouse/ClickHouse/pull/8910) ([Guillaume Tassery](https://github.com/YiuRULE)) +- İçin çoklu düzeltmeler `Kafka` motor: 1) tüketici grubu rebalance sırasında görünen çiftleri düzeltin. 2) nadir düzeltmek ‘holes’ veriler bir anket ile birkaç bölümden yoklandığında ve kısmen işlendiğinde ortaya çıktı (şimdi her zaman tüm anketli mesaj bloğunu işliyoruz / işliyoruz). 3) blok boyutuna göre yıkamaları düzeltin (bundan önce sadece zaman aşımı ile kızarma düzgün çalışıyordu). 4) daha iyi abonelik prosedürü (atama geri bildirimi ile). 5) testlerin daha hızlı çalışmasını sağlayın (varsayılan aralıklarla ve zaman aşımlarıyla). Verilerin daha önce blok boyutuna göre temizlenmemesi nedeniyle (belgelere göre olması gerektiği gibi), bu PR, varsayılan ayarlarla bazı performans düşüşlerine yol açabilir(daha sık ve daha az optimal olan daha küçük yıkama nedeniyle). Bu değişiklikten sonra performans sorunuyla karşılaşırsanız-lütfen artırın `kafka_max_block_size` tabloda daha büyük değere (örneğin `CREATE TABLE ...Engine=Kafka ... SETTINGS ... kafka_max_block_size=524288`). Düzeltiyor [\#7259](https://github.com/ClickHouse/ClickHouse/issues/7259) [\#8917](https://github.com/ClickHouse/ClickHouse/pull/8917) ([filimonov](https://github.com/filimonov)) +- Düzeltmek `Parameter out of bound` prewhere optimizasyonlarından sonra bazı sorgularda istisna. [\#8914](https://github.com/ClickHouse/ClickHouse/pull/8914) ([Baudouin Giard](https://github.com/bgiard)) +- Fonksiyon argümanlarının karışık sabitliği durumu düzeltildi `arrayZip`. [\#8705](https://github.com/ClickHouse/ClickHouse/pull/8705) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yürüt whenürken `CREATE` sorgu, depolama motoru argümanlarında sabit ifadeleri katlayın. Boş veritabanı adı geçerli veritabanı ile değiştirin. Düzeltiyor [\#6508](https://github.com/ClickHouse/ClickHouse/issues/6508), [\#3492](https://github.com/ClickHouse/ClickHouse/issues/3492) [\#9262](https://github.com/ClickHouse/ClickHouse/pull/9262) ([tavplubix](https://github.com/tavplubix)) +- Artık basit döngüsel takma adlarla sütunlar oluşturmak veya eklemek mümkün değil `a DEFAULT b, b DEFAULT a`. [\#9603](https://github.com/ClickHouse/ClickHouse/pull/9603) ([alesapin](https://github.com/alesapin)) +- Bozuk orijinal parçası olabilir çift hareket ile bir hata düzeltildi. Eğer kullanıyorsanız bu önemlidir `ALTER TABLE MOVE` [\#8680](https://github.com/ClickHouse/ClickHouse/pull/8680) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Vermek `interval` backticks olmadan doğru ayrıştırmak için tanımlayıcı. Bir sorgu bile yürütülemez sabit sorun `interval` tanımlayıcı backticks veya çift tırnak içine alınır. Bu düzeltmeler [\#9124](https://github.com/ClickHouse/ClickHouse/issues/9124). [\#9142](https://github.com/ClickHouse/ClickHouse/pull/9142) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit fuzz testi ve yanlış davranış `bitTestAll`/`bitTestAny` işlevler. [\#9143](https://github.com/ClickHouse/ClickHouse/pull/9143) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Olası kilitlenme/yanlış satır sayısını düzeltin `LIMIT n WITH TIES` n'th satırına eşit çok sayıda satır olduğunda. [\#9464](https://github.com/ClickHouse/ClickHouse/pull/9464) ([tavplubix](https://github.com/tavplubix)) +- Enabled ile yazılmış parçalarla mutasyonları düzeltin `insert_quorum`. [\#9463](https://github.com/ClickHouse/ClickHouse/pull/9463) ([alesapin](https://github.com/alesapin)) +- İmha veri yarışı Fix `Poco::HTTPServer`. Sunucu başlatıldığında ve hemen kapatıldığında gerçekleşebilir. [\#9468](https://github.com/ClickHouse/ClickHouse/pull/9468) ([Anton Popov](https://github.com/CurtizJ)) +- Çalışırken yanıltıcı bir hata mesajının gösterildiği hatayı düzeltin `SHOW CREATE TABLE a_table_that_does_not_exist`. [\#8899](https://github.com/ClickHouse/ClickHouse/pull/8899) ([achulkov2](https://github.com/achulkov2)) +- Sabit `Parameters are out of bound` bazı nadir durumlarda istisna `SELECT` CLA anuse when we have an `ORDER BY` ve bir `LIMIT` yan. [\#8892](https://github.com/ClickHouse/ClickHouse/pull/8892) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Mutasyonlar kesinleşmesini düzeltin, zaten mutasyon yapıldığında durum olabilir `is_done=0`. [\#9217](https://github.com/ClickHouse/ClickHouse/pull/9217) ([alesapin](https://github.com/alesapin)) +- Yürütül executingmesini engellemek `ALTER ADD INDEX` eski sözdizimi ile MergeTree tabloları için, çünkü çalışmıyor. [\#8822](https://github.com/ClickHouse/ClickHouse/pull/8822) ([Mikhail Korotov](https://github.com/millb)) +- Sunucu başlatma sırasında erişim tablosu, hangi `LIVE VIEW` bağlıdır, böylece sunucu başlatmak mümkün olacak. Ayrıca kaldırmak `LIVE VIEW` ayırma sırasında bağımlılıklar `LIVE VIEW`. `LIVE VIEW` deneysel bir özelliktir. [\#8824](https://github.com/ClickHouse/ClickHouse/pull/8824) ([tavplubix](https://github.com/tavplubix)) +- Olası segfault'u düzeltin `MergeTreeRangeReader`, Yürüt whileürken `PREWHERE`. [\#9106](https://github.com/ClickHouse/ClickHouse/pull/9106) ([Anton Popov](https://github.com/CurtizJ)) +- Sütun TTLs ile olası eşleşmeyen sağlama toplamlarını düzeltin. [\#9451](https://github.com/ClickHouse/ClickHouse/pull/9451) ([Anton Popov](https://github.com/CurtizJ)) +- Sadece bir birim olduğunda parçalar durumunda TTL kurallarına göre arka planda taşınmadığında bir hata düzeltildi. [\#8672](https://github.com/ClickHouse/ClickHouse/pull/8672) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Sorunu düzelt fixedildi `Method createColumn() is not implemented for data type Set`. Bu düzeltmeler [\#7799](https://github.com/ClickHouse/ClickHouse/issues/7799). [\#8674](https://github.com/ClickHouse/ClickHouse/pull/8674) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Şimdi mutasyonları daha sık sonuçlandırmaya çalışacağız. [\#9427](https://github.com/ClickHouse/ClickHouse/pull/9427) ([alesapin](https://github.com/alesapin)) +- Düzeltmek `intDiv` eksi bir sabit tarafından [\#9351](https://github.com/ClickHouse/ClickHouse/pull/9351) ([hcz](https://github.com/hczhcz)) +- Olası yarış durumunu düzeltin `BlockIO`. [\#9356](https://github.com/ClickHouse/ClickHouse/pull/9356) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Kullanmaya / bırakmaya çalışırken sunucu sonlandırmasına giden hatayı düzeltin `Kafka` tablo yanlış parametrelerle oluşturuldu. [\#9513](https://github.com/ClickHouse/ClickHouse/pull/9513) ([filimonov](https://github.com/filimonov)) +- OS için yanlış sonuç döndürürse geçici çözüm eklendi `timer_create` işlev. [\#8837](https://github.com/ClickHouse/ClickHouse/pull/8837) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kullanımında Sabit hata `min_marks_for_seek` parametre. Dağıtılmış tabloda sharding anahtarı olmadığında hata mesajı düzeltildi ve kullanılmayan parçaları atlamaya çalışıyoruz. [\#8908](https://github.com/ClickHouse/ClickHouse/pull/8908) ([Azat Khuzhin](https://github.com/azat)) + +#### Geliştirme {#improvement} + +- Uygulamak `ALTER MODIFY/DROP` için Mut topasyon topların üstüne sorgular `ReplicatedMergeTree*` motorlar ailesi. Şimdi `ALTERS` yalnızca meta veri güncelleme aşamasında engeller ve bundan sonra engellemez. [\#8701](https://github.com/ClickHouse/ClickHouse/pull/8701) ([alesapin](https://github.com/alesapin)) +- İle iç Birleşimlere çapraz yeniden yazma yeteneği ekleyin `WHERE` unqialified adları içeren bölüm. [\#9512](https://github.com/ClickHouse/ClickHouse/pull/9512) ([Artem Zuikov](https://github.com/4ertus2)) +- Yapmak `SHOW TABLES` ve `SHOW DATABASES` sorgular destek `WHERE` ifadeler ve `FROM`/`IN` [\#9076](https://github.com/ClickHouse/ClickHouse/pull/9076) ([sundyli](https://github.com/sundy-li)) +- Bir ayar eklendi `deduplicate_blocks_in_dependent_materialized_views`. [\#9070](https://github.com/ClickHouse/ClickHouse/pull/9070) ([urykhy](https://github.com/urykhy)) +- Son değişikliklerden sonra MySQL istemcisi onaltılık ikili dizeleri yazdırmaya başladı ve böylece onları okunabilir hale getirdi ([\#9032](https://github.com/ClickHouse/ClickHouse/issues/9032)). Clickhouse'daki geçici çözüm, dize sütunlarını her zaman değil, genellikle durum olan UTF-8 olarak işaretlemektir. [\#9079](https://github.com/ClickHouse/ClickHouse/pull/9079) ([Yuriy Baranov](https://github.com/yurriy)) +- İçin dize ve FixedString tuşları desteği ekleyin `sumMap` [\#8903](https://github.com/ClickHouse/ClickHouse/pull/8903) ([Baudouin Giard](https://github.com/bgiard)) +- SummingMergeTree haritalarında dize anahtarlarını destekleyin [\#8933](https://github.com/ClickHouse/ClickHouse/pull/8933) ([Baudouin Giard](https://github.com/bgiard)) +- İş parçacığı özel durum atılmış olsa bile iş parçacığı havuzu için iş parçacığı sonlandırma sinyali [\#8736](https://github.com/ClickHouse/ClickHouse/pull/8736) ([Ding Xiang Fei](https://github.com/dingxiangfei2009)) +- Ayarlamak için izin ver `query_id` içinde `clickhouse-benchmark` [\#9416](https://github.com/ClickHouse/ClickHouse/pull/9416) ([Anton Popov](https://github.com/CurtizJ)) +- Garip ifadelere izin verme `ALTER TABLE ... PARTITION partition` sorgu. Bu adresler [\#7192](https://github.com/ClickHouse/ClickHouse/issues/7192) [\#8835](https://github.com/ClickHouse/ClickHouse/pull/8835) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tablo `system.table_engines` şimdi özellik desteği (gibi) hakkında bilgi sağlar `supports_ttl` veya `supports_sort_order`). [\#8830](https://github.com/ClickHouse/ClickHouse/pull/8830) ([Max Akhmedov](https://github.com/zlobober)) +- Etkinleştirmek `system.metric_log` varsayılan olarak. ProfileEvents, CurrentMetrics değerleri ile toplanan satırları içerecektir “collect\_interval\_milliseconds” aralığı (varsayılan olarak bir saniye). Tablo çok küçüktür (genellikle megabayt sırasına göre) ve bu verileri varsayılan olarak toplamak mantıklıdır. [\#9225](https://github.com/ClickHouse/ClickHouse/pull/9225) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Initialize query profiler for all threads in a group, e.g. it allows to fully profile insert-queries. Fixes [\#6964](https://github.com/ClickHouse/ClickHouse/issues/6964) [\#8874](https://github.com/ClickHouse/ClickHouse/pull/8874) ([I ivanvan](https://github.com/abyss7)) +- Şimdi geçici `LIVE VIEW` tarafından oluşturulur `CREATE LIVE VIEW name WITH TIMEOUT [42] ...` yerine `CREATE TEMPORARY LIVE VIEW ...`, önceki sözdizimi ile tutarlı olmadığı için `CREATE TEMPORARY TABLE ...` [\#9131](https://github.com/ClickHouse/ClickHouse/pull/9131) ([tavplubix](https://github.com/tavplubix)) +- Text\_log ekleyin.giden girişleri sınırlamak için seviye yapılandırma parametresi `system.text_log` Tablo [\#8809](https://github.com/ClickHouse/ClickHouse/pull/8809) ([Azat Khuzhin](https://github.com/azat)) +- İndir partdiğiniz parçayı TTL kurallarına göre disk /lere/birim putlere koy allowmaya izin verin [\#8598](https://github.com/ClickHouse/ClickHouse/pull/8598) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Harici MySQL sözlükleri için, MySQL bağlantı havuzunun mutualize edilmesine izin verin “share” sözlükler arasında. Bu seçenek, MySQL sunucularına bağlantı sayısını önemli ölçüde azaltır. [\#9409](https://github.com/ClickHouse/ClickHouse/pull/9409) ([Clément Rodriguez](https://github.com/clemrodriguez)) +- Quantiles için en yakın sorgu yürütme süresini göster `clickhouse-benchmark` enterpolasyonlu değerler yerine çıktı. Bazı sorguların yürütme süresine karşılık gelen değerleri göstermek daha iyidir. [\#8712](https://github.com/ClickHouse/ClickHouse/pull/8712) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kafka'ya veri eklerken mesaj için anahtar ve zaman damgası ekleme imkanı. Düzeltiyor [\#7198](https://github.com/ClickHouse/ClickHouse/issues/7198) [\#8969](https://github.com/ClickHouse/ClickHouse/pull/8969) ([filimonov](https://github.com/filimonov)) +- Sunucu terminalden çalıştırılırsa, iş parçacığı numarası, sorgu kimliği ve günlük önceliğini renklere göre vurgulayın. Bu, geliştiriciler için ilişkili günlük iletilerinin daha iyi okunabilirliği içindir. [\#8961](https://github.com/ClickHouse/ClickHouse/pull/8961) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tablolar yüklenirken daha iyi istisna mesajı `Ordinary` veritabanı. [\#9527](https://github.com/ClickHouse/ClickHouse/pull/9527) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Uygulamak `arraySlice` toplama işlev durumları olan diziler için. Bu düzeltmeler [\#9388](https://github.com/ClickHouse/ClickHouse/issues/9388) [\#9391](https://github.com/ClickHouse/ClickHouse/pull/9391) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- In operatörünün sağ tarafında sabit işlevlerin ve sabit dizilerin kullanılmasına izin verin. [\#8813](https://github.com/ClickHouse/ClickHouse/pull/8813) ([Anton Popov](https://github.com/CurtizJ)) +- Sistem için veri getirilirken zookeeper istisnası olduysa.yinelemeler, ayrı bir sütunda görüntüler. Bu uygular [\#9137](https://github.com/ClickHouse/ClickHouse/issues/9137) [\#9138](https://github.com/ClickHouse/ClickHouse/pull/9138) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Atomically kaldırmak mergetree veri parçaları üzerinde yok. [\#8402](https://github.com/ClickHouse/ClickHouse/pull/8402) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Dağıtılmış tablolar için satır düzeyinde güvenliği destekleyin. [\#8926](https://github.com/ClickHouse/ClickHouse/pull/8926) ([I ivanvan](https://github.com/abyss7)) +- Now we recognize suffix (like KB, KiB…) in settings values. [\#8072](https://github.com/ClickHouse/ClickHouse/pull/8072) ([Mikhail Korotov](https://github.com/millb)) +- Büyük bir birleştirme sonucu oluştururken bellek yetersizliğini önleyin. [\#8637](https://github.com/ClickHouse/ClickHouse/pull/8637) ([Artem Zuikov](https://github.com/4ertus2)) +- Etkileşimli modda önerilere kümelerin isimleri eklendi `clickhouse-client`. [\#8709](https://github.com/ClickHouse/ClickHouse/pull/8709) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Initialize query profiler for all threads in a group, e.g. it allows to fully profile insert-queries [\#8820](https://github.com/ClickHouse/ClickHouse/pull/8820) ([I ivanvan](https://github.com/abyss7)) +- Eklenen sütun `exception_code` içinde `system.query_log` Tablo. [\#8770](https://github.com/ClickHouse/ClickHouse/pull/8770) ([Mikhail Korotov](https://github.com/millb)) +- Bağlantı noktasında etkin MySQL uyumluluk sunucusu `9004` varsayılan sunucu yapılandırma dosyasında. Yapılandırmada örnekte sabit şifre oluşturma komutu. [\#8771](https://github.com/ClickHouse/ClickHouse/pull/8771) ([Yuriy Baranov](https://github.com/yurriy)) +- Dosya sistemi readonly ise kapatma üzerinde iptal önleyin. Bu düzeltmeler [\#9094](https://github.com/ClickHouse/ClickHouse/issues/9094) [\#9100](https://github.com/ClickHouse/ClickHouse/pull/9100) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- HTTP POST sorgusunda uzunluk gerektiğinde daha iyi özel durum iletisi. [\#9453](https://github.com/ClickHouse/ClickHouse/pull/9453) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Eklemek `_path` ve `_file` sanal sütunlar için `HDFS` ve `File` motorlar ve `hdfs` ve `file` tablo fonksiyonları [\#8489](https://github.com/ClickHouse/ClickHouse/pull/8489) ([Olga Khvostikova](https://github.com/stavrolia)) +- Hatayı Düzelt `Cannot find column` içine takarken `MATERIALIZED VIEW` durumda yeni sütun view'ın iç tabloya eklendi eğer. [\#8766](https://github.com/ClickHouse/ClickHouse/pull/8766) [\#8788](https://github.com/ClickHouse/ClickHouse/pull/8788) ([vzakaznikov](https://github.com/vzakaznikov)) [\#8788](https://github.com/ClickHouse/ClickHouse/issues/8788) [\#8806](https://github.com/ClickHouse/ClickHouse/pull/8806) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) [\#8803](https://github.com/ClickHouse/ClickHouse/pull/8803) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Son güncellemeden sonra ilerleme göndererek (günlük gibi) yerel istemci-sunucu protokolü üzerinden ilerlemeyi düzeltin. Bu, yalnızca yerel protokolü kullanan bazı üçüncü taraf araçlarla ilgili olabilir. [\#9495](https://github.com/ClickHouse/ClickHouse/pull/9495) ([Azat Khuzhin](https://github.com/azat)) +- MySQL protokolünü kullanarak istemci bağlantılarının sayısını izleyen bir sistem metriği ekleyin ([\#9013](https://github.com/ClickHouse/ClickHouse/issues/9013)). [\#9015](https://github.com/ClickHouse/ClickHouse/pull/9015) ([Eugene Klimov](https://github.com/Slach)) +- Şu andan itibaren, HTTP yanıtları olacak `X-ClickHouse-Timezone` başlık, aynı zaman dilimi değerine ayarlanmış `SELECT timezone()` rapor verecek. [\#9493](https://github.com/ClickHouse/ClickHouse/pull/9493) ([Denis Glazachev](https://github.com/traceon)) + +#### Performans İyileştirme {#performance-improvement} + +- In ile analiz endeksinin performansını artırın [\#9261](https://github.com/ClickHouse/ClickHouse/pull/9261) ([Anton Popov](https://github.com/CurtizJ)) +- Mantıksal işlevlerde daha basit ve daha verimli kod + kod temizleme. Bir takip için [\#8718](https://github.com/ClickHouse/ClickHouse/issues/8718) [\#8728](https://github.com/ClickHouse/ClickHouse/pull/8728) ([Alexander Kazakov](https://github.com/Akazz)) +- Genel performans iyileştirme (%5 aralığında..Etkilenen sorgular için %200) C++20 özellikleri ile daha sıkı takma sağlayarak. [\#9304](https://github.com/ClickHouse/ClickHouse/pull/9304) ([Amos Kuşu](https://github.com/amosbird)) +- Karşılaştırma işlevlerinin iç döngüleri için daha sıkı takma ad. [\#9327](https://github.com/ClickHouse/ClickHouse/pull/9327) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Aritmetik fonksiyonların iç döngüleri için daha sıkı takma ad. [\#9325](https://github.com/ClickHouse/ClickHouse/pull/9325) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- A ~ 3 kat daha hızlı uygulama için ColumnVector::replicate(), hangi aracılığıyla ColumnConst:: convertToFullColumn () uygulanır. Sabitleri gerçekleştirirken testlerde de yararlı olacaktır. [\#9293](https://github.com/ClickHouse/ClickHouse/pull/9293) ([Alexander Kazakov](https://github.com/Akazz)) +- Bir başka küçük performans iyileştirme `ColumnVector::replicate()` (bu hızlandırır `materialize` fonksiyonu ve daha yüksek mertebeden fonksiyonları) daha da geliştirilmesi için [\#9293](https://github.com/ClickHouse/ClickHouse/issues/9293) [\#9442](https://github.com/ClickHouse/ClickHouse/pull/9442) ([Alexander Kazakov](https://github.com/Akazz)) +- Geliştirilmiş performans `stochasticLinearRegression` toplama işlevi. Bu yama Intel tarafından katkıda bulunmuştur. [\#8652](https://github.com/ClickHouse/ClickHouse/pull/8652) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Performansını artırmak `reinterpretAsFixedString` işlev. [\#9342](https://github.com/ClickHouse/ClickHouse/pull/9342) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İçin istemciye blok gönder notmeyin `Null` işlemciler boru hattında Biçimlendir. [\#8797](https://github.com/ClickHouse/ClickHouse/pull/8797) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) [\#8767](https://github.com/ClickHouse/ClickHouse/pull/8767) ([Alexander Kuzmenkov](https://github.com/akuzm)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement} + +- Özel durum işleme artık Linux için Windows Alt Sisteminde düzgün çalışıyor. Bkz. https://github.com/ClickHouse-Extras/libunwind/pull/3 bu düzeltmeler [\#6480](https://github.com/ClickHouse/ClickHouse/issues/6480) [\#9564](https://github.com/ClickHouse/ClickHouse/pull/9564) ([sobolevsv](https://github.com/sobolevsv)) +- Değişmek `readline` ile `replxx` etkileşimli çizgi düzenleme için `clickhouse-client` [\#8416](https://github.com/ClickHouse/ClickHouse/pull/8416) ([I ivanvan](https://github.com/abyss7)) +- FunctionsComparison daha iyi inşa süresi ve daha az şablon örnekleri. [\#9324](https://github.com/ClickHouse/ClickHouse/pull/9324) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İle entegrasyon eklendi `clang-tidy` CI. Ayrıca bakınız [\#6044](https://github.com/ClickHouse/ClickHouse/issues/6044) [\#9566](https://github.com/ClickHouse/ClickHouse/pull/9566) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Şimdi kullanarak cı içinde ClickHouse bağlantı `lld` için bile `gcc`. [\#9049](https://github.com/ClickHouse/ClickHouse/pull/9049) ([alesapin](https://github.com/alesapin)) +- İş parçacığı zamanlama rastgele izin ve glitches eklemek zaman `THREAD_FUZZER_*` ortam değişkenleri ayarlanır. Bu test yardımcı olur. [\#9459](https://github.com/ClickHouse/ClickHouse/pull/9459) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Durumsuz testlerde güvenli soketleri etkinleştirme [\#9288](https://github.com/ClickHouse/ClickHouse/pull/9288) ([tavplubix](https://github.com/tavplubix)) +- Split\_shared\_libraries = daha sağlam yap [\#9156](https://github.com/ClickHouse/ClickHouse/pull/9156) ([Azat Khuzhin](https://github.com/azat)) +- Yapmak “performance\_introspection\_and\_logging” rastgele sunucuya güvenilir test sıkışmış. Bu CI ortamında gerçekleşebilir. Ayrıca bakınız [\#9515](https://github.com/ClickHouse/ClickHouse/issues/9515) [\#9528](https://github.com/ClickHouse/ClickHouse/pull/9528) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- XML stil onayında doğrulayın. [\#9550](https://github.com/ClickHouse/ClickHouse/pull/9550) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Testte sabit yarış durumu `00738_lock_for_inner_table`. Bu test uykuya dayanıyordu. [\#9555](https://github.com/ClickHouse/ClickHouse/pull/9555) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tür performans testlerini kaldırın `once`. Bu, tüm performans testlerini istatistiksel karşılaştırma modunda çalıştırmak için gereklidir (daha güvenilir). [\#9557](https://github.com/ClickHouse/ClickHouse/pull/9557) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Aritmetik fonksiyonlar için performans testi eklendi. [\#9326](https://github.com/ClickHouse/ClickHouse/pull/9326) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İçin performans testi eklendi `sumMap` ve `sumMapWithOverflow` toplama fonksiyonları. İçin takip [\#8933](https://github.com/ClickHouse/ClickHouse/issues/8933) [\#8947](https://github.com/ClickHouse/ClickHouse/pull/8947) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Üslup ile ErrorCodes stil sağlamak. [\#9370](https://github.com/ClickHouse/ClickHouse/pull/9370) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Testler geçmişi için komut dosyası ekleyin. [\#8796](https://github.com/ClickHouse/ClickHouse/pull/8796) ([alesapin](https://github.com/alesapin)) +- GCC uyarısı Ekle `-Wsuggest-override` tüm yerleri bulmak ve düzeltmek için `override` anahtar kelime kullanılmalıdır. [\#8760](https://github.com/ClickHouse/ClickHouse/pull/8760) ([kreuzerkrieg](https://github.com/kreuzerkrieg)) +- Tanımlanmalıdır çünkü Mac OS X altında zayıf sembolü Yoksay [\#9538](https://github.com/ClickHouse/ClickHouse/pull/9538) ([Silinmiş kullanıcı](https://github.com/ghost)) +- Performans testlerinde bazı sorguların çalışma süresini normalleştirin. Bu, tüm performans testlerini karşılaştırma modunda çalıştırmak için hazırlık olarak yapılır. [\#9565](https://github.com/ClickHouse/ClickHouse/pull/9565) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sorgu testleriyle pytest'i desteklemek için bazı testleri düzeltin [\#9062](https://github.com/ClickHouse/ClickHouse/pull/9062) ([I ivanvan](https://github.com/abyss7)) +- Ssl'yi msan ile oluşturmada etkinleştirin, böylece durumsuz testler çalıştırırken sunucu başlangıçta başarısız olmaz [\#9531](https://github.com/ClickHouse/ClickHouse/pull/9531) ([tavplubix](https://github.com/tavplubix)) +- Test sonuçlarında veritabanı ikamesini düzeltin [\#9384](https://github.com/ClickHouse/ClickHouse/pull/9384) ([Ilya Yatsishin](https://github.com/qoega)) +- Çeşitli platformlar için düzeltmeler oluşturun [\#9381](https://github.com/ClickHouse/ClickHouse/pull/9381) ([proller](https://github.com/proller)) [\#8755](https://github.com/ClickHouse/ClickHouse/pull/8755) ([proller](https://github.com/proller)) [\#8631](https://github.com/ClickHouse/ClickHouse/pull/8631) ([proller](https://github.com/proller)) +- Stateless-with-coverage test docker görüntüsüne diskler bölümü eklendi [\#9213](https://github.com/ClickHouse/ClickHouse/pull/9213) ([Pavel Kovalenko](https://github.com/Jokser)) +- GRPC ile oluştururken kaynak ağacı dosyalarından kurtulun [\#9588](https://github.com/ClickHouse/ClickHouse/pull/9588) ([Amos Kuşu](https://github.com/amosbird)) +- Sessioncleaner'ı bağlamdan kaldırarak biraz daha hızlı oluşturma süresi. SessionCleaner kodunu daha basit hale getirin. [\#9232](https://github.com/ClickHouse/ClickHouse/pull/9232) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Clickhouse-test komut dosyasında asılı sorgular için güncelleme denetimi [\#8858](https://github.com/ClickHouse/ClickHouse/pull/8858) ([Alexander Kazakov](https://github.com/Akazz)) +- Depodan bazı gereksiz dosyaları kaldırıldı. [\#8843](https://github.com/ClickHouse/ClickHouse/pull/8843) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Değişen matematik perftests türü `once` -e doğru `loop`. [\#8783](https://github.com/ClickHouse/ClickHouse/pull/8783) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Bizim kod tabanı için interaktif kod tarayıcı HTML raporu oluşturmanıza olanak sağlar docker görüntü ekleyin. [\#8781](https://github.com/ClickHouse/ClickHouse/pull/8781) ([alesapin](https://github.com/alesapin)) Görmek [Woboq Kod Tarayıcı](https://clickhouse.tech/codebrowser/html_report///ClickHouse/dbms/src/index.html) +- MSan altında bazı test hatalarını bastırın. [\#8780](https://github.com/ClickHouse/ClickHouse/pull/8780) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Hızlanma “exception while insert” test. Bu sınama genellikle hata ayıklama-with-coverage derlemede zaman aşımına uğradı. [\#8711](https://github.com/ClickHouse/ClickHouse/pull/8711) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Güncel `libcxx` ve `libcxxabi` yenmek. Hazırlan preparationmasında [\#9304](https://github.com/ClickHouse/ClickHouse/issues/9304) [\#9308](https://github.com/ClickHouse/ClickHouse/pull/9308) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Flacky testi düzeltin `00910_zookeeper_test_alter_compression_codecs`. [\#9525](https://github.com/ClickHouse/ClickHouse/pull/9525) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yinelenen bağlayıcı bayrakları temizleyin. Bağlayıcının beklenmedik bir sembol aramayacağından emin olun. [\#9433](https://github.com/ClickHouse/ClickHouse/pull/9433) ([Amos Kuşu](https://github.com/amosbird)) +- Eklemek `clickhouse-odbc` test görüntüleri içine sürücü. Bu, ClickHouse ile clickhouse etkileşimini kendi ODBC sürücüsü aracılığıyla test etmeyi sağlar. [\#9348](https://github.com/ClickHouse/ClickHouse/pull/9348) ([filimonov](https://github.com/filimonov)) +- Birim testlerinde birkaç hatayı düzeltin. [\#9047](https://github.com/ClickHouse/ClickHouse/pull/9047) ([alesapin](https://github.com/alesapin)) +- Etkinleştirmek `-Wmissing-include-dirs` Mevcut olmayan tüm içeriklerin ortadan kaldırılması için GCC uyarısı-çoğunlukla cmake komut dosyası hatalarının bir sonucu olarak [\#8704](https://github.com/ClickHouse/ClickHouse/pull/8704) ([kreuzerkrieg](https://github.com/kreuzerkrieg)) +- Sorgu profiler çalışamaz, nedenleri açıklayın. Bu için tasarlanmıştır [\#9049](https://github.com/ClickHouse/ClickHouse/issues/9049) [\#9144](https://github.com/ClickHouse/ClickHouse/pull/9144) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Openssl'yi upstream master'a güncelleyin. TLS bağlantıları mesajla başarısız olabilir sorunu düzeltildi `OpenSSL SSL_read: error:14094438:SSL routines:ssl3_read_bytes:tlsv1 alert internal error` ve `SSL Exception: error:2400006E:random number generator::error retrieving entropy`. Sorun 20.1 sürümünde mevcuttu. [\#8956](https://github.com/ClickHouse/ClickHouse/pull/8956) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sunucu için Dockerfile güncelleme [\#8893](https://github.com/ClickHouse/ClickHouse/pull/8893) ([Ilya Mazaev](https://github.com/ne-ray)) +- Build-gcc-from-sources komut dosyasında küçük düzeltmeler [\#8774](https://github.com/ClickHouse/ClickHouse/pull/8774) ([Michael Nacharov](https://github.com/mnach)) +- Değişmek `numbers` -e doğru `zeros` perftests nerede `number` sütun kullanılmaz. Bu daha temiz test sonuçlarına yol açacaktır. [\#9600](https://github.com/ClickHouse/ClickHouse/pull/9600) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Sütun yapıcılarında ınitializer\_list kullanırken yığın taşması sorununu düzeltin. [\#9367](https://github.com/ClickHouse/ClickHouse/pull/9367) ([Silinmiş kullanıcı](https://github.com/ghost)) +- V1.3.0 için librdkafka yükseltin. Birlikte etkinleştir `rdkafka` ve `gsasl` Mac OS X kitaplıkları. [\#9000](https://github.com/ClickHouse/ClickHouse/pull/9000) ([Andrew Onyshchuk](https://github.com/oandrew)) +- gcc 9.2.0 üzerinde düzeltme oluşturun [\#9306](https://github.com/ClickHouse/ClickHouse/pull/9306) ([vxider](https://github.com/Vxider)) + +## ClickHouse yayın v20. 1 {#clickhouse-release-v20-1} + +### ClickHouse yayın v20. 1. 8. 41, 2020-03-20 {#clickhouse-release-v20-1-8-41-2020-03-20} + +#### Hata Düzeltme {#bug-fix-3} + +- Olası kalıcı düzeltme `Cannot schedule a task` hata (işlenmeyen özel durum nedeniyle `ParallelAggregatingBlockInputStream::Handler::onFinish/onFinishThread`). Bu düzeltmeler [\#6833](https://github.com/ClickHouse/ClickHouse/issues/6833). [\#9154](https://github.com/ClickHouse/ClickHouse/pull/9154) ([Azat Khuzhin](https://github.com/azat)) +- Aşırı bellek tüketimini düzeltin `ALTER` sorgular (Mut (asyonlar). Bu düzeltmeler [\#9533](https://github.com/ClickHouse/ClickHouse/issues/9533) ve [\#9670](https://github.com/ClickHouse/ClickHouse/issues/9670). [\#9754](https://github.com/ClickHouse/ClickHouse/pull/9754) ([alesapin](https://github.com/alesapin)) +- Dış sözlükler DDL backquoting hatayı düzeltin. Bu düzeltmeler [\#9619](https://github.com/ClickHouse/ClickHouse/issues/9619). [\#9734](https://github.com/ClickHouse/ClickHouse/pull/9734) ([alesapin](https://github.com/alesapin)) + +### ClickHouse yayın v20.1. 7. 38, 2020-03-18 {#clickhouse-release-v20-1-7-38-2020-03-18} + +#### Hata Düzeltme {#bug-fix-4} + +- Sabit yanlış iç işlev adları için `sumKahan` ve `sumWithOverflow`. Bu işlevleri uzak sorgularda kullanırken istisnaya yol açarım. [\#9636](https://github.com/ClickHouse/ClickHouse/pull/9636) ([Azat Khuzhin](https://github.com/azat)). Bu sorun tüm ClickHouse sürümlerindeydi. +- Vermek `ALTER ON CLUSTER` -den `Distributed` iç çoğaltma ile tablolar. Bu düzeltmeler [\#3268](https://github.com/ClickHouse/ClickHouse/issues/3268). [\#9617](https://github.com/ClickHouse/ClickHouse/pull/9617) ([shinoi2](https://github.com/shinoi2)). Bu sorun tüm ClickHouse sürümlerindeydi. +- Olası istisnaları düzeltin `Size of filter doesn't match size of column` ve `Invalid number of rows in Chunk` içinde `MergeTreeRangeReader`. Yürüt whileürken görün theyebilirler `PREWHERE` bazı durumlarda. Düzeltiyor [\#9132](https://github.com/ClickHouse/ClickHouse/issues/9132). [\#9612](https://github.com/ClickHouse/ClickHouse/pull/9612) ([Anton Popov](https://github.com/CurtizJ)) +- Sorunu düzeltildi: Eğer gibi basit bir aritmetik ifade yazarsanız zaman dilimi korunmuş değildi `time + 1` (gibi bir ifadenin aksine `time + INTERVAL 1 SECOND`). Bu düzeltmeler [\#5743](https://github.com/ClickHouse/ClickHouse/issues/5743). [\#9323](https://github.com/ClickHouse/ClickHouse/pull/9323) ([alexey-milovidov](https://github.com/alexey-milovidov)). Bu sorun tüm ClickHouse sürümlerindeydi. +- Artık basit döngüsel takma adlarla sütunlar oluşturmak veya eklemek mümkün değil `a DEFAULT b, b DEFAULT a`. [\#9603](https://github.com/ClickHouse/ClickHouse/pull/9603) ([alesapin](https://github.com/alesapin)) +- Base64 kodlanmış değerin sonunda dolgu hatalı biçimlendirilmiş olabilir sorunu düzeltildi. Base64 kütüphanesini güncelleyin. Bu düzeltmeler [\#9491](https://github.com/ClickHouse/ClickHouse/issues/9491), yaklar [\#9492](https://github.com/ClickHouse/ClickHouse/issues/9492) [\#9500](https://github.com/ClickHouse/ClickHouse/pull/9500) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İmha veri yarışı Fix `Poco::HTTPServer`. Sunucu başlatıldığında ve hemen kapatıldığında gerçekleşebilir. [\#9468](https://github.com/ClickHouse/ClickHouse/pull/9468) ([Anton Popov](https://github.com/CurtizJ)) +- Olası kilitlenme/yanlış satır sayısını düzeltin `LIMIT n WITH TIES` n'th satırına eşit çok sayıda satır olduğunda. [\#9464](https://github.com/ClickHouse/ClickHouse/pull/9464) ([tavplubix](https://github.com/tavplubix)) +- Sütun TTLs ile olası eşleşmeyen sağlama toplamlarını düzeltin. [\#9451](https://github.com/ClickHouse/ClickHouse/pull/9451) ([Anton Popov](https://github.com/CurtizJ)) +- Bir kullanıcı denediğinde çökmeyi düzeltin `ALTER MODIFY SETTING` eski formatlı için `MergeTree` masa motorları ailesi. [\#9435](https://github.com/ClickHouse/ClickHouse/pull/9435) ([alesapin](https://github.com/alesapin)) +- Şimdi mutasyonları daha sık sonuçlandırmaya çalışacağız. [\#9427](https://github.com/ClickHouse/ClickHouse/pull/9427) ([alesapin](https://github.com/alesapin)) +- Çoğaltma protokolü uyumsuzluğunu düzeltme [\#8598](https://github.com/ClickHouse/ClickHouse/issues/8598). [\#9412](https://github.com/ClickHouse/ClickHouse/pull/9412) ([alesapin](https://github.com/alesapin)) +- Dizi türlerinin bloom\_filter dizini için değil(has()) düzeltin. [\#9407](https://github.com/ClickHouse/ClickHouse/pull/9407) ([achimbab](https://github.com/achimbab)) +- Davranışı Düzelt theildi `match` ve `extract` haystack sıfır bayt olduğunda işlevler. Haystack sabit olduğunda davranış yanlıştı. Bu düzeltmeler [\#9160](https://github.com/ClickHouse/ClickHouse/issues/9160) [\#9163](https://github.com/ClickHouse/ClickHouse/pull/9163) ([alexey-milovidov](https://github.com/alexey-milovidov)) [\#9345](https://github.com/ClickHouse/ClickHouse/pull/9345) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-1} + +- Özel durum işleme artık Linux için Windows Alt Sisteminde düzgün çalışıyor. Bkz. https://github.com/ClickHouse-Extras/libunwind/pull/3 bu düzeltmeler [\#6480](https://github.com/ClickHouse/ClickHouse/issues/6480) [\#9564](https://github.com/ClickHouse/ClickHouse/pull/9564) ([sobolevsv](https://github.com/sobolevsv)) + +### ClickHouse yayın v20. 1. 6. 30, 2020-03-05 {#clickhouse-release-v20-1-6-30-2020-03-05} + +#### Hata Düzeltme {#bug-fix-5} + +- Sıkıştırıldığında veri uyumsuzluğunu düzeltin `T64` codec. + [\#9039](https://github.com/ClickHouse/ClickHouse/pull/9039) [(abyss7)](https://github.com/abyss7) +- Mergetree tablosundan bir iş parçacığında okurken aralıkların sırasını düzeltin. Düzeltiyor [\#8964](https://github.com/ClickHouse/ClickHouse/issues/8964). + [\#9050](https://github.com/ClickHouse/ClickHouse/pull/9050) [(CurtizJ)](https://github.com/CurtizJ) +- Olası segfault'u düzeltin `MergeTreeRangeReader`, Yürüt whileürken `PREWHERE`. Düzeltiyor [\#9064](https://github.com/ClickHouse/ClickHouse/issues/9064). + [\#9106](https://github.com/ClickHouse/ClickHouse/pull/9106) [(CurtizJ)](https://github.com/CurtizJ) +- Düzeltmek `reinterpretAsFixedString` dönmek `FixedString` yerine `String`. + [\#9052](https://github.com/ClickHouse/ClickHouse/pull/9052) [(oandrew)](https://github.com/oandrew) +- Düzeltmek `joinGet` null dönüş türleri ile. Düzeltiyor [\#8919](https://github.com/ClickHouse/ClickHouse/issues/8919) + [\#9014](https://github.com/ClickHouse/ClickHouse/pull/9014) [(amosbird)](https://github.com/amosbird) +- Fuzz testini ve bittestall/bitTestAny işlevlerinin yanlış davranışını düzeltin. + [\#9143](https://github.com/ClickHouse/ClickHouse/pull/9143) [(alexey-milovidov)](https://github.com/alexey-milovidov) +- Haystack sıfır bayt olduğunda match ve extract işlevlerinin davranışını düzeltin. Haystack sabit olduğunda davranış yanlıştı. Düzeltiyor [\#9160](https://github.com/ClickHouse/ClickHouse/issues/9160) + [\#9163](https://github.com/ClickHouse/ClickHouse/pull/9163) [(alexey-milovidov)](https://github.com/alexey-milovidov) +- Kesinlikle monotinik olmayan fonksiyonel indeks kullanıldığında ters yüklemlerin sabit yürütülmesi. Düzeltiyor [\#9034](https://github.com/ClickHouse/ClickHouse/issues/9034) + [\#9223](https://github.com/ClickHouse/ClickHouse/pull/9223) [(Akazz)](https://github.com/Akazz) +- Yeniden yazmak için izin ver `CROSS` -e doğru `INNER JOIN` varsa `[NOT] LIKE` operat inor in `WHERE` bölme. Düzeltiyor [\#9191](https://github.com/ClickHouse/ClickHouse/issues/9191) + [\#9229](https://github.com/ClickHouse/ClickHouse/pull/9229) [(4ertus2)](https://github.com/4ertus2) +- Log engine ile bir tablodaki ilk sütunların bir diğer ad olmasına izin verin. + [\#9231](https://github.com/ClickHouse/ClickHouse/pull/9231) [(abyss7)](https://github.com/abyss7) +- Virgülle birleşmeye izin ver `IN()` için. Düzeltiyor [\#7314](https://github.com/ClickHouse/ClickHouse/issues/7314). + [\#9251](https://github.com/ClickHouse/ClickHouse/pull/9251) [(4ertus2)](https://github.com/4ertus2) +- Geliştirmek `ALTER MODIFY/ADD` sorgu mantığı. Şimdi yapamazsın `ADD` türü olmayan sütun, `MODIFY` varsayılan ifade sütun türünü değiştirmez ve `MODIFY` tür varsayılan ifade değerini kaybetmez. Düzeltiyor [\#8669](https://github.com/ClickHouse/ClickHouse/issues/8669). + [\#9227](https://github.com/ClickHouse/ClickHouse/pull/9227) [(alesapin)](https://github.com/alesapin) +- Mutasyonlar kesinleşmesini düzeltin, zaten mutasyon yapıldığında is\_done = 0 durumuna sahip olabilir. + [\#9217](https://github.com/ClickHouse/ClickHouse/pull/9217) [(alesapin)](https://github.com/alesapin) +- Destek “Processors” sistem için boru hattı.sayılar ve sistem.numbers\_mt. Bu aynı zamanda hatayı giderir `max_execution_time` saygın değildir. + [\#7796](https://github.com/ClickHouse/ClickHouse/pull/7796) [(KochetovNicolai)](https://github.com/KochetovNicolai) +- Yanlış saymayı düzeltin `DictCacheKeysRequestedFound` ölçü. + [\#9411](https://github.com/ClickHouse/ClickHouse/pull/9411) [(nikitamikhaylov)](https://github.com/nikitamikhaylov) +- Depolama politikası için bir kontrol eklendi `ATTACH PARTITION FROM`, `REPLACE PARTITION`, `MOVE TO TABLE` aksi halde, yeniden başlatıldıktan sonra parçanın verilerini erişilemez hale getirebilir ve Clickhouse'un başlatılmasını önleyebilir. + [\#9383](https://github.com/ClickHouse/ClickHouse/pull/9383) [(excitoon)](https://github.com/excitoon) +- Sabit UBSan raporu `MergeTreeIndexSet`. Bu düzeltmeler [\#9250](https://github.com/ClickHouse/ClickHouse/issues/9250) + [\#9365](https://github.com/ClickHouse/ClickHouse/pull/9365) [(alexey-milovidov)](https://github.com/alexey-milovidov) +- BlockİO Olası datarace Fix. + [\#9356](https://github.com/ClickHouse/ClickHouse/pull/9356) [(KochetovNicolai)](https://github.com/KochetovNicolai) +- İçin destek `UInt64` json ile ilgili işlevlerde Int64'e uymayan sayılar. Güncelleştirme `SIMDJSON` yenmek. Bu düzeltmeler [\#9209](https://github.com/ClickHouse/ClickHouse/issues/9209) + [\#9344](https://github.com/ClickHouse/ClickHouse/pull/9344) [(alexey-milovidov)](https://github.com/alexey-milovidov) +- Veri dizini ayrı bir aygıta takılıysa, boş alan miktarı doğru hesaplanmadığında sorunu düzeltin. Varsayılan disk için veri alt dizinindeki boş alanı hesaplayın. Bu düzeltmeler [\#7441](https://github.com/ClickHouse/ClickHouse/issues/7441) + [\#9257](https://github.com/ClickHouse/ClickHouse/pull/9257) [(millb)](https://github.com/millb) +- Mesajla TLS bağlantıları başarısız olduğunda sorunu düzeltin `OpenSSL SSL_read: error:14094438:SSL routines:ssl3_read_bytes:tlsv1 alert internal error and SSL Exception: error:2400006E:random number generator::error retrieving entropy.` Openssl'yi upstream master'a güncelleyin. + [\#8956](https://github.com/ClickHouse/ClickHouse/pull/8956) [(alexey-milovidov)](https://github.com/alexey-milovidov) +- Yürüt whenürken `CREATE` sorgu, depolama motoru argümanlarında sabit ifadeleri katlayın. Boş veritabanı adı geçerli veritabanı ile değiştirin. Düzeltiyor [\#6508](https://github.com/ClickHouse/ClickHouse/issues/6508), [\#3492](https://github.com/ClickHouse/ClickHouse/issues/3492). Ayrıca ClickHouseDictionarySource yerel adresi için onay düzeltin. + [\#9262](https://github.com/ClickHouse/ClickHouse/pull/9262) [(tabplubix)](https://github.com/tavplubix) +- Segfault'u düzeltin `StorageMerge`, StorageFile okurken olabilir. + [\#9387](https://github.com/ClickHouse/ClickHouse/pull/9387) [(tabplubix)](https://github.com/tavplubix) +- Veri kaybını önlemek `Kafka` nadir durumlarda istisna sonek okuduktan sonra ancak taahhütten önce gerçekleşir. Düzeltiyor [\#9378](https://github.com/ClickHouse/ClickHouse/issues/9378). İlgili: [\#7175](https://github.com/ClickHouse/ClickHouse/issues/7175) + [\#9507](https://github.com/ClickHouse/ClickHouse/pull/9507) [(filimonov)](https://github.com/filimonov) +- Kullanmaya / bırakmaya çalışırken sunucu sonlandırmasına giden hatayı düzeltin `Kafka` tablo yanlış parametrelerle oluşturuldu. Düzeltiyor [\#9494](https://github.com/ClickHouse/ClickHouse/issues/9494). Birleşiyor [\#9507](https://github.com/ClickHouse/ClickHouse/issues/9507). + [\#9513](https://github.com/ClickHouse/ClickHouse/pull/9513) [(filimonov)](https://github.com/filimonov) + +#### Yenilik {#new-feature-1} + +- Eklemek `deduplicate_blocks_in_dependent_materialized_views` hayata manzaralı tablolara idempotent ekler davranışlarını kontrol etmek için Seçenek. Bu yeni özellik, altınity'den özel bir istek ile bugfix sürümüne eklendi. + [\#9070](https://github.com/ClickHouse/ClickHouse/pull/9070) [(urykhy)](https://github.com/urykhy) + +### ClickHouse yayın v20.1. 2. 4, 2020-01-22 {#clickhouse-release-v20-1-2-4-2020-01-22} + +#### Geriye Dönük Uyumsuz Değişim {#backward-incompatible-change-1} + +- Ayarı yap `merge_tree_uniform_read_distribution` eski. Sunucu hala bu ayarı tanır, ancak hiçbir etkisi yoktur. [\#8308](https://github.com/ClickHouse/ClickHouse/pull/8308) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Fonksiyonun dönüş türünü değiştirdi `greatCircleDistance` -e doğru `Float32` çünkü şimdi hesaplamanın sonucu `Float32`. [\#7993](https://github.com/ClickHouse/ClickHouse/pull/7993) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Şimdi sorgu parametrelerinin şu şekilde temsil edilmesi bekleniyor “escaped” biçimli. Örneğin, dize geçmek için `ab` yazmak zorundasın `a\tb` veya `a\b` ve sırasıyla, `a%5Ctb` veya `a%5C%09b` URL in'de. Bu, NULL olarak geçme olasılığını eklemek için gereklidir `\N`. Bu düzeltmeler [\#7488](https://github.com/ClickHouse/ClickHouse/issues/7488). [\#8517](https://github.com/ClickHouse/ClickHouse/pull/8517) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Etkinleştirmek `use_minimalistic_part_header_in_zookeeper` için ayar `ReplicatedMergeTree` varsayılan olarak. Bu, Zookeeper'da depolanan veri miktarını önemli ölçüde azaltacaktır. Bu ayar 19.1 sürümünden beri desteklenmektedir ve zaten yarım yıldan fazla bir süredir herhangi bir sorun yaşamadan birden fazla hizmette üretimde kullanıyoruz. 19.1'den eski sürümlere geçiş yapma şansınız varsa bu ayarı devre dışı bırakın. [\#6850](https://github.com/ClickHouse/ClickHouse/pull/6850) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Veri atlama endeksleri üretim hazır ve varsayılan olarak etkindir. Ayar `allow_experimental_data_skipping_indices`, `allow_experimental_cross_to_join_conversion` ve `allow_experimental_multiple_joins_emulation` artık eskimiş ve hiçbir şey yapma. [\#7974](https://github.com/ClickHouse/ClickHouse/pull/7974) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yeni Ekle `ANY JOIN` için mantık `StorageJoin` ile tutarlı `JOIN` işleyiş. Davranış değişiklikleri olmadan yükseltmek için eklemeniz gerekir `SETTINGS any_join_distinct_right_table_keys = 1` motor tabloları meta katılmak veya yükseltmeden sonra bu tabloları yeniden oluşturmak için. [\#8400](https://github.com/ClickHouse/ClickHouse/pull/8400) ([Artem Zuikov](https://github.com/4ertus2)) +- Günlük yapılandırma değişiklikleri uygulamak için yeniden başlatılması için sunucu gerektirir. Bu, sunucunun silinmiş bir günlük dosyasına oturum açtığı hatayı önlemek için geçici bir geçici çözümdür (bkz. [\#8696](https://github.com/ClickHouse/ClickHouse/issues/8696)). [\#8707](https://github.com/ClickHouse/ClickHouse/pull/8707) ([Alexander Kuzmenkov](https://github.com/akuzm)) + +#### Yenilik {#new-feature-2} + +- Parça yolları hakkında bilgi eklendi `system.merges`. [\#8043](https://github.com/ClickHouse/ClickHouse/pull/8043) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Yürütme yeteneği Ekle `SYSTEM RELOAD DICTIONARY` sorgu içinde `ON CLUSTER` modu. [\#8288](https://github.com/ClickHouse/ClickHouse/pull/8288) ([Guillaume Tassery](https://github.com/YiuRULE)) +- Yürütme yeteneği Ekle `CREATE DICTIONARY` sorgular `ON CLUSTER` modu. [\#8163](https://github.com/ClickHouse/ClickHouse/pull/8163) ([alesapin](https://github.com/alesapin)) +- Şimdi kullanıcının profili `users.xml` birden çok profil devralır. [\#8343](https://github.com/ClickHouse/ClickHouse/pull/8343) ([Mikhail f. Shiryaev](https://github.com/Felixoid)) +- Katma `system.stack_trace` tüm sunucu iş parçacıklarının yığın izlerine bakmayı sağlayan tablo. Bu, geliştiricilerin sunucu durumunu iç gözlemlemesi için kullanışlıdır. Bu düzeltmeler [\#7576](https://github.com/ClickHouse/ClickHouse/issues/7576). [\#8344](https://github.com/ClickHouse/ClickHouse/pull/8344) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Eklemek `DateTime64` yapılandırılabilir alt ikinci hassasiyetle veri türü. [\#7170](https://github.com/ClickHouse/ClickHouse/pull/7170) ([Vasily Nemkov](https://github.com/Enmk)) +- Tablo fonksiyonu Ekle `clusterAllReplicas` kümedeki tüm düğümleri sorgulamaya izin verir. [\#8493](https://github.com/ClickHouse/ClickHouse/pull/8493) ([kiran sunkari](https://github.com/kiransunkari)) +- Toplama işlevi Ekle `categoricalInformationValue` ayrık bir özelliğin bilgi değerini hesaplar. [\#8117](https://github.com/ClickHouse/ClickHouse/pull/8117) ([hcz](https://github.com/hczhcz)) +- Veri dosyalarının ayrıştırılmasını hızlandırın `CSV`, `TSV` ve `JSONEachRow` paralel olarak yaparak Biçimlendir .in. [\#7780](https://github.com/ClickHouse/ClickHouse/pull/7780) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Fonksiyon Ekle `bankerRound` bankacı yuvarlama yapar. [\#8112](https://github.com/ClickHouse/ClickHouse/pull/8112) ([hcz](https://github.com/hczhcz)) +- Bölge adları için gömülü sözlükte daha fazla dil desteği: ‘ru’, ‘en’, ‘ua’, ‘uk’, ‘by’, ‘kz’, ‘tr’, ‘de’, ‘uz’, ‘lv’, ‘lt’, ‘et’, ‘pt’, ‘he’, ‘vi’. [\#8189](https://github.com/ClickHouse/ClickHouse/pull/8189) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tutarlılıktaki gelişmeler `ANY JOIN` mantıksal. Şimdi `t1 ANY LEFT JOIN t2` eşitlikler `t2 ANY RIGHT JOIN t1`. [\#7665](https://github.com/ClickHouse/ClickHouse/pull/7665) ([Artem Zuikov](https://github.com/4ertus2)) +- Ayar Ekle `any_join_distinct_right_table_keys` için eski davranışları sağlayan `ANY INNER JOIN`. [\#7665](https://github.com/ClickHouse/ClickHouse/pull/7665) ([Artem Zuikov](https://github.com/4ertus2)) +- Yeni Ekle `SEMI` ve `ANTI JOIN`. Yaş `ANY INNER JOIN` davranış şu anda mevcut `SEMI LEFT JOIN`. [\#7665](https://github.com/ClickHouse/ClickHouse/pull/7665) ([Artem Zuikov](https://github.com/4ertus2)) +- Katma `Distributed` format for `File` motor ve `file` okumak için izin veren tablo işlevi `.bin` asenkron ekler tarafından oluşturulan dosyalar `Distributed` Tablo. [\#8535](https://github.com/ClickHouse/ClickHouse/pull/8535) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- İsteğe bağlı Sıfırla sütun argümanı Ekle `runningAccumulate` hangi her yeni anahtar değeri için toplama sonuçlarını sıfırlamak için izin verir. [\#8326](https://github.com/ClickHouse/ClickHouse/pull/8326) ([Sergey Kononenko](https://github.com/kononencheg)) +- Prometheus bitiş noktası olarak ClickHouse kullanma yeteneği ekleyin. [\#7900](https://github.com/ClickHouse/ClickHouse/pull/7900) ([vdimir](https://github.com/Vdimir)) +- Bölüm Ekle `` içinde `config.xml` uzak tablo motorları ve tablo işlevleri için izin verilen ana bilgisayarları kısıtlayan `URL`, `S3`, `HDFS`. [\#7154](https://github.com/ClickHouse/ClickHouse/pull/7154) ([Mikhail Korotov](https://github.com/millb)) +- Eklendi fonksiyonu `greatCircleAngle` bir küre üzerindeki mesafeyi derece cinsinden hesaplar. [\#8105](https://github.com/ClickHouse/ClickHouse/pull/8105) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- H3 kütüphanesi ile tutarlı olacak şekilde dünya yarıçapı değiştirildi. [\#8105](https://github.com/ClickHouse/ClickHouse/pull/8105) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Katma `JSONCompactEachRow` ve `JSONCompactEachRowWithNamesAndTypes` giriş ve çıkış biçimleri. [\#7841](https://github.com/ClickHouse/ClickHouse/pull/7841) ([Mikhail Korotov](https://github.com/millb)) +- Dosya ile ilgili tablo motorları ve tablo işlevleri için özellik eklendi (`File`, `S3`, `URL`, `HDFS`) okuma ve yaz allowsmayı sağlayan `gzip` ek motor parametresi veya dosya uzantısına dayalı dosyalar. [\#7840](https://github.com/ClickHouse/ClickHouse/pull/7840) ([Andrey Bodrov](https://github.com/apbodrov)) +- Add theed the `randomASCII(length)` fonksiyon, rastgele bir dizi ile bir dize oluşturma [ASCII](https://en.wikipedia.org/wiki/ASCII#Printable_characters) yazdırılabilir karakterler. [\#8401](https://github.com/ClickHouse/ClickHouse/pull/8401) ([Süngü](https://github.com/BayoNet)) +- Eklendi fonksiyonu `JSONExtractArrayRaw` ayrıştırılmamış json dizi öğelerinde bir dizi döndürür `JSON` dize. [\#8081](https://github.com/ClickHouse/ClickHouse/pull/8081) ([Oleg Matrokhin](https://github.com/errx)) +- Eklemek `arrayZip` eşit uzunluktaki birden fazla diziyi bir dizi diziye birleştirmeyi sağlayan işlev. [\#8149](https://github.com/ClickHouse/ClickHouse/pull/8149) ([Kış Zhang](https://github.com/zhang2014)) +- Yapılandırılmış göre diskler arasında veri taşımak için yeteneği ekleyin `TTL`- ifadeler için `*MergeTree` masa motorları ailesi. [\#8140](https://github.com/ClickHouse/ClickHouse/pull/8140) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Yeni toplama fonksiyonu eklendi `avgWeighted` hangi ağırlıklı ortalama hesaplamak için izin verir. [\#7898](https://github.com/ClickHouse/ClickHouse/pull/7898) ([Andrey Bodrov](https://github.com/apbodrov)) +- Şimdi paralel ayrıştırma için varsayılan olarak etkindir `TSV`, `TSKV`, `CSV` ve `JSONEachRow` biçimliler. [\#7894](https://github.com/ClickHouse/ClickHouse/pull/7894) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Birkaç coğrafi işlev Ekle `H3` kitaplık: `h3GetResolution`, `h3EdgeAngle`, `h3EdgeLength`, `h3IsValid` ve `h3kRing`. [\#8034](https://github.com/ClickHouse/ClickHouse/pull/8034) ([Konstantin Malanchev](https://github.com/hombit)) +- Brotli için destek eklendi (`br`) dosya ile ilgili Depolarda ve tablo işlevlerinde sıkıştırma. Bu düzeltmeler [\#8156](https://github.com/ClickHouse/ClickHouse/issues/8156). [\#8526](https://github.com/ClickHouse/ClickHouse/pull/8526) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Eklemek `groupBit*` fonksiyonlar için `SimpleAggregationFunction` tür. [\#8485](https://github.com/ClickHouse/ClickHouse/pull/8485) ([Guillaume Tassery](https://github.com/YiuRULE)) + +#### Hata Düzeltme {#bug-fix-6} + +- Tabloların yeniden adlandırılmasını düzeltin `Distributed` motor. Düzeltmeler sorunu [\#7868](https://github.com/ClickHouse/ClickHouse/issues/7868). [\#8306](https://github.com/ClickHouse/ClickHouse/pull/8306) ([tavplubix](https://github.com/tavplubix)) +- Şimdi sözlükler desteği `EXPRESSION` non-ClickHouse SQL lehçesinde keyfi dizedeki öznitelikler için. [\#8098](https://github.com/ClickHouse/ClickHouse/pull/8098) ([alesapin](https://github.com/alesapin)) +- Kırık düzeltmek `INSERT SELECT FROM mysql(...)` sorgu. Bu düzeltmeler [\#8070](https://github.com/ClickHouse/ClickHouse/issues/8070) ve [\#7960](https://github.com/ClickHouse/ClickHouse/issues/7960). [\#8234](https://github.com/ClickHouse/ClickHouse/pull/8234) ([tavplubix](https://github.com/tavplubix)) +- Hatayı Düzelt “Mismatch column sizes” varsayılan eklerken `Tuple` itibaren `JSONEachRow`. Bu düzeltmeler [\#5653](https://github.com/ClickHouse/ClickHouse/issues/5653). [\#8606](https://github.com/ClickHouse/ClickHouse/pull/8606) ([tavplubix](https://github.com/tavplubix)) +- Şimdi kullanılması durumunda bir istisna atılacaktır `WITH TIES` birlikte `LIMIT BY`. Ayrıca kullanma yeteneği ekleyin `TOP` ile `LIMIT BY`. Bu düzeltmeler [\#7472](https://github.com/ClickHouse/ClickHouse/issues/7472). [\#7637](https://github.com/ClickHouse/ClickHouse/pull/7637) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Taze glibc sürümünden istenmeyen bağımlılığı düzeltin `clickhouse-odbc-bridge` ikilik. [\#8046](https://github.com/ClickHouse/ClickHouse/pull/8046) ([Amos Kuşu](https://github.com/amosbird)) +- Kontrol fonksiyonunda hatayı düzeltin `*MergeTree` motorlar ailesi. Şimdi, son granül ve son işarette (nihai olmayan) eşit miktarda satıra sahip olduğumuzda başarısız olmaz. [\#8047](https://github.com/ClickHouse/ClickHouse/pull/8047) ([alesapin](https://github.com/alesapin)) +- Insert Into Fix `Enum*` sonra sütunlar `ALTER` sorgu, altta yatan sayısal tür tablo belirtilen türe eşit olduğunda. Bu düzeltmeler [\#7836](https://github.com/ClickHouse/ClickHouse/issues/7836). [\#7908](https://github.com/ClickHouse/ClickHouse/pull/7908) ([Anton Popov](https://github.com/CurtizJ)) +- İzin verilen sabit olmayan negatif “size” fonksiyon için argüman `substring`. Yanlışlıkla izin verilmedi. Bu düzeltmeler [\#4832](https://github.com/ClickHouse/ClickHouse/issues/4832). [\#7703](https://github.com/ClickHouse/ClickHouse/pull/7703) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yanlış sayıda argüman geçtiğinde ayrıştırma hatasını düzeltin `(O|J)DBC` masa motoru. [\#7709](https://github.com/ClickHouse/ClickHouse/pull/7709) ([alesapin](https://github.com/alesapin)) +- Syslog için günlükleri gönderirken çalışan clickhouse işleminin komut adını kullanma. Önceki sürümlerde, komut adı yerine boş dize kullanıldı. [\#8460](https://github.com/ClickHouse/ClickHouse/pull/8460) ([Michael Nacharov](https://github.com/mnach)) +- İzin verilen ana bilgisayarların kontrolünü düzeltin `localhost`. Bu PR, sağlanan çözümü düzeltir [\#8241](https://github.com/ClickHouse/ClickHouse/pull/8241). [\#8342](https://github.com/ClickHouse/ClickHouse/pull/8342) ([Vitaly Baranov](https://github.com/vitlibar)) +- Nadir kazayı düzeltin `argMin` ve `argMax` sonuç kullanıldığında, uzun dize bağımsız değişkenleri için işlevler `runningAccumulate` işlev. Bu düzeltmeler [\#8325](https://github.com/ClickHouse/ClickHouse/issues/8325) [\#8341](https://github.com/ClickHouse/ClickHouse/pull/8341) ([dinozor](https://github.com/769344359)) +- İle tablolar için bellek overcommit Fix `Buffer` motor. [\#8345](https://github.com/ClickHouse/ClickHouse/pull/8345) ([Azat Khuzhin](https://github.com/azat)) +- Alabilir fonksiyonları sabit potansiyel hata `NULL` bağımsız değişkenlerden biri olarak ve NULL olmayan döndürür. [\#8196](https://github.com/ClickHouse/ClickHouse/pull/8196) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Arka plan işlemleri için iş parçacığı havuzunda daha iyi metrik hesaplamaları `MergeTree` masa motorları. [\#8194](https://github.com/ClickHouse/ClickHouse/pull/8194) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Düzeltme fonksiyonu `IN` için `WHERE` satır düzeyinde tablo filtresi varsa deyimi. Düzeltiyor [\#6687](https://github.com/ClickHouse/ClickHouse/issues/6687) [\#8357](https://github.com/ClickHouse/ClickHouse/pull/8357) ([I ivanvan](https://github.com/abyss7)) +- Şimdi, integral değeri ayarlar değerleri için tamamen ayrıştırılmazsa bir istisna atılır. [\#7678](https://github.com/ClickHouse/ClickHouse/pull/7678) ([Mikhail Korotov](https://github.com/millb)) +- Toplama işlevi, sorguda ikiden fazla yerel parça içeren dağıtılmış tabloya kullanıldığında özel durumu düzeltin. [\#8164](https://github.com/ClickHouse/ClickHouse/pull/8164) ([小路](https://github.com/nicelulu)) +- Şimdi bloom filtresi sıfır uzunluk dizilerini işleyebilir ve gereksiz hesaplamalar yapmaz. [\#8242](https://github.com/ClickHouse/ClickHouse/pull/8242) ([achimbab](https://github.com/achimbab)) +- Bir istemci ana bilgisayar için istemci ana bilgisayar eşleştirerek izin verilip verilmediğini kontrol sabit `host_regexp` belirtilen `users.xml`. [\#8241](https://github.com/ClickHouse/ClickHouse/pull/8241) ([Vitaly Baranov](https://github.com/vitlibar)) +- Çoklu olarak yanlış pozitiflere yol açan belirsiz sütun kontrolünü rahatlatın `JOIN ON` bölme. [\#8385](https://github.com/ClickHouse/ClickHouse/pull/8385) ([Artem Zuikov](https://github.com/4ertus2)) +- Sabit Olası sunucu çökmesi (`std::terminate`) sunucu veri gönder cannotem whenediğinde veya yaz theama thedığında `JSON` veya `XML` değerleri ile biçim `String` veri türü (gerektiren `UTF-8` doğrulama) veya sonuç verilerini Brotli algoritması ile sıkıştırırken veya diğer bazı nadir durumlarda. Bu düzeltmeler [\#7603](https://github.com/ClickHouse/ClickHouse/issues/7603) [\#8384](https://github.com/ClickHouse/ClickHouse/pull/8384) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yarış durumunu düzeltin `StorageDistributedDirectoryMonitor` CI tarafından bulundu. Bu düzeltmeler [\#8364](https://github.com/ClickHouse/ClickHouse/issues/8364). [\#8383](https://github.com/ClickHouse/ClickHouse/pull/8383) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Şimdi arka plan birleşir `*MergeTree` tablo motorları ailesi depolama ilkesi hacim sırasını daha doğru bir şekilde korur. [\#8549](https://github.com/ClickHouse/ClickHouse/pull/8549) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Şimdi masa motoru `Kafka` ile düzgün çalışır `Native` biçimli. Bu düzeltmeler [\#6731](https://github.com/ClickHouse/ClickHouse/issues/6731) [\#7337](https://github.com/ClickHouse/ClickHouse/issues/7337) [\#8003](https://github.com/ClickHouse/ClickHouse/issues/8003). [\#8016](https://github.com/ClickHouse/ClickHouse/pull/8016) ([filimonov](https://github.com/filimonov)) +- Başlıklarla sabit formatlar (gibi `CSVWithNames`) tablo motoru için EOF hakkında istisna atıyorlardı `Kafka`. [\#8016](https://github.com/ClickHouse/ClickHouse/pull/8016) ([filimonov](https://github.com/filimonov)) +- Sağ kısmında alt sorgudan set yapma ile bir hata düzeltildi `IN` bölme. Bu düzeltmeler [\#5767](https://github.com/ClickHouse/ClickHouse/issues/5767) ve [\#2542](https://github.com/ClickHouse/ClickHouse/issues/2542). [\#7755](https://github.com/ClickHouse/ClickHouse/pull/7755) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Depolama alanından okurken Olası kazayı düzeltin `File`. [\#7756](https://github.com/ClickHouse/ClickHouse/pull/7756) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Dosyaların sabit okuma `Parquet` tür sütunları içeren biçim `list`. [\#8334](https://github.com/ClickHouse/ClickHouse/pull/8334) ([maxulan](https://github.com/maxulan)) +- Hatayı Düzelt `Not found column` ile dağıtılmış sorgular için `PREWHERE` örnekleme anahtarına bağımlı durum `max_parallel_replicas > 1`. [\#7913](https://github.com/ClickHouse/ClickHouse/pull/7913) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Hatayı Düzelt `Not found column` sorgu kullanılırsa `PREWHERE` tablonun diğer adı ve sonuç kümesi bağımlı birincil anahtar koşulu nedeniyle boştu. [\#7911](https://github.com/ClickHouse/ClickHouse/pull/7911) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Fonksiyonlar için sabit dönüş tipi `rand` ve `randConstant` durumunda `Nullable` değişken. Şimdi fonksiyonlar her zaman geri döner `UInt32` ve asla `Nullable(UInt32)`. [\#8204](https://github.com/ClickHouse/ClickHouse/pull/8204) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Engelli yüklem push-down için `WITH FILL` ifade. Bu düzeltmeler [\#7784](https://github.com/ClickHouse/ClickHouse/issues/7784). [\#7789](https://github.com/ClickHouse/ClickHouse/pull/7789) ([Kış Zhang](https://github.com/zhang2014)) +- Sabit yanlış `count()` res forult for `SummingMergeTree` ne zaman `FINAL` bölüm kullanılır. [\#3280](https://github.com/ClickHouse/ClickHouse/issues/3280) [\#7786](https://github.com/ClickHouse/ClickHouse/pull/7786) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Uzak sunuculardan sabit işlevler için olası yanlış sonucu düzeltin. Gibi işlevlerle sorgular için oldu `version()`, `uptime()` vb. farklı sunucular için farklı sabit değerler döndürür. Bu düzeltmeler [\#7666](https://github.com/ClickHouse/ClickHouse/issues/7666). [\#7689](https://github.com/ClickHouse/ClickHouse/pull/7689) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Yanlış sonuçlara yol açan push-down yüklemi optimizasyonunda karmaşık hatayı düzeltin. Bu, push-down yüklemi optimizasyonu ile ilgili birçok sorunu giderir. [\#8503](https://github.com/ClickHouse/ClickHouse/pull/8503) ([Kış Zhang](https://github.com/zhang2014)) +- Çökmeyi düzeltin `CREATE TABLE .. AS dictionary` sorgu. [\#8508](https://github.com/ClickHouse/ClickHouse/pull/8508) ([Azat Khuzhin](https://github.com/azat)) +- Çeşitli iyileştirmeler clickhouse dilbilgisi `.g4` Dosya. [\#8294](https://github.com/ClickHouse/ClickHouse/pull/8294) ([taiyang-li](https://github.com/taiyang-li)) +- Çökmelere yol açan hatayı düzeltin `JOIN`motorlu tablolar ile s `Join`. Bu düzeltmeler [\#7556](https://github.com/ClickHouse/ClickHouse/issues/7556) [\#8254](https://github.com/ClickHouse/ClickHouse/issues/8254) [\#7915](https://github.com/ClickHouse/ClickHouse/issues/7915) [\#8100](https://github.com/ClickHouse/ClickHouse/issues/8100). [\#8298](https://github.com/ClickHouse/ClickHouse/pull/8298) ([Artem Zuikov](https://github.com/4ertus2)) +- Gereksiz sözlükleri yeniden yükleyin `CREATE DATABASE`. [\#7916](https://github.com/ClickHouse/ClickHouse/pull/7916) ([Azat Khuzhin](https://github.com/azat)) +- Okuma için maksimum akış sayısını sınırlayın `StorageFile` ve `StorageHDFS`. Düzeltmeler https://github.com/ClickHouse/ClickHouse/issues/7650. [\#7981](https://github.com/ClickHouse/ClickHouse/pull/7981) ([alesapin](https://github.com/alesapin)) +- Hatayı düzeltin `ALTER ... MODIFY ... CODEC` sorgu, kullanıcı hem varsayılan ifade hem de codec belirttiğinde. Düzeltiyor [8593](https://github.com/ClickHouse/ClickHouse/issues/8593). [\#8614](https://github.com/ClickHouse/ClickHouse/pull/8614) ([alesapin](https://github.com/alesapin)) +- Sütunların arka plan birleşimindeki hatayı düzeltin `SimpleAggregateFunction(LowCardinality)` tür. [\#8613](https://github.com/ClickHouse/ClickHouse/pull/8613) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Sabit tip kontrol fonksiyonu `toDateTime64`. [\#8375](https://github.com/ClickHouse/ClickHouse/pull/8375) ([Vasily Nemkov](https://github.com/Enmk)) +- Şimdi sunucu üzerinde çökme yok `LEFT` veya `FULL JOIN` ve Birleştirme motoru ve desteklenmeyen `join_use_nulls` ayarlar. [\#8479](https://github.com/ClickHouse/ClickHouse/pull/8479) ([Artem Zuikov](https://github.com/4ertus2)) +- Şimdi `DROP DICTIONARY IF EXISTS db.dict` sorgu, istisna atmıyor `db` yok. [\#8185](https://github.com/ClickHouse/ClickHouse/pull/8185) ([Vitaly Baranov](https://github.com/vitlibar)) +- Tablo işlevlerinde Olası çökmeleri düzeltin (`file`, `mysql`, `remote`) referans kullanımı nedeniyle Kaldır toılan `IStorage` nesne. Tablo işlevine ekleme sırasında belirtilen sütunların yanlış ayrıştırılmasını düzeltin. [\#7762](https://github.com/ClickHouse/ClickHouse/pull/7762) ([tavplubix](https://github.com/tavplubix)) +- Başlamadan önce ağ olun `clickhouse-server`. Bu düzeltmeler [\#7507](https://github.com/ClickHouse/ClickHouse/issues/7507). [\#8570](https://github.com/ClickHouse/ClickHouse/pull/8570) ([Zhichang Yu](https://github.com/yuzhichang)) +- Güvenli bağlantılar için zaman aşımlarını düzeltin, böylece sorgular belirsiz bir şekilde askıda kalmaz. Bu düzeltmeler [\#8126](https://github.com/ClickHouse/ClickHouse/issues/8126). [\#8128](https://github.com/ClickHouse/ClickHouse/pull/8128) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Düzeltmek `clickhouse-copier`'In eşzamanlı işçiler arasındaki gereksiz çekişme. [\#7816](https://github.com/ClickHouse/ClickHouse/pull/7816) ([Ding Xiang Fei](https://github.com/dingxiangfei2009)) +- Şimdi mutasyonlar, mutasyon versiyonları mevcut mutasyon versiyonundan daha büyük olsa bile, ekli parçaları atlamaz. [\#7812](https://github.com/ClickHouse/ClickHouse/pull/7812) ([Zhichang Yu](https://github.com/yuzhichang)) [\#8250](https://github.com/ClickHouse/ClickHouse/pull/8250) ([alesapin](https://github.com/alesapin)) +- Gereksiz kopyaları Yoksay `*MergeTree` başka bir diske ve sunucuya taşındıktan sonra veri parçaları yeniden başlatılır. [\#7810](https://github.com/ClickHouse/ClickHouse/pull/7810) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Çökmeyi düzeltin `FULL JOIN` ile `LowCardinality` içinde `JOIN` anahtar. [\#8252](https://github.com/ClickHouse/ClickHouse/pull/8252) ([Artem Zuikov](https://github.com/4ertus2)) +- Sütun adını birden çok kez ekleme sorgusu gibi kullanmak yasaktır `INSERT INTO tbl (x, y, x)`. Bu düzeltmeler [\#5465](https://github.com/ClickHouse/ClickHouse/issues/5465), [\#7681](https://github.com/ClickHouse/ClickHouse/issues/7681). [\#7685](https://github.com/ClickHouse/ClickHouse/pull/7685) ([alesapin](https://github.com/alesapin)) +- Bilinmeyen CPU'lar için fiziksel CPU çekirdeği sayısını tespit etmek için geri dönüş eklendi (mantıksal CPU çekirdeği sayısını kullanarak). Bu düzeltmeler [\#5239](https://github.com/ClickHouse/ClickHouse/issues/5239). [\#7726](https://github.com/ClickHouse/ClickHouse/pull/7726) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Düzeltmek `There's no column` materialized ve alias sütunlar için hata. [\#8210](https://github.com/ClickHouse/ClickHouse/pull/8210) ([Artem Zuikov](https://github.com/4ertus2)) +- Sabit sever kazasında zaman `EXISTS` sorgu olmadan kullanıldı `TABLE` veya `DICTIONARY` niteleyici. Gibi `EXISTS t`. Bu düzeltmeler [\#8172](https://github.com/ClickHouse/ClickHouse/issues/8172). Bu hata 19.17 sürümünde tanıtıldı. [\#8213](https://github.com/ClickHouse/ClickHouse/pull/8213) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Nadir hatayı hata ile düzeltin `"Sizes of columns doesn't match"` kullanırken bu görünebilir `SimpleAggregateFunction` sütun. [\#7790](https://github.com/ClickHouse/ClickHouse/pull/7790) ([Boris Granveaud](https://github.com/bgranvea)) +- Boş olan kullanıcının bulunduğu hatayı düzeltin `allow_databases` tüm veritabanlarına erişim var (ve aynı `allow_dictionaries`). [\#7793](https://github.com/ClickHouse/ClickHouse/pull/7793) ([DeifyTheGod](https://github.com/DeifyTheGod)) +- Sunucu zaten istemciden bağlantısı kesildiğinde istemci çökmesini düzeltin. [\#8071](https://github.com/ClickHouse/ClickHouse/pull/8071) ([Azat Khuzhin](https://github.com/azat)) +- Düzeltmek `ORDER BY` birincil anahtar öneki ve birincil anahtar soneki ile sıralama durumunda davranış. [\#7759](https://github.com/ClickHouse/ClickHouse/pull/7759) ([Anton Popov](https://github.com/CurtizJ)) +- Tabloda nitelikli sütun mevcut olup olmadığını kontrol edin. Bu düzeltmeler [\#6836](https://github.com/ClickHouse/ClickHouse/issues/6836). [\#7758](https://github.com/ClickHouse/ClickHouse/pull/7758) ([Artem Zuikov](https://github.com/4ertus2)) +- İle sabit davranış `ALTER MOVE` belirtilen birleştirme bitiş hamle superpart hemen sonra koştu. Düzeltiyor [\#8103](https://github.com/ClickHouse/ClickHouse/issues/8103). [\#8104](https://github.com/ClickHouse/ClickHouse/pull/8104) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Kullanırken Olası sunucu çökmesini düzeltin `UNION` farklı sayıda sütun ile. Düzeltiyor [\#7279](https://github.com/ClickHouse/ClickHouse/issues/7279). [\#7929](https://github.com/ClickHouse/ClickHouse/pull/7929) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- İşlev için sonuç alt dizesinin boyutunu düzeltin `substr` negatif boyutu ile. [\#8589](https://github.com/ClickHouse/ClickHouse/pull/8589) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Şimdi server part Mut mutasyonu Yürüt inmüyor `MergeTree` arka plan havuzunda yeterli boş iş parçacığı yoksa. [\#8588](https://github.com/ClickHouse/ClickHouse/pull/8588) ([tavplubix](https://github.com/tavplubix)) +- Biçimlendirmede küçük bir yazım hatası düzeltildi `UNION ALL` AST. [\#7999](https://github.com/ClickHouse/ClickHouse/pull/7999) ([litao91](https://github.com/litao91)) +- Negatif sayılar için sabit yanlış bloom filtre sonuçları. Bu düzeltmeler [\#8317](https://github.com/ClickHouse/ClickHouse/issues/8317). [\#8566](https://github.com/ClickHouse/ClickHouse/pull/8566) ([Kış Zhang](https://github.com/zhang2014)) +- Sıkıştırmada sabit potansiyel tampon taşması. Kötü niyetli kullanıcı, arabellekten sonra okunmasına neden olacak sıkıştırılmış verileri iletebilir. Bu sorun Yandex bilgi güvenliği ekibinden Eldar Zaitov tarafından bulundu. [\#8404](https://github.com/ClickHouse/ClickHouse/pull/8404) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Tamsayılar taşması nedeniyle yanlış sonucu düzeltin `arrayIntersect`. [\#7777](https://github.com/ClickHouse/ClickHouse/pull/7777) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Şimdi `OPTIMIZE TABLE` sorgu işlemi gerçekleştirmek çevrimdışı yinelemeler için beklemez. [\#8314](https://github.com/ClickHouse/ClickHouse/pull/8314) ([javi santana](https://github.com/javisantana)) +- Sabit `ALTER TTL` par forser for `Replicated*MergeTree` Tablolar. [\#8318](https://github.com/ClickHouse/ClickHouse/pull/8318) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Sunucu ve istemci arasındaki iletişimi düzeltin, böylece sunucu sorgu hatasından sonra geçici tablolar bilgilerini okur. [\#8084](https://github.com/ClickHouse/ClickHouse/pull/8084) ([Azat Khuzhin](https://github.com/azat)) +- Düzeltmek `bitmapAnd` birleştirilmiş bir bit eşlem ve bir skaler bit eşlem kesişen işlev hatası. [\#8082](https://github.com/ClickHouse/ClickHouse/pull/8082) ([Yue Huang](https://github.com/moon03432)) +- Tanımı rafine `ZXid` hata düzeltmeleri ZooKeeper programcı Kılavuzu göre `clickhouse-cluster-copier`. [\#8088](https://github.com/ClickHouse/ClickHouse/pull/8088) ([Ding Xiang Fei](https://github.com/dingxiangfei2009)) +- `odbc` tablo fonksiyonu şimdi saygı `external_table_functions_use_nulls` ayar. [\#7506](https://github.com/ClickHouse/ClickHouse/pull/7506) ([Vasily Nemkov](https://github.com/Enmk)) +- Nadir bir veri yarışına yol açan Sabit hata. [\#8143](https://github.com/ClickHouse/ClickHouse/pull/8143) ([Alexander Kazakov](https://github.com/Akazz)) +- Şimdi `SYSTEM RELOAD DICTIONARY` göz ardı ederek bir sözlüğü tamamen yeniden yükler `update_field`. Bu düzeltmeler [\#7440](https://github.com/ClickHouse/ClickHouse/issues/7440). [\#8037](https://github.com/ClickHouse/ClickHouse/pull/8037) ([Vitaly Baranov](https://github.com/vitlibar)) +- Sözlüğün sorgu oluştur'da olup olmadığını kontrol etme yeteneği ekleyin. [\#8032](https://github.com/ClickHouse/ClickHouse/pull/8032) ([alesapin](https://github.com/alesapin)) +- Düzeltmek `Float*` ayrıştırma `Values` biçimli. Bu düzeltmeler [\#7817](https://github.com/ClickHouse/ClickHouse/issues/7817). [\#7870](https://github.com/ClickHouse/ClickHouse/pull/7870) ([tavplubix](https://github.com/tavplubix)) +- Bazı arka plan işlemlerinde yer ayıramadığımızda çökmeyi düzeltin `*MergeTree` masa motorları ailesi. [\#7873](https://github.com/ClickHouse/ClickHouse/pull/7873) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Tablo içerdiğinde birleştirme işleminin çökmesini düzeltin `SimpleAggregateFunction(LowCardinality)` sütun. Bu düzeltmeler [\#8515](https://github.com/ClickHouse/ClickHouse/issues/8515). [\#8522](https://github.com/ClickHouse/ClickHouse/pull/8522) ([Azat Khuzhin](https://github.com/azat)) +- Tüm YBÜ yerel destek geri yükleme ve sabit ifadeler için harmanlama uygulamak için yeteneği ekleyin. Ayrıca dil adı ekleyin `system.collations` Tablo. [\#8051](https://github.com/ClickHouse/ClickHouse/pull/8051) ([alesapin](https://github.com/alesapin)) +- Sıfır minimum ömrü olan harici sözlükler olduğunda hatayı düzeltin (`LIFETIME(MIN 0 MAX N)`, `LIFETIME(N)`) arka planda güncelleme yapmayın. [\#7983](https://github.com/ClickHouse/ClickHouse/pull/7983) ([alesapin](https://github.com/alesapin)) +- ClickHouse kaynağı ile harici sözlük sorguda alt sorgu olduğunda çökmesini düzeltin. [\#8351](https://github.com/ClickHouse/ClickHouse/pull/8351) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Motor ile tablodaki dosya uzantısının yanlış ayrıştırılmasını düzeltin `URL`. Bu düzeltmeler [\#8157](https://github.com/ClickHouse/ClickHouse/issues/8157). [\#8419](https://github.com/ClickHouse/ClickHouse/pull/8419) ([Andrey Bodrov](https://github.com/apbodrov)) +- Düzeltmek `CHECK TABLE` sorgu için `*MergeTree` anahtarsız tablolar. Düzeltiyor [\#7543](https://github.com/ClickHouse/ClickHouse/issues/7543). [\#7979](https://github.com/ClickHouse/ClickHouse/pull/7979) ([alesapin](https://github.com/alesapin)) +- Sabit dönüşüm `Float64` MySQL türü için. [\#8079](https://github.com/ClickHouse/ClickHouse/pull/8079) ([Yuriy Baranov](https://github.com/yurriy)) +- Şimdi Eğer tablo tamamen sunucu çökmesi nedeniyle düştü değildi, sunucu geri yüklemek ve yüklemek için çalışacağız. [\#8176](https://github.com/ClickHouse/ClickHouse/pull/8176) ([tavplubix](https://github.com/tavplubix)) +- Tablo işlevinde sabit çökme `file` mevcut olmayan dosyaya eklerken. Şimdi bu durumda dosya oluşturulur ve daha sonra insert işlenir. [\#8177](https://github.com/ClickHouse/ClickHouse/pull/8177) ([Olga Khvostikova](https://github.com/stavrolia)) +- Ne zaman olabilir nadir kilitlenme Fix `trace_log` etkin olduğunu. [\#7838](https://github.com/ClickHouse/ClickHouse/pull/7838) ([filimonov](https://github.com/filimonov)) +- Yanında farklı türleri ile çalışmak için yeteneği ekleyin `Date` içinde `RangeHashed` DDL sorgusundan oluşturulan dış sözlük. Düzeltiyor [7899](https://github.com/ClickHouse/ClickHouse/issues/7899). [\#8275](https://github.com/ClickHouse/ClickHouse/pull/8275) ([alesapin](https://github.com/alesapin)) +- Düzeltmeler çökme zaman `now64()` başka bir işlevin sonucu ile çağrılır. [\#8270](https://github.com/ClickHouse/ClickHouse/pull/8270) ([Vasily Nemkov](https://github.com/Enmk)) +- Mysql Tel protokolü üzerinden bağlantılar için istemci IP tespit ile Sabit hata. [\#7743](https://github.com/ClickHouse/ClickHouse/pull/7743) ([Dmitry Muzyka](https://github.com/dmitriy-myz)) +- Boş dizi işlemeyi düzeltin `arraySplit` işlev. Bu düzeltmeler [\#7708](https://github.com/ClickHouse/ClickHouse/issues/7708). [\#7747](https://github.com/ClickHouse/ClickHouse/pull/7747) ([hcz](https://github.com/hczhcz)) +- Sorunu ne zaman düzeltildi `pid-file` başka bir koşu `clickhouse-server` silinebilir. [\#8487](https://github.com/ClickHouse/ClickHouse/pull/8487) ([Weiqing Xu](https://github.com/weiqxu)) +- Varsa sözlük yeniden yükle `invalidate_query`, güncellemeleri durdurdu ve önceki güncelleme denemelerinde bazı istisnalar. [\#8029](https://github.com/ClickHouse/ClickHouse/pull/8029) ([alesapin](https://github.com/alesapin)) +- Fonksiyonda Sabit hata `arrayReduce` bu yol açabilir “double free” ve toplu işlev birleştiricisinde hata `Resample` bu bellek sızıntısına neden olabilir. Toplama fonksiyonu eklendi `aggThrow`. Bu fonksiyon test amaçlı kullanılabilir. [\#8446](https://github.com/ClickHouse/ClickHouse/pull/8446) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Geliştirme {#improvement-1} + +- İle çalışırken geliştirilmiş günlük kaydı `S3` masa motoru. [\#8251](https://github.com/ClickHouse/ClickHouse/pull/8251) ([Grigory Pervakov](https://github.com/GrigoryPervakov)) +- Çağrılırken hiçbir bağımsız değişken geçirildiğinde yazdırılan yardım iletisi `clickhouse-local`. Bu düzeltmeler [\#5335](https://github.com/ClickHouse/ClickHouse/issues/5335). [\#8230](https://github.com/ClickHouse/ClickHouse/pull/8230) ([Andrey Nagorny](https://github.com/Melancholic)) +- Ayar Ekle `mutations_sync` hangi beklemek sağlar `ALTER UPDATE/DELETE` eşzamanlı sorgular. [\#8237](https://github.com/ClickHouse/ClickHouse/pull/8237) ([alesapin](https://github.com/alesapin)) +- Göreli ayarlamak için izin ver `user_files_path` içinde `config.xml` (bir şekilde benzer `format_schema_path`). [\#7632](https://github.com/ClickHouse/ClickHouse/pull/7632) ([hcz](https://github.com/hczhcz)) +- Dönüştürme işlevleri için yasadışı türler için istisna Ekle `-OrZero` postfix. [\#7880](https://github.com/ClickHouse/ClickHouse/pull/7880) ([Andrey Konyaev](https://github.com/akonyaev90)) +- Bir dağıtılmış sorgu bir parça için veri gönderme başlığındaki kolay bir biçim. [\#8044](https://github.com/ClickHouse/ClickHouse/pull/8044) ([Vitaly Baranov](https://github.com/vitlibar)) +- `Live View` tablo motoru refactoring. [\#8519](https://github.com/ClickHouse/ClickHouse/pull/8519) ([vzakaznikov](https://github.com/vzakaznikov)) +- DDL sorgularından oluşturulan dış sözlükler için ek kontroller ekleyin. [\#8127](https://github.com/ClickHouse/ClickHouse/pull/8127) ([alesapin](https://github.com/alesapin)) +- Hatayı Düzelt `Column ... already exists` kullanırken `FINAL` ve `SAMPLE` together, e.g. `select count() from table final sample 1/2`. Düzeltiyor [\#5186](https://github.com/ClickHouse/ClickHouse/issues/5186). [\#7907](https://github.com/ClickHouse/ClickHouse/pull/7907) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Şimdi tablo ilk argüman `joinGet` fonksiyon tablo indentifier olabilir. [\#7707](https://github.com/ClickHouse/ClickHouse/pull/7707) ([Amos Kuşu](https://github.com/amosbird)) +- Kullanmaya izin ver `MaterializedView` yukarıdaki alt sorgularla `Kafka` Tablolar. [\#8197](https://github.com/ClickHouse/ClickHouse/pull/8197) ([filimonov](https://github.com/filimonov)) +- Şimdi arka plan diskler arasında hareket eder, seprate iş parçacığı havuzunu çalıştırır. [\#7670](https://github.com/ClickHouse/ClickHouse/pull/7670) ([Vladimir Chebotarev](https://github.com/excitoon)) +- `SYSTEM RELOAD DICTIONARY` şimdi eşzamanlı olarak yürütür. [\#8240](https://github.com/ClickHouse/ClickHouse/pull/8240) ([Vitaly Baranov](https://github.com/vitlibar)) +- Yığın izleri artık sanal bellek adresleri yerine (nesne dosyasının yüklendiği) fiziksel adresleri (nesne dosyasındaki uzaklıklar) görüntüler. Bu kullanımına izin verir `addr2line` ikili konum bağımsız ve ASLR etkin olduğunda. Bu düzeltmeler [\#8360](https://github.com/ClickHouse/ClickHouse/issues/8360). [\#8387](https://github.com/ClickHouse/ClickHouse/pull/8387) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Satır düzeyinde güvenlik filtreleri için yeni sözdizimi desteği: `
…
`. Düzeltiyor [\#5779](https://github.com/ClickHouse/ClickHouse/issues/5779). [\#8381](https://github.com/ClickHouse/ClickHouse/pull/8381) ([I ivanvan](https://github.com/abyss7)) +- Şimdi `cityHash` fonksiyonu ile çalışabilir `Decimal` ve `UUID` türler. Düzeltiyor [\#5184](https://github.com/ClickHouse/ClickHouse/issues/5184). [\#7693](https://github.com/ClickHouse/ClickHouse/pull/7693) ([Mikhail Korotov](https://github.com/millb)) +- Uyarlanabilir tanecikliliğin uygulanmasından sonra eskimiş olduğu için sistem günlüklerinden sabit dizin tanecikliliği (1024 idi) kaldırıldı. [\#7698](https://github.com/ClickHouse/ClickHouse/pull/7698) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- ClickHouse SSL olmadan derlendiğinde etkin MySQL uyumluluk sunucusu. [\#7852](https://github.com/ClickHouse/ClickHouse/pull/7852) ([Yuriy Baranov](https://github.com/yurriy)) +- Şimdi sunucu sağlama toplamları toplu halde bozuk veri durumunda daha ayrıntılı hatalar veren partiler dağıttı. [\#7914](https://github.com/ClickHouse/ClickHouse/pull/7914) ([Azat Khuzhin](https://github.com/azat)) +- Destek `DROP DATABASE`, `DETACH TABLE`, `DROP TABLE` ve `ATTACH TABLE` için `MySQL` veritabanı motoru. [\#8202](https://github.com/ClickHouse/ClickHouse/pull/8202) ([Kış Zhang](https://github.com/zhang2014)) +- S3 tablo fonksiyonu ve tablo motoru kimlik doğrulama ekleyin. [\#7623](https://github.com/ClickHouse/ClickHouse/pull/7623) ([Vladimir Chebotarev](https://github.com/excitoon)) +- İlave parçalar için kontrol eklendi `MergeTree` farklı disklerde, tanımlanmamış disklerdeki veri parçalarını kaçırmamak için. [\#8118](https://github.com/ClickHouse/ClickHouse/pull/8118) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Mac istemci ve sunucu için SSL desteğini etkinleştirin. [\#8297](https://github.com/ClickHouse/ClickHouse/pull/8297) ([I ivanvan](https://github.com/abyss7)) +- Şimdi ClickHouse MySQL Federe sunucu olarak çalışabilir (bkz https://dev.mysql.com/doc/refman/5.7/en/federated-create-server.html). [\#7717](https://github.com/ClickHouse/ClickHouse/pull/7717) ([Maxim Fedotov](https://github.com/MaxFedotov)) +- `clickhouse-client` şimdi sadece etkinleştir `bracketed-paste` multiquery açık ve çok satırlı kapalı olduğunda. Bu düzeltmeler (\#7757) \[https://github.com/ClickHouse/ClickHouse/issues/7757\]. [\#7761](https://github.com/ClickHouse/ClickHouse/pull/7761) ([Amos Kuşu](https://github.com/amosbird)) +- Destek `Array(Decimal)` içinde `if` işlev. [\#7721](https://github.com/ClickHouse/ClickHouse/pull/7721) ([Artem Zuikov](https://github.com/4ertus2)) +- Destek ondalık `arrayDifference`, `arrayCumSum` ve `arrayCumSumNegative` işlevler. [\#7724](https://github.com/ClickHouse/ClickHouse/pull/7724) ([Artem Zuikov](https://github.com/4ertus2)) +- Katma `lifetime` sütun için `system.dictionaries` Tablo. [\#6820](https://github.com/ClickHouse/ClickHouse/issues/6820) [\#7727](https://github.com/ClickHouse/ClickHouse/pull/7727) ([kekekule](https://github.com/kekekekule)) +- İçin farklı disklerde mevcut parçalar için geliştirilmiş kontrol `*MergeTree` masa motorları. Kur [\#7660](https://github.com/ClickHouse/ClickHouse/issues/7660). [\#8440](https://github.com/ClickHouse/ClickHouse/pull/8440) ([Vladimir Chebotarev](https://github.com/excitoon)) +- İle entegrasyon `AWS SDK` için `S3` tüm S3 özelliklerini kutudan çıkarmaya izin veren etkileşimler. [\#8011](https://github.com/ClickHouse/ClickHouse/pull/8011) ([Pavel Kovalenko](https://github.com/Jokser)) +- Alt sorgular için destek eklendi `Live View` Tablolar. [\#7792](https://github.com/ClickHouse/ClickHouse/pull/7792) ([vzakaznikov](https://github.com/vzakaznikov)) +- Kullanmak için kontrol edin `Date` veya `DateTime` sütun fromundan `TTL` ifadeler kaldırıldı. [\#7920](https://github.com/ClickHouse/ClickHouse/pull/7920) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Disk hakkında bilgi eklendi `system.detached_parts` Tablo. [\#7833](https://github.com/ClickHouse/ClickHouse/pull/7833) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Şimdi ayarlar `max_(table|partition)_size_to_drop` yeniden başlatma olmadan değiştirilebilir. [\#7779](https://github.com/ClickHouse/ClickHouse/pull/7779) ([Grigory Pervakov](https://github.com/GrigoryPervakov)) +- Hata mesajlarının biraz daha iyi kullanılabilirliği. Kullanıcıdan aşağıdaki satırları kaldırmamasını isteyin `Stack trace:`. [\#7897](https://github.com/ClickHouse/ClickHouse/pull/7897) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Daha iyi okuma mesajları `Kafka` sonra çeşitli biçim enginelerde motor [\#7935](https://github.com/ClickHouse/ClickHouse/issues/7935). [\#8035](https://github.com/ClickHouse/ClickHouse/pull/8035) ([I ivanvan](https://github.com/abyss7)) +- Desteklemeyen MySQL istemcileri ile daha iyi uyumluluk `sha2_password` auth eklentisi. [\#8036](https://github.com/ClickHouse/ClickHouse/pull/8036) ([Yuriy Baranov](https://github.com/yurriy)) +- MySQL uyumluluk sunucusunda daha fazla sütun türünü destekleyin. [\#7975](https://github.com/ClickHouse/ClickHouse/pull/7975) ([Yuriy Baranov](https://github.com/yurriy)) +- Uygulamak `ORDER BY` için optimizasyon `Merge`, `Buffer` ve `Materilized View` altta yatan depolar `MergeTree` Tablolar. [\#8130](https://github.com/ClickHouse/ClickHouse/pull/8130) ([Anton Popov](https://github.com/CurtizJ)) +- Şimdi her zaman POSIX uygulamasını kullanıyoruz `getrandom` eski çekirdeklerle daha iyi uyumluluğa sahip olmak (\<3.17). [\#7940](https://github.com/ClickHouse/ClickHouse/pull/7940) ([Amos Kuşu](https://github.com/amosbird)) +- Bir hareket TTL kuralında geçerli hedef için daha iyi kontrol edin. [\#8410](https://github.com/ClickHouse/ClickHouse/pull/8410) ([Vladimir Chebotarev](https://github.com/excitoon)) +- Kırık ekleme partileri için daha iyi kontroller `Distributed` masa motoru. [\#7933](https://github.com/ClickHouse/ClickHouse/pull/7933) ([Azat Khuzhin](https://github.com/azat)) +- Gelecekte işlem mustesi gereken parça adı diz ofisiyle sütun ekleme `system.mutations` Tablo. [\#8179](https://github.com/ClickHouse/ClickHouse/pull/8179) ([alesapin](https://github.com/alesapin)) +- İşlemciler için paralel birleştirme sıralama optimizasyonu. [\#8552](https://github.com/ClickHouse/ClickHouse/pull/8552) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Ayar `mark_cache_min_lifetime` artık eskimiş ve hiçbir şey yapmıyor. Önceki sürümlerde, Mark cache bellek daha büyük büyüyebilir `mark_cache_size` içinde veri karşılamak için `mark_cache_min_lifetime` ikincilikler. Bu, karışıklığa ve beklenenden daha yüksek bellek kullanımına yol açıyordu, bu özellikle bellek kısıtlı sistemlerde kötüydü. Bu sürümü yükledikten sonra performans düşüşü görecekseniz, `mark_cache_size`. [\#8484](https://github.com/ClickHouse/ClickHouse/pull/8484) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kullanıma hazırlık `tid` her yerde. Bu için gereklidir [\#7477](https://github.com/ClickHouse/ClickHouse/issues/7477). [\#8276](https://github.com/ClickHouse/ClickHouse/pull/8276) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +#### Performans İyileştirme {#performance-improvement-1} + +- İşlemciler boru hattında performans iyileştirmeleri. [\#7988](https://github.com/ClickHouse/ClickHouse/pull/7988) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Önbellek sözlüklerinde süresi dolmuş anahtarların engellenmeyen güncellemeleri (eskileri okuma izni ile). [\#8303](https://github.com/ClickHouse/ClickHouse/pull/8303) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Olmadan ClickHouse derlemek `-fno-omit-frame-pointer` küresel bir daha kayıt yedek. [\#8097](https://github.com/ClickHouse/ClickHouse/pull/8097) ([Amos Kuşu](https://github.com/amosbird)) +- Hızlanma `greatCircleDistance` fonksiyon ve bunun için performans testleri ekleyin. [\#7307](https://github.com/ClickHouse/ClickHouse/pull/7307) ([Olga Khvostikova](https://github.com/stavrolia)) +- Fonksiyonun geliştirilmiş performansı `roundDown`. [\#8465](https://github.com/ClickHouse/ClickHouse/pull/8465) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Geliştirilmiş performans `max`, `min`, `argMin`, `argMax` için `DateTime64` veri türü. [\#8199](https://github.com/ClickHouse/ClickHouse/pull/8199) ([Vasily Nemkov](https://github.com/Enmk)) +- Bir sınırı olmadan veya büyük sınırı ve dış sıralama ile sıralama geliştirilmiş performans. [\#8545](https://github.com/ClickHouse/ClickHouse/pull/8545) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kayan nokta sayılarını 6 kata kadar biçimlendirmenin geliştirilmiş performansı. [\#8542](https://github.com/ClickHouse/ClickHouse/pull/8542) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Geliştirilmiş performans `modulo` işlev. [\#7750](https://github.com/ClickHouse/ClickHouse/pull/7750) ([Amos Kuşu](https://github.com/amosbird)) +- Optimum `ORDER BY` ve tek sütun tuşu ile birleştirme. [\#8335](https://github.com/ClickHouse/ClickHouse/pull/8335) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İçin daha iyi uygulama `arrayReduce`, `-Array` ve `-State` birleştiriciler. [\#7710](https://github.com/ClickHouse/ClickHouse/pull/7710) ([Amos Kuşu](https://github.com/amosbird)) +- Şimdi `PREWHERE` olarak en az verimli olacak şekilde optimize edilmelidir `WHERE`. [\#7769](https://github.com/ClickHouse/ClickHouse/pull/7769) ([Amos Kuşu](https://github.com/amosbird)) +- Yolu geliştirmek `round` ve `roundBankers` negatif sayılar işleme. [\#8229](https://github.com/ClickHouse/ClickHouse/pull/8229) ([hcz](https://github.com/hczhcz)) +- Geliştirilmiş çözme performansı `DoubleDelta` ve `Gorilla` codec bileşenleri yaklaşık %30-40 oranında. Bu düzeltmeler [\#7082](https://github.com/ClickHouse/ClickHouse/issues/7082). [\#8019](https://github.com/ClickHouse/ClickHouse/pull/8019) ([Vasily Nemkov](https://github.com/Enmk)) +- Geliştirilmiş performans `base64` ilgili fonksiyonlar. [\#8444](https://github.com/ClickHouse/ClickHouse/pull/8444) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Bir işlev eklendi `geoDistance`. Bu benzer `greatCircleDistance` ancak wgs-84 elipsoid modeline yaklaşım kullanır. Her iki fonksiyonun performansı da aynıdır. [\#8086](https://github.com/ClickHouse/ClickHouse/pull/8086) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Hızla `min` ve `max` için toplama fonksiyonları `Decimal` veri türü. [\#8144](https://github.com/ClickHouse/ClickHouse/pull/8144) ([Artem Zuikov](https://github.com/4ertus2)) +- Vectorize işleme `arrayReduce`. [\#7608](https://github.com/ClickHouse/ClickHouse/pull/7608) ([Amos Kuşu](https://github.com/amosbird)) +- `if` zincirler şimdi olarak optimize edilmiştir `multiIf`. [\#8355](https://github.com/ClickHouse/ClickHouse/pull/8355) ([kamalov-ruslan](https://github.com/kamalov-ruslan)) +- Performans gerilemesini düzeltin `Kafka` masa motoru 19.15'te tanıtıldı. Bu düzeltmeler [\#7261](https://github.com/ClickHouse/ClickHouse/issues/7261). [\#7935](https://github.com/ClickHouse/ClickHouse/pull/7935) ([filimonov](https://github.com/filimonov)) +- Kaldırıyordu “pie” kod üretimi `gcc` Debian paketlerinden bazen varsayılan olarak getirir. [\#8483](https://github.com/ClickHouse/ClickHouse/pull/8483) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Paralel ayrıştırma veri formatları [\#6553](https://github.com/ClickHouse/ClickHouse/pull/6553) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)) +- Optimize edilmiş ayrıştırıcıyı etkinleştir `Values` varsayılan olarak ifadelerle (`input_format_values_deduce_templates_of_expressions=1`). [\#8231](https://github.com/ClickHouse/ClickHouse/pull/8231) ([tavplubix](https://github.com/tavplubix)) + +#### Yapı / Test / Ambalaj Geliştirme {#buildtestingpackaging-improvement-2} + +- İçin düzeltmeler oluşturun `ARM` ve minimal modda. [\#8304](https://github.com/ClickHouse/ClickHouse/pull/8304) ([proller](https://github.com/proller)) +- İçin kapsama dosyası Ekle `clickhouse-server` std:: atexit çağrılmadığında. Ayrıca kapsama ile vatansız testlerde biraz geliştirilmiş günlüğü. [\#8267](https://github.com/ClickHouse/ClickHouse/pull/8267) ([alesapin](https://github.com/alesapin)) +- Contrib'de llvm kütüphanesini güncelleyin. OS paketlerinden LLVM kullanmaktan kaçının. [\#8258](https://github.com/ClickHouse/ClickHouse/pull/8258) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Paket yapmak `curl` tamamen sessiz inşa. [\#8232](https://github.com/ClickHouse/ClickHouse/pull/8232) [\#8203](https://github.com/ClickHouse/ClickHouse/pull/8203) ([Pavel Kovalenko](https://github.com/Jokser)) +- Bazı düzeltmek `MemorySanitizer` uyarmalar. [\#8235](https://github.com/ClickHouse/ClickHouse/pull/8235) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Kullanmak `add_warning` ve `no_warning` makro inlar içinde `CMakeLists.txt`. [\#8604](https://github.com/ClickHouse/ClickHouse/pull/8604) ([I ivanvan](https://github.com/abyss7)) +- Minio S3 uyumlu nesne desteği ekleyin (https://min.io/) daha iyi entegrasyon testleri için. [\#7863](https://github.com/ClickHouse/ClickHouse/pull/7863) [\#7875](https://github.com/ClickHouse/ClickHouse/pull/7875) ([Pavel Kovalenko](https://github.com/Jokser)) +- İthal `libc` başlıklar contrib için. Oluşturur daha tutarlı (sadece için çeşitli sistemler üzerinde yapmak için izin verir `x86_64-linux-gnu`). [\#5773](https://github.com/ClickHouse/ClickHouse/pull/5773) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kaldırmak `-fPIC` bazı kütüphanelerden. [\#8464](https://github.com/ClickHouse/ClickHouse/pull/8464) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Temizlemek `CMakeLists.txt` kıvırmak için. Bkz. https://github.com/ClickHouse/ClickHouse/pull/8011\#issuecomment-569478910 [\#8459](https://github.com/ClickHouse/ClickHouse/pull/8459) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sessiz uyarılar `CapNProto` kitaplık. [\#8220](https://github.com/ClickHouse/ClickHouse/pull/8220) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kısa dize optimize karma tablolar için performans testleri ekleyin. [\#7679](https://github.com/ClickHouse/ClickHouse/pull/7679) ([Amos Kuşu](https://github.com/amosbird)) +- Şimdi ClickHouse üzerine inşa edecek `AArch64` bile `MADV_FREE` kullanılamaz. Bu düzeltmeler [\#8027](https://github.com/ClickHouse/ClickHouse/issues/8027). [\#8243](https://github.com/ClickHouse/ClickHouse/pull/8243) ([Amos Kuşu](https://github.com/amosbird)) +- Güncelleştirme `zlib-ng` bellek dezenfektanı sorunları düzeltmek için. [\#7182](https://github.com/ClickHouse/ClickHouse/pull/7182) [\#8206](https://github.com/ClickHouse/ClickHouse/pull/8206) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Linux olmayan sistemde dahili MySQL kütüphanesini etkinleştirin, çünkü OS paketlerinin kullanımı çok kırılgandır ve genellikle hiç çalışmaz. Bu düzeltmeler [\#5765](https://github.com/ClickHouse/ClickHouse/issues/5765). [\#8426](https://github.com/ClickHouse/ClickHouse/pull/8426) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Etkinleştirildikten sonra bazı sistemlerde sabit yapı `libc++`. Bu yerini alır [\#8374](https://github.com/ClickHouse/ClickHouse/issues/8374). [\#8380](https://github.com/ClickHouse/ClickHouse/pull/8380) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yapmak `Field` yöntemleri daha fazla tür-daha fazla hata bulmak için güvenli. [\#7386](https://github.com/ClickHouse/ClickHouse/pull/7386) [\#8209](https://github.com/ClickHouse/ClickHouse/pull/8209) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Eksik dosyalar eklendi `libc-headers` alt modül. [\#8507](https://github.com/ClickHouse/ClickHouse/pull/8507) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yanlış Düzelt `JSON` performans testi çıktısında alıntı. [\#8497](https://github.com/ClickHouse/ClickHouse/pull/8497) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Şimdi yığın izleme için görüntülenir `std::exception` ve `Poco::Exception`. Önceki sürümlerde sadece mevcuttu `DB::Exception`. Bu teşhis geliştirir. [\#8501](https://github.com/ClickHouse/ClickHouse/pull/8501) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Taşıma `clock_gettime` ve `clock_nanosleep` taze glibc sürümleri için. [\#8054](https://github.com/ClickHouse/ClickHouse/pull/8054) ([Amos Kuşu](https://github.com/amosbird)) +- Etkinleştirmek `part_log` geliştiriciler için örnek yapılandırmada. [\#8609](https://github.com/ClickHouse/ClickHouse/pull/8609) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yeniden yüklemenin async doğasını düzeltin `01036_no_superfluous_dict_reload_on_create_database*`. [\#8111](https://github.com/ClickHouse/ClickHouse/pull/8111) ([Azat Khuzhin](https://github.com/azat)) +- Sabit codec performans testleri. [\#8615](https://github.com/ClickHouse/ClickHouse/pull/8615) ([Vasily Nemkov](https://github.com/Enmk)) +- İçin yükleme s scriptscript addleri Ekle `.tgz` onlar için yapı ve belgeler. [\#8612](https://github.com/ClickHouse/ClickHouse/pull/8612) [\#8591](https://github.com/ClickHouse/ClickHouse/pull/8591) ([alesapin](https://github.com/alesapin)) +- Eski kaldırıldı `ZSTD` test (2016 yılında zstd'nin 1.0 sürümünün olduğu hatayı yeniden üretmek için oluşturuldu). Bu düzeltmeler [\#8618](https://github.com/ClickHouse/ClickHouse/issues/8618). [\#8619](https://github.com/ClickHouse/ClickHouse/pull/8619) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Mac OS Catalina üzerinde sabit yapı. [\#8600](https://github.com/ClickHouse/ClickHouse/pull/8600) ([meo](https://github.com/meob)) +- Sonuç fark yapmak için codec performans testlerinde satır sayısı arttı. [\#8574](https://github.com/ClickHouse/ClickHouse/pull/8574) ([Vasily Nemkov](https://github.com/Enmk)) +- Hata ayıklama yapılarında, tedavi `LOGICAL_ERROR` onaylama işlemi hatası gibi özel durumlar, dikkat kolaylaştırmak. [\#8475](https://github.com/ClickHouse/ClickHouse/pull/8475) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Biçimlerle ilgili performans testini daha deterministik hale getirin. [\#8477](https://github.com/ClickHouse/ClickHouse/pull/8477) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Güncelleştirme `lz4` bir hafızayı düzeltmek İçinvatandaş arızası. [\#8181](https://github.com/ClickHouse/ClickHouse/pull/8181) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Bilinen bir MemorySanitizer yanlış pozitif özel durum işleme bastırın. [\#8182](https://github.com/ClickHouse/ClickHouse/pull/8182) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Güncelleştirme `gcc` ve `g++` sürüm 9 için `build/docker/build.sh` [\#7766](https://github.com/ClickHouse/ClickHouse/pull/7766) ([TLightSky](https://github.com/tlightsky)) +- Bunu test etmek için performans testi örneği ekleyin `PREWHERE` daha kötü `WHERE`. [\#7768](https://github.com/ClickHouse/ClickHouse/pull/7768) ([Amos Kuşu](https://github.com/amosbird)) +- Bir gevşek testi düzeltmek için ilerleme. [\#8621](https://github.com/ClickHouse/ClickHouse/pull/8621) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Veri için MemorySanitizer raporundan kaçının `libunwind`. [\#8539](https://github.com/ClickHouse/ClickHouse/pull/8539) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Güncel `libc++` en son sürüme. [\#8324](https://github.com/ClickHouse/ClickHouse/pull/8324) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Kaynaklardan YBÜ Kütüphanesi oluşturun. Bu düzeltmeler [\#6460](https://github.com/ClickHouse/ClickHouse/issues/6460). [\#8219](https://github.com/ClickHouse/ClickHouse/pull/8219) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Anahtar fromlı `libressl` -e doğru `openssl`. ClickHouse, bu değişiklikten sonra TLS 1.3 ve SNI'Yİ desteklemelidir. Bu düzeltmeler [\#8171](https://github.com/ClickHouse/ClickHouse/issues/8171). [\#8218](https://github.com/ClickHouse/ClickHouse/pull/8218) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Sabit UBSan raporu kullanırken `chacha20_poly1305` SS SSLL ('den (Bağlan (ış happensta olur https://yandex.ru/). [\#8214](https://github.com/ClickHouse/ClickHouse/pull/8214) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İçin varsayılan şifre dosyasının düzeltme modu `.deb` linux dağıtımları. [\#8075](https://github.com/ClickHouse/ClickHouse/pull/8075) ([proller](https://github.com/proller)) +- Almak için geliştirilmiş ifade `clickhouse-server` Pidıd ın `clickhouse-test`. [\#8063](https://github.com/ClickHouse/ClickHouse/pull/8063) ([Alexander Kazakov](https://github.com/Akazz)) +- V1.10.0 için contrib/googletest güncellendi. [\#8587](https://github.com/ClickHouse/ClickHouse/pull/8587) ([Alexander Burmak](https://github.com/Alex-Burmak)) +- Sabit ThreadSaninitizer raporu `base64` kitaplık. Ayrıca bu kütüphaneyi en son sürüme güncelledi, ancak önemli değil. Bu düzeltmeler [\#8397](https://github.com/ClickHouse/ClickHouse/issues/8397). [\#8403](https://github.com/ClickHouse/ClickHouse/pull/8403) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Düzeltmek `00600_replace_running_query` işlemciler için. [\#8272](https://github.com/ClickHouse/ClickHouse/pull/8272) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- İçin destek Kaldır `tcmalloc` yapmak `CMakeLists.txt` basit. [\#8310](https://github.com/ClickHouse/ClickHouse/pull/8310) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yayın gcc şimdi kullanmak oluşturur `libc++` yerine `libstdc++`. Son zamanlarda `libc++` sadece clang ile kullanıldı. Bu yapı yapılandırmaları ve taşınabilirlik tutarlılığını artıracaktır. [\#8311](https://github.com/ClickHouse/ClickHouse/pull/8311) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- MemorySanitizer ile inşa etmek için YBÜ kütüphanesini etkinleştirin. [\#8222](https://github.com/ClickHouse/ClickHouse/pull/8222) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Gelen uyarıları bastır `CapNProto` kitaplık. [\#8224](https://github.com/ClickHouse/ClickHouse/pull/8224) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- İçin özel kod durumları kaldırıldı `tcmalloc`, çünkü artık desteklenmiyor. [\#8225](https://github.com/ClickHouse/ClickHouse/pull/8225) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- CI kapsama görevinde, kapsama raporunu kaydetmesine izin vermek için sunucuyu incelikle öldürün. Bu, son zamanlarda gördüğümüz eksik kapsama raporlarını düzeltir. [\#8142](https://github.com/ClickHouse/ClickHouse/pull/8142) ([alesapin](https://github.com/alesapin)) +- Karşı tüm codec bileşenleri için performans testleri `Float64` ve `UInt64` değerler. [\#8349](https://github.com/ClickHouse/ClickHouse/pull/8349) ([Vasily Nemkov](https://github.com/Enmk)) +- `termcap` (f çeşitli sorunlar için çok kaldırılmış ve kurşundur.g. eksik “up” kap ve yankılanan `^J` çok satır yerine). İyilik `terminfo` veya paketlenmiş `ncurses`. [\#7737](https://github.com/ClickHouse/ClickHouse/pull/7737) ([Amos Kuşu](https://github.com/amosbird)) +- Düzeltmek `test_storage_s3` entegrasyon testi. [\#7734](https://github.com/ClickHouse/ClickHouse/pull/7734) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Destek `StorageFile(, null)` aslında Diske yazmadan verilen format dosyasına blok eklemek için. Bu performans testleri için gereklidir. [\#8455](https://github.com/ClickHouse/ClickHouse/pull/8455) ([Amos Kuşu](https://github.com/amosbird)) +- Eklenen argüman `--print-time` test başına yürütme süresini basan işlevsel testlere. [\#8001](https://github.com/ClickHouse/ClickHouse/pull/8001) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Eklenen iddialar `KeyCondition` rpn değerlendirirken. Bu, gcc-9'dan gelen uyarıyı düzeltir. [\#8279](https://github.com/ClickHouse/ClickHouse/pull/8279) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Cı yapılarında cmake seçeneklerini dökümü. [\#8273](https://github.com/ClickHouse/ClickHouse/pull/8273) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Bazı fat kitaplıkları için hata ayıklama bilgisi oluşturmayın. [\#8271](https://github.com/ClickHouse/ClickHouse/pull/8271) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Yapmak `log_to_console.xml` her zaman ne olursa olsun interaktif ya da değil, stderr oturum açın. [\#8395](https://github.com/ClickHouse/ClickHouse/pull/8395) ([Alexander Kuzmenkov](https://github.com/akuzm)) +- Kullanılmayan bazı özellikler kaldırıldı `clickhouse-performance-test` aracı. [\#8555](https://github.com/ClickHouse/ClickHouse/pull/8555) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Şimdi de arayacağız `lld-X` karşılık gelen ile `clang-X` sürüm. [\#8092](https://github.com/ClickHouse/ClickHouse/pull/8092) ([alesapin](https://github.com/alesapin)) +- Parke inşa iyileştirme. [\#8421](https://github.com/ClickHouse/ClickHouse/pull/8421) ([maxulan](https://github.com/maxulan)) +- Daha fazla GCC uyarısı [\#8221](https://github.com/ClickHouse/ClickHouse/pull/8221) ([kreuzerkrieg](https://github.com/kreuzerkrieg)) +- Arch Linux için paket şimdi ClickHouse sunucusu çalıştırmak için izin verir, ve sadece istemci. [\#8534](https://github.com/ClickHouse/ClickHouse/pull/8534) ([Vladimir Chebotarev](https://github.com/excitoon)) +- İşlemcilerle testi düzeltin. Küçük performans düzeltmeleri. [\#7672](https://github.com/ClickHouse/ClickHouse/pull/7672) ([Nikolai Kochetov](https://github.com/KochetovNicolai)) +- Contrib/protobuf güncelleyin. [\#8256](https://github.com/ClickHouse/ClickHouse/pull/8256) ([Matwey V. Kornilov](https://github.com/matwey)) +- Yeni yıl kutlaması olarak C++20'ye geçmenin hazırlanmasında. “May the C++ force be with ClickHouse.” [\#8447](https://github.com/ClickHouse/ClickHouse/pull/8447) ([Amos Kuşu](https://github.com/amosbird)) + +#### Deneysel Özellik {#experimental-feature-1} + +- Deneysel ayar eklendi `min_bytes_to_use_mmap_io`. Bu userspace çekirdekten veri kopyalamadan büyük dosyaları okumak için izin verir. Bu ayar varsayılan olarak devre dışıdır. Önerilen eşik yaklaşık 64 MB'dir, çünkü mmap / munmap yavaştır. [\#8520](https://github.com/ClickHouse/ClickHouse/pull/8520) ([alexey-milovidov](https://github.com/alexey-milovidov)) +- Erişim kontrol sisteminin bir parçası olarak yeniden işlenmiş kotalar. Yeni tablo eklendi `system.quotas` yeni fonksiyonlar `currentQuota`, `currentQuotaKey`, yeni SQL sözdizimi `CREATE QUOTA`, `ALTER QUOTA`, `DROP QUOTA`, `SHOW QUOTA`. [\#7257](https://github.com/ClickHouse/ClickHouse/pull/7257) ([Vitaly Baranov](https://github.com/vitlibar)) +- İstisnalar atmak yerine bilinmeyen ayarları uyarılarla atlamaya izin verin. [\#7653](https://github.com/ClickHouse/ClickHouse/pull/7653) ([Vitaly Baranov](https://github.com/vitlibar)) +- Erişim kontrol sisteminin bir parçası olarak reworked satır politikaları. Yeni tablo eklendi `system.row_policies` yeni işlev `currentRowPolicies()`, yeni SQL sözdizimi `CREATE POLICY`, `ALTER POLICY`, `DROP POLICY`, `SHOW CREATE POLICY`, `SHOW POLICIES`. [\#7808](https://github.com/ClickHouse/ClickHouse/pull/7808) ([Vitaly Baranov](https://github.com/vitlibar)) + +#### Güvenlik Düzeltme {#security-fix} + +- İle tablolarda dizin yapısını okuma imkanı Düzelt theildi `File` masa motoru. Bu düzeltmeler [\#8536](https://github.com/ClickHouse/ClickHouse/issues/8536). [\#8537](https://github.com/ClickHouse/ClickHouse/pull/8537) ([alexey-milovidov](https://github.com/alexey-milovidov)) + +## [2019 için Changelog](https://github.com/ClickHouse/ClickHouse/blob/master/docs/en/changelog/2019.md) {#changelog-for-2019} diff --git a/docs/tr/whats_new/index.md b/docs/tr/whats_new/index.md new file mode 100644 index 00000000000..17464a36cb0 --- /dev/null +++ b/docs/tr/whats_new/index.md @@ -0,0 +1,8 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_folder_title: Ne yeni +toc_priority: 72 +--- + + diff --git a/docs/tr/whats_new/roadmap.md b/docs/tr/whats_new/roadmap.md new file mode 100644 index 00000000000..fc43396d834 --- /dev/null +++ b/docs/tr/whats_new/roadmap.md @@ -0,0 +1,19 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 74 +toc_title: "Yol haritas\u0131" +--- + +# Yol haritası {#roadmap} + +## Q1 2020 {#q1-2020} + +- Rol tabanlı erişim denetimi + +## Q2 2020 {#q2-2020} + +- Dış kimlik doğrulama hizmetleri ile entegrasyon +- Kullanıcılar arasında küme kapasitesinin daha hassas dağılımı için kaynak havuzları + +{## [Orijinal makale](https://clickhouse.tech/docs/en/roadmap/) ##} diff --git a/docs/tr/whats_new/security_changelog.md b/docs/tr/whats_new/security_changelog.md new file mode 100644 index 00000000000..117d1766cdb --- /dev/null +++ b/docs/tr/whats_new/security_changelog.md @@ -0,0 +1,76 @@ +--- +machine_translated: true +machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 +toc_priority: 76 +toc_title: "G\xFCvenlik Changelog" +--- + +## ClickHouse sürümünde düzeltildi 19.14.3.3, 2019-09-10 {#fixed-in-clickhouse-release-19-14-3-3-2019-09-10} + +### CVE-2019-15024 {#cve-2019-15024} + +Аn attacker that has write access to ZooKeeper and who ican run a custom server available from the network where ClickHouse runs, can create a custom-built malicious server that will act as a ClickHouse replica and register it in ZooKeeper. When another replica will fetch data part from the malicious replica, it can force clickhouse-server to write to arbitrary path on filesystem. + +Kredi: Yandex Bilgi Güvenliği ekibinden Eldar Zaitov + +### CVE-2019-16535 {#cve-2019-16535} + +Аn OOB read, OOB write and integer underflow in decompression algorithms can be used to achieve RCE or DoS via native protocol. + +Kredi: Yandex Bilgi Güvenliği ekibinden Eldar Zaitov + +### CVE-2019-16536 {#cve-2019-16536} + +DOS'A giden yığın taşması, kötü amaçlı kimliği doğrulanmış bir istemci tarafından tetiklenebilir. + +Kredi: Yandex Bilgi Güvenliği ekibinden Eldar Zaitov + +## ClickHouse sürümü 19.13.6.1, 2019-09-20'de düzeltildi {#fixed-in-clickhouse-release-19-13-6-1-2019-09-20} + +### CVE-2019-18657 {#cve-2019-18657} + +Tablo fonksiyonu `url` güvenlik açığı saldırganın istekte rasgele HTTP üstbilgileri enjekte etmesine izin vermişti. + +Krediler: [Nikita Tikhomirov](https://github.com/NSTikhomirov) + +## ClickHouse sürümünde sabit 18.12.13, 2018-09-10 {#fixed-in-clickhouse-release-18-12-13-2018-09-10} + +### CVE-2018-14672 {#cve-2018-14672} + +Catboost modellerini yüklemek için işlevler, yol geçişine izin verdi ve hata mesajları aracılığıyla keyfi dosyaları okudu. + +Kredi: Yandex Bilgi Güvenliği ekibinden Andrey Krasichkov + +## ClickHouse sürüm 18.10.3, 2018-08-13 sabit {#fixed-in-clickhouse-release-18-10-3-2018-08-13} + +### CVE-2018-14671 {#cve-2018-14671} + +unixODBC, dosya sisteminden rasgele paylaşılan nesnelerin yüklenmesine izin verdi ve bu da uzaktan kod yürütme güvenlik açığına yol açtı. + +Kredi: Yandex Bilgi Güvenliği ekibinden Andrey Krasichkov ve Evgeny Sidorov + +## ClickHouse sürüm 1.1.54388, 2018-06-28 sabit {#fixed-in-clickhouse-release-1-1-54388-2018-06-28} + +### CVE-2018-14668 {#cve-2018-14668} + +“remote” tablo fonksiyonu izin keyfi semboller “user”, “password” ve “default\_database” çapraz Protokol isteği sahtecilik saldırılarına yol açan alanlar. + +Kredi: Yandex Bilgi Güvenliği ekibinden Andrey Krasichkov + +## ClickHouse sürüm 1.1.54390, 2018-07-06 sabit {#fixed-in-clickhouse-release-1-1-54390-2018-07-06} + +### CVE-2018-14669 {#cve-2018-14669} + +ClickHouse MySQL istemcisi vardı “LOAD DATA LOCAL INFILE” işlevsellik, kötü niyetli bir MySQL veritabanının bağlı ClickHouse sunucusundan rasgele dosyaları okumasına izin verdi. + +Kredi: Yandex Bilgi Güvenliği ekibinden Andrey Krasichkov ve Evgeny Sidorov + +## ClickHouse sürüm 1.1.54131, 2017-01-10 sabit {#fixed-in-clickhouse-release-1-1-54131-2017-01-10} + +### CVE-2018-14670 {#cve-2018-14670} + +Deb paketindeki yanlış yapılandırma, veritabanının yetkisiz kullanımına neden olabilir. + +Kredi: İngiltere'nin Ulusal siber güvenlik merkezi (NCSC) + +{## [Orijinal makale](https://clickhouse.tech/docs/en/security_changelog/) ##} diff --git a/website/images/flags/tr.svg b/website/images/flags/tr.svg new file mode 100644 index 00000000000..30524de46d8 --- /dev/null +++ b/website/images/flags/tr.svg @@ -0,0 +1,8 @@ + + + + + + + diff --git a/website/locale/en/LC_MESSAGES/messages.po b/website/locale/en/LC_MESSAGES/messages.po index c272d156de6..ef9726c101c 100644 --- a/website/locale/en/LC_MESSAGES/messages.po +++ b/website/locale/en/LC_MESSAGES/messages.po @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: PROJECT VERSION\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" -"POT-Creation-Date: 2020-03-30 15:12+0300\n" +"POT-Creation-Date: 2020-04-15 13:19+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language: en\n" @@ -80,11 +80,15 @@ msgstr "" "codebase and waits for fellow native speakers to make it more human-" "readable." +#: templates/docs/content.html:7 +msgid "You can also use the original English version as a reference." +msgstr "You can also use the original English version as a reference." + #: templates/docs/content.html:10 msgid "Help ClickHouse documentation by editing this page" msgstr "Help ClickHouse documentation by editing this page" -#: templates/docs/content.html:31 +#: templates/docs/content.html:27 msgid "Built from" msgstr "Built from" @@ -184,15 +188,15 @@ msgstr "Email discussions" msgid "Like ClickHouse?" msgstr "Like ClickHouse?" -#: templates/index/community.html:142 +#: templates/index/community.html:143 msgid "Help to spread the word about it via" msgstr "Help to spread the word about it via" -#: templates/index/community.html:143 +#: templates/index/community.html:144 msgid "and" msgstr "and" -#: templates/index/community.html:155 +#: templates/index/community.html:153 msgid "Hosting ClickHouse Meetups" msgstr "Hosting ClickHouse Meetups" diff --git a/website/locale/es/LC_MESSAGES/messages.mo b/website/locale/es/LC_MESSAGES/messages.mo index e7a8e7bd13ce1af89e7308d7e5c562163ba3ae86..6f29d0fd3dfec8914086ce544e2098e51da9a1ec 100644 GIT binary patch delta 1062 zcmYMzO-NKx6u|LQYFdspel|8`mm0EY6vs5C$jVY{Q4paG9>)EwpFw@T4|}j5Gkyk340OjUr~z|$2+KK8U5{cNcB3AZhuX?9T*MjFqv|7A z7!zz?clexk7UNIU#5vS=VGXr&Rh9H#cUnvT8u1#ETOOkpFoAb*2{rL?UJwm%8MUz6 zsAoKmn&2(=;v&)v@mJ>)?L)nO0QDt5g2UKVP5&uI=2^Hx024rus{jB1 delta 900 zcmYMzOGs2v9LMp0YV*kJVe>mgKyO7RKSqY|3ILKd)q#IzmC zR)fE=1+$qfMttj_(S+|%rQJrVWj`?u_mIWgK5E5BScQM^4FN(dFQ5K&)|rc_ivGZ2 zJVrh5%QkDrAm-vI#6y z=*9#p@D%DD_=u|53f{&wKlQJr;iZ1WvKT6X7JQ1MsK5uP2~JUomGPozZyQko`mqCt zQG30J3bdKJzJ+?ZckvOPAUW7zpx5jHnU4q9R|YnS7Q=7YiaFG^86V<({DLaoU*s`! x^9g8+yr}0LRNw&K!GhVr^w*w5t@9x(dOaF0iPYbW)K!P0v)`R(nTg3@+kZ3oSKR;r diff --git a/website/locale/es/LC_MESSAGES/messages.po b/website/locale/es/LC_MESSAGES/messages.po index 1a8706e60fd..96632f2b7f3 100644 --- a/website/locale/es/LC_MESSAGES/messages.po +++ b/website/locale/es/LC_MESSAGES/messages.po @@ -7,7 +7,7 @@ msgid "" msgstr "" "Project-Id-Version: PROJECT VERSION\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" -"POT-Creation-Date: 2020-03-30 15:12+0300\n" +"POT-Creation-Date: 2020-04-15 13:19+0000\n" "PO-Revision-Date: 2020-03-26 10:19+0300\n" "Last-Translator: FULL NAME \n" "Language: es\n" @@ -79,11 +79,15 @@ msgstr "" "la base de código principal de ClickHouse y espera a que otros hablantes " "nativos lo hagan más legible por humanos." +#: templates/docs/content.html:7 +msgid "You can also use the original English version as a reference." +msgstr "También puede usar la versión original en inglés como referencia." + #: templates/docs/content.html:10 msgid "Help ClickHouse documentation by editing this page" msgstr "Ayuda a la documentación de ClickHouse editando esta página" -#: templates/docs/content.html:31 +#: templates/docs/content.html:27 msgid "Built from" msgstr "Construido a partir de" @@ -187,15 +191,15 @@ msgstr "Discusiones por correo electrónico" msgid "Like ClickHouse?" msgstr "¿Te gusta ClickHouse?" -#: templates/index/community.html:142 +#: templates/index/community.html:143 msgid "Help to spread the word about it via" msgstr "Ayuda a correr la voz al respecto a través de" -#: templates/index/community.html:143 +#: templates/index/community.html:144 msgid "and" msgstr "y" -#: templates/index/community.html:155 +#: templates/index/community.html:153 msgid "Hosting ClickHouse Meetups" msgstr "Grupos de Meetup de Hosting ClickHouse" diff --git a/website/locale/fa/LC_MESSAGES/messages.mo b/website/locale/fa/LC_MESSAGES/messages.mo index 6d2a415b7fc7d65435aa5a2d3e6a3f89888cb4b5..d474a31e03a8a62f2d09d4533c21219a539b94ac 100644 GIT binary patch delta 1122 zcmYMyOGs2v7{Kw*M`=FFw9GW^kdlNC9CNZF10yqYBW)t6#W0RKHOek#@@Nf0OM$q!*A9>EA3ox`ovS8|gn z&)AsEY!&X&aj5fsr~!vCtP@7o8YZxg`aJH$B{Z1I#qP#()D)gTUBH7`Y&?K^RYQ4X z5ASjOGxRqyh@{DVq)R4HznNKNY57<{{*O`kN<#yd@&V|^Cs8*H;ygaYQfw#MUFb!v zM^R5UgL<+>?8O9<4C&y*(g4n)X0{9UYA@j^-YF#i+bERrdQ0T{P$&E$%r;En!x+bQ z?7}6yh;5{S+mTmz9Y3I6(NR{{`K_oY?m(_zTzCr4qcnGRdV9SAzsqObF>l)C%%;Yx^Xx6d2uG5wxkh-t*Lo9S5rF>SDKYmUF|_Gke&YGWLi)9FN$MMAVKLdpHp_){K4An$i|)&e#zv zX3g3o#+tI8+e6w-SA0&3R!pl;v~$6ZBqy0fG(OEb*1Yx9TF_ZB)*Hk*#>J-Kd#&pfBgCV679lVHMRtyF^Ob-SHh0ugzbV&uB zx9AX&loy#7!49DpA<&DE2Zw=>A$Srzl;HcrgdX|~tAAg-VrbEv?F7{?-) zSsC#y$wdtl6IhNJBr{t;a+fJnnGbRi!Z=>VIc&gXY{6|*>;9qE``G9b0=J^JsH@EE6W*unDEI%+ zMw(^)EasLCqP~?F@(O#2{rI+m{_DfrWI}z4P&el*k`_p~onSJ0-odF8K BS_%LF diff --git a/website/locale/fa/LC_MESSAGES/messages.po b/website/locale/fa/LC_MESSAGES/messages.po index 5e4205412d1..03a7d9baf3f 100644 --- a/website/locale/fa/LC_MESSAGES/messages.po +++ b/website/locale/fa/LC_MESSAGES/messages.po @@ -7,7 +7,7 @@ msgid "" msgstr "" "Project-Id-Version: PROJECT VERSION\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" -"POT-Creation-Date: 2020-03-30 15:12+0300\n" +"POT-Creation-Date: 2020-04-15 13:19+0000\n" "PO-Revision-Date: 2020-03-26 10:19+0300\n" "Last-Translator: FULL NAME \n" "Language: fa\n" @@ -78,11 +78,15 @@ msgstr "" " کنار پایگاه داده اصلی خانه کلیک زندگی می کند و منتظر سخنرانان مادری " "همکار به انسان بیشتر قابل خواندن است." +#: templates/docs/content.html:7 +msgid "You can also use the original English version as a reference." +msgstr "شما همچنین می توانید نسخه اصلی انگلیسی به عنوان یک مرجع استفاده کنید." + #: templates/docs/content.html:10 msgid "Help ClickHouse documentation by editing this page" msgstr "راهنما مستندات تاتر با ویرایش این صفحه" -#: templates/docs/content.html:31 +#: templates/docs/content.html:27 msgid "Built from" msgstr "ساخته شده از" @@ -182,15 +186,15 @@ msgstr "بحث های ایمیل" msgid "Like ClickHouse?" msgstr "مانند خانه کلیک?" -#: templates/index/community.html:142 +#: templates/index/community.html:143 msgid "Help to spread the word about it via" msgstr "کمک به گسترش این کلمه از طریق" -#: templates/index/community.html:143 +#: templates/index/community.html:144 msgid "and" msgstr "و" -#: templates/index/community.html:155 +#: templates/index/community.html:153 msgid "Hosting ClickHouse Meetups" msgstr "میزبانی اکسسوری تاتر" diff --git a/website/locale/fr/LC_MESSAGES/messages.mo b/website/locale/fr/LC_MESSAGES/messages.mo index 7d67a68c6e57cb194a3af7cdc2bdc5d03e856336..c5f2ca8793f1c7b359f28d980ca4d0e1d407fff0 100644 GIT binary patch delta 1075 zcmYMyO-NKx6u|LQTA5$z?F#&YGNP5*;a4Kwq*_rCk?IrrTA?fC7;_)?(w zk??8bw~ybuE!zA4NfwFhrklcQyo04Ui48c7#rOhu;hTbssPn(#AzZ_~7+|s*#zv8G zIZLCCfkCXnn>d9Jv7BUr+e9|#N4JY~VQ7a4UrF=FBN;&rbgMA_09)x#VH1A9a$G|V z{2Sv~S0YkHd>Ny$hk<(-z!@Ynd5Pp8pYSw(!7^;vxtTx{>hln4g(8^47-~YVv5^gY zL}JP+Weedt_Tm8+J4t*=(1_tv)YAUIPW**bO`1u6E4Cs>7xldxs7E!5ckng7sXk0 z@H^@e_0)@8#tGD&Eny$7q8?E@tLvTUL|v!5;CT$wzl72?IOt|wFYP2ve9kQzE$Qs{ zawhJijg#~}lk=^~4qM}8+#y#d#nMAb*B>?`HskY}aeU*Lj7`{#O~-BXl{2R&|hgc4e VP25YRtjR3o6ASr5oG10Ye*of^l{EkW delta 901 zcmYMyPe{{o7{~F)|EtY^YqhBxn2I80I;Wr#QILvfqYkxH1QGQzqJs!d5IlrfX?76> z@t|V2odOFFffQavcNrN%hrp8*B0}$vzaKcZy}r-)_viaO&-XhOJ!(v5{JD$9r-fgb z-*%RwtIvxZvm1nQEX4#~$7u}V9OmLW7UL(^ZPfjHSdAGh$82tv5v(vvS{s8~OgzB= zj^an0LLbQl^UVGc*W{Z$!f=5ZUwg?Pmuv{N(3m?viOs|_Sc9L@hZ)que{c}%GoeFnR9sPy%c!qke zy2#n0de?SLD$^bYRruU>64k0zygUI|%) s7Fu)N!Up10Fg21h<5{@pTP}<>#F{FjtsT+kJ590Fp|8}t&=KnT4}q&$Hvj+t diff --git a/website/locale/fr/LC_MESSAGES/messages.po b/website/locale/fr/LC_MESSAGES/messages.po index 38cd1031b49..0797104a1a5 100644 --- a/website/locale/fr/LC_MESSAGES/messages.po +++ b/website/locale/fr/LC_MESSAGES/messages.po @@ -7,7 +7,7 @@ msgid "" msgstr "" "Project-Id-Version: PROJECT VERSION\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" -"POT-Creation-Date: 2020-03-30 15:12+0300\n" +"POT-Creation-Date: 2020-04-15 13:19+0000\n" "PO-Revision-Date: 2020-03-30 15:12+0300\n" "Last-Translator: FULL NAME \n" "Language: fr\n" @@ -79,11 +79,17 @@ msgstr "" "code ClickHouse principale et attend que d'autres locuteurs natifs le " "rendent plus lisible par l'homme." +#: templates/docs/content.html:7 +msgid "You can also use the original English version as a reference." +msgstr "" +"Vous pouvez également utiliser la version originale anglaise comme " +"référence." + #: templates/docs/content.html:10 msgid "Help ClickHouse documentation by editing this page" msgstr "Aide clickhouse documentation en éditant cette page" -#: templates/docs/content.html:31 +#: templates/docs/content.html:27 msgid "Built from" msgstr "Construit à partir de" @@ -185,15 +191,15 @@ msgstr "Discussions par courriel" msgid "Like ClickHouse?" msgstr "Comme ClickHouse?" -#: templates/index/community.html:142 +#: templates/index/community.html:143 msgid "Help to spread the word about it via" msgstr "Aider à passer le mot à ce sujet via" -#: templates/index/community.html:143 +#: templates/index/community.html:144 msgid "and" msgstr "et" -#: templates/index/community.html:155 +#: templates/index/community.html:153 msgid "Hosting ClickHouse Meetups" msgstr "Accueil Clickhouse Meetups" diff --git a/website/locale/ja/LC_MESSAGES/messages.mo b/website/locale/ja/LC_MESSAGES/messages.mo index ec416b79c0a36f0016fb83e1e797a68211db1bf5..96cc1b834bde34870f518518657412042efd1e80 100644 GIT binary patch delta 1074 zcmYMyT}TvB6u|LQu4$=dn_p$fSdvjHyQ_kRiU#)eU=)D_5p3(I8{01Ix&|faY#5n+ zNV{1gC`4971mQ!0Ss)Pv^;9oG*~28-izPu3LG(Yl(6Bqdxo7U&d(N4ec71gB&N>~} zg`=APX8tc$=;;3uNDnK36g`n!v=hh8CbA-Ie`+?`(>yda$^*mQ4^ZNLJD|; z>?vPpTNy6lUMym<8upiVE}C&1wY76tkKd54Nd@VzL=VygsYb254oh)2o@b+zs0A!# zEx!uK+U3e~a69p0)b$RaCftI(TKNesim(T_;V5pw87#&*+<|GlV13Yo*|-Nsu@&`I zeaA-B@()83*=WKEqzN*Lxj2!GPdVv-BY_zLb(q5H+WJP+kLwurVH7pdAE*^)^PyWTqHYw!BRGI8DYHmZWC`{DpJY6hEN(L{$ff_9(KII)nZHGf5J$eqe$2rRJdPfG ziM99(^;K1puT$-{IFu&B2a$HS@& delta 900 zcmYMyUr5tY6u|M*wrtbi)|@l7&Cn7Trt;h7Kr>`Lltk=BM!r}*2x|Y3KtT|i5ZPOW zvU-S~G!pbd6eol2C1OzY7J@xE6qGZo=*PCtJ@@{0?>YD0t#IB<6@8Ah z@O1DE^39#l=>Icd7pWq=jg|Nq%ke4J;tO=(2Rw~SmO0e-zv2Zf;#suuvRaP;k(6}O zI73Gg{rCW1;}jYsQ*%<}h`6atc1yO=hPz1d@&mQvpBTbJoMwR_3#ZxNSkEwIS?KGM(f#-1y8}SXcU>5a{yXeJZe2Xp)T#x8I#&LzgKKlPq zz9xK~tSDX*SdIOt{f{t?V?Or(3XL^7bjyFEUMdf(O<@T2XckZ_{)n3JK5AkvE{smt zfl2H}rjS>tJ1~bjzHIfc<2>;f)PzQ>?~0gY{)|X(Z-$$A0}D8e-kQ>7n!qmNMbsnO yL*3F}mWQa79$VU|!X!3U@7bR_XWNZ;?r2-oYzW6Lha;EF=<231QZYMId-ES}m|DL8 diff --git a/website/locale/ja/LC_MESSAGES/messages.po b/website/locale/ja/LC_MESSAGES/messages.po index e0c901ea399..9ef50c6d5b9 100644 --- a/website/locale/ja/LC_MESSAGES/messages.po +++ b/website/locale/ja/LC_MESSAGES/messages.po @@ -7,7 +7,7 @@ msgid "" msgstr "" "Project-Id-Version: PROJECT VERSION\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" -"POT-Creation-Date: 2020-03-30 15:12+0300\n" +"POT-Creation-Date: 2020-04-15 13:19+0000\n" "PO-Revision-Date: 2020-03-26 10:19+0300\n" "Last-Translator: FULL NAME \n" "Language: ja\n" @@ -71,11 +71,15 @@ msgstr "" "このドキュメントページの以下の内容は機械翻訳されています。 異な他のウェブサイトで行われませんができます。 " "この翻訳テキスト生活をGitHubリポジトリとClickHouseコードベース、待ち員ネイティブスピーカーで人間が読む." +#: templates/docs/content.html:7 +msgid "You can also use the original English version as a reference." +msgstr "また、参照として、元の英語版を使用することができます。" + #: templates/docs/content.html:10 msgid "Help ClickHouse documentation by editing this page" msgstr "このページを編集してClickHouseの文書を編集する" -#: templates/docs/content.html:31 +#: templates/docs/content.html:27 msgid "Built from" msgstr "から構築" @@ -175,15 +179,15 @@ msgstr "メールでの議論" msgid "Like ClickHouse?" msgstr "ClickHouseのような？" -#: templates/index/community.html:142 +#: templates/index/community.html:143 msgid "Help to spread the word about it via" msgstr "それについての言葉を広めるのに役立ちます" -#: templates/index/community.html:143 +#: templates/index/community.html:144 msgid "and" msgstr "と" -#: templates/index/community.html:155 +#: templates/index/community.html:153 msgid "Hosting ClickHouse Meetups" msgstr "開催ClickHouse Meetups" diff --git a/website/locale/messages.pot b/website/locale/messages.pot index a09273f2907..8465be2bf7c 100644 --- a/website/locale/messages.pot +++ b/website/locale/messages.pot @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: PROJECT VERSION\n" "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" -"POT-Creation-Date: 2020-03-30 15:12+0300\n" +"POT-Creation-Date: 2020-04-15 13:19+0000\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \n" "Language-Team: LANGUAGE \n" @@ -64,11 +64,15 @@ msgid "" "readable." msgstr "" +#: templates/docs/content.html:7 +msgid "You can also use the original English version as a reference." +msgstr "" + #: templates/docs/content.html:10 msgid "Help ClickHouse documentation by editing this page" msgstr "" -#: templates/docs/content.html:31 +#: templates/docs/content.html:27 msgid "Built from" msgstr "" @@ -168,15 +172,15 @@ msgstr "" msgid "Like ClickHouse?" msgstr "" -#: templates/index/community.html:142 +#: templates/index/community.html:143 msgid "Help to spread the word about it via" msgstr "" -#: templates/index/community.html:143 +#: templates/index/community.html:144 msgid "and" msgstr "" -#: templates/index/community.html:155 +#: templates/index/community.html:153 msgid "Hosting ClickHouse Meetups" msgstr "" diff --git a/website/locale/ru/LC_MESSAGES/messages.mo b/website/locale/ru/LC_MESSAGES/messages.mo index d6e0e5eaffebb3dfdc03edcf94c1587113f5dcd3..8aecc12706d6f9aaacca9882f42439f2ca16dffc 100644 GIT binary patch delta 1154 zcmYMyOGuPa6u|LgT0SeaG|k7{ND}dZPcq9)K`Mf_ArUg@s3X%1IXaqVzj|CiL5yTY%E zC!6PGl=lAre9io}m6u0m&rZQPA#w?M3IY%R% zKr0@^n>dBzn8arCcZ+P(uiPV2k43Q}{E44`3`s9)qFa&pD3;To!aRJ1Nw|fY_&2s- zdYniy`Q-+UOajB0ijR<;Nf_CKyvNh{2@^3RerE%DsN+Sb6)M9XY((AAGG_4sZ;+hw zjj|QtPdtmcELKf^X`|7IGpMEginaIyshX6q{asj&6hW#`zx)*DV*`F9Q72Ytf1k)P z>_y$!1FXTPsOxV=;@jA-6B0SNL+HXfJdV}ahdDTlT9LP?NA(?D7?sQdBtC+AR1f*= zcy{`PGBz_F<~$jaj5Ow80iMJQs7F1NM*TZ!+$V4eV_97t((q8{xA7T_=3#OzG!uN8>rW|Xq?9HfeJk!)A+GS1*4 z>K8Rpj(>e5r!?h?OyD)tBZ_hD7>k-P0XcrjLA`YODD|za-fnNe@AjFNd2e)ITy0aJ z$F#Wp#_bCROi$2bx;s23(B*CS>ZC@0yU!c!Fuk6xAg>vB(6~*Pr_Iyl@wa$NCN~nN z_f{5{RhhDinz9pxrKR(ClJ2EsO*q5G8ML!@$v(FW#;({kZ4g?Rbfu*AJA=-Mv1`tN z4cmF1Ri-XGBX-rf?Ti{atAv*sSad>mX(u?x`vY{tI%CeT^sF;PEX1me85$vHn75W} exI}DN?3~zjl7xsY*k>$0=8Q35mnYBUcK!uR*WlU! delta 901 zcmYMyPe_w-7{Ku--E?d3)J@IQ`H#)%GG)4iHLa15-s+I(C37fv*u3oENoZ2Ei(tf< zhtRqRX?l^JM7?=2q6o1JVH5}_tnl36 z=i#?=NqhgFhs7e5bjQ$zNxY0t@hUE$1>ayfZkX<%u78hS%wruEu~==udXbcbXsR*w;;*TkrLJc%+jz7j8`f2px78;mG4Sa@^SYi{Y zAil(D)G{!OZp)F6A5>viXw(IyE zhp>!~g^4dCH16Va)Y2Xz)sk;mgeS=6\n" "Language: ru\n" @@ -64,7 +64,7 @@ msgstr "ООО «Яндекс»" #: templates/docs/content.html:6 msgid "Help wanted!" -msgstr "Помощь нужна!" +msgstr "Нужна помощь!" #: templates/docs/content.html:7 msgid "" @@ -74,17 +74,23 @@ msgid "" "codebase and waits for fellow native speakers to make it more human-" "readable." msgstr "" -"Следующее содержание этой страницы документации было переведено на " -"машинный язык. Но в отличие от других сайтов, это делается не на лету. " +"Нижеследующее содержание этой страницы документации было создано через " +"машинный перевод. Но в отличие от других сайтов, это делается не на лету. " "Этот переведенный текст живет в репозитории GitHub вместе с основной " "кодовой базой ClickHouse и ждет, когда другие носители языка сделают его " -"более удобочитаемым для человека." +"более удобочитаемым." + +#: templates/docs/content.html:7 +msgid "You can also use the original English version as a reference." +msgstr "" +"Вы также можете использовать оригинальную английскую версию в качестве " +"образца." #: templates/docs/content.html:10 msgid "Help ClickHouse documentation by editing this page" msgstr "Помогите документации ClickHouse, отредактировав эту страницу" -#: templates/docs/content.html:31 +#: templates/docs/content.html:27 msgid "Built from" msgstr "Собрано из" @@ -184,15 +190,15 @@ msgstr "Обсуждения по электронной почте" msgid "Like ClickHouse?" msgstr "Нравится ClickHouse?" -#: templates/index/community.html:142 +#: templates/index/community.html:143 msgid "Help to spread the word about it via" msgstr "Помогите распространить информацию о нём через" -#: templates/index/community.html:143 +#: templates/index/community.html:144 msgid "and" msgstr "и" -#: templates/index/community.html:155 +#: templates/index/community.html:153 msgid "Hosting ClickHouse Meetups" msgstr "Таких Встреч ClickHouse " diff --git a/website/locale/tr/LC_MESSAGES/messages.mo b/website/locale/tr/LC_MESSAGES/messages.mo new file mode 100644 index 0000000000000000000000000000000000000000..c8aa99e505d9308cf64463327e732dfc8d9a5d2b GIT binary patch literal 6158 zcmd^@O>87b6~_w*0hSOTkPt`&l_hAA@R;3A0vl)ZF}7!IC;r%YX0uujNHxjrokXO{} zA5!WQ;J-mxf9LH=odoX%<@#|@@^oQ>&wyfY7u4WYP}ct#lz8odp8@{@N}k>T?*wmW zlb?h4gOaBg!8^g132L4Dud}K6{QyA~dmjOX2X#>Vw4nGo0KWwO0u;Mm0Y3-+6HLK- z2(HBUd;AbPehSL@BT(#n36%K!1AH2M1H^T;1ewI&%b=Y1RZ!k@-~jyQP{R*)@P}zr+sbwP=77AsXR;7Z0^ELcau0$a~mepTQ1wsiRGm{wMnX-*J{pX zLp2w=PJc1xuAU9!UiEr@cBNUpUa>aI2h}@k-LC66Hf^zgW)ofSbmH7+)iuq~bo%;o zob=Oy>DcO{D{_z+|Rva6dBM^sEF_r^7U}kOcJi z55$D_P+u`Vuvc{@!exX~ZLektfeME@G)d3uO$n(@b=)lj0=bM%2`lMi6P@Ng05xeO#{48#Ww>iD4|6i<6%5Zkt+|))zwy0j6}<+K|mi4u?nDb@edL^_GDV zS5e`?s%$?;iAzu|kbk6ILeE7=R;4q5UUB#yl# z*ou%4*TUlg+%I3j)pUTlL16)*4zy`Y5M8D>ohcVdP;79YT8t4K_Nbgw%0#M`%J6NN zO<}=MM@3{vM{k2-A%ur&HHmyTv4k!rlNi~_-hzNdTmzTbP6qi*rj}hF`8d>o$JI(6 zX09gA$O%$|p)D?}Pd3RqF(_{h@&vlT83}(!BSk%&RjVelYE5)w!DWkin+&CSVV*&3 zg`6dy$WyGlPM8jVOqP@W#1^ipi}M%s!CC8)9^+Nh`am_0>^fY~jJw&ElmJwyiUGMo z!A{njdZ~F*&(@nu%_)6(skOLvsiiO1*VpT-t))g&udVC3wbl8h*3#N4R~K}B^@@IK zX?1=|TdDv;*{h^AEkf_2LFjBSty)Dd@{h@RwCav_Syih?G`NmRsn z!=%&(fr{X&^R|{H#;2jk$h4k?H@OcbO=TTy*>>tOn@$OxaMj0|4vL!c1>d^ia9X#d z29LI(o~~v(bep0vhY1ncWve)W31RGeDSChnh|durus^Vcx{D5N83*$ucU>zEYELb| z&U9c+U%DcxjQF3JR@sNw%gb|$zO6fu(u8R&^F)z28fp)X5A{TU4v4LxhxEuUr~3{; zBooScB?L(`#YtRHHgsvPpER4M*-6}>P}~$fu%dF>1c6XjT}`q5ZmiUomY=B4&#yO{%@Y^bTD3W8b;v+% z9!qBQ+0$oF*G@lJJM)k}^T5oRhre)|KP;@R+f65O@z(3UT&`O-X;y1Zh#x02`og8< zWxZNoY3TFEj(+UKG76I;P%|+6@S@hDWyl?UetG$c&`p!}$4*=f^TdR;3v{D&M*Bf= znLc{v5ncZG(bFeZmR1@^u{bk*`oyG?Ypvlx&Y*O@I0z|=M|5YyB&p3F&9iRp+|fF* zn(WjXo@#*xGx}WHWhWNOiN_Me;f$U&ZJOiR>2sW*8hturl1H?E+Cd_k>2%v6xZEv% zcr|Y}T8SnCz7Qsy8jW*3w?Z03*T%szK^Uf#Hb(==+a133v zscDaQt6P?1=;%2Uj(7KWBBSetIn^ZxR<>xb^Lb4 zk1QrnVLsl;tLMm2NT7OovFju2}Zv*S8w+b<(BwZ3brHGh@s&ta?Lk;&;`OSY7!jfI z?ii1UAu-BzKlV9U?AuVj-7vL?Ly^2mO6Y$@Y9!Wdb6>TfXOEbHMYEz6;$;#UQ9a2_$Hx2EdSvcpcoi={b^-z`OD;oPg3e);B_e$$VT7jzvVs zUh)pYjc#l+Um;f#tMQJbDsIRp%~3^6X6n*^pO=c|j|S!;`B03^6qs5#d>O?(GPw}8 z!pbXVyU1sxPp&P`UmCw~NiU4A&yKIlxcn6+;5whBl5Dtz9~9w2U8d&ob!LVub-mbF zU#ze4N>MHQJCIPXEw9w)>#I|`UTSIK8^=W6O+!Ut2Gv6@nE#m#<1`mm&c~E0(w&(U z56b9L1XLx%5*v#V$gmS#fSD2+h$ak$`KBwhA;Ub|Ok5a|~Gs6a_M6^Fb;* zOK8Y4)mfOrP5~8J6c3N6Z6Q9fhVsr+|Hr(F`#HY>U_Emw_LX7b!=X^M%zu|yW#kbkuc(RMY{5B$a(W`FN#|7Nakdq);7!J-H2+esHM$F zh-`|Ve7a^VD|lN`1Z}(=4-x;CV_;ktt$Fd iU=_cj;1Y2-xWUJBq0C0+Z, 2020. +# +msgid "" +msgstr "" +"Project-Id-Version: PROJECT VERSION\n" +"Report-Msgid-Bugs-To: EMAIL@ADDRESS\n" +"POT-Creation-Date: 2020-04-15 13:19+0000\n" +"PO-Revision-Date: 2020-04-15 13:17+0000\n" +"Last-Translator: FULL NAME \n" +"Language: tr\n" +"Language-Team: tr \n" +"Plural-Forms: nplurals=1; plural=0\n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.8.0\n" + +#: templates/common_meta.html:5 templates/common_meta.html:9 +#: templates/common_meta.html:16 +msgid "ClickHouse DBMS" +msgstr "ClickHouse DBMS" + +#: templates/common_meta.html:11 +msgid "" +"ClickHouse is an open source column-oriented database management system " +"that allows generating analytical data reports in real time using SQL " +"queries." +msgstr "" +"ClickHouse SQL sorguları kullanarak gerçek zamanlı olarak analitik veri " +"raporları üreten sağlayan bir açık kaynak sütun odaklı veritabanı yönetim" +" sistemidir." + +#: templates/common_meta.html:19 +msgid "" +"ClickHouse is an open source distributed column-oriented database " +"management system that allows generating analytical data reports in real " +"time using SQL queries. Сreated by Yandex ClickHouse manages extremely " +"large volumes of data in a stable and sustainable manner." +msgstr "" +"ClickHouse is an open source distributed column-oriented database " +"management system that allows generating analytical data reports in real " +"time using SQL queries. Сreated by Yandex ClickHouse manages extremely " +"large volumes of data in a stable and sustainable manner." + +#: templates/footer.html:8 +msgid "ClickHouse source code is published under the Apache 2.0 License." +msgstr "ClickHouse kaynak kodu Apache 2.0 Lisansı altında yayınlandı." + +#: templates/footer.html:8 +msgid "" +"Software is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR " +"CONDITIONS OF ANY KIND, either express or implied." +msgstr "" +"Yazılım \"OLDUĞU GİBİ\" BAZINDA dağıtılır, GARANTİ VEYA HERHANGİ bir şart" +" OLMADAN, Açık veya zımni." + +#: templates/footer.html:11 +msgid "Yandex LLC" +msgstr "Yandex LLC" + +#: templates/docs/content.html:6 +msgid "Help wanted!" +msgstr "Yardım istedi!" + +#: templates/docs/content.html:7 +msgid "" +"The following content of this documentation page has been machine-" +"translated. But unlike other websites, it is not done on the fly. This " +"translated text lives on GitHub repository alongside main ClickHouse " +"codebase and waits for fellow native speakers to make it more human-" +"readable." +msgstr "" +"Bu Dokümantasyon sayfasının aşağıdaki içeriği makine tarafından " +"çevrilmiştir. Ancak diğer web sitelerinin aksine, anında yapılmaz. Bu " +"çevrilmiş metin, ana ClickHouse kod tabanının yanında GitHub deposunda " +"yaşar ve diğer anadili konuşanların daha insan tarafından okunabilir " +"olmasını bekler." + +#: templates/docs/content.html:7 +msgid "You can also use the original English version as a reference." +msgstr "Orijinal İngilizce sürümünü referans olarak da kullanabilirsiniz." + +#: templates/docs/content.html:10 +msgid "Help ClickHouse documentation by editing this page" +msgstr "Bu sayfayı düzenleyerek ClickHouse belgelerine yardım edin" + +#: templates/docs/content.html:27 +msgid "Built from" +msgstr "Dahili" + +#: templates/docs/sidebar.html:3 +msgid "Multi-page or single-page" +msgstr "Çok sayfalı veya tek sayfalı" + +#: templates/docs/sidebar.html:5 +msgid "Multi-page version" +msgstr "Çok sayfalı sürüm" + +#: templates/docs/sidebar.html:8 +msgid "Single-page version" +msgstr "Tek sayfalık sürüm" + +#: templates/docs/sidebar.html:13 +msgid "Version" +msgstr "Sürüm" + +#: templates/docs/sidebar.html:13 templates/docs/sidebar.html:19 +msgid "latest" +msgstr "son" + +#: templates/docs/sidebar.html:36 +msgid "PDF version" +msgstr "PDF versiyonu" + +#: templates/docs/toc.html:8 +msgid "Table of Contents" +msgstr "İçindekiler tablosu" + +#: templates/index/community.html:4 +msgid "ClickHouse community" +msgstr "ClickHouse topluluğu" + +#: templates/index/community.html:13 templates/index/community.html:14 +msgid "ClickHouse YouTube Channel" +msgstr "ClickHouse YouTube Kanalı" + +#: templates/index/community.html:25 templates/index/community.html:26 +msgid "ClickHouse Official Twitter Account" +msgstr "ClickHouse Resmi Twitter Hesabı" + +#: templates/index/community.html:36 templates/index/community.html:37 +msgid "ClickHouse at Telegram" +msgstr "Telegram'da ClickHouse" + +#: templates/index/community.html:41 +msgid "Chat with real users in " +msgstr "Gerçek kullanıcılar ile sohbet " + +#: templates/index/community.html:44 templates/index/community.html:116 +msgid "English" +msgstr "İngilizce" + +#: templates/index/community.html:45 +msgid "or in" +msgstr "veya içinde" + +#: templates/index/community.html:47 templates/index/community.html:117 +msgid "Russian" +msgstr "Rusça" + +#: templates/index/community.html:65 +msgid "Open GitHub issue to ask for help or to file a feature request" +msgstr "Yardım istemek veya bir özellik isteği göndermek için GitHub sorununu açın" + +#: templates/index/community.html:76 templates/index/community.html:77 +msgid "ClickHouse Slack Workspace" +msgstr "ClickHouse Slack Çalışma Alanı" + +#: templates/index/community.html:82 +msgid "Multipurpose public hangout" +msgstr "Çok amaçlı kamu hangout" + +#: templates/index/community.html:101 +msgid "Ask any questions" +msgstr "Herhangi bir soru sorun" + +#: templates/index/community.html:115 +msgid "ClickHouse Blog" +msgstr "ClickHouse Blog" + +#: templates/index/community.html:116 +msgid "in" +msgstr "içinde" + +#: templates/index/community.html:128 templates/index/community.html:129 +msgid "ClickHouse at Google Groups" +msgstr "Google Grupları'nda ClickHouse" + +#: templates/index/community.html:133 +msgid "Email discussions" +msgstr "E-posta tartış discussionsmaları" + +#: templates/index/community.html:142 +msgid "Like ClickHouse?" +msgstr "ClickHouse Gibi Mi?" + +#: templates/index/community.html:143 +msgid "Help to spread the word about it via" +msgstr "Aracılığıyla bu konuda kelime yaymak için yardım" + +#: templates/index/community.html:144 +msgid "and" +msgstr "ve" + +#: templates/index/community.html:153 +msgid "Hosting ClickHouse Meetups" +msgstr "ClickHouse Buluşmaları Barındırma" + +#: templates/index/community.html:157 +msgid "" +"ClickHouse meetups are essential for strengthening community worldwide, " +"but they couldn't be possible without the help of local organizers. " +"Please, feel this form if you want to become one or want to meet " +"ClickHouse core team for any other reason." +msgstr "" +"ClickHouse buluşmalar dünya çapında toplumu güçlendirmek için gereklidir," +" ancak yerel organizatörlerin yardımı olmadan mümkün olamazdı. Eğer biri " +"olmak istiyorsanız veya başka bir nedenle ClickHouse çekirdek ekibi " +"karşılamak istiyorsanız, bu formu hissedin." + +#: templates/index/community.html:159 +msgid "ClickHouse Meetup" +msgstr "ClickHouse Meetup" + +#: templates/index/community.html:165 +msgid "Name" +msgstr "Ad" + +#: templates/index/community.html:168 +msgid "Email" +msgstr "Posta" + +#: templates/index/community.html:171 +msgid "Company" +msgstr "Şirket" + +#: templates/index/community.html:174 +msgid "City" +msgstr "Şehir" + +#: templates/index/community.html:179 +msgid "We'd like to host a public ClickHouse Meetup" +msgstr "Halka açık bir ClickHouse buluşmasına ev sahipliği yapmak istiyoruz" + +#: templates/index/community.html:185 +msgid "We'd like to invite Yandex ClickHouse team to our office" +msgstr "Yandex ClickHouse ekibini ofisimize davet etmek istiyoruz" + +#: templates/index/community.html:191 +msgid "We'd like to invite Yandex ClickHouse team to another event we organize" +msgstr "" +"Yandex ClickHouse ekibini organize ettiğimiz başka bir etkinliğe davet " +"etmek istiyoruz" + +#: templates/index/community.html:197 +msgid "We're interested in commercial consulting, support or managed service" +msgstr "Ticari danışmanlık, destek veya yönetilen hizmetle ilgileniyoruz" + +#: templates/index/community.html:201 +msgid "Additional comments" +msgstr "Ek yorumlar" + +#: templates/index/community.html:203 +msgid "Send" +msgstr "Göndermek" + +#: templates/index/community.html:212 +msgid "" +"If you have any more thoughts or questions, feel free to contact Yandex " +"ClickHouse team directly at" +msgstr "" +"Daha fazla düşünceniz veya sorunuz varsa, Yandex ClickHouse ekibiyle " +"doğrudan iletişime geçmekten çekinmeyin" + +#: templates/index/community.html:213 +msgid "turn on JavaScript to see email address" +msgstr "e-posta adresini görmek için JavaScript'i açın" + diff --git a/website/locale/zh/LC_MESSAGES/messages.mo b/website/locale/zh/LC_MESSAGES/messages.mo index 3a2aa7f01c6d2f0b874f9aad366eb3c18d563a93..896fedc0658dad52a01dd758ecd94884e4b177d3 100644 GIT binary patch delta 1049 zcmYMyT}V@57{KwTw9@>@W)sVjLurPa=9b#0g~3dMs4l%6^Qeot!R8G5K(nw9Lj`L= zh~6Yg1tLOOD&2G=6y0tC zRPo!+@6{TO{(k}~BDsXExEZhDMjXI=9Kuw5hMREO@-^!I54Z~#a2wj#td?PcNQcxj z$YY`rx8OyLVLxV4OvyTtCF08UBDLt;Ai`IITv(EJ)I^u8`CfDr$FK-zF%uV16EC9= z^U_3e$S)TdY-OScZ8(BdCX+}F@(z#Ud(6Q6^wk22P}iNP9dcn5J*WjuVF54j2FWR3 zXqyuk@dOs~umj|mCI%iHMr~~ZYw!osH7Te3wdh8gAXTVuegsSKIChih9P*XLtkt7f zLEWF7z50T7)OfEIS7XNxCeAQWgO;~ZTlWZe;#;)iPisAmgDxcAjqT_`J*sK^Mm(D% zvLBz)1}$g-S(0Vc4rg%DLJDp4-@%}m32pgV)QzpEZ+00Qa0Io0zt*~)e(QsaQRm&L z53I*(JdJc+x~=(s%X_Hz4dE$#oJ;@p#y?E_M*RnByo6fV3ZBGLvK+=JYJzdpqnfwk zU#Le_nr9suY9cr4^N!&jtV5}7Z1lJJLqTuA@J;wr&ZpHhgrbJe8#KIuNXUprOrx#E zG(us2vtKuPg3SScq{V1A!x3&Xyb;4|gv};1YzBR1`M{@)p{&X>SC!$~cgS_nQBg5* zE3+WIdai3U{(LymHx{27iO;-D-Wg5w4ksS=B=29F?-`$qT~FS;F*o=mJ~J4fe39tu Pn(w^&xwC8FfxYe@(;}Ld delta 901 zcmYMyPe@cz6vy%7jOke8pYd-sV_FW3G-m3g4GKbnL_yF(l0ZceL{x$nxe+uGW@!tt zg&+hOB`TP%5(f+f30k-j6=X;d5)0i#LaV+%yx?PIKKGvc=ACoTeWz8&(a}_X`jm0q z;~V0;mZsUo)!{WOVA_cRe2JHF9IxU8rsGG<#RcaY>i+LofhoL>9&VPU7&IHTID=vW zZCHo{_!eKIpJGZbnVm5YXP7;}P^K9l>*9wc>qR9Rbny|aW1he;enCH`P>FwG4`%qx z^2l%f46YFv#(bPYDzi^W4Yq;J_zkb1FYCO3LezQ))uEgC3hPk?&0~-aB$1r9N876K z03Tuw4~vuEo-t^}H>lQbBi*te=)pr|^Y#<9;}eYFA54%S#P+nq_u1!1u!OpQ9ksDd zH$QOmBP=EE$)W!mlrxacsFro$EgZuloOSD~c!T*a4&fQWDr#=THe2QHfWv n62BI$^m`M&$!h;hcI-~9ro6Vkv9>N+6I\n" "Language: zh\n" @@ -71,11 +71,15 @@ msgstr "" "本文档页面的以下内容已经过机器翻译。 但与其他网站不同，它不是在飞行中完成。 " "这个翻译的文本生活在github存储库旁边的主ClickHouse代码库，并等待同胞母语，使其更具人类可读性。" +#: templates/docs/content.html:7 +msgid "You can also use the original English version as a reference." +msgstr "您也可以使用原始的英文版本作为参考。" + #: templates/docs/content.html:10 msgid "Help ClickHouse documentation by editing this page" msgstr "通过编辑此页面帮助ClickHouse文档" -#: templates/docs/content.html:31 +#: templates/docs/content.html:27 msgid "Built from" msgstr "建于" @@ -175,15 +179,15 @@ msgstr "电子邮件讨论" msgid "Like ClickHouse?" msgstr "像克里克豪斯？" -#: templates/index/community.html:142 +#: templates/index/community.html:143 msgid "Help to spread the word about it via" msgstr "帮助通过传播这个词" -#: templates/index/community.html:143 +#: templates/index/community.html:144 msgid "and" msgstr "和" -#: templates/index/community.html:155 +#: templates/index/community.html:153 msgid "Hosting ClickHouse Meetups" msgstr "碌莽禄Hosting拢Hosting0755-88888888" diff --git a/website/templates/docs/content.html b/website/templates/docs/content.html index d4ff1fd8554..2ad6855a684 100644 --- a/website/templates/docs/content.html +++ b/website/templates/docs/content.html @@ -4,7 +4,7 @@ {% if page.meta.machine_translated %} From 23ae3f4bffbb04b3a348d0553b831d4dc012215b Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Thu, 16 Apr 2020 00:43:58 +0300 Subject: [PATCH 38/73] Update select_format.xml --- tests/performance/select_format.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/performance/select_format.xml b/tests/performance/select_format.xml index e47d981c4d7..2bdbde83c2d 100644 --- a/tests/performance/select_format.xml +++ b/tests/performance/select_format.xml @@ -44,7 +44,7 @@ ODBCDriver2 MySQLWire Avro - MsgPack + From b2f2ceba1f52ceb6ba1b266f25659efbd9c708cb Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Thu, 16 Apr 2020 03:44:46 +0300 Subject: [PATCH 39/73] Update adopters.md --- docs/en/introduction/adopters.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/en/introduction/adopters.md b/docs/en/introduction/adopters.md index a1494c23066..55718e71feb 100644 --- a/docs/en/introduction/adopters.md +++ b/docs/en/introduction/adopters.md @@ -76,6 +76,6 @@ toc_title: Adopters | [ЦВТ](https://htc-cs.ru/) | Software Development | Metrics, Logging | — | — | [Blog Post, March 2019, in Russian](https://vc.ru/dev/62715-kak-my-stroili-monitoring-na-prometheus-clickhouse-i-elk) | | [МКБ](https://mkb.ru/) | Bank | Web-system monitoring | — | — | [Slides in Russian, September 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup28/mkb.pdf) | | [金数据](https://jinshuju.net) | BI Analytics | Main product | — | — | [Slides in Chinese, October 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup24/3.%20金数据数据架构调整方案Public.pdf) | -| [Instana](https://www.instana.com) | APM Platform | Main product | — | — | [Twitter post](https://twitter.com/mieldonkers/status/1248884119158882304) | +| [Instana](https://www.instana.com) | APM Platform | Main product | — | — | [Twitter post](https://twitter.com/mieldonkers/status/1248884119158882304) | [Wargaming](https://wargaming.com/en/) | | | — | — | [Interview](https://habr.com/en/post/496954/) | [Original article](https://clickhouse.tech/docs/en/introduction/adopters/) From 074fdb016b75b04b90ddf737aa1a2fad948fdaa8 Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Thu, 16 Apr 2020 03:46:24 +0300 Subject: [PATCH 40/73] Update adopters.md --- docs/en/introduction/adopters.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docs/en/introduction/adopters.md b/docs/en/introduction/adopters.md index 55718e71feb..be886576c1b 100644 --- a/docs/en/introduction/adopters.md +++ b/docs/en/introduction/adopters.md @@ -76,6 +76,7 @@ toc_title: Adopters | [ЦВТ](https://htc-cs.ru/) | Software Development | Metrics, Logging | — | — | [Blog Post, March 2019, in Russian](https://vc.ru/dev/62715-kak-my-stroili-monitoring-na-prometheus-clickhouse-i-elk) | | [МКБ](https://mkb.ru/) | Bank | Web-system monitoring | — | — | [Slides in Russian, September 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup28/mkb.pdf) | | [金数据](https://jinshuju.net) | BI Analytics | Main product | — | — | [Slides in Chinese, October 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup24/3.%20金数据数据架构调整方案Public.pdf) | -| [Instana](https://www.instana.com) | APM Platform | Main product | — | — | [Twitter post](https://twitter.com/mieldonkers/status/1248884119158882304) | [Wargaming](https://wargaming.com/en/) | | | — | — | [Interview](https://habr.com/en/post/496954/) | +| [Instana](https://www.instana.com) | APM Platform | Main product | — | — | [Twitter post](https://twitter.com/mieldonkers/status/1248884119158882304) | +| [Wargaming](https://wargaming.com/en/) | | | — | — | [Interview](https://habr.com/en/post/496954/) | [Original article](https://clickhouse.tech/docs/en/introduction/adopters/) From 868d28be7b197904c1e86626d87b61892acf17e2 Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Thu, 16 Apr 2020 03:46:59 +0300 Subject: [PATCH 41/73] Update adopters.md --- docs/en/introduction/adopters.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/en/introduction/adopters.md b/docs/en/introduction/adopters.md index be886576c1b..4e3fd4d5f4b 100644 --- a/docs/en/introduction/adopters.md +++ b/docs/en/introduction/adopters.md @@ -77,6 +77,6 @@ toc_title: Adopters | [МКБ](https://mkb.ru/) | Bank | Web-system monitoring | — | — | [Slides in Russian, September 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup28/mkb.pdf) | | [金数据](https://jinshuju.net) | BI Analytics | Main product | — | — | [Slides in Chinese, October 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup24/3.%20金数据数据架构调整方案Public.pdf) | | [Instana](https://www.instana.com) | APM Platform | Main product | — | — | [Twitter post](https://twitter.com/mieldonkers/status/1248884119158882304) | -| [Wargaming](https://wargaming.com/en/) | | | — | — | [Interview](https://habr.com/en/post/496954/) | +| [Wargaming](https://wargaming.com/en/) | Online games | | — | — | [Interview](https://habr.com/en/post/496954/) | [Original article](https://clickhouse.tech/docs/en/introduction/adopters/) From 01d3c8319354bfc2abadd4befa9aba717634e776 Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Thu, 16 Apr 2020 03:48:07 +0300 Subject: [PATCH 42/73] Update adopters.md --- docs/en/introduction/adopters.md | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/docs/en/introduction/adopters.md b/docs/en/introduction/adopters.md index 4e3fd4d5f4b..b1463727b70 100644 --- a/docs/en/introduction/adopters.md +++ b/docs/en/introduction/adopters.md @@ -77,6 +77,8 @@ toc_title: Adopters | [МКБ](https://mkb.ru/) | Bank | Web-system monitoring | — | — | [Slides in Russian, September 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup28/mkb.pdf) | | [金数据](https://jinshuju.net) | BI Analytics | Main product | — | — | [Slides in Chinese, October 2019](https://github.com/ClickHouse/clickhouse-presentations/blob/master/meetup24/3.%20金数据数据架构调整方案Public.pdf) | | [Instana](https://www.instana.com) | APM Platform | Main product | — | — | [Twitter post](https://twitter.com/mieldonkers/status/1248884119158882304) | -| [Wargaming](https://wargaming.com/en/) | Online games | | — | — | [Interview](https://habr.com/en/post/496954/) | +| [Wargaming](https://wargaming.com/en/) | Games | | — | — | [Interview](https://habr.com/en/post/496954/) | +| [Crazypanda](https://crazypanda.ru/en/) | Games | | — | — | Live session on ClickHouse meetup | + [Original article](https://clickhouse.tech/docs/en/introduction/adopters/) From 2a7396e41d46b1f9d9d708ce001ab9acfc5d4f14 Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Thu, 16 Apr 2020 03:49:47 +0300 Subject: [PATCH 43/73] Update adopters.md --- docs/en/introduction/adopters.md | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/en/introduction/adopters.md b/docs/en/introduction/adopters.md index b1463727b70..c6f2a63c1be 100644 --- a/docs/en/introduction/adopters.md +++ b/docs/en/introduction/adopters.md @@ -79,6 +79,7 @@ toc_title: Adopters | [Instana](https://www.instana.com) | APM Platform | Main product | — | — | [Twitter post](https://twitter.com/mieldonkers/status/1248884119158882304) | | [Wargaming](https://wargaming.com/en/) | Games | | — | — | [Interview](https://habr.com/en/post/496954/) | | [Crazypanda](https://crazypanda.ru/en/) | Games | | — | — | Live session on ClickHouse meetup | +| [FunCorp](https://fun.co/rp) | Games | | — | — | [Article](https://habr.com/en/company/funcorp/blog/433346/) | [Original article](https://clickhouse.tech/docs/en/introduction/adopters/) From 725969289ed6ae599c02f63176a2090a8e10d3b1 Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Thu, 16 Apr 2020 03:50:44 +0300 Subject: [PATCH 44/73] Update adopters.md --- docs/en/introduction/adopters.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/en/introduction/adopters.md b/docs/en/introduction/adopters.md index c6f2a63c1be..b75b1c942eb 100644 --- a/docs/en/introduction/adopters.md +++ b/docs/en/introduction/adopters.md @@ -79,7 +79,7 @@ toc_title: Adopters | [Instana](https://www.instana.com) | APM Platform | Main product | — | — | [Twitter post](https://twitter.com/mieldonkers/status/1248884119158882304) | | [Wargaming](https://wargaming.com/en/) | Games | | — | — | [Interview](https://habr.com/en/post/496954/) | | [Crazypanda](https://crazypanda.ru/en/) | Games | | — | — | Live session on ClickHouse meetup | -| [FunCorp](https://fun.co/rp) | Games | | — | — | [Article](https://habr.com/en/company/funcorp/blog/433346/) | +| [FunCorp](https://fun.co/rp) | Games | | — | — | [Article](https://www.altinity.com/blog/migrating-from-redshift-to-clickhouse) | [Original article](https://clickhouse.tech/docs/en/introduction/adopters/) From cdeda4ab91542e9bc23c75e62aee0aa2a5aea573 Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Wed, 15 Apr 2020 23:28:05 +0300 Subject: [PATCH 45/73] Fix usage of max_parser_depth setting; remove harmful default function arguments --- programs/client/Client.cpp | 8 +- programs/compressor/Compressor.cpp | 3 +- programs/copier/ClusterCopier.cpp | 22 +- programs/copier/TaskTableAndShard.h | 10 +- programs/format/Format.cpp | 2 +- programs/local/LocalServer.cpp | 4 +- programs/odbc-bridge/ColumnInfoHandler.cpp | 4 +- src/Access/DiskAccessStorage.cpp | 3 +- src/Access/RowPolicyCache.cpp | 3 +- .../parseAggregateFunctionParameters.cpp | 3 +- .../tests/gtest_compressionCodec.cpp | 2 +- src/Core/Defines.h | 3 + src/Core/Settings.h | 2 +- src/DataStreams/tests/expression_stream.cpp | 2 +- src/DataStreams/tests/filter_stream.cpp | 2 +- src/DataTypes/DataTypeFactory.cpp | 4 +- src/Databases/DatabaseOrdinary.cpp | 3 +- .../tests/gtest_dictionary_configuration.cpp | 8 +- src/Interpreters/DDLWorker.cpp | 2 +- src/Interpreters/InterpreterCreateQuery.cpp | 8 +- .../InterpreterKillQueryQuery.cpp | 2 +- src/Interpreters/InterpreterSelectQuery.cpp | 2 +- ...InterpreterShowCreateAccessEntityQuery.cpp | 23 +- .../JoinToSubqueryTransformVisitor.cpp | 3 +- src/Interpreters/SyntaxAnalyzer.cpp | 3 +- src/Interpreters/SystemLog.h | 3 +- src/Interpreters/loadMetadata.cpp | 2 +- src/Interpreters/tests/CMakeLists.txt | 3 - src/Interpreters/tests/create_query.cpp | 2 +- src/Interpreters/tests/expression.cpp | 2 +- .../tests/expression_analyzer.cpp | 2 +- .../tests/gtest_cycle_aliases.cpp | 6 +- .../tests/in_join_subqueries_preprocessor.cpp | 2 +- .../tests/logical_expressions_optimizer.cpp | 295 ------------------ src/Parsers/IParser.h | 2 - src/Parsers/parseQuery.cpp | 21 +- src/Parsers/parseQuery.h | 20 +- src/Parsers/tests/create_parser.cpp | 2 +- src/Parsers/tests/gtest_dictionary_parser.cpp | 18 +- src/Parsers/tests/select_parser.cpp | 2 +- src/Storages/ColumnsDescription.cpp | 4 +- src/Storages/ConstraintsDescription.cpp | 4 +- src/Storages/IndicesDescription.cpp | 5 +- src/Storages/MutationCommands.cpp | 3 +- src/Storages/StorageReplicatedMergeTree.cpp | 9 +- src/Storages/getStructureOfRemoteTable.cpp | 2 +- ..._transform_query_for_external_database.cpp | 2 +- .../parseColumnsListForTableFunction.cpp | 4 +- 48 files changed, 152 insertions(+), 394 deletions(-) delete mode 100644 src/Interpreters/tests/logical_expressions_optimizer.cpp diff --git a/programs/client/Client.cpp b/programs/client/Client.cpp index e01eef98006..e4c046d18ba 100644 --- a/programs/client/Client.cpp +++ b/programs/client/Client.cpp @@ -684,7 +684,7 @@ private: if (ignore_error) { Tokens tokens(begin, end); - IParser::Pos token_iterator(tokens); + IParser::Pos token_iterator(tokens, context.getSettingsRef().max_parser_depth); while (token_iterator->type != TokenType::Semicolon && token_iterator.isValid()) ++token_iterator; begin = token_iterator->end; @@ -958,10 +958,12 @@ private: ParserQuery parser(end, true); ASTPtr res; + const auto & settings = context.getSettingsRef(); + if (is_interactive || ignore_error) { String message; - res = tryParseQuery(parser, pos, end, message, true, "", allow_multi_statements, 0); + res = tryParseQuery(parser, pos, end, message, true, "", allow_multi_statements, settings.max_query_size, settings.max_parser_depth); if (!res) { @@ -970,7 +972,7 @@ private: } } else - res = parseQueryAndMovePosition(parser, pos, end, "", allow_multi_statements, 0); + res = parseQueryAndMovePosition(parser, pos, end, "", allow_multi_statements, settings.max_query_size, settings.max_parser_depth); if (is_interactive) { diff --git a/programs/compressor/Compressor.cpp b/programs/compressor/Compressor.cpp index 98a3055da28..fecdad9bcea 100644 --- a/programs/compressor/Compressor.cpp +++ b/programs/compressor/Compressor.cpp @@ -14,6 +14,7 @@ #include #include #include +#include namespace DB @@ -123,7 +124,7 @@ int mainEntryClickHouseCompressor(int argc, char ** argv) DB::ParserCodec codec_parser; std::string codecs_line = boost::algorithm::join(codecs, ","); - auto ast = DB::parseQuery(codec_parser, "(" + codecs_line + ")", 0); + auto ast = DB::parseQuery(codec_parser, "(" + codecs_line + ")", 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); codec = DB::CompressionCodecFactory::instance().get(ast, nullptr); } else diff --git a/programs/copier/ClusterCopier.cpp b/programs/copier/ClusterCopier.cpp index c4714ff201f..cd5b1e2a2cd 100644 --- a/programs/copier/ClusterCopier.cpp +++ b/programs/copier/ClusterCopier.cpp @@ -1197,7 +1197,9 @@ TaskStatus ClusterCopier::processPartitionPieceTaskImpl( query += " LIMIT " + limit; ParserQuery p_query(query.data() + query.size()); - return parseQuery(p_query, query, 0); + + const auto & settings = context.getSettingsRef(); + return parseQuery(p_query, query, settings.max_query_size, settings.max_parser_depth); }; /// Load balancing @@ -1409,7 +1411,8 @@ TaskStatus ClusterCopier::processPartitionPieceTaskImpl( query += "INSERT INTO " + getQuotedTable(split_table_for_current_piece) + " VALUES "; ParserQuery p_query(query.data() + query.size()); - query_insert_ast = parseQuery(p_query, query, 0); + const auto & settings = context.getSettingsRef(); + query_insert_ast = parseQuery(p_query, query, settings.max_query_size, settings.max_parser_depth); LOG_DEBUG(log, "Executing INSERT query: " << query); } @@ -1634,7 +1637,8 @@ ASTPtr ClusterCopier::getCreateTableForPullShard(const ConnectionTimeouts & time &task_cluster->settings_pull); ParserCreateQuery parser_create_query; - return parseQuery(parser_create_query, create_query_pull_str, 0); + const auto & settings = context.getSettingsRef(); + return parseQuery(parser_create_query, create_query_pull_str, settings.max_query_size, settings.max_parser_depth); } /// If it is implicitly asked to create split Distributed table for certain piece on current shard, we will do it. @@ -1712,7 +1716,8 @@ std::set ClusterCopier::getShardPartitions(const ConnectionTimeouts & ti } ParserQuery parser_query(query.data() + query.size()); - ASTPtr query_ast = parseQuery(parser_query, query, 0); + const auto & settings = context.getSettingsRef(); + ASTPtr query_ast = parseQuery(parser_query, query, settings.max_query_size, settings.max_parser_depth); LOG_DEBUG(log, "Computing destination partition set, executing query: " << query); @@ -1759,7 +1764,8 @@ bool ClusterCopier::checkShardHasPartition(const ConnectionTimeouts & timeouts, << partition_quoted_name << " existence, executing query: " << query); ParserQuery parser_query(query.data() + query.size()); - ASTPtr query_ast = parseQuery(parser_query, query, 0); +const auto & settings = context.getSettingsRef(); + ASTPtr query_ast = parseQuery(parser_query, query, settings.max_query_size, settings.max_parser_depth); Context local_context = context; local_context.setSettings(task_cluster->settings_pull); @@ -1793,7 +1799,8 @@ bool ClusterCopier::checkPresentPartitionPiecesOnCurrentShard(const ConnectionTi << "existence, executing query: " << query); ParserQuery parser_query(query.data() + query.size()); - ASTPtr query_ast = parseQuery(parser_query, query, 0); + const auto & settings = context.getSettingsRef(); + ASTPtr query_ast = parseQuery(parser_query, query, settings.max_query_size, settings.max_parser_depth); Context local_context = context; local_context.setSettings(task_cluster->settings_pull); @@ -1826,7 +1833,8 @@ UInt64 ClusterCopier::executeQueryOnCluster( if (query_ast_ == nullptr) { ParserQuery p_query(query.data() + query.size()); - query_ast = parseQuery(p_query, query, 0); + const auto & settings = context.getSettingsRef(); + query_ast = parseQuery(p_query, query, settings.max_query_size, settings.max_parser_depth); } else query_ast = query_ast_; diff --git a/programs/copier/TaskTableAndShard.h b/programs/copier/TaskTableAndShard.h index 615ad297b79..32841e93a14 100644 --- a/programs/copier/TaskTableAndShard.h +++ b/programs/copier/TaskTableAndShard.h @@ -4,6 +4,9 @@ #include "Internals.h" #include "ClusterPartition.h" +#include + + namespace DB { namespace ErrorCodes @@ -260,9 +263,10 @@ inline TaskTable::TaskTable(TaskCluster & parent, const Poco::Util::AbstractConf + "." + escapeForFileName(table_push.second); engine_push_str = config.getString(table_prefix + "engine"); + { ParserStorage parser_storage; - engine_push_ast = parseQuery(parser_storage, engine_push_str, 0); + engine_push_ast = parseQuery(parser_storage, engine_push_str, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); engine_push_partition_key_ast = extractPartitionKey(engine_push_ast); primary_key_comma_separated = createCommaSeparatedStringFrom(extractPrimaryKeyColumnNames(engine_push_ast)); engine_push_zk_path = extractReplicatedTableZookeeperPath(engine_push_ast); @@ -273,7 +277,7 @@ inline TaskTable::TaskTable(TaskCluster & parent, const Poco::Util::AbstractConf auxiliary_engine_split_asts.reserve(number_of_splits); { ParserExpressionWithOptionalAlias parser_expression(false); - sharding_key_ast = parseQuery(parser_expression, sharding_key_str, 0); + sharding_key_ast = parseQuery(parser_expression, sharding_key_str, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); main_engine_split_ast = createASTStorageDistributed(cluster_push_name, table_push.first, table_push.second, sharding_key_ast); @@ -291,7 +295,7 @@ inline TaskTable::TaskTable(TaskCluster & parent, const Poco::Util::AbstractConf if (!where_condition_str.empty()) { ParserExpressionWithOptionalAlias parser_expression(false); - where_condition_ast = parseQuery(parser_expression, where_condition_str, 0); + where_condition_ast = parseQuery(parser_expression, where_condition_str, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); // Will use canonical expression form where_condition_str = queryToString(where_condition_ast); diff --git a/programs/format/Format.cpp b/programs/format/Format.cpp index f826d6394bc..b5a4e2d1603 100644 --- a/programs/format/Format.cpp +++ b/programs/format/Format.cpp @@ -53,7 +53,7 @@ int mainEntryClickHouseFormat(int argc, char ** argv) const char * end = pos + query.size(); ParserQuery parser(end); - ASTPtr res = parseQuery(parser, pos, end, "query", 0); + ASTPtr res = parseQuery(parser, pos, end, "query", 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); if (!quiet) { diff --git a/programs/local/LocalServer.cpp b/programs/local/LocalServer.cpp index 26752da5d87..1ab07d79401 100644 --- a/programs/local/LocalServer.cpp +++ b/programs/local/LocalServer.cpp @@ -267,8 +267,10 @@ void LocalServer::processQueries() String initial_create_query = getInitialCreateTableQuery(); String queries_str = initial_create_query + config().getRawString("query"); + const auto & settings = context->getSettingsRef(); + std::vector queries; - auto parse_res = splitMultipartQuery(queries_str, queries); + auto parse_res = splitMultipartQuery(queries_str, queries, settings.max_query_size, settings.max_parser_depth); if (!parse_res.second) throw Exception("Cannot parse and execute the following part of query: " + String(parse_res.first), ErrorCodes::SYNTAX_ERROR); diff --git a/programs/odbc-bridge/ColumnInfoHandler.cpp b/programs/odbc-bridge/ColumnInfoHandler.cpp index b89d50569f6..e3c00f48fb5 100644 --- a/programs/odbc-bridge/ColumnInfoHandler.cpp +++ b/programs/odbc-bridge/ColumnInfoHandler.cpp @@ -120,12 +120,14 @@ void ODBCColumnsInfoHandler::handleRequest(Poco::Net::HTTPServerRequest & reques SCOPE_EXIT(SQLFreeStmt(hstmt, SQL_DROP)); + const auto & context_settings = context->getSettingsRef(); + /// TODO Why not do SQLColumns instead? std::string name = schema_name.empty() ? table_name : schema_name + "." + table_name; std::stringstream ss; std::string input = "SELECT * FROM " + name + " WHERE 1 = 0"; ParserQueryWithOutput parser; - ASTPtr select = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr select = parseQuery(parser, input.data(), input.data() + input.size(), "", context_settings.max_query_size, context_settings.max_parser_depth); IAST::FormatSettings settings(ss, true); settings.always_quote_identifiers = true; diff --git a/src/Access/DiskAccessStorage.cpp b/src/Access/DiskAccessStorage.cpp index 12c65e7df1e..d7ba8563f5a 100644 --- a/src/Access/DiskAccessStorage.cpp +++ b/src/Access/DiskAccessStorage.cpp @@ -32,6 +32,7 @@ #include #include #include +#include #include #include #include @@ -93,7 +94,7 @@ namespace const char * end = begin + file_contents.size(); while (pos < end) { - queries.emplace_back(parseQueryAndMovePosition(parser, pos, end, "", true, 0)); + queries.emplace_back(parseQueryAndMovePosition(parser, pos, end, "", true, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH)); while (isWhitespaceASCII(*pos) || *pos == ';') ++pos; } diff --git a/src/Access/RowPolicyCache.cpp b/src/Access/RowPolicyCache.cpp index 44f2cd160d4..fc67b7e9b86 100644 --- a/src/Access/RowPolicyCache.cpp +++ b/src/Access/RowPolicyCache.cpp @@ -8,6 +8,7 @@ #include #include #include +#include namespace DB @@ -77,7 +78,7 @@ void RowPolicyCache::PolicyInfo::setPolicy(const RowPolicyPtr & policy_) try { ParserExpression parser; - parsed_conditions[type] = parseQuery(parser, condition, 0); + parsed_conditions[type] = parseQuery(parser, condition, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); } catch (...) { diff --git a/src/AggregateFunctions/parseAggregateFunctionParameters.cpp b/src/AggregateFunctions/parseAggregateFunctionParameters.cpp index bcb73f1e9d9..2a6b9e3b499 100644 --- a/src/AggregateFunctions/parseAggregateFunctionParameters.cpp +++ b/src/AggregateFunctions/parseAggregateFunctionParameters.cpp @@ -2,6 +2,7 @@ #include #include #include +#include namespace DB @@ -65,7 +66,7 @@ void getAggregateFunctionNameAndParametersArray( ParserExpressionList params_parser(false); ASTPtr args_ast = parseQuery(params_parser, parameters_str.data(), parameters_str.data() + parameters_str.size(), - "parameters of aggregate function in " + error_context, 0); + "parameters of aggregate function in " + error_context, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); if (args_ast->children.empty()) throw Exception("Incorrect list of parameters to aggregate function " diff --git a/src/Compression/tests/gtest_compressionCodec.cpp b/src/Compression/tests/gtest_compressionCodec.cpp index a6bfdaebb14..f3652366a24 100644 --- a/src/Compression/tests/gtest_compressionCodec.cpp +++ b/src/Compression/tests/gtest_compressionCodec.cpp @@ -462,7 +462,7 @@ CompressionCodecPtr makeCodec(const std::string & codec_string, const DataTypePt { const std::string codec_statement = "(" + codec_string + ")"; Tokens tokens(codec_statement.begin().base(), codec_statement.end().base()); - IParser::Pos token_iterator(tokens); + IParser::Pos token_iterator(tokens, 0); Expected expected; ASTPtr codec_ast; diff --git a/src/Core/Defines.h b/src/Core/Defines.h index c797f527be9..fe614cec6bd 100644 --- a/src/Core/Defines.h +++ b/src/Core/Defines.h @@ -95,3 +95,6 @@ /// Actually, there may be multiple acquisitions of different locks for a given table within one query. /// Check with IStorage class for the list of possible locks #define DBMS_DEFAULT_LOCK_ACQUIRE_TIMEOUT_SEC 120 + +/// Default limit on recursion depth of recursive descend parser. +#define DBMS_DEFAULT_MAX_PARSER_DEPTH 1000 diff --git a/src/Core/Settings.h b/src/Core/Settings.h index 725171d4a1b..325abc16f3f 100644 --- a/src/Core/Settings.h +++ b/src/Core/Settings.h @@ -404,7 +404,7 @@ struct Settings : public SettingsCollection M(SettingBool, use_compact_format_in_distributed_parts_names, false, "Changes format of directories names for distributed table insert parts.", 0) \ M(SettingUInt64, multiple_joins_rewriter_version, 1, "1 or 2. Second rewriter version knows about table columns and keep not clashed names as is.", 0) \ M(SettingBool, validate_polygons, true, "Throw exception if polygon is invalid in function pointInPolygon (e.g. self-tangent, self-intersecting). If the setting is false, the function will accept invalid polygons but may silently return wrong result.", 0) \ - M(SettingUInt64, max_parser_depth, 1000, "Maximum parser depth.", 0) \ + M(SettingUInt64, max_parser_depth, DBMS_DEFAULT_MAX_PARSER_DEPTH, "Maximum parser depth (recursion depth of recursive descend parser).", 0) \ M(SettingSeconds, temporary_live_view_timeout, DEFAULT_TEMPORARY_LIVE_VIEW_TIMEOUT_SEC, "Timeout after which temporary live view is deleted.", 0) \ M(SettingBool, transform_null_in, false, "If enabled, NULL values will be matched with 'IN' operator as if they are considered equal.", 0) \ M(SettingBool, allow_nondeterministic_mutations, false, "Allow non-deterministic functions in ALTER UPDATE/ALTER DELETE statements", 0) \ diff --git a/src/DataStreams/tests/expression_stream.cpp b/src/DataStreams/tests/expression_stream.cpp index bd4117f5aab..fbfde018ed6 100644 --- a/src/DataStreams/tests/expression_stream.cpp +++ b/src/DataStreams/tests/expression_stream.cpp @@ -33,7 +33,7 @@ try std::string input = "SELECT number, number / 3, number * number"; ParserSelectQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); Context context = Context::createGlobal(); context.makeGlobalContext(); diff --git a/src/DataStreams/tests/filter_stream.cpp b/src/DataStreams/tests/filter_stream.cpp index 5e324251440..8356b90957c 100644 --- a/src/DataStreams/tests/filter_stream.cpp +++ b/src/DataStreams/tests/filter_stream.cpp @@ -35,7 +35,7 @@ try std::string input = "SELECT number, number % 3 == 1"; ParserSelectQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); formatAST(*ast, std::cerr); std::cerr << std::endl; diff --git a/src/DataTypes/DataTypeFactory.cpp b/src/DataTypes/DataTypeFactory.cpp index 20f7681ec1b..f81adfe347c 100644 --- a/src/DataTypes/DataTypeFactory.cpp +++ b/src/DataTypes/DataTypeFactory.cpp @@ -9,6 +9,8 @@ #include #include #include +#include + namespace DB { @@ -26,7 +28,7 @@ namespace ErrorCodes DataTypePtr DataTypeFactory::get(const String & full_name) const { ParserIdentifierWithOptionalParameters parser; - ASTPtr ast = parseQuery(parser, full_name.data(), full_name.data() + full_name.size(), "data type", 0); + ASTPtr ast = parseQuery(parser, full_name.data(), full_name.data() + full_name.size(), "data type", 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); return get(ast); } diff --git a/src/Databases/DatabaseOrdinary.cpp b/src/Databases/DatabaseOrdinary.cpp index a1f5ea1ae6f..11c4a4400cd 100644 --- a/src/Databases/DatabaseOrdinary.cpp +++ b/src/Databases/DatabaseOrdinary.cpp @@ -234,7 +234,8 @@ void DatabaseOrdinary::alterTable( } ParserCreateQuery parser; - ASTPtr ast = parseQuery(parser, statement.data(), statement.data() + statement.size(), "in file " + table_metadata_path, 0); + ASTPtr ast = parseQuery(parser, statement.data(), statement.data() + statement.size(), "in file " + table_metadata_path, + 0, context.getSettingsRef().max_parser_depth); auto & ast_create_query = ast->as(); diff --git a/src/Dictionaries/tests/gtest_dictionary_configuration.cpp b/src/Dictionaries/tests/gtest_dictionary_configuration.cpp index 9c1ad9467b0..ae9c5385b8d 100644 --- a/src/Dictionaries/tests/gtest_dictionary_configuration.cpp +++ b/src/Dictionaries/tests/gtest_dictionary_configuration.cpp @@ -52,7 +52,7 @@ TEST(ConvertDictionaryAST, SimpleDictConfiguration) " RANGE(MIN second_column MAX third_column)"; ParserCreateDictionaryQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); ASTCreateQuery * create = ast->as(); DictionaryConfigurationPtr config = getDictionaryConfigurationFromAST(*create); @@ -120,7 +120,7 @@ TEST(ConvertDictionaryAST, TrickyAttributes) " SOURCE(CLICKHOUSE(HOST 'localhost'))"; ParserCreateDictionaryQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); ASTCreateQuery * create = ast->as(); DictionaryConfigurationPtr config = getDictionaryConfigurationFromAST(*create); @@ -165,7 +165,7 @@ TEST(ConvertDictionaryAST, ComplexKeyAndLayoutWithParams) " LIFETIME(MIN 1 MAX 10)"; ParserCreateDictionaryQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); ASTCreateQuery * create = ast->as(); DictionaryConfigurationPtr config = getDictionaryConfigurationFromAST(*create); @@ -216,7 +216,7 @@ TEST(ConvertDictionaryAST, ComplexSource) " RANGE(MIN second_column MAX third_column)"; ParserCreateDictionaryQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); ASTCreateQuery * create = ast->as(); DictionaryConfigurationPtr config = getDictionaryConfigurationFromAST(*create); /// source diff --git a/src/Interpreters/DDLWorker.cpp b/src/Interpreters/DDLWorker.cpp index 4a39cc6b8a1..e786849d121 100644 --- a/src/Interpreters/DDLWorker.cpp +++ b/src/Interpreters/DDLWorker.cpp @@ -463,7 +463,7 @@ void DDLWorker::parseQueryAndResolveHost(DDLTask & task) ParserQuery parser_query(end); String description; - task.query = parseQuery(parser_query, begin, end, description, 0); + task.query = parseQuery(parser_query, begin, end, description, 0, context.getSettingsRef().max_parser_depth); } // XXX: serious design flaw since `ASTQueryWithOnCluster` is not inherited from `IAST`! diff --git a/src/Interpreters/InterpreterCreateQuery.cpp b/src/Interpreters/InterpreterCreateQuery.cpp index 076b654548b..37e2c8c5945 100644 --- a/src/Interpreters/InterpreterCreateQuery.cpp +++ b/src/Interpreters/InterpreterCreateQuery.cpp @@ -6,6 +6,8 @@ #include #include +#include + #include #include @@ -181,7 +183,7 @@ ASTPtr InterpreterCreateQuery::formatColumns(const NamesAndTypesList & columns) String type_name = column.type->getName(); auto pos = type_name.data(); const auto end = pos + type_name.size(); - column_declaration->type = parseQuery(storage_p, pos, end, "data type", 0); + column_declaration->type = parseQuery(storage_p, pos, end, "data type", 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); columns_list->children.emplace_back(column_declaration); } @@ -207,7 +209,7 @@ ASTPtr InterpreterCreateQuery::formatColumns(const ColumnsDescription & columns) String type_name = column.type->getName(); auto type_name_pos = type_name.data(); const auto type_name_end = type_name_pos + type_name.size(); - column_declaration->type = parseQuery(storage_p, type_name_pos, type_name_end, "data type", 0); + column_declaration->type = parseQuery(storage_p, type_name_pos, type_name_end, "data type", 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); if (column.default_desc.expression) { @@ -227,7 +229,7 @@ ASTPtr InterpreterCreateQuery::formatColumns(const ColumnsDescription & columns) auto codec_desc_pos = codec_desc.data(); const auto codec_desc_end = codec_desc_pos + codec_desc.size(); ParserIdentifierWithParameters codec_p; - column_declaration->codec = parseQuery(codec_p, codec_desc_pos, codec_desc_end, "column codec", 0); + column_declaration->codec = parseQuery(codec_p, codec_desc_pos, codec_desc_end, "column codec", 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); } if (column.ttl) diff --git a/src/Interpreters/InterpreterKillQueryQuery.cpp b/src/Interpreters/InterpreterKillQueryQuery.cpp index b23d88524e1..23f39ab3fc5 100644 --- a/src/Interpreters/InterpreterKillQueryQuery.cpp +++ b/src/Interpreters/InterpreterKillQueryQuery.cpp @@ -267,7 +267,7 @@ BlockIO InterpreterKillQueryQuery::execute() else { ParserAlterCommand parser; - auto command_ast = parseQuery(parser, command_col.getDataAt(i).toString(), 0); + auto command_ast = parseQuery(parser, command_col.getDataAt(i).toString(), 0, context.getSettingsRef().max_parser_depth); required_access_rights = InterpreterAlterQuery::getRequiredAccessForCommand(command_ast->as(), table_id.database_name, table_id.table_name); if (!access->isGranted(&Poco::Logger::get("InterpreterKillQueryQuery"), required_access_rights)) { diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp index 82fc4d0873e..691b3c1045b 100644 --- a/src/Interpreters/InterpreterSelectQuery.cpp +++ b/src/Interpreters/InterpreterSelectQuery.cpp @@ -137,7 +137,7 @@ String InterpreterSelectQuery::generateFilterActions(ExpressionActionsPtr & acti for (const auto & column_str : prerequisite_columns) { ParserExpression expr_parser; - expr_list->children.push_back(parseQuery(expr_parser, column_str, 0)); + expr_list->children.push_back(parseQuery(expr_parser, column_str, 0, context->getSettingsRef().max_parser_depth)); } select_ast->setExpression(ASTSelectQuery::Expression::TABLES, std::make_shared()); diff --git a/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp b/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp index 4c2dcc19a88..0d3b88facce 100644 --- a/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp +++ b/src/Interpreters/InterpreterShowCreateAccessEntityQuery.cpp @@ -21,6 +21,7 @@ #include #include #include +#include #include #include @@ -37,7 +38,7 @@ namespace ASTPtr getCreateQueryImpl( const User & user, const AccessControlManager * manager /* not used if attach_mode == true */, - bool attach_mode = false) + bool attach_mode) { auto query = std::make_shared(); query->name = user.getName(); @@ -72,7 +73,7 @@ namespace } - ASTPtr getCreateQueryImpl(const Role & role, const AccessControlManager * manager, bool attach_mode = false) + ASTPtr getCreateQueryImpl(const Role & role, const AccessControlManager * manager, bool attach_mode) { auto query = std::make_shared(); query->name = role.getName(); @@ -90,7 +91,7 @@ namespace } - ASTPtr getCreateQueryImpl(const SettingsProfile & profile, const AccessControlManager * manager, bool attach_mode = false) + ASTPtr getCreateQueryImpl(const SettingsProfile & profile, const AccessControlManager * manager, bool attach_mode) { auto query = std::make_shared(); query->name = profile.getName(); @@ -121,7 +122,7 @@ namespace ASTPtr getCreateQueryImpl( const Quota & quota, const AccessControlManager * manager /* not used if attach_mode == true */, - bool attach_mode = false) + bool attach_mode) { auto query = std::make_shared(); query->name = quota.getName(); @@ -156,7 +157,7 @@ namespace ASTPtr getCreateQueryImpl( const RowPolicy & policy, const AccessControlManager * manager /* not used if attach_mode == true */, - bool attach_mode = false) + bool attach_mode) { auto query = std::make_shared(); query->name_parts = RowPolicy::FullNameParts{policy.getDatabase(), policy.getTableName(), policy.getName()}; @@ -171,7 +172,7 @@ namespace if (!condition.empty()) { ParserExpression parser; - ASTPtr expr = parseQuery(parser, condition, 0); + ASTPtr expr = parseQuery(parser, condition, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); query->conditions.push_back(std::pair{index, expr}); } } @@ -190,7 +191,7 @@ namespace ASTPtr getCreateQueryImpl( const IAccessEntity & entity, const AccessControlManager * manager /* not used if attach_mode == true */, - bool attach_mode = false) + bool attach_mode) { if (const User * user = typeid_cast(&entity)) return getCreateQueryImpl(*user, manager, attach_mode); @@ -264,24 +265,24 @@ ASTPtr InterpreterShowCreateAccessEntityQuery::getCreateQuery(const ASTShowCreat if (show_query.current_user) { auto user = context.getUser(); - return getCreateQueryImpl(*user, &access_control); + return getCreateQueryImpl(*user, &access_control, false); } if (show_query.current_quota) { auto quota = access_control.read(context.getQuota()->getUsageInfo().quota_id); - return getCreateQueryImpl(*quota, &access_control); + return getCreateQueryImpl(*quota, &access_control, false); } auto type = getType(show_query.kind); if (show_query.kind == Kind::ROW_POLICY) { RowPolicyPtr policy = access_control.read(show_query.row_policy_name.getFullName(context)); - return getCreateQueryImpl(*policy, &access_control); + return getCreateQueryImpl(*policy, &access_control, false); } auto entity = access_control.read(access_control.getID(type, show_query.name)); - return getCreateQueryImpl(*entity, &access_control); + return getCreateQueryImpl(*entity, &access_control, false); } diff --git a/src/Interpreters/JoinToSubqueryTransformVisitor.cpp b/src/Interpreters/JoinToSubqueryTransformVisitor.cpp index 331c364c5fa..6a08e11ad9e 100644 --- a/src/Interpreters/JoinToSubqueryTransformVisitor.cpp +++ b/src/Interpreters/JoinToSubqueryTransformVisitor.cpp @@ -14,6 +14,7 @@ #include #include #include +#include namespace DB @@ -35,7 +36,7 @@ namespace ASTPtr makeSubqueryTemplate() { ParserTablesInSelectQueryElement parser(true); - ASTPtr subquery_template = parseQuery(parser, "(select * from _t) as `--.s`", 0); + ASTPtr subquery_template = parseQuery(parser, "(select * from _t) as `--.s`", 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); if (!subquery_template) throw Exception("Cannot parse subquery template", ErrorCodes::LOGICAL_ERROR); return subquery_template; diff --git a/src/Interpreters/SyntaxAnalyzer.cpp b/src/Interpreters/SyntaxAnalyzer.cpp index 5c1b6c7e62b..e19961e7a7c 100644 --- a/src/Interpreters/SyntaxAnalyzer.cpp +++ b/src/Interpreters/SyntaxAnalyzer.cpp @@ -1,4 +1,5 @@ #include +#include #include #include @@ -587,7 +588,7 @@ void replaceJoinedTable(const ASTSelectQuery & select_query) if (table_id.alias.empty() && table_id.isShort()) { ParserTableExpression parser; - table_expr = parseQuery(parser, expr, 0)->as(); + table_expr = parseQuery(parser, expr, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH)->as(); } } } diff --git a/src/Interpreters/SystemLog.h b/src/Interpreters/SystemLog.h index 7c8dc1606f7..9b0c273674c 100644 --- a/src/Interpreters/SystemLog.h +++ b/src/Interpreters/SystemLog.h @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -460,7 +461,7 @@ ASTPtr SystemLog::getCreateTableQuery() ParserStorage storage_parser; ASTPtr storage_ast = parseQuery( storage_parser, storage_def.data(), storage_def.data() + storage_def.size(), - "Storage to create table for " + LogElement::name(), 0); + "Storage to create table for " + LogElement::name(), 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); create->set(create->storage, storage_ast); return create; diff --git a/src/Interpreters/loadMetadata.cpp b/src/Interpreters/loadMetadata.cpp index 53954faa2c0..42bef47a501 100644 --- a/src/Interpreters/loadMetadata.cpp +++ b/src/Interpreters/loadMetadata.cpp @@ -36,7 +36,7 @@ static void executeCreateQuery( bool has_force_restore_data_flag) { ParserCreateQuery parser; - ASTPtr ast = parseQuery(parser, query.data(), query.data() + query.size(), "in file " + file_name, 0); + ASTPtr ast = parseQuery(parser, query.data(), query.data() + query.size(), "in file " + file_name, 0, context.getSettingsRef().max_parser_depth); auto & ast_create_query = ast->as(); ast_create_query.attach = true; diff --git a/src/Interpreters/tests/CMakeLists.txt b/src/Interpreters/tests/CMakeLists.txt index da45c1a5153..26ebf007e6c 100644 --- a/src/Interpreters/tests/CMakeLists.txt +++ b/src/Interpreters/tests/CMakeLists.txt @@ -47,9 +47,6 @@ add_executable (two_level_hash_map two_level_hash_map.cpp) target_include_directories (two_level_hash_map SYSTEM BEFORE PRIVATE ${SPARSEHASH_INCLUDE_DIR}) target_link_libraries (two_level_hash_map PRIVATE dbms) -add_executable (logical_expressions_optimizer logical_expressions_optimizer.cpp) -target_link_libraries (logical_expressions_optimizer PRIVATE dbms clickhouse_parsers) - add_executable (in_join_subqueries_preprocessor in_join_subqueries_preprocessor.cpp) target_link_libraries (in_join_subqueries_preprocessor PRIVATE dbms clickhouse_parsers) add_check(in_join_subqueries_preprocessor) diff --git a/src/Interpreters/tests/create_query.cpp b/src/Interpreters/tests/create_query.cpp index 20a0bfcb062..ad006de3be6 100644 --- a/src/Interpreters/tests/create_query.cpp +++ b/src/Interpreters/tests/create_query.cpp @@ -76,7 +76,7 @@ try ") ENGINE = Log"; ParserCreateQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); Context context = Context::createGlobal(); context.makeGlobalContext(); diff --git a/src/Interpreters/tests/expression.cpp b/src/Interpreters/tests/expression.cpp index 8d64b4f64ce..5432e405d1c 100644 --- a/src/Interpreters/tests/expression.cpp +++ b/src/Interpreters/tests/expression.cpp @@ -41,7 +41,7 @@ int main(int argc, char ** argv) "s1 < s2 AND x % 3 < x % 5"; ParserSelectQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); formatAST(*ast, std::cerr); std::cerr << std::endl; diff --git a/src/Interpreters/tests/expression_analyzer.cpp b/src/Interpreters/tests/expression_analyzer.cpp index 2f8b6b2aef2..66b4900584f 100644 --- a/src/Interpreters/tests/expression_analyzer.cpp +++ b/src/Interpreters/tests/expression_analyzer.cpp @@ -72,7 +72,7 @@ private: ParserSelectQuery parser; std::string message; auto text = query.data(); - if (ASTPtr ast = tryParseQuery(parser, text, text + query.size(), message, false, "", false, 0)) + if (ASTPtr ast = tryParseQuery(parser, text, text + query.size(), message, false, "", false, 0, 0)) return ast; throw Exception(message, ErrorCodes::SYNTAX_ERROR); } diff --git a/src/Interpreters/tests/gtest_cycle_aliases.cpp b/src/Interpreters/tests/gtest_cycle_aliases.cpp index c8037b23d84..593db93de3e 100644 --- a/src/Interpreters/tests/gtest_cycle_aliases.cpp +++ b/src/Interpreters/tests/gtest_cycle_aliases.cpp @@ -12,11 +12,11 @@ TEST(QueryNormalizer, SimpleCycleAlias) { String query = "a as b, b as a"; ParserExpressionList parser(false); - ASTPtr ast = parseQuery(parser, query, 0); + ASTPtr ast = parseQuery(parser, query, 0, 0); Aliases aliases; - aliases["a"] = parseQuery(parser, "b as a", 0)->children[0]; - aliases["b"] = parseQuery(parser, "a as b", 0)->children[0]; + aliases["a"] = parseQuery(parser, "b as a", 0, 0)->children[0]; + aliases["b"] = parseQuery(parser, "a as b", 0, 0)->children[0]; Settings settings; QueryNormalizer::Data normalizer_data(aliases, settings); diff --git a/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp b/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp index 9a17f03f32a..412557f13b8 100644 --- a/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp +++ b/src/Interpreters/tests/in_join_subqueries_preprocessor.cpp @@ -1224,7 +1224,7 @@ bool parse(DB::ASTPtr & ast, const std::string & query) std::string message; auto begin = query.data(); auto end = begin + query.size(); - ast = DB::tryParseQuery(parser, begin, end, message, false, "", false, 0); + ast = DB::tryParseQuery(parser, begin, end, message, false, "", false, 0, 0); return ast != nullptr; } diff --git a/src/Interpreters/tests/logical_expressions_optimizer.cpp b/src/Interpreters/tests/logical_expressions_optimizer.cpp deleted file mode 100644 index c21c4dda299..00000000000 --- a/src/Interpreters/tests/logical_expressions_optimizer.cpp +++ /dev/null @@ -1,295 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include -#include - - -namespace -{ - -struct TestEntry -{ - std::string input; - std::string expected_output; - UInt64 limit; -}; - -using TestEntries = std::vector; -using TestResult = std::pair; - -void run(); -void performTests(const TestEntries & entries); -TestResult check(const TestEntry & entry); -bool parse(DB::ASTPtr & ast, const std::string & query); -bool equals(const DB::ASTPtr & lhs, const DB::ASTPtr & rhs); -void reorder(DB::IAST * ast); - - -void run() -{ - /// NOTE: Queries are not always realistic, but we are only interested in the syntax. - TestEntries entries = - { - { - "SELECT 1", - "SELECT 1", - 3 - }, - - // WHERE - - { - "SELECT name, value FROM report WHERE (name = 'Alice') OR (name = 'Bob') OR (name = 'Carol')", - "SELECT name, value FROM report WHERE (name = 'Alice') OR (name = 'Bob') OR (name = 'Carol')", - 4 - }, - - { - "SELECT name, value FROM report WHERE (name = 'Alice') OR (name = 'Bob') OR (name = 'Carol')", - "SELECT name, value FROM report WHERE name IN ('Alice', 'Bob', 'Carol')", - 3 - }, - - { - "SELECT name, value FROM report WHERE (name = 'Alice') OR (name = 'Bob') OR (name = 'Carol')", - "SELECT name, value FROM report WHERE name IN ('Alice', 'Bob', 'Carol')", - 2 - }, - - { - "SELECT name, value FROM report WHERE (name = 'Alice') OR (value = 1000) OR (name = 'Bob') OR (name = 'Carol')", - "SELECT name, value FROM report WHERE (value = 1000) OR name IN ('Alice', 'Bob', 'Carol')", - 2 - }, - - { - "SELECT name, value FROM report WHERE (name = 'Alice') OR (value = 1000) OR (name = 'Bob') OR (name = 'Carol') OR (value = 2000)", - "SELECT name, value FROM report WHERE name IN ('Alice', 'Bob', 'Carol') OR value IN (1000, 2000)", - 2 - }, - - { - "SELECT value FROM report WHERE ((value + 1) = 1000) OR ((2 * value) = 2000) OR ((2 * value) = 4000) OR ((value + 1) = 3000)", - "SELECT value FROM report WHERE ((value + 1) IN (1000, 3000)) OR ((2 * value) IN (2000, 4000))", - 2 - }, - - { - "SELECT name, value FROM report WHERE ((name = 'Alice') OR (name = 'Bob') OR (name = 'Carol')) AND ((value = 1000) OR (value = 2000))", - "SELECT name, value FROM report WHERE name IN ('Alice', 'Bob', 'Carol') AND ((value = 1000) OR (value = 2000))", - 3 - }, - - // PREWHERE - - { - "SELECT name, value FROM report PREWHERE (name = 'Alice') OR (name = 'Bob') OR (name = 'Carol')", - "SELECT name, value FROM report PREWHERE (name = 'Alice') OR (name = 'Bob') OR (name = 'Carol')", - 4 - }, - - { - "SELECT name, value FROM report PREWHERE (name = 'Alice') OR (name = 'Bob') OR (name = 'Carol')", - "SELECT name, value FROM report PREWHERE name IN ('Alice', 'Bob', 'Carol')", - 3 - }, - - { - "SELECT name, value FROM report PREWHERE (name = 'Alice') OR (name = 'Bob') OR (name = 'Carol')", - "SELECT name, value FROM report PREWHERE name IN ('Alice', 'Bob', 'Carol')", - 2 - }, - - { - "SELECT name, value FROM report PREWHERE (name = 'Alice') OR (value = 1000) OR (name = 'Bob') OR (name = 'Carol')", - "SELECT name, value FROM report PREWHERE (value = 1000) OR name IN ('Alice', 'Bob', 'Carol')", - 2 - }, - - { - "SELECT name, value FROM report PREWHERE (name = 'Alice') OR (value = 1000) OR (name = 'Bob') OR (name = 'Carol') OR (value = 2000)", - "SELECT name, value FROM report PREWHERE name IN ('Alice', 'Bob', 'Carol') OR value IN (1000, 2000)", - 2 - }, - - { - "SELECT value FROM report PREWHERE ((value + 1) = 1000) OR ((2 * value) = 2000) OR ((2 * value) = 4000) OR ((value + 1) = 3000)", - "SELECT value FROM report PREWHERE (value + 1) IN (1000, 3000) OR (2 * value) IN (2000, 4000)", - 2 - }, - - // HAVING - - { - "SELECT number, count() FROM (SELECT * FROM system.numbers LIMIT 10) GROUP BY number HAVING number = 1", - "SELECT number, count() FROM (SELECT * FROM system.numbers LIMIT 10) GROUP BY number HAVING number = 1", - 2 - }, - - { - "SELECT number, count() FROM (SELECT * FROM system.numbers LIMIT 10) GROUP BY number HAVING (number = 1) OR (number = 2)", - "SELECT number, count() FROM (SELECT * FROM system.numbers LIMIT 10) GROUP BY number HAVING number IN (1, 2)", - 2 - }, - - { - "SELECT number, count() FROM (SELECT * FROM system.numbers LIMIT 10) GROUP BY number HAVING (number = 1) OR (number = 2)", - "SELECT number, count() FROM (SELECT * FROM system.numbers LIMIT 10) GROUP BY number HAVING (number = 1) OR (number = 2)", - 3 - }, - - { - "SELECT number, count() FROM (SELECT * FROM system.numbers LIMIT 10) GROUP BY number HAVING ((number + 1) = 1) OR ((number + 1) = 2) OR ((number + 3) = 7)", - "SELECT number, count() FROM (SELECT * FROM system.numbers LIMIT 10) GROUP BY number HAVING ((number + 3) = 7) OR (number + 1) IN (1, 2)", - 2 - }, - - // PREWHERE + WHERE + HAVING - - { - "SELECT number, count(), 1 AS T, 2 AS U FROM (SELECT * FROM system.numbers LIMIT 10) PREWHERE (U = 1) OR (U = 2) " - "WHERE (T = 1) OR (T = 2) GROUP BY number HAVING (number = 1) OR (number = 2)", - "SELECT number, count(), 1 AS T, 2 AS U FROM (SELECT * FROM system.numbers LIMIT 10) PREWHERE U IN (1, 2) " - "WHERE T IN (1, 2) GROUP BY number HAVING number IN (1, 2)", - 2 - }, - - { - "SELECT number, count(), 1 AS T, 2 AS U FROM (SELECT * FROM system.numbers LIMIT 10) PREWHERE (U = 1) OR (U = 2) OR (U = 3) " - "WHERE (T = 1) OR (T = 2) GROUP BY number HAVING (number = 1) OR (number = 2)", - "SELECT number, count(), 1 AS T, 2 AS U FROM (SELECT * FROM system.numbers LIMIT 10) PREWHERE U IN (1, 2, 3) " - "WHERE (T = 1) OR (T = 2) GROUP BY number HAVING (number = 1) OR (number = 2)", - 3 - }, - - { - "SELECT x = 1 OR x=2 OR (x = 3 AS x3) AS y, 4 AS x", - "SELECT x IN (1, 2, 3) AS y, 4 AS x", - 2 - } - }; - - performTests(entries); -} - -void performTests(const TestEntries & entries) -{ - unsigned int count = 0; - unsigned int i = 1; - - for (const auto & entry : entries) - { - auto res = check(entry); - if (res.first) - { - ++count; - std::cout << "Test " << i << " passed.\n"; - } - else - std::cout << "Test " << i << " failed. Expected: " << entry.expected_output << ". Received: " << res.second << "\n"; - - ++i; - } - std::cout << count << " out of " << entries.size() << " test(s) passed.\n"; -} - -TestResult check(const TestEntry & entry) -{ - try - { - /// Parse and optimize the incoming query. - DB::ASTPtr ast_input; - if (!parse(ast_input, entry.input)) - return TestResult(false, "parse error"); - - auto select_query = typeid_cast(&*ast_input); - - DB::LogicalExpressionsOptimizer optimizer(select_query, entry.limit); - optimizer.perform(); - - /// Parse the expected result. - DB::ASTPtr ast_expected; - if (!parse(ast_expected, entry.expected_output)) - return TestResult(false, "parse error"); - - /// Compare the optimized query and the expected result. - bool res = equals(ast_input, ast_expected); - std::string output = DB::queryToString(ast_input); - - return TestResult(res, output); - } - catch (DB::Exception & e) - { - return TestResult(false, e.displayText()); - } -} - -bool parse(DB::ASTPtr & ast, const std::string & query) -{ - DB::ParserSelectQuery parser; - std::string message; - auto begin = query.data(); - auto end = begin + query.size(); - ast = DB::tryParseQuery(parser, begin, end, message, false, "", false, 0); - return ast != nullptr; -} - -bool equals(const DB::ASTPtr & lhs, const DB::ASTPtr & rhs) -{ - DB::ASTPtr lhs_reordered = lhs->clone(); - reorder(&*lhs_reordered); - - DB::ASTPtr rhs_reordered = rhs->clone(); - reorder(&*rhs_reordered); - - return lhs_reordered->getTreeHash() == rhs_reordered->getTreeHash(); -} - -void reorderImpl(DB::IAST * ast) -{ - if (ast == nullptr) - return; - - auto & children = ast->children; - if (children.empty()) - return; - - for (auto & child : children) - reorderImpl(&*child); - - std::sort(children.begin(), children.end(), [](const DB::ASTPtr & lhs, const DB::ASTPtr & rhs) - { - return lhs->getTreeHash() < rhs->getTreeHash(); - }); -} - -void reorder(DB::IAST * ast) -{ - if (ast == nullptr) - return; - - auto select_query = typeid_cast(ast); - if (select_query == nullptr) - return; - - reorderImpl(select_query->where().get()); - reorderImpl(select_query->prewhere().get()); - reorderImpl(select_query->having().get()); -} - -} - -int main() -{ - run(); - return 0; -} diff --git a/src/Parsers/IParser.h b/src/Parsers/IParser.h index 5bfbf1ed476..69c199c201e 100644 --- a/src/Parsers/IParser.h +++ b/src/Parsers/IParser.h @@ -56,8 +56,6 @@ public: /// Token iterator augmented with depth information. This allows to control recursion depth. struct Pos : TokenIterator { - using TokenIterator::TokenIterator; - uint32_t depth = 0; uint32_t max_depth = 0; diff --git a/src/Parsers/parseQuery.cpp b/src/Parsers/parseQuery.cpp index b8ab940f2dd..ff537e0f70e 100644 --- a/src/Parsers/parseQuery.cpp +++ b/src/Parsers/parseQuery.cpp @@ -328,19 +328,28 @@ ASTPtr parseQuery( IParser & parser, const std::string & query, const std::string & query_description, - size_t max_query_size) + size_t max_query_size, + size_t max_parser_depth) { - return parseQuery(parser, query.data(), query.data() + query.size(), query_description, max_query_size); + return parseQuery(parser, query.data(), query.data() + query.size(), query_description, max_query_size, max_parser_depth); } -ASTPtr parseQuery(IParser & parser, const std::string & query, size_t max_query_size) +ASTPtr parseQuery( + IParser & parser, + const std::string & query, + size_t max_query_size, + size_t max_parser_depth) { - return parseQuery(parser, query.data(), query.data() + query.size(), parser.getName(), max_query_size); + return parseQuery(parser, query.data(), query.data() + query.size(), parser.getName(), max_query_size, max_parser_depth); } -std::pair splitMultipartQuery(const std::string & queries, std::vector & queries_list) +std::pair splitMultipartQuery( + const std::string & queries, + std::vector & queries_list, + size_t max_query_size, + size_t max_parser_depth) { ASTPtr ast; @@ -356,7 +365,7 @@ std::pair splitMultipartQuery(const std::string & queries, s { begin = pos; - ast = parseQueryAndMovePosition(parser, pos, end, "", true, 0); + ast = parseQueryAndMovePosition(parser, pos, end, "", true, max_query_size, max_parser_depth); auto * insert = ast->as(); diff --git a/src/Parsers/parseQuery.h b/src/Parsers/parseQuery.h index feea204181e..14a9a85b22c 100644 --- a/src/Parsers/parseQuery.h +++ b/src/Parsers/parseQuery.h @@ -17,7 +17,7 @@ ASTPtr tryParseQuery( bool allow_multi_statements, /// If false, check for non-space characters after semicolon and set error message if any. size_t max_query_size, /// If (end - pos) > max_query_size and query is longer than max_query_size then throws "Max query size exceeded". /// Disabled if zero. Is used in order to check query size if buffer can contains data for INSERT query. - size_t max_parser_depth = 0); + size_t max_parser_depth); /// Parse query or throw an exception with error message. @@ -27,8 +27,8 @@ ASTPtr parseQueryAndMovePosition( const char * end, const std::string & description, bool allow_multi_statements, - size_t max_query_size = 0, - size_t max_parser_depth = 0); + size_t max_query_size, + size_t max_parser_depth); ASTPtr parseQuery( IParser & parser, @@ -36,24 +36,30 @@ ASTPtr parseQuery( const char * end, const std::string & description, size_t max_query_size, - size_t max_parser_depth = 0); + size_t max_parser_depth); ASTPtr parseQuery( IParser & parser, const std::string & query, const std::string & query_description, - size_t max_query_size); + size_t max_query_size, + size_t max_parser_depth); ASTPtr parseQuery( IParser & parser, const std::string & query, - size_t max_query_size); + size_t max_query_size, + size_t max_parser_depth); /** Split queries separated by ; on to list of single queries * Returns pointer to the end of last successfully parsed query (first), and true if all queries are successfully parsed (second) * NOTE: INSERT's data should be placed in single line. */ -std::pair splitMultipartQuery(const std::string & queries, std::vector & queries_list); +std::pair splitMultipartQuery( + const std::string & queries, + std::vector & queries_list, + size_t max_query_size, + size_t max_parser_depth); } diff --git a/src/Parsers/tests/create_parser.cpp b/src/Parsers/tests/create_parser.cpp index 6137d4d18da..fbdc967fa2a 100644 --- a/src/Parsers/tests/create_parser.cpp +++ b/src/Parsers/tests/create_parser.cpp @@ -12,7 +12,7 @@ int main(int, char **) std::string input = "CREATE TABLE hits (URL String, UserAgentMinor2 FixedString(2), EventTime DateTime) ENGINE = Log"; ParserCreateQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); formatAST(*ast, std::cerr); std::cerr << std::endl; diff --git a/src/Parsers/tests/gtest_dictionary_parser.cpp b/src/Parsers/tests/gtest_dictionary_parser.cpp index 25dcbb326ad..60eeab5f615 100644 --- a/src/Parsers/tests/gtest_dictionary_parser.cpp +++ b/src/Parsers/tests/gtest_dictionary_parser.cpp @@ -43,7 +43,7 @@ TEST(ParserDictionaryDDL, SimpleDictionary) " RANGE(MIN second_column MAX third_column)"; ParserCreateDictionaryQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); ASTCreateQuery * create = ast->as(); EXPECT_EQ(create->table, "dict1"); EXPECT_EQ(create->database, "test"); @@ -139,7 +139,7 @@ TEST(ParserDictionaryDDL, AttributesWithMultipleProperties) " SOURCE(CLICKHOUSE(HOST 'localhost'))"; ParserCreateDictionaryQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); ASTCreateQuery * create = ast->as(); EXPECT_EQ(create->table, "dict2"); EXPECT_EQ(create->database, ""); @@ -186,7 +186,7 @@ TEST(ParserDictionaryDDL, CustomAttributePropertiesOrder) " LIFETIME(300)"; ParserCreateDictionaryQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); ASTCreateQuery * create = ast->as(); /// test attributes @@ -241,7 +241,7 @@ TEST(ParserDictionaryDDL, NestedSource) " RANGE(MIN second_column MAX third_column)"; ParserCreateDictionaryQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); ASTCreateQuery * create = ast->as(); EXPECT_EQ(create->table, "dict4"); EXPECT_EQ(create->database, ""); @@ -289,7 +289,7 @@ TEST(ParserDictionaryDDL, Formatting) " RANGE(MIN second_column MAX third_column)"; ParserCreateDictionaryQuery parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); ASTCreateQuery * create = ast->as(); auto str = serializeAST(*create, true); EXPECT_EQ(str, "CREATE DICTIONARY test.dict5 (`key_column1` UInt64 DEFAULT 1 HIERARCHICAL INJECTIVE, `key_column2` String DEFAULT '', `second_column` UInt8 EXPRESSION intDiv(50, rand() % 1000), `third_column` UInt8) PRIMARY KEY key_column1, key_column2 SOURCE(MYSQL(HOST 'localhost' PORT 9000 USER 'default' REPLICA (HOST '127.0.0.1' PRIORITY 1) PASSWORD '')) LIFETIME(MIN 1 MAX 10) LAYOUT(CACHE(SIZE_IN_CELLS 50)) RANGE(MIN second_column MAX third_column)"); @@ -300,7 +300,7 @@ TEST(ParserDictionaryDDL, ParseDropQuery) String input1 = "DROP DICTIONARY test.dict1"; ParserDropQuery parser; - ASTPtr ast1 = parseQuery(parser, input1.data(), input1.data() + input1.size(), "", 0); + ASTPtr ast1 = parseQuery(parser, input1.data(), input1.data() + input1.size(), "", 0, 0); ASTDropQuery * drop1 = ast1->as(); EXPECT_TRUE(drop1->is_dictionary); @@ -311,7 +311,7 @@ TEST(ParserDictionaryDDL, ParseDropQuery) String input2 = "DROP DICTIONARY IF EXISTS dict2"; - ASTPtr ast2 = parseQuery(parser, input2.data(), input2.data() + input2.size(), "", 0); + ASTPtr ast2 = parseQuery(parser, input2.data(), input2.data() + input2.size(), "", 0, 0); ASTDropQuery * drop2 = ast2->as(); EXPECT_TRUE(drop2->is_dictionary); @@ -326,7 +326,7 @@ TEST(ParserDictionaryDDL, ParsePropertiesQueries) String input1 = "SHOW CREATE DICTIONARY test.dict1"; ParserTablePropertiesQuery parser; - ASTPtr ast1 = parseQuery(parser, input1.data(), input1.data() + input1.size(), "", 0); + ASTPtr ast1 = parseQuery(parser, input1.data(), input1.data() + input1.size(), "", 0, 0); ASTShowCreateDictionaryQuery * show1 = ast1->as(); EXPECT_EQ(show1->table, "dict1"); @@ -335,7 +335,7 @@ TEST(ParserDictionaryDDL, ParsePropertiesQueries) String input2 = "EXISTS DICTIONARY dict2"; - ASTPtr ast2 = parseQuery(parser, input2.data(), input2.data() + input2.size(), "", 0); + ASTPtr ast2 = parseQuery(parser, input2.data(), input2.data() + input2.size(), "", 0, 0); ASTExistsDictionaryQuery * show2 = ast2->as(); EXPECT_EQ(show2->table, "dict2"); diff --git a/src/Parsers/tests/select_parser.cpp b/src/Parsers/tests/select_parser.cpp index f5d94746aa1..7711f0d2527 100644 --- a/src/Parsers/tests/select_parser.cpp +++ b/src/Parsers/tests/select_parser.cpp @@ -22,7 +22,7 @@ try " FORMAT TabSeparated"; ParserQueryWithOutput parser; - ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0); + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); std::cout << "Success." << std::endl; formatAST(*ast, std::cerr); diff --git a/src/Storages/ColumnsDescription.cpp b/src/Storages/ColumnsDescription.cpp index 76a55d059ee..c4f6d11605f 100644 --- a/src/Storages/ColumnsDescription.cpp +++ b/src/Storages/ColumnsDescription.cpp @@ -23,11 +23,13 @@ #include #include #include +#include #include #include #include #include + namespace DB { @@ -102,7 +104,7 @@ void ColumnDescription::readText(ReadBuffer & buf) ParserColumnDeclaration column_parser(/* require type */ true); String column_line; readEscapedStringUntilEOL(column_line, buf); - ASTPtr ast = parseQuery(column_parser, column_line, "column parser", 0); + ASTPtr ast = parseQuery(column_parser, column_line, "column parser", 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); if (const auto * col_ast = ast->as()) { name = col_ast->name; diff --git a/src/Storages/ConstraintsDescription.cpp b/src/Storages/ConstraintsDescription.cpp index ad0cd76733a..8c38af0cd5e 100644 --- a/src/Storages/ConstraintsDescription.cpp +++ b/src/Storages/ConstraintsDescription.cpp @@ -5,6 +5,8 @@ #include #include +#include + namespace DB { @@ -28,7 +30,7 @@ ConstraintsDescription ConstraintsDescription::parse(const String & str) ConstraintsDescription res; ParserConstraintDeclarationList parser; - ASTPtr list = parseQuery(parser, str, 0); + ASTPtr list = parseQuery(parser, str, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); for (const auto & constraint : list->children) res.constraints.push_back(std::dynamic_pointer_cast(constraint)); diff --git a/src/Storages/IndicesDescription.cpp b/src/Storages/IndicesDescription.cpp index a5772a835bf..2363e7924ba 100644 --- a/src/Storages/IndicesDescription.cpp +++ b/src/Storages/IndicesDescription.cpp @@ -5,6 +5,9 @@ #include #include +#include + + namespace DB { @@ -42,7 +45,7 @@ IndicesDescription IndicesDescription::parse(const String & str) IndicesDescription res; ParserIndexDeclarationList parser; - ASTPtr list = parseQuery(parser, str, 0); + ASTPtr list = parseQuery(parser, str, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); for (const auto & index : list->children) res.indices.push_back(std::dynamic_pointer_cast(index)); diff --git a/src/Storages/MutationCommands.cpp b/src/Storages/MutationCommands.cpp index d48f8525162..f3569c344d9 100644 --- a/src/Storages/MutationCommands.cpp +++ b/src/Storages/MutationCommands.cpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -137,7 +138,7 @@ void MutationCommands::readText(ReadBuffer & in) ParserAlterCommandList p_alter_commands; auto commands_ast = parseQuery( - p_alter_commands, commands_str.data(), commands_str.data() + commands_str.length(), "mutation commands list", 0); + p_alter_commands, commands_str.data(), commands_str.data() + commands_str.length(), "mutation commands list", 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); for (ASTAlterCommand * command_ast : commands_ast->as().commands) { auto command = MutationCommand::parse(command_ast, true); diff --git a/src/Storages/StorageReplicatedMergeTree.cpp b/src/Storages/StorageReplicatedMergeTree.cpp index 556e7b41c52..a19a424c643 100644 --- a/src/Storages/StorageReplicatedMergeTree.cpp +++ b/src/Storages/StorageReplicatedMergeTree.cpp @@ -1,4 +1,5 @@ -#include +#include + #include #include #include @@ -25,6 +26,8 @@ #include #include +#include + #include #include @@ -479,7 +482,7 @@ void StorageReplicatedMergeTree::setTableStructure(ColumnsDescription new_column if (metadata_diff.sorting_key_changed) { ParserNotEmptyExpressionList parser(false); - auto new_sorting_key_expr_list = parseQuery(parser, metadata_diff.new_sorting_key, 0); + auto new_sorting_key_expr_list = parseQuery(parser, metadata_diff.new_sorting_key, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); if (new_sorting_key_expr_list->children.size() == 1) metadata.order_by_ast = new_sorting_key_expr_list->children[0]; @@ -507,7 +510,7 @@ void StorageReplicatedMergeTree::setTableStructure(ColumnsDescription new_column if (metadata_diff.ttl_table_changed) { ParserTTLExpressionList parser; - metadata.ttl_for_table_ast = parseQuery(parser, metadata_diff.new_ttl_table, 0); + metadata.ttl_for_table_ast = parseQuery(parser, metadata_diff.new_ttl_table, 0, DBMS_DEFAULT_MAX_PARSER_DEPTH); } } diff --git a/src/Storages/getStructureOfRemoteTable.cpp b/src/Storages/getStructureOfRemoteTable.cpp index eb386c66d60..3b4ee489b46 100644 --- a/src/Storages/getStructureOfRemoteTable.cpp +++ b/src/Storages/getStructureOfRemoteTable.cpp @@ -137,7 +137,7 @@ ColumnsDescription getStructureOfRemoteTableInShard( column.default_desc.kind = columnDefaultKindFromString(kind_name); String expr_str = (*default_expr)[i].get(); column.default_desc.expression = parseQuery( - expr_parser, expr_str.data(), expr_str.data() + expr_str.size(), "default expression", 0); + expr_parser, expr_str.data(), expr_str.data() + expr_str.size(), "default expression", 0, context.getSettingsRef().max_parser_depth); } res.add(column); diff --git a/src/Storages/tests/gtest_transform_query_for_external_database.cpp b/src/Storages/tests/gtest_transform_query_for_external_database.cpp index 385e47201a5..22407ca1bd9 100644 --- a/src/Storages/tests/gtest_transform_query_for_external_database.cpp +++ b/src/Storages/tests/gtest_transform_query_for_external_database.cpp @@ -48,7 +48,7 @@ static State & state() static void check(const std::string & query, const std::string & expected, const Context & context, const NamesAndTypesList & columns) { ParserSelectQuery parser; - ASTPtr ast = parseQuery(parser, query, 1000); + ASTPtr ast = parseQuery(parser, query, 1000, 1000); SelectQueryInfo query_info; query_info.syntax_analyzer_result = SyntaxAnalyzer(context).analyzeSelect(ast, columns); query_info.query = ast; diff --git a/src/TableFunctions/parseColumnsListForTableFunction.cpp b/src/TableFunctions/parseColumnsListForTableFunction.cpp index 9b775b70492..c419164ac38 100644 --- a/src/TableFunctions/parseColumnsListForTableFunction.cpp +++ b/src/TableFunctions/parseColumnsListForTableFunction.cpp @@ -19,9 +19,7 @@ ColumnsDescription parseColumnsListFromString(const std::string & structure, con Expected expected; Tokens tokens(structure.c_str(), structure.c_str() + structure.size()); - IParser::Pos token_iterator(tokens); - const Settings & settings = context.getSettingsRef(); - token_iterator.max_depth = settings.max_parser_depth; + IParser::Pos token_iterator(tokens, context.getSettingsRef().max_parser_depth); ParserColumnDeclarationList parser; ASTPtr columns_list_raw; From 8f6e90390f4a7a5e6dea6810fb9360ff004038b8 Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Wed, 15 Apr 2020 23:32:14 +0300 Subject: [PATCH 46/73] Added a test --- .../queries/0_stateless/01196_max_parser_depth.reference | 3 +++ tests/queries/0_stateless/01196_max_parser_depth.sh | 8 ++++++++ 2 files changed, 11 insertions(+) create mode 100644 tests/queries/0_stateless/01196_max_parser_depth.reference create mode 100755 tests/queries/0_stateless/01196_max_parser_depth.sh diff --git a/tests/queries/0_stateless/01196_max_parser_depth.reference b/tests/queries/0_stateless/01196_max_parser_depth.reference new file mode 100644 index 00000000000..a72c1b18aa2 --- /dev/null +++ b/tests/queries/0_stateless/01196_max_parser_depth.reference @@ -0,0 +1,3 @@ +Code: 306 +Code: 306 +Code: 306 diff --git a/tests/queries/0_stateless/01196_max_parser_depth.sh b/tests/queries/0_stateless/01196_max_parser_depth.sh new file mode 100755 index 00000000000..471c1c22ecb --- /dev/null +++ b/tests/queries/0_stateless/01196_max_parser_depth.sh @@ -0,0 +1,8 @@ +#!/usr/bin/env bash + +CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +. $CURDIR/../shell_config.sh + +{ printf "select "; for x in {1..1000}; do printf "coalesce(null, "; done; printf "1"; for x in {1..1000}; do printf ")"; done; } | $CLICKHOUSE_CLIENT 2>&1 | grep -o -F 'Code: 306' +{ printf "select "; for x in {1..1000}; do printf "coalesce(null, "; done; printf "1"; for x in {1..1000}; do printf ")"; done; } | $CLICKHOUSE_LOCAL 2>&1 | grep -o -F 'Code: 306' +{ printf "select "; for x in {1..1000}; do printf "coalesce(null, "; done; printf "1"; for x in {1..1000}; do printf ")"; done; } | $CLICKHOUSE_CURL --data-binary @- -vsS "$CLICKHOUSE_URL" 2>&1 | grep -o -F 'Code: 306' From 0221fba8734703ffe1a20683d47c305fabc47639 Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Thu, 16 Apr 2020 05:59:16 +0300 Subject: [PATCH 47/73] Fix tests --- programs/client/Client.cpp | 7 +++++-- tests/queries/0_stateless/00328_long_case_construction.sql | 1 - tests/queries/0_stateless/00990_hasToken.sh | 2 +- tests/queries/0_stateless/01068_parens.sql | 3 ++- 4 files changed, 8 insertions(+), 5 deletions(-) diff --git a/programs/client/Client.cpp b/programs/client/Client.cpp index e4c046d18ba..b1dda4b4da9 100644 --- a/programs/client/Client.cpp +++ b/programs/client/Client.cpp @@ -959,11 +959,14 @@ private: ASTPtr res; const auto & settings = context.getSettingsRef(); + size_t max_length = 0; + if (!allow_multi_statements) + max_length = settings.max_query_size; if (is_interactive || ignore_error) { String message; - res = tryParseQuery(parser, pos, end, message, true, "", allow_multi_statements, settings.max_query_size, settings.max_parser_depth); + res = tryParseQuery(parser, pos, end, message, true, "", allow_multi_statements, max_length, settings.max_parser_depth); if (!res) { @@ -972,7 +975,7 @@ private: } } else - res = parseQueryAndMovePosition(parser, pos, end, "", allow_multi_statements, settings.max_query_size, settings.max_parser_depth); + res = parseQueryAndMovePosition(parser, pos, end, "", allow_multi_statements, max_length, settings.max_parser_depth); if (is_interactive) { diff --git a/tests/queries/0_stateless/00328_long_case_construction.sql b/tests/queries/0_stateless/00328_long_case_construction.sql index d0fc90d0884..aa653d667f7 100644 --- a/tests/queries/0_stateless/00328_long_case_construction.sql +++ b/tests/queries/0_stateless/00328_long_case_construction.sql @@ -1,4 +1,3 @@ - /* Trivial case */ SELECT CASE WHEN 1 THEN 2 WHEN 3 THEN 4 ELSE 5 END; diff --git a/tests/queries/0_stateless/00990_hasToken.sh b/tests/queries/0_stateless/00990_hasToken.sh index 4ccb77b8ecc..4ef62bc69c0 100755 --- a/tests/queries/0_stateless/00990_hasToken.sh +++ b/tests/queries/0_stateless/00990_hasToken.sh @@ -5,4 +5,4 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) # We should have correct env vars from shell_config.sh to run this test -python $CURDIR/00990_hasToken.python | ${CLICKHOUSE_CLIENT} -nm +python $CURDIR/00990_hasToken.python | ${CLICKHOUSE_CLIENT} --max_query_size 1048576 -nm diff --git a/tests/queries/0_stateless/01068_parens.sql b/tests/queries/0_stateless/01068_parens.sql index 7cb4f097b15..42948760594 100644 --- a/tests/queries/0_stateless/01068_parens.sql +++ b/tests/queries/0_stateless/01068_parens.sql @@ -1 +1,2 @@ -((((((((((((((SELECT((((((((((((((((((((((((((((((((1)))))))))))))))))))))))))))))))))))))))))))))) +SET max_parser_depth = 10000; +((((((((((((((SELECT((((((((((((((((((((((((((((((((1)))))))))))))))))))))))))))))))))))))))))))))); From db2a307a8e9ee8191c8c2e4195112463055b7dd7 Mon Sep 17 00:00:00 2001 From: Ramazan Polat Date: Thu, 16 Apr 2020 09:51:01 +0300 Subject: [PATCH 48/73] First Turkish translation contribution of ClickHouse! (#10297) * Manual translation to TR First Turkish translation contribution of ClickHouse! * Update index.md Co-authored-by: Ivan Blinkov --- docs/tr/index.md | 52 +++++++++++++++++++++++------------------------- 1 file changed, 25 insertions(+), 27 deletions(-) diff --git a/docs/tr/index.md b/docs/tr/index.md index 0ef0f264b87..fb65930b39c 100644 --- a/docs/tr/index.md +++ b/docs/tr/index.md @@ -1,17 +1,15 @@ --- -machine_translated: true -machine_translated_rev: e8cd92bba3269f47787db090899f7c242adf7818 toc_priority: 0 toc_title: "Genel bak\u0131\u015F" --- # ClickHouse nedir? {#what-is-clickhouse} -ClickHouse, sorguların çevrimiçi analitik işlenmesi (OLAP) için sütun odaklı bir veritabanı yönetim sistemidir (DBMS). +ClickHouse, sorguların çevrimiçi analitik işlenmesi (*Online Analytical Processing* - OLAP) için sütun odaklı bir Veritabanı Yönetim Sistemidir (*DataBase Management System* - DBMS). -İn a “normal” satır yönelimli DBMS, veri bu sırayla saklanır: +“Normal” bir satır odaklı DBMS içinde veriler şu şekilde saklanır: -| Satır | Watchıd | JavaEnable | Başlık | GoodEvent | EventTime | +| Satır | WatchId | JavaEnable | Başlık | İyiOlay | OlayZamanı | |-------|-------------|------------|----------------------|-----------|---------------------| | \#0 | 89354350662 | 1 | Yatırımcı İlişkileri | 1 | 2016-05-18 05:19:20 | | \#1 | 90329509958 | 0 | Bize ulaşın | 1 | 2016-05-18 08:10:20 | @@ -20,47 +18,47 @@ ClickHouse, sorguların çevrimiçi analitik işlenmesi (OLAP) için sütun odak Başka bir deyişle, bir satırla ilgili tüm değerler fiziksel olarak yan yana depolanır. -Satır yönelimli DBMS örnekleri MySQL, Postgres ve MS SQL Server'dır. +MySQL, Postgres ve MS SQL Server gibi veritabanları satır odaklı DBMS örnekleridir. -Sütun yönelimli bir DBMS'DE, veriler şu şekilde saklanır: +Sütun odaklı bir DBMS'de ise veriler şu şekilde saklanır: | Satır: | \#0 | \#1 | \#2 | \#N | |-------------|----------------------|---------------------|---------------------|-----| -| Watchıd: | 89354350662 | 90329509958 | 89953706054 | … | +| WatchId: | 89354350662 | 90329509958 | 89953706054 | … | | JavaEnable: | 1 | 0 | 1 | … | | Başlık: | Yatırımcı İlişkileri | Bize ulaşın | Görev | … | -| GoodEvent: | 1 | 1 | 1 | … | -| EventTime: | 2016-05-18 05:19:20 | 2016-05-18 08:10:20 | 2016-05-18 07:38:00 | … | +| İyiOlay: | 1 | 1 | 1 | … | +| OlayZamanı: | 2016-05-18 05:19:20 | 2016-05-18 08:10:20 | 2016-05-18 07:38:00 | … | Bu örnekler yalnızca verilerin düzenlendiği sırayı gösterir. Farklı sütunlardaki değerler ayrı olarak depolanır ve aynı sütundaki veriler birlikte depolanır. -Bir sütun odaklı DBMS örnekleri: Vertica, Paraccel (Actian Matrix ve Amazon Redshift), Sybase IQ, Exasol, Infobright, InfiniDB, MonetDB (VectorWise ve Actian vektör), LucidDB, SAP HANA, Google Dremel, Google PowerDrill, Druid ve kdb+. +Sütun odaklı DBMS örnekleri: Vertica, Paraccel (Actian Matrix ve Amazon Redshift), Sybase IQ, Exasol, Infobright, InfiniDB, MonetDB (VectorWise ve Actian vektör), LucidDB, SAP HANA, Google Dremel, Google PowerDrill, Druid ve kdb+. -Different orders for storing data are better suited to different scenarios. The data access scenario refers to what queries are made, how often, and in what proportion; how much data is read for each type of query – rows, columns, and bytes; the relationship between reading and updating data; the working size of the data and how locally it is used; whether transactions are used, and how isolated they are; requirements for data replication and logical integrity; requirements for latency and throughput for each type of query, and so on. +Verinin farklı bir şekilde sıralanarak depolanması, bazı veri erişim senaryoları için daha uygundur. Veri erişim senaryosu, hangi sorguların ne kadar sıklıkla yapıldığını, ne kadar verinin okunduğu, bunların hangi tiplerde hangi kolonlardan, satırlardan ve hangi miktarda(bayt olarak) okunacağını; verinin okunması ile güncellenmesi arasındaki ilişkiyi; verinin işlenen boyutu ve ne kadar yerel olduğunu; veri değiş-tokuşunun(transaction) olup olmayacağını, olacaksa diğer işlemlerden ne kadat yalıtılacağını; verilerin kopyalanması ve mantıksal bütünlük intiyaçlarını; her sorgu türünün gecikme ve iletim debisi ihtiyaçlarını gösterir. -Sistem üzerindeki yük ne kadar yüksek olursa, kullanım senaryosunun gereksinimlerine uyacak şekilde ayarlanmış sistemi özelleştirmek o kadar önemlidir ve bu özelleştirme o kadar ince taneli olur. Önemli ölçüde farklı senaryolara eşit derecede uygun bir sistem yoktur. Bir sistem geniş bir senaryo kümesine uyarlanabilirse, yüksek bir yük altında, sistem tüm senaryoları eşit derecede zayıf bir şekilde ele alır veya olası senaryolardan yalnızca biri veya birkaçı için iyi çalışır. +Sistem üzerindeki yük ne kadar fazlaysa, sistem ayarlarının kullanım senaryolarına uyarlanması ve bu ayarların ne kadar hassas olduğu da o kadar önemli hale gelir. Birbirinden büyük ölçüde farklı olan veri erişim senaryolarına tam uyum sağlayan, yani her işe ve yüke gelen bir sistem yoktur. Eğer bir sistem yük altında her türlü veri erişim senaryosuna adapte olabiliyorsa, o halde böyle bir sistem ya tüm senaryolara ya da senaryoların bir veya birkaçına karşı zayıp bir performans gösterir. ## OLAP senaryosunun temel özellikleri {#key-properties-of-olap-scenario} -- İsteklerin büyük çoğunluğu okuma erişimi içindir. +- İsteklerin büyük çoğunluğu, okuma erişimi içindir. - Veriler, tek satırlarla değil, oldukça büyük gruplar halinde (\> 1000 satır) güncellenir; veya hiç güncellenmez. -- Veri DB eklenir, ancak değiştirilmez. -- Okumalar için, dB'den oldukça fazla sayıda satır çıkarılır,ancak yalnızca küçük bir sütun alt kümesi. -- Tablolar şunlardır “wide,” çok sayıda sütun içerdikleri anlamına gelir. -- Sorgular nispeten nadirdir (genellikle sunucu başına yüzlerce sorgu veya saniyede daha az). +- Veri, veritabanına eklenir, ancak değiştirilmez. +- Bazı sorgular için veritabanından den oldukça fazla sayıda satır çekilir, ancak sonuç sadece birkaç satır ve sütunludur. +- Tablolar "geniştir", yani bir tabloda çok sayıda kolon vardır(onlarca). +- Sorgular sıkılığı diğer senaryolara göre daha azdır (genellikle sunucu başına saniyede 100 veya daha az sorgu gelir). - Basit sorgular için, 50 ms civarında gecikmelere izin verilir. -- Sütun değerleri oldukça küçüktür: sayılar ve kısa dizeler (örneğin, URL başına 60 bayt). -- Tek bir sorguyu işlerken yüksek verim gerektirir (sunucu başına saniyede milyarlarca satıra kadar). -- İşlemler gerekli değildir. -- Veri tutarlılığı için düşük gereksinimler. -- Sorgu başına bir büyük tablo var. Biri hariç tüm tablolar küçüktür. -- Bir sorgu sonucu, kaynak veriden önemli ölçüde daha küçüktür. Başka bir deyişle, veriler filtrelenir veya toplanır, böylece sonuç tek bir sunucunun RAM'İNE sığar. +- Saklanan veriler oldukça küçüktür: genelde sadece sayılar ve kısa metinler içerir(örneğin, URL başına 60 bayt). +- Tek bir sorguyu işlemek yüksek miktarda veri okunmasını gerektirir(sunucu başına saniyede milyarlarca satıra kadar). +- Veri değiş-tokuşu(transaction) gerekli değildir. +- Veri tutarlılığı o kadar da önemli değildir. +- Genelde bir tane çok büyük tablo vardır, gerisi küçük tablolardan oluşur +- Bir sorgu sonucu elde edilen veri, okuanan veri miktarından oldukça küçüktür. Başka bir deyişle, milyarlarca satır içinden veriler süzgeçlenerek veya birleştirilerek elde edilen verilerin tek bir sunucunun RAM'ine sığar. -OLAP senaryosunun diğer popüler senaryolardan (OLTP veya anahtar değeri erişimi gibi) çok farklı olduğunu görmek kolaydır. Bu nedenle, iyi bir performans elde etmek istiyorsanız, analitik sorguları işlemek için OLTP veya anahtar değeri DB'Yİ kullanmayı denemek mantıklı değildir. Örneğin, analitik için MongoDB veya Redis kullanmaya çalışırsanız, OLAP veritabanlarına kıyasla çok düşük performans elde edersiniz. +OLAP senaryosunun diğer popüler senaryolardan (*Online Transactional Processing* - OLTP veya *Key-Value* veritabanı) çok farklı olduğu açıkça görülebilir. Bu nedenle, iyi bir performans elde etmek istiyorsanız, analitik sorguları işlemek için OLTP veya *Key-Value* veritabanlarını kullanmak pek mantıklı olmaz. Örneğin, analitik için MongoDB veya Redis kullanmaya çalışırsanız, OLAP veritabanlarına kıyasla çok düşük performans elde edersiniz. ## Sütun yönelimli veritabanları OLAP senaryosunda neden daha iyi çalışır {#why-column-oriented-databases-work-better-in-the-olap-scenario} -Sütun yönelimli veritabanları OLAP senaryolarına daha uygundur: çoğu sorgunun işlenmesinde en az 100 kat daha hızlıdır. Nedenleri aşağıda ayrıntılı olarak açıklanmıştır, ancak gerçek görsel olarak göstermek daha kolaydır: +Sütun yönelimli veritabanları OLAP senaryolarına daha uygundur: hatta o kadar ki, çoğu sorgunun işlenmesi en az 100 kat daha hızlıdır. Her ne kadar OLAP veritabanlarının neden bu kadar hızlı olduğuna dair nedenler aşağıda ayrıntılı verilmiş olsa da görseller üzerinden anlatmak daha kolay olacakttır: **Satır yönelimli DBMS** @@ -70,7 +68,7 @@ Sütun yönelimli veritabanları OLAP senaryolarına daha uygundur: çoğu sorgu ![Column-oriented](images/column_oriented.gif#) -Farkı görüyor musun? +Farkı görüyor musunuz? ### Giriş/çıkış {#inputoutput} From 9aabff4c40ae868535b7fcb5a3232fcd174dc458 Mon Sep 17 00:00:00 2001 From: Ivan Blinkov Date: Thu, 16 Apr 2020 09:51:39 +0300 Subject: [PATCH 49/73] Update README.md --- README.md | 1 - 1 file changed, 1 deletion(-) diff --git a/README.md b/README.md index 3db5e08d2a9..8da2c5771a9 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,5 @@ ClickHouse is an open-source column-oriented database management system that all ## Upcoming Events -* [ClickHouse Monitoring Round Table (online in English)](https://www.eventbrite.com/e/clickhouse-april-virtual-meetup-tickets-102272923066) on April 15, 2020. * [ClickHouse Workshop in Novosibirsk](https://2020.codefest.ru/lecture/1628) on TBD date. * [Yandex C++ Open-Source Sprints in Moscow](https://events.yandex.ru/events/otkrytyj-kod-v-yandek-28-03-2020) on TBD date. From f1f862a6a858f07611c285e2fda0a9b95fd11ff2 Mon Sep 17 00:00:00 2001 From: Nikolai Kochetov Date: Thu, 16 Apr 2020 11:35:32 +0300 Subject: [PATCH 50/73] Update docker for stateless_with_coverage. --- docker/test/stateless_with_coverage/run.sh | 1 + 1 file changed, 1 insertion(+) diff --git a/docker/test/stateless_with_coverage/run.sh b/docker/test/stateless_with_coverage/run.sh index 0a914030c4a..6eec6f278dc 100755 --- a/docker/test/stateless_with_coverage/run.sh +++ b/docker/test/stateless_with_coverage/run.sh @@ -50,6 +50,7 @@ ln -s /usr/share/clickhouse-test/config/zookeeper.xml /etc/clickhouse-server/con ln -s /usr/share/clickhouse-test/config/disks.xml /etc/clickhouse-server/config.d/; \ ln -s /usr/share/clickhouse-test/config/secure_ports.xml /etc/clickhouse-server/config.d/; \ ln -s /usr/share/clickhouse-test/config/clusters.xml /etc/clickhouse-server/config.d/; \ + ln -s /usr/share/clickhouse-test/config/graphite.xml /etc/clickhouse-server/config.d/; \ ln -s /usr/share/clickhouse-test/config/server.key /etc/clickhouse-server/; \ ln -s /usr/share/clickhouse-test/config/server.crt /etc/clickhouse-server/; \ ln -s /usr/share/clickhouse-test/config/dhparam.pem /etc/clickhouse-server/; \ From ff0d04de05c7b76f8185ed39883807662c413368 Mon Sep 17 00:00:00 2001 From: Ivan Blinkov Date: Thu, 16 Apr 2020 11:47:12 +0300 Subject: [PATCH 51/73] Update README.md --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 8da2c5771a9..955f9d1a5d1 100644 --- a/README.md +++ b/README.md @@ -11,7 +11,7 @@ ClickHouse is an open-source column-oriented database management system that all * [Slack](https://join.slack.com/t/clickhousedb/shared_invite/zt-d2zxkf9e-XyxDa_ucfPxzuH4SJIm~Ng) and [Telegram](https://telegram.me/clickhouse_en) allow to chat with ClickHouse users in real-time. * [Blog](https://clickhouse.yandex/blog/en/) contains various ClickHouse-related articles, as well as announces and reports about events. * [Contacts](https://clickhouse.tech/#contacts) can help to get your questions answered if there are any. -* You can also [fill this form](https://forms.yandex.com/surveys/meet-yandex-clickhouse-team/) to meet Yandex ClickHouse team in person. +* You can also [fill this form](https://clickhouse.tech/#meet) to meet Yandex ClickHouse team in person. ## Upcoming Events From 9b85ca0f3efd8220aaa8c9989a91198e372dcfe0 Mon Sep 17 00:00:00 2001 From: Ivan Blinkov Date: Thu, 16 Apr 2020 12:09:04 +0300 Subject: [PATCH 52/73] Update build.py --- docs/tools/build.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/tools/build.py b/docs/tools/build.py index 30a8d6f1eee..4f3a5378b34 100755 --- a/docs/tools/build.py +++ b/docs/tools/build.py @@ -384,7 +384,7 @@ if __name__ == '__main__': arg_parser.add_argument('--output-dir', default='build') arg_parser.add_argument('--enable-stable-releases', action='store_true') arg_parser.add_argument('--stable-releases-limit', type=int, default='4') - arg_parser.add_argument('--lts-releases-limit', type=int, default='1') + arg_parser.add_argument('--lts-releases-limit', type=int, default='2') arg_parser.add_argument('--version-prefix', type=str, default='') arg_parser.add_argument('--is-stable-release', action='store_true') arg_parser.add_argument('--skip-single-page', action='store_true') From b9c8d919aed4295bd9c5f6e33865c74f2618a418 Mon Sep 17 00:00:00 2001 From: Ivan Blinkov Date: Thu, 16 Apr 2020 12:14:30 +0300 Subject: [PATCH 53/73] Update install.md --- docs/en/getting_started/install.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/en/getting_started/install.md b/docs/en/getting_started/install.md index 316cc5a47ef..3a9cac802fc 100644 --- a/docs/en/getting_started/install.md +++ b/docs/en/getting_started/install.md @@ -38,7 +38,7 @@ sudo apt-get update sudo apt-get install clickhouse-client clickhouse-server ``` -You can also download and install packages manually from here: https://repo.yandex.ru/clickhouse/deb/stable/main/. +You can also download and install packages manually from [here](https://repo.yandex.ru/clickhouse/deb/stable/main/). #### Packages {#packages} @@ -67,7 +67,7 @@ Then run these commands to install packages: sudo yum install clickhouse-server clickhouse-client ``` -You can also download and install packages manually from here: https://repo.clickhouse.tech/rpm/stable/x86\_64. +You can also download and install packages manually from [here](https://repo.clickhouse.tech/rpm/stable/x86_64). ### From Tgz Archives {#from-tgz-archives} From 398ed4d9c27b2b521e024c670219f9d616b69ba2 Mon Sep 17 00:00:00 2001 From: alesapin Date: Thu, 16 Apr 2020 14:23:37 +0300 Subject: [PATCH 54/73] Fix images.json list --- docker/images.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/docker/images.json b/docker/images.json index c7dfc82d906..434a3c7af10 100644 --- a/docker/images.json +++ b/docker/images.json @@ -1,10 +1,10 @@ { "docker/packager/deb": "yandex/clickhouse-deb-builder", "docker/packager/binary": "yandex/clickhouse-binary-builder", + "docker/test/coverage": "yandex/clickhouse-coverage", "docker/test/compatibility/centos": "yandex/clickhouse-test-old-centos", "docker/test/compatibility/ubuntu": "yandex/clickhouse-test-old-ubuntu", "docker/test/integration": "yandex/clickhouse-integration-test", - "docker/test/performance": "yandex/clickhouse-performance-test", "docker/test/performance-comparison": "yandex/clickhouse-performance-comparison", "docker/test/pvs": "yandex/clickhouse-pvs-test", "docker/test/stateful": "yandex/clickhouse-stateful-test", @@ -14,5 +14,6 @@ "docker/test/unit": "yandex/clickhouse-unit-test", "docker/test/stress": "yandex/clickhouse-stress-test", "docker/test/split_build_smoke_test": "yandex/clickhouse-split-build-smoke-test", + "docker/test/codebrowser": "yandex/clickhouse-codebrowser", "tests/integration/image": "yandex/clickhouse-integration-tests-runner" } From 8d9240d3e9f34648c0cdbfe06a86323f378c1e63 Mon Sep 17 00:00:00 2001 From: alesapin Date: Thu, 16 Apr 2020 15:26:57 +0300 Subject: [PATCH 55/73] Second kill in statlesess image --- docker/test/stateless_with_coverage/run.sh | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/docker/test/stateless_with_coverage/run.sh b/docker/test/stateless_with_coverage/run.sh index 6eec6f278dc..238c7567694 100755 --- a/docker/test/stateless_with_coverage/run.sh +++ b/docker/test/stateless_with_coverage/run.sh @@ -14,6 +14,11 @@ kill_clickhouse () { sleep 10 fi done + + echo "Will try to send second kill signal for sure" + kill `pgrep -u clickhouse` 2>/dev/null + sleep 5 + echo "clickhouse pids" `ps aux | grep clickhouse` | ts '%Y-%m-%d %H:%M:%S' } start_clickhouse () { From e230632645a29d917a934a1b46d2b8a81a5bb9d1 Mon Sep 17 00:00:00 2001 From: Ivan Lezhankin Date: Thu, 16 Apr 2020 15:31:57 +0300 Subject: [PATCH 56/73] Changes required for auto-sync with Arcadia --- base/common/types.h | 4 + base/common/ya.make | 35 ++ base/daemon/BaseDaemon.cpp | 16 +- base/daemon/ya.make | 14 + base/loggers/ya.make | 15 + base/pcg-random/ya.make | 5 + base/widechar_width/ya.make | 9 + base/ya.make | 4 + programs/server/HTTPHandler.cpp | 6 +- programs/server/MySQLHandler.cpp | 16 +- programs/server/MySQLHandler.h | 8 +- programs/server/MySQLHandlerFactory.h | 8 +- programs/server/Server.cpp | 21 +- programs/server/TCPHandler.cpp | 5 +- programs/server/ya.make | 30 ++ programs/ya.make | 3 + src/Access/AccessFlags.h | 8 +- src/Access/ContextAccess.cpp | 6 +- src/Access/DiskAccessStorage.cpp | 4 +- src/Access/ExtendedRoleSet.cpp | 18 +- src/Access/QuotaCache.cpp | 18 +- src/Access/RoleCache.cpp | 17 +- src/Access/RowPolicyCache.cpp | 17 +- src/Access/SettingsProfilesCache.cpp | 19 +- src/Access/ya.make | 40 ++ .../registerAggregateFunctions.cpp | 2 + src/AggregateFunctions/ya.make | 54 +++ src/Client/Connection.cpp | 9 +- src/Client/ya.make | 15 + src/Columns/Collator.cpp | 20 +- src/Columns/ya.make | 34 ++ src/Common/ClickHouseRevision.cpp | 5 +- src/Common/Exception.cpp | 5 +- src/Common/OpenSSLHelpers.h | 9 +- src/Common/OptimizedRegularExpression.h | 10 +- src/Common/QueryProfiler.cpp | 1 - src/Common/QueryProfiler.h | 7 +- src/Common/StackTrace.cpp | 7 +- src/Common/XDBCBridgeHelper.h | 5 +- src/Common/getNumberOfPhysicalCPUCores.cpp | 11 +- src/Common/new_delete.cpp | 33 +- src/Common/ya.make | 109 +++++ src/Compression/ya.make | 33 ++ src/Core/Field.h | 2 + src/Core/MySQLProtocol.h | 10 +- src/Core/NamesAndTypes.cpp | 8 +- src/Core/ya.make | 24 + src/DataStreams/ya.make | 71 +++ src/DataTypes/Native.h | 30 +- src/DataTypes/ya.make | 41 ++ src/Databases/DatabaseFactory.cpp | 11 +- src/Databases/DatabaseMySQL.cpp | 47 +- src/Databases/ya.make | 19 + src/Dictionaries/CMakeLists.txt | 7 - .../CacheDictionary_generate1.cpp | 32 ++ .../CacheDictionary_generate1.cpp.in | 22 - .../CacheDictionary_generate2.cpp | 34 ++ .../CacheDictionary_generate2.cpp.in | 23 - .../CacheDictionary_generate3.cpp | 31 ++ .../CacheDictionary_generate3.cpp.in | 20 - .../ComplexKeyCacheDictionary_generate1.cpp | 32 ++ ...ComplexKeyCacheDictionary_generate1.cpp.in | 22 - .../ComplexKeyCacheDictionary_generate2.cpp | 35 ++ ...ComplexKeyCacheDictionary_generate2.cpp.in | 25 -- .../ComplexKeyCacheDictionary_generate3.cpp | 35 ++ ...ComplexKeyCacheDictionary_generate3.cpp.in | 25 -- src/Dictionaries/HashedDictionary.h | 6 + src/Dictionaries/MongoDBBlockInputStream.cpp | 40 +- src/Dictionaries/MongoDBDictionarySource.h | 8 +- src/Dictionaries/MySQLDictionarySource.cpp | 2 +- src/Dictionaries/MySQLDictionarySource.h | 6 +- src/Dictionaries/RedisBlockInputStream.h | 5 +- src/Dictionaries/RedisDictionarySource.h | 7 +- src/Dictionaries/XDBCDictionarySource.cpp | 5 +- src/Dictionaries/registerDictionaries.cpp | 2 + src/Dictionaries/ya.make | 63 +++ src/Disks/DiskS3.h | 4 +- src/Disks/registerDisks.cpp | 4 +- src/Disks/ya.make | 17 + src/Formats/FormatFactory.cpp | 10 +- src/Formats/MySQLBlockInputStream.cpp | 24 +- src/Formats/ProtobufColumnMatcher.h | 21 +- src/Formats/ProtobufReader.cpp | 140 +++--- src/Formats/ProtobufReader.h | 14 +- src/Formats/ProtobufSchemas.cpp | 14 +- src/Formats/ProtobufWriter.cpp | 84 ++-- src/Formats/ProtobufWriter.h | 18 +- src/Formats/ya.make | 24 + src/Functions/DivisionUtils.h | 4 +- src/Functions/FunctionBase64Conversion.h | 21 +- src/Functions/FunctionBinaryArithmetic.h | 13 +- src/Functions/FunctionIfBase.h | 4 +- src/Functions/FunctionMathBinaryFloat64.h | 5 +- src/Functions/FunctionMathUnary.h | 7 +- src/Functions/FunctionUnaryArithmetic.h | 13 +- src/Functions/FunctionsEmbeddedDictionaries.h | 5 +- src/Functions/FunctionsExternalDictionaries.h | 18 +- src/Functions/FunctionsHashing.cpp | 2 + src/Functions/FunctionsHashing.h | 45 +- src/Functions/FunctionsJSON.h | 5 +- src/Functions/FunctionsStringRegex.cpp | 15 +- src/Functions/IFunction.cpp | 13 +- src/Functions/IFunction.h | 5 +- src/Functions/RapidJSONParser.h | 14 +- src/Functions/Regexps.h | 10 +- src/Functions/SimdJSONParser.h | 15 +- src/Functions/base64Encode.cpp | 7 +- src/Functions/convertCharset.cpp | 32 +- src/Functions/intDiv.cpp | 1 - src/Functions/registerFunctions.cpp | 2 + .../registerFunctionsConsistentHashing.cpp | 4 + src/Functions/registerFunctionsGeo.cpp | 4 +- .../registerFunctionsMiscellaneous.cpp | 4 +- src/Functions/registerFunctionsString.cpp | 4 +- src/Functions/version.cpp | 4 +- src/Functions/ya.make | 418 ++++++++++++++++++ src/IO/BrotliReadBuffer.cpp | 10 +- src/IO/BrotliWriteBuffer.cpp | 10 +- src/IO/CompressionMethod.cpp | 4 +- src/IO/HTTPCommon.cpp | 19 +- src/IO/ReadWriteBufferFromHTTP.h | 6 +- src/IO/UseSSL.cpp | 6 +- src/IO/WriteBufferFromHTTPServerResponse.cpp | 5 +- src/IO/WriteBufferFromHTTPServerResponse.h | 5 +- src/IO/ya.make | 59 +++ src/Interpreters/Aggregator.cpp | 5 +- src/Interpreters/AsynchronousMetrics.cpp | 20 +- src/Interpreters/ClientInfo.cpp | 5 +- src/Interpreters/Context.h | 5 +- src/Interpreters/ExpressionActions.cpp | 5 +- src/Interpreters/ExpressionActions.h | 5 +- src/Interpreters/ExpressionJIT.h | 16 +- .../ExternalDictionariesLoader.cpp | 11 +- src/Interpreters/InterpreterSetRoleQuery.cpp | 4 +- src/Interpreters/InterpreterSystemQuery.cpp | 5 +- src/Interpreters/ya.make | 138 ++++++ src/Parsers/ASTSystemQuery.h | 5 +- src/Parsers/ya.make | 113 +++++ .../Formats/Impl/ProtobufRowInputFormat.h | 12 +- .../Formats/Impl/ProtobufRowOutputFormat.h | 16 +- src/Processors/ya.make | 100 +++++ src/Storages/IStorage.cpp | 9 +- .../MergeTree/MergeTreeIndexFullText.cpp | 3 +- src/Storages/StorageMySQL.h | 13 +- .../System/StorageSystemBuildOptions.cpp | 4 + src/Storages/registerStorages.cpp | 3 - src/Storages/registerStorages.h | 7 +- src/Storages/ya.make | 167 +++++++ src/TableFunctions/ITableFunctionXDBC.h | 5 +- src/TableFunctions/TableFunctionMySQL.cpp | 42 +- src/TableFunctions/registerTableFunctions.h | 7 +- src/TableFunctions/ya.make | 26 ++ src/ya.make | 26 ++ ya.make | 2 + 154 files changed, 2719 insertions(+), 717 deletions(-) create mode 100644 base/daemon/ya.make create mode 100644 base/loggers/ya.make create mode 100644 base/pcg-random/ya.make create mode 100644 base/widechar_width/ya.make create mode 100644 programs/server/ya.make create mode 100644 programs/ya.make create mode 100644 src/Access/ya.make create mode 100644 src/AggregateFunctions/ya.make create mode 100644 src/Client/ya.make create mode 100644 src/Columns/ya.make create mode 100644 src/Common/ya.make create mode 100644 src/Compression/ya.make create mode 100644 src/Core/ya.make create mode 100644 src/DataStreams/ya.make create mode 100644 src/DataTypes/ya.make create mode 100644 src/Databases/ya.make create mode 100644 src/Dictionaries/CacheDictionary_generate1.cpp delete mode 100644 src/Dictionaries/CacheDictionary_generate1.cpp.in create mode 100644 src/Dictionaries/CacheDictionary_generate2.cpp delete mode 100644 src/Dictionaries/CacheDictionary_generate2.cpp.in create mode 100644 src/Dictionaries/CacheDictionary_generate3.cpp delete mode 100644 src/Dictionaries/CacheDictionary_generate3.cpp.in create mode 100644 src/Dictionaries/ComplexKeyCacheDictionary_generate1.cpp delete mode 100644 src/Dictionaries/ComplexKeyCacheDictionary_generate1.cpp.in create mode 100644 src/Dictionaries/ComplexKeyCacheDictionary_generate2.cpp delete mode 100644 src/Dictionaries/ComplexKeyCacheDictionary_generate2.cpp.in create mode 100644 src/Dictionaries/ComplexKeyCacheDictionary_generate3.cpp delete mode 100644 src/Dictionaries/ComplexKeyCacheDictionary_generate3.cpp.in create mode 100644 src/Dictionaries/ya.make create mode 100644 src/Disks/ya.make create mode 100644 src/Formats/ya.make create mode 100644 src/Functions/ya.make create mode 100644 src/IO/ya.make create mode 100644 src/Interpreters/ya.make create mode 100644 src/Parsers/ya.make create mode 100644 src/Processors/ya.make create mode 100644 src/Storages/ya.make create mode 100644 src/TableFunctions/ya.make create mode 100644 src/ya.make diff --git a/base/common/types.h b/base/common/types.h index 8f125146add..238e4e3956b 100644 --- a/base/common/types.h +++ b/base/common/types.h @@ -11,6 +11,10 @@ using Int16 = int16_t; using Int32 = int32_t; using Int64 = int64_t; +#if __cplusplus <= 201703L +using char8_t = unsigned char; +#endif + using UInt8 = char8_t; using UInt16 = uint16_t; using UInt32 = uint32_t; diff --git a/base/common/ya.make b/base/common/ya.make index a41c8f4c583..31a66893330 100644 --- a/base/common/ya.make +++ b/base/common/ya.make @@ -1,12 +1,47 @@ LIBRARY() +ADDINCL( + GLOBAL clickhouse/base + contrib/libs/cctz/include +) + +CFLAGS (GLOBAL -DARCADIA_BUILD) + +IF (OS_DARWIN) + CFLAGS (GLOBAL -DOS_DARWIN) +ELSEIF (OS_FREEBSD) + CFLAGS (GLOBAL -DOS_FREEBSD) +ELSEIF (OS_LINUX) + CFLAGS (GLOBAL -DOS_LINUX) +ENDIF () + PEERDIR( + contrib/libs/cctz/src + contrib/libs/cxxsupp/libcxx-filesystem + contrib/libs/poco/Net contrib/libs/poco/Util + contrib/restricted/boost + contrib/restricted/cityhash-1.0.2 ) SRCS( argsToConfig.cpp coverage.cpp + DateLUT.cpp + DateLUTImpl.cpp + demangle.cpp + getFQDNOrHostName.cpp + getMemoryAmount.cpp + getThreadId.cpp + JSON.cpp + LineReader.cpp + mremap.cpp + phdr_cache.cpp + preciseExp10.c + setTerminalEcho.cpp + shift10.cpp + sleep.cpp + terminalColors.cpp ) END() diff --git a/base/daemon/BaseDaemon.cpp b/base/daemon/BaseDaemon.cpp index c150dc03014..74df1a41a88 100644 --- a/base/daemon/BaseDaemon.cpp +++ b/base/daemon/BaseDaemon.cpp @@ -50,11 +50,13 @@ #include #include #include -#include -#ifdef __APPLE__ -// ucontext is not available without _XOPEN_SOURCE -#define _XOPEN_SOURCE 700 +#if !defined(ARCADIA_BUILD) +# include +#endif + +#if defined(OS_DARWIN) +# define _XOPEN_SOURCE 700 // ucontext is not available without _XOPEN_SOURCE #endif #include @@ -410,7 +412,7 @@ std::string BaseDaemon::getDefaultCorePath() const void BaseDaemon::closeFDs() { -#if defined(__FreeBSD__) || (defined(__APPLE__) && defined(__MACH__)) +#if defined(OS_FREEBSD) || defined(OS_DARWIN) Poco::File proc_path{"/dev/fd"}; #else Poco::File proc_path{"/proc/self/fd"}; @@ -430,7 +432,7 @@ void BaseDaemon::closeFDs() else { int max_fd = -1; -#ifdef _SC_OPEN_MAX +#if defined(_SC_OPEN_MAX) max_fd = sysconf(_SC_OPEN_MAX); if (max_fd == -1) #endif @@ -448,7 +450,7 @@ namespace /// the maximum is 1000, and chromium uses 300 for its tab processes. Ignore /// whatever errors that occur, because it's just a debugging aid and we don't /// care if it breaks. -#if defined(__linux__) && !defined(NDEBUG) +#if defined(OS_LINUX) && !defined(NDEBUG) void debugIncreaseOOMScore() { const std::string new_score = "555"; diff --git a/base/daemon/ya.make b/base/daemon/ya.make new file mode 100644 index 00000000000..1c72af3ed53 --- /dev/null +++ b/base/daemon/ya.make @@ -0,0 +1,14 @@ +LIBRARY() + +NO_COMPILER_WARNINGS() + +PEERDIR( + clickhouse/src/Common +) + +SRCS( + BaseDaemon.cpp + GraphiteWriter.cpp +) + +END() diff --git a/base/loggers/ya.make b/base/loggers/ya.make new file mode 100644 index 00000000000..b1c84042eee --- /dev/null +++ b/base/loggers/ya.make @@ -0,0 +1,15 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common +) + +SRCS( + ExtendedLogChannel.cpp + Loggers.cpp + OwnFormattingChannel.cpp + OwnPatternFormatter.cpp + OwnSplitChannel.cpp +) + +END() diff --git a/base/pcg-random/ya.make b/base/pcg-random/ya.make new file mode 100644 index 00000000000..c6a50887178 --- /dev/null +++ b/base/pcg-random/ya.make @@ -0,0 +1,5 @@ +LIBRARY() + +ADDINCL (GLOBAL clickhouse/base/pcg-random) + +END() diff --git a/base/widechar_width/ya.make b/base/widechar_width/ya.make new file mode 100644 index 00000000000..fa0b4f705db --- /dev/null +++ b/base/widechar_width/ya.make @@ -0,0 +1,9 @@ +LIBRARY() + +ADDINCL(GLOBAL clickhouse/base/widechar_width) + +SRCS( + widechar_width.cpp +) + +END() diff --git a/base/ya.make b/base/ya.make index 25ab5886b2c..004da9af2ae 100644 --- a/base/ya.make +++ b/base/ya.make @@ -1,3 +1,7 @@ RECURSE( common + daemon + loggers + pcg-random + widechar_width ) diff --git a/programs/server/HTTPHandler.cpp b/programs/server/HTTPHandler.cpp index ec890c0a96d..77236210741 100644 --- a/programs/server/HTTPHandler.cpp +++ b/programs/server/HTTPHandler.cpp @@ -15,7 +15,6 @@ #include #include #include -#include #include #include #include @@ -36,6 +35,11 @@ #include #include +#if !defined(ARCADIA_BUILD) +# include +#endif + + namespace DB { diff --git a/programs/server/MySQLHandler.cpp b/programs/server/MySQLHandler.cpp index bfab19061ce..97d9f1919ac 100644 --- a/programs/server/MySQLHandler.cpp +++ b/programs/server/MySQLHandler.cpp @@ -1,10 +1,8 @@ -#include - #include "MySQLHandler.h" + #include #include #include -#include #include #include #include @@ -18,11 +16,15 @@ #include #include +#if !defined(ARCADIA_BUILD) +# include +#endif + #if USE_POCO_NETSSL -#include -#include -#include -#include +# include +# include +# include +# include #endif namespace DB diff --git a/programs/server/MySQLHandler.h b/programs/server/MySQLHandler.h index ca5d045beb0..01634dd68dc 100644 --- a/programs/server/MySQLHandler.h +++ b/programs/server/MySQLHandler.h @@ -1,13 +1,17 @@ #pragma once -#include + #include #include #include #include #include "IServer.h" +#if !defined(ARCADIA_BUILD) +# include +#endif + #if USE_POCO_NETSSL -#include +# include #endif namespace CurrentMetrics diff --git a/programs/server/MySQLHandlerFactory.h b/programs/server/MySQLHandlerFactory.h index b7df9fa60e0..74f0bb35a40 100644 --- a/programs/server/MySQLHandlerFactory.h +++ b/programs/server/MySQLHandlerFactory.h @@ -1,11 +1,15 @@ #pragma once -#include #include #include #include "IServer.h" + +#if !defined(ARCADIA_BUILD) +# include +#endif + #if USE_SSL -#include +# include #endif namespace DB diff --git a/programs/server/Server.cpp b/programs/server/Server.cpp index 5322514e7c2..3490ff6a445 100644 --- a/programs/server/Server.cpp +++ b/programs/server/Server.cpp @@ -15,7 +15,6 @@ #include #include #include -#include #include #include #include @@ -26,7 +25,6 @@ #include #include #include -#include "config_core.h" #include #include #include @@ -59,19 +57,24 @@ #include "MetricsTransmitter.h" #include #include "TCPHandlerFactory.h" -#include "Common/config_version.h" #include #include #include "MySQLHandlerFactory.h" +#if !defined(ARCADIA_BUILD) +# include +# include "config_core.h" +# include "Common/config_version.h" +#endif + #if defined(OS_LINUX) -#include -#include +# include +# include #endif #if USE_POCO_NETSSL -#include -#include +# include +# include #endif namespace CurrentMetrics @@ -248,7 +251,7 @@ int Server::main(const std::vector & /*args*/) const auto memory_amount = getMemoryAmount(); -#if defined(__linux__) +#if defined(OS_LINUX) std::string executable_path = getExecutablePath(); if (executable_path.empty()) executable_path = "/usr/bin/clickhouse"; /// It is used for information messages. @@ -631,7 +634,7 @@ int Server::main(const std::vector & /*args*/) dns_cache_updater = std::make_unique(*global_context, config().getInt("dns_cache_update_period", 15)); } -#if defined(__linux__) +#if defined(OS_LINUX) if (!TaskStatsInfoGetter::checkPermissions()) { LOG_INFO(log, "It looks like the process has no CAP_NET_ADMIN capability, 'taskstats' performance statistics will be disabled." diff --git a/programs/server/TCPHandler.cpp b/programs/server/TCPHandler.cpp index d82c6e31528..70825cb4f7e 100644 --- a/programs/server/TCPHandler.cpp +++ b/programs/server/TCPHandler.cpp @@ -6,7 +6,6 @@ #include #include #include -#include #include #include #include @@ -33,6 +32,10 @@ #include "TCPHandler.h" +#if !defined(ARCADIA_BUILD) +# include +#endif + namespace DB { diff --git a/programs/server/ya.make b/programs/server/ya.make new file mode 100644 index 00000000000..7f0a3969fd2 --- /dev/null +++ b/programs/server/ya.make @@ -0,0 +1,30 @@ +PROGRAM(clickhouse-server) + +PEERDIR( + clickhouse/base/common + clickhouse/base/daemon + clickhouse/base/loggers + clickhouse/src + contrib/libs/poco/NetSSL_OpenSSL +) + +SRCS( + clickhouse-server.cpp + + HTTPHandler.cpp + HTTPHandlerFactory.cpp + InterserverIOHTTPHandler.cpp + MetricsTransmitter.cpp + MySQLHandler.cpp + MySQLHandlerFactory.cpp + NotFoundHandler.cpp + PingRequestHandler.cpp + PrometheusMetricsWriter.cpp + PrometheusRequestHandler.cpp + ReplicasStatusHandler.cpp + RootRequestHandler.cpp + Server.cpp + TCPHandler.cpp +) + +END() diff --git a/programs/ya.make b/programs/ya.make new file mode 100644 index 00000000000..6c773c312b8 --- /dev/null +++ b/programs/ya.make @@ -0,0 +1,3 @@ +RECURSE( + server +) diff --git a/src/Access/AccessFlags.h b/src/Access/AccessFlags.h index c8f57fcd419..cbba295be1a 100644 --- a/src/Access/AccessFlags.h +++ b/src/Access/AccessFlags.h @@ -253,7 +253,7 @@ private: } else { - if (nodes.contains(keyword)) + if (nodes.count(keyword)) throw Exception(keyword + " declared twice", ErrorCodes::LOGICAL_ERROR); node = std::make_unique(keyword, node_type); nodes[node->keyword] = node.get(); @@ -279,7 +279,7 @@ private: { auto parent_node = std::make_unique(parent_keyword); it_parent = nodes.emplace(parent_node->keyword, parent_node.get()).first; - assert(!owned_nodes.contains(parent_node->keyword)); + assert(!owned_nodes.count(parent_node->keyword)); std::string_view parent_keyword_as_string_view = parent_node->keyword; owned_nodes[parent_keyword_as_string_view] = std::move(parent_node); } @@ -299,9 +299,9 @@ private: #undef MAKE_ACCESS_FLAGS_TO_KEYWORD_TREE_NODE - if (!owned_nodes.contains("NONE")) + if (!owned_nodes.count("NONE")) throw Exception("'NONE' not declared", ErrorCodes::LOGICAL_ERROR); - if (!owned_nodes.contains("ALL")) + if (!owned_nodes.count("ALL")) throw Exception("'ALL' not declared", ErrorCodes::LOGICAL_ERROR); flags_to_keyword_tree = std::move(owned_nodes["ALL"]); diff --git a/src/Access/ContextAccess.cpp b/src/Access/ContextAccess.cpp index 915593f58f0..ab504e32579 100644 --- a/src/Access/ContextAccess.cpp +++ b/src/Access/ContextAccess.cpp @@ -147,9 +147,9 @@ void ContextAccess::setUser(const UserPtr & user_) const current_roles.reserve(params.current_roles.size()); for (const auto & id : params.current_roles) { - if (user->granted_roles.contains(id)) + if (user->granted_roles.count(id)) current_roles.push_back(id); - if (user->granted_roles_with_admin_option.contains(id)) + if (user->granted_roles_with_admin_option.count(id)) current_roles_with_admin_option.push_back(id); } } @@ -358,7 +358,7 @@ void ContextAccess::checkAdminOption(const UUID & role_id) const return; auto roles_with_admin_option_loaded = roles_with_admin_option.load(); - if (roles_with_admin_option_loaded && roles_with_admin_option_loaded->contains(role_id)) + if (roles_with_admin_option_loaded && roles_with_admin_option_loaded->count(role_id)) return; std::optional role_name = manager->readName(role_id); diff --git a/src/Access/DiskAccessStorage.cpp b/src/Access/DiskAccessStorage.cpp index 12c65e7df1e..263f4e82d95 100644 --- a/src/Access/DiskAccessStorage.cpp +++ b/src/Access/DiskAccessStorage.cpp @@ -560,7 +560,7 @@ std::vector DiskAccessStorage::findAllImpl(std::type_index type) const bool DiskAccessStorage::existsImpl(const UUID & id) const { std::lock_guard lock{mutex}; - return id_to_entry_map.contains(id); + return id_to_entry_map.count(id); } @@ -709,7 +709,7 @@ void DiskAccessStorage::updateNoLock(const UUID & id, const UpdateFunc & update_ if (name_changed) { const auto & name_to_id_map = name_to_id_maps.at(type); - if (name_to_id_map.contains(new_name)) + if (name_to_id_map.count(new_name)) throwNameCollisionCannotRename(type, String{old_name}, new_name); scheduleWriteLists(type); } diff --git a/src/Access/ExtendedRoleSet.cpp b/src/Access/ExtendedRoleSet.cpp index eed475bc3cc..145bd0fe7e5 100644 --- a/src/Access/ExtendedRoleSet.cpp +++ b/src/Access/ExtendedRoleSet.cpp @@ -253,44 +253,44 @@ void ExtendedRoleSet::add(const boost::container::flat_set & ids_) bool ExtendedRoleSet::match(const UUID & id) const { - return (all || ids.contains(id)) && !except_ids.contains(id); + return (all || ids.count(id)) && !except_ids.count(id); } bool ExtendedRoleSet::match(const UUID & user_id, const std::vector & enabled_roles) const { - if (!all && !ids.contains(user_id)) + if (!all && !ids.count(user_id)) { bool found_enabled_role = std::any_of( - enabled_roles.begin(), enabled_roles.end(), [this](const UUID & enabled_role) { return ids.contains(enabled_role); }); + enabled_roles.begin(), enabled_roles.end(), [this](const UUID & enabled_role) { return ids.count(enabled_role); }); if (!found_enabled_role) return false; } - if (except_ids.contains(user_id)) + if (except_ids.count(user_id)) return false; bool in_except_list = std::any_of( - enabled_roles.begin(), enabled_roles.end(), [this](const UUID & enabled_role) { return except_ids.contains(enabled_role); }); + enabled_roles.begin(), enabled_roles.end(), [this](const UUID & enabled_role) { return except_ids.count(enabled_role); }); return !in_except_list; } bool ExtendedRoleSet::match(const UUID & user_id, const boost::container::flat_set & enabled_roles) const { - if (!all && !ids.contains(user_id)) + if (!all && !ids.count(user_id)) { bool found_enabled_role = std::any_of( - enabled_roles.begin(), enabled_roles.end(), [this](const UUID & enabled_role) { return ids.contains(enabled_role); }); + enabled_roles.begin(), enabled_roles.end(), [this](const UUID & enabled_role) { return ids.count(enabled_role); }); if (!found_enabled_role) return false; } - if (except_ids.contains(user_id)) + if (except_ids.count(user_id)) return false; bool in_except_list = std::any_of( - enabled_roles.begin(), enabled_roles.end(), [this](const UUID & enabled_role) { return except_ids.contains(enabled_role); }); + enabled_roles.begin(), enabled_roles.end(), [this](const UUID & enabled_role) { return except_ids.count(enabled_role); }); return !in_except_list; } diff --git a/src/Access/QuotaCache.cpp b/src/Access/QuotaCache.cpp index 6db3eb66c5d..96cd6b3e8bb 100644 --- a/src/Access/QuotaCache.cpp +++ b/src/Access/QuotaCache.cpp @@ -250,16 +250,18 @@ void QuotaCache::quotaRemoved(const UUID & quota_id) void QuotaCache::chooseQuotaToConsume() { /// `mutex` is already locked. - std::erase_if( - enabled_quotas, - [&](const std::pair> & pr) + + for (auto i = enabled_quotas.begin(), e = enabled_quotas.end(); i != e;) + { + auto elem = i->second.lock(); + if (!elem) + i = enabled_quotas.erase(i); + else { - auto elem = pr.second.lock(); - if (!elem) - return true; // remove from the `enabled_quotas` list. chooseQuotaToConsumeFor(*elem); - return false; // keep in the `enabled_quotas` list. - }); + ++i; + } + } } void QuotaCache::chooseQuotaToConsumeFor(EnabledQuota & enabled) diff --git a/src/Access/RoleCache.cpp b/src/Access/RoleCache.cpp index 63e19a3cb40..0263b793017 100644 --- a/src/Access/RoleCache.cpp +++ b/src/Access/RoleCache.cpp @@ -103,16 +103,17 @@ void RoleCache::collectRolesInfo() { /// `mutex` is already locked. - std::erase_if( - enabled_roles, - [&](const std::pair> & pr) + for (auto i = enabled_roles.begin(), e = enabled_roles.end(); i != e;) + { + auto elem = i->second.lock(); + if (!elem) + i = enabled_roles.erase(i); + else { - auto elem = pr.second.lock(); - if (!elem) - return true; // remove from the `enabled_roles` map. collectRolesInfoFor(*elem); - return false; // keep in the `enabled_roles` map. - }); + ++i; + } + } } diff --git a/src/Access/RowPolicyCache.cpp b/src/Access/RowPolicyCache.cpp index 44f2cd160d4..04b4202c211 100644 --- a/src/Access/RowPolicyCache.cpp +++ b/src/Access/RowPolicyCache.cpp @@ -178,16 +178,17 @@ void RowPolicyCache::rowPolicyRemoved(const UUID & policy_id) void RowPolicyCache::mixConditions() { /// `mutex` is already locked. - std::erase_if( - enabled_row_policies, - [&](const std::pair> & pr) + for (auto i = enabled_row_policies.begin(), e = enabled_row_policies.end(); i != e;) + { + auto elem = i->second.lock(); + if (!elem) + i = enabled_row_policies.erase(i); + else { - auto elem = pr.second.lock(); - if (!elem) - return true; // remove from the `enabled_row_policies` map. mixConditionsFor(*elem); - return false; // keep in the `enabled_row_policies` map. - }); + ++i; + } + } } diff --git a/src/Access/SettingsProfilesCache.cpp b/src/Access/SettingsProfilesCache.cpp index 552ed324635..f283715e129 100644 --- a/src/Access/SettingsProfilesCache.cpp +++ b/src/Access/SettingsProfilesCache.cpp @@ -104,16 +104,17 @@ void SettingsProfilesCache::setDefaultProfileName(const String & default_profile void SettingsProfilesCache::mergeSettingsAndConstraints() { /// `mutex` is already locked. - std::erase_if( - enabled_settings, - [&](const std::pair> & pr) + for (auto i = enabled_settings.begin(), e = enabled_settings.end(); i != e;) + { + auto enabled = i->second.lock(); + if (!enabled) + i = enabled_settings.erase(i); + else { - auto enabled = pr.second.lock(); - if (!enabled) - return true; // remove from the `enabled_settings` list. mergeSettingsAndConstraintsFor(*enabled); - return false; // keep in the `enabled_settings` list. - }); + ++i; + } + } } @@ -161,7 +162,7 @@ void SettingsProfilesCache::substituteProfiles(SettingsProfileElements & element auto parent_profile_id = *element.parent_profile; element.parent_profile.reset(); - if (already_substituted.contains(parent_profile_id)) + if (already_substituted.count(parent_profile_id)) continue; already_substituted.insert(parent_profile_id); diff --git a/src/Access/ya.make b/src/Access/ya.make new file mode 100644 index 00000000000..fb2e23e0684 --- /dev/null +++ b/src/Access/ya.make @@ -0,0 +1,40 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common +) + +SRCS( + AccessControlManager.cpp + AccessRights.cpp + AccessRightsElement.cpp + AllowedClientHosts.cpp + Authentication.cpp + ContextAccess.cpp + DiskAccessStorage.cpp + EnabledQuota.cpp + EnabledRoles.cpp + EnabledRolesInfo.cpp + EnabledRowPolicies.cpp + EnabledSettings.cpp + ExtendedRoleSet.cpp + IAccessEntity.cpp + IAccessStorage.cpp + MemoryAccessStorage.cpp + MultipleAccessStorage.cpp + Quota.cpp + QuotaCache.cpp + QuotaUsageInfo.cpp + Role.cpp + RoleCache.cpp + RowPolicy.cpp + RowPolicyCache.cpp + SettingsConstraints.cpp + SettingsProfile.cpp + SettingsProfileElement.cpp + SettingsProfilesCache.cpp + User.cpp + UsersConfigAccessStorage.cpp +) + +END() diff --git a/src/AggregateFunctions/registerAggregateFunctions.cpp b/src/AggregateFunctions/registerAggregateFunctions.cpp index a4fc41e9c06..a9ab1d4f8ea 100644 --- a/src/AggregateFunctions/registerAggregateFunctions.cpp +++ b/src/AggregateFunctions/registerAggregateFunctions.cpp @@ -32,7 +32,9 @@ void registerAggregateFunctions() registerAggregateFunctionUniqUpTo(factory); registerAggregateFunctionTopK(factory); registerAggregateFunctionsBitwise(factory); +#if !defined(ARCADIA_BUILD) registerAggregateFunctionsBitmap(factory); +#endif registerAggregateFunctionsMaxIntersections(factory); registerAggregateFunctionHistogram(factory); registerAggregateFunctionRetention(factory); diff --git a/src/AggregateFunctions/ya.make b/src/AggregateFunctions/ya.make new file mode 100644 index 00000000000..bfa32b6dd78 --- /dev/null +++ b/src/AggregateFunctions/ya.make @@ -0,0 +1,54 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common +) + +SRCS( + AggregateFunctionAggThrow.cpp + AggregateFunctionArray.cpp + AggregateFunctionAvg.cpp + AggregateFunctionAvgWeighted.cpp + AggregateFunctionBitwise.cpp + AggregateFunctionBoundingRatio.cpp + AggregateFunctionCategoricalInformationValue.cpp + AggregateFunctionCombinatorFactory.cpp + AggregateFunctionCount.cpp + AggregateFunctionEntropy.cpp + AggregateFunctionFactory.cpp + AggregateFunctionForEach.cpp + AggregateFunctionGroupArray.cpp + AggregateFunctionGroupArrayInsertAt.cpp + AggregateFunctionGroupArrayMoving.cpp + AggregateFunctionGroupUniqArray.cpp + AggregateFunctionHistogram.cpp + AggregateFunctionIf.cpp + AggregateFunctionMaxIntersections.cpp + AggregateFunctionMerge.cpp + AggregateFunctionMinMaxAny.cpp + AggregateFunctionMLMethod.cpp + AggregateFunctionNull.cpp + AggregateFunctionOrFill.cpp + AggregateFunctionQuantile.cpp + AggregateFunctionResample.cpp + AggregateFunctionRetention.cpp + AggregateFunctionSequenceMatch.cpp + AggregateFunctionSimpleLinearRegression.cpp + AggregateFunctionState.cpp + AggregateFunctionStatistics.cpp + AggregateFunctionStatisticsSimple.cpp + AggregateFunctionSum.cpp + AggregateFunctionSumMap.cpp + AggregateFunctionTimeSeriesGroupSum.cpp + AggregateFunctionTopK.cpp + AggregateFunctionUniq.cpp + AggregateFunctionUniqCombined.cpp + AggregateFunctionUniqUpTo.cpp + AggregateFunctionWindowFunnel.cpp + parseAggregateFunctionParameters.cpp + registerAggregateFunctions.cpp + UniqCombinedBiasData.cpp + UniqVariadicHash.cpp +) + +END() diff --git a/src/Client/Connection.cpp b/src/Client/Connection.cpp index f530652caae..cc79e3ec2c8 100644 --- a/src/Client/Connection.cpp +++ b/src/Client/Connection.cpp @@ -19,16 +19,19 @@ #include #include #include -#include #include #include #include #include #include -#include +#if !defined(ARCADIA_BUILD) +# include +# include +#endif + #if USE_POCO_NETSSL -#include +# include #endif namespace CurrentMetrics diff --git a/src/Client/ya.make b/src/Client/ya.make new file mode 100644 index 00000000000..685e0540ad7 --- /dev/null +++ b/src/Client/ya.make @@ -0,0 +1,15 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common + contrib/libs/poco/NetSSL_OpenSSL +) + +SRCS( + Connection.cpp + ConnectionPoolWithFailover.cpp + MultiplexedConnections.cpp + TimeoutSetter.cpp +) + +END() diff --git a/src/Columns/Collator.cpp b/src/Columns/Collator.cpp index c3915125fa1..77735564077 100644 --- a/src/Columns/Collator.cpp +++ b/src/Columns/Collator.cpp @@ -1,17 +1,19 @@ #include -#include "config_core.h" +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif #if USE_ICU - #include - #include - #include - #include +# include +# include +# include +# include #else - #ifdef __clang__ - #pragma clang diagnostic ignored "-Wunused-private-field" - #pragma clang diagnostic ignored "-Wmissing-noreturn" - #endif +# if defined(__clang__) +# pragma clang diagnostic ignored "-Wunused-private-field" +# pragma clang diagnostic ignored "-Wmissing-noreturn" +# endif #endif #include diff --git a/src/Columns/ya.make b/src/Columns/ya.make new file mode 100644 index 00000000000..b36a524e775 --- /dev/null +++ b/src/Columns/ya.make @@ -0,0 +1,34 @@ +LIBRARY() + +ADDINCL( + contrib/libs/icu/common + contrib/libs/icu/i18n + contrib/libs/pdqsort +) + +PEERDIR( + clickhouse/src/Common + contrib/libs/icu + contrib/libs/pdqsort +) + +SRCS( + Collator.cpp + ColumnAggregateFunction.cpp + ColumnArray.cpp + ColumnConst.cpp + ColumnDecimal.cpp + ColumnFixedString.cpp + ColumnFunction.cpp + ColumnLowCardinality.cpp + ColumnNullable.cpp + ColumnsCommon.cpp + ColumnString.cpp + ColumnTuple.cpp + ColumnVector.cpp + FilterDescription.cpp + getLeastSuperColumn.cpp + IColumn.cpp +) + +END() diff --git a/src/Common/ClickHouseRevision.cpp b/src/Common/ClickHouseRevision.cpp index 5513922a655..0b81026adca 100644 --- a/src/Common/ClickHouseRevision.cpp +++ b/src/Common/ClickHouseRevision.cpp @@ -1,5 +1,8 @@ #include -#include + +#if !defined(ARCADIA_BUILD) +# include +#endif namespace ClickHouseRevision { diff --git a/src/Common/Exception.cpp b/src/Common/Exception.cpp index bc3d4a78969..edeb3be069a 100644 --- a/src/Common/Exception.cpp +++ b/src/Common/Exception.cpp @@ -8,11 +8,14 @@ #include #include #include -#include #include #include #include +#if !defined(ARCADIA_BUILD) +# include +#endif + namespace DB { diff --git a/src/Common/OpenSSLHelpers.h b/src/Common/OpenSSLHelpers.h index 8155ffd30ef..e77fc3037c1 100644 --- a/src/Common/OpenSSLHelpers.h +++ b/src/Common/OpenSSLHelpers.h @@ -1,8 +1,11 @@ #pragma once -#include -#if USE_SSL -#include +#if !defined(ARCADIA_BUILD) +# include +#endif + +#if USE_SSL +# include namespace DB diff --git a/src/Common/OptimizedRegularExpression.h b/src/Common/OptimizedRegularExpression.h index 0c31558cecb..fddefe596c4 100644 --- a/src/Common/OptimizedRegularExpression.h +++ b/src/Common/OptimizedRegularExpression.h @@ -5,12 +5,16 @@ #include #include #include -#include #include + +#if !defined(ARCADIA_BUILD) +# include +#endif + #if USE_RE2_ST - #include +# include #else - #define re2_st re2 +# define re2_st re2 #endif diff --git a/src/Common/QueryProfiler.cpp b/src/Common/QueryProfiler.cpp index dd9f36fb3ae..a78c2b2ea6c 100644 --- a/src/Common/QueryProfiler.cpp +++ b/src/Common/QueryProfiler.cpp @@ -6,7 +6,6 @@ #include #include #include -#include #include #include diff --git a/src/Common/QueryProfiler.h b/src/Common/QueryProfiler.h index 17280372237..f00a081972e 100644 --- a/src/Common/QueryProfiler.h +++ b/src/Common/QueryProfiler.h @@ -1,11 +1,14 @@ #pragma once #include -#include -#include #include #include +#if !defined(ARCADIA_BUILD) +# include +# include +#endif + namespace Poco { diff --git a/src/Common/StackTrace.cpp b/src/Common/StackTrace.cpp index 785a97e4d74..48633ef01c1 100644 --- a/src/Common/StackTrace.cpp +++ b/src/Common/StackTrace.cpp @@ -3,7 +3,6 @@ #include #include #include -#include #include #include #include @@ -14,8 +13,12 @@ #include #include +#if !defined(ARCADIA_BUILD) +# include +#endif + #if USE_UNWIND -# include +# include #endif std::string signalToErrorMessage(int sig, const siginfo_t & info, const ucontext_t & context) diff --git a/src/Common/XDBCBridgeHelper.h b/src/Common/XDBCBridgeHelper.h index b9d1f2cdcdf..41aeb421394 100644 --- a/src/Common/XDBCBridgeHelper.h +++ b/src/Common/XDBCBridgeHelper.h @@ -13,10 +13,13 @@ #include #include #include -#include #include #include +#if !defined(ARCADIA_BUILD) +# include +#endif + namespace DB { namespace ErrorCodes diff --git a/src/Common/getNumberOfPhysicalCPUCores.cpp b/src/Common/getNumberOfPhysicalCPUCores.cpp index 32b70b76fbd..1eaa64ae2a4 100644 --- a/src/Common/getNumberOfPhysicalCPUCores.cpp +++ b/src/Common/getNumberOfPhysicalCPUCores.cpp @@ -1,11 +1,16 @@ #include #include -#include +#if !defined(ARCADIA_BUILD) +# include +#else +# include +#endif + #if USE_CPUID -# include +# include #elif USE_CPUINFO -# include +# include #endif diff --git a/src/Common/new_delete.cpp b/src/Common/new_delete.cpp index 0aa5f8aacce..ed0d99679e4 100644 --- a/src/Common/new_delete.cpp +++ b/src/Common/new_delete.cpp @@ -1,4 +1,3 @@ -#include #include #include @@ -14,14 +13,13 @@ /// Replace default new/delete with memory tracking versions. /// @sa https://en.cppreference.com/w/cpp/memory/new/operator_new /// https://en.cppreference.com/w/cpp/memory/new/operator_delete -#if !UNBUNDLED namespace Memory { inline ALWAYS_INLINE void trackMemory(std::size_t size) { -#if USE_JEMALLOC +#if USE_JEMALLOC && JEMALLOC_VERSION_MAJOR >= 5 /// The nallocx() function allocates no memory, but it performs the same size computation as the mallocx() function /// @note je_mallocx() != je_malloc(). It's expected they don't differ much in allocation logic. if (likely(size != 0)) @@ -49,18 +47,18 @@ inline ALWAYS_INLINE void untrackMemory(void * ptr [[maybe_unused]], std::size_t { try { -#if USE_JEMALLOC +#if USE_JEMALLOC && JEMALLOC_VERSION_MAJOR >= 5 /// @note It's also possible to use je_malloc_usable_size() here. if (likely(ptr != nullptr)) CurrentMemoryTracker::free(sallocx(ptr, 0)); #else if (size) CurrentMemoryTracker::free(size); -# ifdef _GNU_SOURCE +# if defined(_GNU_SOURCE) /// It's innaccurate resource free for sanitizers. malloc_usable_size() result is greater or equal to allocated size. else CurrentMemoryTracker::free(malloc_usable_size(ptr)); -# endif +# endif #endif } catch (...) @@ -130,26 +128,3 @@ void operator delete[](void * ptr, std::size_t size) noexcept Memory::untrackMemory(ptr, size); Memory::deleteSized(ptr, size); } - -#else - -/// new - -void * operator new(std::size_t size) { return Memory::newImpl(size); } -void * operator new[](std::size_t size) { return Memory::newImpl(size); } - -void * operator new(std::size_t size, const std::nothrow_t &) noexcept { return Memory::newNoExept(size); } -void * operator new[](std::size_t size, const std::nothrow_t &) noexcept { return Memory::newNoExept(size); } - -/// delete - -void operator delete(void * ptr) noexcept { Memory::deleteImpl(ptr); } -void operator delete[](void * ptr) noexcept { Memory::deleteImpl(ptr); } - -void operator delete(void * ptr, const std::nothrow_t &) noexcept { Memory::deleteImpl(ptr); } -void operator delete[](void * ptr, const std::nothrow_t &) noexcept { Memory::deleteImpl(ptr); } - -void operator delete(void * ptr, std::size_t size) noexcept { Memory::deleteSized(ptr, size); } -void operator delete[](void * ptr, std::size_t size) noexcept { Memory::deleteSized(ptr, size); } - -#endif diff --git a/src/Common/ya.make b/src/Common/ya.make new file mode 100644 index 00000000000..53155ac471f --- /dev/null +++ b/src/Common/ya.make @@ -0,0 +1,109 @@ +LIBRARY() + +ADDINCL ( + GLOBAL clickhouse/src + contrib/libs/libcpuid + contrib/libs/libunwind/include + GLOBAL contrib/restricted/ryu +) + +PEERDIR( + clickhouse/base/common + clickhouse/base/pcg-random + clickhouse/base/widechar_width + contrib/libs/libcpuid/libcpuid + contrib/libs/openssl + contrib/libs/re2 + contrib/restricted/ryu +) + +# TODO: stub for config_version.h +CFLAGS (GLOBAL -DDBMS_NAME=\"ClickHouse\") +CFLAGS (GLOBAL -DDBMS_VERSION_MAJOR=0) +CFLAGS (GLOBAL -DDBMS_VERSION_MINOR=0) +CFLAGS (GLOBAL -DDBMS_VERSION_PATCH=0) +CFLAGS (GLOBAL -DVERSION_FULL=\"Clickhouse\") +CFLAGS (GLOBAL -DVERSION_INTEGER=0) +CFLAGS (GLOBAL -DVERSION_NAME=\"Clickhouse\") +CFLAGS (GLOBAL -DVERSION_OFFICIAL=\"\\\(arcadia\\\)\") +CFLAGS (GLOBAL -DVERSION_REVISION=0) +CFLAGS (GLOBAL -DVERSION_STRING=\"Unknown\") + +SRCS( + ActionLock.cpp + AlignedBuffer.cpp + checkStackSize.cpp + ClickHouseRevision.cpp + Config/AbstractConfigurationComparison.cpp + Config/ConfigProcessor.cpp + Config/configReadClient.cpp + Config/ConfigReloader.cpp + createHardLink.cpp + CurrentMetrics.cpp + CurrentThread.cpp + DNSResolver.cpp + Dwarf.cpp + Elf.cpp + ErrorCodes.cpp + escapeForFileName.cpp + Exception.cpp + ExternalLoaderStatus.cpp + FieldVisitors.cpp + FileChecker.cpp + filesystemHelpers.cpp + formatIPv6.cpp + formatReadable.cpp + getExecutablePath.cpp + getMultipleKeysFromConfig.cpp + getNumberOfPhysicalCPUCores.cpp + hasLinuxCapability.cpp + hex.cpp + IntervalKind.cpp + IPv6ToBinary.cpp + isLocalAddress.cpp + Macros.cpp + malloc.cpp + MemoryTracker.cpp + new_delete.cpp + OptimizedRegularExpression.cpp + parseAddress.cpp + parseGlobs.cpp + parseRemoteDescription.cpp + PipeFDs.cpp + PODArray.cpp + ProfileEvents.cpp + QueryProfiler.cpp + quoteString.cpp + randomSeed.cpp + RemoteHostFilter.cpp + RWLock.cpp + SensitiveDataMasker.cpp + setThreadName.cpp + SharedLibrary.cpp + ShellCommand.cpp + StackTrace.cpp + StatusFile.cpp + StatusInfo.cpp + Stopwatch.cpp + StringUtils/StringUtils.cpp + StudentTTest.cpp + SymbolIndex.cpp + TaskStatsInfoGetter.cpp + TerminalSize.cpp + thread_local_rng.cpp + ThreadFuzzer.cpp + ThreadPool.cpp + ThreadStatus.cpp + TraceCollector.cpp + UTF8Helpers.cpp + WeakHash.cpp + ZooKeeper/IKeeper.cpp + ZooKeeper/Lock.cpp + ZooKeeper/TestKeeper.cpp + ZooKeeper/ZooKeeper.cpp + ZooKeeper/ZooKeeperHolder.cpp + ZooKeeper/ZooKeeperImpl.cpp + ZooKeeper/ZooKeeperNodeCache.cpp +) + +END() diff --git a/src/Compression/ya.make b/src/Compression/ya.make new file mode 100644 index 00000000000..55b5287e3f3 --- /dev/null +++ b/src/Compression/ya.make @@ -0,0 +1,33 @@ +LIBRARY() + +ADDINCL( + contrib/libs/lz4 + contrib/libs/zstd +) + +PEERDIR( + clickhouse/src/Common + contrib/libs/lz4 + contrib/libs/zstd +) + +SRCS( + CachedCompressedReadBuffer.cpp + CompressedReadBuffer.cpp + CompressedReadBufferBase.cpp + CompressedReadBufferFromFile.cpp + CompressedWriteBuffer.cpp + CompressionCodecDelta.cpp + CompressionCodecDoubleDelta.cpp + CompressionCodecGorilla.cpp + CompressionCodecLZ4.cpp + CompressionCodecMultiple.cpp + CompressionCodecNone.cpp + CompressionCodecT64.cpp + CompressionCodecZSTD.cpp + CompressionFactory.cpp + ICompressionCodec.cpp + LZ4_decompress_faster.cpp +) + +END() diff --git a/src/Core/Field.h b/src/Core/Field.h index 5e62e4ef3e4..152ae29bd1e 100644 --- a/src/Core/Field.h +++ b/src/Core/Field.h @@ -157,7 +157,9 @@ private: template <> struct NearestFieldTypeImpl { using Type = std::conditional_t, Int64, UInt64>; }; template <> struct NearestFieldTypeImpl { using Type = Int64; }; template <> struct NearestFieldTypeImpl { using Type = UInt64; }; +#if __cplusplus > 201703L template <> struct NearestFieldTypeImpl { using Type = UInt64; }; +#endif template <> struct NearestFieldTypeImpl { using Type = UInt64; }; template <> struct NearestFieldTypeImpl { using Type = UInt64; }; diff --git a/src/Core/MySQLProtocol.h b/src/Core/MySQLProtocol.h index 5255c6f263e..20dd25b6b2d 100644 --- a/src/Core/MySQLProtocol.h +++ b/src/Core/MySQLProtocol.h @@ -22,10 +22,14 @@ #include #include #include -#include "config_core.h" + +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + #if USE_SSL -#include -#include +# include +# include #endif /// Implementation of MySQL wire protocol. diff --git a/src/Core/NamesAndTypes.cpp b/src/Core/NamesAndTypes.cpp index b45e7d771a9..3a55a4328a7 100644 --- a/src/Core/NamesAndTypes.cpp +++ b/src/Core/NamesAndTypes.cpp @@ -137,8 +137,12 @@ NamesAndTypesList NamesAndTypesList::filter(const Names & names) const NamesAndTypesList NamesAndTypesList::addTypes(const Names & names) const { - /// NOTE It's better to make a map in `IStorage` than to create it here every time again. - ::google::dense_hash_map types; + /// NOTE: It's better to make a map in `IStorage` than to create it here every time again. +#if !defined(ARCADIA_BUILD) + google::dense_hash_map types; +#else + google::sparsehash::dense_hash_map types; +#endif types.set_empty_key(StringRef()); for (const NameAndTypePair & column : *this) diff --git a/src/Core/ya.make b/src/Core/ya.make new file mode 100644 index 00000000000..4999fe334bc --- /dev/null +++ b/src/Core/ya.make @@ -0,0 +1,24 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common + contrib/libs/sparsehash + contrib/restricted/boost/libs +) + +SRCS( + BackgroundSchedulePool.cpp + Block.cpp + BlockInfo.cpp + ColumnWithTypeAndName.cpp + ExternalResultDescription.cpp + ExternalTable.cpp + Field.cpp + iostream_debug_helpers.cpp + MySQLProtocol.cpp + NamesAndTypes.cpp + Settings.cpp + SettingsCollection.cpp +) + +END() diff --git a/src/DataStreams/ya.make b/src/DataStreams/ya.make new file mode 100644 index 00000000000..e6f8d8a94d7 --- /dev/null +++ b/src/DataStreams/ya.make @@ -0,0 +1,71 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common +) + +NO_COMPILER_WARNINGS() + +SRCS( + AddingDefaultBlockOutputStream.cpp + AddingDefaultsBlockInputStream.cpp + AggregatingBlockInputStream.cpp + AggregatingSortedBlockInputStream.cpp + AsynchronousBlockInputStream.cpp + BlockIO.cpp + BlockStreamProfileInfo.cpp + CheckConstraintsBlockOutputStream.cpp + CheckSortedBlockInputStream.cpp + CollapsingFinalBlockInputStream.cpp + CollapsingSortedBlockInputStream.cpp + ColumnGathererStream.cpp + ConvertingBlockInputStream.cpp + copyData.cpp + CountingBlockOutputStream.cpp + CreatingSetsBlockInputStream.cpp + CubeBlockInputStream.cpp + DistinctBlockInputStream.cpp + DistinctSortedBlockInputStream.cpp + ExecutionSpeedLimits.cpp + ExpressionBlockInputStream.cpp + FillingBlockInputStream.cpp + FilterBlockInputStream.cpp + FilterColumnsBlockInputStream.cpp + finalizeBlock.cpp + FinishSortingBlockInputStream.cpp + GraphiteRollupSortedBlockInputStream.cpp + IBlockInputStream.cpp + InputStreamFromASTInsertQuery.cpp + InternalTextLogsRowOutputStream.cpp + LimitBlockInputStream.cpp + LimitByBlockInputStream.cpp + materializeBlock.cpp + MaterializingBlockInputStream.cpp + MergeSortingBlockInputStream.cpp + MergingAggregatedBlockInputStream.cpp + MergingAggregatedMemoryEfficientBlockInputStream.cpp + MergingSortedBlockInputStream.cpp + narrowBlockInputStreams.cpp + NativeBlockInputStream.cpp + NativeBlockOutputStream.cpp + ParallelAggregatingBlockInputStream.cpp + ParallelParsingBlockInputStream.cpp + PartialSortingBlockInputStream.cpp + processConstants.cpp + PushingToViewsBlockOutputStream.cpp + RemoteBlockInputStream.cpp + RemoteBlockOutputStream.cpp + ReplacingSortedBlockInputStream.cpp + ReverseBlockInputStream.cpp + RollupBlockInputStream.cpp + SizeLimits.cpp + SquashingBlockInputStream.cpp + SquashingBlockOutputStream.cpp + SquashingTransform.cpp + SummingSortedBlockInputStream.cpp + TotalsHavingBlockInputStream.cpp + TTLBlockInputStream.cpp + VersionedCollapsingSortedBlockInputStream.cpp +) + +END() diff --git a/src/DataTypes/Native.h b/src/DataTypes/Native.h index 3652e85e2d3..754365dfc87 100644 --- a/src/DataTypes/Native.h +++ b/src/DataTypes/Native.h @@ -1,23 +1,25 @@ #pragma once -#include "config_core.h" +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + #if USE_EMBEDDED_COMPILER +# include +# include +# include +# include +# include +# include +# include +# include -#include -#include -#include -#include -#include -#include -#include -#include +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-parameter" -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" +# include -#include - -#pragma GCC diagnostic pop +# pragma GCC diagnostic pop namespace DB diff --git a/src/DataTypes/ya.make b/src/DataTypes/ya.make new file mode 100644 index 00000000000..c3a1e452d0d --- /dev/null +++ b/src/DataTypes/ya.make @@ -0,0 +1,41 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common + clickhouse/src/Formats +) + +SRCS( + convertMySQLDataType.cpp + DataTypeAggregateFunction.cpp + DataTypeArray.cpp + DataTypeCustomIPv4AndIPv6.cpp + DataTypeCustomSimpleAggregateFunction.cpp + DataTypeCustomSimpleTextSerialization.cpp + DataTypeDate.cpp + DataTypeDateTime.cpp + DataTypeDateTime64.cpp + DataTypeDecimalBase.cpp + DataTypeEnum.cpp + DataTypeFactory.cpp + DataTypeFixedString.cpp + DataTypeFunction.cpp + DataTypeInterval.cpp + DataTypeLowCardinality.cpp + DataTypeLowCardinalityHelpers.cpp + DataTypeNothing.cpp + DataTypeNullable.cpp + DataTypeNumberBase.cpp + DataTypesDecimal.cpp + DataTypesNumber.cpp + DataTypeString.cpp + DataTypeTuple.cpp + DataTypeUUID.cpp + FieldToDataType.cpp + getLeastSupertype.cpp + getMostSubtype.cpp + IDataType.cpp + NestedUtils.cpp +) + +END() diff --git a/src/Databases/DatabaseFactory.cpp b/src/Databases/DatabaseFactory.cpp index f1cea04dc29..b4a5537a192 100644 --- a/src/Databases/DatabaseFactory.cpp +++ b/src/Databases/DatabaseFactory.cpp @@ -9,15 +9,16 @@ #include #include #include -#include "config_core.h" #include "DatabaseFactory.h" #include +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + #if USE_MYSQL - -#include -#include - +# include +# include #endif diff --git a/src/Databases/DatabaseMySQL.cpp b/src/Databases/DatabaseMySQL.cpp index 1cbbd4b06d9..7528e3fa719 100644 --- a/src/Databases/DatabaseMySQL.cpp +++ b/src/Databases/DatabaseMySQL.cpp @@ -1,29 +1,30 @@ -#include "config_core.h" +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif #if USE_MYSQL +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include +# include +# include namespace DB diff --git a/src/Databases/ya.make b/src/Databases/ya.make new file mode 100644 index 00000000000..4aff1054023 --- /dev/null +++ b/src/Databases/ya.make @@ -0,0 +1,19 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common +) + +SRCS( + DatabaseDictionary.cpp + DatabaseFactory.cpp + DatabaseLazy.cpp + DatabaseMemory.cpp + DatabaseMySQL.cpp + DatabaseOnDisk.cpp + DatabaseOrdinary.cpp + DatabasesCommon.cpp + DatabaseWithDictionaries.cpp +) + +END() diff --git a/src/Dictionaries/CMakeLists.txt b/src/Dictionaries/CMakeLists.txt index c7766fbc628..0a7693edc60 100644 --- a/src/Dictionaries/CMakeLists.txt +++ b/src/Dictionaries/CMakeLists.txt @@ -1,14 +1,7 @@ include(${ClickHouse_SOURCE_DIR}/cmake/dbms_glob_sources.cmake) -include(${ClickHouse_SOURCE_DIR}/cmake/generate_code.cmake) add_headers_and_sources(clickhouse_dictionaries .) -generate_code(ComplexKeyCacheDictionary_generate1 UInt8 UInt16 UInt32 UInt64 UInt128 Int8 Int16 Int32 Int64 Float32 Float64 Decimal32 Decimal64 Decimal128) -generate_code(ComplexKeyCacheDictionary_generate2 UInt8 UInt16 UInt32 UInt64 UInt128 Int8 Int16 Int32 Int64 Float32 Float64 Decimal32 Decimal64 Decimal128) -generate_code(ComplexKeyCacheDictionary_generate3 UInt8 UInt16 UInt32 UInt64 UInt128 Int8 Int16 Int32 Int64 Float32 Float64 Decimal32 Decimal64 Decimal128) -generate_code(CacheDictionary_generate1 UInt8 UInt16 UInt32 UInt64 UInt128 Int8 Int16 Int32 Int64 Float32 Float64 Decimal32 Decimal64 Decimal128) -generate_code(CacheDictionary_generate2 UInt8 UInt16 UInt32 UInt64 UInt128 Int8 Int16 Int32 Int64 Float32 Float64 Decimal32 Decimal64 Decimal128) -generate_code(CacheDictionary_generate3 UInt8 UInt16 UInt32 UInt64 UInt128 Int8 Int16 Int32 Int64 Float32 Float64 Decimal32 Decimal64 Decimal128) add_headers_and_sources(clickhouse_dictionaries ${CMAKE_CURRENT_BINARY_DIR}/generated/) list(REMOVE_ITEM clickhouse_dictionaries_sources DictionaryFactory.cpp DictionarySourceFactory.cpp DictionaryStructure.cpp getDictionaryConfigurationFromAST.cpp) diff --git a/src/Dictionaries/CacheDictionary_generate1.cpp b/src/Dictionaries/CacheDictionary_generate1.cpp new file mode 100644 index 00000000000..edb4b89d550 --- /dev/null +++ b/src/Dictionaries/CacheDictionary_generate1.cpp @@ -0,0 +1,32 @@ +#include +#include + +namespace DB +{ +#define DEFINE(TYPE) \ + void CacheDictionary::get##TYPE(const std::string & attribute_name, const PaddedPODArray & ids, ResultArrayType & out) \ + const \ + { \ + auto & attribute = getAttribute(attribute_name); \ + checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut##TYPE); \ + const auto null_value = std::get(attribute.null_values); \ + getItemsNumberImpl(attribute, ids, out, [&](const size_t) { return null_value; }); \ + } + +DEFINE(UInt8) +DEFINE(UInt16) +DEFINE(UInt32) +DEFINE(UInt64) +DEFINE(UInt128) +DEFINE(Int8) +DEFINE(Int16) +DEFINE(Int32) +DEFINE(Int64) +DEFINE(Float32) +DEFINE(Float64) +DEFINE(Decimal32) +DEFINE(Decimal64) +DEFINE(Decimal128) + +#undef DEFINE +} diff --git a/src/Dictionaries/CacheDictionary_generate1.cpp.in b/src/Dictionaries/CacheDictionary_generate1.cpp.in deleted file mode 100644 index b870a0ed69b..00000000000 --- a/src/Dictionaries/CacheDictionary_generate1.cpp.in +++ /dev/null @@ -1,22 +0,0 @@ -#include -#include - -namespace DB -{ -namespace ErrorCodes -{ - extern const int TYPE_MISMATCH; -} - -using TYPE = @NAME@; -void CacheDictionary::get@NAME@(const std::string & attribute_name, const PaddedPODArray & ids, ResultArrayType & out) const -{ - auto & attribute = getAttribute(attribute_name); - checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut@NAME@); - - const auto null_value = std::get(attribute.null_values); - - getItemsNumberImpl(attribute, ids, out, [&](const size_t) { return null_value; }); -} - -} diff --git a/src/Dictionaries/CacheDictionary_generate2.cpp b/src/Dictionaries/CacheDictionary_generate2.cpp new file mode 100644 index 00000000000..97fa9e1a365 --- /dev/null +++ b/src/Dictionaries/CacheDictionary_generate2.cpp @@ -0,0 +1,34 @@ +#include +#include + +namespace DB +{ +#define DEFINE(TYPE) \ + void CacheDictionary::get##TYPE( \ + const std::string & attribute_name, \ + const PaddedPODArray & ids, \ + const PaddedPODArray & def, \ + ResultArrayType & out) const \ + { \ + auto & attribute = getAttribute(attribute_name); \ + checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut##TYPE); \ + getItemsNumberImpl(attribute, ids, out, [&](const size_t row) { return def[row]; }); \ + } + +DEFINE(UInt8) +DEFINE(UInt16) +DEFINE(UInt32) +DEFINE(UInt64) +DEFINE(UInt128) +DEFINE(Int8) +DEFINE(Int16) +DEFINE(Int32) +DEFINE(Int64) +DEFINE(Float32) +DEFINE(Float64) +DEFINE(Decimal32) +DEFINE(Decimal64) +DEFINE(Decimal128) + +#undef DEFINE +} diff --git a/src/Dictionaries/CacheDictionary_generate2.cpp.in b/src/Dictionaries/CacheDictionary_generate2.cpp.in deleted file mode 100644 index 367e150c2cb..00000000000 --- a/src/Dictionaries/CacheDictionary_generate2.cpp.in +++ /dev/null @@ -1,23 +0,0 @@ -#include -#include - -namespace DB -{ -namespace ErrorCodes -{ - extern const int TYPE_MISMATCH; -} - -using TYPE = @NAME@; -void CacheDictionary::get@NAME@(const std::string & attribute_name, - const PaddedPODArray & ids, - const PaddedPODArray & def, - ResultArrayType & out) const -{ - auto & attribute = getAttribute(attribute_name); - checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut@NAME@); - - getItemsNumberImpl(attribute, ids, out, [&](const size_t row) { return def[row]; }); -} - -} diff --git a/src/Dictionaries/CacheDictionary_generate3.cpp b/src/Dictionaries/CacheDictionary_generate3.cpp new file mode 100644 index 00000000000..8a94ca6bc20 --- /dev/null +++ b/src/Dictionaries/CacheDictionary_generate3.cpp @@ -0,0 +1,31 @@ +#include +#include + +namespace DB +{ +#define DEFINE(TYPE) \ + void CacheDictionary::get##TYPE( \ + const std::string & attribute_name, const PaddedPODArray & ids, const TYPE def, ResultArrayType & out) const \ + { \ + auto & attribute = getAttribute(attribute_name); \ + checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut##TYPE); \ + getItemsNumberImpl(attribute, ids, out, [&](const size_t) { return def; }); \ + } + +DEFINE(UInt8) +DEFINE(UInt16) +DEFINE(UInt32) +DEFINE(UInt64) +DEFINE(UInt128) +DEFINE(Int8) +DEFINE(Int16) +DEFINE(Int32) +DEFINE(Int64) +DEFINE(Float32) +DEFINE(Float64) +DEFINE(Decimal32) +DEFINE(Decimal64) +DEFINE(Decimal128) + +#undef DEFINE +} diff --git a/src/Dictionaries/CacheDictionary_generate3.cpp.in b/src/Dictionaries/CacheDictionary_generate3.cpp.in deleted file mode 100644 index 8e2c26302e8..00000000000 --- a/src/Dictionaries/CacheDictionary_generate3.cpp.in +++ /dev/null @@ -1,20 +0,0 @@ -#include -#include - -namespace DB -{ -namespace ErrorCodes -{ - extern const int TYPE_MISMATCH; -} - -using TYPE = @NAME@; -void CacheDictionary::get@NAME@(const std::string & attribute_name, const PaddedPODArray & ids, const TYPE def, ResultArrayType & out) const -{ - auto & attribute = getAttribute(attribute_name); - checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut@NAME@); - - getItemsNumberImpl(attribute, ids, out, [&](const size_t) { return def; }); -} - -} diff --git a/src/Dictionaries/ComplexKeyCacheDictionary_generate1.cpp b/src/Dictionaries/ComplexKeyCacheDictionary_generate1.cpp new file mode 100644 index 00000000000..6f9761cd064 --- /dev/null +++ b/src/Dictionaries/ComplexKeyCacheDictionary_generate1.cpp @@ -0,0 +1,32 @@ +#include + +namespace DB +{ +#define DEFINE(TYPE) \ + void ComplexKeyCacheDictionary::get##TYPE( \ + const std::string & attribute_name, const Columns & key_columns, const DataTypes & key_types, ResultArrayType & out) const \ + { \ + dict_struct.validateKeyTypes(key_types); \ + auto & attribute = getAttribute(attribute_name); \ + checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut##TYPE); \ + const auto null_value = std::get(attribute.null_values); \ + getItemsNumberImpl(attribute, key_columns, out, [&](const size_t) { return null_value; }); \ + } + +DEFINE(UInt8) +DEFINE(UInt16) +DEFINE(UInt32) +DEFINE(UInt64) +DEFINE(UInt128) +DEFINE(Int8) +DEFINE(Int16) +DEFINE(Int32) +DEFINE(Int64) +DEFINE(Float32) +DEFINE(Float64) +DEFINE(Decimal32) +DEFINE(Decimal64) +DEFINE(Decimal128) + +#undef DEFINE +} diff --git a/src/Dictionaries/ComplexKeyCacheDictionary_generate1.cpp.in b/src/Dictionaries/ComplexKeyCacheDictionary_generate1.cpp.in deleted file mode 100644 index 5c0ed408a55..00000000000 --- a/src/Dictionaries/ComplexKeyCacheDictionary_generate1.cpp.in +++ /dev/null @@ -1,22 +0,0 @@ -#include - -namespace DB -{ -namespace ErrorCodes -{ - extern const int TYPE_MISMATCH; -} - -using TYPE = @NAME@; -void ComplexKeyCacheDictionary::get@NAME@(const std::string & attribute_name, const Columns & key_columns, const DataTypes & key_types, ResultArrayType & out) const -{ - dict_struct.validateKeyTypes(key_types); - - auto & attribute = getAttribute(attribute_name); - checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut@NAME@); - - const auto null_value = std::get(attribute.null_values); - - getItemsNumberImpl(attribute, key_columns, out, [&](const size_t) { return null_value; }); -} -} diff --git a/src/Dictionaries/ComplexKeyCacheDictionary_generate2.cpp b/src/Dictionaries/ComplexKeyCacheDictionary_generate2.cpp new file mode 100644 index 00000000000..297da2c91a0 --- /dev/null +++ b/src/Dictionaries/ComplexKeyCacheDictionary_generate2.cpp @@ -0,0 +1,35 @@ +#include + +namespace DB +{ +#define DEFINE(TYPE) \ + void ComplexKeyCacheDictionary::get##TYPE( \ + const std::string & attribute_name, \ + const Columns & key_columns, \ + const DataTypes & key_types, \ + const PaddedPODArray & def, \ + ResultArrayType & out) const \ + { \ + dict_struct.validateKeyTypes(key_types); \ + auto & attribute = getAttribute(attribute_name); \ + checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut##TYPE); \ + getItemsNumberImpl(attribute, key_columns, out, [&](const size_t row) { return def[row]; }); \ + } + +DEFINE(UInt8) +DEFINE(UInt16) +DEFINE(UInt32) +DEFINE(UInt64) +DEFINE(UInt128) +DEFINE(Int8) +DEFINE(Int16) +DEFINE(Int32) +DEFINE(Int64) +DEFINE(Float32) +DEFINE(Float64) +DEFINE(Decimal32) +DEFINE(Decimal64) +DEFINE(Decimal128) + +#undef DEFINE +} diff --git a/src/Dictionaries/ComplexKeyCacheDictionary_generate2.cpp.in b/src/Dictionaries/ComplexKeyCacheDictionary_generate2.cpp.in deleted file mode 100644 index b3233cd05e1..00000000000 --- a/src/Dictionaries/ComplexKeyCacheDictionary_generate2.cpp.in +++ /dev/null @@ -1,25 +0,0 @@ -#include - -namespace DB -{ -namespace ErrorCodes -{ - extern const int TYPE_MISMATCH; -} - -using TYPE = @NAME@; - -void ComplexKeyCacheDictionary::get@NAME@(const std::string & attribute_name, - const Columns & key_columns, - const DataTypes & key_types, - const PaddedPODArray & def, - ResultArrayType & out) const -{ - dict_struct.validateKeyTypes(key_types); - - auto & attribute = getAttribute(attribute_name); - checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut@NAME@); - - getItemsNumberImpl(attribute, key_columns, out, [&](const size_t row) { return def[row]; }); -} -} diff --git a/src/Dictionaries/ComplexKeyCacheDictionary_generate3.cpp b/src/Dictionaries/ComplexKeyCacheDictionary_generate3.cpp new file mode 100644 index 00000000000..222e9c8ee77 --- /dev/null +++ b/src/Dictionaries/ComplexKeyCacheDictionary_generate3.cpp @@ -0,0 +1,35 @@ +#include + +namespace DB +{ +#define DEFINE(TYPE) \ + void ComplexKeyCacheDictionary::get##TYPE( \ + const std::string & attribute_name, \ + const Columns & key_columns, \ + const DataTypes & key_types, \ + const TYPE def, \ + ResultArrayType & out) const \ + { \ + dict_struct.validateKeyTypes(key_types); \ + auto & attribute = getAttribute(attribute_name); \ + checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut##TYPE); \ + getItemsNumberImpl(attribute, key_columns, out, [&](const size_t) { return def; }); \ + } + +DEFINE(UInt8) +DEFINE(UInt16) +DEFINE(UInt32) +DEFINE(UInt64) +DEFINE(UInt128) +DEFINE(Int8) +DEFINE(Int16) +DEFINE(Int32) +DEFINE(Int64) +DEFINE(Float32) +DEFINE(Float64) +DEFINE(Decimal32) +DEFINE(Decimal64) +DEFINE(Decimal128) + +#undef DEFINE +} diff --git a/src/Dictionaries/ComplexKeyCacheDictionary_generate3.cpp.in b/src/Dictionaries/ComplexKeyCacheDictionary_generate3.cpp.in deleted file mode 100644 index 02e77c01a4a..00000000000 --- a/src/Dictionaries/ComplexKeyCacheDictionary_generate3.cpp.in +++ /dev/null @@ -1,25 +0,0 @@ -#include - -namespace DB -{ -namespace ErrorCodes -{ - extern const int TYPE_MISMATCH; -} - -using TYPE = @NAME@; - -void ComplexKeyCacheDictionary::get@NAME@(const std::string & attribute_name, - const Columns & key_columns, - const DataTypes & key_types, - const TYPE def, - ResultArrayType & out) const -{ - dict_struct.validateKeyTypes(key_types); - - auto & attribute = getAttribute(attribute_name); - checkAttributeType(name, attribute_name, attribute.type, AttributeUnderlyingType::ut@NAME@); - - getItemsNumberImpl(attribute, key_columns, out, [&](const size_t) { return def; }); -} -} diff --git a/src/Dictionaries/HashedDictionary.h b/src/Dictionaries/HashedDictionary.h index 3f8eec979bb..a361352a8bd 100644 --- a/src/Dictionaries/HashedDictionary.h +++ b/src/Dictionaries/HashedDictionary.h @@ -156,8 +156,14 @@ private: template using CollectionPtrType = std::unique_ptr>; +#if !defined(ARCADIA_BUILD) template using SparseCollectionType = google::sparse_hash_map>; +#else + template + using SparseCollectionType = google::sparsehash::sparse_hash_map>; +#endif + template using SparseCollectionPtrType = std::unique_ptr>; diff --git a/src/Dictionaries/MongoDBBlockInputStream.cpp b/src/Dictionaries/MongoDBBlockInputStream.cpp index b1c2f67cc86..e0ff7cb6529 100644 --- a/src/Dictionaries/MongoDBBlockInputStream.cpp +++ b/src/Dictionaries/MongoDBBlockInputStream.cpp @@ -1,25 +1,27 @@ -#include "config_core.h" +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + #if USE_POCO_MONGODB +# include +# include +# include -#include -#include -#include +# include +# include +# include +# include -#include -#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include "DictionaryStructure.h" -#include "MongoDBBlockInputStream.h" +# include +# include +# include +# include +# include +# include +# include +# include +# include "DictionaryStructure.h" +# include "MongoDBBlockInputStream.h" namespace DB diff --git a/src/Dictionaries/MongoDBDictionarySource.h b/src/Dictionaries/MongoDBDictionarySource.h index bf4669248dc..622d61c5b09 100644 --- a/src/Dictionaries/MongoDBDictionarySource.h +++ b/src/Dictionaries/MongoDBDictionarySource.h @@ -1,9 +1,12 @@ #pragma once #include -#include "config_core.h" -#if USE_POCO_MONGODB +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + +#if USE_POCO_MONGODB # include "DictionaryStructure.h" # include "IDictionarySource.h" @@ -91,4 +94,5 @@ private: }; } + #endif diff --git a/src/Dictionaries/MySQLDictionarySource.cpp b/src/Dictionaries/MySQLDictionarySource.cpp index 00527064d79..4ba16ca19de 100644 --- a/src/Dictionaries/MySQLDictionarySource.cpp +++ b/src/Dictionaries/MySQLDictionarySource.cpp @@ -1,8 +1,8 @@ #include "MySQLDictionarySource.h" + #include #include "DictionarySourceFactory.h" #include "DictionaryStructure.h" -#include "config_core.h" #include "registerDictionaries.h" namespace DB diff --git a/src/Dictionaries/MySQLDictionarySource.h b/src/Dictionaries/MySQLDictionarySource.h index 95e660d220f..34f784cdfeb 100644 --- a/src/Dictionaries/MySQLDictionarySource.h +++ b/src/Dictionaries/MySQLDictionarySource.h @@ -2,9 +2,11 @@ #include -#include "config_core.h" -#if USE_MYSQL +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif +#if USE_MYSQL # include # include # include "DictionaryStructure.h" diff --git a/src/Dictionaries/RedisBlockInputStream.h b/src/Dictionaries/RedisBlockInputStream.h index 86448095787..6e350e7c4f1 100644 --- a/src/Dictionaries/RedisBlockInputStream.h +++ b/src/Dictionaries/RedisBlockInputStream.h @@ -1,8 +1,11 @@ #pragma once -#include "config_core.h" #include +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + #if USE_POCO_REDIS # include # include diff --git a/src/Dictionaries/RedisDictionarySource.h b/src/Dictionaries/RedisDictionarySource.h index dc62d7dc625..e42bd2678cb 100644 --- a/src/Dictionaries/RedisDictionarySource.h +++ b/src/Dictionaries/RedisDictionarySource.h @@ -1,10 +1,12 @@ #pragma once -#include "config_core.h" #include -#if USE_POCO_REDIS +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif +#if USE_POCO_REDIS # include "DictionaryStructure.h" # include "IDictionarySource.h" @@ -101,4 +103,5 @@ namespace ErrorCodes }; } + #endif diff --git a/src/Dictionaries/XDBCDictionarySource.cpp b/src/Dictionaries/XDBCDictionarySource.cpp index 8647c8ccac5..3fea0a024ef 100644 --- a/src/Dictionaries/XDBCDictionarySource.cpp +++ b/src/Dictionaries/XDBCDictionarySource.cpp @@ -16,9 +16,12 @@ #include "DictionaryStructure.h" #include "readInvalidateQuery.h" -#include #include "registerDictionaries.h" +#if !defined(ARCADIA_BUILD) +# include +#endif + #if USE_POCO_SQLODBC || USE_POCO_DATAODBC # include #endif diff --git a/src/Dictionaries/registerDictionaries.cpp b/src/Dictionaries/registerDictionaries.cpp index 60218d457b4..cbd2d6010cb 100644 --- a/src/Dictionaries/registerDictionaries.cpp +++ b/src/Dictionaries/registerDictionaries.cpp @@ -25,7 +25,9 @@ void registerDictionaries() registerDictionaryRangeHashed(factory); registerDictionaryComplexKeyHashed(factory); registerDictionaryComplexKeyCache(factory); +#if !defined(ARCADIA_BUILD) registerDictionaryTrie(factory); +#endif registerDictionaryFlat(factory); registerDictionaryHashed(factory); registerDictionaryCache(factory); diff --git a/src/Dictionaries/ya.make b/src/Dictionaries/ya.make new file mode 100644 index 00000000000..3f831c3c9fe --- /dev/null +++ b/src/Dictionaries/ya.make @@ -0,0 +1,63 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common + contrib/libs/poco/Data + contrib/libs/poco/Data/ODBC + contrib/libs/poco/MongoDB + contrib/libs/poco/Redis + contrib/libs/sparsehash +) + +NO_COMPILER_WARNINGS() + +SRCS( + CacheDictionary_generate1.cpp + CacheDictionary_generate2.cpp + CacheDictionary_generate3.cpp + CacheDictionary.cpp + ClickHouseDictionarySource.cpp + ComplexKeyCacheDictionary_createAttributeWithType.cpp + ComplexKeyCacheDictionary_generate1.cpp + ComplexKeyCacheDictionary_generate2.cpp + ComplexKeyCacheDictionary_generate3.cpp + ComplexKeyCacheDictionary_setAttributeValue.cpp + ComplexKeyCacheDictionary_setDefaultAttributeValue.cpp + ComplexKeyCacheDictionary.cpp + ComplexKeyHashedDictionary.cpp + DictionaryBlockInputStreamBase.cpp + DictionaryFactory.cpp + DictionarySourceFactory.cpp + DictionarySourceHelpers.cpp + DictionaryStructure.cpp + Embedded/GeodataProviders/HierarchiesProvider.cpp + Embedded/GeodataProviders/HierarchyFormatReader.cpp + Embedded/GeodataProviders/NamesFormatReader.cpp + Embedded/GeodataProviders/NamesProvider.cpp + Embedded/GeoDictionariesLoader.cpp + Embedded/RegionsHierarchies.cpp + Embedded/RegionsHierarchy.cpp + Embedded/RegionsNames.cpp + ExecutableDictionarySource.cpp + ExternalQueryBuilder.cpp + FileDictionarySource.cpp + FlatDictionary.cpp + getDictionaryConfigurationFromAST.cpp + HashedDictionary.cpp + HTTPDictionarySource.cpp + LibraryDictionarySource.cpp + LibraryDictionarySourceExternal.cpp + MongoDBBlockInputStream.cpp + MongoDBDictionarySource.cpp + MySQLDictionarySource.cpp + PolygonDictionary.cpp + RangeHashedDictionary.cpp + readInvalidateQuery.cpp + RedisBlockInputStream.cpp + RedisDictionarySource.cpp + registerDictionaries.cpp + writeParenthesisedString.cpp + XDBCDictionarySource.cpp +) + +END() diff --git a/src/Disks/DiskS3.h b/src/Disks/DiskS3.h index 1b61ed1cde3..c89fde4b103 100644 --- a/src/Disks/DiskS3.h +++ b/src/Disks/DiskS3.h @@ -1,6 +1,8 @@ #pragma once -#include +#if !defined(ARCADIA_BUILD) +# include +#endif #if USE_AWS_S3 # include "DiskFactory.h" diff --git a/src/Disks/registerDisks.cpp b/src/Disks/registerDisks.cpp index f28918cdbd0..2da39e62b19 100644 --- a/src/Disks/registerDisks.cpp +++ b/src/Disks/registerDisks.cpp @@ -2,7 +2,9 @@ #include "DiskFactory.h" -#include +#if !defined(ARCADIA_BUILD) +# include +#endif namespace DB { diff --git a/src/Disks/ya.make b/src/Disks/ya.make new file mode 100644 index 00000000000..71eb47c489c --- /dev/null +++ b/src/Disks/ya.make @@ -0,0 +1,17 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common +) + +SRCS( + DiskFactory.cpp + DiskLocal.cpp + DiskMemory.cpp + DiskS3.cpp + DiskSpaceMonitor.cpp + IDisk.cpp + registerDisks.cpp +) + +END() diff --git a/src/Formats/FormatFactory.cpp b/src/Formats/FormatFactory.cpp index 7d741004766..d48b2dde206 100644 --- a/src/Formats/FormatFactory.cpp +++ b/src/Formats/FormatFactory.cpp @@ -1,12 +1,12 @@ +#include + #include -#include #include #include #include #include #include #include -#include #include #include #include @@ -16,6 +16,10 @@ #include #include +#if !defined(ARCADIA_BUILD) +# include +#endif + namespace DB { @@ -347,12 +351,14 @@ FormatFactory::FormatFactory() registerOutputFormatProcessorJSONCompactEachRow(*this); registerInputFormatProcessorProtobuf(*this); registerOutputFormatProcessorProtobuf(*this); +#if !defined(ARCADIA_BUILD) registerInputFormatProcessorCapnProto(*this); registerInputFormatProcessorORC(*this); registerInputFormatProcessorParquet(*this); registerOutputFormatProcessorParquet(*this); registerInputFormatProcessorAvro(*this); registerOutputFormatProcessorAvro(*this); +#endif registerInputFormatProcessorTemplate(*this); registerOutputFormatProcessorTemplate(*this); registerInputFormatProcessorRegexp(*this); diff --git a/src/Formats/MySQLBlockInputStream.cpp b/src/Formats/MySQLBlockInputStream.cpp index 4f8291ffebe..17c09cdc14d 100644 --- a/src/Formats/MySQLBlockInputStream.cpp +++ b/src/Formats/MySQLBlockInputStream.cpp @@ -1,15 +1,17 @@ -#include "config_core.h" -#if USE_MYSQL +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif -#include -#include -#include -#include -#include -#include -#include -#include -#include "MySQLBlockInputStream.h" +#if USE_MYSQL +# include +# include +# include +# include +# include +# include +# include +# include +# include "MySQLBlockInputStream.h" namespace DB diff --git a/src/Formats/ProtobufColumnMatcher.h b/src/Formats/ProtobufColumnMatcher.h index ed6c632f8e8..03c5ec40fc6 100644 --- a/src/Formats/ProtobufColumnMatcher.h +++ b/src/Formats/ProtobufColumnMatcher.h @@ -1,15 +1,17 @@ #pragma once -#include "config_formats.h" -#if USE_PROTOBUF +#if !defined(ARCADIA_BUILD) +# include "config_formats.h" +#endif -#include -#include -#include -#include -#include -#include -#include +#if USE_PROTOBUF +# include +# include +# include +# include +# include +# include +# include namespace google { @@ -190,4 +192,5 @@ namespace ProtobufColumnMatcher } } + #endif diff --git a/src/Formats/ProtobufReader.cpp b/src/Formats/ProtobufReader.cpp index 5426e8fac62..249bcf12711 100644 --- a/src/Formats/ProtobufReader.cpp +++ b/src/Formats/ProtobufReader.cpp @@ -1,16 +1,14 @@ -#include "config_formats.h" -#if USE_PROTOBUF - #include "ProtobufReader.h" -#include -#include -#include -#include -#include -#include -#include -#include +#if USE_PROTOBUF +# include +# include +# include +# include +# include +# include +# include +# include namespace DB @@ -272,25 +270,25 @@ UInt64 ProtobufReader::SimpleReader::continueReadingVarint(UInt64 first_byte) UInt64 result = (first_byte & ~static_cast(0x80)); char c; -#define PROTOBUF_READER_READ_VARINT_BYTE(byteNo) \ - do \ - { \ - in.readStrict(c); \ - ++cursor; \ - if constexpr ((byteNo) < 10) \ +# define PROTOBUF_READER_READ_VARINT_BYTE(byteNo) \ + do \ { \ - result |= static_cast(static_cast(c)) << (7 * ((byteNo) - 1)); \ - if (likely(!(c & 0x80))) \ - return result; \ - } \ - else \ - { \ - if (likely(c == 1)) \ - return result; \ - } \ - if constexpr ((byteNo) < 9) \ - result &= ~(static_cast(0x80) << (7 * ((byteNo) - 1))); \ - } while (false) + in.readStrict(c); \ + ++cursor; \ + if constexpr ((byteNo) < 10) \ + { \ + result |= static_cast(static_cast(c)) << (7 * ((byteNo)-1)); \ + if (likely(!(c & 0x80))) \ + return result; \ + } \ + else \ + { \ + if (likely(c == 1)) \ + return result; \ + } \ + if constexpr ((byteNo) < 9) \ + result &= ~(static_cast(0x80) << (7 * ((byteNo)-1))); \ + } while (false) PROTOBUF_READER_READ_VARINT_BYTE(2); PROTOBUF_READER_READ_VARINT_BYTE(3); @@ -302,7 +300,7 @@ UInt64 ProtobufReader::SimpleReader::continueReadingVarint(UInt64 first_byte) PROTOBUF_READER_READ_VARINT_BYTE(9); PROTOBUF_READER_READ_VARINT_BYTE(10); -#undef PROTOBUF_READER_READ_VARINT_BYTE +# undef PROTOBUF_READER_READ_VARINT_BYTE throwUnknownFormat(); } @@ -311,22 +309,22 @@ void ProtobufReader::SimpleReader::ignoreVarint() { char c; -#define PROTOBUF_READER_IGNORE_VARINT_BYTE(byteNo) \ - do \ - { \ - in.readStrict(c); \ - ++cursor; \ - if constexpr ((byteNo) < 10) \ +# define PROTOBUF_READER_IGNORE_VARINT_BYTE(byteNo) \ + do \ { \ - if (likely(!(c & 0x80))) \ - return; \ - } \ - else \ - { \ - if (likely(c == 1)) \ - return; \ - } \ - } while (false) + in.readStrict(c); \ + ++cursor; \ + if constexpr ((byteNo) < 10) \ + { \ + if (likely(!(c & 0x80))) \ + return; \ + } \ + else \ + { \ + if (likely(c == 1)) \ + return; \ + } \ + } while (false) PROTOBUF_READER_IGNORE_VARINT_BYTE(1); PROTOBUF_READER_IGNORE_VARINT_BYTE(2); @@ -338,7 +336,8 @@ void ProtobufReader::SimpleReader::ignoreVarint() PROTOBUF_READER_IGNORE_VARINT_BYTE(8); PROTOBUF_READER_IGNORE_VARINT_BYTE(9); PROTOBUF_READER_IGNORE_VARINT_BYTE(10); -#undef PROTOBUF_READER_IGNORE_VARINT_BYTE + +# undef PROTOBUF_READER_IGNORE_VARINT_BYTE throwUnknownFormat(); } @@ -694,16 +693,17 @@ private: std::optional> enum_name_to_value_map; }; -#define PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS(field_type_id) \ - template <> \ - std::unique_ptr ProtobufReader::createConverter( \ - const google::protobuf::FieldDescriptor * field) \ - { \ - return std::make_unique(simple_reader, field); \ - } +# define PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS(field_type_id) \ + template <> \ + std::unique_ptr ProtobufReader::createConverter( \ + const google::protobuf::FieldDescriptor * field) \ + { \ + return std::make_unique(simple_reader, field); \ + } PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS(google::protobuf::FieldDescriptor::TYPE_STRING) PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS(google::protobuf::FieldDescriptor::TYPE_BYTES) -#undef PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS + +# undef PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS template @@ -850,13 +850,14 @@ private: std::optional> set_of_enum_values; }; -#define PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(field_type_id, field_type) \ - template <> \ - std::unique_ptr ProtobufReader::createConverter( \ - const google::protobuf::FieldDescriptor * field) \ - { \ - return std::make_unique>(simple_reader, field); /* NOLINT */ \ - } +# define PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(field_type_id, field_type) \ + template <> \ + std::unique_ptr ProtobufReader::createConverter( \ + const google::protobuf::FieldDescriptor * field) \ + { \ + return std::make_unique>(simple_reader, field); /* NOLINT */ \ + } + PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_INT32, Int64); PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_SINT32, Int64); PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_UINT32, UInt64); @@ -869,7 +870,8 @@ PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::Fi PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_SFIXED64, Int64); PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_FLOAT, float); PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_DOUBLE, double); -#undef PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS + +# undef PROTOBUF_READER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS class ProtobufReader::ConverterFromBool : public ConverterBaseImpl @@ -1073,10 +1075,10 @@ void ProtobufReader::setTraitsDataAfterMatchingColumns(Message * message) } switch (field.field_descriptor->type()) { -#define PROTOBUF_READER_CONVERTER_CREATING_CASE(field_type_id) \ - case field_type_id: \ - field.data.converter = createConverter(field.field_descriptor); \ - break +# define PROTOBUF_READER_CONVERTER_CREATING_CASE(field_type_id) \ + case field_type_id: \ + field.data.converter = createConverter(field.field_descriptor); \ + break PROTOBUF_READER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_STRING); PROTOBUF_READER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_BYTES); PROTOBUF_READER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_INT32); @@ -1093,8 +1095,9 @@ void ProtobufReader::setTraitsDataAfterMatchingColumns(Message * message) PROTOBUF_READER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_DOUBLE); PROTOBUF_READER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_BOOL); PROTOBUF_READER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_ENUM); -#undef PROTOBUF_READER_CONVERTER_CREATING_CASE - default: __builtin_unreachable(); +# undef PROTOBUF_READER_CONVERTER_CREATING_CASE + default: + __builtin_unreachable(); } message->data.field_number_to_field_map.emplace(field.field_number, &field); } @@ -1171,4 +1174,5 @@ bool ProtobufReader::readColumnIndex(size_t & column_index) } } + #endif diff --git a/src/Formats/ProtobufReader.h b/src/Formats/ProtobufReader.h index 393b15eb343..a50c2f202f0 100644 --- a/src/Formats/ProtobufReader.h +++ b/src/Formats/ProtobufReader.h @@ -5,13 +5,15 @@ #include #include -#include "config_formats.h" -#if USE_PROTOBUF +#if !defined(ARCADIA_BUILD) +# include "config_formats.h" +#endif -#include -#include "ProtobufColumnMatcher.h" -#include -#include +#if USE_PROTOBUF +# include +# include +# include +# include "ProtobufColumnMatcher.h" namespace google { diff --git a/src/Formats/ProtobufSchemas.cpp b/src/Formats/ProtobufSchemas.cpp index f4973263bc8..9c6ed76ef27 100644 --- a/src/Formats/ProtobufSchemas.cpp +++ b/src/Formats/ProtobufSchemas.cpp @@ -1,10 +1,12 @@ -#include "config_formats.h" -#if USE_PROTOBUF +#if !defined(ARCADIA_BUILD) +# include "config_formats.h" +#endif -#include -#include -#include -#include +#if USE_PROTOBUF +# include +# include +# include +# include namespace DB diff --git a/src/Formats/ProtobufWriter.cpp b/src/Formats/ProtobufWriter.cpp index 8ee309d41c9..d68999c7ce4 100644 --- a/src/Formats/ProtobufWriter.cpp +++ b/src/Formats/ProtobufWriter.cpp @@ -1,18 +1,16 @@ -#include "config_formats.h" -#if USE_PROTOBUF - #include "ProtobufWriter.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#if USE_PROTOBUF +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include namespace DB @@ -496,19 +494,19 @@ private: std::optional> enum_value_to_name_map; }; -#define PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS(field_type_id) \ - template <> \ - std::unique_ptr ProtobufWriter::createConverter( \ - const google::protobuf::FieldDescriptor * field) \ - { \ - if (shouldSkipNullValue(field)) \ - return std::make_unique>(simple_writer, field); \ - else \ - return std::make_unique>(simple_writer, field); \ - } +# define PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS(field_type_id) \ + template <> \ + std::unique_ptr ProtobufWriter::createConverter( \ + const google::protobuf::FieldDescriptor * field) \ + { \ + if (shouldSkipNullValue(field)) \ + return std::make_unique>(simple_writer, field); \ + else \ + return std::make_unique>(simple_writer, field); \ + } PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS(google::protobuf::FieldDescriptor::TYPE_STRING) PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS(google::protobuf::FieldDescriptor::TYPE_BYTES) -#undef PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS +# undef PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_STRINGS template @@ -606,18 +604,19 @@ private: } }; -#define PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(field_type_id, field_type) \ - template <> \ - std::unique_ptr ProtobufWriter::createConverter( \ - const google::protobuf::FieldDescriptor * field) \ - { \ - if (shouldSkipNullValue(field)) \ - return std::make_unique>(simple_writer, field); \ - else if (shouldPackRepeated(field)) \ - return std::make_unique>(simple_writer, field); \ - else \ - return std::make_unique>(simple_writer, field); \ - } +# define PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(field_type_id, field_type) \ + template <> \ + std::unique_ptr ProtobufWriter::createConverter( \ + const google::protobuf::FieldDescriptor * field) \ + { \ + if (shouldSkipNullValue(field)) \ + return std::make_unique>(simple_writer, field); \ + else if (shouldPackRepeated(field)) \ + return std::make_unique>(simple_writer, field); \ + else \ + return std::make_unique>(simple_writer, field); \ + } + PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_INT32, Int32); PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_SINT32, Int32); PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_UINT32, UInt32); @@ -630,7 +629,7 @@ PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::Fi PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_SFIXED64, Int64); PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_FLOAT, float); PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS(google::protobuf::FieldDescriptor::TYPE_DOUBLE, double); -#undef PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS +# undef PROTOBUF_WRITER_CREATE_CONVERTER_SPECIALIZATION_FOR_NUMBERS template @@ -871,10 +870,10 @@ void ProtobufWriter::setTraitsDataAfterMatchingColumns(Message * message) } switch (field.field_descriptor->type()) { -#define PROTOBUF_WRITER_CONVERTER_CREATING_CASE(field_type_id) \ - case field_type_id: \ - field.data.converter = createConverter(field.field_descriptor); \ - break +# define PROTOBUF_WRITER_CONVERTER_CREATING_CASE(field_type_id) \ + case field_type_id: \ + field.data.converter = createConverter(field.field_descriptor); \ + break PROTOBUF_WRITER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_STRING); PROTOBUF_WRITER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_BYTES); PROTOBUF_WRITER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_INT32); @@ -891,7 +890,7 @@ void ProtobufWriter::setTraitsDataAfterMatchingColumns(Message * message) PROTOBUF_WRITER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_DOUBLE); PROTOBUF_WRITER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_BOOL); PROTOBUF_WRITER_CONVERTER_CREATING_CASE(google::protobuf::FieldDescriptor::TYPE_ENUM); -#undef PROTOBUF_WRITER_CONVERTER_CREATING_CASE +# undef PROTOBUF_WRITER_CONVERTER_CREATING_CASE default: throw Exception( String("Protobuf type '") + field.field_descriptor->type_name() + "' isn't supported", ErrorCodes::NOT_IMPLEMENTED); @@ -991,4 +990,5 @@ void ProtobufWriter::setNestedMessageNeedsRepeat() } } + #endif diff --git a/src/Formats/ProtobufWriter.h b/src/Formats/ProtobufWriter.h index 3862ed88cdb..1778f2adb21 100644 --- a/src/Formats/ProtobufWriter.h +++ b/src/Formats/ProtobufWriter.h @@ -3,17 +3,17 @@ #include #include #include - -#include "config_formats.h" - #include -#if USE_PROTOBUF +#if !defined(ARCADIA_BUILD) +# include "config_formats.h" +#endif -#include "ProtobufColumnMatcher.h" -#include -#include -#include +#if USE_PROTOBUF +# include +# include +# include +# include "ProtobufColumnMatcher.h" namespace google @@ -233,6 +233,8 @@ private: } #else +# include + namespace DB { diff --git a/src/Formats/ya.make b/src/Formats/ya.make new file mode 100644 index 00000000000..de61820e58d --- /dev/null +++ b/src/Formats/ya.make @@ -0,0 +1,24 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common + contrib/libs/protobuf_std +) + +SRCS( + FormatFactory.cpp + FormatSchemaInfo.cpp + IRowInputStream.cpp + IRowOutputStream.cpp + MySQLBlockInputStream.cpp + NativeFormat.cpp + NullFormat.cpp + ParsedTemplateFormatString.cpp + ProtobufColumnMatcher.cpp + ProtobufReader.cpp + ProtobufSchemas.cpp + ProtobufWriter.cpp + verbosePrintString.cpp +) + +END() diff --git a/src/Functions/DivisionUtils.h b/src/Functions/DivisionUtils.h index df3b86f721d..5a0c1b8232a 100644 --- a/src/Functions/DivisionUtils.h +++ b/src/Functions/DivisionUtils.h @@ -2,9 +2,11 @@ #include #include -#include #include +#if !defined(ARCADIA_BUILD) +# include +#endif namespace DB { diff --git a/src/Functions/FunctionBase64Conversion.h b/src/Functions/FunctionBase64Conversion.h index 27a873f69fa..5b100bf68ce 100644 --- a/src/Functions/FunctionBase64Conversion.h +++ b/src/Functions/FunctionBase64Conversion.h @@ -1,13 +1,16 @@ -#include "config_functions.h" +#if !defined(ARCADIA_BUILD) +# include "config_functions.h" +#endif + #if USE_BASE64 -#include -#include -#include -#include -#include -#include -#include -#include +# include +# include +# include +# include +# include +# include +# include +# include namespace DB diff --git a/src/Functions/FunctionBinaryArithmetic.h b/src/Functions/FunctionBinaryArithmetic.h index 2ad52d69f09..30b6da8b696 100644 --- a/src/Functions/FunctionBinaryArithmetic.h +++ b/src/Functions/FunctionBinaryArithmetic.h @@ -27,13 +27,16 @@ #include "FunctionFactory.h" #include #include -#include + +#if !defined(ARCADIA_BUILD) +# include +#endif #if USE_EMBEDDED_COMPILER -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" -#include -#pragma GCC diagnostic pop +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-parameter" +# include +# pragma GCC diagnostic pop #endif diff --git a/src/Functions/FunctionIfBase.h b/src/Functions/FunctionIfBase.h index 48aa1c0b6b2..bdb883ee342 100644 --- a/src/Functions/FunctionIfBase.h +++ b/src/Functions/FunctionIfBase.h @@ -1,9 +1,11 @@ #pragma once -#include #include #include +#if !defined(ARCADIA_BUILD) +# include +#endif namespace DB { diff --git a/src/Functions/FunctionMathBinaryFloat64.h b/src/Functions/FunctionMathBinaryFloat64.h index 2927d4ef228..f696e4728fb 100644 --- a/src/Functions/FunctionMathBinaryFloat64.h +++ b/src/Functions/FunctionMathBinaryFloat64.h @@ -8,7 +8,10 @@ #include #include #include -#include "config_functions.h" + +#if !defined(ARCADIA_BUILD) +# include "config_functions.h" +#endif /** More efficient implementations of mathematical functions are possible when using a separate library. * Disabled due to license compatibility limitations. diff --git a/src/Functions/FunctionMathUnary.h b/src/Functions/FunctionMathUnary.h index 716b52b40c5..b048b994951 100644 --- a/src/Functions/FunctionMathUnary.h +++ b/src/Functions/FunctionMathUnary.h @@ -7,7 +7,10 @@ #include #include #include -#include "config_functions.h" + +#if !defined(ARCADIA_BUILD) +# include "config_functions.h" +#endif /** More efficient implementations of mathematical functions are possible when using a separate library. * Disabled due to license compatibility limitations. @@ -20,7 +23,7 @@ * Enabled by default. */ #if USE_FASTOPS -#include +# include #endif diff --git a/src/Functions/FunctionUnaryArithmetic.h b/src/Functions/FunctionUnaryArithmetic.h index 89687b5b23e..4e3ccdc8952 100644 --- a/src/Functions/FunctionUnaryArithmetic.h +++ b/src/Functions/FunctionUnaryArithmetic.h @@ -10,13 +10,16 @@ #include #include #include -#include + +#if !defined(ARCADIA_BUILD) +# include +#endif #if USE_EMBEDDED_COMPILER -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" -#include -#pragma GCC diagnostic pop +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-parameter" +# include +# pragma GCC diagnostic pop #endif diff --git a/src/Functions/FunctionsEmbeddedDictionaries.h b/src/Functions/FunctionsEmbeddedDictionaries.h index 12b478a26b6..44fdca9736d 100644 --- a/src/Functions/FunctionsEmbeddedDictionaries.h +++ b/src/Functions/FunctionsEmbeddedDictionaries.h @@ -15,9 +15,12 @@ #include #include #include -#include #include +#if !defined(ARCADIA_BUILD) +# include +#endif + namespace DB { diff --git a/src/Functions/FunctionsExternalDictionaries.h b/src/Functions/FunctionsExternalDictionaries.h index fc3c2c583a9..61ba555be92 100644 --- a/src/Functions/FunctionsExternalDictionaries.h +++ b/src/Functions/FunctionsExternalDictionaries.h @@ -135,7 +135,9 @@ private: !executeDispatchSimple(block, arguments, result, dict_ptr) && !executeDispatchComplex(block, arguments, result, dict_ptr) && !executeDispatchComplex(block, arguments, result, dict_ptr) && +#if !defined(ARCADIA_BUILD) !executeDispatchComplex(block, arguments, result, dict_ptr) && +#endif !executeDispatchComplex(block, arguments, result, dict_ptr)) throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE}; } @@ -306,7 +308,9 @@ private: !executeDispatch(block, arguments, result, dict_ptr) && !executeDispatchComplex(block, arguments, result, dict_ptr) && !executeDispatchComplex(block, arguments, result, dict_ptr) && +#if !defined(ARCADIA_BUILD) !executeDispatchComplex(block, arguments, result, dict_ptr) && +#endif !executeDispatchComplex(block, arguments, result, dict_ptr) && !executeDispatchRange(block, arguments, result, dict_ptr)) throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE}; @@ -488,8 +492,10 @@ private: !executeDispatch(block, arguments, result, dict_ptr) && !executeDispatchComplex(block, arguments, result, dict_ptr) && !executeDispatchComplex(block, arguments, result, dict_ptr) && - !executeDispatchComplex(block, arguments, result, dict_ptr) && - !executeDispatchComplex(block, arguments, result, dict_ptr)) +#if !defined(ARCADIA_BUILD) + !executeDispatchComplex(block, arguments, result, dict_ptr) && +#endif + !executeDispatchComplex(block, arguments, result, dict_ptr)) throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE}; } @@ -826,7 +832,9 @@ private: !executeDispatch(block, arguments, result, dict_ptr) && !executeDispatchComplex(block, arguments, result, dict_ptr) && !executeDispatchComplex(block, arguments, result, dict_ptr) && +#if !defined(ARCADIA_BUILD) !executeDispatchComplex(block, arguments, result, dict_ptr) && +#endif !executeDispatchComplex(block, arguments, result, dict_ptr) && !executeDispatchRange(block, arguments, result, dict_ptr)) throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE}; @@ -1086,8 +1094,10 @@ private: !executeDispatch(block, arguments, result, dict_ptr) && !executeDispatchComplex(block, arguments, result, dict_ptr) && !executeDispatchComplex(block, arguments, result, dict_ptr) && - !executeDispatchComplex(block, arguments, result, dict_ptr) && - !executeDispatchComplex(block, arguments, result, dict_ptr)) +#if !defined(ARCADIA_BUILD) + !executeDispatchComplex(block, arguments, result, dict_ptr) && +#endif + !executeDispatchComplex(block, arguments, result, dict_ptr)) throw Exception{"Unsupported dictionary type " + dict_ptr->getTypeName(), ErrorCodes::UNKNOWN_TYPE}; } diff --git a/src/Functions/FunctionsHashing.cpp b/src/Functions/FunctionsHashing.cpp index 8705e6bfaa3..900455a1015 100644 --- a/src/Functions/FunctionsHashing.cpp +++ b/src/Functions/FunctionsHashing.cpp @@ -26,12 +26,14 @@ void registerFunctionsHashing(FunctionFactory & factory) factory.registerFunction(); factory.registerFunction(); factory.registerFunction(); +#if !defined(ARCADIA_BUILD) factory.registerFunction(); factory.registerFunction(); factory.registerFunction(); factory.registerFunction(); factory.registerFunction(); factory.registerFunction(); +#endif #if USE_XXHASH factory.registerFunction(); diff --git a/src/Functions/FunctionsHashing.h b/src/Functions/FunctionsHashing.h index a589b220351..f647390e1c8 100644 --- a/src/Functions/FunctionsHashing.h +++ b/src/Functions/FunctionsHashing.h @@ -3,22 +3,24 @@ #include #include #include -#include -#include +#if !defined(ARCADIA_BUILD) +# include +# include +# include "config_functions.h" +# include "config_core.h" +#endif #include #include #include -#include "config_functions.h" #if USE_XXHASH -# include +# include #endif -#include "config_core.h" #if USE_SSL -# include -# include +# include +# include #endif #include @@ -219,7 +221,7 @@ struct SipHash128Impl } }; - +#if !defined(ARCADIA_BUILD) /** Why we need MurmurHash2? * MurmurHash2 is an outdated hash function, superseded by MurmurHash3 and subsequently by CityHash, xxHash, HighwayHash. * Usually there is no reason to use MurmurHash. @@ -331,6 +333,18 @@ struct MurmurHash3Impl64 static constexpr bool use_int_hash_for_pods = false; }; +struct MurmurHash3Impl128 +{ + static constexpr auto name = "murmurHash3_128"; + enum { length = 16 }; + + static void apply(const char * begin, const size_t size, unsigned char * out_char_data) + { + MurmurHash3_x64_128(begin, size, 0, out_char_data); + } +}; +#endif + /// http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/478a4add975b/src/share/classes/java/lang/String.java#l1452 /// Care should be taken to do all calculation in unsigned integers (to avoid undefined behaviour on overflow) /// but obtain the same result as it is done in singed integers with two's complement arithmetic. @@ -411,17 +425,6 @@ struct HiveHashImpl static constexpr bool use_int_hash_for_pods = false; }; -struct MurmurHash3Impl128 -{ - static constexpr auto name = "murmurHash3_128"; - enum { length = 16 }; - - static void apply(const char * begin, const size_t size, unsigned char * out_char_data) - { - MurmurHash3_x64_128(begin, size, 0, out_char_data); - } -}; - struct ImplCityHash64 { static constexpr auto name = "cityHash64"; @@ -1145,12 +1148,16 @@ using FunctionSipHash128 = FunctionStringHashFixedString; using FunctionCityHash64 = FunctionAnyHash; using FunctionFarmHash64 = FunctionAnyHash; using FunctionMetroHash64 = FunctionAnyHash; + +#if !defined(ARCADIA_BUILD) using FunctionMurmurHash2_32 = FunctionAnyHash; using FunctionMurmurHash2_64 = FunctionAnyHash; using FunctionGccMurmurHash = FunctionAnyHash; using FunctionMurmurHash3_32 = FunctionAnyHash; using FunctionMurmurHash3_64 = FunctionAnyHash; using FunctionMurmurHash3_128 = FunctionStringHashFixedString; +#endif + using FunctionJavaHash = FunctionAnyHash; using FunctionJavaHashUTF16LE = FunctionAnyHash; using FunctionHiveHash = FunctionAnyHash; diff --git a/src/Functions/FunctionsJSON.h b/src/Functions/FunctionsJSON.h index 468b499b78c..acd7c42732c 100644 --- a/src/Functions/FunctionsJSON.h +++ b/src/Functions/FunctionsJSON.h @@ -5,7 +5,6 @@ #include #include #include -#include "config_functions.h" #include #include #include @@ -27,6 +26,10 @@ #include #include +#if !defined(ARCADIA_BUILD) +# include "config_functions.h" +#endif + namespace DB { diff --git a/src/Functions/FunctionsStringRegex.cpp b/src/Functions/FunctionsStringRegex.cpp index 856852ae197..2f4c2432d54 100644 --- a/src/Functions/FunctionsStringRegex.cpp +++ b/src/Functions/FunctionsStringRegex.cpp @@ -17,16 +17,15 @@ #include #include -#include "config_functions.h" -#if USE_HYPERSCAN -# if __has_include() -# include -# else -# include -# endif +#if !defined(ARCADIA_BUILD) +# include "config_functions.h" +# include +#endif + +#if USE_HYPERSCAN +# include #endif -#include #if USE_RE2_ST # include #else diff --git a/src/Functions/IFunction.cpp b/src/Functions/IFunction.cpp index 7355b5df9ad..911810a272c 100644 --- a/src/Functions/IFunction.cpp +++ b/src/Functions/IFunction.cpp @@ -1,6 +1,5 @@ #include -#include #include #include #include @@ -24,11 +23,15 @@ #include #include +#if !defined(ARCADIA_BUILD) +# include +#endif + #if USE_EMBEDDED_COMPILER -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wunused-parameter" -#include -#pragma GCC diagnostic pop +# pragma GCC diagnostic push +# pragma GCC diagnostic ignored "-Wunused-parameter" +# include +# pragma GCC diagnostic pop #endif diff --git a/src/Functions/IFunction.h b/src/Functions/IFunction.h index 3887f3f1669..5ef6e5aaf22 100644 --- a/src/Functions/IFunction.h +++ b/src/Functions/IFunction.h @@ -2,12 +2,15 @@ #include -#include "config_core.h" #include #include #include #include +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + /// This file contains user interface for functions. /// For developer interface (in case you need to implement a new function) see IFunctionImpl.h diff --git a/src/Functions/RapidJSONParser.h b/src/Functions/RapidJSONParser.h index ff4ecd506fd..07b0aea3543 100644 --- a/src/Functions/RapidJSONParser.h +++ b/src/Functions/RapidJSONParser.h @@ -1,13 +1,15 @@ #pragma once -#include "config_functions.h" +#if !defined(ARCADIA_BUILD) +# include "config_functions.h" +#endif + #if USE_RAPIDJSON +# include +# include +# include -#include -#include -#include - -#include +# include namespace DB diff --git a/src/Functions/Regexps.h b/src/Functions/Regexps.h index 5d93e823419..433e416a18f 100644 --- a/src/Functions/Regexps.h +++ b/src/Functions/Regexps.h @@ -14,14 +14,12 @@ #include #include +#if !defined(ARCADIA_BUILD) +# include "config_functions.h" +#endif -#include "config_functions.h" #if USE_HYPERSCAN -# if __has_include() -# include -# else -# include -# endif +# include #endif namespace ProfileEvents diff --git a/src/Functions/SimdJSONParser.h b/src/Functions/SimdJSONParser.h index a12119c5c6d..d5630cf1cf1 100644 --- a/src/Functions/SimdJSONParser.h +++ b/src/Functions/SimdJSONParser.h @@ -1,13 +1,15 @@ #pragma once -#include "config_functions.h" +#if !defined(ARCADIA_BUILD) +# include "config_functions.h" +#endif + #if USE_SIMDJSON +# include +# include +# include -#include -#include -#include - -#include +# include namespace DB @@ -137,4 +139,5 @@ private: }; } + #endif diff --git a/src/Functions/base64Encode.cpp b/src/Functions/base64Encode.cpp index f76fedda71e..8cf54eca768 100644 --- a/src/Functions/base64Encode.cpp +++ b/src/Functions/base64Encode.cpp @@ -1,9 +1,12 @@ #include #include -#include "config_functions.h" + +#if !defined(ARCADIA_BUILD) +# include "config_functions.h" +#endif #if USE_BASE64 -#include +# include namespace DB { diff --git a/src/Functions/convertCharset.cpp b/src/Functions/convertCharset.cpp index 372bf08a0d2..9bd1f1b1cf6 100644 --- a/src/Functions/convertCharset.cpp +++ b/src/Functions/convertCharset.cpp @@ -1,20 +1,22 @@ -#include "config_core.h" +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + #if USE_ICU +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include -#include +# include +# include +# include namespace DB diff --git a/src/Functions/intDiv.cpp b/src/Functions/intDiv.cpp index 062a374c00f..d21e779045f 100644 --- a/src/Functions/intDiv.cpp +++ b/src/Functions/intDiv.cpp @@ -3,7 +3,6 @@ #if defined(__SSE2__) # define LIBDIVIDE_SSE2 1 -# define LIBDIVIDE_VECTOR_TYPE #endif #include diff --git a/src/Functions/registerFunctions.cpp b/src/Functions/registerFunctions.cpp index 233018c7f16..02013e33d16 100644 --- a/src/Functions/registerFunctions.cpp +++ b/src/Functions/registerFunctions.cpp @@ -46,7 +46,9 @@ void registerFunctions() registerFunctionsArithmetic(factory); registerFunctionsArray(factory); registerFunctionsTuple(factory); +#if !defined(ARCADIA_BUILD) registerFunctionsBitmap(factory); +#endif registerFunctionsCoding(factory); registerFunctionsComparison(factory); registerFunctionsConditional(factory); diff --git a/src/Functions/registerFunctionsConsistentHashing.cpp b/src/Functions/registerFunctionsConsistentHashing.cpp index 95a856b6d3c..ceec6dca5e6 100644 --- a/src/Functions/registerFunctionsConsistentHashing.cpp +++ b/src/Functions/registerFunctionsConsistentHashing.cpp @@ -5,14 +5,18 @@ class FunctionFactory; void registerFunctionYandexConsistentHash(FunctionFactory & factory); void registerFunctionJumpConsistentHash(FunctionFactory & factory); +#if !defined(ARCADIA_BUILD) void registerFunctionSumburConsistentHash(FunctionFactory & factory); +#endif void registerFunctionsConsistentHashing(FunctionFactory & factory) { registerFunctionYandexConsistentHash(factory); registerFunctionJumpConsistentHash(factory); +#if !defined(ARCADIA_BUILD) registerFunctionSumburConsistentHash(factory); +#endif } } diff --git a/src/Functions/registerFunctionsGeo.cpp b/src/Functions/registerFunctionsGeo.cpp index cb3c268a19a..2ed02bbd73b 100644 --- a/src/Functions/registerFunctionsGeo.cpp +++ b/src/Functions/registerFunctionsGeo.cpp @@ -1,4 +1,6 @@ -#include "config_functions.h" +#if !defined(ARCADIA_BUILD) +# include "config_functions.h" +#endif namespace DB { diff --git a/src/Functions/registerFunctionsMiscellaneous.cpp b/src/Functions/registerFunctionsMiscellaneous.cpp index 30cab4cc53a..221e14fcce1 100644 --- a/src/Functions/registerFunctionsMiscellaneous.cpp +++ b/src/Functions/registerFunctionsMiscellaneous.cpp @@ -1,4 +1,6 @@ -#include +#if !defined(ARCADIA_BUILD) +# include +#endif namespace DB { diff --git a/src/Functions/registerFunctionsString.cpp b/src/Functions/registerFunctionsString.cpp index cc94e877bbf..5493b98d3fc 100644 --- a/src/Functions/registerFunctionsString.cpp +++ b/src/Functions/registerFunctionsString.cpp @@ -1,4 +1,6 @@ -#include "config_functions.h" +#if !defined(ARCADIA_BUILD) +# include "config_functions.h" +#endif namespace DB { diff --git a/src/Functions/version.cpp b/src/Functions/version.cpp index 34eabd30336..e11f45f160a 100644 --- a/src/Functions/version.cpp +++ b/src/Functions/version.cpp @@ -1,9 +1,11 @@ #include #include #include -#include #include +#if !defined(ARCADIA_BUILD) +# include +#endif namespace DB { diff --git a/src/Functions/ya.make b/src/Functions/ya.make new file mode 100644 index 00000000000..efcae6bf73b --- /dev/null +++ b/src/Functions/ya.make @@ -0,0 +1,418 @@ +LIBRARY() + +ADDINCL( + library/consistent_hashing + contrib/libs/farmhash + contrib/libs/hyperscan/src + contrib/libs/icu/common + contrib/libs/libdivide + contrib/libs/rapidjson/include + contrib/libs/xxhash +) + +PEERDIR( + clickhouse/src/Common + clickhouse/src/Dictionaries + contrib/libs/farmhash + contrib/libs/fastops/fastops + contrib/libs/hyperscan + contrib/libs/icu + contrib/libs/libdivide + contrib/libs/metrohash + contrib/libs/rapidjson + contrib/libs/xxhash + library/consistent_hashing +) + +SRCS( + array/array.cpp + array/arrayAll.cpp + array/arrayAUC.cpp + array/arrayCompact.cpp + array/arrayConcat.cpp + array/arrayCount.cpp + array/arrayCumSum.cpp + array/arrayCumSumNonNegative.cpp + array/arrayDifference.cpp + array/arrayDistinct.cpp + array/arrayElement.cpp + array/arrayEnumerate.cpp + array/arrayEnumerateDense.cpp + array/arrayEnumerateDenseRanked.cpp + array/arrayEnumerateRanked.cpp + array/arrayEnumerateUniq.cpp + array/arrayEnumerateUniqRanked.cpp + array/arrayExists.cpp + array/arrayFill.cpp + array/arrayFilter.cpp + array/arrayFirst.cpp + array/arrayFirstIndex.cpp + array/arrayFlatten.cpp + array/arrayIntersect.cpp + array/arrayJoin.cpp + array/arrayMap.cpp + array/arrayPopBack.cpp + array/arrayPopFront.cpp + array/arrayPushBack.cpp + array/arrayPushFront.cpp + array/arrayReduce.cpp + array/arrayReduceInRanges.cpp + array/arrayResize.cpp + array/arrayReverse.cpp + array/arraySlice.cpp + array/arraySort.cpp + array/arraySplit.cpp + array/arraySum.cpp + array/arrayUniq.cpp + array/arrayWithConstant.cpp + array/arrayZip.cpp + array/countEqual.cpp + array/emptyArray.cpp + array/emptyArrayToSingle.cpp + array/has.cpp + array/hasAll.cpp + array/hasAny.cpp + array/indexOf.cpp + array/length.cpp + array/range.cpp + array/registerFunctionsArray.cpp + GatherUtils/concat.cpp + GatherUtils/createArraySink.cpp + GatherUtils/createArraySource.cpp + GatherUtils/createValueSource.cpp + GatherUtils/has.cpp + GatherUtils/push.cpp + GatherUtils/resizeConstantSize.cpp + GatherUtils/resizeDynamicSize.cpp + GatherUtils/sliceDynamicOffsetBounded.cpp + GatherUtils/sliceDynamicOffsetUnbounded.cpp + GatherUtils/sliceFromLeftConstantOffsetBounded.cpp + GatherUtils/sliceFromLeftConstantOffsetUnbounded.cpp + GatherUtils/sliceFromRightConstantOffsetBounded.cpp + GatherUtils/sliceFromRightConstantOffsetUnbounded.cpp + URL/basename.cpp + URL/cutFragment.cpp + URL/cutQueryString.cpp + URL/cutQueryStringAndFragment.cpp + URL/cutToFirstSignificantSubdomain.cpp + URL/cutURLParameter.cpp + URL/cutWWW.cpp + URL/decodeURLComponent.cpp + URL/domain.cpp + URL/domainWithoutWWW.cpp + URL/extractURLParameter.cpp + URL/extractURLParameterNames.cpp + URL/extractURLParameters.cpp + URL/firstSignificantSubdomain.cpp + URL/fragment.cpp + URL/path.cpp + URL/pathFull.cpp + URL/protocol.cpp + URL/queryString.cpp + URL/queryStringAndFragment.cpp + URL/registerFunctionsURL.cpp + URL/tldLookup.generated.cpp + URL/topLevelDomain.cpp + URL/URLHierarchy.cpp + URL/URLPathHierarchy.cpp + abs.cpp + acos.cpp + addDays.cpp + addHours.cpp + addMinutes.cpp + addMonths.cpp + addQuarters.cpp + addressToLine.cpp + addressToSymbol.cpp + addSeconds.cpp + addWeeks.cpp + addYears.cpp + appendTrailingCharIfAbsent.cpp + asin.cpp + assumeNotNull.cpp + atan.cpp + bar.cpp + base64Decode.cpp + base64Encode.cpp + bitAnd.cpp + bitBoolMaskAnd.cpp + bitBoolMaskOr.cpp + bitCount.cpp + bitNot.cpp + bitOr.cpp + bitRotateLeft.cpp + bitRotateRight.cpp + bitShiftLeft.cpp + bitShiftRight.cpp + bitSwapLastTwo.cpp + bitTest.cpp + bitTestAll.cpp + bitTestAny.cpp + bitWrapperFunc.cpp + bitXor.cpp + blockNumber.cpp + blockSerializedSize.cpp + blockSize.cpp + caseWithExpression.cpp + cbrt.cpp + coalesce.cpp + concat.cpp + convertCharset.cpp + cos.cpp + CRC.cpp + currentDatabase.cpp + currentQuota.cpp + currentRowPolicies.cpp + currentUser.cpp + dateDiff.cpp + defaultValueOfArgumentType.cpp + demange.cpp + divide.cpp + dumpColumnStructure.cpp + e.cpp + empty.cpp + endsWith.cpp + equals.cpp + erf.cpp + erfc.cpp + evalMLMethod.cpp + exp.cpp + exp2.cpp + exp10.cpp + extractTimeZoneFromFunctionArguments.cpp + filesystem.cpp + finalizeAggregation.cpp + formatDateTime.cpp + formatString.cpp + FunctionFactory.cpp + FunctionFQDN.cpp + FunctionHelpers.cpp + FunctionJoinGet.cpp + FunctionsCoding.cpp + FunctionsConversion.cpp + FunctionsEmbeddedDictionaries.cpp + FunctionsExternalDictionaries.cpp + FunctionsExternalModels.cpp + FunctionsFormatting.cpp + FunctionsHashing.cpp + FunctionsJSON.cpp + FunctionsLogical.cpp + FunctionsRandom.cpp + FunctionsRound.cpp + FunctionsStringArray.cpp + FunctionsStringRegex.cpp + FunctionsStringSimilarity.cpp + gcd.cpp + generateUUIDv4.cpp + GeoHash.cpp + geohashDecode.cpp + geohashEncode.cpp + geohashesInBox.cpp + getMacro.cpp + getScalar.cpp + getSizeOfEnumType.cpp + greatCircleDistance.cpp + greater.cpp + greaterOrEquals.cpp + greatest.cpp + hasColumnInTable.cpp + hasToken.cpp + hasTokenCaseInsensitive.cpp + hostName.cpp + identity.cpp + if.cpp + ifNotFinite.cpp + ifNull.cpp + IFunction.cpp + ignore.cpp + ignoreExceptNull.cpp + in.cpp + intDiv.cpp + intDivOrZero.cpp + intExp2.cpp + intExp10.cpp + isConstant.cpp + isFinite.cpp + isInfinite.cpp + isNaN.cpp + isNotNull.cpp + isNull.cpp + isValidUTF8.cpp + jumpConsistentHash.cpp + lcm.cpp + least.cpp + lengthUTF8.cpp + less.cpp + lessOrEquals.cpp + lgamma.cpp + log.cpp + log2.cpp + log10.cpp + lowCardinalityIndices.cpp + lowCardinalityKeys.cpp + lower.cpp + lowerUTF8.cpp + materialize.cpp + minus.cpp + modulo.cpp + moduloOrZero.cpp + multiIf.cpp + multiply.cpp + multiSearchAllPositions.cpp + multiSearchAllPositionsCaseInsensitive.cpp + multiSearchAllPositionsCaseInsensitiveUTF8.cpp + multiSearchAllPositionsUTF8.cpp + multiSearchAny.cpp + multiSearchAnyCaseInsensitive.cpp + multiSearchAnyCaseInsensitiveUTF8.cpp + multiSearchAnyUTF8.cpp + multiSearchFirstIndex.cpp + multiSearchFirstIndexCaseInsensitive.cpp + multiSearchFirstIndexCaseInsensitiveUTF8.cpp + multiSearchFirstIndexUTF8.cpp + multiSearchFirstPosition.cpp + multiSearchFirstPositionCaseInsensitive.cpp + multiSearchFirstPositionCaseInsensitiveUTF8.cpp + multiSearchFirstPositionUTF8.cpp + negate.cpp + neighbor.cpp + notEmpty.cpp + notEquals.cpp + now.cpp + now64.cpp + nullIf.cpp + pi.cpp + plus.cpp + pointInEllipses.cpp + pointInPolygon.cpp + position.cpp + positionCaseInsensitive.cpp + positionCaseInsensitiveUTF8.cpp + positionUTF8.cpp + pow.cpp + rand.cpp + rand64.cpp + randConstant.cpp + randomPrintableASCII.cpp + regexpQuoteMeta.cpp + registerFunctions.cpp + registerFunctionsArithmetic.cpp + registerFunctionsComparison.cpp + registerFunctionsConditional.cpp + registerFunctionsConsistentHashing.cpp + registerFunctionsDateTime.cpp + registerFunctionsGeo.cpp + registerFunctionsHigherOrder.cpp + registerFunctionsIntrospection.cpp + registerFunctionsMath.cpp + registerFunctionsMiscellaneous.cpp + registerFunctionsNull.cpp + registerFunctionsRandom.cpp + registerFunctionsReinterpret.cpp + registerFunctionsString.cpp + registerFunctionsStringSearch.cpp + registerFunctionsTuple.cpp + registerFunctionsVisitParam.cpp + reinterpretAsFixedString.cpp + reinterpretAsString.cpp + reinterpretStringAs.cpp + repeat.cpp + replicate.cpp + reverse.cpp + reverseUTF8.cpp + roundAge.cpp + roundDuration.cpp + roundToExp2.cpp + rowNumberInAllBlocks.cpp + rowNumberInBlock.cpp + runningAccumulate.cpp + runningDifference.cpp + runningDifferenceStartingWithFirstValue.cpp + sigmoid.cpp + sin.cpp + sleep.cpp + sleepEachRow.cpp + sqrt.cpp + startsWith.cpp + substring.cpp + subtractDays.cpp + subtractHours.cpp + subtractMinutes.cpp + subtractMonths.cpp + subtractQuarters.cpp + subtractSeconds.cpp + subtractWeeks.cpp + subtractYears.cpp + tan.cpp + tanh.cpp + tgamma.cpp + throwIf.cpp + timeSlot.cpp + timeSlots.cpp + timezone.cpp + toColumnTypeName.cpp + toCustomWeek.cpp + today.cpp + toDayOfMonth.cpp + toDayOfWeek.cpp + toDayOfYear.cpp + toHour.cpp + toISOWeek.cpp + toISOYear.cpp + toLowCardinality.cpp + toMinute.cpp + toMonday.cpp + toMonth.cpp + toNullable.cpp + toQuarter.cpp + toRelativeDayNum.cpp + toRelativeHourNum.cpp + toRelativeMinuteNum.cpp + toRelativeMonthNum.cpp + toRelativeQuarterNum.cpp + toRelativeSecondNum.cpp + toRelativeWeekNum.cpp + toRelativeYearNum.cpp + toSecond.cpp + toStartOfDay.cpp + toStartOfFifteenMinutes.cpp + toStartOfFiveMinute.cpp + toStartOfHour.cpp + toStartOfInterval.cpp + toStartOfISOYear.cpp + toStartOfMinute.cpp + toStartOfMonth.cpp + toStartOfQuarter.cpp + toStartOfTenMinutes.cpp + toStartOfYear.cpp + toTime.cpp + toTimeZone.cpp + toTypeName.cpp + toValidUTF8.cpp + toYear.cpp + toYYYYMM.cpp + toYYYYMMDD.cpp + toYYYYMMDDhhmmss.cpp + transform.cpp + trap.cpp + trim.cpp + tryBase64Decode.cpp + tuple.cpp + tupleElement.cpp + upper.cpp + upperUTF8.cpp + uptime.cpp + version.cpp + visibleWidth.cpp + visitParamExtractBool.cpp + visitParamExtractFloat.cpp + visitParamExtractInt.cpp + visitParamExtractRaw.cpp + visitParamExtractString.cpp + visitParamExtractUInt.cpp + visitParamHas.cpp + yandexConsistentHash.cpp + yesterday.cpp +) + +END() diff --git a/src/IO/BrotliReadBuffer.cpp b/src/IO/BrotliReadBuffer.cpp index f68424cd54e..ee888b8af22 100644 --- a/src/IO/BrotliReadBuffer.cpp +++ b/src/IO/BrotliReadBuffer.cpp @@ -1,8 +1,10 @@ -#include -#if USE_BROTLI +#if !defined(ARCADIA_BUILD) +# include +#endif -#include "BrotliReadBuffer.h" -#include +#if USE_BROTLI +# include +# include "BrotliReadBuffer.h" namespace DB { diff --git a/src/IO/BrotliWriteBuffer.cpp b/src/IO/BrotliWriteBuffer.cpp index ac1e2b3c188..e3001409e86 100644 --- a/src/IO/BrotliWriteBuffer.cpp +++ b/src/IO/BrotliWriteBuffer.cpp @@ -1,8 +1,10 @@ -#include -#if USE_BROTLI +#if !defined(ARCADIA_BUILD) +# include +#endif -#include -#include +#if USE_BROTLI +# include +# include namespace DB { diff --git a/src/IO/CompressionMethod.cpp b/src/IO/CompressionMethod.cpp index 20f1ea44301..a0a5e19f4fa 100644 --- a/src/IO/CompressionMethod.cpp +++ b/src/IO/CompressionMethod.cpp @@ -7,7 +7,9 @@ #include #include -#include +#if !defined(ARCADIA_BUILD) +# include +#endif namespace DB diff --git a/src/IO/HTTPCommon.cpp b/src/IO/HTTPCommon.cpp index d8ce3427c91..97a0525a9b8 100644 --- a/src/IO/HTTPCommon.cpp +++ b/src/IO/HTTPCommon.cpp @@ -1,6 +1,5 @@ #include -#include #include #include #include @@ -9,14 +8,18 @@ #include +#if !defined(ARCADIA_BUILD) +# include +#endif + #if USE_POCO_NETSSL -#include -#include -#include -#include -#include -#include -#include +# include +# include +# include +# include +# include +# include +# include #endif #include diff --git a/src/IO/ReadWriteBufferFromHTTP.h b/src/IO/ReadWriteBufferFromHTTP.h index f5e6f91537d..2d4e3f0472e 100644 --- a/src/IO/ReadWriteBufferFromHTTP.h +++ b/src/IO/ReadWriteBufferFromHTTP.h @@ -14,10 +14,13 @@ #include #include #include -#include #include #include +#if !defined(ARCADIA_BUILD) +# include +#endif + #define DEFAULT_HTTP_READ_BUFFER_TIMEOUT 1800 #define DEFAULT_HTTP_READ_BUFFER_CONNECTION_TIMEOUT 1 @@ -302,4 +305,3 @@ public: }; } - diff --git a/src/IO/UseSSL.cpp b/src/IO/UseSSL.cpp index 2aad0ef49e2..6770de2cbad 100644 --- a/src/IO/UseSSL.cpp +++ b/src/IO/UseSSL.cpp @@ -1,9 +1,11 @@ #include "UseSSL.h" -#include +#if !defined(ARCADIA_BUILD) +# include +#endif #if USE_POCO_NETSSL -#include +# include #endif namespace DB diff --git a/src/IO/WriteBufferFromHTTPServerResponse.cpp b/src/IO/WriteBufferFromHTTPServerResponse.cpp index 77198ca93ea..0f30f1352e3 100644 --- a/src/IO/WriteBufferFromHTTPServerResponse.cpp +++ b/src/IO/WriteBufferFromHTTPServerResponse.cpp @@ -7,7 +7,10 @@ #include #include #include -#include + +#if !defined(ARCADIA_BUILD) +# include +#endif namespace DB diff --git a/src/IO/WriteBufferFromHTTPServerResponse.h b/src/IO/WriteBufferFromHTTPServerResponse.h index 1307c007656..ffa36c11c5b 100644 --- a/src/IO/WriteBufferFromHTTPServerResponse.h +++ b/src/IO/WriteBufferFromHTTPServerResponse.h @@ -13,7 +13,10 @@ #include #include #include -#include + +#if !defined(ARCADIA_BUILD) +# include +#endif namespace Poco diff --git a/src/IO/ya.make b/src/IO/ya.make new file mode 100644 index 00000000000..81bf6060a94 --- /dev/null +++ b/src/IO/ya.make @@ -0,0 +1,59 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common + contrib/libs/brotli/dec + contrib/libs/brotli/enc + contrib/libs/poco/NetSSL_OpenSSL +) + +SRCS( + AIO.cpp + AIOContextPool.cpp + BrotliReadBuffer.cpp + BrotliWriteBuffer.cpp + CascadeWriteBuffer.cpp + CompressionMethod.cpp + copyData.cpp + createReadBufferFromFileBase.cpp + createWriteBufferFromFileBase.cpp + DoubleConverter.cpp + HashingWriteBuffer.cpp + HexWriteBuffer.cpp + HTTPCommon.cpp + LimitReadBuffer.cpp + MemoryReadWriteBuffer.cpp + MMapReadBufferFromFile.cpp + MMapReadBufferFromFileDescriptor.cpp + NullWriteBuffer.cpp + parseDateTimeBestEffort.cpp + PeekableReadBuffer.cpp + Progress.cpp + ReadBufferAIO.cpp + ReadBufferFromFile.cpp + ReadBufferFromFileBase.cpp + ReadBufferFromFileDescriptor.cpp + ReadBufferFromIStream.cpp + ReadBufferFromMemory.cpp + ReadBufferFromPocoSocket.cpp + readFloatText.cpp + ReadHelpers.cpp + ReadWriteBufferFromHTTP.cpp + UseSSL.cpp + WriteBufferAIO.cpp + WriteBufferFromFile.cpp + WriteBufferFromFileBase.cpp + WriteBufferFromFileDescriptor.cpp + WriteBufferFromFileDescriptorDiscardOnFailure.cpp + WriteBufferFromHTTP.cpp + WriteBufferFromHTTPServerResponse.cpp + WriteBufferFromOStream.cpp + WriteBufferFromPocoSocket.cpp + WriteBufferFromTemporaryFile.cpp + WriteBufferValidUTF8.cpp + WriteHelpers.cpp + ZlibDeflatingWriteBuffer.cpp + ZlibInflatingReadBuffer.cpp +) + +END() diff --git a/src/Interpreters/Aggregator.cpp b/src/Interpreters/Aggregator.cpp index 07c1d7476ad..03fc04d2152 100644 --- a/src/Interpreters/Aggregator.cpp +++ b/src/Interpreters/Aggregator.cpp @@ -25,11 +25,14 @@ #include #include #include -#include #include #include #include +#if !defined(ARCADIA_BUILD) +# include +#endif + namespace ProfileEvents { diff --git a/src/Interpreters/AsynchronousMetrics.cpp b/src/Interpreters/AsynchronousMetrics.cpp index 35a352b67b6..304db048f4f 100644 --- a/src/Interpreters/AsynchronousMetrics.cpp +++ b/src/Interpreters/AsynchronousMetrics.cpp @@ -5,7 +5,6 @@ #include #include #include -#include "config_core.h" #include #include #include @@ -13,12 +12,12 @@ #include #include -#if __has_include() -#include +#if !defined(ARCADIA_BUILD) +# include "config_core.h" #endif #if USE_JEMALLOC - #include +# include #endif @@ -216,9 +215,9 @@ void AsynchronousMetrics::update() set("NumberOfTables", total_number_of_tables); } -#if USE_JEMALLOC +#if USE_JEMALLOC && JEMALLOC_VERSION_MAJOR >= 4 { - #define FOR_EACH_METRIC(M) \ +# define FOR_EACH_METRIC(M) \ M("allocated", size_t) \ M("active", size_t) \ M("metadata", size_t) \ @@ -228,9 +227,9 @@ void AsynchronousMetrics::update() M("retained", size_t) \ M("background_thread.num_threads", size_t) \ M("background_thread.num_runs", uint64_t) \ - M("background_thread.run_interval", uint64_t) \ + M("background_thread.run_interval", uint64_t) - #define GET_METRIC(NAME, TYPE) \ +# define GET_METRIC(NAME, TYPE) \ do \ { \ TYPE value{}; \ @@ -241,13 +240,12 @@ void AsynchronousMetrics::update() FOR_EACH_METRIC(GET_METRIC) - #undef GET_METRIC - #undef FOR_EACH_METRIC +# undef GET_METRIC +# undef FOR_EACH_METRIC } #endif /// Add more metrics as you wish. } - } diff --git a/src/Interpreters/ClientInfo.cpp b/src/Interpreters/ClientInfo.cpp index ed806e5ad57..909582aa308 100644 --- a/src/Interpreters/ClientInfo.cpp +++ b/src/Interpreters/ClientInfo.cpp @@ -6,9 +6,12 @@ #include #include #include -#include #include +#if !defined(ARCADIA_BUILD) +# include +#endif + namespace DB { diff --git a/src/Interpreters/Context.h b/src/Interpreters/Context.h index f68b08bf9f0..6cf1a066b18 100644 --- a/src/Interpreters/Context.h +++ b/src/Interpreters/Context.h @@ -13,7 +13,6 @@ #include #include #include -#include "config_core.h" #include #include #include @@ -25,6 +24,10 @@ #include #include +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + namespace Poco { diff --git a/src/Interpreters/ExpressionActions.cpp b/src/Interpreters/ExpressionActions.cpp index 435e493ffa9..447c54c769a 100644 --- a/src/Interpreters/ExpressionActions.cpp +++ b/src/Interpreters/ExpressionActions.cpp @@ -1,4 +1,3 @@ -#include "config_core.h" #include #include #include @@ -15,6 +14,10 @@ #include #include +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + namespace ProfileEvents { diff --git a/src/Interpreters/ExpressionActions.h b/src/Interpreters/ExpressionActions.h index 0c3027dfbab..5a29eaaab9e 100644 --- a/src/Interpreters/ExpressionActions.h +++ b/src/Interpreters/ExpressionActions.h @@ -7,12 +7,15 @@ #include #include #include -#include "config_core.h" #include #include #include #include +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + namespace DB { diff --git a/src/Interpreters/ExpressionJIT.h b/src/Interpreters/ExpressionJIT.h index 995fb35e52c..0a103aab378 100644 --- a/src/Interpreters/ExpressionJIT.h +++ b/src/Interpreters/ExpressionJIT.h @@ -1,13 +1,15 @@ #pragma once -#include "config_core.h" -#if USE_EMBEDDED_COMPILER +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif -#include -#include -#include -#include -#include +#if USE_EMBEDDED_COMPILER +# include +# include +# include +# include +# include namespace DB diff --git a/src/Interpreters/ExternalDictionariesLoader.cpp b/src/Interpreters/ExternalDictionariesLoader.cpp index 02388028c73..889b1c58b55 100644 --- a/src/Interpreters/ExternalDictionariesLoader.cpp +++ b/src/Interpreters/ExternalDictionariesLoader.cpp @@ -1,6 +1,9 @@ #include #include -#include "config_core.h" + +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif #if USE_MYSQL # include @@ -32,9 +35,9 @@ ExternalLoader::LoadablePtr ExternalDictionariesLoader::create( void ExternalDictionariesLoader::resetAll() { - #if USE_MYSQL - mysqlxx::PoolFactory::instance().reset(); - #endif +#if USE_MYSQL + mysqlxx::PoolFactory::instance().reset(); +#endif } } diff --git a/src/Interpreters/InterpreterSetRoleQuery.cpp b/src/Interpreters/InterpreterSetRoleQuery.cpp index 2a6f2317a9c..8f085d66c4c 100644 --- a/src/Interpreters/InterpreterSetRoleQuery.cpp +++ b/src/Interpreters/InterpreterSetRoleQuery.cpp @@ -50,7 +50,7 @@ void InterpreterSetRoleQuery::setRole(const ASTSetRoleQuery & query) { for (const auto & id : roles_from_query.getMatchingIDs()) { - if (!user->granted_roles.contains(id)) + if (!user->granted_roles.count(id)) throw Exception("Role should be granted to set current", ErrorCodes::SET_NON_GRANTED_ROLE); new_current_roles.push_back(id); } @@ -85,7 +85,7 @@ void InterpreterSetRoleQuery::updateUserSetDefaultRoles(User & user, const Exten { for (const auto & id : roles_from_query.getMatchingIDs()) { - if (!user.granted_roles.contains(id)) + if (!user.granted_roles.count(id)) throw Exception("Role should be granted to set default", ErrorCodes::SET_NON_GRANTED_ROLE); } } diff --git a/src/Interpreters/InterpreterSystemQuery.cpp b/src/Interpreters/InterpreterSystemQuery.cpp index 36713be1ff7..01a84559e92 100644 --- a/src/Interpreters/InterpreterSystemQuery.cpp +++ b/src/Interpreters/InterpreterSystemQuery.cpp @@ -1,7 +1,6 @@ #include #include #include -#include "config_core.h" #include #include #include @@ -32,6 +31,10 @@ #include #include +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + namespace DB { diff --git a/src/Interpreters/ya.make b/src/Interpreters/ya.make new file mode 100644 index 00000000000..7eb8a899e9c --- /dev/null +++ b/src/Interpreters/ya.make @@ -0,0 +1,138 @@ +LIBRARY() + +ADDINCL( + contrib/libs/libdivide + contrib/libs/pdqsort +) + +PEERDIR( + clickhouse/src/Core + contrib/libs/libdivide + contrib/libs/pdqsort +) + +NO_COMPILER_WARNINGS() + +SRCS( + ActionLocksManager.cpp + ActionsVisitor.cpp + addMissingDefaults.cpp + addTypeConversionToAST.cpp + Aggregator.cpp + ArrayJoinAction.cpp + AsynchronousMetrics.cpp + BloomFilter.cpp + castColumn.cpp + CatBoostModel.cpp + ClientInfo.cpp + Cluster.cpp + ClusterProxy/executeQuery.cpp + ClusterProxy/SelectStreamFactory.cpp + CollectJoinOnKeysVisitor.cpp + ColumnNamesContext.cpp + Context.cpp + convertFieldToType.cpp + createBlockSelector.cpp + CrossToInnerJoinVisitor.cpp + DatabaseAndTableWithAlias.cpp + DatabaseCatalog.cpp + DDLWorker.cpp + DNSCacheUpdater.cpp + EmbeddedDictionaries.cpp + evaluateConstantExpression.cpp + executeQuery.cpp + ExecuteScalarSubqueriesVisitor.cpp + ExpressionActions.cpp + ExpressionAnalyzer.cpp + ExternalDictionariesLoader.cpp + ExternalLoader.cpp + ExternalLoaderDatabaseConfigRepository.cpp + ExternalLoaderTempConfigRepository.cpp + ExternalLoaderXMLConfigRepository.cpp + ExternalModelsLoader.cpp + ExtractExpressionInfoVisitor.cpp + FillingRow.cpp + getClusterName.cpp + getTableExpressions.cpp + HashJoin.cpp + IdentifierSemantic.cpp + IExternalLoadable.cpp + InJoinSubqueriesPreprocessor.cpp + inplaceBlockConversions.cpp + InternalTextLogsQueue.cpp + InterpreterAlterQuery.cpp + InterpreterCheckQuery.cpp + InterpreterCreateQuery.cpp + InterpreterCreateQuotaQuery.cpp + InterpreterCreateRoleQuery.cpp + InterpreterCreateRowPolicyQuery.cpp + InterpreterCreateSettingsProfileQuery.cpp + InterpreterCreateUserQuery.cpp + InterpreterDescribeQuery.cpp + InterpreterDropAccessEntityQuery.cpp + InterpreterDropQuery.cpp + InterpreterExistsQuery.cpp + InterpreterExplainQuery.cpp + InterpreterFactory.cpp + InterpreterGrantQuery.cpp + InterpreterInsertQuery.cpp + InterpreterKillQueryQuery.cpp + InterpreterOptimizeQuery.cpp + InterpreterRenameQuery.cpp + InterpreterSelectQuery.cpp + InterpreterSelectWithUnionQuery.cpp + InterpreterSetQuery.cpp + InterpreterSetRoleQuery.cpp + InterpreterShowCreateAccessEntityQuery.cpp + InterpreterShowCreateQuery.cpp + InterpreterShowGrantsQuery.cpp + InterpreterShowProcesslistQuery.cpp + InterpreterShowQuotasQuery.cpp + InterpreterShowRowPoliciesQuery.cpp + InterpreterShowTablesQuery.cpp + InterpreterSystemQuery.cpp + InterpreterUseQuery.cpp + InterpreterWatchQuery.cpp + interpretSubquery.cpp + join_common.cpp + JoinedTables.cpp + JoinSwitcher.cpp + JoinToSubqueryTransformVisitor.cpp + loadMetadata.cpp + LogicalExpressionsOptimizer.cpp + MarkTableIdentifiersVisitor.cpp + MergeJoin.cpp + MetricLog.cpp + MutationsInterpreter.cpp + NullableUtils.cpp + OptimizeIfChains.cpp + OptimizeIfWithConstantConditionVisitor.cpp + PartLog.cpp + PredicateExpressionsOptimizer.cpp + PredicateRewriteVisitor.cpp + ProcessList.cpp + ProfileEventsExt.cpp + QueryAliasesVisitor.cpp + QueryLog.cpp + QueryNormalizer.cpp + QueryThreadLog.cpp + RenameColumnVisitor.cpp + ReplaceQueryParameterVisitor.cpp + RequiredSourceColumnsVisitor.cpp + RowRefs.cpp + Set.cpp + SetVariants.cpp + sortBlock.cpp + StorageID.cpp + SubqueryForSet.cpp + SyntaxAnalyzer.cpp + SystemLog.cpp + TableJoin.cpp + TablesStatus.cpp + TextLog.cpp + ThreadStatusExt.cpp + TraceLog.cpp + TranslateQualifiedNamesVisitor.cpp +) + +END() diff --git a/src/Parsers/ASTSystemQuery.h b/src/Parsers/ASTSystemQuery.h index f5b9afde4b3..eac96e50cb1 100644 --- a/src/Parsers/ASTSystemQuery.h +++ b/src/Parsers/ASTSystemQuery.h @@ -1,9 +1,12 @@ #pragma once -#include "config_core.h" #include #include +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + namespace DB { diff --git a/src/Parsers/ya.make b/src/Parsers/ya.make new file mode 100644 index 00000000000..942124c2c7a --- /dev/null +++ b/src/Parsers/ya.make @@ -0,0 +1,113 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common +) + +SRCS( + ASTAlterQuery.cpp + ASTAsterisk.cpp + ASTColumnDeclaration.cpp + ASTColumnsMatcher.cpp + ASTConstraintDeclaration.cpp + ASTCreateQuery.cpp + ASTCreateQuotaQuery.cpp + ASTCreateRoleQuery.cpp + ASTCreateRowPolicyQuery.cpp + ASTCreateSettingsProfileQuery.cpp + ASTCreateUserQuery.cpp + ASTDictionary.cpp + ASTDictionaryAttributeDeclaration.cpp + ASTDropAccessEntityQuery.cpp + ASTDropQuery.cpp + ASTExpressionList.cpp + ASTExtendedRoleSet.cpp + ASTFunction.cpp + ASTFunctionWithKeyValueArguments.cpp + ASTGrantQuery.cpp + ASTIdentifier.cpp + ASTInsertQuery.cpp + ASTKillQueryQuery.cpp + ASTLiteral.cpp + ASTOptimizeQuery.cpp + ASTOrderByElement.cpp + ASTPartition.cpp + ASTQualifiedAsterisk.cpp + ASTQueryParameter.cpp + ASTQueryWithOnCluster.cpp + ASTQueryWithOutput.cpp + ASTQueryWithTableAndOutput.cpp + ASTSampleRatio.cpp + ASTSelectQuery.cpp + ASTSelectWithUnionQuery.cpp + ASTSetRoleQuery.cpp + ASTSettingsProfileElement.cpp + ASTShowCreateAccessEntityQuery.cpp + ASTShowGrantsQuery.cpp + ASTShowQuotasQuery.cpp + ASTShowRowPoliciesQuery.cpp + ASTShowTablesQuery.cpp + ASTSubquery.cpp + ASTSystemQuery.cpp + ASTTablesInSelectQuery.cpp + ASTTTLElement.cpp + ASTWithAlias.cpp + CommonParsers.cpp + ExpressionElementParsers.cpp + ExpressionListParsers.cpp + formatAST.cpp + IAST.cpp + iostream_debug_helpers.cpp + IParserBase.cpp + Lexer.cpp + makeASTForLogicalFunction.cpp + parseDatabaseAndTableName.cpp + parseIdentifierOrStringLiteral.cpp + parseIntervalKind.cpp + parseQuery.cpp + ParserAlterQuery.cpp + ParserCase.cpp + ParserCheckQuery.cpp + ParserCreateQuery.cpp + ParserCreateQuotaQuery.cpp + ParserCreateRoleQuery.cpp + ParserCreateRowPolicyQuery.cpp + ParserCreateSettingsProfileQuery.cpp + ParserCreateUserQuery.cpp + ParserDescribeTableQuery.cpp + ParserDictionary.cpp + ParserDictionaryAttributeDeclaration.cpp + ParserDropAccessEntityQuery.cpp + ParserDropQuery.cpp + ParserExtendedRoleSet.cpp + ParserGrantQuery.cpp + ParserInsertQuery.cpp + ParserKillQueryQuery.cpp + ParserOptimizeQuery.cpp + ParserPartition.cpp + ParserQuery.cpp + ParserQueryWithOutput.cpp + ParserRenameQuery.cpp + ParserSampleRatio.cpp + ParserSelectQuery.cpp + ParserSelectWithUnionQuery.cpp + ParserSetQuery.cpp + ParserSetRoleQuery.cpp + ParserSettingsProfileElement.cpp + ParserShowCreateAccessEntityQuery.cpp + ParserShowGrantsQuery.cpp + ParserShowQuotasQuery.cpp + ParserShowRowPoliciesQuery.cpp + ParserShowTablesQuery.cpp + ParserSystemQuery.cpp + ParserTablePropertiesQuery.cpp + ParserTablesInSelectQuery.cpp + ParserUnionQueryElement.cpp + ParserUseQuery.cpp + ParserWatchQuery.cpp + parseUserName.cpp + queryToString.cpp + TokenIterator.cpp +) + +END() diff --git a/src/Processors/Formats/Impl/ProtobufRowInputFormat.h b/src/Processors/Formats/Impl/ProtobufRowInputFormat.h index 029b2c8329e..8dd36722efc 100644 --- a/src/Processors/Formats/Impl/ProtobufRowInputFormat.h +++ b/src/Processors/Formats/Impl/ProtobufRowInputFormat.h @@ -1,11 +1,13 @@ #pragma once -#include "config_formats.h" -#if USE_PROTOBUF +#if !defined(ARCADIA_BUILD) +# include "config_formats.h" +#endif -#include -#include -#include +#if USE_PROTOBUF +# include +# include +# include namespace DB { diff --git a/src/Processors/Formats/Impl/ProtobufRowOutputFormat.h b/src/Processors/Formats/Impl/ProtobufRowOutputFormat.h index ae8ebbf28f4..f216af01d80 100644 --- a/src/Processors/Formats/Impl/ProtobufRowOutputFormat.h +++ b/src/Processors/Formats/Impl/ProtobufRowOutputFormat.h @@ -1,13 +1,15 @@ #pragma once -#include "config_formats.h" -#if USE_PROTOBUF +#if !defined(ARCADIA_BUILD) +# include "config_formats.h" +#endif -#include -#include -#include -#include -#include +#if USE_PROTOBUF +# include +# include +# include +# include +# include namespace google diff --git a/src/Processors/ya.make b/src/Processors/ya.make new file mode 100644 index 00000000000..9822344aec1 --- /dev/null +++ b/src/Processors/ya.make @@ -0,0 +1,100 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common + contrib/libs/msgpack + contrib/libs/protobuf_std +) + +SRCS( + Chunk.cpp + ConcatProcessor.cpp + DelayedPortsProcessor.cpp + Executors/ParallelPipelineExecutor.cpp + Executors/PipelineExecutor.cpp + Executors/SequentialPipelineExecutor.cpp + Executors/TreeExecutorBlockInputStream.cpp + ForkProcessor.cpp + Formats/IInputFormat.cpp + Formats/Impl/BinaryRowInputFormat.cpp + Formats/Impl/BinaryRowOutputFormat.cpp + Formats/Impl/ConstantExpressionTemplate.cpp + Formats/Impl/CSVRowInputFormat.cpp + Formats/Impl/CSVRowOutputFormat.cpp + Formats/Impl/JSONCompactEachRowRowInputFormat.cpp + Formats/Impl/JSONCompactEachRowRowOutputFormat.cpp + Formats/Impl/JSONCompactRowOutputFormat.cpp + Formats/Impl/JSONEachRowRowInputFormat.cpp + Formats/Impl/JSONEachRowRowOutputFormat.cpp + Formats/Impl/JSONEachRowWithProgressRowOutputFormat.cpp + Formats/Impl/JSONRowOutputFormat.cpp + Formats/Impl/MsgPackRowInputFormat.cpp + Formats/Impl/MsgPackRowOutputFormat.cpp + Formats/Impl/MySQLOutputFormat.cpp + Formats/Impl/NativeFormat.cpp + Formats/Impl/NullFormat.cpp + Formats/Impl/ODBCDriver2BlockOutputFormat.cpp + Formats/Impl/ODBCDriverBlockOutputFormat.cpp + Formats/Impl/PrettyBlockOutputFormat.cpp + Formats/Impl/PrettyCompactBlockOutputFormat.cpp + Formats/Impl/PrettySpaceBlockOutputFormat.cpp + Formats/Impl/ProtobufRowInputFormat.cpp + Formats/Impl/ProtobufRowOutputFormat.cpp + Formats/Impl/RegexpRowInputFormat.cpp + Formats/Impl/TabSeparatedRowInputFormat.cpp + Formats/Impl/TabSeparatedRowOutputFormat.cpp + Formats/Impl/TemplateBlockOutputFormat.cpp + Formats/Impl/TemplateRowInputFormat.cpp + Formats/Impl/TSKVRowInputFormat.cpp + Formats/Impl/TSKVRowOutputFormat.cpp + Formats/Impl/ValuesBlockInputFormat.cpp + Formats/Impl/ValuesRowOutputFormat.cpp + Formats/Impl/VerticalRowOutputFormat.cpp + Formats/Impl/XMLRowOutputFormat.cpp + Formats/IOutputFormat.cpp + Formats/IRowInputFormat.cpp + Formats/IRowOutputFormat.cpp + Formats/LazyOutputFormat.cpp + Formats/OutputStreamToOutputFormat.cpp + Formats/RowInputFormatWithDiagnosticInfo.cpp + IAccumulatingTransform.cpp + IInflatingTransform.cpp + IProcessor.cpp + ISimpleTransform.cpp + ISink.cpp + ISource.cpp + LimitTransform.cpp + Pipe.cpp + Port.cpp + QueryPipeline.cpp + ResizeProcessor.cpp + Sources/SinkToOutputStream.cpp + Sources/SourceFromInputStream.cpp + Sources/SourceWithProgress.cpp + Transforms/AddingMissedTransform.cpp + Transforms/AggregatingTransform.cpp + Transforms/ConvertingTransform.cpp + Transforms/CreatingSetsTransform.cpp + Transforms/CubeTransform.cpp + Transforms/DistinctTransform.cpp + Transforms/ExpressionTransform.cpp + Transforms/ExtremesTransform.cpp + Transforms/FillingTransform.cpp + Transforms/FilterTransform.cpp + Transforms/FinishSortingTransform.cpp + Transforms/InflatingExpressionTransform.cpp + Transforms/LimitByTransform.cpp + Transforms/LimitsCheckingTransform.cpp + Transforms/MaterializingTransform.cpp + Transforms/MergeSortingTransform.cpp + Transforms/MergingAggregatedMemoryEfficientTransform.cpp + Transforms/MergingAggregatedTransform.cpp + Transforms/MergingSortedTransform.cpp + Transforms/PartialSortingTransform.cpp + Transforms/ReverseTransform.cpp + Transforms/RollupTransform.cpp + Transforms/SortingTransform.cpp + Transforms/TotalsHavingTransform.cpp +) + +END() diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp index 5a792080370..fc69123e696 100644 --- a/src/Storages/IStorage.cpp +++ b/src/Storages/IStorage.cpp @@ -126,8 +126,13 @@ Block IStorage::getSampleBlockForColumns(const Names & column_names) const namespace { - using NamesAndTypesMap = ::google::dense_hash_map; - using UniqueStrings = ::google::dense_hash_set; +#if !defined(ARCADIA_BUILD) + using NamesAndTypesMap = google::dense_hash_map; + using UniqueStrings = google::dense_hash_set; +#else + using NamesAndTypesMap = google::sparsehash::dense_hash_map; + using UniqueStrings = google::sparsehash::dense_hash_set; +#endif String listOfColumns(const NamesAndTypesList & available_columns) { diff --git a/src/Storages/MergeTree/MergeTreeIndexFullText.cpp b/src/Storages/MergeTree/MergeTreeIndexFullText.cpp index e42ac942362..6887b7c0d9d 100644 --- a/src/Storages/MergeTree/MergeTreeIndexFullText.cpp +++ b/src/Storages/MergeTree/MergeTreeIndexFullText.cpp @@ -208,8 +208,7 @@ bool MergeTreeConditionFullText::mayBeTrueOnGranule(MergeTreeIndexGranulePtr idx else if (element.function == RPNElement::FUNCTION_EQUALS || element.function == RPNElement::FUNCTION_NOT_EQUALS) { - rpn_stack.emplace_back( - granule->bloom_filters[element.key_column].contains(*element.bloom_filter), true); + rpn_stack.emplace_back(granule->bloom_filters[element.key_column].contains(*element.bloom_filter), true); if (element.function == RPNElement::FUNCTION_NOT_EQUALS) rpn_stack.back() = !rpn_stack.back(); diff --git a/src/Storages/StorageMySQL.h b/src/Storages/StorageMySQL.h index 3bde1cab4c7..8b98536e4d7 100644 --- a/src/Storages/StorageMySQL.h +++ b/src/Storages/StorageMySQL.h @@ -1,13 +1,16 @@ #pragma once -#include "config_core.h" +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + #if USE_MYSQL -#include +# include -#include -#include -#include +# include +# include +# include namespace DB diff --git a/src/Storages/System/StorageSystemBuildOptions.cpp b/src/Storages/System/StorageSystemBuildOptions.cpp index 73d1c91f422..4dd4ff90572 100644 --- a/src/Storages/System/StorageSystemBuildOptions.cpp +++ b/src/Storages/System/StorageSystemBuildOptions.cpp @@ -18,11 +18,15 @@ NamesAndTypesList StorageSystemBuildOptions::getNamesAndTypes() void StorageSystemBuildOptions::fillData(MutableColumns & res_columns, const Context &, const SelectQueryInfo &) const { +#if !defined(ARCADIA_BUILD) for (auto it = auto_config_build; *it; it += 2) { res_columns[0]->insert(it[0]); res_columns[1]->insert(it[1]); } +#else + UNUSED(res_columns); +#endif } } diff --git a/src/Storages/registerStorages.cpp b/src/Storages/registerStorages.cpp index f5fab52285d..5ad26b70803 100644 --- a/src/Storages/registerStorages.cpp +++ b/src/Storages/registerStorages.cpp @@ -1,6 +1,3 @@ -#include -#include "config_core.h" - #include #include diff --git a/src/Storages/registerStorages.h b/src/Storages/registerStorages.h index 63a758f5b38..c9874551073 100644 --- a/src/Storages/registerStorages.h +++ b/src/Storages/registerStorages.h @@ -1,6 +1,9 @@ #pragma once -#include -#include "config_core.h" + +#if !defined(ARCADIA_BUILD) +# include +# include "config_core.h" +#endif namespace DB { diff --git a/src/Storages/ya.make b/src/Storages/ya.make new file mode 100644 index 00000000000..6a032d82bdc --- /dev/null +++ b/src/Storages/ya.make @@ -0,0 +1,167 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common + contrib/libs/sparsehash +) + +SRCS( + Distributed/DirectoryMonitor.cpp + Distributed/DistributedBlockOutputStream.cpp + LiveView/StorageLiveView.cpp + MergeTree/ActiveDataPartSet.cpp + MergeTree/AllMergeSelector.cpp + MergeTree/BackgroundProcessingPool.cpp + MergeTree/BoolMask.cpp + MergeTree/checkDataPart.cpp + MergeTree/DataPartsExchange.cpp + MergeTree/EphemeralLockInZooKeeper.cpp + MergeTree/IMergedBlockOutputStream.cpp + MergeTree/IMergeTreeDataPart.cpp + MergeTree/IMergeTreeDataPartWriter.cpp + MergeTree/IMergeTreeReader.cpp + MergeTree/KeyCondition.cpp + MergeTree/LevelMergeSelector.cpp + MergeTree/localBackup.cpp + MergeTree/MergedBlockOutputStream.cpp + MergeTree/MergedColumnOnlyOutputStream.cpp + MergeTree/MergeList.cpp + MergeTree/MergeTreeBaseSelectProcessor.cpp + MergeTree/MergeTreeBlockOutputStream.cpp + MergeTree/MergeTreeBlockReadUtils.cpp + MergeTree/MergeTreeData.cpp + MergeTree/MergeTreeDataMergerMutator.cpp + MergeTree/MergeTreeDataPartChecksum.cpp + MergeTree/MergeTreeDataPartCompact.cpp + MergeTree/MergeTreeDataPartTTLInfo.cpp + MergeTree/MergeTreeDataPartType.cpp + MergeTree/MergeTreeDataPartWide.cpp + MergeTree/MergeTreeDataPartWriterCompact.cpp + MergeTree/MergeTreeDataPartWriterWide.cpp + MergeTree/MergeTreeDataSelectExecutor.cpp + MergeTree/MergeTreeDataWriter.cpp + MergeTree/MergeTreeIndexAggregatorBloomFilter.cpp + MergeTree/MergeTreeIndexBloomFilter.cpp + MergeTree/MergeTreeIndexConditionBloomFilter.cpp + MergeTree/MergeTreeIndexFullText.cpp + MergeTree/MergeTreeIndexGranularity.cpp + MergeTree/MergeTreeIndexGranularityInfo.cpp + MergeTree/MergeTreeIndexGranuleBloomFilter.cpp + MergeTree/MergeTreeIndexMinMax.cpp + MergeTree/MergeTreeIndexReader.cpp + MergeTree/MergeTreeIndexSet.cpp + MergeTree/MergeTreeIndices.cpp + MergeTree/MergeTreeMarksLoader.cpp + MergeTree/MergeTreeMutationEntry.cpp + MergeTree/MergeTreePartInfo.cpp + MergeTree/MergeTreePartition.cpp + MergeTree/MergeTreePartsMover.cpp + MergeTree/MergeTreeRangeReader.cpp + MergeTree/MergeTreeReaderCompact.cpp + MergeTree/MergeTreeReaderStream.cpp + MergeTree/MergeTreeReaderWide.cpp + MergeTree/MergeTreeReadPool.cpp + MergeTree/MergeTreeReverseSelectProcessor.cpp + MergeTree/MergeTreeSelectProcessor.cpp + MergeTree/MergeTreeSequentialBlockInputStream.cpp + MergeTree/MergeTreeSettings.cpp + MergeTree/MergeTreeThreadSelectBlockInputProcessor.cpp + MergeTree/MergeTreeWhereOptimizer.cpp + MergeTree/registerStorageMergeTree.cpp + MergeTree/ReplicatedMergeTreeAddress.cpp + MergeTree/ReplicatedMergeTreeAltersSequence.cpp + MergeTree/ReplicatedMergeTreeBlockOutputStream.cpp + MergeTree/ReplicatedMergeTreeCleanupThread.cpp + MergeTree/ReplicatedMergeTreeLogEntry.cpp + MergeTree/ReplicatedMergeTreeMutationEntry.cpp + MergeTree/ReplicatedMergeTreePartCheckThread.cpp + MergeTree/ReplicatedMergeTreePartHeader.cpp + MergeTree/ReplicatedMergeTreeQueue.cpp + MergeTree/ReplicatedMergeTreeRestartingThread.cpp + MergeTree/ReplicatedMergeTreeTableMetadata.cpp + MergeTree/SimpleMergeSelector.cpp + MergeTree/TTLMergeSelector.cpp + System/attachSystemTables.cpp + System/StorageSystemAggregateFunctionCombinators.cpp + System/StorageSystemAsynchronousMetrics.cpp + System/StorageSystemBuildOptions.cpp + System/StorageSystemClusters.cpp + System/StorageSystemCollations.cpp + System/StorageSystemColumns.cpp + System/StorageSystemContributors.cpp + System/StorageSystemContributors.generated.cpp + System/StorageSystemDatabases.cpp + System/StorageSystemDataTypeFamilies.cpp + System/StorageSystemDetachedParts.cpp + System/StorageSystemDictionaries.cpp + System/StorageSystemDisks.cpp + System/StorageSystemEvents.cpp + System/StorageSystemFormats.cpp + System/StorageSystemFunctions.cpp + System/StorageSystemGraphite.cpp + System/StorageSystemMacros.cpp + System/StorageSystemMerges.cpp + System/StorageSystemMergeTreeSettings.cpp + System/StorageSystemMetrics.cpp + System/StorageSystemModels.cpp + System/StorageSystemMutations.cpp + System/StorageSystemNumbers.cpp + System/StorageSystemOne.cpp + System/StorageSystemParts.cpp + System/StorageSystemPartsBase.cpp + System/StorageSystemPartsColumns.cpp + System/StorageSystemProcesses.cpp + System/StorageSystemQuotas.cpp + System/StorageSystemQuotaUsage.cpp + System/StorageSystemReplicas.cpp + System/StorageSystemReplicationQueue.cpp + System/StorageSystemRowPolicies.cpp + System/StorageSystemSettings.cpp + System/StorageSystemStackTrace.cpp + System/StorageSystemStoragePolicies.cpp + System/StorageSystemTableEngines.cpp + System/StorageSystemTableFunctions.cpp + System/StorageSystemTables.cpp + System/StorageSystemZeros.cpp + System/StorageSystemZooKeeper.cpp + AlterCommands.cpp + ColumnDefault.cpp + ColumnsDescription.cpp + ConstraintsDescription.cpp + getStructureOfRemoteTable.cpp + IndicesDescription.cpp + IStorage.cpp + MutationCommands.cpp + PartitionCommands.cpp + ReadInOrderOptimizer.cpp + registerStorages.cpp + StorageBuffer.cpp + StorageDictionary.cpp + StorageDistributed.cpp + StorageFactory.cpp + StorageFile.cpp + StorageGenerateRandom.cpp + StorageInMemoryMetadata.cpp + StorageInput.cpp + StorageJoin.cpp + StorageLog.cpp + StorageLogSettings.cpp + StorageMaterializedView.cpp + StorageMemory.cpp + StorageMerge.cpp + StorageMergeTree.cpp + StorageMySQL.cpp + StorageNull.cpp + StorageReplicatedMergeTree.cpp + StorageSet.cpp + StorageStripeLog.cpp + StorageTinyLog.cpp + StorageURL.cpp + StorageValues.cpp + StorageView.cpp + StorageXDBC.cpp + transformQueryForExternalDatabase.cpp + VirtualColumnUtils.cpp +) + +END() diff --git a/src/TableFunctions/ITableFunctionXDBC.h b/src/TableFunctions/ITableFunctionXDBC.h index 262c237bac2..547fda3f734 100644 --- a/src/TableFunctions/ITableFunctionXDBC.h +++ b/src/TableFunctions/ITableFunctionXDBC.h @@ -4,7 +4,10 @@ #include #include #include -#include + +#if !defined(ARCADIA_BUILD) +# include +#endif namespace DB { diff --git a/src/TableFunctions/TableFunctionMySQL.cpp b/src/TableFunctions/TableFunctionMySQL.cpp index be707c3520d..0afc74f163e 100644 --- a/src/TableFunctions/TableFunctionMySQL.cpp +++ b/src/TableFunctions/TableFunctionMySQL.cpp @@ -1,25 +1,27 @@ -#include "config_core.h" +#if !defined(ARCADIA_BUILD) +# include "config_core.h" +#endif + #if USE_MYSQL +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include +# include "registerTableFunctions.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "registerTableFunctions.h" - -#include +# include namespace DB diff --git a/src/TableFunctions/registerTableFunctions.h b/src/TableFunctions/registerTableFunctions.h index 3cde28685cc..8c54913676a 100644 --- a/src/TableFunctions/registerTableFunctions.h +++ b/src/TableFunctions/registerTableFunctions.h @@ -1,6 +1,9 @@ #pragma once -#include -#include "config_core.h" + +#if !defined(ARCADIA_BUILD) +# include +# include "config_core.h" +#endif namespace DB { diff --git a/src/TableFunctions/ya.make b/src/TableFunctions/ya.make new file mode 100644 index 00000000000..4d5d53ead88 --- /dev/null +++ b/src/TableFunctions/ya.make @@ -0,0 +1,26 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Common +) + +SRCS( + ITableFunction.cpp + ITableFunctionFileLike.cpp + ITableFunctionXDBC.cpp + parseColumnsListForTableFunction.cpp + registerTableFunctions.cpp + TableFunctionFactory.cpp + TableFunctionFile.cpp + TableFunctionGenerateRandom.cpp + TableFunctionInput.cpp + TableFunctionMerge.cpp + TableFunctionMySQL.cpp + TableFunctionNumbers.cpp + TableFunctionRemote.cpp + TableFunctionURL.cpp + TableFunctionValues.cpp + TableFunctionZeros.cpp +) + +END() diff --git a/src/ya.make b/src/ya.make new file mode 100644 index 00000000000..95e5914bbe7 --- /dev/null +++ b/src/ya.make @@ -0,0 +1,26 @@ +LIBRARY() + +PEERDIR( + clickhouse/src/Access + clickhouse/src/AggregateFunctions + clickhouse/src/Client + clickhouse/src/Columns + clickhouse/src/Common + clickhouse/src/Compression + clickhouse/src/Core + clickhouse/src/Databases + clickhouse/src/DataStreams + clickhouse/src/DataTypes + clickhouse/src/Formats + clickhouse/src/Dictionaries + clickhouse/src/Disks + clickhouse/src/Functions + clickhouse/src/Interpreters + clickhouse/src/IO + clickhouse/src/Parsers + clickhouse/src/Processors + clickhouse/src/Storages + clickhouse/src/TableFunctions +) + +END() diff --git a/ya.make b/ya.make index 84f1a2163a4..7f7c1bbce2f 100644 --- a/ya.make +++ b/ya.make @@ -7,4 +7,6 @@ OWNER(g:clickhouse) RECURSE( base + programs + src ) From 2ef123bc0eaf3be734d7cc36c57c9e7c9ee77c32 Mon Sep 17 00:00:00 2001 From: Ivan Blinkov Date: Thu, 16 Apr 2020 15:53:07 +0300 Subject: [PATCH 57/73] Replace one benchmark link --- website/templates/index/performance.html | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/website/templates/index/performance.html b/website/templates/index/performance.html index 9f31ad7a3ad..de54b05dd2d 100644 --- a/website/templates/index/performance.html +++ b/website/templates/index/performance.html @@ -38,12 +38,11 @@ rel="external nofollow noreferrer" target="_blank" class="text-reset">Geospatial processing with Clickhouse
Carto
  • ClickHouse and Vertica comparison
    zhtsh (machine translation from Chinese)
    • -
  • ClickHouse and InfiniDB comparison
    RamboLau (machine translation from Chinese)
    • +
  • MySQL vs ColumnStore vs ClickHouse
    Mafiree (machine translation from Chinese)
    • - - + {## TODO: ##} From 03c575934b4b818872704fe118e6945efe6dc88b Mon Sep 17 00:00:00 2001 From: Ivan Blinkov Date: Thu, 16 Apr 2020 15:55:32 +0300 Subject: [PATCH 58/73] Minor docs content improvements (#10304) * Add link to flink-clickhouse-sink + fixes nearby * Add link to dbal-doctrine * cleanup ru toc root * Sort out russian docs ToC a little bit * Add link collection of commercial support services --- docs/en/commercial/cloud.md | 5 ++ docs/en/commercial/support.md | 21 ++++++ docs/en/development/index.md | 2 +- .../en/interfaces/third-party/integrations.md | 8 ++- .../es/interfaces/third-party/integrations.md | 8 ++- .../fa/interfaces/third-party/integrations.md | 3 + .../fr/interfaces/third-party/integrations.md | 3 + .../ja/interfaces/third-party/integrations.md | 3 + docs/redirects.txt | 1 + docs/ru/commercial/index.md | 4 +- docs/ru/engines/index.md | 2 +- .../getting_started/example_datasets/index.md | 5 ++ docs/ru/getting_started/index.md | 7 ++ docs/ru/guides/index.md | 6 ++ docs/ru/index.md | 5 ++ docs/ru/interfaces/index.md | 6 ++ docs/ru/interfaces/third-party/index.md | 2 +- .../ru/interfaces/third-party/integrations.md | 70 ++++++++++--------- docs/ru/introduction/index.md | 2 +- docs/ru/operations/index.md | 6 ++ .../aggregate_functions/index.md | 6 ++ docs/ru/sql_reference/data_types/index.md | 6 ++ docs/ru/sql_reference/index.md | 7 ++ docs/ru/sql_reference/statements/alter.md | 5 ++ docs/ru/sql_reference/statements/create.md | 5 ++ docs/ru/sql_reference/statements/index.md | 2 +- .../sql_reference/statements/insert_into.md | 5 ++ docs/ru/sql_reference/statements/select.md | 5 ++ .../ru/sql_reference/table_functions/index.md | 6 ++ docs/ru/{ => whats_new}/extended_roadmap.md | 0 docs/ru/whats_new/index.md | 2 +- .../tr/interfaces/third-party/integrations.md | 3 + .../zh/interfaces/third-party/integrations.md | 61 ++++++++-------- 33 files changed, 212 insertions(+), 70 deletions(-) create mode 100644 docs/en/commercial/support.md rename docs/ru/{ => whats_new}/extended_roadmap.md (100%) diff --git a/docs/en/commercial/cloud.md b/docs/en/commercial/cloud.md index 3f7ead86219..5255d254100 100644 --- a/docs/en/commercial/cloud.md +++ b/docs/en/commercial/cloud.md @@ -1,3 +1,8 @@ +--- +toc_title: Cloud +toc_priority: 1 +--- + # ClickHouse Cloud Service Providers {#clickhouse-cloud-service-providers} !!! info "Info" diff --git a/docs/en/commercial/support.md b/docs/en/commercial/support.md new file mode 100644 index 00000000000..e7b4503a534 --- /dev/null +++ b/docs/en/commercial/support.md @@ -0,0 +1,21 @@ +--- +toc_title: Support +toc_priority: 3 +--- + +# ClickHouse Commercial Support Service Providers {#clickhouse-commercial-support-service-providers} + +!!! info "Info" + If you have launched a ClickHouse commercial support service, feel free to [open a pull-request](https://github.com/ClickHouse/ClickHouse/edit/master/docs/en/commercial/support.md) adding it to the following list. + +## Altinity {#altinity} + +[Service description](https://www.altinity.com/24x7-support) + +## Mafiree {#mafiree} + +[Service description](http://mafiree.com/clickhouse-analytics-services.php) + +## MinervaDB {#minervadb} + +[Service description](https://minervadb.com/index.php/clickhouse-consulting-and-support-by-minervadb/) diff --git a/docs/en/development/index.md b/docs/en/development/index.md index bb4158554d3..34329853509 100644 --- a/docs/en/development/index.md +++ b/docs/en/development/index.md @@ -1,5 +1,5 @@ --- -toc_folder_title: Development +toc_folder_title: Разработка toc_hidden: true toc_priority: 58 toc_title: hidden diff --git a/docs/en/interfaces/third-party/integrations.md b/docs/en/interfaces/third-party/integrations.md index ff0b7fe2e19..9f4b0f2fa65 100644 --- a/docs/en/interfaces/third-party/integrations.md +++ b/docs/en/interfaces/third-party/integrations.md @@ -24,7 +24,10 @@ toc_title: Integrations - [ClickHouseMigrator](https://github.com/zlzforever/ClickHouseMigrator) - Message queues - [Kafka](https://kafka.apache.org) - - [clickhouse\_sinker](https://github.com/housepower/clickhouse_sinker) (uses [Go client](https://github.com/kshvakov/clickhouse/)) + - [clickhouse\_sinker](https://github.com/housepower/clickhouse_sinker) (uses [Go client](https://github.com/ClickHouse/clickhouse-go/)) +- Stream processing + - [Flink](https://flink.apache.org) + - [flink-clickhouse-sink](https://github.com/ivi-ru/flink-clickhouse-sink) - Object storages - [S3](https://en.wikipedia.org/wiki/Amazon_S3) - [clickhouse-backup](https://github.com/AlexAkulov/clickhouse-backup) @@ -72,6 +75,9 @@ toc_title: Integrations - [sqlalchemy-clickhouse](https://github.com/cloudflare/sqlalchemy-clickhouse) (uses [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) - [pandas](https://pandas.pydata.org) - [pandahouse](https://github.com/kszucs/pandahouse) +- PHP + - [Doctrine](https://www.doctrine-project.org/) + - [dbal-clickhouse](https://packagist.org/packages/friendsofdoctrine/dbal-clickhouse) - R - [dplyr](https://db.rstudio.com/dplyr/) - [RClickHouse](https://github.com/IMSMWU/RClickHouse) (uses [clickhouse-cpp](https://github.com/artpaul/clickhouse-cpp)) diff --git a/docs/es/interfaces/third-party/integrations.md b/docs/es/interfaces/third-party/integrations.md index 00be86b187d..d706278a280 100644 --- a/docs/es/interfaces/third-party/integrations.md +++ b/docs/es/interfaces/third-party/integrations.md @@ -26,7 +26,10 @@ toc_title: "Integraci\xF3n" - [Método de codificación de datos:](https://github.com/zlzforever/ClickHouseMigrator) - Colas de mensajes - [Kafka](https://kafka.apache.org) - - [Método de codificación de datos:](https://github.com/housepower/clickhouse_sinker) (utilizar [Ir cliente](https://github.com/kshvakov/clickhouse/)) + - [clickhouse\_sinker](https://github.com/housepower/clickhouse_sinker) (usos [Go client](https://github.com/ClickHouse/clickhouse-go/)) +- Procesamiento de flujo + - [Flink](https://flink.apache.org) + - [flink-clickhouse-sink](https://github.com/ivi-ru/flink-clickhouse-sink) - Almacenamiento de objetos - [S3](https://en.wikipedia.org/wiki/Amazon_S3) - [Haga clic en el botón de copia de seguridad](https://github.com/AlexAkulov/clickhouse-backup) @@ -74,6 +77,9 @@ toc_title: "Integraci\xF3n" - [sqlalchemy-clickhouse](https://github.com/cloudflare/sqlalchemy-clickhouse) (utilizar [InformaciónSistema abierto.](https://github.com/Infinidat/infi.clickhouse_orm)) - [pandas](https://pandas.pydata.org) - [Pandahouse](https://github.com/kszucs/pandahouse) +- PHP + - [Doctrine](https://www.doctrine-project.org/) + - [dbal-clickhouse](https://packagist.org/packages/friendsofdoctrine/dbal-clickhouse) - R - [Dplyr](https://db.rstudio.com/dplyr/) - [Bienvenidos al Portal de Licitación Electrónica de Licitación Electrónica](https://github.com/IMSMWU/RClickhouse) (utilizar [Bienvenidos](https://github.com/artpaul/clickhouse-cpp)) diff --git a/docs/fa/interfaces/third-party/integrations.md b/docs/fa/interfaces/third-party/integrations.md index ddbdffad169..0ad13d1fd9e 100644 --- a/docs/fa/interfaces/third-party/integrations.md +++ b/docs/fa/interfaces/third-party/integrations.md @@ -74,6 +74,9 @@ toc_title: "\u06CC\u06A9\u067E\u0627\u0631\u0686\u06AF\u06CC" - [sqlalchemy-clickhouse](https://github.com/cloudflare/sqlalchemy-clickhouse) (استفاده [اطالعات.کلیک \_شورم](https://github.com/Infinidat/infi.clickhouse_orm)) - [پانداها](https://pandas.pydata.org) - [پانداهاوس](https://github.com/kszucs/pandahouse) +- PHP + - [Doctrine](https://www.doctrine-project.org/) + - [dbal-clickhouse](https://packagist.org/packages/friendsofdoctrine/dbal-clickhouse) - R - [هواپیمای دوباله](https://db.rstudio.com/dplyr/) - [خانه روستایی](https://github.com/IMSMWU/RClickhouse) (استفاده [صفحه اصلی](https://github.com/artpaul/clickhouse-cpp)) diff --git a/docs/fr/interfaces/third-party/integrations.md b/docs/fr/interfaces/third-party/integrations.md index 76648d8613d..565be2b9604 100644 --- a/docs/fr/interfaces/third-party/integrations.md +++ b/docs/fr/interfaces/third-party/integrations.md @@ -74,6 +74,9 @@ toc_title: "Int\xE9gration" - [sqlalchemy-clickhouse](https://github.com/cloudflare/sqlalchemy-clickhouse) (utiliser [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) - [Panda](https://pandas.pydata.org) - [pandahouse](https://github.com/kszucs/pandahouse) +- PHP + - [Doctrine](https://www.doctrine-project.org/) + - [dbal-clickhouse](https://packagist.org/packages/friendsofdoctrine/dbal-clickhouse) - R - [dplyr](https://db.rstudio.com/dplyr/) - [RClickhouse](https://github.com/IMSMWU/RClickhouse) (utiliser [clickhouse-cpp](https://github.com/artpaul/clickhouse-cpp)) diff --git a/docs/ja/interfaces/third-party/integrations.md b/docs/ja/interfaces/third-party/integrations.md index 7f5bfb93325..74d0a51e7de 100644 --- a/docs/ja/interfaces/third-party/integrations.md +++ b/docs/ja/interfaces/third-party/integrations.md @@ -74,6 +74,9 @@ toc_title: "\u7D71\u5408" - [sqlalchemy-clickhouse](https://github.com/cloudflare/sqlalchemy-clickhouse) (用途 [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) - [パンダ](https://pandas.pydata.org) - [パンダハウス](https://github.com/kszucs/pandahouse) +- PHP + - [Doctrine](https://www.doctrine-project.org/) + - [dbal-clickhouse](https://packagist.org/packages/friendsofdoctrine/dbal-clickhouse) - R - [dplyr](https://db.rstudio.com/dplyr/) - [Rクリックハウス](https://github.com/IMSMWU/RClickhouse) (用途 [クリックハウス-cpp](https://github.com/artpaul/clickhouse-cpp)) diff --git a/docs/redirects.txt b/docs/redirects.txt index 95df6773359..1a9455355db 100644 --- a/docs/redirects.txt +++ b/docs/redirects.txt @@ -43,6 +43,7 @@ dicts/external_dicts_dict_sources.md query_language/dicts/external_dicts_dict_so dicts/external_dicts_dict_structure.md query_language/dicts/external_dicts_dict_structure.md dicts/index.md query_language/dicts/index.md dicts/internal_dicts.md query_language/dicts/internal_dicts.md +extended_roadmap.md whats_new/extended_roadmap.md formats.md interfaces/formats.md formats/capnproto.md interfaces/formats.md formats/csv.md interfaces/formats.md diff --git a/docs/ru/commercial/index.md b/docs/ru/commercial/index.md index f9065c7cd50..dc78f6f4899 100644 --- a/docs/ru/commercial/index.md +++ b/docs/ru/commercial/index.md @@ -1,7 +1,7 @@ --- -toc_folder_title: Commercial +toc_folder_title: Коммерческие услуги toc_priority: 70 -toc_title: Commercial +toc_title: Коммерческие услуги --- diff --git a/docs/ru/engines/index.md b/docs/ru/engines/index.md index c4b0b299858..a3d85155cbb 100644 --- a/docs/ru/engines/index.md +++ b/docs/ru/engines/index.md @@ -1,5 +1,5 @@ --- -toc_folder_title: Engines +toc_folder_title: Движки toc_priority: 25 --- diff --git a/docs/ru/getting_started/example_datasets/index.md b/docs/ru/getting_started/example_datasets/index.md index c01f73ddc4d..5fbe0843f4b 100644 --- a/docs/ru/getting_started/example_datasets/index.md +++ b/docs/ru/getting_started/example_datasets/index.md @@ -1,3 +1,8 @@ +--- +toc_folder_title: Тестовые массивы данных +toc_priority: 12 +toc_title: Обзор +--- # Тестовые массивы данных Этот раздел описывает как получить тестовые массивы данных и загрузить их в ClickHouse. diff --git a/docs/ru/getting_started/index.md b/docs/ru/getting_started/index.md index aa126f7b697..7711d6b94ee 100644 --- a/docs/ru/getting_started/index.md +++ b/docs/ru/getting_started/index.md @@ -1,3 +1,10 @@ +--- +toc_folder_title: Начало работы +toc_hidden: true +toc_priority: 8 +toc_title: hidden +--- + # Начало работы {#nachalo-raboty} Если вы новичок в ClickHouse и хотите вживую оценить его производительность, прежде всего нужно пройти через [процесс установки](install.md). diff --git a/docs/ru/guides/index.md b/docs/ru/guides/index.md index 1ece4b22b85..2ba84e9afc2 100644 --- a/docs/ru/guides/index.md +++ b/docs/ru/guides/index.md @@ -1,3 +1,9 @@ +--- +toc_folder_title: Руководства +toc_priority: 38 +toc_title: Обзор +--- + # Руководства {#rukovodstva} Подробные пошаговые инструкции, которые помогут вам решать различные задачи с помощью ClickHouse. diff --git a/docs/ru/index.md b/docs/ru/index.md index c49c33adf6f..4636c2cb5df 100644 --- a/docs/ru/index.md +++ b/docs/ru/index.md @@ -1,3 +1,8 @@ +--- +toc_priority: 0 +toc_title: Обзор +--- + # Что такое ClickHouse {#chto-takoe-clickhouse} ClickHouse - столбцовая система управления базами данных (СУБД) для онлайн обработки аналитических запросов (OLAP). diff --git a/docs/ru/interfaces/index.md b/docs/ru/interfaces/index.md index 8f5a2e5f073..be49e640132 100644 --- a/docs/ru/interfaces/index.md +++ b/docs/ru/interfaces/index.md @@ -1,3 +1,9 @@ +--- +toc_folder_title: Интерфейсы +toc_priority: 14 +toc_title: Введение +--- + # Интерфейсы {#interfaces} ClickHouse предоставляет два сетевых интерфейса (оба могут быть дополнительно обернуты в TLS для дополнительной безопасности): diff --git a/docs/ru/interfaces/third-party/index.md b/docs/ru/interfaces/third-party/index.md index 16d315d059c..8e768ad9d8e 100644 --- a/docs/ru/interfaces/third-party/index.md +++ b/docs/ru/interfaces/third-party/index.md @@ -1,5 +1,5 @@ --- -toc_folder_title: Third-Party +toc_folder_title: От сторонних разработчиков toc_priority: 24 --- diff --git a/docs/ru/interfaces/third-party/integrations.md b/docs/ru/interfaces/third-party/integrations.md index c05ff4d062f..d16404e2f27 100644 --- a/docs/ru/interfaces/third-party/integrations.md +++ b/docs/ru/interfaces/third-party/integrations.md @@ -7,66 +7,72 @@ - Реляционные системы управления базами данных - [MySQL](https://www.mysql.com) - - [ProxySQL](https://github.com/sysown/proxysql/wiki/ClickHouse-Support) - - [clickhouse-mysql-data-reader](https://github.com/Altinity/clickhouse-mysql-data-reader) - - [horgh-replicator](https://github.com/larsnovikov/horgh-replicator) + - [ProxySQL](https://github.com/sysown/proxysql/wiki/ClickHouse-Support) + - [clickhouse-mysql-data-reader](https://github.com/Altinity/clickhouse-mysql-data-reader) + - [horgh-replicator](https://github.com/larsnovikov/horgh-replicator) - [PostgreSQL](https://www.postgresql.org) - - [clickhousedb\_fdw](https://github.com/Percona-Lab/clickhousedb_fdw) - - [infi.clickhouse\_fdw](https://github.com/Infinidat/infi.clickhouse_fdw) (использует [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) - - [pg2ch](https://github.com/mkabilov/pg2ch) - - [clickhouse\_fdw](https://github.com/adjust/clickhouse_fdw) + - [clickhousedb\_fdw](https://github.com/Percona-Lab/clickhousedb_fdw) + - [infi.clickhouse\_fdw](https://github.com/Infinidat/infi.clickhouse_fdw) (использует [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) + - [pg2ch](https://github.com/mkabilov/pg2ch) + - [clickhouse\_fdw](https://github.com/adjust/clickhouse_fdw) - [MSSQL](https://en.wikipedia.org/wiki/Microsoft_SQL_Server) - - [ClickHouseMightrator](https://github.com/zlzforever/ClickHouseMigrator) + - [ClickHouseMightrator](https://github.com/zlzforever/ClickHouseMigrator) - Очереди сообщений - [Kafka](https://kafka.apache.org) - - [clickhouse\_sinker](https://github.com/housepower/clickhouse_sinker) (использует [Go client](https://github.com/kshvakov/clickhouse/)) + - [clickhouse\_sinker](https://github.com/housepower/clickhouse_sinker) (использует [Go client](https://github.com/ClickHouse/clickhouse-go/)) +- Потоковая обработка + - [Flink](https://flink.apache.org) + - [flink-clickhouse-sink](https://github.com/ivi-ru/flink-clickhouse-sink) - Хранилища объектов - [S3](https://en.wikipedia.org/wiki/Amazon_S3) - - [clickhouse-backup](https://github.com/AlexAkulov/clickhouse-backup) + - [clickhouse-backup](https://github.com/AlexAkulov/clickhouse-backup) - Оркестрация контейнеров - [Kubernetes](https://kubernetes.io) - - [clickhouse-operator](https://github.com/Altinity/clickhouse-operator) + - [clickhouse-operator](https://github.com/Altinity/clickhouse-operator) - Системы управления конфигурацией - [puppet](https://puppet.com) - - [innogames/clickhouse](https://forge.puppet.com/innogames/clickhouse) - - [mfedotov/clickhouse](https://forge.puppet.com/mfedotov/clickhouse) + - [innogames/clickhouse](https://forge.puppet.com/innogames/clickhouse) + - [mfedotov/clickhouse](https://forge.puppet.com/mfedotov/clickhouse) - Мониторинг - [Graphite](https://graphiteapp.org) - - [graphouse](https://github.com/yandex/graphouse) - - [carbon-clickhouse](https://github.com/lomik/carbon-clickhouse) + - - [graphite-clickhouse](https://github.com/lomik/graphite-clickhouse) - - [graphite-ch-optimizer](https://github.com/innogames/graphite-ch-optimizer) - оптимизирует партиции таблиц [\*GraphiteMergeTree](../../engines/table_engines/mergetree_family/graphitemergetree.md#graphitemergetree) согласно правилам в [конфигурации rollup](../../engines/table_engines/mergetree_family/graphitemergetree.md#rollup-configuration) + - [graphouse](https://github.com/yandex/graphouse) + - [carbon-clickhouse](https://github.com/lomik/carbon-clickhouse) + + - [graphite-clickhouse](https://github.com/lomik/graphite-clickhouse) + - [graphite-ch-optimizer](https://github.com/innogames/graphite-ch-optimizer) - оптимизирует партиции таблиц [\*GraphiteMergeTree](../../engines/table_engines/mergetree_family/graphitemergetree.md#graphitemergetree) согласно правилам в [конфигурации rollup](../../engines/table_engines/mergetree_family/graphitemergetree.md#rollup-configuration) - [Grafana](https://grafana.com/) - - [clickhouse-grafana](https://github.com/Vertamedia/clickhouse-grafana) + - [clickhouse-grafana](https://github.com/Vertamedia/clickhouse-grafana) - [Prometheus](https://prometheus.io/) - - [clickhouse\_exporter](https://github.com/f1yegor/clickhouse_exporter) - - [PromHouse](https://github.com/Percona-Lab/PromHouse) - - [clickhouse\_exporter](https://github.com/hot-wifi/clickhouse_exporter) (использует [Go client](https://github.com/kshvakov/clickhouse/)) + - [clickhouse\_exporter](https://github.com/f1yegor/clickhouse_exporter) + - [PromHouse](https://github.com/Percona-Lab/PromHouse) + - [clickhouse\_exporter](https://github.com/hot-wifi/clickhouse_exporter) (использует [Go client](https://github.com/kshvakov/clickhouse/)) - [Nagios](https://www.nagios.org/) - - [check\_clickhouse](https://github.com/exogroup/check_clickhouse/) - - [check\_clickhouse.py](https://github.com/innogames/igmonplugins/blob/master/src/check_clickhouse.py) + - [check\_clickhouse](https://github.com/exogroup/check_clickhouse/) + - [check\_clickhouse.py](https://github.com/innogames/igmonplugins/blob/master/src/check_clickhouse.py) - [Zabbix](https://www.zabbix.com) - - [clickhouse-zabbix-template](https://github.com/Altinity/clickhouse-zabbix-template) + - [clickhouse-zabbix-template](https://github.com/Altinity/clickhouse-zabbix-template) - [Sematext](https://sematext.com/) - - [clickhouse интеграция](https://github.com/sematext/sematext-agent-integrations/tree/master/clickhouse) + - [clickhouse интеграция](https://github.com/sematext/sematext-agent-integrations/tree/master/clickhouse) - Логирование - [rsyslog](https://www.rsyslog.com/) - - [omclickhouse](https://www.rsyslog.com/doc/master/configuration/modules/omclickhouse.html) + - [omclickhouse](https://www.rsyslog.com/doc/master/configuration/modules/omclickhouse.html) - [fluentd](https://www.fluentd.org) - - [loghouse](https://github.com/flant/loghouse) (для [Kubernetes](https://kubernetes.io)) - - [logagent](https://www.sematext.com/logagent) - - [logagent output-plugin-clickhouse](https://sematext.com/docs/logagent/output-plugin-clickhouse/) + - [loghouse](https://github.com/flant/loghouse) (для [Kubernetes](https://kubernetes.io)) + - [Sematext](https://www.sematext.com/logagent) + - [logagent output-plugin-clickhouse](https://sematext.com/docs/logagent/output-plugin-clickhouse/) - Гео - [MaxMind](https://dev.maxmind.com/geoip/) - - [clickhouse-maxmind-geoip](https://github.com/AlexeyKupershtokh/clickhouse-maxmind-geoip) + - [clickhouse-maxmind-geoip](https://github.com/AlexeyKupershtokh/clickhouse-maxmind-geoip) ## Экосистемы вокруг языков программирования {#ekosistemy-vokrug-iazykov-programmirovaniia} - Python - [SQLAlchemy](https://www.sqlalchemy.org) - - [sqlalchemy-clickhouse](https://github.com/cloudflare/sqlalchemy-clickhouse) (использует [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) + - [sqlalchemy-clickhouse](https://github.com/cloudflare/sqlalchemy-clickhouse) (использует [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) - [pandas](https://pandas.pydata.org) - - [pandahouse](https://github.com/kszucs/pandahouse) + - [pandahouse](https://github.com/kszucs/pandahouse) +- PHP + - [Doctrine](https://www.doctrine-project.org/) + - [dbal-clickhouse](https://packagist.org/packages/friendsofdoctrine/dbal-clickhouse) - R - [dplyr](https://db.rstudio.com/dplyr/) - [RClickhouse](https://github.com/IMSMWU/RClickhouse) (использует [clickhouse-cpp](https://github.com/artpaul/clickhouse-cpp)) diff --git a/docs/ru/introduction/index.md b/docs/ru/introduction/index.md index ba80f9c2640..5479b37428f 100644 --- a/docs/ru/introduction/index.md +++ b/docs/ru/introduction/index.md @@ -1,5 +1,5 @@ --- -toc_folder_title: Introduction +toc_folder_title: Введение toc_priority: 1 --- diff --git a/docs/ru/operations/index.md b/docs/ru/operations/index.md index 3df5dbb1f7e..babb22cd8b4 100644 --- a/docs/ru/operations/index.md +++ b/docs/ru/operations/index.md @@ -1,3 +1,9 @@ +--- +toc_folder_title: Эксплуатация +toc_priority: 41 +toc_title: Введение +--- + # Эксплуатация {#ekspluatatsiia} Руководство по эксплуатации ClickHouse состоит из следующих основных разделов: diff --git a/docs/ru/sql_reference/aggregate_functions/index.md b/docs/ru/sql_reference/aggregate_functions/index.md index e0c07a1c95e..d28e105f6fc 100644 --- a/docs/ru/sql_reference/aggregate_functions/index.md +++ b/docs/ru/sql_reference/aggregate_functions/index.md @@ -1,3 +1,9 @@ +--- +toc_folder_title: Агрегатные функции +toc_priority: 33 +toc_title: Введение +--- + # Агрегатные функции {#aggregate-functions} Агрегатные функции работают в [привычном](http://www.sql-tutorial.com/sql-aggregate-functions-sql-tutorial) для специалистов по базам данных смысле. diff --git a/docs/ru/sql_reference/data_types/index.md b/docs/ru/sql_reference/data_types/index.md index a362b4708e6..1fd52b9bf9e 100644 --- a/docs/ru/sql_reference/data_types/index.md +++ b/docs/ru/sql_reference/data_types/index.md @@ -1,3 +1,9 @@ +--- +toc_folder_title: Типы данных +toc_priority: 37 +toc_title: Введение +--- + # Типы данных {#data_types} ClickHouse может сохранять в ячейках таблиц данные различных типов. diff --git a/docs/ru/sql_reference/index.md b/docs/ru/sql_reference/index.md index ca35c14a547..ca21b0df3ed 100644 --- a/docs/ru/sql_reference/index.md +++ b/docs/ru/sql_reference/index.md @@ -1,3 +1,10 @@ +--- +toc_folder_title: Справка по SQL +toc_hidden: true +toc_priority: 28 +toc_title: hidden +--- + # Справка по SQL {#spravka-po-sql} - [SELECT](statements/select.md) diff --git a/docs/ru/sql_reference/statements/alter.md b/docs/ru/sql_reference/statements/alter.md index bc06fe074d2..5c08d68623e 100644 --- a/docs/ru/sql_reference/statements/alter.md +++ b/docs/ru/sql_reference/statements/alter.md @@ -1,3 +1,8 @@ +--- +toc_priority: 36 +toc_title: ALTER +--- + ## ALTER {#query_language_queries_alter} Запрос `ALTER` поддерживается только для таблиц типа `*MergeTree`, а также `Merge` и `Distributed`. Запрос имеет несколько вариантов. diff --git a/docs/ru/sql_reference/statements/create.md b/docs/ru/sql_reference/statements/create.md index 7a5e3c9dc08..e09877d3495 100644 --- a/docs/ru/sql_reference/statements/create.md +++ b/docs/ru/sql_reference/statements/create.md @@ -1,3 +1,8 @@ +--- +toc_priority: 35 +toc_title: CREATE +--- + ## CREATE DATABASE {#query-language-create-database} Создает базу данных. diff --git a/docs/ru/sql_reference/statements/index.md b/docs/ru/sql_reference/statements/index.md index 1adf93a153e..5b461b73c92 100644 --- a/docs/ru/sql_reference/statements/index.md +++ b/docs/ru/sql_reference/statements/index.md @@ -1,5 +1,5 @@ --- -toc_folder_title: Statements +toc_folder_title: Выражения toc_priority: 31 --- diff --git a/docs/ru/sql_reference/statements/insert_into.md b/docs/ru/sql_reference/statements/insert_into.md index ed07d6d3b1c..e9c80466a58 100644 --- a/docs/ru/sql_reference/statements/insert_into.md +++ b/docs/ru/sql_reference/statements/insert_into.md @@ -1,3 +1,8 @@ +--- +toc_priority: 34 +toc_title: INSERT INTO +--- + ## INSERT {#insert} Добавление данных. diff --git a/docs/ru/sql_reference/statements/select.md b/docs/ru/sql_reference/statements/select.md index bd9dc21e2aa..2ceeb3489c2 100644 --- a/docs/ru/sql_reference/statements/select.md +++ b/docs/ru/sql_reference/statements/select.md @@ -1,3 +1,8 @@ +--- +toc_priority: 33 +toc_title: SELECT +--- + # Синтаксис запросов SELECT {#sintaksis-zaprosov-select} `SELECT` осуществляет выборку данных. diff --git a/docs/ru/sql_reference/table_functions/index.md b/docs/ru/sql_reference/table_functions/index.md index f0e465c5cb0..70c701d1713 100644 --- a/docs/ru/sql_reference/table_functions/index.md +++ b/docs/ru/sql_reference/table_functions/index.md @@ -1,3 +1,9 @@ +--- +toc_folder_title: Табличные функции +toc_priority: 34 +toc_title: Введение +--- + # Табличные функции {#tablichnye-funktsii} Табличные функции — это метод создания таблиц. diff --git a/docs/ru/extended_roadmap.md b/docs/ru/whats_new/extended_roadmap.md similarity index 100% rename from docs/ru/extended_roadmap.md rename to docs/ru/whats_new/extended_roadmap.md diff --git a/docs/ru/whats_new/index.md b/docs/ru/whats_new/index.md index 0901166b887..b97b3623a9e 100644 --- a/docs/ru/whats_new/index.md +++ b/docs/ru/whats_new/index.md @@ -1,5 +1,5 @@ --- -toc_folder_title: What's New +toc_folder_title: Что нового? toc_priority: 72 --- diff --git a/docs/tr/interfaces/third-party/integrations.md b/docs/tr/interfaces/third-party/integrations.md index ecb6662d0e8..2216e68a4c4 100644 --- a/docs/tr/interfaces/third-party/integrations.md +++ b/docs/tr/interfaces/third-party/integrations.md @@ -74,6 +74,9 @@ toc_title: Entegrasyonlar - [sqlalchemy-clickhouse](https://github.com/cloudflare/sqlalchemy-clickhouse) (kullanma [ınfi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) - [Pandalar](https://pandas.pydata.org) - [pandahouse](https://github.com/kszucs/pandahouse) +- PHP + - [Doctrine](https://www.doctrine-project.org/) + - [dbal-clickhouse](https://packagist.org/packages/friendsofdoctrine/dbal-clickhouse) - R - [dplyr](https://db.rstudio.com/dplyr/) - [RClickHouse](https://github.com/IMSMWU/RClickHouse) (kullanma [clickhouse-cpp](https://github.com/artpaul/clickhouse-cpp)) diff --git a/docs/zh/interfaces/third-party/integrations.md b/docs/zh/interfaces/third-party/integrations.md index aac3d7a1b11..128a4060c2d 100644 --- a/docs/zh/interfaces/third-party/integrations.md +++ b/docs/zh/interfaces/third-party/integrations.md @@ -1,4 +1,3 @@ - # 第三方集成库 {#di-san-fang-ji-cheng-ku} !!! warning "声明" @@ -8,18 +7,21 @@ - 关系数据库管理系统 - [MySQL](https://www.mysql.com) - - [ProxySQL](https://github.com/sysown/proxysql/wiki/ClickHouse-Support) - - [clickhouse-mysql-data-reader](https://github.com/Altinity/clickhouse-mysql-data-reader) - - [horgh-复制器](https://github.com/larsnovikov/horgh-replicator) + - [ProxySQL](https://github.com/sysown/proxysql/wiki/ClickHouse-Support) + - [clickhouse-mysql-data-reader](https://github.com/Altinity/clickhouse-mysql-data-reader) + - [horgh-复制器](https://github.com/larsnovikov/horgh-replicator) - [PostgreSQL](https://www.postgresql.org) - - [clickhousedb\_fdw](https://github.com/Percona-Lab/clickhousedb_fdw) - - [infi.clickhouse\_fdw](https://github.com/Infinidat/infi.clickhouse_fdw) (使用 [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) - - [pg2ch](https://github.com/mkabilov/pg2ch) + - [clickhousedb\_fdw](https://github.com/Percona-Lab/clickhousedb_fdw) + - [infi.clickhouse\_fdw](https://github.com/Infinidat/infi.clickhouse_fdw) (使用 [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) + - [pg2ch](https://github.com/mkabilov/pg2ch) - [MSSQL](https://en.wikipedia.org/wiki/Microsoft_SQL_Server) - - [ClickHouseMightrator](https://github.com/zlzforever/ClickHouseMigrator) + - [ClickHouseMightrator](https://github.com/zlzforever/ClickHouseMigrator) - 消息队列 - [卡夫卡](https://kafka.apache.org) - - [clickhouse\_sinker](https://github.com/housepower/clickhouse_sinker) (使用 [去客户](https://github.com/kshvakov/clickhouse/)) + - [clickhouse\_sinker](https://github.com/housepower/clickhouse_sinker) (使用 [去客户](https://github.com/ClickHouse/clickhouse-go/)) +- 流处理 + - [Flink](https://flink.apache.org) + - [flink-clickhouse-sink](https://github.com/ivi-ru/flink-clickhouse-sink) - 对象存储 - [S3](https://en.wikipedia.org/wiki/Amazon_S3) - [ﾂ环板backupｮﾂ嘉ｯﾂ偲](https://github.com/AlexAkulov/clickhouse-backup) @@ -32,41 +34,44 @@ - [mfedotov/clickhouse](https://forge.puppet.com/mfedotov/clickhouse) - 监控 - [石墨](https://graphiteapp.org) - - [graphouse](https://github.com/yandex/graphouse) - - [ﾂ暗ｪﾂ氾环催ﾂ団](https://github.com/lomik/carbon-clickhouse) + - - [ﾂ环板-ｮﾂ嘉ｯﾂ偲](https://github.com/lomik/graphite-clickhouse) - - [石墨-ch-optimizer](https://github.com/innogames/graphite-ch-optimizer) -优化静态分区 [\*GraphiteMergeTree](../../engines/table_engines/mergetree_family/graphitemergetree.md#graphitemergetree) 如果从规则 [汇总配置](../../engines/table_engines/mergetree_family/graphitemergetree.md#rollup-configuration) 可以应用 + - [graphouse](https://github.com/yandex/graphouse) + - [ﾂ暗ｪﾂ氾环催ﾂ団](https://github.com/lomik/carbon-clickhouse) + + - [ﾂ环板-ｮﾂ嘉ｯﾂ偲](https://github.com/lomik/graphite-clickhouse) + - [石墨-ch-optimizer](https://github.com/innogames/graphite-ch-optimizer) -优化静态分区 [\*GraphiteMergeTree](../../engines/table_engines/mergetree_family/graphitemergetree.md#graphitemergetree) 如果从规则 [汇总配置](../../engines/table_engines/mergetree_family/graphitemergetree.md#rollup-configuration) 可以应用 - [Grafana](https://grafana.com/) - - [clickhouse-grafana](https://github.com/Vertamedia/clickhouse-grafana) + - [clickhouse-grafana](https://github.com/Vertamedia/clickhouse-grafana) - [普罗米修斯号](https://prometheus.io/) - - [clickhouse\_exporter](https://github.com/f1yegor/clickhouse_exporter) - - [PromHouse](https://github.com/Percona-Lab/PromHouse) - - [clickhouse\_exporter](https://github.com/hot-wifi/clickhouse_exporter) （用途 [去客户](https://github.com/kshvakov/clickhouse/)) + - [clickhouse\_exporter](https://github.com/f1yegor/clickhouse_exporter) + - [PromHouse](https://github.com/Percona-Lab/PromHouse) + - [clickhouse\_exporter](https://github.com/hot-wifi/clickhouse_exporter) （用途 [去客户](https://github.com/kshvakov/clickhouse/)) - [Nagios](https://www.nagios.org/) - - [check\_clickhouse](https://github.com/exogroup/check_clickhouse/) - - [check\_clickhouse.py](https://github.com/innogames/igmonplugins/blob/master/src/check_clickhouse.py) + - [check\_clickhouse](https://github.com/exogroup/check_clickhouse/) + - [check\_clickhouse.py](https://github.com/innogames/igmonplugins/blob/master/src/check_clickhouse.py) - [Zabbix](https://www.zabbix.com) - - [ﾂ暗ｪﾂ氾环催ﾂ団ﾂ法ﾂ人](https://github.com/Altinity/clickhouse-zabbix-template) + - [ﾂ暗ｪﾂ氾环催ﾂ団ﾂ法ﾂ人](https://github.com/Altinity/clickhouse-zabbix-template) - [Sematext](https://sematext.com/) - - [clickhouse积分](https://github.com/sematext/sematext-agent-integrations/tree/master/clickhouse) + - [clickhouse积分](https://github.com/sematext/sematext-agent-integrations/tree/master/clickhouse) - 记录 - [rsyslog](https://www.rsyslog.com/) - - [鹿茫house om omhousehousehousehouse酶](https://www.rsyslog.com/doc/master/configuration/modules/omclickhouse.html) + - [鹿茫house omhousee酶](https://www.rsyslog.com/doc/master/configuration/modules/omclickhouse.html) - [fluentd](https://www.fluentd.org) - - [loghouse](https://github.com/flant/loghouse) (对于 [Kubernetes](https://kubernetes.io)) - - [logagent](https://www.sematext.com/logagent) - - [logagent输出-插件-clickhouse](https://sematext.com/docs/logagent/output-plugin-clickhouse/) + - [loghouse](https://github.com/flant/loghouse) (对于 [Kubernetes](https://kubernetes.io)) + - [Sematext](https://www.sematext.com/logagent) + - [logagent输出-插件-clickhouse](https://sematext.com/docs/logagent/output-plugin-clickhouse/) - 地理 - [MaxMind](https://dev.maxmind.com/geoip/) - - [ﾂ环板-ｮﾂ嘉ｯﾂ偲青clickｼﾂ氾ｶﾂ鉄ﾂ工ﾂ渉](https://github.com/AlexeyKupershtokh/clickhouse-maxmind-geoip) + - [ﾂ环板-ｮﾂ嘉ｯﾂ偲青clickｼﾂ氾ｶﾂ鉄ﾂ工ﾂ渉](https://github.com/AlexeyKupershtokh/clickhouse-maxmind-geoip) ## 编程语言生态系统 {#bian-cheng-yu-yan-sheng-tai-xi-tong} - Python - [SQLAlchemy](https://www.sqlalchemy.org) - - [ﾂ暗ｪﾂ氾环催ﾂ団ﾂ法ﾂ人](https://github.com/cloudflare/sqlalchemy-clickhouse) (使用 [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) + - [ﾂ暗ｪﾂ氾环催ﾂ団ﾂ法ﾂ人](https://github.com/cloudflare/sqlalchemy-clickhouse) (使用 [infi.clickhouse\_orm](https://github.com/Infinidat/infi.clickhouse_orm)) - [熊猫](https://pandas.pydata.org) - - [pandahouse](https://github.com/kszucs/pandahouse) + - [pandahouse](https://github.com/kszucs/pandahouse) +- PHP + - [Doctrine](https://www.doctrine-project.org/) + - [dbal-clickhouse](https://packagist.org/packages/friendsofdoctrine/dbal-clickhouse) - R - [dplyr](https://db.rstudio.com/dplyr/) - [RClickhouse](https://github.com/IMSMWU/RClickhouse) (使用 [ﾂ暗ｪﾂ氾环催ﾂ団](https://github.com/artpaul/clickhouse-cpp)) From dc247ed01141d5b7fac05811d5e95c71fd298347 Mon Sep 17 00:00:00 2001 From: alesapin Date: Thu, 16 Apr 2020 16:16:50 +0300 Subject: [PATCH 59/73] Add special key to dupload which allows to push .deb package to several branches in repo --- utils/release/push_packages | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/utils/release/push_packages b/utils/release/push_packages index 4a0548bb4ca..68d72bb39fe 100755 --- a/utils/release/push_packages +++ b/utils/release/push_packages @@ -152,7 +152,7 @@ def transfer_packages_dupload(ssh_key, path, repo_user, repo_url, incoming_direc } with DebRelease(config, repo_user, ssh_key): logging.info("Duploading") - subprocess.check_call("dupload --nomail --to {repo} {path}".format(repo=repo_short_name, path=path), shell=True) + subprocess.check_call("dupload -f --nomail --to {repo} {path}".format(repo=repo_short_name, path=path), shell=True) logging.info("Dupload finished") From 605f3b211999e8bc4dddb764782e0d3d5ee4e496 Mon Sep 17 00:00:00 2001 From: Alexander Tokmakov Date: Thu, 16 Apr 2020 18:30:18 +0300 Subject: [PATCH 60/73] fix DROP vs OPTIMIZE race in ReplicatedMergeTree --- src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp | 3 +++ src/Storages/MergeTree/ReplicatedMergeTreeQueue.h | 3 +++ src/Storages/StorageReplicatedMergeTree.cpp | 10 ++++++++-- ...00993_system_parts_race_condition_drop_zookeeper.sh | 8 ++++---- 4 files changed, 18 insertions(+), 6 deletions(-) diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp b/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp index bebb6ee79c3..72044ab832c 100644 --- a/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp +++ b/src/Storages/MergeTree/ReplicatedMergeTreeQueue.cpp @@ -16,6 +16,7 @@ namespace ErrorCodes extern const int LOGICAL_ERROR; extern const int UNEXPECTED_NODE_IN_ZOOKEEPER; extern const int UNFINISHED; + extern const int ABORTED; } @@ -426,6 +427,8 @@ bool ReplicatedMergeTreeQueue::removeFromVirtualParts(const MergeTreePartInfo & void ReplicatedMergeTreeQueue::pullLogsToQueue(zkutil::ZooKeeperPtr zookeeper, Coordination::WatchCallback watch_callback) { std::lock_guard lock(pull_logs_to_queue_mutex); + if (pull_log_blocker.isCancelled()) + throw Exception("Log pulling is cancelled", ErrorCodes::ABORTED); String index_str = zookeeper->get(replica_path + "/log_pointer"); UInt64 index; diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeQueue.h b/src/Storages/MergeTree/ReplicatedMergeTreeQueue.h index fcb3dfb4b86..2191104a291 100644 --- a/src/Storages/MergeTree/ReplicatedMergeTreeQueue.h +++ b/src/Storages/MergeTree/ReplicatedMergeTreeQueue.h @@ -356,6 +356,9 @@ public: /// A blocker that stops selects from the queue ActionBlocker actions_blocker; + /// A blocker that stops pulling entries from replication log to queue + ActionBlocker pull_log_blocker; + /// Adds a subscriber SubscriberHandler addSubscriber(SubscriberCallBack && callback); diff --git a/src/Storages/StorageReplicatedMergeTree.cpp b/src/Storages/StorageReplicatedMergeTree.cpp index a19a424c643..3f907541a3c 100644 --- a/src/Storages/StorageReplicatedMergeTree.cpp +++ b/src/Storages/StorageReplicatedMergeTree.cpp @@ -300,8 +300,6 @@ StorageReplicatedMergeTree::StorageReplicatedMergeTree( } createNewZooKeeperNodes(); - - } @@ -2905,6 +2903,7 @@ void StorageReplicatedMergeTree::shutdown() fetcher.blocker.cancelForever(); merger_mutator.merges_blocker.cancelForever(); parts_mover.moves_blocker.cancelForever(); + queue.pull_log_blocker.cancelForever(); restarting_thread.shutdown(); @@ -3641,7 +3640,11 @@ void StorageReplicatedMergeTree::drop(TableStructureWriteLockHolder &) LOG_INFO(log, "Removing replica " << replica_path); replica_is_active_node = nullptr; + /// It may left some garbage if replica_path subtree are concurently modified zookeeper->tryRemoveRecursive(replica_path); + if (zookeeper->exists(replica_path)) + LOG_ERROR(log, "Replica was not completely removed from ZooKeeper, " + << replica_path << " still exists and may contain some garbage."); /// Check that `zookeeper_path` exists: it could have been deleted by another replica after execution of previous line. Strings replicas; @@ -3649,6 +3652,9 @@ void StorageReplicatedMergeTree::drop(TableStructureWriteLockHolder &) { LOG_INFO(log, "Removing table " << zookeeper_path << " (this might take several minutes)"); zookeeper->tryRemoveRecursive(zookeeper_path); + if (zookeeper->exists(zookeeper_path)) + LOG_ERROR(log, "Table was not completely removed from ZooKeeper, " + << zookeeper_path << " still exists and may contain some garbage."); } } diff --git a/tests/queries/0_stateless/00993_system_parts_race_condition_drop_zookeeper.sh b/tests/queries/0_stateless/00993_system_parts_race_condition_drop_zookeeper.sh index 2d458ba7e28..01127a3ef7b 100755 --- a/tests/queries/0_stateless/00993_system_parts_race_condition_drop_zookeeper.sh +++ b/tests/queries/0_stateless/00993_system_parts_race_condition_drop_zookeeper.sh @@ -72,28 +72,28 @@ timeout $TIMEOUT bash -c thread2 2> /dev/null & timeout $TIMEOUT bash -c thread3 2> /dev/null & timeout $TIMEOUT bash -c thread4 2> /dev/null & timeout $TIMEOUT bash -c thread5 2> /dev/null & -timeout $TIMEOUT bash -c thread6 2> /dev/null & +timeout $TIMEOUT bash -c thread6 2>&1 | grep "was not completely removed from ZooKeeper" & timeout $TIMEOUT bash -c thread1 2> /dev/null & timeout $TIMEOUT bash -c thread2 2> /dev/null & timeout $TIMEOUT bash -c thread3 2> /dev/null & timeout $TIMEOUT bash -c thread4 2> /dev/null & timeout $TIMEOUT bash -c thread5 2> /dev/null & -timeout $TIMEOUT bash -c thread6 2> /dev/null & +timeout $TIMEOUT bash -c thread6 2>&1 | grep "was not completely removed from ZooKeeper" & timeout $TIMEOUT bash -c thread1 2> /dev/null & timeout $TIMEOUT bash -c thread2 2> /dev/null & timeout $TIMEOUT bash -c thread3 2> /dev/null & timeout $TIMEOUT bash -c thread4 2> /dev/null & timeout $TIMEOUT bash -c thread5 2> /dev/null & -timeout $TIMEOUT bash -c thread6 2> /dev/null & +timeout $TIMEOUT bash -c thread6 2>&1 | grep "was not completely removed from ZooKeeper" & timeout $TIMEOUT bash -c thread1 2> /dev/null & timeout $TIMEOUT bash -c thread2 2> /dev/null & timeout $TIMEOUT bash -c thread3 2> /dev/null & timeout $TIMEOUT bash -c thread4 2> /dev/null & timeout $TIMEOUT bash -c thread5 2> /dev/null & -timeout $TIMEOUT bash -c thread6 2> /dev/null & +timeout $TIMEOUT bash -c thread6 2>&1 | grep "was not completely removed from ZooKeeper" & wait From 3de1a36b33e91327b67bf9e13c5629d0fdaa4822 Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Thu, 16 Apr 2020 18:55:39 +0300 Subject: [PATCH 61/73] Update ya.make --- src/Common/ya.make | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Common/ya.make b/src/Common/ya.make index 53155ac471f..eece911d2b8 100644 --- a/src/Common/ya.make +++ b/src/Common/ya.make @@ -22,9 +22,9 @@ CFLAGS (GLOBAL -DDBMS_NAME=\"ClickHouse\") CFLAGS (GLOBAL -DDBMS_VERSION_MAJOR=0) CFLAGS (GLOBAL -DDBMS_VERSION_MINOR=0) CFLAGS (GLOBAL -DDBMS_VERSION_PATCH=0) -CFLAGS (GLOBAL -DVERSION_FULL=\"Clickhouse\") +CFLAGS (GLOBAL -DVERSION_FULL=\"ClickHouse\") CFLAGS (GLOBAL -DVERSION_INTEGER=0) -CFLAGS (GLOBAL -DVERSION_NAME=\"Clickhouse\") +CFLAGS (GLOBAL -DVERSION_NAME=\"ClickHouse\") CFLAGS (GLOBAL -DVERSION_OFFICIAL=\"\\\(arcadia\\\)\") CFLAGS (GLOBAL -DVERSION_REVISION=0) CFLAGS (GLOBAL -DVERSION_STRING=\"Unknown\") From 15dc45b9b25246f03e11138fd711f3f423f55461 Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Thu, 16 Apr 2020 19:44:49 +0300 Subject: [PATCH 62/73] Update extended_roadmap.md --- docs/ru/whats_new/extended_roadmap.md | 8 +------- 1 file changed, 1 insertion(+), 7 deletions(-) diff --git a/docs/ru/whats_new/extended_roadmap.md b/docs/ru/whats_new/extended_roadmap.md index 135a49ca8fb..219eb188e8f 100644 --- a/docs/ru/whats_new/extended_roadmap.md +++ b/docs/ru/whats_new/extended_roadmap.md @@ -15,9 +15,7 @@ Задача «normalized z-Order curve» в перспективе может быть полезна для БК и Метрики, так как позволяет смешивать OrderID и PageID и избежать дублирования данных. В задаче также вводится способ индексации путём обращения функции нескольких аргументов на интервале, что имеет смысл для дальнейшего развития. -Изначально делал [Андрей Чулков](https://github.com/achulkov2), ВШЭ, теперь (не) доделывает [Ольга Хвостикова](https://github.com/stavrolia), но сроки немного сдвинуты из-за задачи 25.9. Будем надеятся на лучшее. - -Upd. Доделывать будет другой человек. Приоритет не высокий. +[Андрей Чулков](https://github.com/achulkov2), ВШЭ. ### 1.2. Wait-free каталог баз данных. {#wait-free-katalog-baz-dannykh} @@ -869,8 +867,6 @@ Upd. Нас заставляют переписать эту библиотек ### 10.14. Поддержка всех типов в функции transform. {#podderzhka-vsekh-tipov-v-funktsii-transform} -Задачу взяла Ольга Хвостикова. Upd. Статус неизвестен. - ### 10.15. Использование словарей как специализированного layout для Join. {#ispolzovanie-slovarei-kak-spetsializirovannogo-layout-dlia-join} ### 10.16. Словари на локальном SSD. {#slovari-na-lokalnom-ssd} @@ -1414,8 +1410,6 @@ N.Vartolomei. ### 22.3. Защита от абсурдно заданных пользователем кодеков. {#zashchita-ot-absurdno-zadannykh-polzovatelem-kodekov} -В очереди, скорее всего [Ольга Хвостикова](https://github.com/stavrolia). - ### 22.4. Исправление оставшихся deadlocks в табличных RWLock-ах. {#ispravlenie-ostavshikhsia-deadlocks-v-tablichnykh-rwlock-akh} Александр Казаков. Нужно для Яндекс.Метрики и Datalens. Задача постепенно тащится и исправлениями в соседних местах стала менее актуальна. From ce372f464bf21efe1207a0bc246072344667ad41 Mon Sep 17 00:00:00 2001 From: Artem Zuikov Date: Thu, 16 Apr 2020 21:03:27 +0300 Subject: [PATCH 63/73] Fix finalize chain logic in ExpressionAnalysisResult (#10302) --- src/Interpreters/ExpressionAnalyzer.cpp | 8 ++++--- .../01117_chain_finalize_bug.reference | 9 +++++++ .../0_stateless/01117_chain_finalize_bug.sql | 24 +++++++++++++++++++ 3 files changed, 38 insertions(+), 3 deletions(-) create mode 100644 tests/queries/0_stateless/01117_chain_finalize_bug.reference create mode 100644 tests/queries/0_stateless/01117_chain_finalize_bug.sql diff --git a/src/Interpreters/ExpressionAnalyzer.cpp b/src/Interpreters/ExpressionAnalyzer.cpp index 9ec32737fdc..bb2553c76a4 100644 --- a/src/Interpreters/ExpressionAnalyzer.cpp +++ b/src/Interpreters/ExpressionAnalyzer.cpp @@ -963,13 +963,15 @@ ExpressionAnalysisResult::ExpressionAnalysisResult( auto finalize_chain = [&](ExpressionActionsChain & chain) { + chain.finalize(); + if (!finalized) { - chain.finalize(); finalize(chain, context, where_step_num); - chain.clear(); + finalized = true; } - finalized = true; + + chain.clear(); }; { diff --git a/tests/queries/0_stateless/01117_chain_finalize_bug.reference b/tests/queries/0_stateless/01117_chain_finalize_bug.reference new file mode 100644 index 00000000000..5704c399b5c --- /dev/null +++ b/tests/queries/0_stateless/01117_chain_finalize_bug.reference @@ -0,0 +1,9 @@ +1 0 +1 1 +2 0 +2 1 +1 0 +1 1 +2 0 +2 1 +200000 diff --git a/tests/queries/0_stateless/01117_chain_finalize_bug.sql b/tests/queries/0_stateless/01117_chain_finalize_bug.sql new file mode 100644 index 00000000000..f79f82b8d4d --- /dev/null +++ b/tests/queries/0_stateless/01117_chain_finalize_bug.sql @@ -0,0 +1,24 @@ +SELECT arrayJoin(arrayMap(i -> (i + 1), range(2))) AS index, number +FROM numbers(2) +GROUP BY number +ORDER BY index, number; + +SET max_bytes_before_external_group_by = 1; + +SELECT arrayJoin(arrayMap(i -> (i + 1), range(2))) AS index, number +FROM numbers(2) +GROUP BY number +ORDER BY index, number; + +SET group_by_two_level_threshold = 2; + +SELECT count() FROM +( + SELECT + arrayJoin(arrayMap(i -> (i + 1), range(2))) AS index, + number + FROM numbers_mt(100000) + GROUP BY number + ORDER BY index ASC + SETTINGS max_block_size = 100000, max_threads = 2 +); From 80873d79e3d7935b05626fff479febd387d4cdf8 Mon Sep 17 00:00:00 2001 From: Ivan Blinkov Date: Thu, 16 Apr 2020 21:03:52 +0300 Subject: [PATCH 64/73] [docs] tuning of
    tag, search menu colours and hidden pages (#10313) * improve hidden page title * adjust docsearch menu colors * enable pymdownx.details * some
    styling * remove useless example --- docs/en/index.md | 42 ----------------------------- docs/es/index.md | 42 ----------------------------- docs/fa/index.md | 48 --------------------------------- docs/fr/index.md | 42 ----------------------------- docs/ja/index.md | 42 ----------------------------- docs/ru/index.md | 42 ----------------------------- docs/tools/build.py | 1 + docs/tr/index.md | 42 ----------------------------- docs/zh/index.md | 48 --------------------------------- website/css/docs.css | 21 ++++++++++++++- website/templates/docs/nav.html | 6 ++++- 11 files changed, 26 insertions(+), 350 deletions(-) diff --git a/docs/en/index.md b/docs/en/index.md index e38a89abd49..67c4ca4d53b 100644 --- a/docs/en/index.md +++ b/docs/en/index.md @@ -78,48 +78,6 @@ See the difference? For example, the query “count the number of records for each advertising platform” requires reading one “advertising platform ID” column, which takes up 1 byte uncompressed. If most of the traffic was not from advertising platforms, you can expect at least 10-fold compression of this column. When using a quick compression algorithm, data decompression is possible at a speed of at least several gigabytes of uncompressed data per second. In other words, this query can be processed at a speed of approximately several billion rows per second on a single server. This speed is actually achieved in practice. -
    - -Example - -``` bash -$ clickhouse-client -ClickHouse client version 0.0.52053. -Connecting to localhost:9000. -Connected to ClickHouse server version 0.0.52053. -``` - -``` sql -SELECT CounterID, count() FROM hits GROUP BY CounterID ORDER BY count() DESC LIMIT 20 -``` - -``` text -┌─CounterID─┬──count()─┐ -│ 114208 │ 56057344 │ -│ 115080 │ 51619590 │ -│ 3228 │ 44658301 │ -│ 38230 │ 42045932 │ -│ 145263 │ 42042158 │ -│ 91244 │ 38297270 │ -│ 154139 │ 26647572 │ -│ 150748 │ 24112755 │ -│ 242232 │ 21302571 │ -│ 338158 │ 13507087 │ -│ 62180 │ 12229491 │ -│ 82264 │ 12187441 │ -│ 232261 │ 12148031 │ -│ 146272 │ 11438516 │ -│ 168777 │ 11403636 │ -│ 4120072 │ 11227824 │ -│ 10938808 │ 10519739 │ -│ 74088 │ 9047015 │ -│ 115079 │ 8837972 │ -│ 337234 │ 8205961 │ -└───────────┴──────────┘ -``` - -
    - ### CPU {#cpu} Since executing a query requires processing a large number of rows, it helps to dispatch all operations for entire vectors instead of for separate rows, or to implement the query engine so that there is almost no dispatching cost. If you don’t do this, with any half-decent disk subsystem, the query interpreter inevitably stalls the CPU. It makes sense to both store data in columns and process it, when possible, by columns. diff --git a/docs/es/index.md b/docs/es/index.md index 2cbe375e8ee..1348ef7013d 100644 --- a/docs/es/index.md +++ b/docs/es/index.md @@ -80,48 +80,6 @@ Ver la diferencia? Por ejemplo, la consulta “count the number of records for each advertising platform” requiere leer uno “advertising platform ID” columna, que ocupa 1 byte sin comprimir. Si la mayor parte del tráfico no proviene de plataformas publicitarias, puede esperar al menos una compresión de 10 veces de esta columna. Cuando se utiliza un algoritmo de compresión rápida, la descompresión de datos es posible a una velocidad de al menos varios gigabytes de datos sin comprimir por segundo. En otras palabras, esta consulta se puede procesar a una velocidad de aproximadamente varios miles de millones de filas por segundo en un único servidor. Esta velocidad se logra realmente en la práctica. -
    - -Ejemplo - -``` bash -$ clickhouse-client -ClickHouse client version 0.0.52053. -Connecting to localhost:9000. -Connected to ClickHouse server version 0.0.52053. -``` - -``` sql -SELECT CounterID, count() FROM hits GROUP BY CounterID ORDER BY count() DESC LIMIT 20 -``` - -``` text -┌─CounterID─┬──count()─┐ -│ 114208 │ 56057344 │ -│ 115080 │ 51619590 │ -│ 3228 │ 44658301 │ -│ 38230 │ 42045932 │ -│ 145263 │ 42042158 │ -│ 91244 │ 38297270 │ -│ 154139 │ 26647572 │ -│ 150748 │ 24112755 │ -│ 242232 │ 21302571 │ -│ 338158 │ 13507087 │ -│ 62180 │ 12229491 │ -│ 82264 │ 12187441 │ -│ 232261 │ 12148031 │ -│ 146272 │ 11438516 │ -│ 168777 │ 11403636 │ -│ 4120072 │ 11227824 │ -│ 10938808 │ 10519739 │ -│ 74088 │ 9047015 │ -│ 115079 │ 8837972 │ -│ 337234 │ 8205961 │ -└───────────┴──────────┘ -``` - -
    - ### CPU {#cpu} Dado que la ejecución de una consulta requiere procesar un gran número de filas, ayuda enviar todas las operaciones para vectores completos en lugar de para filas separadas, o implementar el motor de consultas para que casi no haya costo de envío. Si no hace esto, con cualquier subsistema de disco medio decente, el intérprete de consultas inevitablemente detiene la CPU. Tiene sentido almacenar datos en columnas y procesarlos, cuando sea posible, por columnas. diff --git a/docs/fa/index.md b/docs/fa/index.md index a8f1c201e37..f2b8f433edb 100644 --- a/docs/fa/index.md +++ b/docs/fa/index.md @@ -79,54 +79,6 @@ ClickHouse یک مدیریت دیتابیس (DBMS) ستون گرا برای پر برای مثال، query «تعداد رکوردها به ازای هر بستر نیازمندی» نیازمند خواندن ستون «آیدی بستر آگهی»، که 1 بایت بدون فشرده طول می کشد، خواهد بود. اگر بیشتر ترافیک مربوط به بستر های نیازمندی نبود، شما می توانید انتظار حداقل 10 برابر فشرده سازی این ستون را داشته باشید. زمانی که از الگوریتم فشرده سازی quick استفاده می کنید، عملیات decompression داده ها با سرعت حداقل چندین گیگابایت در ثانیه انجام می شود. به عبارت دیگر، این query توانایی پردازش تقریبا چندین میلیارد رکورد در ثانیه به ازای یک سرور را دارد. این سرعت در عمل واقعی و دست یافتنی است. -
    - -مثال - - $ clickhouse-client - ClickHouse client version 0.0.52053. - Connecting to localhost:9000. - Connected to ClickHouse server version 0.0.52053. - - :) SELECT CounterID, count() FROM hits GROUP BY CounterID ORDER BY count() DESC LIMIT 20 - - SELECT - CounterID, - count() - FROM hits - GROUP BY CounterID - ORDER BY count() DESC - LIMIT 20 - - ┌─CounterID─┬──count()─┐ - │ 114208 │ 56057344 │ - │ 115080 │ 51619590 │ - │ 3228 │ 44658301 │ - │ 38230 │ 42045932 │ - │ 145263 │ 42042158 │ - │ 91244 │ 38297270 │ - │ 154139 │ 26647572 │ - │ 150748 │ 24112755 │ - │ 242232 │ 21302571 │ - │ 338158 │ 13507087 │ - │ 62180 │ 12229491 │ - │ 82264 │ 12187441 │ - │ 232261 │ 12148031 │ - │ 146272 │ 11438516 │ - │ 168777 │ 11403636 │ - │ 4120072 │ 11227824 │ - │ 10938808 │ 10519739 │ - │ 74088 │ 9047015 │ - │ 115079 │ 8837972 │ - │ 337234 │ 8205961 │ - └───────────┴──────────┘ - - 20 rows in set. Elapsed: 0.153 sec. Processed 1.00 billion rows, 4.00 GB (6.53 billion rows/s., 26.10 GB/s.) - - :) - -
    - ### CPU {#cpu} از آنجایی که اجرای یک query نیازمند پردازش تعداد زیادی سطر می باشد، این کمک می کند تا تمام عملیات ها به جای ارسال به سطرهای جداگانه، برای کل بردار ارسال شود، یا برای ترکیب query engine به طوری که هیچ هزینه ی ارسالی وجود ندارد. اگر این کار رو نکنید، با هر half-decent disk subsystem، تفسیرگر query ناگزیر است که CPU را متوقف کند. این منطقی است که که در صورت امکان هر دو کار ذخیره سازی داده در ستون ها و پردازش ستون ها با هم انجام شود. diff --git a/docs/fr/index.md b/docs/fr/index.md index 0e53167306e..bcdeda0a693 100644 --- a/docs/fr/index.md +++ b/docs/fr/index.md @@ -80,48 +80,6 @@ Vous voyez la différence? Par exemple, la requête “count the number of records for each advertising platform” nécessite la lecture d'un “advertising platform ID” colonne, qui prend 1 octet non compressé. Si la majeure partie du trafic ne provenait pas de plates-formes publicitaires, vous pouvez vous attendre à une compression d'au moins 10 fois de cette colonne. Lors de l'utilisation d'un algorithme de compression rapide, la décompression des données est possible à une vitesse d'au moins plusieurs gigaoctets de données non compressées par seconde. En d'autres termes, cette requête ne peut être traitée qu'à une vitesse d'environ plusieurs milliards de lignes par seconde sur un seul serveur. Cette vitesse est effectivement atteinte dans la pratique. -
    - -Exemple - -``` bash -$ clickhouse-client -ClickHouse client version 0.0.52053. -Connecting to localhost:9000. -Connected to ClickHouse server version 0.0.52053. -``` - -``` sql -SELECT CounterID, count() FROM hits GROUP BY CounterID ORDER BY count() DESC LIMIT 20 -``` - -``` text -┌─CounterID─┬──count()─┐ -│ 114208 │ 56057344 │ -│ 115080 │ 51619590 │ -│ 3228 │ 44658301 │ -│ 38230 │ 42045932 │ -│ 145263 │ 42042158 │ -│ 91244 │ 38297270 │ -│ 154139 │ 26647572 │ -│ 150748 │ 24112755 │ -│ 242232 │ 21302571 │ -│ 338158 │ 13507087 │ -│ 62180 │ 12229491 │ -│ 82264 │ 12187441 │ -│ 232261 │ 12148031 │ -│ 146272 │ 11438516 │ -│ 168777 │ 11403636 │ -│ 4120072 │ 11227824 │ -│ 10938808 │ 10519739 │ -│ 74088 │ 9047015 │ -│ 115079 │ 8837972 │ -│ 337234 │ 8205961 │ -└───────────┴──────────┘ -``` - -
    - ### CPU {#cpu} Étant donné que l'exécution d'une requête nécessite le traitement d'un grand nombre de lignes, il est utile de répartir toutes les opérations pour des vecteurs entiers au lieu de lignes séparées, ou d'implémenter le moteur de requête de sorte qu'il n'y ait presque aucun coût d'expédition. Si vous ne le faites pas, avec un sous-système de disque à moitié décent, l'interpréteur de requête bloque inévitablement le processeur. Il est logique de stocker des données dans des colonnes et de les traiter, si possible, par des colonnes. diff --git a/docs/ja/index.md b/docs/ja/index.md index 07c2724eb0e..4dc166d7f5c 100644 --- a/docs/ja/index.md +++ b/docs/ja/index.md @@ -82,48 +82,6 @@ OLAPシナリオは、他の一般的なシナリオ（OLTPやKey-Valueアクセ たとえば、「各広告プラットフォームのレコード数をカウントする」クエリでは、1つの「広告プラットフォームID」列を読み取る必要がありますが、これは非圧縮では1バイトの領域を要します。トラフィックのほとんどが広告プラットフォームからのものではない場合、この列は少なくとも10倍の圧縮が期待できます。高速な圧縮アルゴリズムを使用すれば、1秒あたり少なくとも非圧縮データに換算して数ギガバイトの速度でデータを展開できます。つまり、このクエリは、単一のサーバーで1秒あたり約数十億行の速度で処理できます。この速度はまさに実際に達成されます。 -
    - -Example - -``` bash -$ clickhouse-client -ClickHouse client version 0.0.52053. -Connecting to localhost:9000. -Connected to ClickHouse server version 0.0.52053. -``` - -``` sql -SELECT CounterID, count() FROM hits GROUP BY CounterID ORDER BY count() DESC LIMIT 20 -``` - -``` text -┌─CounterID─┬──count()─┐ -│ 114208 │ 56057344 │ -│ 115080 │ 51619590 │ -│ 3228 │ 44658301 │ -│ 38230 │ 42045932 │ -│ 145263 │ 42042158 │ -│ 91244 │ 38297270 │ -│ 154139 │ 26647572 │ -│ 150748 │ 24112755 │ -│ 242232 │ 21302571 │ -│ 338158 │ 13507087 │ -│ 62180 │ 12229491 │ -│ 82264 │ 12187441 │ -│ 232261 │ 12148031 │ -│ 146272 │ 11438516 │ -│ 168777 │ 11403636 │ -│ 4120072 │ 11227824 │ -│ 10938808 │ 10519739 │ -│ 74088 │ 9047015 │ -│ 115079 │ 8837972 │ -│ 337234 │ 8205961 │ -└───────────┴──────────┘ -``` - -
    - ### CPU {#cpu} クエリを実行するには大量の行を処理する必要があるため、個別の行ではなくベクター全体のすべての操作をディスパッチするか、ディスパッチコストがほとんどないようにクエリエンジンを実装すると効率的です。 適切なディスクサブシステムでこれを行わないと、クエリインタープリターが必然的にCPUを失速させます。 diff --git a/docs/ru/index.md b/docs/ru/index.md index 4636c2cb5df..e537c240cb6 100644 --- a/docs/ru/index.md +++ b/docs/ru/index.md @@ -82,48 +82,6 @@ ClickHouse - столбцовая система управления базам Например, для запроса «посчитать количество записей для каждой рекламной системы», требуется прочитать один столбец «идентификатор рекламной системы», который занимает 1 байт в несжатом виде. Если большинство переходов было не с рекламных систем, то можно рассчитывать хотя бы на десятикратное сжатие этого столбца. При использовании быстрого алгоритма сжатия, возможно разжатие данных со скоростью более нескольких гигабайт несжатых данных в секунду. То есть, такой запрос может выполняться со скоростью около нескольких миллиардов строк в секунду на одном сервере. На практике, такая скорость действительно достигается. -
    - -Пример - -``` bash -$ clickhouse-client -ClickHouse client version 0.0.52053. -Connecting to localhost:9000. -Connected to ClickHouse server version 0.0.52053. -``` - -``` sql -SELECT CounterID, count() FROM hits GROUP BY CounterID ORDER BY count() DESC LIMIT 20 -``` - -``` text -┌─CounterID─┬──count()─┐ -│ 114208 │ 56057344 │ -│ 115080 │ 51619590 │ -│ 3228 │ 44658301 │ -│ 38230 │ 42045932 │ -│ 145263 │ 42042158 │ -│ 91244 │ 38297270 │ -│ 154139 │ 26647572 │ -│ 150748 │ 24112755 │ -│ 242232 │ 21302571 │ -│ 338158 │ 13507087 │ -│ 62180 │ 12229491 │ -│ 82264 │ 12187441 │ -│ 232261 │ 12148031 │ -│ 146272 │ 11438516 │ -│ 168777 │ 11403636 │ -│ 4120072 │ 11227824 │ -│ 10938808 │ 10519739 │ -│ 74088 │ 9047015 │ -│ 115079 │ 8837972 │ -│ 337234 │ 8205961 │ -└───────────┴──────────┘ -``` - -
    - ### По вычислениям {#po-vychisleniiam} Так как для выполнения запроса надо обработать достаточно большое количество строк, становится актуальным диспетчеризовывать все операции не для отдельных строк, а для целых векторов, или реализовать движок выполнения запроса так, чтобы издержки на диспетчеризацию были примерно нулевыми. Если этого не делать, то при любой не слишком плохой дисковой подсистеме, интерпретатор запроса неизбежно упрётся в CPU. diff --git a/docs/tools/build.py b/docs/tools/build.py index 4f3a5378b34..4876c6e7566 100755 --- a/docs/tools/build.py +++ b/docs/tools/build.py @@ -111,6 +111,7 @@ def build_for_lang(lang, args): 'codehilite', 'nl2br', 'sane_lists', + 'pymdownx.details', 'pymdownx.magiclink', 'pymdownx.superfences', 'extra', diff --git a/docs/tr/index.md b/docs/tr/index.md index fb65930b39c..5cbf9330750 100644 --- a/docs/tr/index.md +++ b/docs/tr/index.md @@ -78,48 +78,6 @@ Farkı görüyor musunuz? Örneğin, sorgu “count the number of records for each advertising platform” bir okuma gerektirir “advertising platform ID” 1 bayt sıkıştırılmamış kadar alır sütun. Trafiğin çoğu reklam platformlarından değilse, bu sütunun en az 10 kat sıkıştırılmasını bekleyebilirsiniz. Hızlı bir sıkıştırma algoritması kullanırken, saniyede en az birkaç gigabayt sıkıştırılmamış veri hızında veri dekompresyonu mümkündür. Başka bir deyişle, bu sorgu, tek bir sunucuda saniyede yaklaşık birkaç milyar satır hızında işlenebilir. Bu hız aslında pratikte elde edilir. -
    - -Örnek - -``` bash -$ clickhouse-client -ClickHouse client version 0.0.52053. -Connecting to localhost:9000. -Connected to ClickHouse server version 0.0.52053. -``` - -``` sql -SELECT CounterID, count() FROM hits GROUP BY CounterID ORDER BY count() DESC LIMIT 20 -``` - -``` text -┌─CounterID─┬──count()─┐ -│ 114208 │ 56057344 │ -│ 115080 │ 51619590 │ -│ 3228 │ 44658301 │ -│ 38230 │ 42045932 │ -│ 145263 │ 42042158 │ -│ 91244 │ 38297270 │ -│ 154139 │ 26647572 │ -│ 150748 │ 24112755 │ -│ 242232 │ 21302571 │ -│ 338158 │ 13507087 │ -│ 62180 │ 12229491 │ -│ 82264 │ 12187441 │ -│ 232261 │ 12148031 │ -│ 146272 │ 11438516 │ -│ 168777 │ 11403636 │ -│ 4120072 │ 11227824 │ -│ 10938808 │ 10519739 │ -│ 74088 │ 9047015 │ -│ 115079 │ 8837972 │ -│ 337234 │ 8205961 │ -└───────────┴──────────┘ -``` - -
    - ### CPU {#cpu} Bir sorguyu yürütmek çok sayıda satırı işlemeyi gerektirdiğinden, ayrı satırlar yerine tüm vektörler için tüm işlemlerin gönderilmesine veya sorgu motorunun neredeyse hiç gönderim maliyeti olmaması için uygulanmasına yardımcı olur. Bunu yapmazsanız, yarı iyi bir disk alt sistemi ile, sorgu yorumlayıcısı kaçınılmaz olarak CPU'yu durdurur. Hem verileri sütunlarda depolamak hem de mümkün olduğunda sütunlarla işlemek mantıklıdır. diff --git a/docs/zh/index.md b/docs/zh/index.md index cb9ccf0420a..455a578456b 100644 --- a/docs/zh/index.md +++ b/docs/zh/index.md @@ -81,54 +81,6 @@ ClickHouse是一个用于联机分析(OLAP)的列式数据库管理系统(DBMS) 例如，查询«统计每个广告平台的记录数量»需要读取«广告平台ID»这一列，它在未压缩的情况下需要1个字节进行存储。如果大部分流量不是来自广告平台，那么这一列至少可以以十倍的压缩率被压缩。当采用快速压缩算法，它的解压速度最少在十亿字节(未压缩数据)每秒。换句话说，这个查询可以在单个服务器上以每秒大约几十亿行的速度进行处理。这实际上是当前实现的速度。 -
    - -示例 - - $ clickhouse-client - ClickHouse client version 0.0.52053. - Connecting to localhost:9000. - Connected to ClickHouse server version 0.0.52053. - - :) SELECT CounterID, count() FROM hits GROUP BY CounterID ORDER BY count() DESC LIMIT 20 - - SELECT - CounterID, - count() - FROM hits - GROUP BY CounterID - ORDER BY count() DESC - LIMIT 20 - - ┌─CounterID─┬──count()─┐ - │ 114208 │ 56057344 │ - │ 115080 │ 51619590 │ - │ 3228 │ 44658301 │ - │ 38230 │ 42045932 │ - │ 145263 │ 42042158 │ - │ 91244 │ 38297270 │ - │ 154139 │ 26647572 │ - │ 150748 │ 24112755 │ - │ 242232 │ 21302571 │ - │ 338158 │ 13507087 │ - │ 62180 │ 12229491 │ - │ 82264 │ 12187441 │ - │ 232261 │ 12148031 │ - │ 146272 │ 11438516 │ - │ 168777 │ 11403636 │ - │ 4120072 │ 11227824 │ - │ 10938808 │ 10519739 │ - │ 74088 │ 9047015 │ - │ 115079 │ 8837972 │ - │ 337234 │ 8205961 │ - └───────────┴──────────┘ - - 20 rows in set. Elapsed: 0.153 sec. Processed 1.00 billion rows, 4.00 GB (6.53 billion rows/s., 26.10 GB/s.) - - :) - -
    - ### CPU {#cpu} 由于执行一个查询需要处理大量的行，因此在整个向量上执行所有操作将比在每一行上执行所有操作更加高效。同时这将有助于实现一个几乎没有调用成本的查询引擎。如果你不这样做，使用任何一个机械硬盘，查询引擎都不可避免的停止CPU进行等待。所以，在数据按列存储并且按列执行是很有意义的。 diff --git a/website/css/docs.css b/website/css/docs.css index f4c4857bc7e..7e4e1040848 100644 --- a/website/css/docs.css +++ b/website/css/docs.css @@ -1,3 +1,14 @@ +details { + background: #444451; + padding: 1rem; + margin-bottom: 1rem; + margin-top: 1rem; +} + +summary { + font-weight: bold; +} + #sidebar { position: fixed; z-index: 50; @@ -109,6 +120,15 @@ border-color: #333; } +.algolia-autocomplete .algolia-docsearch-suggestion--content { + background-color: #333; +} + +.algolia-autocomplete .algolia-docsearch-suggestion--content:hover, +.algolia-autocomplete .ds-dropdown-menu .ds-suggestion.ds-cursor .algolia-docsearch-suggestion:not(.suggestion-layout-simple) .algolia-docsearch-suggestion--content { + background-color: #444451 !important; +} + .algolia-autocomplete .algolia-docsearch-suggestion--category-header, .algolia-autocomplete .algolia-docsearch-suggestion--subcategory-column, .algolia-autocomplete .algolia-docsearch-suggestion--title, @@ -184,4 +204,3 @@ color: #bbb; } } - diff --git a/website/templates/docs/nav.html b/website/templates/docs/nav.html index 42808819ef3..adc7231658f 100644 --- a/website/templates/docs/nav.html +++ b/website/templates/docs/nav.html @@ -6,7 +6,11 @@

    - {{ page.title or config.site_name }} + {% if page.title != 'hidden' %} + {{ page.title or config.site_name }} + {% else %} + {{ page.meta.toc_folder_title or config.site_name }} + {% endif %}

    From d5b3b2c7b68a0b493384caabcb6f4a2549449b92 Mon Sep 17 00:00:00 2001 From: Alexander Kazakov Date: Thu, 16 Apr 2020 21:56:21 +0300 Subject: [PATCH 65/73] Updated RWLockImpl: Fixed suboptimacy (readers queuing up) + minor tweaks to names and comments (#10303) * Readers queue correction * Comments, renamings and cosmetics --- src/Common/RWLock.cpp | 29 ++++++++--------------------- src/Common/RWLock.h | 12 +++++++++--- 2 files changed, 17 insertions(+), 24 deletions(-) diff --git a/src/Common/RWLock.cpp b/src/Common/RWLock.cpp index d6b8cbd244f..a8dba490fac 100644 --- a/src/Common/RWLock.cpp +++ b/src/Common/RWLock.cpp @@ -154,23 +154,17 @@ RWLockImpl::getLock(RWLockImpl::Type type, const String & query_id, const std::c writers_queue.emplace_back(type); /// SM1: may throw (nothing to roll back) } else if (readers_queue.empty() || - (rdlock_owner == readers_queue.begin() && !writers_queue.empty())) + (rdlock_owner == readers_queue.begin() && readers_queue.size() == 1 && !writers_queue.empty())) { readers_queue.emplace_back(type); /// SM1: may throw (nothing to roll back) } GroupsContainer::iterator it_group = (type == Type::Write) ? std::prev(writers_queue.end()) : std::prev(readers_queue.end()); + /// Lock is free to acquire if (rdlock_owner == readers_queue.end() && wrlock_owner == writers_queue.end()) { - if (type == Type::Read) - { - rdlock_owner = it_group; /// SM2: nothrow - } - else - { - wrlock_owner = it_group; /// SM2: nothrow - } + (type == Read ? rdlock_owner : wrlock_owner) = it_group; /// SM2: nothrow } else { @@ -192,17 +186,10 @@ RWLockImpl::getLock(RWLockImpl::Type type, const String & query_id, const std::c /// Step 3a. Check if we must handle timeout and exit if (!wait_result) /// Wait timed out! { + /// Rollback(SM1): nothrow if (it_group->requests == 0) { - /// Roll back SM1 - if (type == Read) - { - readers_queue.erase(it_group); /// Rollback(SM1): nothrow - } - else - { - writers_queue.erase(it_group); /// Rollback(SM1): nothrow - } + (type == Read ? readers_queue : writers_queue).erase(it_group); } return nullptr; @@ -224,7 +211,7 @@ RWLockImpl::getLock(RWLockImpl::Type type, const String & query_id, const std::c /// Methods std::list<>::emplace_back() and std::unordered_map<>::emplace() provide strong exception safety /// We only need to roll back the changes to these objects: owner_queries and the readers/writers queue if (it_group->requests == 0) - eraseGroup(it_group); /// Rollback(SM1): nothrow + dropOwnerGroupAndPassOwnership(it_group); /// Rollback(SM1): nothrow throw; } @@ -272,11 +259,11 @@ void RWLockImpl::unlock(GroupsContainer::iterator group_it, const String & query /// If we are the last remaining referrer, remove this QNode and notify the next one if (--group_it->requests == 0) /// SM: nothrow - eraseGroup(group_it); + dropOwnerGroupAndPassOwnership(group_it); } -void RWLockImpl::eraseGroup(GroupsContainer::iterator group_it) noexcept +void RWLockImpl::dropOwnerGroupAndPassOwnership(GroupsContainer::iterator group_it) noexcept { rdlock_owner = readers_queue.end(); wrlock_owner = writers_queue.end(); diff --git a/src/Common/RWLock.h b/src/Common/RWLock.h index 43366192cf8..ad0a3f139fc 100644 --- a/src/Common/RWLock.h +++ b/src/Common/RWLock.h @@ -19,9 +19,15 @@ class RWLockImpl; using RWLock = std::shared_ptr; -/// Implements shared lock with FIFO service +/// Implements Readers-Writers locking algorithm that serves requests in "Phase Fair" order. /// (Phase Fair RWLock as suggested in https://www.cs.unc.edu/~anderson/papers/rtsj10-for-web.pdf) -/// Can be acquired recursively (for the same query) in Read mode +/// It is used for synchronizing access to various objects on query level (i.e. Storages). +/// +/// In general, ClickHouse processes queries by multiple threads of execution in parallel. +/// As opposed to the standard OS synchronization primitives (mutexes), this implementation allows +/// unlock() to be called by a thread other than the one, that called lock(). +/// It is also possible to acquire RWLock in Read mode without waiting (FastPath) by multiple threads, +/// that execute the same query (share the same query_id). /// /// NOTE: it is important to allow acquiring the same lock in Read mode without waiting if it is already /// acquired by another thread of the same query. Otherwise the following deadlock is possible: @@ -82,6 +88,6 @@ private: private: RWLockImpl() = default; void unlock(GroupsContainer::iterator group_it, const String & query_id) noexcept; - void eraseGroup(GroupsContainer::iterator group_it) noexcept; + void dropOwnerGroupAndPassOwnership(GroupsContainer::iterator group_it) noexcept; }; } From 831c48c5149bab38fc5e88d59149802a50997bd5 Mon Sep 17 00:00:00 2001 From: Avogar Date: Thu, 16 Apr 2020 23:10:42 +0300 Subject: [PATCH 66/73] Add MarkdownRowOutput format --- src/Formats/FormatFactory.cpp | 1 + src/Formats/FormatFactory.h | 1 + .../Formats/Impl/MarkdownRowOutputFormat.cpp | 62 +++++++++++++++++++ .../Formats/Impl/MarkdownRowOutputFormat.h | 39 ++++++++++++ .../01231_markdown_format.reference | 5 ++ .../0_stateless/01231_markdown_format.sql | 6 ++ 6 files changed, 114 insertions(+) create mode 100644 src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp create mode 100644 src/Processors/Formats/Impl/MarkdownRowOutputFormat.h create mode 100644 tests/queries/0_stateless/01231_markdown_format.reference create mode 100644 tests/queries/0_stateless/01231_markdown_format.sql diff --git a/src/Formats/FormatFactory.cpp b/src/Formats/FormatFactory.cpp index 7d741004766..f944a32c4b3 100644 --- a/src/Formats/FormatFactory.cpp +++ b/src/Formats/FormatFactory.cpp @@ -377,6 +377,7 @@ FormatFactory::FormatFactory() registerOutputFormatProcessorODBCDriver2(*this); registerOutputFormatProcessorNull(*this); registerOutputFormatProcessorMySQLWrite(*this); + registerOutputFormatProcessorMarkdown(*this); } FormatFactory & FormatFactory::instance() diff --git a/src/Formats/FormatFactory.h b/src/Formats/FormatFactory.h index 9199ed89890..39d6eb0cc15 100644 --- a/src/Formats/FormatFactory.h +++ b/src/Formats/FormatFactory.h @@ -198,6 +198,7 @@ void registerOutputFormatProcessorODBCDriver(FormatFactory & factory); void registerOutputFormatProcessorODBCDriver2(FormatFactory & factory); void registerOutputFormatProcessorNull(FormatFactory & factory); void registerOutputFormatProcessorMySQLWrite(FormatFactory & factory); +void registerOutputFormatProcessorMarkdown(FormatFactory & factory); /// Input only formats. void registerInputFormatProcessorCapnProto(FormatFactory & factory); diff --git a/src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp b/src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp new file mode 100644 index 00000000000..54aecc7b43b --- /dev/null +++ b/src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp @@ -0,0 +1,62 @@ +#include +#include + +namespace DB +{ + +MarkdownRowOutputFormat::MarkdownRowOutputFormat(WriteBuffer & out_, const Block & header_, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_) + : IRowOutputFormat(header_, out_, callback), format_settings(format_settings_) {} + +void MarkdownRowOutputFormat::writePrefix() +{ + auto & header = getPort(PortKind::Main).getHeader(); + size_t columns = header.columns(); + + writeChar('|', out); + for (size_t i = 0; i < columns; ++i) + { + writeEscapedString(header.safeGetByPosition(i).name, out); + writeChar('|', out); + } + writeCString("\n|", out); + String format = ":-:|"; + for (size_t i = 0; i < columns; ++i) + { + writeString(format, out); + } + writeChar('\n', out); +} + +void MarkdownRowOutputFormat::writeRowStartDelimiter() +{ + writeChar('|', out); +} + +void MarkdownRowOutputFormat::writeFieldDelimiter() +{ + writeChar('|', out); +} + +void MarkdownRowOutputFormat::writeRowEndDelimiter() +{ + writeCString("|\n", out); +} + +void MarkdownRowOutputFormat::writeField(const IColumn & column, const IDataType & type, size_t row_num) +{ + type.serializeAsTextEscaped(column, row_num, out, format_settings); +} + +void registerOutputFormatProcessorMarkdown(FormatFactory & factory) +{ + factory.registerOutputFormatProcessor("Markdown", []( + WriteBuffer & buf, + const Block & sample, + FormatFactory::WriteCallback callback, + const FormatSettings & settings) + { + return std::make_shared(buf, sample, callback, settings); + }); +} + +} \ No newline at end of file diff --git a/src/Processors/Formats/Impl/MarkdownRowOutputFormat.h b/src/Processors/Formats/Impl/MarkdownRowOutputFormat.h new file mode 100644 index 00000000000..2f39cce0181 --- /dev/null +++ b/src/Processors/Formats/Impl/MarkdownRowOutputFormat.h @@ -0,0 +1,39 @@ +#pragma once + +#include +#include +#include + +namespace DB +{ + +class ReadBuffer; + +class MarkdownRowOutputFormat : public IRowOutputFormat +{ +public: + MarkdownRowOutputFormat(WriteBuffer & out_, const Block & header_, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_); + + /// Write higher part of markdown table like this: + /// |columnName1|columnName2|...|columnNameN| + /// |:-:|:-:|...|:-:| + void writePrefix() override; + + /// Write '|' before each row + void writeRowStartDelimiter() override; + + /// Write '|' between values + void writeFieldDelimiter() override; + + /// Write '|\n' after each row + void writeRowEndDelimiter() override ; + + void writeField(const IColumn & column, const IDataType & type, size_t row_num) override; + String getName() const override { return "MarkdownRowOutputFormat"; } + +protected: + const FormatSettings format_settings; +}; + + +} diff --git a/tests/queries/0_stateless/01231_markdown_format.reference b/tests/queries/0_stateless/01231_markdown_format.reference new file mode 100644 index 00000000000..57ad6c51de8 --- /dev/null +++ b/tests/queries/0_stateless/01231_markdown_format.reference @@ -0,0 +1,5 @@ +|id|name|array| +|:-:|:-:|:-:| +|1|name1|[1,2,3]| +|2|name2|[4,5,6]| +|3|name3|[7,8,9]| diff --git a/tests/queries/0_stateless/01231_markdown_format.sql b/tests/queries/0_stateless/01231_markdown_format.sql new file mode 100644 index 00000000000..693664be1ab --- /dev/null +++ b/tests/queries/0_stateless/01231_markdown_format.sql @@ -0,0 +1,6 @@ +DROP TABLE IF EXISTS makrdown; +CREATE TABLE markdown (id UInt32, name String, array Array(Int8)) ENGINE = Memory; +INSERT INTO markdown VALUES (1, 'name1', [1,2,3]), (2, 'name2', [4,5,6]), (3, 'name3', [7,8,9]); + +SELECT * FROM markdown FORMAT Markdown; +DROP TABLE IF EXISTS markdown From 89d787dae3b1639cf24b51b407f531ef727aed7a Mon Sep 17 00:00:00 2001 From: Avogar Date: Thu, 16 Apr 2020 23:11:52 +0300 Subject: [PATCH 67/73] Add new line at the end of file --- src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp b/src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp index 54aecc7b43b..398934d22f3 100644 --- a/src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp +++ b/src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp @@ -59,4 +59,4 @@ void registerOutputFormatProcessorMarkdown(FormatFactory & factory) }); } -} \ No newline at end of file +} From c62c288e4cc748b03059f48d724b79e4becfd576 Mon Sep 17 00:00:00 2001 From: Artem Zuikov Date: Thu, 16 Apr 2020 23:28:23 +0300 Subject: [PATCH 68/73] fix COMMA and other JOIN mix (#10311) --- src/Interpreters/CrossToInnerJoinVisitor.cpp | 12 ++++++---- .../01117_comma_and_others_join_mix.reference | 23 +++++++++++++++++++ .../01117_comma_and_others_join_mix.sql | 20 ++++++++++++++++ 3 files changed, 51 insertions(+), 4 deletions(-) create mode 100644 tests/queries/0_stateless/01117_comma_and_others_join_mix.reference create mode 100644 tests/queries/0_stateless/01117_comma_and_others_join_mix.sql diff --git a/src/Interpreters/CrossToInnerJoinVisitor.cpp b/src/Interpreters/CrossToInnerJoinVisitor.cpp index 903f561b8bb..af694fe634a 100644 --- a/src/Interpreters/CrossToInnerJoinVisitor.cpp +++ b/src/Interpreters/CrossToInnerJoinVisitor.cpp @@ -52,17 +52,21 @@ struct JoinedElement void rewriteCommaToCross() { - if (join) + if (join && join->kind == ASTTableJoin::Kind::Comma) join->kind = ASTTableJoin::Kind::Cross; } - void rewriteCrossToInner(ASTPtr on_expression) + bool rewriteCrossToInner(ASTPtr on_expression) { + if (join->kind != ASTTableJoin::Kind::Cross) + return false; + join->kind = ASTTableJoin::Kind::Inner; join->strictness = ASTTableJoin::Strictness::All; join->on_expression = on_expression; join->children.push_back(join->on_expression); + return true; } ASTPtr arrayJoin() const { return element.array_join; } @@ -329,8 +333,8 @@ void CrossToInnerJoinMatcher::visit(ASTSelectQuery & select, ASTPtr &, Data & da { if (visitor_data.matchAny(i)) { - joined_tables[i].rewriteCrossToInner(visitor_data.makeOnExpression(i)); - data.done = true; + if (joined_tables[i].rewriteCrossToInner(visitor_data.makeOnExpression(i))) + data.done = true; } } } diff --git a/tests/queries/0_stateless/01117_comma_and_others_join_mix.reference b/tests/queries/0_stateless/01117_comma_and_others_join_mix.reference new file mode 100644 index 00000000000..e50321284f4 --- /dev/null +++ b/tests/queries/0_stateless/01117_comma_and_others_join_mix.reference @@ -0,0 +1,23 @@ +0 0 0 +0 0 1 +0 0 2 +0 0 3 +1 1 0 +1 1 1 +1 1 2 +1 1 3 +- +0 0 0 +0 1 0 +1 0 1 +1 1 1 +2 0 \N +2 1 \N +- +0 0 0 +0 1 1 +0 2 2 +1 0 0 +1 1 1 +1 2 2 +\N \N 3 diff --git a/tests/queries/0_stateless/01117_comma_and_others_join_mix.sql b/tests/queries/0_stateless/01117_comma_and_others_join_mix.sql new file mode 100644 index 00000000000..5fe297956b8 --- /dev/null +++ b/tests/queries/0_stateless/01117_comma_and_others_join_mix.sql @@ -0,0 +1,20 @@ +SET join_use_nulls = 1; + +SELECT * +FROM numbers(2) AS n1 +JOIN numbers(3) AS n2 ON n1.number = n2.number, numbers(4) AS n3 +ORDER BY n1.number, n2.number, n3.number; + +SELECT '-'; + +SELECT * +FROM numbers(3) AS n1, numbers(2) AS n2 +LEFT JOIN numbers(2) AS n3 ON n1.number = n3.number +ORDER BY n1.number, n2.number, n3.number; + +SELECT '-'; + +SELECT * +FROM numbers(2) AS n1, numbers(3) AS n2 +RIGHT JOIN numbers(4) AS n3 ON n2.number = n3.number +ORDER BY n1.number, n2.number, n3.number; From 475ab6feef6f1215d962f8d79a91c78a235be886 Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Thu, 16 Apr 2020 23:30:34 +0300 Subject: [PATCH 69/73] Added results from Sergey Zakharov. --- website/benchmark_hardware.html | 54 ++++++++++++++++++++++++++++++++- 1 file changed, 53 insertions(+), 1 deletion(-) diff --git a/website/benchmark_hardware.html b/website/benchmark_hardware.html index b45ccb4875c..efb371c588f 100644 --- a/website/benchmark_hardware.html +++ b/website/benchmark_hardware.html @@ -2529,6 +2529,57 @@ var results = [0.022, 0.008, 0.006] ] }, + + { + "system": "AMD EPYC 7502P 32-Core Processor with HT (64 thread) / 512 Gb RAM / mdadm RAID1 SAMSUNG MZQLB3T8HALS-00007 + LVM", + "time": "2020-04-16 00:00:00", + "result": + [ +[0.007, 0.002, 0.002], +[0.022, 0.011, 0.011], +[0.028, 0.017, 0.017], +[0.050, 0.022, 0.022], +[0.098, 0.079, 0.078], +[0.149, 0.125, 0.126], +[0.020, 0.014, 0.014], +[0.015, 0.013, 0.013], +[0.169, 0.148, 0.148], +[0.237, 0.171, 0.168], +[0.103, 0.084, 0.082], +[0.099, 0.085, 0.084], +[0.262, 0.221, 0.221], +[0.312, 0.281, 0.282], +[0.274, 0.259, 0.255], +[0.255, 0.237, 0.237], +[0.616, 0.592, 0.589], +[0.398, 0.364, 0.359], +[1.358, 1.301, 1.292], +[0.056, 0.025, 0.022], +[0.485, 0.265, 0.263], +[0.510, 0.271, 0.255], +[0.938, 0.693, 0.674], +[1.262, 0.396, 0.367], +[0.144, 0.082, 0.081], +[0.088, 0.066, 0.065], +[0.141, 0.084, 0.082], +[0.488, 0.329, 0.325], +[0.441, 0.376, 0.374], +[1.054, 1.049, 1.068], +[0.222, 0.190, 0.189], +[0.386, 0.321, 0.319], +[1.703, 1.625, 1.660], +[1.272, 1.202, 1.207], +[1.276, 1.185, 1.204], +[0.398, 0.382, 0.382], +[0.171, 0.160, 0.160], +[0.071, 0.058, 0.059], +[0.059, 0.055, 0.053], +[0.364, 0.341, 0.354], +[0.028, 0.022, 0.027], +[0.027, 0.020, 0.018], +[0.010, 0.008, 0.005], + ] + }, ]; @@ -2959,7 +3010,8 @@ Results for AWS are from Wolf Kreuzerkrieg.
    Results for Huawei Taishan are from Peng Gao in sina.com.
    Results for Selectel and AMD EPYC 7402P are from Andrey Dudin.
    Results for ProLiant are from Denis Ustinov.
    -Results for AMD EPYC 7502P are from Kostiantyn Velychkovskyi.
    +Results for AMD EPYC 7502P 128GiB are from Kostiantyn Velychkovskyi.
    +Results for AMD EPYC 7502P 512GiB are from Sergey Zakharov.
    Results for Pinebook Pro are from Aleksey R. @kITerE.
    Results for AMD Ryzen are from Alexey Milovidov. Firefox was running in background.
    Results for Azure E32s are from Piotr Maśko.
    From 2672b71b2d7426c3568cab922cff40a6e0886d62 Mon Sep 17 00:00:00 2001 From: Kruglov Pavel <48961922+Avogar@users.noreply.github.com> Date: Thu, 16 Apr 2020 23:47:01 +0300 Subject: [PATCH 70/73] Delete extra spaces --- src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp b/src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp index 398934d22f3..13e03198668 100644 --- a/src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp +++ b/src/Processors/Formats/Impl/MarkdownRowOutputFormat.cpp @@ -3,7 +3,7 @@ namespace DB { - + MarkdownRowOutputFormat::MarkdownRowOutputFormat(WriteBuffer & out_, const Block & header_, FormatFactory::WriteCallback callback, const FormatSettings & format_settings_) : IRowOutputFormat(header_, out_, callback), format_settings(format_settings_) {} From fa62be250f02db7128aa539c3a037d964cc22955 Mon Sep 17 00:00:00 2001 From: Alexander Kuzmenkov Date: Thu, 16 Apr 2020 23:54:52 +0300 Subject: [PATCH 71/73] performance comparison --- tests/performance/array_fill.xml | 6 +-- .../performance/mingroupby-orderbylimit1.xml | 37 +++++++++++++------ tests/performance/simple_join_query.xml | 2 +- 3 files changed, 30 insertions(+), 15 deletions(-) diff --git a/tests/performance/array_fill.xml b/tests/performance/array_fill.xml index d29e02730a3..b858ba03c8e 100644 --- a/tests/performance/array_fill.xml +++ b/tests/performance/array_fill.xml @@ -1,8 +1,8 @@ SELECT arraySlice(arrayFill(x -> ((x % 2) >= 0), range(100000000)), 1, 10) FORMAT Null - SELECT arraySlice(arrayFill(x -> (((x.1) % 2) >= 0), arrayMap(x -> (x, toString(x)), range(100000000))), 1, 10) FORMAT Null + SELECT arraySlice(arrayFill(x -> (((x.1) % 2) >= 0), arrayMap(x -> (x, toString(x)), range(10000000))), 1, 10) FORMAT Null SELECT arraySlice(arrayFill(x -> ((x % 2) >= 2), range(100000000)), 1, 10) FORMAT Null - SELECT arraySlice(arrayFill(x -> (((x.1) % 2) >= 2), arrayMap(x -> (x, toString(x)), range(100000000))), 1, 10) FORMAT Null + SELECT arraySlice(arrayFill(x -> (((x.1) % 2) >= 2), arrayMap(x -> (x, toString(x)), range(10000000))), 1, 10) FORMAT Null SELECT arraySlice(arrayFill(x -> ((x % 2) = 0), range(100000000)), 1, 10) FORMAT Null - SELECT arraySlice(arrayFill(x -> (((x.1) % 2) = 0), arrayMap(x -> (x, toString(x)), range(100000000))), 1, 10) FORMAT Null + SELECT arraySlice(arrayFill(x -> (((x.1) % 2) = 0), arrayMap(x -> (x, toString(x)), range(10000000))), 1, 10) FORMAT Null diff --git a/tests/performance/mingroupby-orderbylimit1.xml b/tests/performance/mingroupby-orderbylimit1.xml index 34cd992558b..306095a7e1c 100644 --- a/tests/performance/mingroupby-orderbylimit1.xml +++ b/tests/performance/mingroupby-orderbylimit1.xml @@ -12,53 +12,68 @@ - aggregationscale + aggregationscale_all + + 1111111 + 111111 + 11111 + + + + aggregationscale_small 111111 11111 + + aggregationscale_big + + 1111111 + 111111 + + - create table mingroupby_orderbylimit1_{aggregationscale}_tuple + create table mingroupby_orderbylimit1_{aggregationscale_all}_tuple Engine=MergeTree order by tuple() AS - select toUInt64( number % {aggregationscale} ) key, toUInt64(1) value + select toUInt64( number % {aggregationscale_all} ) key, toUInt64(1) value from numbers(2000000); - create table mingroupby_orderbylimit1_{aggregationscale}_key_value + create table mingroupby_orderbylimit1_{aggregationscale_all}_key_value Engine=MergeTree order by (key,value) AS - select toUInt64( number % {aggregationscale} ) key, toUInt64(1) value + select toUInt64( number % {aggregationscale_all} ) key, toUInt64(1) value from numbers(2000000); SELECT key, min(value) - FROM mingroupby_orderbylimit1_{aggregationscale}_tuple + FROM mingroupby_orderbylimit1_{aggregationscale_big}_tuple group by key format Null; SELECT key, min(value) - FROM mingroupby_orderbylimit1_{aggregationscale}_key_value + FROM mingroupby_orderbylimit1_{aggregationscale_big}_key_value group by key format Null; SELECT key, value - FROM mingroupby_orderbylimit1_{aggregationscale}_tuple + FROM mingroupby_orderbylimit1_{aggregationscale_small}_tuple order by key, value limit 1 by key format Null; SELECT key, value - FROM mingroupby_orderbylimit1_{aggregationscale}_key_value + FROM mingroupby_orderbylimit1_{aggregationscale_small}_key_value order by key, value limit 1 by key format Null; - DROP TABLE IF EXISTS mingroupby_orderbylimit1_{aggregationscale}_tuple - DROP TABLE IF EXISTS mingroupby_orderbylimit1_{aggregationscale}_key_value + DROP TABLE IF EXISTS mingroupby_orderbylimit1_{aggregationscale_all}_tuple + DROP TABLE IF EXISTS mingroupby_orderbylimit1_{aggregationscale_all}_key_value diff --git a/tests/performance/simple_join_query.xml b/tests/performance/simple_join_query.xml index 8f62ffdfd00..92fdfd23f93 100644 --- a/tests/performance/simple_join_query.xml +++ b/tests/performance/simple_join_query.xml @@ -12,7 +12,7 @@ CREATE TABLE join_table(A Int64, S0 String, S1 String, S2 String, S3 String) ENGINE = MergeTree ORDER BY A - INSERT INTO join_table SELECT number AS A, toString(arrayMap(x->x, range(100))) S0, S0 AS S1, S0 AS S2, S0 AS S3 from numbers(500000) + INSERT INTO join_table SELECT number AS A, toString(arrayMap(x->x, range(100))) S0, S0 AS S1, S0 AS S2, S0 AS S3 from numbers_mt(5000000) SELECT COUNT() FROM join_table LEFT JOIN join_table USING A SELECT COUNT() FROM join_table LEFT JOIN (SELECT A FROM join_table) AS right USING A From aef97164062d6358c053b040786f49c69513e628 Mon Sep 17 00:00:00 2001 From: Ivan Blinkov Date: Fri, 17 Apr 2020 00:55:34 +0300 Subject: [PATCH 72/73] Update index.md --- docs/zh/index.md | 5 ----- 1 file changed, 5 deletions(-) diff --git a/docs/zh/index.md b/docs/zh/index.md index 455a578456b..c6cc5069b14 100644 --- a/docs/zh/index.md +++ b/docs/zh/index.md @@ -1,8 +1,3 @@ ---- -machine_translated: true -machine_translated_rev: b111334d6614a02564cf32f379679e9ff970d9b1 ---- - # 什么是ClickHouse？ {#shi-yao-shi-clickhouse} ClickHouse是一个用于联机分析(OLAP)的列式数据库管理系统(DBMS)。 From 9b66f33eb5ddd028d8cc134ef3a26c1cd84d53fc Mon Sep 17 00:00:00 2001 From: Alexander Kuzmenkov Date: Fri, 17 Apr 2020 01:25:08 +0300 Subject: [PATCH 73/73] performance comparison --- docker/test/performance-comparison/entrypoint.sh | 3 --- docker/test/performance-comparison/perf.py | 2 +- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/docker/test/performance-comparison/entrypoint.sh b/docker/test/performance-comparison/entrypoint.sh index dc0480715d0..b125d624bfe 100755 --- a/docker/test/performance-comparison/entrypoint.sh +++ b/docker/test/performance-comparison/entrypoint.sh @@ -87,9 +87,6 @@ git -C ch diff --name-only "$SHA_TO_TEST" "$(git -C ch merge-base "$SHA_TO_TEST" # Set python output encoding so that we can print queries with Russian letters. export PYTHONIOENCODING=utf-8 -# Use a default number of runs if not told otherwise -export CHPC_RUNS=${CHPC_RUNS:-7} - # By default, use the main comparison script from the tested package, so that we # can change it in PRs. script_path="right/scripts" diff --git a/docker/test/performance-comparison/perf.py b/docker/test/performance-comparison/perf.py index 55d93f89c6e..9be84fdc4b6 100755 --- a/docker/test/performance-comparison/perf.py +++ b/docker/test/performance-comparison/perf.py @@ -25,7 +25,7 @@ parser = argparse.ArgumentParser(description='Run performance test.') parser.add_argument('file', metavar='FILE', type=argparse.FileType('r', encoding='utf-8'), nargs=1, help='test description file') parser.add_argument('--host', nargs='*', default=['localhost'], help="Server hostname(s). Corresponds to '--port' options.") parser.add_argument('--port', nargs='*', default=[9000], help="Server port(s). Corresponds to '--host' options.") -parser.add_argument('--runs', type=int, default=int(os.environ.get('CHPC_RUNS', 7)), help='Number of query runs per server. Defaults to CHPC_RUNS environment variable.') +parser.add_argument('--runs', type=int, default=int(os.environ.get('CHPC_RUNS', 11)), help='Number of query runs per server. Defaults to CHPC_RUNS environment variable.') parser.add_argument('--no-long', type=bool, default=True, help='Skip the tests tagged as long.') args = parser.parse_args()