From bc0d9a2cae28f162ac2bfa3332bf2ca45bde2fd3 Mon Sep 17 00:00:00 2001 From: f1yegor Date: Sat, 25 Mar 2017 21:12:56 +0100 Subject: [PATCH 1/2] translate comments --- .../AggregateFunctionDebug.cpp | 20 +-- .../AggregateFunctionFactory.cpp | 22 +-- .../AggregateFunctionUniqUpTo.cpp | 2 +- .../AggregateFunctionsUniq.cpp | 8 +- dbms/src/Client/Benchmark.cpp | 4 +- dbms/src/Client/InterruptListener.h | 12 +- dbms/src/Client/MultiplexedConnections.cpp | 18 +-- dbms/src/Client/config.xml | 2 +- dbms/src/Columns/ColumnAggregateFunction.cpp | 45 +++--- dbms/src/Columns/ColumnArray.cpp | 22 +-- dbms/src/Columns/ColumnsCommon.cpp | 10 +- dbms/src/Common/FileChecker.cpp | 10 +- dbms/src/Common/ShellCommand.cpp | 26 ++-- dbms/src/Common/StackTrace.cpp | 2 +- dbms/src/Common/VirtualColumnUtils.cpp | 12 +- dbms/src/Common/escapeForFileName.cpp | 2 +- dbms/src/Common/isLocalAddress.cpp | 6 +- dbms/src/Common/localBackup.cpp | 10 +- dbms/src/Common/tests/AvalancheTest.cpp | 2 +- dbms/src/Common/tests/AvalancheTest.h | 2 +- dbms/src/Common/tests/Random.cpp | 2 +- dbms/src/Common/tests/Random.h | 2 +- .../Common/tests/arena_with_free_lists.cpp | 12 +- dbms/src/Common/tests/compact_array.cpp | 2 +- dbms/src/Common/tests/int_hashes_perf.cpp | 8 +- .../src/Common/tests/parallel_aggregation.cpp | 92 +++++------ .../Common/tests/parallel_aggregation2.cpp | 2 +- dbms/src/Common/tests/sip_hash.cpp | 2 +- dbms/src/Common/tests/sip_hash_perf.cpp | 2 +- dbms/src/Core/Block.cpp | 30 ++-- dbms/src/Core/BlockInfo.cpp | 6 +- dbms/src/Core/ErrorCodes.cpp | 10 +- dbms/src/Core/NamesAndTypes.cpp | 2 +- .../AddingDefaultBlockOutputStream.cpp | 4 +- .../AggregatingBlockInputStream.cpp | 6 +- .../AggregatingSortedBlockInputStream.cpp | 20 +-- .../DataStreams/BlockStreamProfileInfo.cpp | 8 +- dbms/src/DataStreams/CSVRowInputStream.cpp | 16 +- .../CollapsingFinalBlockInputStream.cpp | 14 +- .../CollapsingSortedBlockInputStream.cpp | 22 +-- .../CreatingSetsBlockInputStream.cpp | 6 +- .../DataStreams/FilterBlockInputStream.cpp | 46 +++--- dbms/src/DataStreams/FormatFactory.cpp | 4 +- .../GraphiteRollupSortedBlockInputStream.cpp | 24 +-- dbms/src/DataStreams/IBlockInputStream.cpp | 6 +- .../IProfilingBlockInputStream.cpp | 24 +-- .../DataStreams/JSONEachRowRowInputStream.cpp | 20 +-- .../src/DataStreams/LimitBlockInputStream.cpp | 6 +- .../MergingSortedBlockInputStream.cpp | 28 ++-- .../DataStreams/NativeBlockInputStream.cpp | 10 +- .../DataStreams/NativeBlockOutputStream.cpp | 28 ++-- .../ParallelAggregatingBlockInputStream.cpp | 14 +- .../DataStreams/PrettyBlockOutputStream.cpp | 8 +- .../PrettyCompactBlockOutputStream.cpp | 6 +- .../PrettySpaceBlockOutputStream.cpp | 6 +- .../DataStreams/RemoteBlockInputStream.cpp | 41 ++--- .../ReplacingSortedBlockInputStream.cpp | 12 +- .../SummingSortedBlockInputStream.cpp | 40 ++--- dbms/src/DataStreams/TSKVRowInputStream.cpp | 38 ++--- .../TabSeparatedRowInputStream.cpp | 12 +- .../TotalsHavingBlockInputStream.cpp | 12 +- dbms/src/DataStreams/ValuesRowInputStream.cpp | 16 +- dbms/src/DataStreams/XMLRowOutputStream.cpp | 4 +- dbms/src/DataStreams/copyData.cpp | 2 +- .../src/DataStreams/glueBlockInputStreams.cpp | 2 +- .../tests/block_tab_separated_streams.cpp | 4 +- .../tests/filter_stream_hitlog.cpp | 4 +- dbms/src/DataStreams/tests/native_streams.cpp | 6 +- dbms/src/DataStreams/tests/sorting_stream.cpp | 4 +- dbms/src/DataTypes/DataTypeArray.cpp | 16 +- dbms/src/DataTypes/DataTypeDate.cpp | 2 +- dbms/src/DataTypes/DataTypeDateTime.cpp | 2 +- dbms/src/DataTypes/DataTypeEnum.cpp | 4 +- dbms/src/DataTypes/DataTypeNumberBase.cpp | 4 +- dbms/src/DataTypes/DataTypeString.cpp | 12 +- dbms/src/DataTypes/DataTypeTuple.cpp | 2 +- dbms/src/DataTypes/FieldToDataType.cpp | 16 +- dbms/src/Databases/DatabaseCloud.cpp | 110 ++++++------- dbms/src/Databases/DatabaseMemory.cpp | 4 +- dbms/src/Databases/DatabaseOrdinary.cpp | 54 +++---- dbms/src/Databases/DatabasesCommon.cpp | 10 +- dbms/src/Dictionaries/DictionaryStructure.cpp | 6 +- .../Embedded/RegionsHierarchy.cpp | 6 +- .../Dictionaries/Embedded/RegionsNames.cpp | 2 +- .../Dictionaries/MySQLDictionarySource.cpp | 4 +- dbms/src/Functions/FunctionFactory.cpp | 4 +- dbms/src/Functions/FunctionsArray.cpp | 32 ++-- dbms/src/Functions/FunctionsConditional.cpp | 2 +- dbms/src/Functions/FunctionsMiscellaneous.cpp | 147 +++++++++--------- dbms/src/Functions/FunctionsString.cpp | 36 ++--- dbms/src/Functions/FunctionsStringSearch.cpp | 96 ++++++------ .../tests/logical_functions_performance.cpp | 26 ++-- dbms/src/IO/CachedCompressedReadBuffer.cpp | 6 +- dbms/src/IO/CompressedReadBuffer.cpp | 6 +- dbms/src/IO/CompressedReadBufferFromFile.cpp | 10 +- dbms/src/IO/CompressedWriteBuffer.cpp | 2 +- dbms/src/IO/HashingWriteBuffer.cpp | 12 +- dbms/src/IO/InterserverWriteBuffer.cpp | 4 +- dbms/src/IO/ReadBufferAIO.cpp | 30 ++-- dbms/src/IO/ReadBufferFromPocoSocket.cpp | 2 +- dbms/src/IO/ReadHelpers.cpp | 34 ++-- dbms/src/IO/WriteBufferAIO.cpp | 50 +++--- dbms/src/IO/WriteBufferFromPocoSocket.cpp | 2 +- dbms/src/IO/copyData.cpp | 8 +- .../src/IO/tests/o_direct_and_dirty_pages.cpp | 4 +- dbms/src/IO/tests/parse_int_perf.cpp | 4 +- 106 files changed, 851 insertions(+), 852 deletions(-) diff --git a/dbms/src/AggregateFunctions/AggregateFunctionDebug.cpp b/dbms/src/AggregateFunctions/AggregateFunctionDebug.cpp index a9d1cf8459a..9906ed139c3 100644 --- a/dbms/src/AggregateFunctions/AggregateFunctionDebug.cpp +++ b/dbms/src/AggregateFunctions/AggregateFunctionDebug.cpp @@ -10,18 +10,18 @@ namespace DB { -/** Управление состояниями агрегатных функций делается нетривиальным образом: - * - память для них нужно выделяется в пуле, - * указатели на эти состояния могут передаваться между различными структурами данных, - * при этом нельзя сделать RAII-обёртки для каждого отдельного состояния. - * Подробнее см. Aggregator.h. +/** State management of aggregate functions is done in a non-trivial way: + * - the memory for them needs to be allocated in the pool, + * pointers to these states can be passed between different data structures, + * herewith, you can not make RAII wrappers for each individual state. + * For more information, see Aggregator.h. * - * В связи с этим, возникают трудно-отлаживаемые баги. - * Для упрощения воспроизведения багов, была написана агрегатная функция debug, - * и её исходники решено не удалять после отладки. + * In this regard, there are difficult-debugging bugs. + * To simplify the playback of bugs, an aggregate `debug` function was written, + * and its source code is decided not to delete after debugging. * - * Эта агрегатная функция принимает ноль аргументов и ничего не делает. - * Но у неё сделано состояние, которое нетривиально создаётся и уничтожается. + * This aggregate function takes zero arguments and does nothing. + * But it has a state that is non-trivially created and destroyed. */ diff --git a/dbms/src/AggregateFunctions/AggregateFunctionFactory.cpp b/dbms/src/AggregateFunctions/AggregateFunctionFactory.cpp index c35d5917fab..8d475d25a01 100644 --- a/dbms/src/AggregateFunctions/AggregateFunctionFactory.cpp +++ b/dbms/src/AggregateFunctions/AggregateFunctionFactory.cpp @@ -22,7 +22,7 @@ namespace ErrorCodes namespace { -/// Ничего не проверяет. +/// Does not check anything. std::string trimRight(const std::string & in, const char * suffix) { return in.substr(0, in.size() - strlen(suffix)); @@ -161,14 +161,14 @@ AggregateFunctionPtr AggregateFunctionFactory::getImpl(const String & name, cons if ((recursion_level == 0) && endsWith(name, "State")) { - /// Для агрегатных функций вида aggState, где agg - имя другой агрегатной функции. + /// For aggregate functions of the form `aggState`, where `agg` is the name of another aggregate function. AggregateFunctionPtr nested = get(trimRight(name, "State"), argument_types, recursion_level + 1); return createAggregateFunctionState(nested); } if ((recursion_level <= 1) && endsWith(name, "Merge")) { - /// Для агрегатных функций вида aggMerge, где agg - имя другой агрегатной функции. + /// For aggregate functions of the form `aggMerge`, where `agg` is the name of another aggregate function. if (argument_types.size() != 1) throw Exception("Incorrect number of arguments for aggregate function " + name, ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH); const DataTypeAggregateFunction * function = typeid_cast(&*argument_types[0]); @@ -193,7 +193,7 @@ AggregateFunctionPtr AggregateFunctionFactory::getImpl(const String & name, cons ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH }; - /// Для агрегатных функций вида aggIf, где agg - имя другой агрегатной функции. + /// For aggregate functions of the form `aggIf`, where `agg` is the name of another aggregate function. DataTypes nested_dt = argument_types; nested_dt.pop_back(); AggregateFunctionPtr nested = get(trimRight(name, "If"), nested_dt, recursion_level + 1); @@ -202,7 +202,7 @@ AggregateFunctionPtr AggregateFunctionFactory::getImpl(const String & name, cons if ((recursion_level <= 3) && endsWith(name, "Array")) { - /// Для агрегатных функций вида aggArray, где agg - имя другой агрегатной функции. + /// For aggregate functions of the form `aggArray`, where `agg` is the name of another aggregate function. size_t num_agruments = argument_types.size(); DataTypes nested_arguments; @@ -214,7 +214,7 @@ AggregateFunctionPtr AggregateFunctionFactory::getImpl(const String & name, cons throw Exception("Illegal type " + argument_types[i]->getName() + " of argument #" + toString(i + 1) + " for aggregate function " + name + ". Must be array.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); } - /// + 3, чтобы ни один другой модификатор не мог идти перед Array + /// + 3, so that no other modifier can go before the `Array` AggregateFunctionPtr nested = get(trimRight(name, "Array"), nested_arguments, recursion_level + 3); return createAggregateFunctionArray(nested); } @@ -239,22 +239,22 @@ bool AggregateFunctionFactory::isAggregateFunctionName(const String & name, int if (recursion_level == 0 && case_insensitive_aggregate_functions.count(Poco::toLower(name))) return true; - /// Для агрегатных функций вида aggState, где agg - имя другой агрегатной функции. + /// For aggregate functions of the form `aggState`, where `agg` is the name of another aggregate function. if ((recursion_level <= 0) && endsWith(name, "State")) return isAggregateFunctionName(trimRight(name, "State"), recursion_level + 1); - /// Для агрегатных функций вида aggMerge, где agg - имя другой агрегатной функции. + /// For aggregate functions of the form `aggMerge`, where `agg` is the name of another aggregate function. if ((recursion_level <= 1) && endsWith(name, "Merge")) return isAggregateFunctionName(trimRight(name, "Merge"), recursion_level + 1); - /// Для агрегатных функций вида aggIf, где agg - имя другой агрегатной функции. + /// For aggregate functions of the form `aggIf`, where `agg` is the name of another aggregate function. if ((recursion_level <= 2) && endsWith(name, "If")) return isAggregateFunctionName(trimRight(name, "If"), recursion_level + 1); - /// Для агрегатных функций вида aggArray, где agg - имя другой агрегатной функции. + /// For aggregate functions of the form `aggArray`, where `agg` is the name of another aggregate function. if ((recursion_level <= 3) && endsWith(name, "Array")) { - /// + 3, чтобы ни один другой модификатор не мог идти перед Array + /// + 3, so that no other modifier can go before `Array` return isAggregateFunctionName(trimRight(name, "Array"), recursion_level + 3); } diff --git a/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp b/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp index 78df3adc09a..727c81d571a 100644 --- a/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp +++ b/dbms/src/AggregateFunctions/AggregateFunctionUniqUpTo.cpp @@ -31,7 +31,7 @@ AggregateFunctionPtr createAggregateFunctionUniqUpTo(const std::string & name, c } else if (argument_types.size() > 1) { - /// Если аргументов несколько, то среди них недопустимо наличие кортежей. + /// If there are several arguments, then no tuples allowed among them. for (const auto & type : argument_types) if (typeid_cast(type.get())) throw Exception("Tuple argument of function " + name + " must be the only argument", diff --git a/dbms/src/AggregateFunctions/AggregateFunctionsUniq.cpp b/dbms/src/AggregateFunctions/AggregateFunctionsUniq.cpp index 387ca3ca8d2..3829c7a04e4 100644 --- a/dbms/src/AggregateFunctions/AggregateFunctionsUniq.cpp +++ b/dbms/src/AggregateFunctions/AggregateFunctionsUniq.cpp @@ -8,8 +8,8 @@ namespace DB namespace { -/** DataForVariadic - структура с данными, которая будет использоваться для агрегатной функции uniq от множества аргументов. - * Отличается, например, тем, что использует тривиальную хэш-функцию, так как uniq от множества аргументов сначала самостоятельно их хэширует. +/** `DataForVariadic` is a data structure that will be used for `uniq` aggregate function of multiple arguments. + * It differs, for example, in that it uses a trivial hash function, since `uniq` of many arguments first hashes them out itself. */ template @@ -37,7 +37,7 @@ AggregateFunctionPtr createAggregateFunctionUniq(const std::string & name, const } else if (argument_types.size() > 1) { - /// Если аргументов несколько, то среди них недопустимо наличие кортежей. + /// If there are several arguments, then no tuples allowed among them. for (const auto & type : argument_types) if (typeid_cast(type.get())) throw Exception("Tuple argument of function " + name + " must be the only argument", @@ -75,7 +75,7 @@ AggregateFunctionPtr createAggregateFunctionUniq(const std::string & name, const } else if (argument_types.size() > 1) { - /// Если аргументов несколько, то среди них недопустимо наличие кортежей. + /// If there are several arguments, then no tuples allowed among them. for (const auto & type : argument_types) if (typeid_cast(type.get())) throw Exception("Tuple argument of function " + name + " must be the only argument", diff --git a/dbms/src/Client/Benchmark.cpp b/dbms/src/Client/Benchmark.cpp index 01e19aef1bd..a8daa0fea3c 100644 --- a/dbms/src/Client/Benchmark.cpp +++ b/dbms/src/Client/Benchmark.cpp @@ -260,7 +260,7 @@ private: try { - /// В этих потоках не будем принимать сигнал INT. + /// In these threads we do not accept INT signal. sigset_t sig_set; if (sigemptyset(&sig_set) || sigaddset(&sig_set, SIGINT) @@ -451,7 +451,7 @@ int mainEntryClickHouseBenchmark(int argc, char ** argv) print_stacktrace = options.count("stacktrace"); - /// Извлекаем settings and limits из полученных options + /// Extract `settings` and `limits` from received `options` Settings settings; #define EXTRACT_SETTING(TYPE, NAME, DEFAULT) \ diff --git a/dbms/src/Client/InterruptListener.h b/dbms/src/Client/InterruptListener.h index 85dc06fc39d..cb481f4d369 100644 --- a/dbms/src/Client/InterruptListener.h +++ b/dbms/src/Client/InterruptListener.h @@ -39,11 +39,11 @@ static int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct times #endif -/** Пока существует объект этого класса - блокирует сигнал INT, при этом позволяет узнать, не пришёл ли он. - * Это нужно, чтобы можно было прервать выполнение запроса с помощью Ctrl+C. - * В один момент времени используйте только один экземпляр этого класса. - * Если метод check вернул true (пришёл сигнал), то следующие вызовы будут ждать следующий сигнал. - */ +/** As long as there exists an object of this class - it blocks the INT signal, at the same time it lets you know if it came. +  * This is necessary so that you can interrupt the execution of the request with Ctrl+C. +  * Use only one instance of this class at a time. +  * If `check` method returns true (the signal has arrived), the next call will wait for the next signal. +  */ class InterruptListener { private: @@ -94,7 +94,7 @@ public: } } - /// Можно прекратить блокировать сигнал раньше, чем в деструкторе. + /// You can stop blocking the signal earlier than in the destructor. void unblock() { if (active) diff --git a/dbms/src/Client/MultiplexedConnections.cpp b/dbms/src/Client/MultiplexedConnections.cpp index a3774a62924..fa4d97a1620 100644 --- a/dbms/src/Client/MultiplexedConnections.cpp +++ b/dbms/src/Client/MultiplexedConnections.cpp @@ -113,7 +113,7 @@ void MultiplexedConnections::sendQuery( { if (settings == nullptr) { - /// Каждый шард имеет один адрес. + /// Each shard has one address. auto it = connections.begin(); for (size_t i = 0; i < shard_states.size(); ++i) { @@ -127,7 +127,7 @@ void MultiplexedConnections::sendQuery( } else { - /// Каждый шард имеет одну или несколько реплик. + /// Each shard has one or more replicas. auto it = connections.begin(); for (const auto & shard_state : shard_states) { @@ -244,7 +244,7 @@ Connection::Packet MultiplexedConnections::drain() case Protocol::Server::Exception: default: - /// Если мы получили исключение или неизвестный пакет, сохраняем его. + /// If we receive an exception or an unknown package, we save it. res = std::move(packet); break; } @@ -281,8 +281,8 @@ void MultiplexedConnections::initFromShard(IConnectionPool * pool) { auto entries = pool->getMany(settings, pool_mode); - /// Если getMany() не выделил соединений и не кинул исключения, это значит, что была - /// установлена настройка skip_unavailable_shards. Тогда просто возвращаемся. + /// If getMany() did not allocate connections and did not throw exceptions, this means that + /// `skip_unavailable_shards` was set. Then just return. if (entries.empty()) return; @@ -396,8 +396,8 @@ MultiplexedConnections::ReplicaMap::iterator MultiplexedConnections::waitForRead Poco::Net::Socket::SocketList read_list; read_list.reserve(active_connection_total_count); - /// Сначала проверяем, есть ли данные, которые уже лежат в буфере - /// хоть одного соединения. + /// First, we check if there are data already in the buffer + /// of at least one connection. for (const auto & e : replica_map) { const ReplicaState & state = e.second; @@ -406,8 +406,8 @@ MultiplexedConnections::ReplicaMap::iterator MultiplexedConnections::waitForRead read_list.push_back(connection->socket); } - /// Если не было найдено никаких данных, то проверяем, есть ли соединения - /// готовые для чтения. + /// If no data was found, then we check if there are any connections + /// ready for reading. if (read_list.empty()) { Poco::Net::Socket::SocketList write_list; diff --git a/dbms/src/Client/config.xml b/dbms/src/Client/config.xml index c5e4b75f69a..2b93a4ce288 100644 --- a/dbms/src/Client/config.xml +++ b/dbms/src/Client/config.xml @@ -1,3 +1,3 @@ - + diff --git a/dbms/src/Columns/ColumnAggregateFunction.cpp b/dbms/src/Columns/ColumnAggregateFunction.cpp index e1f6723590a..f5334441ef3 100644 --- a/dbms/src/Columns/ColumnAggregateFunction.cpp +++ b/dbms/src/Columns/ColumnAggregateFunction.cpp @@ -28,36 +28,35 @@ ColumnPtr ColumnAggregateFunction::convertToValues() const const IAggregateFunction * function = func.get(); ColumnPtr res = function->getReturnType()->createColumn(); - /** Если агрегатная функция возвращает нефинализированное состояние, - * то надо просто скопировать указатели на него а также разделяемое владение данными. + /** If the aggregate function returns an unfinalized/unfinished state, + * then you just need to copy pointers to it and also shared ownership of data. * - * Также заменяем агрегатную функцию на вложенную. - * То есть, если этот столбец - состояния агрегатной функции aggState, - * то мы возвращаем такой же столбец, но с состояниями агрегатной функции agg. - * Это одни и те же состояния, меняем только функцию, которой они соответствуют. + * Also replace the aggregate function with the nested function. + * That is, if this column is the states of the aggregate function `aggState`, + * then we return the same column, but with the states of the aggregate function `agg`. + * These are the same states, changing only the function to which they correspond. * - * Это довольно сложно для понимания. - * Пример, когда такое происходит: + * Further is quite difficult to understand. + * Example when this happens: * * SELECT k, finalizeAggregation(quantileTimingState(0.5)(x)) FROM ... GROUP BY k WITH TOTALS * - * Здесь вычисляется агрегатная функция quantileTimingState. - * Её тип возвращаемого значения: - * AggregateFunction(quantileTiming(0.5), UInt64). - * Из-за наличия WITH TOTALS, при агрегации будут сохранены состояния этой агрегатной функции - * в столбце ColumnAggregateFunction, имеющего тип + * This calculates the aggregate function `quantileTimingState`. + * Its return type AggregateFunction(quantileTiming(0.5), UInt64)`. + * Due to the presence of WITH TOTALS, during aggregation the states of this aggregate function will be stored + * in the ColumnAggregateFunction column of type * AggregateFunction(quantileTimingState(0.5), UInt64). - * Затем в TotalsHavingBlockInputStream у него будет вызван метод convertToValues, - * чтобы получить "готовые" значения. - * Но он всего лишь преобразует столбец типа - * AggregateFunction(quantileTimingState(0.5), UInt64) - * в AggregateFunction(quantileTiming(0.5), UInt64) - * - в такие же состояния. + * Then, in `TotalsHavingBlockInputStream`, it will be called `convertToValues` ​​method, + * to get the "ready" values. + * But it just converts a column of type + * `AggregateFunction(quantileTimingState(0.5), UInt64)` + * into `AggregateFunction(quantileTiming(0.5), UInt64)` + * - in the same states. * - * Затем будет вычислена функция finalizeAggregation, которая позовёт convertToValues уже от результата. - * И это преобразует столбец типа + * Then `finalizeAggregation` function will be calculated, which will call `convertToValues` ​​already on the result. + * And this converts a column of type * AggregateFunction(quantileTiming(0.5), UInt64) - * в UInt16 - уже готовый результат работы quantileTiming. + * into UInt16 - already finished result of `quantileTiming`. */ if (const AggregateFunctionState * function_state = typeid_cast(function)) { @@ -132,7 +131,7 @@ ColumnPtr ColumnAggregateFunction::filter(const Filter & filter, ssize_t result_ if (filter[i]) res_data.push_back(getData()[i]); - /// Для экономии оперативки в случае слишком сильной фильтрации. + /// To save RAM in case of too strong filtering. if (res_data.size() * 2 < res_data.capacity()) res_data = Container_t(res_data.cbegin(), res_data.cend()); diff --git a/dbms/src/Columns/ColumnArray.cpp b/dbms/src/Columns/ColumnArray.cpp index 81e13d3d048..c375951bce7 100644 --- a/dbms/src/Columns/ColumnArray.cpp +++ b/dbms/src/Columns/ColumnArray.cpp @@ -423,7 +423,7 @@ ColumnPtr ColumnArray::filterString(const Filter & filt, ssize_t result_size_hin Offsets_t & res_string_offsets = typeid_cast(res->getData()).getOffsets(); Offsets_t & res_offsets = res->getOffsets(); - if (result_size_hint < 0) /// Остальные случаи не рассматриваем. + if (result_size_hint < 0) /// Other cases are not considered. { res_chars.reserve(src_chars.size()); res_string_offsets.reserve(src_string_offsets.size()); @@ -438,12 +438,12 @@ ColumnPtr ColumnArray::filterString(const Filter & filt, ssize_t result_size_hin for (size_t i = 0; i < col_size; ++i) { - /// Количество строк в массиве. + /// Number of rows in the array. size_t array_size = src_offsets[i] - prev_src_offset; if (filt[i]) { - /// Если массив не пуст - копируем внутренности. + /// If the array is not empty - copy content. if (array_size) { size_t chars_to_copy = src_string_offsets[array_size + prev_src_offset - 1] - prev_src_string_offset; @@ -494,8 +494,8 @@ ColumnPtr ColumnArray::filterGeneric(const Filter & filt, ssize_t result_size_hi ssize_t nested_result_size_hint = 0; if (result_size_hint < 0) nested_result_size_hint = result_size_hint; - else if (result_size_hint && result_size_hint < 1000000000 && data->size() < 1000000000) /// Избегаем переполнения. - nested_result_size_hint = result_size_hint * data->size() / size; + else if (result_size_hint && result_size_hint < 1000000000 && data->size() < 1000000000) /// Avoid overflow. + nested_result_size_hint = result_size_hint * data->size() / size; res->data = data->filter(nested_filt, nested_result_size_hint); @@ -584,7 +584,7 @@ void ColumnArray::getPermutation(bool reverse, size_t limit, int nan_direction_h ColumnPtr ColumnArray::replicate(const Offsets_t & replicate_offsets) const { - /// Не получается реализовать в общем случае. + /// It does not work out in general case. if (typeid_cast(data.get())) return replicateNumber(replicate_offsets); if (typeid_cast(data.get())) return replicateNumber(replicate_offsets); @@ -688,11 +688,11 @@ ColumnPtr ColumnArray::replicateString(const Offsets_t & replicate_offsets) cons for (size_t i = 0; i < col_size; ++i) { - /// Насколько размножить массив. + /// How much to replicate the array. size_t size_to_replicate = replicate_offsets[i] - prev_replicate_offset; - /// Количество строк в массиве. + /// The number of rows in the array. size_t value_size = src_offsets[i] - prev_src_offset; - /// Количество символов в строках массива, включая нулевые байты. + /// Number of characters in rows of the array, including zero/null bytes. size_t sum_chars_size = value_size == 0 ? 0 : (src_string_offsets[prev_src_offset + value_size - 1] - prev_src_string_offset); for (size_t j = 0; j < size_to_replicate; ++j) @@ -703,7 +703,7 @@ ColumnPtr ColumnArray::replicateString(const Offsets_t & replicate_offsets) cons size_t prev_src_string_offset_local = prev_src_string_offset; for (size_t k = 0; k < value_size; ++k) { - /// Размер одной строки. + /// Size of one row. size_t chars_size = src_string_offsets[k + prev_src_offset] - prev_src_string_offset_local; current_res_string_offset += chars_size; @@ -712,7 +712,7 @@ ColumnPtr ColumnArray::replicateString(const Offsets_t & replicate_offsets) cons prev_src_string_offset_local += chars_size; } - /// Копирование символов массива строк. + /// Copies the characters of the array of rows. res_chars.resize(res_chars.size() + sum_chars_size); memcpySmallAllowReadWriteOverflow15( &res_chars[res_chars.size() - sum_chars_size], &src_chars[prev_src_string_offset], sum_chars_size); diff --git a/dbms/src/Columns/ColumnsCommon.cpp b/dbms/src/Columns/ColumnsCommon.cpp index 1acf6c5c8e8..9474b6e770c 100644 --- a/dbms/src/Columns/ColumnsCommon.cpp +++ b/dbms/src/Columns/ColumnsCommon.cpp @@ -12,9 +12,9 @@ size_t countBytesInFilter(const IColumn::Filter & filt) { size_t count = 0; - /** NOTE: По идее, filt должен содержать только нолики и единички. - * Но, на всякий случай, здесь используется условие > 0 (на знаковые байты). - * Лучше было бы использовать != 0, то это не позволяет SSE2. + /** NOTE: In theory, `filt` should only contain zeros and ones. + * But, just in case, here the condition > 0 (to signed bytes) is used. + * It would be better to use != 0, then this does not allow SSE2. */ const Int8 * pos = reinterpret_cast(&filt[0]); @@ -69,7 +69,7 @@ void filterArraysImpl( if (result_size_hint < 0) res_elems.reserve(src_elems.size()); - else if (result_size_hint < 1000000000 && src_elems.size() < 1000000000) /// Избегаем переполнения. + else if (result_size_hint < 1000000000 && src_elems.size() < 1000000000) /// Avoid overflow. res_elems.reserve((result_size_hint * src_elems.size() + size - 1) / size); } @@ -166,7 +166,7 @@ void filterArraysImpl( } -/// Явные инстанцирования - чтобы не размещать реализацию функции выше в заголовочном файле. +/// Explicit instantiations - not to place the implementation of the function above in the header file. template void filterArraysImpl( const PaddedPODArray &, const IColumn::Offsets_t &, PaddedPODArray &, IColumn::Offsets_t &, diff --git a/dbms/src/Common/FileChecker.cpp b/dbms/src/Common/FileChecker.cpp index b0c2ad02d68..5b44e087f41 100644 --- a/dbms/src/Common/FileChecker.cpp +++ b/dbms/src/Common/FileChecker.cpp @@ -44,8 +44,8 @@ void FileChecker::update(const Files::const_iterator & begin, const Files::const bool FileChecker::check() const { - /** Читаем файлы заново при каждом вызове check - чтобы не нарушать константность. - * Метод check вызывается редко. + /** Read the files again every time you call `check` - so as not to violate the constancy. + * `check` method is rarely called. */ Map local_map; load(local_map); @@ -92,7 +92,7 @@ void FileChecker::save() const { WriteBufferFromFile out(tmp_files_info_path); - /// Столь сложная структура JSON-а - для совместимости со старым форматом. + /// So complex JSON structure - for compatibility with the old format. writeCString("{\"yandex\":{", out); for (auto it = map.begin(); it != map.end(); ++it) @@ -100,7 +100,7 @@ void FileChecker::save() const if (it != map.begin()) writeString(",", out); - /// escapeForFileName на самом деле не нужен. Но он оставлен для совместимости со старым кодом. + /// `escapeForFileName` is not really needed. But it is left for compatibility with the old code. writeJSONString(escapeForFileName(it->first), out); writeString(":{\"size\":\"", out); writeIntText(it->second, out); @@ -136,7 +136,7 @@ void FileChecker::load(Map & map) const ReadBufferFromFile in(files_info_path); WriteBufferFromString out(content); - /// Библиотека JSON не поддерживает пробельные символы. Удаляем их. Неэффективно. + /// The JSON library does not support whitespace. We delete them. Ineffective. while (!in.eof()) { char c; diff --git a/dbms/src/Common/ShellCommand.cpp b/dbms/src/Common/ShellCommand.cpp index 3aeaf4a9d85..2b5567d6244 100644 --- a/dbms/src/Common/ShellCommand.cpp +++ b/dbms/src/Common/ShellCommand.cpp @@ -62,10 +62,10 @@ namespace } }; - /// По этим кодам возврата из дочернего процесса мы узнаем (наверняка) об ошибках при его создании. + /// By these return codes from the child process, we learn (for sure) about errors when creating it. enum class ReturnCodes : int { - CANNOT_DUP_STDIN = 42, /// Значение не принципиально, но выбрано так, чтобы редко конфликтовать с кодом возврата программы. + CANNOT_DUP_STDIN = 42, /// The value is not important, but it is chosen so that it's rare to conflict with the program return code. CANNOT_DUP_STDOUT = 43, CANNOT_DUP_STDERR = 44, CANNOT_EXEC = 45, @@ -79,10 +79,10 @@ namespace DB std::unique_ptr ShellCommand::executeImpl(const char * filename, char * const argv[], bool pipe_stdin_only) { - /** Тут написано, что при обычном вызове vfork, есть шанс deadlock-а в многопоточных программах, - * из-за резолвинга символов в shared-библиотеке: + /** Here it is written that with a normal call `vfork`, there is a chance of deadlock in multithreaded programs, + * because of the resolving of characters in the shared library * http://www.oracle.com/technetwork/server-storage/solaris10/subprocess-136439.html - * Поэтому, отделим резолвинг символа от вызова. + * Therefore, separate the resolving of the symbol from the call. */ static void * real_vfork = dlsym(RTLD_DEFAULT, "vfork"); @@ -100,12 +100,12 @@ std::unique_ptr ShellCommand::executeImpl(const char * filename, c if (0 == pid) { - /// Находимся в свежесозданном процессе. + /// We are in the freshly created process. - /// Почему _exit а не exit? Потому что exit вызывает atexit и деструкторы thread local storage. - /// А там куча мусора (в том числе, например, блокируется mutex). А это нельзя делать после vfork - происходит deadlock. + /// Why `_exit` and not `exit`? Because `exit` calls `atexit` and destructors of thread local storage. + /// And there is a lot of garbage (including, for example, mutex is blocked). And this can not be done after `vfork` - deadlock happens. - /// Заменяем файловые дескрипторы на концы наших пайпов. + /// Replace the file descriptors with the ends of our pipes. if (STDIN_FILENO != dup2(pipe_stdin.read_fd, STDIN_FILENO)) _exit(int(ReturnCodes::CANNOT_DUP_STDIN)); @@ -119,14 +119,14 @@ std::unique_ptr ShellCommand::executeImpl(const char * filename, c } execv(filename, argv); - /// Если процесс запущен, то execv не возвращает сюда. + /// If the process is running, then `execv` does not return here. _exit(int(ReturnCodes::CANNOT_EXEC)); } std::unique_ptr res(new ShellCommand(pid, pipe_stdin.write_fd, pipe_stdout.read_fd, pipe_stderr.read_fd)); - /// Теперь владение файловыми дескрипторами передано в результат. + /// Now the ownership of the file descriptors is passed to the result. pipe_stdin.write_fd = -1; pipe_stdout.read_fd = -1; pipe_stderr.read_fd = -1; @@ -137,8 +137,8 @@ std::unique_ptr ShellCommand::executeImpl(const char * filename, c std::unique_ptr ShellCommand::execute(const std::string & command, bool pipe_stdin_only) { - /// Аргументы в неконстантных кусках памяти (как требуется для execv). - /// Причём, их копирование должно быть совершено раньше вызова vfork, чтобы после vfork делать минимум вещей. + /// Arguments in non-constant chunks of memory (as required for `execv`). + /// Moreover, their copying must be done before calling `vfork`, so after `vfork` do a minimum of things. std::vector argv0("sh", "sh" + strlen("sh") + 1); std::vector argv1("-c", "-c" + strlen("-c") + 1); std::vector argv2(command.data(), command.data() + command.size() + 1); diff --git a/dbms/src/Common/StackTrace.cpp b/dbms/src/Common/StackTrace.cpp index a1f5f0dc734..841220d9d3e 100644 --- a/dbms/src/Common/StackTrace.cpp +++ b/dbms/src/Common/StackTrace.cpp @@ -27,7 +27,7 @@ std::string StackTrace::toString() const { for (size_t i = 0, size = frames_size; i < size; ++i) { - /// Делаем demangling имён. Имя находится в скобках, до символа '+'. + /// We do "demangling" of names. The name is in parenthesis, before the '+' character. char * name_start = nullptr; char * name_end = nullptr; diff --git a/dbms/src/Common/VirtualColumnUtils.cpp b/dbms/src/Common/VirtualColumnUtils.cpp index ea7bde6331a..671cc948cf9 100644 --- a/dbms/src/Common/VirtualColumnUtils.cpp +++ b/dbms/src/Common/VirtualColumnUtils.cpp @@ -93,7 +93,7 @@ void rewriteEntityInAst(ASTPtr ast, const String & column_name, const Field & va asts.insert(asts.begin(), column_value); } -/// Проверка, что функция зависит только от заданных столбцов +/// Verifying that the function depends only on the specified columns static bool isValidFunction(ASTPtr expression, const NameSet & columns) { for (size_t i = 0; i < expression->children.size(); ++i) @@ -108,7 +108,7 @@ static bool isValidFunction(ASTPtr expression, const NameSet & columns) return true; } -/// Извлечь все подфункции главной конъюнкции, но зависящие только от заданных столбцов +/// Extract all subfunctions of the main conjunction, but depending only on the specified columns static void extractFunctions(ASTPtr expression, const NameSet & columns, std::vector & result) { const ASTFunction * function = typeid_cast(&*expression); @@ -123,7 +123,7 @@ static void extractFunctions(ASTPtr expression, const NameSet & columns, std::ve } } -/// Построить конъюнкцию из заданных функций +/// Construct a conjunction from given functions static ASTPtr buildWhereExpression(const ASTs & functions) { if (functions.size() == 0) return nullptr; @@ -148,7 +148,7 @@ bool filterBlockWithQuery(ASTPtr query, Block & block, const Context & context) for (const auto & it : block.getColumnsList()) columns.insert(it.name); - /// Составим выражение, вычисляющее выражения в WHERE и PREWHERE, зависящие только от имеющихся столбцов. + /// We will create an expression that evaluates the expressions in WHERE and PREWHERE, depending only on the existing columns. std::vector functions; if (select.where_expression) extractFunctions(select.where_expression, columns, functions); @@ -158,12 +158,12 @@ bool filterBlockWithQuery(ASTPtr query, Block & block, const Context & context) if (!expression_ast) return false; - /// Распарсим и вычислим выражение. + /// Let's parse and calculate the expression. ExpressionAnalyzer analyzer(expression_ast, context, {}, block.getColumnsList()); ExpressionActionsPtr actions = analyzer.getActions(false); actions->execute(block); - /// Отфильтруем блок. + /// Filter the block. String filter_column_name = expression_ast->getColumnName(); ColumnPtr filter_column = block.getByName(filter_column_name).column; if (auto converted = filter_column->convertToFullColumnIfConst()) diff --git a/dbms/src/Common/escapeForFileName.cpp b/dbms/src/Common/escapeForFileName.cpp index 9956300cc9b..f79c3946064 100644 --- a/dbms/src/Common/escapeForFileName.cpp +++ b/dbms/src/Common/escapeForFileName.cpp @@ -44,7 +44,7 @@ std::string unescapeForFileName(const std::string & s) res += *pos; else { - /// пропустим '%' + /// skip '%' if (++pos == end) break; char val = unhex(*pos) * 16; diff --git a/dbms/src/Common/isLocalAddress.cpp b/dbms/src/Common/isLocalAddress.cpp index ea830bc4fb1..8dbcdfeb112 100644 --- a/dbms/src/Common/isLocalAddress.cpp +++ b/dbms/src/Common/isLocalAddress.cpp @@ -19,9 +19,9 @@ bool isLocalAddress(const Poco::Net::SocketAddress & address) return interfaces.end() != std::find_if(interfaces.begin(), interfaces.end(), [&] (const Poco::Net::NetworkInterface & interface) { - /** Сравниваем адреса без учёта scope. - * Теоретически, это может быть неверно - зависит от настройки route - * - через какой интерфейс мы на самом деле будем обращаться к заданному адресу. + /** Compare the addresses without taking into account `scope`. + * Theoretically, this may not be correct - depends on `route` setting + * - through which interface we will actually access the specified address. */ return interface.address().length() == address.host().length() && 0 == memcmp(interface.address().addr(), address.host().addr(), address.host().length()); diff --git a/dbms/src/Common/localBackup.cpp b/dbms/src/Common/localBackup.cpp index 6efce719d78..fdd40a22944 100644 --- a/dbms/src/Common/localBackup.cpp +++ b/dbms/src/Common/localBackup.cpp @@ -41,8 +41,8 @@ static void localBackupImpl(Poco::Path source_path, Poco::Path destination_path, std::string source_str = source.toString(); std::string destination_str = destination.toString(); - /** Пытаемся создать hard link. - * Если он уже существует, то проверим, что source и destination указывают на один и тот же inode. + /** We are trying to create a hard link. + * If it already exists, we check that source and destination point to the same inode. */ if (0 != link(source_str.c_str(), destination_str.c_str())) { @@ -84,9 +84,9 @@ void localBackup(Poco::Path source_path, Poco::Path destination_path) size_t try_no = 0; const size_t max_tries = 10; - /** В директории могут постоянно добавляться и удаляться файлы. - * Если какой-то файл удалился во время попытки сделать бэкап, то повторим попытку снова, - * так как важно учесть какие-нибудь новые файлы, который могли появиться. + /** Files in the directory can be permanently added and deleted. + * If some file is deleted during an attempt to make a backup, then try again, + * because it's important to take into account any new files that might appear. */ while (true) { diff --git a/dbms/src/Common/tests/AvalancheTest.cpp b/dbms/src/Common/tests/AvalancheTest.cpp index de0119c9dd9..5257a5385bd 100644 --- a/dbms/src/Common/tests/AvalancheTest.cpp +++ b/dbms/src/Common/tests/AvalancheTest.cpp @@ -1,4 +1,4 @@ -/// Взято из SMHasher. +/// Taken from SMHasher. #include "AvalancheTest.h" diff --git a/dbms/src/Common/tests/AvalancheTest.h b/dbms/src/Common/tests/AvalancheTest.h index b63dd0b6ade..5c1cc6c20de 100644 --- a/dbms/src/Common/tests/AvalancheTest.h +++ b/dbms/src/Common/tests/AvalancheTest.h @@ -1,4 +1,4 @@ -/// Взято из SMHasher. +/// Taken from SMHasher. //----------------------------------------------------------------------------- // Flipping a single bit of a key should cause an "avalanche" of changes in diff --git a/dbms/src/Common/tests/Random.cpp b/dbms/src/Common/tests/Random.cpp index 934e9024ba5..e8aeee0a3ea 100644 --- a/dbms/src/Common/tests/Random.cpp +++ b/dbms/src/Common/tests/Random.cpp @@ -1,4 +1,4 @@ -/// Взято из SMHasher. +/// Taken from SMHasher. #ifdef __APPLE__ #include #endif diff --git a/dbms/src/Common/tests/Random.h b/dbms/src/Common/tests/Random.h index 6681c9c2acb..382f5fb16c1 100644 --- a/dbms/src/Common/tests/Random.h +++ b/dbms/src/Common/tests/Random.h @@ -1,4 +1,4 @@ -/// Взято из SMHasher. +/// Taken from SMHasher. #pragma once diff --git a/dbms/src/Common/tests/arena_with_free_lists.cpp b/dbms/src/Common/tests/arena_with_free_lists.cpp index 85398098bb3..df4b89a5954 100644 --- a/dbms/src/Common/tests/arena_with_free_lists.cpp +++ b/dbms/src/Common/tests/arena_with_free_lists.cpp @@ -1,4 +1,4 @@ -/** Запускать так (пример): +/** Run this (example) * ./arena_with_free_lists 5000000 < ../../Server/data/test/hits/20140317_20140323_2_178_4/Title.bin */ @@ -25,7 +25,7 @@ using namespace DB; -/// Реализация ArenaWithFreeLists, которая содержит баг. Используется, чтобы воспроизвести баг. +/// Implementation of ArenaWithFreeLists, which contains a bug. Used to reproduce the bug. #if USE_BAD_ARENA class ArenaWithFreeLists : private Allocator @@ -47,7 +47,7 @@ private: static auto sizeToPreviousPowerOfTwo(const int size) { return _bit_scan_reverse(size - 1); - /// Баг расположен в строчке выше. Если заменить на следующую строчку, то баг исправляется. + /// The bug is located in the line above. If you change to the next line, then the bug is fixed. //return size <= 1 ? 0 : _bit_scan_reverse(size - 1); } @@ -110,7 +110,7 @@ public: block->next = old; } - /// Размер выделенного пула в байтах + /// Size of the allocated pool in bytes size_t size() const { return pool.size(); @@ -120,7 +120,7 @@ public: #endif -/// Небольшой кусочек, выдранный из CacheDictionary. Используется только для того, чтобы продемонстрировать проблему. +/// A small piece copied from the CacheDictionary. It is used only to demonstrate the problem. struct Dictionary { template using ContainerType = Value[]; @@ -158,7 +158,7 @@ struct Dictionary std::unique_ptr string_arena; - /// Эта функция компилируется в точно такой же машинный код, как в продакшене, когда был баг. + /// This function is compiled into exactly the same machine code as in production, when there was a bug. void NO_INLINE setAttributeValue(Attribute & attribute, const UInt64 idx, const Field & value) const { switch (attribute.type) diff --git a/dbms/src/Common/tests/compact_array.cpp b/dbms/src/Common/tests/compact_array.cpp index 1f60dedf2dc..3d194e9f682 100644 --- a/dbms/src/Common/tests/compact_array.cpp +++ b/dbms/src/Common/tests/compact_array.cpp @@ -1,4 +1,4 @@ -/// Баг в GCC: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124 +/// Bug in GCC: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59124 #if !__clang__ #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Warray-bounds" diff --git a/dbms/src/Common/tests/int_hashes_perf.cpp b/dbms/src/Common/tests/int_hashes_perf.cpp index 4fe0465f1e1..3f7f8d6f258 100644 --- a/dbms/src/Common/tests/int_hashes_perf.cpp +++ b/dbms/src/Common/tests/int_hashes_perf.cpp @@ -9,7 +9,7 @@ #include #include -#include "AvalancheTest.h" /// Взято из SMHasher. +#include "AvalancheTest.h" /// Taken from SMHasher. #ifdef __APPLE__ @@ -214,7 +214,7 @@ void report(const char * name, size_t n, double elapsed, UInt64 tsc_diff, size_t template static inline void test(size_t n, const UInt64 * data, const char * name) { - /// throughput. Вычисления хэш-функций от разных значений могут перекрываться. + /// throughput. Calculations of hash functions from different values ​​may overlap. { Stopwatch watch; @@ -232,7 +232,7 @@ static inline void test(size_t n, const UInt64 * data, const char * name) report(name, n, watch.elapsedSeconds(), tsc_diff, res); } - /// latency. Чтобы вычислить следующее значение, надо сначала вычислить предыдущее. Добавляется latency L1-кэша. + /// latency. To calculate the next value, you must first calculate the previous one. The latency of the L1 cache is added. { Stopwatch watch; @@ -254,7 +254,7 @@ static inline void test(size_t n, const UInt64 * data, const char * name) report(name, n, watch.elapsedSeconds(), tsc_diff, res); } - /// quality. Методы взяты из SMHasher. + /// quality. Methods are taken from SMHasher. { auto wrapper = [](const void * blob, const int len, const uint32_t seed, void * out) { diff --git a/dbms/src/Common/tests/parallel_aggregation.cpp b/dbms/src/Common/tests/parallel_aggregation.cpp index 6e9f0875ad6..9ed8719ddce 100644 --- a/dbms/src/Common/tests/parallel_aggregation.cpp +++ b/dbms/src/Common/tests/parallel_aggregation.cpp @@ -140,7 +140,7 @@ void aggregate3(Map & local_map, Map & global_map, Mutex & mutex, Source::const_ if (found != local_map.end()) ++found->second; else if (local_map.size() < threshold) - ++local_map[*it]; /// TODO Можно было бы делать один lookup, а не два. + ++local_map[*it]; /// TODO You could do one lookup, not two. else { if (mutex.try_lock()) @@ -228,7 +228,7 @@ void aggregate5(Map & local_map, MapSmallLocks & global_map, Source::const_itera if (found != local_map.end()) ++found->second; else if (local_map.size() < threshold) - ++local_map[*it]; /// TODO Можно было бы делать один lookup, а не два. + ++local_map[*it]; /// TODO You could do one lookup, not two. else { SmallScopedLock lock; @@ -274,9 +274,9 @@ int main(int argc, char ** argv) if (!method || method == 1) { - /** Вариант 1. - * В разных потоках агрегируем независимо в разные хэш-таблицы. - * Затем сливаем их вместе. + /** Option 1. + * In different threads, we aggregate independently into different hash tables. + * Then merge them together. */ std::vector maps(num_threads); @@ -330,7 +330,7 @@ int main(int argc, char ** argv) if (!method || method == 12) { - /** То же самое, но с оптимизацией для подряд идущих одинаковых значений. + /** The same, but with optimization for consecutive identical values. */ std::vector maps(num_threads); @@ -385,11 +385,11 @@ int main(int argc, char ** argv) if (!method || method == 11) { - /** Вариант 11. - * То же, что вариант 1, но при мердже, изменён порядок циклов, - * что потенциально может дать лучшую кэш-локальность. + /** Option 11. + * Same as option 1, but with merge, the order of the cycles is changed, + * which potentially can give better cache locality. * - * На практике, разницы нет. + * In practice, there is no difference. */ std::vector maps(num_threads); @@ -460,12 +460,12 @@ int main(int argc, char ** argv) if (!method || method == 2) { - /** Вариант 2. - * В разных потоках агрегируем независимо в разные two-level хэш-таблицы. - * Затем сливаем их вместе, распараллелив по bucket-ам первого уровня. - * При использовании хэш-таблиц больших размеров (10 млн. элементов и больше), - * и большого количества потоков (8-32), слияние является узким местом, - * и преимущество в производительности достигает 4 раз. + /** Option 2. + * In different threads, we aggregate independently into different two-level hash tables. + * Then merge them together, parallelizing by the first level buckets. + * When using hash tables of large sizes (10 million elements or more), + * and a large number of threads (8-32), the merge is a bottleneck, + * and has a performance advantage of 4 times. */ std::vector maps(num_threads); @@ -576,14 +576,14 @@ int main(int argc, char ** argv) if (!method || method == 3) { - /** Вариант 3. - * В разных потоках агрегируем независимо в разные хэш-таблицы, - * пока их размер не станет достаточно большим. - * Если размер локальной хэш-таблицы большой, и в ней нет элемента, - * то вставляем его в одну глобальную хэш-таблицу, защищённую mutex-ом, - * а если mutex не удалось захватить, то вставляем в локальную. - * Затем сливаем все локальные хэш-таблицы в глобальную. - * Этот метод плохой - много contention-а. + /** Option 3. + * In different threads, we aggregate independently into different hash tables, + * until their size becomes large enough. + * If the size of the local hash table is large, and there is no element in it, + * then we insert it into one global hash table, protected by mutex, + * and if mutex failed to capture, then insert it into the local one. + * Then merge all the local hash tables to the global one. + * This method is bad - a lot of contention. */ std::vector local_maps(num_threads); @@ -646,10 +646,10 @@ int main(int argc, char ** argv) if (!method || method == 33) { - /** Вариант 33. - * В разных потоках агрегируем независимо в разные хэш-таблицы, - * пока их размер не станет достаточно большим. - * Затем сбрасываем данные в глобальную хэш-таблицу, защищённую mutex-ом, и продолжаем. + /** Option 33. + * In different threads, we aggregate independently into different hash tables, + * until their size becomes large enough. + * Then we insert the data to the global hash table, protected by mutex, and continue. */ std::vector local_maps(num_threads); @@ -712,13 +712,13 @@ int main(int argc, char ** argv) if (!method || method == 4) { - /** Вариант 4. - * В разных потоках агрегируем независимо в разные хэш-таблицы, - * пока их размер не станет достаточно большим. - * Если размер локальной хэш-таблицы большой, и в ней нет элемента, - * то вставляем его в одну из 256 глобальных хэш-таблиц, каждая из которых под своим mutex-ом. - * Затем сливаем все локальные хэш-таблицы в глобальную. - * Этот метод не такой уж плохой при большом количестве потоков, но хуже второго. + /** Option 4. + * In different threads, we aggregate independently into different hash tables, + * until their size becomes large enough. + * If the size of the local hash table is large, and there is no element in it, + * then insert it into one of 256 global hash tables, each of which is under its mutex. + * Then merge all local hash tables into the global one. + * This method is not so bad with a lot of threads, but worse than the second one. */ std::vector local_maps(num_threads); @@ -783,13 +783,13 @@ int main(int argc, char ** argv) /* if (!method || method == 5) { - */ /** Вариант 5. - * В разных потоках агрегируем независимо в разные хэш-таблицы, - * пока их размер не станет достаточно большим. - * Если размер локальной хэш-таблицы большой, и в ней нет элемента, - * то вставляем его в одну глобальную хэш-таблицу, содержащую маленькие защёлки в каждой ячейке, - * а если защёлку не удалось захватить, то вставляем в локальную. - * Затем сливаем все локальные хэш-таблицы в глобальную. + */ /** Option 5. + * In different threads, we aggregate independently into different hash tables, + * until their size becomes large enough. + * If the size of the local hash table is large and there is no element in it, + * then insert it into one global hash table containing small latches in each cell, + * and if the latch can not be captured, then insert it into the local one. + * Then merge all local hash tables into the global one. */ /* Map local_maps[num_threads]; @@ -850,10 +850,10 @@ int main(int argc, char ** argv) /*if (!method || method == 6) { - *//** Вариант 6. - * В разных потоках агрегируем независимо в разные хэш-таблицы. - * Затем "сливаем" их, проходя по ним в одинаковом порядке ключей. - * Довольно тормозной вариант. + *//** Option 6. + * In different threads, we aggregate independently into different hash tables. + * Then "merge" them, passing them in the same order of the keys. + * Quite a slow option. */ /* std::vector maps(num_threads); diff --git a/dbms/src/Common/tests/parallel_aggregation2.cpp b/dbms/src/Common/tests/parallel_aggregation2.cpp index d8a201804bb..b34caaaf7a8 100644 --- a/dbms/src/Common/tests/parallel_aggregation2.cpp +++ b/dbms/src/Common/tests/parallel_aggregation2.cpp @@ -139,7 +139,7 @@ struct MergeSequential }; template -struct MergeSequentialTransposed /// На практике не лучше обычного. +struct MergeSequentialTransposed /// In practice not better than usual. { template static void NO_INLINE execute(Map ** source_maps, size_t num_maps, Map *& result_map, diff --git a/dbms/src/Common/tests/sip_hash.cpp b/dbms/src/Common/tests/sip_hash.cpp index fccf03d00a4..d8d4851e665 100644 --- a/dbms/src/Common/tests/sip_hash.cpp +++ b/dbms/src/Common/tests/sip_hash.cpp @@ -6,7 +6,7 @@ #include -/// Адаптированный вариант https://www.131002.net/siphash/siphash24.c +/// Adapted version https://www.131002.net/siphash/siphash24.c /* SipHash-2-4 output with diff --git a/dbms/src/Common/tests/sip_hash_perf.cpp b/dbms/src/Common/tests/sip_hash_perf.cpp index 229d3da5322..44cb573d457 100644 --- a/dbms/src/Common/tests/sip_hash_perf.cpp +++ b/dbms/src/Common/tests/sip_hash_perf.cpp @@ -8,7 +8,7 @@ #include -/** Тестировать так: +/** Test this way: * * clickhouse-client --query="SELECT SearchPhrase AS k FROM test.hits WHERE k != ''" > phrases.tsv * clickhouse-client --query="SELECT URL AS k FROM test.hits" > urls.tsv diff --git a/dbms/src/Core/Block.cpp b/dbms/src/Core/Block.cpp index 41e2e12b993..b482ec3e6ae 100644 --- a/dbms/src/Core/Block.cpp +++ b/dbms/src/Core/Block.cpp @@ -28,8 +28,8 @@ namespace ErrorCodes void Block::addDefaults(const NamesAndTypesList & required_columns) { - /// Для недостающих столбцов из вложенной структуры нужно создавать не столбец пустых массивов, а столбец массивов правильных длин. - /// Сначала запомним столбцы смещений для всех массивов в блоке. + /// For missing columns of nested structure, you need to create not a column of empty arrays, but a column of arrays of correct lengths. + /// First, remember the offset columns for all arrays in the block. std::map offset_columns; for (const auto & elem : data) @@ -39,7 +39,7 @@ void Block::addDefaults(const NamesAndTypesList & required_columns) String offsets_name = DataTypeNested::extractNestedTableName(elem.name); auto & offsets_column = offset_columns[offsets_name]; - /// Если почему-то есть разные столбцы смещений для одной вложенной структуры, то берём непустой. + /// If for some reason there are different displacement columns for one nested structure, then we take nonempty. if (!offsets_column || offsets_column->empty()) offsets_column = array->getOffsetsColumn(); } @@ -70,8 +70,8 @@ void Block::addDefaults(const NamesAndTypesList & required_columns) } else { - /** Нужно превратить константный столбец в полноценный, так как в части блоков (из других кусков), - * он может быть полноценным (а то интерпретатор может посчитать, что он константный везде). + /** It is necessary to turn a constant column into a full column, since in part of blocks (from other parts), + * it can be full (or the interpreter may decide that it is constant everywhere). */ column_to_add.column = dynamic_cast( *column_to_add.type->createConstColumn( @@ -389,7 +389,7 @@ NamesAndTypesList Block::getColumnsList() const void Block::checkNestedArraysOffsets() const { - /// Указатели на столбцы-массивы, для проверки равенства столбцов смещений во вложенных структурах данных + /// Pointers to array columns, to check the equality of offset columns in nested data structures using ArrayColumns = std::map; ArrayColumns array_columns; @@ -423,7 +423,7 @@ void Block::checkNestedArraysOffsets() const void Block::optimizeNestedArraysOffsets() { - /// Указатели на столбцы-массивы, для проверки равенства столбцов смещений во вложенных структурах данных + /// Pointers to array columns, to check the equality of offset columns in nested data structures using ArrayColumns = std::map; ArrayColumns array_columns; @@ -450,7 +450,7 @@ void Block::optimizeNestedArraysOffsets() if (!it->second->hasEqualOffsets(*column_array)) throw Exception("Sizes of nested arrays do not match", ErrorCodes::SIZES_OF_ARRAYS_DOESNT_MATCH); - /// делаем так, чтобы столбцы смещений массивов внутри одной вложенной таблицы указывали в одно место + /// make columns of arrays offsets inside one nested table point to the same place column_array->getOffsetsColumn() = it->second->getOffsetsColumn(); } } @@ -479,8 +479,8 @@ bool blocksHaveEqualStructure(const Block & lhs, const Block & rhs) void getBlocksDifference(const Block & lhs, const Block & rhs, std::string & out_lhs_diff, std::string & out_rhs_diff) { - /// Традиционная задача: наибольшая общая подпоследовательность (LCS). - /// Полагаем, что порядок важен. Если это когда-то станет не так, упростим: например, сделаем 2 set'а. + /// The traditional task: the largest common subsequence (LCS). + /// Assume that order is important. If this becomes wrong once, let's simplify it: for example, make 2 sets. std::vector> lcs(lhs.columns() + 1); for (auto & v : lcs) @@ -497,7 +497,7 @@ void getBlocksDifference(const Block & lhs, const Block & rhs, std::string & out } } - /// Теперь идем обратно и собираем ответ. + /// Now go back and collect the answer. ColumnsWithTypeAndName left_columns; ColumnsWithTypeAndName right_columns; size_t l = lhs.columns(); @@ -506,15 +506,15 @@ void getBlocksDifference(const Block & lhs, const Block & rhs, std::string & out { if (lhs.safeGetByPosition(l - 1) == rhs.safeGetByPosition(r - 1)) { - /// Данный элемент в обеих последовательностях, значит, в diff не попадает. + /// This element is in both sequences, so it does not get into `diff`. --l; --r; } else { - /// Маленькая эвристика: чаще всего используется при получении разницы для (expected_block, actual_block). - /// Поэтому предпочтение будем отдавать полю, которое есть в левом блоке (expected_block), поэтому - /// в diff попадет столбец из actual_block. + /// Small heuristics: most often used when getting a difference for (expected_block, actual_block). + /// Therefore, the preference will be given to the field, which is in the left block (expected_block), therefore + /// in `diff` the column from `actual_block` will get. if (lcs[l][r - 1] >= lcs[l - 1][r]) right_columns.push_back(rhs.safeGetByPosition(--r)); else diff --git a/dbms/src/Core/BlockInfo.cpp b/dbms/src/Core/BlockInfo.cpp index d0a2758b394..885de8d7cd6 100644 --- a/dbms/src/Core/BlockInfo.cpp +++ b/dbms/src/Core/BlockInfo.cpp @@ -17,10 +17,10 @@ namespace ErrorCodes } -/// Записать значения в бинарном виде. NOTE: Можно было бы использовать protobuf, но он был бы overkill для данного случая. +/// Write values ​​in binary form. NOTE: You could use protobuf, but it would be overkill for this case. void BlockInfo::write(WriteBuffer & out) const { - /// Набор пар FIELD_NUM, значение в бинарном виде. Затем 0. + /// Set of pairs `FIELD_NUM`, value in binary form. Then 0. #define WRITE_FIELD(TYPE, NAME, DEFAULT, FIELD_NUM) \ writeVarUInt(FIELD_NUM, out); \ writeBinary(NAME, out); @@ -31,7 +31,7 @@ void BlockInfo::write(WriteBuffer & out) const writeVarUInt(0, out); } -/// Прочитать значения в бинарном виде. +/// Read values ​​in binary form. void BlockInfo::read(ReadBuffer & in) { UInt64 field_num = 0; diff --git a/dbms/src/Core/ErrorCodes.cpp b/dbms/src/Core/ErrorCodes.cpp index 80770ee718a..315cd6d6d79 100644 --- a/dbms/src/Core/ErrorCodes.cpp +++ b/dbms/src/Core/ErrorCodes.cpp @@ -3,11 +3,11 @@ namespace DB namespace ErrorCodes { - /** Раньше эти константы были расположены в одном enum-е. - * Но в этом случае возникает проблема: при добавлении новой константы необходимо перекомпилировать - * все translation unit-ы, которые используют хотя бы одну константу (почти весь проект). - * Поэтому сделано так, что определения констант расположены здесь, в одном файле, - * а их объявления - в разных файлах, по месту использования. + /** Previously, these constants were located in one enum. + * But in this case there is a problem: when you add a new constant, you need to recompile + * all translation units that use at least one constant (almost the whole project). + * Therefore it is made so that definitions of constants are located here, in one file, + * and their declaration are in different files, at the place of use. */ extern const int UNSUPPORTED_METHOD = 1; diff --git a/dbms/src/Core/NamesAndTypes.cpp b/dbms/src/Core/NamesAndTypes.cpp index 83cec16f486..61d5ed22cd5 100644 --- a/dbms/src/Core/NamesAndTypes.cpp +++ b/dbms/src/Core/NamesAndTypes.cpp @@ -115,7 +115,7 @@ NamesAndTypesList NamesAndTypesList::filter(const Names & names) const NamesAndTypesList NamesAndTypesList::addTypes(const Names & names) const { - /// NOTE Лучше сделать map в IStorage, чем создавать его здесь каждый раз заново. + /// NOTE It's better to make a map in `IStorage` than to create it here every time again. google::dense_hash_map types; types.set_empty_key(StringRef()); diff --git a/dbms/src/DataStreams/AddingDefaultBlockOutputStream.cpp b/dbms/src/DataStreams/AddingDefaultBlockOutputStream.cpp index a4b3c4c00c2..fe6a5983542 100644 --- a/dbms/src/DataStreams/AddingDefaultBlockOutputStream.cpp +++ b/dbms/src/DataStreams/AddingDefaultBlockOutputStream.cpp @@ -8,13 +8,13 @@ void AddingDefaultBlockOutputStream::write(const DB::Block & block) { Block res = block; - /// Вычисляет явно указанные (в column_defaults) значения по-умолчанию. + /// Computes explicitly specified values ​​(in column_defaults) by default. /** @todo if somehow block does not contain values for implicitly-defaulted columns that are prerequisites * for explicitly-defaulted ones, exception will be thrown during evaluating such columns * (implicitly-defaulted columns are evaluated on the line after following one. */ evaluateMissingDefaults(res, *required_columns, column_defaults, context); - /// Добавляет не указанные значения по-умолчанию. + /// Adds not specified default values. if (!only_explicit_column_defaults) /// @todo this line may be moved before `evaluateMissingDefaults` with passing {required_columns - explicitly-defaulted columns} res.addDefaults(*required_columns); diff --git a/dbms/src/DataStreams/AggregatingBlockInputStream.cpp b/dbms/src/DataStreams/AggregatingBlockInputStream.cpp index 5fc601c8324..d23bd8b4053 100644 --- a/dbms/src/DataStreams/AggregatingBlockInputStream.cpp +++ b/dbms/src/DataStreams/AggregatingBlockInputStream.cpp @@ -34,15 +34,15 @@ Block AggregatingBlockInputStream::readImpl() } else { - /** Если есть временные файлы с частично-агрегированными данными на диске, - * то читаем и мерджим их, расходуя минимальное количество памяти. + /** If there are temporary files with partially-aggregated data on the disk, + * then read and merge them, spending the minimum amount of memory. */ ProfileEvents::increment(ProfileEvents::ExternalAggregationMerge); if (!isCancelled()) { - /// Сбросим имеющиеся в оперативке данные тоже на диск. Так проще. + /// Flush data in the RAM to disk also. It's easier. size_t rows = data_variants->sizeWithoutOverflowRow(); if (rows) aggregator.writeToTemporaryFile(*data_variants, rows); diff --git a/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp b/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp index 97ef8eb49ec..34dc8735c2e 100644 --- a/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp +++ b/dbms/src/DataStreams/AggregatingSortedBlockInputStream.cpp @@ -21,24 +21,24 @@ Block AggregatingSortedBlockInputStream::readImpl() if (merged_columns.empty()) return Block(); - /// Дополнительная инициализация. + /// Additional initialization. if (next_key.empty()) { next_key.columns.resize(description.size()); - /// Заполним номера столбцов, которые нужно доагрегировать. + /// Fill in the column numbers that need to be aggregated. for (size_t i = 0; i < num_columns; ++i) { ColumnWithTypeAndName & column = merged_block.safeGetByPosition(i); - /// Оставляем только состояния аггрегатных функций. + /// We leave only states of aggregate functions. if (!startsWith(column.type->getName(), "AggregateFunction")) { column_numbers_not_to_aggregate.push_back(i); continue; } - /// Входят ли в PK? + /// Included into PK? SortDescription::const_iterator it = description.begin(); for (; it != description.end(); ++it) if (it->column_name == column.name || (it->column_name.empty() && it->column_number == i)) @@ -72,7 +72,7 @@ void AggregatingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, { size_t merged_rows = 0; - /// Вынимаем строки в нужном порядке и кладём в merged_block, пока строк не больше max_block_size + /// We take the rows in the correct order and put them in `merged_block`, while the rows are no more than `max_block_size` while (!queue.empty()) { TSortCursor current = queue.top(); @@ -81,7 +81,7 @@ void AggregatingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, bool key_differs; - if (current_key.empty()) /// Первый встретившийся ключ. + if (current_key.empty()) /// The first key encountered. { current_key.columns.resize(description.size()); setPrimaryKeyRef(current_key, current); @@ -90,7 +90,7 @@ void AggregatingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, else key_differs = next_key != current_key; - /// если накопилось достаточно строк и последняя посчитана полностью + /// if there are enough rows accumulated and the last one is calculated completely if (key_differs && merged_rows >= max_block_size) return; @@ -100,14 +100,14 @@ void AggregatingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, { current_key.swap(next_key); - /// Запишем данные для очередной группы. Копируем значения обычных столбцов. + /// We will write the data for the group. We copy the values ​​of ordinary columns. for (size_t i = 0, size = column_numbers_not_to_aggregate.size(); i < size; ++i) { size_t j = column_numbers_not_to_aggregate[i]; merged_columns[j]->insertFrom(*current->all_columns[j], current->pos); } - /// Добавляем в агрегатные столбцы пустое состояние агрегации. Состояние будет обновлено в функции addRow. + /// Add the empty aggregation state to the aggregate columns. The state will be updated in the `addRow` function. for (auto & column_to_aggregate : columns_to_aggregate) column_to_aggregate->insertDefault(); @@ -123,7 +123,7 @@ void AggregatingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, } else { - /// Достаём из соответствующего источника следующий блок, если есть. + /// We fetch the next block from the appropriate source, if there is one. fetchNextBlock(current, queue); } } diff --git a/dbms/src/DataStreams/BlockStreamProfileInfo.cpp b/dbms/src/DataStreams/BlockStreamProfileInfo.cpp index ff63d0c1808..5c7b89998d6 100644 --- a/dbms/src/DataStreams/BlockStreamProfileInfo.cpp +++ b/dbms/src/DataStreams/BlockStreamProfileInfo.cpp @@ -86,7 +86,7 @@ void BlockStreamProfileInfo::calculateRowsBeforeLimit() const { calculated_rows_before_limit = true; - /// есть ли Limit? + /// is there a Limit? BlockStreamProfileInfos limits; collectInfosForStreamsWithName("Limit", limits); @@ -94,8 +94,8 @@ void BlockStreamProfileInfo::calculateRowsBeforeLimit() const { applied_limit = true; - /** Берём количество строчек, прочитанных ниже PartialSorting-а, если есть, или ниже Limit-а. - * Это нужно, потому что сортировка может вернуть только часть строк. + /** Take the number of lines read below `PartialSorting`, if any, or below `Limit`. + * This is necessary, because sorting can return only part of the rows. */ BlockStreamProfileInfos partial_sortings; collectInfosForStreamsWithName("PartialSorting", partial_sortings); @@ -108,7 +108,7 @@ void BlockStreamProfileInfo::calculateRowsBeforeLimit() const } else { - /// Тогда данные о rows_before_limit могут быть в RemoteBlockInputStream-е (приехать с удалённого сервера). + /// Then the data about `rows_before_limit` can be in `RemoteBlockInputStream` (come from a remote server). BlockStreamProfileInfos remotes; collectInfosForStreamsWithName("Remote", remotes); diff --git a/dbms/src/DataStreams/CSVRowInputStream.cpp b/dbms/src/DataStreams/CSVRowInputStream.cpp index 51e8d59a706..a0b891e9c27 100644 --- a/dbms/src/DataStreams/CSVRowInputStream.cpp +++ b/dbms/src/DataStreams/CSVRowInputStream.cpp @@ -27,7 +27,7 @@ CSVRowInputStream::CSVRowInputStream(ReadBuffer & istr_, const Block & sample_, static void skipEndOfLine(ReadBuffer & istr) { - /// \n (Unix) или \r\n (DOS/Windows) или \n\r (Mac OS Classic) + /// \n (Unix) or \r\n (DOS/Windows) or \n\r (Mac OS Classic) if (*istr.position() == '\n') { @@ -56,7 +56,7 @@ static void skipDelimiter(ReadBuffer & istr, const char delimiter, bool is_last_ if (istr.eof()) return; - /// поддерживаем лишний разделитель на конце строки + /// we support the extra delimiter at the end of the line if (*istr.position() == delimiter) { ++istr.position(); @@ -71,7 +71,7 @@ static void skipDelimiter(ReadBuffer & istr, const char delimiter, bool is_last_ } -/// Пропустить допустимые в CSV пробельные символы. +/// Skip `whitespace` symbols allowed in CSV. static inline void skipWhitespacesAndTabs(ReadBuffer & buf) { while (!buf.eof() @@ -143,7 +143,7 @@ String CSVRowInputStream::getDiagnosticInfo() WriteBufferFromString out(res); Block block = sample.cloneEmpty(); - /// Вывести подробную диагностику возможно лишь если последняя и предпоследняя строка ещё находятся в буфере для чтения. + /// It is possible to display detailed diagnostics only if the last and next to last rows are still in the read buffer. size_t bytes_read_at_start_of_buffer = istr.count() - istr.offset(); if (bytes_read_at_start_of_buffer != bytes_read_at_start_of_buffer_on_prev_row) { @@ -161,7 +161,7 @@ String CSVRowInputStream::getDiagnosticInfo() if (sample.safeGetByPosition(i).type->getName().size() > max_length_of_data_type_name) max_length_of_data_type_name = sample.safeGetByPosition(i).type->getName().size(); - /// Откатываем курсор для чтения на начало предыдущей или текущей строки и парсим всё заново. Но теперь выводим подробную информацию. + /// Roll back the cursor to the beginning of the previous or current row and parse all over again. But now we derive detailed information. if (pos_of_prev_row) { @@ -228,7 +228,7 @@ bool CSVRowInputStream::parseRowAndPrintDiagnosticInfo(Block & block, if (data_types[i]->isNumeric()) { - /// Пустая строка вместо числа. + /// An empty string instead of a number. if (curr_position == prev_position) { out << "ERROR: text "; @@ -271,13 +271,13 @@ bool CSVRowInputStream::parseRowAndPrintDiagnosticInfo(Block & block, } } - /// Разделители + /// Delimiters if (i + 1 == size) { if (istr.eof()) return false; - /// поддерживаем лишний разделитель на конце строки + /// we support the extra delimiter at the end of the line if (*istr.position() == delimiter) { ++istr.position(); diff --git a/dbms/src/DataStreams/CollapsingFinalBlockInputStream.cpp b/dbms/src/DataStreams/CollapsingFinalBlockInputStream.cpp index a5f4852afb4..6dfd58179b1 100644 --- a/dbms/src/DataStreams/CollapsingFinalBlockInputStream.cpp +++ b/dbms/src/DataStreams/CollapsingFinalBlockInputStream.cpp @@ -1,6 +1,6 @@ #include -/// Максимальное количество сообщений о некорректных данных в логе. +/// Maximum number of messages about incorrect data in the log. #define MAX_ERROR_MESSAGES 10 @@ -9,7 +9,7 @@ namespace DB CollapsingFinalBlockInputStream::~CollapsingFinalBlockInputStream() { - /// Нужно обезвредить все MergingBlockPtr, чтобы они не пытались класть блоки в output_blocks. + /// You must cancel all `MergingBlockPtr` so that they do not try to put blocks in `output_blocks`. previous.block.cancel(); last_positive.block.cancel(); @@ -26,7 +26,7 @@ CollapsingFinalBlockInputStream::~CollapsingFinalBlockInputStream() void CollapsingFinalBlockInputStream::reportBadCounts() { - /// При неконсистентных данных, это - неизбежная ошибка, которая не может быть легко исправлена админами. Поэтому Warning. + /// With inconsistent data, this is an unavoidable error that can not be easily fixed by admins. Therefore Warning. LOG_WARNING(log, "Incorrect data: number of rows with sign = 1 (" << count_positive << ") differs with number of rows with sign = -1 (" << count_negative << ") by more than one"); @@ -82,7 +82,7 @@ Block CollapsingFinalBlockInputStream::readImpl() first = false; } - /// Будем формировать блоки для ответа, пока не получится непустой блок. + /// We will create blocks for the answer until we get a non-empty block. while (true) { while (!queue.empty() && output_blocks.empty()) @@ -93,7 +93,7 @@ Block CollapsingFinalBlockInputStream::readImpl() bool has_next = !queue.empty(); Cursor next = has_next ? queue.top() : Cursor(); - /// Будем продвигаться в текущем блоке, не используя очередь, пока возможно. + /// We will advance in the current block, not using the queue, as long as possible. while (true) { if (!current.equal(previous)) @@ -121,7 +121,7 @@ Block CollapsingFinalBlockInputStream::readImpl() { fetchNextBlock(current.block->stream_index); - /// Все потоки кончились. Обработаем последний ключ. + /// All streams are over. We'll process the last key. if (!has_next) commitCurrent(); @@ -140,7 +140,7 @@ Block CollapsingFinalBlockInputStream::readImpl() } } - /// Конец потока. + /// End of the stream. if (output_blocks.empty()) { if (blocks_fetched != blocks_output) diff --git a/dbms/src/DataStreams/CollapsingSortedBlockInputStream.cpp b/dbms/src/DataStreams/CollapsingSortedBlockInputStream.cpp index da548855fa6..321c751591d 100644 --- a/dbms/src/DataStreams/CollapsingSortedBlockInputStream.cpp +++ b/dbms/src/DataStreams/CollapsingSortedBlockInputStream.cpp @@ -2,7 +2,7 @@ #include #include -/// Максимальное количество сообщений о некорректных данных в логе. +/// Maximum number of messages about incorrect data in the log. #define MAX_ERROR_MESSAGES 10 @@ -31,9 +31,9 @@ void CollapsingSortedBlockInputStream::reportIncorrectData() s << ")."; - /** Пока ограничимся всего лишь логгированием таких ситуаций, - * так как данные генерируются внешними программами. - * При неконсистентных данных, это - неизбежная ошибка, которая не может быть легко исправлена админами. Поэтому Warning. + /** Fow now we limit ourselves to just logging such situations, + * since the data is generated by external programs. + * With inconsistent data, this is an unavoidable error that can not be easily corrected by admins. Therefore Warning. */ LOG_WARNING(log, s.rdbuf()); } @@ -45,7 +45,7 @@ void CollapsingSortedBlockInputStream::insertRows(ColumnPlainPtrs & merged_colum { if (count_positive == count_negative && !last_is_positive) { - /// Если все строки во входных потоках схлопнулись, мы все равно хотим выдать хоть один блок в результат. + /// If all the rows in the input streams collapsed, we still want to give at least one block in the result. if (last_in_stream && merged_rows == 0 && !blocks_written) { LOG_INFO(log, "All rows collapsed"); @@ -111,7 +111,7 @@ Block CollapsingSortedBlockInputStream::readImpl() if (merged_columns.empty()) return Block(); - /// Дополнительная инициализация. + /// Additional initialization. if (first_negative.empty()) { first_negative.columns.resize(num_columns); @@ -135,7 +135,7 @@ void CollapsingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, s { size_t merged_rows = 0; - /// Вынимаем строки в нужном порядке и кладём в merged_block, пока строк не больше max_block_size + /// Take rows in correct order and put them into `merged_block` until the rows no more than `max_block_size` for (; !queue.empty(); ++current_pos) { TSortCursor current = queue.top(); @@ -153,7 +153,7 @@ void CollapsingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, s bool key_differs = next_key != current_key; - /// если накопилось достаточно строк и последняя посчитана полностью + /// if there are enough rows and the last one is calculated completely if (key_differs && merged_rows >= max_block_size) { ++blocks_written; @@ -168,7 +168,7 @@ void CollapsingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, s if (key_differs) { - /// Запишем данные для предыдущего первичного ключа. + /// We write data for the previous primary key. insertRows(merged_columns, merged_rows); current_key.swap(next_key); @@ -213,12 +213,12 @@ void CollapsingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, s } else { - /// Достаём из соответствующего источника следующий блок, если есть. + /// We take next block from the corresponding source, if there is one. fetchNextBlock(current, queue); } } - /// Запишем данные для последнего первичного ключа. + /// Write data for last primary key. insertRows(merged_columns, merged_rows, true); finished = true; diff --git a/dbms/src/DataStreams/CreatingSetsBlockInputStream.cpp b/dbms/src/DataStreams/CreatingSetsBlockInputStream.cpp index c055b28b75e..cea1630d6c1 100644 --- a/dbms/src/DataStreams/CreatingSetsBlockInputStream.cpp +++ b/dbms/src/DataStreams/CreatingSetsBlockInputStream.cpp @@ -51,7 +51,7 @@ void CreatingSetsBlockInputStream::createAll() { for (auto & elem : subqueries_for_sets) { - if (elem.second.source) /// Бывают заранее подготовленные Set/Join - для них не указывается source. + if (elem.second.source) /// There could be prepared in advance Set/Join - no source is specified for them. { if (isCancelled()) return; @@ -141,11 +141,11 @@ void CreatingSetsBlockInputStream::createOne(SubqueryForSet & subquery) } } -// subquery.source->readSuffix(); /// TODO Блокируется в RemoteBlockInputStream::readSuffixImpl при запросе SELECT number FROM system.numbers WHERE number IN (SELECT number FROM remote('127.0.0.{1,2}', system, numbers) WHERE number % 2 = 1 LIMIT 10) LIMIT 10 +// subquery.source->readSuffix(); /// TODO Blocked in `RemoteBlockInputStream::readSuffixImpl` when querying `SELECT number FROM system.numbers WHERE number IN (SELECT number FROM remote(`127.0.0.{1,2}', system, numbers) WHERE number % 2 = 1 LIMIT 10) LIMIT 10` if (table_out) table_out->writeSuffix(); - /// Выведем информацию о том, сколько считано строк и байт. + /// We will display information about how many rows and bytes are read. size_t rows = 0; size_t bytes = 0; diff --git a/dbms/src/DataStreams/FilterBlockInputStream.cpp b/dbms/src/DataStreams/FilterBlockInputStream.cpp index 202086c5933..2c184d2d9b3 100644 --- a/dbms/src/DataStreams/FilterBlockInputStream.cpp +++ b/dbms/src/DataStreams/FilterBlockInputStream.cpp @@ -61,19 +61,19 @@ Block FilterBlockInputStream::readImpl() const Block & sample_block = expression->getSampleBlock(); - /// Найдём настоящую позицию столбца с фильтром в блоке. - /** sample_block имеет структуру результата вычисления выражения. - * Но эта структура не обязательно совпадает с expression->execute(res) ниже, - * потому что выражение может применяться к блоку, который также содержит дополнительные, - * ненужные для данного выражения столбцы, но нужные позже, в следующих стадиях конвейера выполнения запроса. - * Таких столбцов в sample_block не будет. - * Поэтому, позиция столбца-фильтра в нём может быть другой. + /// Find the current position of the filter column in the block. + /** sample_block has the result structure of evaluating the expression. + * But this structure does not necessarily match expression->execute(res) below, + * because the expression can be applied to a block that also contains additional, + * columns unnecessary for this expression, but needed later, in the next stages of the query execution pipeline. + * There will be no such columns in sample_block. + * Therefore, the position of the filter column in it can be different. */ ssize_t filter_column_in_sample_block = filter_column; if (filter_column_in_sample_block == -1) filter_column_in_sample_block = sample_block.getPositionByName(filter_column_name); - /// Проверим, не является ли столбец с фильтром константой, содержащей 0 или 1. + /// Let's check if the filter column is a constant containing 0 or 1. ColumnPtr column = sample_block.safeGetByPosition(filter_column_in_sample_block).column; if (column) @@ -99,7 +99,7 @@ Block FilterBlockInputStream::readImpl() return res; } - /// Пока не встретится блок, после фильтрации которого что-нибудь останется, или поток не закончится. + /// Until the block is encountered, after filtering which something remains, or the stream does not end. while (1) { res = children.back()->read(); @@ -111,7 +111,7 @@ Block FilterBlockInputStream::readImpl() if (filter_always_true) return res; - /// Найдём настоящую позицию столбца с фильтром в блоке. + /// Find the current position of the filter column in the block. if (filter_column == -1) filter_column = res.getPositionByName(filter_column_name); @@ -135,10 +135,10 @@ Block FilterBlockInputStream::readImpl() const ColumnUInt8 * column_vec = typeid_cast(observed_column); if (!column_vec) { - /** Бывает, что на этапе анализа выражений (в sample_block) столбцы-константы ещё не вычислены, - * а сейчас - вычислены. То есть, не все случаи покрываются кодом выше. - * Это происходит, если функция возвращает константу для неконстантного аргумента. - * Например, функция ignore. + /** It happens that at the stage of analysis of expressions (in sample_block) the columns-constants have not been calculated yet, + * and now - are calculated. That is, not all cases are covered by the code above. + * This happens if the function returns a constant for a non-constant argument. + * For example, `ignore` function. */ const ColumnConstUInt8 * column_const = typeid_cast(observed_column); @@ -184,9 +184,9 @@ Block FilterBlockInputStream::readImpl() const IColumn::Filter & filter = column_vec->getData(); - /** Выясним, сколько строк будет в результате. - * Для этого отфильтруем первый попавшийся неконстантный столбец - * или же посчитаем количество выставленных байт в фильтре. + /** Let's find out how many rows will be in result. + * To do this, we filter out the first non-constant column + * or calculate number of set bytes in the filter. */ size_t first_non_constant_column = 0; for (size_t i = 0; i < columns; ++i) @@ -212,27 +212,27 @@ Block FilterBlockInputStream::readImpl() filtered_rows = countBytesInFilter(filter); } - /// Если текущий блок полностью отфильтровался - перейдём к следующему. + /// If the current block is completely filtered out, let's move on to the next one. if (filtered_rows == 0) continue; - /// Если через фильтр проходят все строчки. + /// If all the rows pass through the filter. if (filtered_rows == filter.size()) { - /// Заменим столбец с фильтром на константу. + /// Replace the column with the filter by a constant. res.safeGetByPosition(filter_column).column = std::make_shared(filtered_rows, 1); - /// Остальные столбцы трогать не нужно. + /// No need to touch the rest of the columns. return res; } - /// Фильтруем остальные столбцы. + /// Filter the rest of the columns. for (size_t i = 0; i < columns; ++i) { ColumnWithTypeAndName & current_column = res.safeGetByPosition(i); if (i == static_cast(filter_column)) { - /// Сам столбец с фильтром заменяем на столбец с константой 1, так как после фильтрации в нём ничего другого не останется. + /// The column with filter itself is replaced with a column with a constant `1`, since after filtering, nothing else will remain. current_column.column = std::make_shared(filtered_rows, 1); continue; } diff --git a/dbms/src/DataStreams/FormatFactory.cpp b/dbms/src/DataStreams/FormatFactory.cpp index 62922e11078..d45d438274c 100644 --- a/dbms/src/DataStreams/FormatFactory.cpp +++ b/dbms/src/DataStreams/FormatFactory.cpp @@ -185,8 +185,8 @@ static BlockOutputStreamPtr getOutputImpl(const String & name, WriteBuffer & buf BlockOutputStreamPtr FormatFactory::getOutput(const String & name, WriteBuffer & buf, const Block & sample, const Context & context) const { - /** Материализация нужна, так как форматы могут использовать функции IDataType, - * которые допускают работу только с полными столбцами. + /** Materialization is needed, because formats can use the functions `IDataType`, + * which only work with full columns. */ return std::make_shared(getOutputImpl(name, buf, sample, context)); } diff --git a/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.cpp b/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.cpp index 39c54ca7b67..1dc9cc1fe6d 100644 --- a/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.cpp +++ b/dbms/src/DataStreams/GraphiteRollupSortedBlockInputStream.cpp @@ -36,16 +36,16 @@ UInt32 GraphiteRollupSortedBlockInputStream::selectPrecision(const Graphite::Ret } -/** Округлить unix timestamp до precision секунд. - * При этом, дата не должна измениться. Дата исчисляется с помощью локального часового пояса. +/** Round the unix timestamp to seconds precision. + * In this case, the date should not change. The date is calculated using the local time zone. * - * Если величина округления не больше часа, - * то, исходя из допущения, что часовые пояса, отличающиеся от UTC на нецелое количество часов не поддерживаются, - * достаточно просто округлить unix timestamp вниз до числа, кратного 3600. - * А если величина округления больше, - * то будем подвергать округлению число секунд от начала суток в локальном часовом поясе. + * If the rounding value is less than an hour, + * then, assuming that time zones that differ from UTC by a non-integer number of hours are not supported, + * just simply round the unix timestamp down to a multiple of 3600. + * And if the rounding value is greater, + * then we will round down the number of seconds from the beginning of the day in the local time zone. * - * Округление более чем до суток не поддерживается. + * Rounding to more than a day is not supported. */ static time_t roundTimeToPrecision(const DateLUTImpl & date_lut, time_t time, UInt32 precision) { @@ -114,7 +114,7 @@ void GraphiteRollupSortedBlockInputStream::merge(ColumnPlainPtrs & merged_column size_t merged_rows = 0; - /// Вынимаем строки в нужном порядке и кладём в merged_block, пока строк не больше max_block_size + /// Take rows in needed order and put them into `merged_block` until rows no more than `max_block_size` while (!queue.empty()) { TSortCursor current = queue.top(); @@ -195,7 +195,7 @@ void GraphiteRollupSortedBlockInputStream::merge(ColumnPlainPtrs & merged_column } else { - /// Достаём из соответствующего источника следующий блок, если есть. + /// We get the next block from the appropriate source, if there is one. fetchNextBlock(current, queue); } } @@ -218,7 +218,7 @@ void GraphiteRollupSortedBlockInputStream::merge(ColumnPlainPtrs & merged_column template void GraphiteRollupSortedBlockInputStream::startNextRow(ColumnPlainPtrs & merged_columns, TSortCursor & cursor) { - /// Копируем не модифицированные значения столбцов. + /// Copy unmodified column values. for (size_t i = 0, size = unmodified_column_numbers.size(); i < size; ++i) { size_t j = unmodified_column_numbers[i]; @@ -232,7 +232,7 @@ void GraphiteRollupSortedBlockInputStream::startNextRow(ColumnPlainPtrs & merged void GraphiteRollupSortedBlockInputStream::finishCurrentRow(ColumnPlainPtrs & merged_columns) { - /// Вставляем вычисленные значения столбцов time, value, version. + /// Insert calculated values ​​of the columns `time`, `value`, `version`. merged_columns[time_column_num]->insert(UInt64(current_time_rounded)); merged_columns[version_column_num]->insert(current_max_version); diff --git a/dbms/src/DataStreams/IBlockInputStream.cpp b/dbms/src/DataStreams/IBlockInputStream.cpp index d614a951b03..01dacac9ec0 100644 --- a/dbms/src/DataStreams/IBlockInputStream.cpp +++ b/dbms/src/DataStreams/IBlockInputStream.cpp @@ -61,7 +61,7 @@ size_t IBlockInputStream::checkDepthImpl(size_t max_depth, size_t level) const void IBlockInputStream::dumpTree(std::ostream & ostr, size_t indent, size_t multiplier) { - /// Не будем отображать в дереве обёртку потока блоков в AsynchronousBlockInputStream. + /// We will not display the wrapper of the block stream in the AsynchronousBlockInputStream in the tree. if (getName() != "Asynchronous") { ostr << String(indent, ' ') << getName(); @@ -70,7 +70,7 @@ void IBlockInputStream::dumpTree(std::ostream & ostr, size_t indent, size_t mult ostr << std::endl; ++indent; - /// Если поддерево повторяется несколько раз, то будем выводить его один раз с множителем. + /// If the subtree is repeated several times, then we output it once with the multiplier. using Multipliers = std::map; Multipliers multipliers; @@ -81,7 +81,7 @@ void IBlockInputStream::dumpTree(std::ostream & ostr, size_t indent, size_t mult { String id = (*it)->getTreeID(); size_t & subtree_multiplier = multipliers[id]; - if (subtree_multiplier != 0) /// Уже выведенные поддеревья помечаем нулём в массиве множителей. + if (subtree_multiplier != 0) /// Already printed subtrees are marked with zero in the array of multipliers. { (*it)->dumpTree(ostr, indent, subtree_multiplier); subtree_multiplier = 0; diff --git a/dbms/src/DataStreams/IProfilingBlockInputStream.cpp b/dbms/src/DataStreams/IProfilingBlockInputStream.cpp index 68fba55ba36..cab5a73de5b 100644 --- a/dbms/src/DataStreams/IProfilingBlockInputStream.cpp +++ b/dbms/src/DataStreams/IProfilingBlockInputStream.cpp @@ -31,7 +31,7 @@ Block IProfilingBlockInputStream::read() if (const IProfilingBlockInputStream * p_child = dynamic_cast(&*child)) info.nested_infos.push_back(&p_child->info); - /// Заметим, что после такого, элементы children нельзя удалять до того, как может потребоваться работать с nested_info. + /// Note that after this, `children` elements can not be deleted before you might need to work with `nested_info`. info.started = true; } @@ -59,11 +59,11 @@ Block IProfilingBlockInputStream::read() } else { - /** Если поток закончился, то ещё попросим всех детей прервать выполнение. - * Это имеет смысл при выполнении запроса с LIMIT-ом: - * - бывает ситуация, когда все необходимые данные уже прочитали, - * но источники-дети ещё продолжают работать, - * при чём они могут работать в отдельных потоках или даже удалённо. + /** If the thread is over, then we will ask all children to abort the execution. + * This makes sense when running a query with LIMIT + * - there is a situation when all the necessary data has already been read, + * but `children sources are still working, + * herewith they can work in separate threads or even remotely. */ cancel(); } @@ -201,7 +201,7 @@ void IProfilingBlockInputStream::checkQuota(Block & block) switch (limits.mode) { case LIMITS_TOTAL: - /// Проверяется в методе progress. + /// Checked in `progress` method. break; case LIMITS_CURRENT: @@ -232,15 +232,15 @@ void IProfilingBlockInputStream::progressImpl(const Progress & value) if (!process_list_elem->updateProgressIn(value)) cancel(); - /// Общее количество данных, обработанных или предполагаемых к обработке во всех листовых источниках, возможно, на удалённых серверах. + /// The total amount of data processed or intended for processing in all leaf sources, possibly on remote servers. size_t rows_processed = process_list_elem->progress_in.rows; size_t bytes_processed = process_list_elem->progress_in.bytes; size_t total_rows_estimate = std::max(rows_processed, process_list_elem->progress_in.total_rows.load(std::memory_order_relaxed)); - /** Проверяем ограничения на объём данных для чтения, скорость выполнения запроса, квоту на объём данных для чтения. - * NOTE: Может быть, имеет смысл сделать, чтобы они проверялись прямо в ProcessList? + /** Check the restrictions on the amount of data to read, the speed of the query, the quota on the amount of data to read. + * NOTE: Maybe it makes sense to have them checked directly in ProcessList? */ if (limits.mode == LIMITS_TOTAL @@ -260,7 +260,7 @@ void IProfilingBlockInputStream::progressImpl(const Progress & value) } else if (limits.read_overflow_mode == OverflowMode::BREAK) { - /// Для break будем останавливаться только если действительно было прочитано столько строк, а не только предполагается к чтению. + /// For `break`, we will stop only if so many lines were actually read, and not just supposed to be read. if ((limits.max_rows_to_read && rows_processed > limits.max_rows_to_read) || (limits.max_bytes_to_read && bytes_processed > limits.max_bytes_to_read)) { @@ -286,7 +286,7 @@ void IProfilingBlockInputStream::progressImpl(const Progress & value) size_t total_rows = process_list_elem->progress_in.total_rows; - /// Если предсказанное время выполнения больше, чем max_execution_time. + /// If the predicted execution time is longer than `max_execution_time`. if (limits.max_execution_time != 0 && total_rows) { double estimated_execution_time_seconds = total_elapsed * (static_cast(total_rows) / rows_processed); diff --git a/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp b/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp index 8245a7450b2..f2839ab6154 100644 --- a/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp +++ b/dbms/src/DataStreams/JSONEachRowRowInputStream.cpp @@ -20,13 +20,13 @@ JSONEachRowRowInputStream::JSONEachRowRowInputStream(ReadBuffer & istr_, const B size_t columns = sample.columns(); for (size_t i = 0; i < columns; ++i) - name_map[sample.safeGetByPosition(i).name] = i; /// NOTE Можно было бы расположить имена более кэш-локально. + name_map[sample.safeGetByPosition(i).name] = i; /// NOTE You could place names more cache-locally. } -/** Прочитать имя поля в формате JSON. - * Ссылка на имя поля будет записана в ref. - * Также может быть использован временный буфер tmp, чтобы скопировать туда имя поля. +/** Read the field name in JSON format. + * A reference to the field name will be written to ref. + * You can also use temporary `tmp` buffer to copy field name there. */ static StringRef readName(ReadBuffer & buf, String & tmp) { @@ -36,7 +36,7 @@ static StringRef readName(ReadBuffer & buf, String & tmp) if (next_pos != buf.buffer().end() && *next_pos != '\\') { - /// Наиболее вероятный вариант - в имени ключа нет эскейп-последовательностей и имя целиком поместилось в буфер. + /// The most likely option is that there is no escape sequence in the key name, and the entire name is placed in the buffer. assertChar('"', buf); StringRef res(buf.position(), next_pos - buf.position()); buf.position() += next_pos - buf.position(); @@ -68,8 +68,8 @@ bool JSONEachRowRowInputStream::read(Block & block) size_t columns = block.columns(); - /// Множество столбцов, для которых были считаны значения. Остальные затем заполним значениями по-умолчанию. - /// TODO Возможность предоставить свои DEFAULT-ы. + /// Set of columns for which the values ​​were read. The rest will be filled with default values. + /// TODO Ability to provide your DEFAULTs. bool read_columns[columns]; memset(read_columns, 0, columns); @@ -96,8 +96,8 @@ bool JSONEachRowRowInputStream::read(Block & block) StringRef name_ref = readName(istr, name_buf); - /// NOTE Возможна оптимизация путём кэширования порядка полей (который почти всегда одинаковый) - /// и быстрой проверки на соответствие следующему ожидаемому полю, вместо поиска в хэш-таблице. + /// NOTE Optimization is possible by caching the order of fields (which is almost always the same) + /// and a quick check to match the next expected field, instead of searching the hash table. auto it = name_map.find(name_ref); if (name_map.end() == it) @@ -127,7 +127,7 @@ bool JSONEachRowRowInputStream::read(Block & block) if (!istr.eof() && *istr.position() == ',') ++istr.position(); - /// Заполняем не встретившиеся столбцы значениями по-умолчанию. + /// Fill non-visited columns with the default values. for (size_t i = 0; i < columns; ++i) if (!read_columns[i]) block.getByPosition(i).column.get()->insertDefault(); diff --git a/dbms/src/DataStreams/LimitBlockInputStream.cpp b/dbms/src/DataStreams/LimitBlockInputStream.cpp index d94b752cd7c..5af71062707 100644 --- a/dbms/src/DataStreams/LimitBlockInputStream.cpp +++ b/dbms/src/DataStreams/LimitBlockInputStream.cpp @@ -18,7 +18,7 @@ Block LimitBlockInputStream::readImpl() Block res; size_t rows = 0; - /// pos - сколько строк было прочитано, включая последний прочитанный блок + /// pos - how many lines were read, including the last read block if (pos >= offset + limit) { @@ -41,11 +41,11 @@ Block LimitBlockInputStream::readImpl() pos += rows; } while (pos <= offset); - /// отдать целый блок + /// give away the whole block if (pos >= offset + rows && pos <= offset + limit) return res; - /// отдать кусок блока + /// give away a piece of the block size_t start = std::max( static_cast(0), static_cast(offset) - static_cast(pos) + static_cast(rows)); diff --git a/dbms/src/DataStreams/MergingSortedBlockInputStream.cpp b/dbms/src/DataStreams/MergingSortedBlockInputStream.cpp index 48bf1b61c49..0798ec80c6a 100644 --- a/dbms/src/DataStreams/MergingSortedBlockInputStream.cpp +++ b/dbms/src/DataStreams/MergingSortedBlockInputStream.cpp @@ -32,7 +32,7 @@ String MergingSortedBlockInputStream::getID() const for (size_t i = 0; i < children.size(); ++i) children_ids[i] = children[i]->getID(); - /// Порядок не имеет значения. + /// The order does not matter. std::sort(children_ids.begin(), children_ids.end()); for (size_t i = 0; i < children_ids.size(); ++i) @@ -47,7 +47,7 @@ String MergingSortedBlockInputStream::getID() const void MergingSortedBlockInputStream::init(Block & merged_block, ColumnPlainPtrs & merged_columns) { - /// Читаем первые блоки, инициализируем очередь. + /// Read the first blocks, initialize the queue. if (first) { first = false; @@ -83,9 +83,9 @@ void MergingSortedBlockInputStream::init(Block & merged_block, ColumnPlainPtrs & initQueue(queue); } - /// Инициализируем результат. + /// Initialize the result. - /// Клонируем структуру первого непустого блока источников. + /// We clone the structure of the first non-empty source block. { auto it = source_blocks.cbegin(); for (; it != source_blocks.cend(); ++it) @@ -99,12 +99,12 @@ void MergingSortedBlockInputStream::init(Block & merged_block, ColumnPlainPtrs & } } - /// Если все входные блоки пустые. + /// If all the input blocks are empty. if (it == source_blocks.cend()) return; } - /// Проверим, что у всех блоков-источников одинаковая структура. + /// Let's check that all source blocks have the same structure. for (auto it = source_blocks.cbegin(); it != source_blocks.cend(); ++it) { const SharedBlockPtr & shared_block_ptr = *it; @@ -178,8 +178,8 @@ void MergingSortedBlockInputStream::merge(Block & merged_block, ColumnPlainPtrs { size_t merged_rows = 0; - /** Увеличить счётчики строк. - * Вернуть true, если пора закончить формировать текущий блок данных. + /** Increase row counters. + * Return true if it's time to finish generating the current data block. */ auto count_row_and_check_limit = [&, this]() { @@ -202,7 +202,7 @@ void MergingSortedBlockInputStream::merge(Block & merged_block, ColumnPlainPtrs return false; }; - /// Вынимаем строки в нужном порядке и кладём в merged_block, пока строк не больше max_block_size + /// Take rows in required order and put them into `merged_block`, while the rows are no more than `max_block_size` while (!queue.empty()) { TSortCursor current = queue.top(); @@ -210,14 +210,14 @@ void MergingSortedBlockInputStream::merge(Block & merged_block, ColumnPlainPtrs while (true) { - /** А вдруг для текущего курсора блок целиком меньше или равен, чем остальные? - * Или в очереди остался только один источник данных? Тогда можно целиком взять блок текущего курсора. + /** And what if the block is smaller or equal than the rest for the current cursor? + * Or is there only one data source left in the queue? Then you can take the entire block of current cursor. */ if (current.impl->isFirst() && (queue.empty() || current.totallyLessOrEquals(queue.top()))) { // std::cerr << "current block is totally less or equals\n"; - /// Если в текущем блоке уже есть данные, то сначала вернём его. Мы попадём сюда снова при следующем вызове функции merge. + /// If there are already data in the current block, we first return it. We'll get here again the next time we call the merge function. if (merged_rows != 0) { // std::cerr << "merged rows is non-zero\n"; @@ -286,7 +286,7 @@ void MergingSortedBlockInputStream::merge(Block & merged_block, ColumnPlainPtrs return; } - /// Не кладём курсор обратно в очередь, а продолжаем работать с текущим курсором. + /// Do not put the cursor back in the queue, but continue to work with the current cursor. // std::cerr << "current is still on top, using current row\n"; continue; } @@ -298,7 +298,7 @@ void MergingSortedBlockInputStream::merge(Block & merged_block, ColumnPlainPtrs } else { - /// Достаём из соответствующего источника следующий блок, если есть. + /// We get the next block from the corresponding source, if there is one. // std::cerr << "It was last row, fetching next block\n"; fetchNextBlock(current, queue); } diff --git a/dbms/src/DataStreams/NativeBlockInputStream.cpp b/dbms/src/DataStreams/NativeBlockInputStream.cpp index e73385ec411..f4394016158 100644 --- a/dbms/src/DataStreams/NativeBlockInputStream.cpp +++ b/dbms/src/DataStreams/NativeBlockInputStream.cpp @@ -63,7 +63,7 @@ void NativeBlockInputStream::readData(const IDataType & type, IColumn & column, } else if (const DataTypeArray * type_arr = typeid_cast(&type)) { - /** Для массивов требуется сначала десериализовать смещения, а потом значения. + /** For arrays, you first need to deserialize the offsets, and then the values. */ IColumn & offsets_column = *typeid_cast(column).getOffsetsColumn(); type_arr->getOffsetsType()->deserializeBinaryBulk(offsets_column, istr, rows, 0); @@ -79,7 +79,7 @@ void NativeBlockInputStream::readData(const IDataType & type, IColumn & column, typeid_cast(column).getOffsets()[rows - 1]); } else - type.deserializeBinaryBulk(column, istr, rows, 0); /// TODO Использовать avg_value_size_hint. + type.deserializeBinaryBulk(column, istr, rows, 0); /// TODO Use avg_value_size_hint. if (column.size() != rows) throw Exception("Cannot read all data in NativeBlockInputStream.", ErrorCodes::CANNOT_READ_ALL_DATA); @@ -103,11 +103,11 @@ Block NativeBlockInputStream::readImpl() return res; } - /// Дополнительная информация о блоке. + /// Additional information about the block. if (server_revision >= DBMS_MIN_REVISION_WITH_BLOCK_INFO) res.info.read(istr); - /// Размеры + /// Dimensions size_t columns = 0; size_t rows = 0; @@ -126,7 +126,7 @@ Block NativeBlockInputStream::readImpl() { if (use_index) { - /// Если текущая позиция и так какая требуется, то реального seek-а не происходит. + /// If the current position is what is required, the real seek does not occur. istr_concrete->seek(index_column_it->location.offset_in_compressed_file, index_column_it->location.offset_in_decompressed_block); } diff --git a/dbms/src/DataStreams/NativeBlockOutputStream.cpp b/dbms/src/DataStreams/NativeBlockOutputStream.cpp index 6761acd8b7c..877b745cbfc 100644 --- a/dbms/src/DataStreams/NativeBlockOutputStream.cpp +++ b/dbms/src/DataStreams/NativeBlockOutputStream.cpp @@ -44,8 +44,8 @@ void NativeBlockOutputStream::flush() void NativeBlockOutputStream::writeData(const IDataType & type, const ColumnPtr & column, WriteBuffer & ostr, size_t offset, size_t limit) { - /** Если есть столбцы-константы - то материализуем их. - * (Так как тип данных не умеет сериализовывать/десериализовывать константы.) + /** If there are columns-constants - then we materialize them. + * (Since the data type does not know how to serialize / deserialize constants.) */ ColumnPtr full_column; @@ -69,7 +69,7 @@ void NativeBlockOutputStream::writeData(const IDataType & type, const ColumnPtr } else if (const DataTypeArray * type_arr = typeid_cast(&type)) { - /** Для массивов требуется сначала сериализовать смещения, а потом значения. + /** For arrays, you first need to serialize the offsets, and then the values. */ const ColumnArray & column_array = typeid_cast(*full_column); type_arr->getOffsetsType()->serializeBinaryBulk(*column_array.getOffsetsColumn(), ostr, offset, limit); @@ -81,12 +81,12 @@ void NativeBlockOutputStream::writeData(const IDataType & type, const ColumnPtr if (offset > offsets.size()) return; - /** offset - с какого массива писать. - * limit - сколько массивов максимум записать, или 0, если писать всё, что есть. - * end - до какого массива заканчивается записываемый кусок. + /** offset - from which array to write. + * limit - how many arrays should be written, or 0, if you write everything that is. + * end - up to which array written part finishes. * - * nested_offset - с какого элемента внутренностей писать. - * nested_limit - сколько элементов внутренностей писать, или 0, если писать всё, что есть. + * nested_offset - from which nested element to write. + * nested_limit - how many nested elements to write, or 0, if you write everything that is. */ size_t end = std::min(offset + limit, offsets.size()); @@ -118,19 +118,19 @@ void NativeBlockOutputStream::writeData(const IDataType & type, const ColumnPtr void NativeBlockOutputStream::write(const Block & block) { - /// Дополнительная информация о блоке. + /// Additional information about the block. if (client_revision >= DBMS_MIN_REVISION_WITH_BLOCK_INFO) block.info.write(ostr); - /// Размеры + /// Dimensions size_t columns = block.columns(); size_t rows = block.rows(); writeVarUInt(columns, ostr); writeVarUInt(rows, ostr); - /** Индекс имеет ту же структуру, что и поток с данными. - * Но вместо значений столбца он содержит засечку, ссылающуюся на место в файле с данными, где находится этот кусочек столбца. + /** The index has the same structure as the data stream. + * But instead of column values, it contains a mark that points to the location in the data file where this part of the column is located. */ if (index_ostr) { @@ -140,12 +140,12 @@ void NativeBlockOutputStream::write(const Block & block) for (size_t i = 0; i < columns; ++i) { - /// Для индекса. + /// For the index. MarkInCompressedFile mark; if (index_ostr) { - ostr_concrete->next(); /// Заканчиваем сжатый блок. + ostr_concrete->next(); /// Finish compressed block. mark.offset_in_compressed_file = initial_size_of_file + ostr_concrete->getCompressedBytes(); mark.offset_in_decompressed_block = ostr_concrete->getRemainingBytes(); } diff --git a/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.cpp b/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.cpp index 66bcdef70c4..dbffcd85bf8 100644 --- a/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.cpp +++ b/dbms/src/DataStreams/ParallelAggregatingBlockInputStream.cpp @@ -38,7 +38,7 @@ String ParallelAggregatingBlockInputStream::getID() const for (size_t i = 0; i < children.size(); ++i) children_ids[i] = children[i]->getID(); - /// Порядок не имеет значения. + /// Order does not matter. std::sort(children_ids.begin(), children_ids.end()); for (size_t i = 0; i < children_ids.size(); ++i) @@ -74,14 +74,14 @@ Block ParallelAggregatingBlockInputStream::readImpl() if (!aggregator.hasTemporaryFiles()) { - /** Если все частично-агрегированные данные в оперативке, то мерджим их параллельно, тоже в оперативке. + /** If all partially-aggregated data is in RAM, then merge them in parallel, also in RAM. */ impl = aggregator.mergeAndConvertToBlocks(many_data, final, max_threads); } else { - /** Если есть временные файлы с частично-агрегированными данными на диске, - * то читаем и мерджим их, расходуя минимальное количество памяти. + /** If there are temporary files with partially-aggregated data on the disk, + * then read and merge them, spending the minimum amount of memory. */ ProfileEvents::increment(ProfileEvents::ExternalAggregationMerge); @@ -133,7 +133,7 @@ void ParallelAggregatingBlockInputStream::Handler::onFinishThread(size_t thread_ { if (!parent.isCancelled() && parent.aggregator.hasTemporaryFiles()) { - /// Сбросим имеющиеся в оперативке данные тоже на диск. Так проще их потом объединять. + /// Flush data in the RAM to disk. So it's easier to unite them later. auto & data = *parent.many_data[thread_num]; if (data.isConvertibleToTwoLevel()) @@ -149,8 +149,8 @@ void ParallelAggregatingBlockInputStream::Handler::onFinish() { if (!parent.isCancelled() && parent.aggregator.hasTemporaryFiles()) { - /// Может так получиться, что какие-то данные ещё не сброшены на диск, - /// потому что во время вызова onFinishThread ещё никакие данные не были сброшены на диск, а потом какие-то - были. + /// It may happen that some data has not yet been flushed, + /// because at the time of `onFinishThread` call, no data has been flushed to disk, and then some were. for (auto & data : parent.many_data) { if (data->isConvertibleToTwoLevel()) diff --git a/dbms/src/DataStreams/PrettyBlockOutputStream.cpp b/dbms/src/DataStreams/PrettyBlockOutputStream.cpp index 6b301e6435c..d3baad83199 100644 --- a/dbms/src/DataStreams/PrettyBlockOutputStream.cpp +++ b/dbms/src/DataStreams/PrettyBlockOutputStream.cpp @@ -101,7 +101,7 @@ void PrettyBlockOutputStream::write(const Block & block_) return; } - /// Будем вставлять суда столбцы с вычисленными значениями видимых длин. + /// We will insert here columns with the calculated values ​​of visible lengths. Block block = block_; size_t rows = block.rows(); @@ -111,7 +111,7 @@ void PrettyBlockOutputStream::write(const Block & block_) Widths_t name_widths; calculateWidths(block, max_widths, name_widths); - /// Создадим разделители + /// Create separators std::stringstream top_separator; std::stringstream middle_names_separator; std::stringstream middle_values_separator; @@ -149,10 +149,10 @@ void PrettyBlockOutputStream::write(const Block & block_) std::string middle_values_separator_s = middle_values_separator.str(); std::string bottom_separator_s = bottom_separator.str(); - /// Выведем блок + /// Output the block writeString(top_separator_s, ostr); - /// Имена + /// Names writeCString("┃ ", ostr); for (size_t i = 0; i < columns; ++i) { diff --git a/dbms/src/DataStreams/PrettyCompactBlockOutputStream.cpp b/dbms/src/DataStreams/PrettyCompactBlockOutputStream.cpp index 2c9948a031d..009f8dab16a 100644 --- a/dbms/src/DataStreams/PrettyCompactBlockOutputStream.cpp +++ b/dbms/src/DataStreams/PrettyCompactBlockOutputStream.cpp @@ -18,7 +18,7 @@ void PrettyCompactBlockOutputStream::writeHeader( const Widths_t & max_widths, const Widths_t & name_widths) { - /// Имена + /// Names writeCString("┌─", ostr); for (size_t i = 0; i < max_widths.size(); ++i) { @@ -55,7 +55,7 @@ void PrettyCompactBlockOutputStream::writeHeader( void PrettyCompactBlockOutputStream::writeBottom(const Widths_t & max_widths) { - /// Создадим разделители + /// Create delimiters std::stringstream bottom_separator; bottom_separator << "└"; @@ -118,7 +118,7 @@ void PrettyCompactBlockOutputStream::write(const Block & block_) return; } - /// Будем вставлять сюда столбцы с вычисленными значениями видимых длин. + /// We will insert columns here with the calculated values ​​of visible lengths. Block block = block_; size_t rows = block.rows(); diff --git a/dbms/src/DataStreams/PrettySpaceBlockOutputStream.cpp b/dbms/src/DataStreams/PrettySpaceBlockOutputStream.cpp index 4e516dae83d..0e61c9a87a5 100644 --- a/dbms/src/DataStreams/PrettySpaceBlockOutputStream.cpp +++ b/dbms/src/DataStreams/PrettySpaceBlockOutputStream.cpp @@ -15,7 +15,7 @@ void PrettySpaceBlockOutputStream::write(const Block & block_) return; } - /// Будем вставлять суда столбцы с вычисленными значениями видимых длин. + /// We will insert here columns with the calculated values ​​of visible lengths. Block block = block_; size_t rows = block.rows(); @@ -25,13 +25,13 @@ void PrettySpaceBlockOutputStream::write(const Block & block_) Widths_t name_widths; calculateWidths(block, max_widths, name_widths); - /// Не будем выравнивать по слишком длинным значениям. + /// Do not align on too long values. if (terminal_width > 80) for (size_t i = 0; i < columns; ++i) if (max_widths[i] > terminal_width / 2) max_widths[i] = terminal_width / 2; - /// Имена + /// Names for (size_t i = 0; i < columns; ++i) { if (i != 0) diff --git a/dbms/src/DataStreams/RemoteBlockInputStream.cpp b/dbms/src/DataStreams/RemoteBlockInputStream.cpp index 3e323d0e264..81d89f90f17 100644 --- a/dbms/src/DataStreams/RemoteBlockInputStream.cpp +++ b/dbms/src/DataStreams/RemoteBlockInputStream.cpp @@ -54,9 +54,9 @@ RemoteBlockInputStream::RemoteBlockInputStream(ConnectionPoolsPtr & pools_, cons RemoteBlockInputStream::~RemoteBlockInputStream() { - /** Если прервались в середине цикла общения с репликами, то прервываем - * все соединения, затем читаем и пропускаем оставшиеся пакеты чтобы - * эти соединения не остались висеть в рассихронизированном состоянии. + /** If interrupted in the middle of the loop of communication with replicas, then interrupt + * all connections, then read and skip the remaining packets to make sure + * these connections did not remain hanging in the out-of-sync state. */ if (established || isQueryPending()) multiplexed_connections->disconnect(); @@ -87,7 +87,7 @@ void RemoteBlockInputStream::cancel() { std::lock_guard lock(external_tables_mutex); - /// Останавливаем отправку внешних данных. + /// Stop sending external data. for (auto & vec : external_tables_data) for (auto & elem : vec) if (IProfilingBlockInputStream * stream = dynamic_cast(elem.first.get())) @@ -150,10 +150,10 @@ Block RemoteBlockInputStream::readImpl() switch (packet.type) { case Protocol::Server::Data: - /// Если блок не пуст и не является заголовочным блоком + /// If the block is not empty and is not a header block if (packet.block && (packet.block.rows() > 0)) return packet.block; - break; /// Если блок пуст - получим другие пакеты до EndOfStream. + break; /// If the block is empty - we will receive other packets before EndOfStream. case Protocol::Server::Exception: got_exception_from_replica = true; @@ -169,11 +169,11 @@ Block RemoteBlockInputStream::readImpl() break; case Protocol::Server::Progress: - /** Используем прогресс с удалённого сервера. - * В том числе, запишем его в ProcessList, - * и будем использовать его для проверки - * ограничений (например, минимальная скорость выполнения запроса) - * и квот (например, на количество строчек для чтения). + /** We use the progress from a remote server. + * We also include in ProcessList, + * and we use it to check + * constraints (for example, the minimum speed of query execution) + * and quotas (for example, the number of lines to read). */ progressImpl(packet.progress); break; @@ -200,24 +200,25 @@ Block RemoteBlockInputStream::readImpl() void RemoteBlockInputStream::readSuffixImpl() { - /** Если одно из: - * - ничего не начинали делать; - * - получили все пакеты до EndOfStream; + /** If one of: + * - nothing started to do; + * - received all packets before EndOfStream; * - получили с одной реплики эксепшен; - * - получили с одной реплики неизвестный пакет; - * то больше читать ничего не нужно. + * - received exception from one replica; + * - received an unknown packet from one replica; + * then you do not need to read anything. */ if (!isQueryPending() || hasThrownException()) return; - /** Если ещё прочитали не все данные, но они больше не нужны. - * Это может быть из-за того, что данных достаточно (например, при использовании LIMIT). + /** If you have not read all the data yet, but they are no longer needed. + * This may be due to the fact that the data is sufficient (for example, when using LIMIT). */ - /// Отправим просьбу прервать выполнение запроса, если ещё не отправляли. + /// Send the request to abort the execution of the request, if not already sent. tryCancel("Cancelling query because enough data has been read"); - /// Получим оставшиеся пакеты, чтобы не было рассинхронизации в соединениях с репликами. + /// Get the remaining packages so that there is no out of sync in the connections to the replicas. Connection::Packet packet = multiplexed_connections->drain(); switch (packet.type) { diff --git a/dbms/src/DataStreams/ReplacingSortedBlockInputStream.cpp b/dbms/src/DataStreams/ReplacingSortedBlockInputStream.cpp index 6b0e8818639..e237fe3f9b1 100644 --- a/dbms/src/DataStreams/ReplacingSortedBlockInputStream.cpp +++ b/dbms/src/DataStreams/ReplacingSortedBlockInputStream.cpp @@ -52,7 +52,7 @@ void ReplacingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, st { size_t merged_rows = 0; - /// Вынимаем строки в нужном порядке и кладём в merged_block, пока строк не больше max_block_size + /// Take the rows in needed order and put them into `merged_block` until rows no more than `max_block_size` while (!queue.empty()) { TSortCursor current = queue.top(); @@ -73,7 +73,7 @@ void ReplacingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, st bool key_differs = next_key != current_key; - /// если накопилось достаточно строк и последняя посчитана полностью + /// if there are enough rows and the last one is calculated completely if (key_differs && merged_rows >= max_block_size) return; @@ -82,12 +82,12 @@ void ReplacingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, st if (key_differs) { max_version = 0; - /// Запишем данные для предыдущего первичного ключа. + /// Write the data for the previous primary key. insertRow(merged_columns, merged_rows); current_key.swap(next_key); } - /// Нестрогое сравнение, так как мы выбираем последнюю строку для одинаковых значений версий. + /// A non-strict comparison, since we select the last row for the same version values. if (version >= max_version) { max_version = version; @@ -101,12 +101,12 @@ void ReplacingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, st } else { - /// Достаём из соответствующего источника следующий блок, если есть. + /// We get the next block from the corresponding source, if there is one. fetchNextBlock(current, queue); } } - /// Запишем данные для последнего первичного ключа. + /// We will write the data for the last primary key. insertRow(merged_columns, merged_rows); finished = true; diff --git a/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp b/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp index c5c0e959def..7b82a91d312 100644 --- a/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp +++ b/dbms/src/DataStreams/SummingSortedBlockInputStream.cpp @@ -63,19 +63,19 @@ Block SummingSortedBlockInputStream::readImpl() if (merged_columns.empty()) return Block(); - /// Дополнительная инициализация. + /// Additional initialization. if (current_row.empty()) { current_row.resize(num_columns); next_key.columns.resize(description.size()); - /// Имя вложенной структуры -> номера столбцов, которые к ней относятся. + /// name of nested structure -> the column numbers that refer to it. std::unordered_map> discovered_maps; - /** Заполним номера столбцов, которые должны быть просуммированы. - * Это могут быть только числовые столбцы, не входящие в ключ сортировки. - * Если задан непустой список column_names_to_sum, то берём только эти столбцы. - * Часть столбцов из column_names_to_sum может быть не найдена. Это игнорируется. + /** Fill in the column numbers, which must be summed. + * This can only be numeric columns that are not part of the sort key. + * If a non-empty column_names_to_sum is specified, then we only take these columns. + * Some columns from column_names_to_sum may not be found. This is ignored. */ for (size_t i = 0; i < num_columns; ++i) { @@ -93,7 +93,7 @@ Block SummingSortedBlockInputStream::readImpl() } else { - /// Оставляем только числовые типы. При чём, даты и даты-со-временем здесь такими не считаются. + /// Leave only numeric types. Note that dates and datetime here are not considered such. if (!column.type->isNumeric() || column.type->getName() == "Date" || column.type->getName() == "DateTime" || @@ -101,7 +101,7 @@ Block SummingSortedBlockInputStream::readImpl() column.type->getName() == "Nullable(DateTime)") continue; - /// Входят ли в PK? + /// Do they enter the PK? if (isInPrimaryKey(description, column.name, i)) continue; @@ -180,7 +180,7 @@ void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std: { size_t merged_rows = 0; - /// Вынимаем строки в нужном порядке и кладём в merged_block, пока строк не больше max_block_size + /// Take the rows in needed order and put them in `merged_block` until rows no more than `max_block_size` while (!queue.empty()) { TSortCursor current = queue.top(); @@ -189,8 +189,8 @@ void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std: bool key_differs; - if (current_key.empty()) /// Первый встретившийся ключ. - { + if (current_key.empty()) /// The first key encountered. + { current_key.columns.resize(description.size()); setPrimaryKeyRef(current_key, current); key_differs = true; @@ -198,7 +198,7 @@ void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std: else key_differs = next_key != current_key; - /// если накопилось достаточно строк и последняя посчитана полностью + /// if there are enough rows and the last one is calculated completely if (key_differs && merged_rows >= max_block_size) return; @@ -206,7 +206,7 @@ void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std: if (key_differs) { - /// Запишем данные для предыдущей группы. + /// Write the data for the previous group. if (!current_row_is_zero) { ++merged_rows; @@ -231,13 +231,13 @@ void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std: } else { - /// Достаём из соответствующего источника следующий блок, если есть. + /// We get the next block from the corresponding source, if there is one. fetchNextBlock(current, queue); } } - /// Запишем данные для последней группы, если она ненулевая. - /// Если она нулевая, и без нее выходной поток окажется пустым, запишем ее все равно. + /// We will write the data for the last group, if it is non-zero. + /// If it is zero, and without it the output stream will be empty, we will write it anyway. if (!current_row_is_zero || !output_is_non_empty) { ++merged_rows; @@ -248,8 +248,8 @@ void SummingSortedBlockInputStream::merge(ColumnPlainPtrs & merged_columns, std: } -/** Реализует операцию +=. - * Возвращает false, если результат получился нулевым. +/** Implements `+=` operation. + * Returns false if the result is zero. */ class FieldVisitorSum : public StaticVisitor { @@ -285,7 +285,7 @@ bool SummingSortedBlockInputStream::mergeMaps(Row & row, TSortCursor & cursor) template bool SummingSortedBlockInputStream::mergeMap(const MapDescription & desc, Row & row, TSortCursor & cursor) { - /// Сильно неоптимально. + /// Strongly non-optimal. Row & left = row; Row right(left.size()); @@ -369,7 +369,7 @@ bool SummingSortedBlockInputStream::mergeMap(const MapDescription & desc, Row & template bool SummingSortedBlockInputStream::addRow(Row & row, TSortCursor & cursor) { - bool res = mergeMaps(row, cursor); /// Есть ли хотя бы одно ненулевое число или непустой массив + bool res = mergeMaps(row, cursor); /// Is there at least one non-zero number or non-empty array for (size_t i = 0, size = column_numbers_to_sum.size(); i < size; ++i) { diff --git a/dbms/src/DataStreams/TSKVRowInputStream.cpp b/dbms/src/DataStreams/TSKVRowInputStream.cpp index 9fb112938aa..26a1375ff53 100644 --- a/dbms/src/DataStreams/TSKVRowInputStream.cpp +++ b/dbms/src/DataStreams/TSKVRowInputStream.cpp @@ -22,16 +22,16 @@ TSKVRowInputStream::TSKVRowInputStream(ReadBuffer & istr_, const Block & sample_ size_t columns = sample.columns(); for (size_t i = 0; i < columns; ++i) - name_map[sample.safeGetByPosition(i).name] = i; /// NOTE Можно было бы расположить имена более кэш-локально. + name_map[sample.safeGetByPosition(i).name] = i; /// NOTE You could place names more cache-locally. } -/** Прочитать имя поля в формате tskv. - * Вернуть true, если после имени поля идёт знак равенства, - * иначе (поле без значения) вернуть false. - * Ссылка на имя поля будет записана в ref. - * Также может быть использован временный буфер tmp, чтобы скопировать туда имя поля. - * При чтении, пропускает имя и знак равенства после него. +/** Read the field name in the `tskv` format. + * Return true if the field is followed by an equal sign, + * otherwise (field with no value) return false. + * The reference to the field name will be written to `ref`. + * A temporary `tmp` buffer can also be used to copy the field name to it. + * When reading, skips the name and the equal sign after it. */ static bool readName(ReadBuffer & buf, StringRef & ref, String & tmp) { @@ -48,26 +48,26 @@ static bool readName(ReadBuffer & buf, StringRef & ref, String & tmp) continue; } - /// Дошли до конца имени. + /// Came to the end of the name. if (*next_pos != '\\') { bool have_value = *next_pos == '='; if (tmp.empty()) { - /// Данные не нужно копировать, можно ссылаться прямо на внутренность buf. + /// No need to copy data, you can refer directly to the `buf`. ref = StringRef(buf.position(), next_pos - buf.position()); buf.position() += next_pos + have_value - buf.position(); } else { - /// Копируем данные во временную строку и возвращаем ссылку на неё. + /// Copy the data to a temporary string and return a reference to it. tmp.append(buf.position(), next_pos - buf.position()); buf.position() += next_pos + have_value - buf.position(); ref = StringRef(tmp); } return have_value; } - /// В имени есть эскейп-последовательность. + /// The name has an escape sequence. else { tmp.append(buf.position(), next_pos - buf.position()); @@ -92,14 +92,14 @@ bool TSKVRowInputStream::read(Block & block) size_t columns = block.columns(); - /// Множество столбцов, для которых были считаны значения. Остальные затем заполним значениями по-умолчанию. - /// TODO Возможность предоставить свои DEFAULT-ы. + /// Set of columns for which the values ​​were read. The rest will be filled with default values. + /// TODO Ability to provide your DEFAULTs. bool read_columns[columns]; memset(read_columns, 0, columns); if (unlikely(*istr.position() == '\n')) { - /// Пустая строка. Допустимо, но непонятно зачем. + /// An empty string. It is permissible, but it is unclear why. ++istr.position(); } else @@ -111,8 +111,8 @@ bool TSKVRowInputStream::read(Block & block) if (has_value) { - /// NOTE Возможна оптимизация путём кэширования порядка полей (который почти всегда одинаковый) - /// и быстрой проверки на соответствие следующему ожидаемому полю, вместо поиска в хэш-таблице. + /// NOTE Optimization is possible by caching the order of fields (which is almost always the same) + /// and quickly checking for the next expected field, instead of searching the hash table. auto it = name_map.find(name_ref); if (name_map.end() == it) @@ -120,7 +120,7 @@ bool TSKVRowInputStream::read(Block & block) if (!skip_unknown) throw Exception("Unknown field found while parsing TSKV format: " + name_ref.toString(), ErrorCodes::INCORRECT_DATA); - /// Если ключ не найден, то пропускаем значение. + /// If the key is not found, skip the value. NullSink sink; readEscapedStringInto(sink, istr); } @@ -139,7 +139,7 @@ bool TSKVRowInputStream::read(Block & block) } else { - /// Единственное, что может идти без значения - это фрагмент tskv, который игнорируется. + /// The only thing that can go without value is `tskv` fragment that is ignored. if (!(name_ref.size == 4 && 0 == memcmp(name_ref.data, "tskv", 4))) throw Exception("Found field without value while parsing TSKV format: " + name_ref.toString(), ErrorCodes::INCORRECT_DATA); } @@ -163,7 +163,7 @@ bool TSKVRowInputStream::read(Block & block) } } - /// Заполняем не встретившиеся столбцы значениями по-умолчанию. + /// Fill in the not met columns with default values. for (size_t i = 0; i < columns; ++i) if (!read_columns[i]) block.getByPosition(i).column.get()->insertDefault(); diff --git a/dbms/src/DataStreams/TabSeparatedRowInputStream.cpp b/dbms/src/DataStreams/TabSeparatedRowInputStream.cpp index 8cd0d93d440..e8d03dbf8d6 100644 --- a/dbms/src/DataStreams/TabSeparatedRowInputStream.cpp +++ b/dbms/src/DataStreams/TabSeparatedRowInputStream.cpp @@ -58,7 +58,7 @@ void TabSeparatedRowInputStream::readPrefix() } -/** Проверка на распространённый случай ошибки - использование Windows перевода строки. + /** Check for a common error case - usage of Windows line feed. */ static void checkForCarriageReturn(ReadBuffer & istr) { @@ -84,7 +84,7 @@ bool TabSeparatedRowInputStream::read(Block & block) { data_types[i].get()->deserializeTextEscaped(*block.getByPosition(i).column.get(), istr); - /// пропускаем разделители + /// skip separators if (i + 1 == size) { if (!istr.eof()) @@ -112,7 +112,7 @@ String TabSeparatedRowInputStream::getDiagnosticInfo() WriteBufferFromString out(res); Block block = sample.cloneEmpty(); - /// Вывести подробную диагностику возможно лишь если последняя и предпоследняя строка ещё находятся в буфере для чтения. + /// It is possible to display detailed diagnostics only if the last and next to last lines are still in the read buffer. size_t bytes_read_at_start_of_buffer = istr.count() - istr.offset(); if (bytes_read_at_start_of_buffer != bytes_read_at_start_of_buffer_on_prev_row) { @@ -130,7 +130,7 @@ String TabSeparatedRowInputStream::getDiagnosticInfo() if (sample.safeGetByPosition(i).type->getName().size() > max_length_of_data_type_name) max_length_of_data_type_name = sample.safeGetByPosition(i).type->getName().size(); - /// Откатываем курсор для чтения на начало предыдущей или текущей строки и парсим всё заново. Но теперь выводим подробную информацию. + /// Roll back the cursor to the beginning of the previous or current line and pars all over again. But now we derive detailed information. if (pos_of_prev_row) { @@ -194,7 +194,7 @@ bool TabSeparatedRowInputStream::parseRowAndPrintDiagnosticInfo(Block & block, if (data_types[i]->isNumeric()) { - /// Пустая строка вместо числа. + /// An empty string instead of a number. if (curr_position == prev_position) { out << "ERROR: text "; @@ -237,7 +237,7 @@ bool TabSeparatedRowInputStream::parseRowAndPrintDiagnosticInfo(Block & block, } } - /// Разделители + /// Delimiters if (i + 1 == size) { if (!istr.eof()) diff --git a/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp b/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp index 2997369e80d..6efcdff51d3 100644 --- a/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp +++ b/dbms/src/DataStreams/TotalsHavingBlockInputStream.cpp @@ -54,8 +54,8 @@ const Block & TotalsHavingBlockInputStream::getTotals() { if (!totals) { - /** Если totals_mode == AFTER_HAVING_AUTO, нужно решить, добавлять ли в TOTALS агрегаты для строк, - * не прошедших max_rows_to_group_by. + /** If totals_mode == AFTER_HAVING_AUTO, you need to decide whether to add aggregates to TOTALS for strings, + * not passed max_rows_to_group_by. */ if (overflow_aggregates) { @@ -86,7 +86,7 @@ Block TotalsHavingBlockInputStream::readImpl() { block = children[0]->read(); - /// Блок со значениями, не вошедшими в max_rows_to_group_by. Отложим его. + /// Block with values ​​not included in `max_rows_to_group_by`. We'll postpone it. if (overflow_row && block && block.info.is_overflows) { overflow_aggregates = block; @@ -107,7 +107,7 @@ Block TotalsHavingBlockInputStream::readImpl() } else { - /// Вычисляем выражение в HAVING. + /// Compute the expression in HAVING. expression->execute(finalized); size_t filter_column_pos = finalized.getPositionByName(filter_column_name); @@ -125,13 +125,13 @@ Block TotalsHavingBlockInputStream::readImpl() IColumn::Filter & filter = filter_column->getData(); - /// Прибавляем значения в totals (если это не было сделано ранее). + /// Add values ​​to `totals` (if it was not already done). if (totals_mode == TotalsMode::BEFORE_HAVING) addToTotals(current_totals, block, nullptr); else addToTotals(current_totals, block, &filter); - /// Фильтруем блок по выражению в HAVING. + /// Filter the block by expression in HAVING. size_t columns = finalized.columns(); for (size_t i = 0; i < columns; ++i) diff --git a/dbms/src/DataStreams/ValuesRowInputStream.cpp b/dbms/src/DataStreams/ValuesRowInputStream.cpp index 2faf43697b6..68cfe11f67c 100644 --- a/dbms/src/DataStreams/ValuesRowInputStream.cpp +++ b/dbms/src/DataStreams/ValuesRowInputStream.cpp @@ -41,9 +41,9 @@ bool ValuesRowInputStream::read(Block & block) if (istr.eof() || *istr.position() == ';') return false; - /** Как правило, это обычный формат для потокового парсинга. - * Но в качестве исключения, поддерживается также обработка произвольных выражений вместо значений. - * Это очень неэффективно. Но если выражений нет, то оверхед отсутствует. + /** Typically, this is the usual format for streaming parsing. + * But as an exception, it also supports processing arbitrary expressions instead of values. + * This is very inefficient. But if there are no expressions, then there is no overhead. */ ParserExpressionWithOptionalAlias parser(false); @@ -75,9 +75,9 @@ bool ValuesRowInputStream::read(Block & block) if (!interpret_expressions) throw; - /** Обычный потоковый парсер не смог распарсить значение. - * Попробуем распарсить его SQL-парсером как константное выражение. - * Это исключительный случай. + /** The normal streaming parser could not parse the value. + * Let's try to parse it with a SQL parser as a constant expression. + * This is an exceptional case. */ if (e.code() == ErrorCodes::CANNOT_PARSE_INPUT_ASSERTION_FAILED || e.code() == ErrorCodes::CANNOT_PARSE_QUOTED_STRING @@ -85,9 +85,9 @@ bool ValuesRowInputStream::read(Block & block) || e.code() == ErrorCodes::CANNOT_PARSE_DATETIME || e.code() == ErrorCodes::CANNOT_READ_ARRAY_FROM_TEXT) { - /// TODO Работоспособность, если выражение не помещается целиком до конца буфера. + /// TODO Performance if the expression does not fit entirely to the end of the buffer. - /// Если начало значения уже не лежит в буфере. + /// If the beginning of the value is no longer in the buffer. if (istr.count() - istr.offset() != prev_istr_bytes) throw; diff --git a/dbms/src/DataStreams/XMLRowOutputStream.cpp b/dbms/src/DataStreams/XMLRowOutputStream.cpp index ae54449f1e5..0746689c485 100644 --- a/dbms/src/DataStreams/XMLRowOutputStream.cpp +++ b/dbms/src/DataStreams/XMLRowOutputStream.cpp @@ -19,8 +19,8 @@ XMLRowOutputStream::XMLRowOutputStream(WriteBuffer & ostr_, const Block & sample if (!sample_.getByPosition(i).type->isNumeric()) have_non_numeric_columns = true; - /// В качестве имён элементов будем использовать имя столбца, если оно имеет допустимый вид, или "field", иначе. - /// Условие, приведённое ниже, более строгое, чем того требует стандарт XML. + /// As element names, we will use the column name if it has a valid form, or "field", otherwise. + /// The condition below is more strict than the XML standard requires. bool is_column_name_suitable = true; const char * begin = fields[i].name.data(); const char * end = begin + fields[i].name.size(); diff --git a/dbms/src/DataStreams/copyData.cpp b/dbms/src/DataStreams/copyData.cpp index 2000e6ddbe6..72e7bcf4968 100644 --- a/dbms/src/DataStreams/copyData.cpp +++ b/dbms/src/DataStreams/copyData.cpp @@ -32,7 +32,7 @@ void copyData(IBlockInputStream & from, IBlockOutputStream & to, std::atomic(&from)) { if (input->getProfileInfo().hasAppliedLimit()) diff --git a/dbms/src/DataStreams/glueBlockInputStreams.cpp b/dbms/src/DataStreams/glueBlockInputStreams.cpp index f1421a664fb..a700e4654ff 100644 --- a/dbms/src/DataStreams/glueBlockInputStreams.cpp +++ b/dbms/src/DataStreams/glueBlockInputStreams.cpp @@ -26,7 +26,7 @@ static void glue(BlockInputStreamPtr & node, IDsMap & ids_map, ForksMap & forks_ String id = node->getID(); if (ids_map.end() != ids_map.find(id) && ids_map[id].size() > 1) { - /// Вставить "вилку" или использовать уже готовую. + /// Insert a "fork" or use an existing one. if (forks_map.end() == forks_map.find(id)) { forks_map[id] = std::make_shared(node); diff --git a/dbms/src/DataStreams/tests/block_tab_separated_streams.cpp b/dbms/src/DataStreams/tests/block_tab_separated_streams.cpp index 34d16f1844f..8a653884e5e 100644 --- a/dbms/src/DataStreams/tests/block_tab_separated_streams.cpp +++ b/dbms/src/DataStreams/tests/block_tab_separated_streams.cpp @@ -84,7 +84,7 @@ try {"WithHash", std::make_shared()}, }; - /// создаём описание, как читать данные из tab separated дампа + /// we create a description of how to read data from the tab separated dump Block sample; for (const auto & name_type : names_and_types_list) @@ -96,7 +96,7 @@ try sample.insert(std::move(elem)); } - /// читаем данные из строчного tsv файла и одновременно пишем в блочный tsv файл + /// read the data from row tsv file and simultaneously write to the block tsv file { ReadBufferFromIStream in_buf(std::cin); WriteBufferFromOStream out_buf(std::cout); diff --git a/dbms/src/DataStreams/tests/filter_stream_hitlog.cpp b/dbms/src/DataStreams/tests/filter_stream_hitlog.cpp index 91aec6753a9..1a1c220c66d 100644 --- a/dbms/src/DataStreams/tests/filter_stream_hitlog.cpp +++ b/dbms/src/DataStreams/tests/filter_stream_hitlog.cpp @@ -103,11 +103,11 @@ int main(int argc, char ** argv) std::cerr << std::endl; std::cerr << ast->getTreeID() << std::endl; - /// создаём объект существующей таблицы хит лога + /// create an object of an existing hit log table StoragePtr table = StorageLog::create("./", "HitLog", std::make_shared(names_and_types_list)); - /// читаем из неё, применяем выражение, фильтруем, и пишем в tsv виде в консоль + /// read from it, apply the expression, filter, and write in tsv form to the console ExpressionAnalyzer analyzer(ast, context, nullptr, names_and_types_list); ExpressionActionsChain chain; diff --git a/dbms/src/DataStreams/tests/native_streams.cpp b/dbms/src/DataStreams/tests/native_streams.cpp index 02550e483b3..d38d6b76f00 100644 --- a/dbms/src/DataStreams/tests/native_streams.cpp +++ b/dbms/src/DataStreams/tests/native_streams.cpp @@ -93,11 +93,11 @@ try for (const auto & name_type : names_and_types_list) column_names.push_back(name_type.name); - /// создаём объект существующей таблицы хит лога + /// create an object of an existing hit log table StoragePtr table = StorageLog::create("./", "HitLog", std::make_shared(names_and_types_list)); - /// читаем из неё + /// read from it if (argc == 2 && 0 == strcmp(argv[1], "read")) { QueryProcessingStage::Enum stage; @@ -108,7 +108,7 @@ try copyData(*in, out3); } - /// читаем данные из native файла и одновременно пишем в таблицу + /// read the data from the native file and simultaneously write to the table if (argc == 2 && 0 == strcmp(argv[1], "write")) { ReadBufferFromFileDescriptor in1(STDIN_FILENO); diff --git a/dbms/src/DataStreams/tests/sorting_stream.cpp b/dbms/src/DataStreams/tests/sorting_stream.cpp index 6e0159e4fbf..180cec77f91 100644 --- a/dbms/src/DataStreams/tests/sorting_stream.cpp +++ b/dbms/src/DataStreams/tests/sorting_stream.cpp @@ -105,11 +105,11 @@ try formatAST(*ast, std::cerr); std::cerr << std::endl; - /// создаём объект существующей таблицы хит лога + /// create an object of an existing hit log table StoragePtr table = StorageLog::create("./", "HitLog", std::make_shared(names_and_types_list)); - /// читаем из неё, сортируем, и пишем в tsv виде в консоль + /// read from it, sort it, and write it in tsv form to the console Names column_names { diff --git a/dbms/src/DataTypes/DataTypeArray.cpp b/dbms/src/DataTypes/DataTypeArray.cpp index f051b7ef3c5..b24cadd6cda 100644 --- a/dbms/src/DataTypes/DataTypeArray.cpp +++ b/dbms/src/DataTypes/DataTypeArray.cpp @@ -105,12 +105,12 @@ void DataTypeArray::serializeBinaryBulk(const IColumn & column, WriteBuffer & os if (offset > offsets.size()) return; - /** offset - с какого массива писать. - * limit - сколько массивов максимум записать, или 0, если писать всё, что есть. - * end - до какого массива заканчивается записываемый кусок. + /** offset - from which array to write. + * limit - how many arrays should be written, or 0, if you write everything that is. + * end - up to which array the recorded piece ends. * - * nested_offset - с какого элемента внутренностей писать. - * nested_limit - сколько элементов внутренностей писать, или 0, если писать всё, что есть. + * nested_offset - from which element of the innards to write. + * nested_limit - how many elements of the innards to write, or 0, if you write everything that is. */ size_t end = std::min(offset + limit, offsets.size()); @@ -131,7 +131,7 @@ void DataTypeArray::deserializeBinaryBulk(IColumn & column, ReadBuffer & istr, s ColumnArray::Offsets_t & offsets = column_array.getOffsets(); IColumn & nested_column = column_array.getData(); - /// Должно быть считано согласнованное с offsets количество значений. + /// Number of values correlated with `offsets` must be read. size_t last_offset = (offsets.empty() ? 0 : offsets.back()); if (last_offset < nested_column.size()) throw Exception("Nested column longer than last offset", ErrorCodes::LOGICAL_ERROR); @@ -354,7 +354,7 @@ void DataTypeArray::serializeTextXML(const IColumn & column, size_t row_num, Wri void DataTypeArray::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr) const { - /// Хорошего способа сериализовать массив в CSV нет. Поэтому сериализуем его в строку, а затем полученную строку запишем в CSV. + /// There is no good way to serialize an array in CSV. Therefore, we serialize it into a string, and then write the resulting string in CSV. String s; { WriteBufferFromString wb(s); @@ -390,7 +390,7 @@ ColumnPtr DataTypeArray::createColumn() const ColumnPtr DataTypeArray::createConstColumn(size_t size, const Field & field) const { - /// Последним аргументом нельзя отдать this. + /// `this` can not be passed as the last argument. return std::make_shared(size, get(field), std::make_shared(nested)); } diff --git a/dbms/src/DataTypes/DataTypeDate.cpp b/dbms/src/DataTypes/DataTypeDate.cpp index 417ffc88fec..e5b8a12660a 100644 --- a/dbms/src/DataTypes/DataTypeDate.cpp +++ b/dbms/src/DataTypes/DataTypeDate.cpp @@ -43,7 +43,7 @@ void DataTypeDate::deserializeTextQuoted(IColumn & column, ReadBuffer & istr) co assertChar('\'', istr); readDateText(x, istr); assertChar('\'', istr); - static_cast(column).getData().push_back(x); /// Важно делать это в конце - для exception safety. + static_cast(column).getData().push_back(x); /// It's important to do this at the end - for exception safety. } void DataTypeDate::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, bool) const diff --git a/dbms/src/DataTypes/DataTypeDateTime.cpp b/dbms/src/DataTypes/DataTypeDateTime.cpp index 0ffa1deefed..befc19ce92a 100644 --- a/dbms/src/DataTypes/DataTypeDateTime.cpp +++ b/dbms/src/DataTypes/DataTypeDateTime.cpp @@ -43,7 +43,7 @@ void DataTypeDateTime::deserializeTextQuoted(IColumn & column, ReadBuffer & istr assertChar('\'', istr); readDateTimeText(x, istr); assertChar('\'', istr); - static_cast(column).getData().push_back(x); /// Важно делать это в конце - для exception safety. + static_cast(column).getData().push_back(x); /// It's important to do this at the end - for exception safety. } void DataTypeDateTime::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, bool) const diff --git a/dbms/src/DataTypes/DataTypeEnum.cpp b/dbms/src/DataTypes/DataTypeEnum.cpp index 4c9662490c8..1555aaf8786 100644 --- a/dbms/src/DataTypes/DataTypeEnum.cpp +++ b/dbms/src/DataTypes/DataTypeEnum.cpp @@ -150,7 +150,7 @@ void DataTypeEnum::serializeTextEscaped(const IColumn & column, size_t row template void DataTypeEnum::deserializeTextEscaped(IColumn & column, ReadBuffer & istr) const { - /// NOTE Неплохо было бы сделать без создания временного объекта - хотя бы вынести std::string наружу. + /// NOTE It would be nice to do without creating a temporary object - at least extract std::string out. std::string name; readEscapedString(name, istr); static_cast(column).getData().push_back(getValue(StringRef(name))); @@ -284,7 +284,7 @@ Field DataTypeEnum::castToValue(const Field & value_or_name) const } -/// Явные инстанцирования. +/// Explicit instantiations. template class DataTypeEnum; template class DataTypeEnum; diff --git a/dbms/src/DataTypes/DataTypeNumberBase.cpp b/dbms/src/DataTypes/DataTypeNumberBase.cpp index 1888f064537..a6f015d682c 100644 --- a/dbms/src/DataTypes/DataTypeNumberBase.cpp +++ b/dbms/src/DataTypes/DataTypeNumberBase.cpp @@ -83,7 +83,7 @@ template void DataTypeNumberBase::deserializeTextJSON(IColumn & column, ReadBuffer & istr) const { bool has_quote = false; - if (!istr.eof() && *istr.position() == '"') /// Понимаем число как в кавычках, так и без. + if (!istr.eof() && *istr.position() == '"') /// We understand the number both in quotes and without. { has_quote = true; ++istr.position(); @@ -133,7 +133,7 @@ Field DataTypeNumberBase::getDefault() const template void DataTypeNumberBase::serializeBinary(const Field & field, WriteBuffer & ostr) const { - /// ColumnVector::value_type - более узкий тип. Например, UInt8, когда тип Field - UInt64 + /// ColumnVector::value_type is a narrower type. For example, UInt8, when the Field type is UInt64 typename ColumnVector::value_type x = get::Type>(field); writeBinary(x, ostr); } diff --git a/dbms/src/DataTypes/DataTypeString.cpp b/dbms/src/DataTypes/DataTypeString.cpp index 80395786552..d0e1da2f637 100644 --- a/dbms/src/DataTypes/DataTypeString.cpp +++ b/dbms/src/DataTypes/DataTypeString.cpp @@ -126,7 +126,7 @@ static NO_INLINE void deserializeBinarySSE2(ColumnString::Chars_t & data, Column if (size) { #if __SSE2__ - /// Оптимистичная ветка, в которой возможно более эффективное копирование. + /// An optimistic branch in which more efficient copying is possible. if (offset + 16 * UNROLL_TIMES <= data.allocated_size() && istr.position() + size + 16 * UNROLL_TIMES <= istr.buffer().end()) { const __m128i * sse_src_pos = reinterpret_cast(istr.position()); @@ -135,7 +135,7 @@ static NO_INLINE void deserializeBinarySSE2(ColumnString::Chars_t & data, Column while (sse_src_pos < sse_src_end) { - /// NOTE gcc 4.9.2 разворачивает цикл, но почему-то использует только один xmm регистр. + /// NOTE gcc 4.9.2 expands the loop, but for some reason uses only one xmm register. ///for (size_t j = 0; j < UNROLL_TIMES; ++j) /// _mm_storeu_si128(sse_dst_pos + j, _mm_loadu_si128(sse_src_pos + j)); @@ -177,18 +177,18 @@ void DataTypeString::deserializeBinaryBulk(IColumn & column, ReadBuffer & istr, if (avg_value_size_hint && avg_value_size_hint > sizeof(offsets[0])) { - /// Выбрано наугад. + /// Randomly selected. constexpr auto avg_value_size_hint_reserve_multiplier = 1.2; avg_chars_size = (avg_value_size_hint - sizeof(offsets[0])) * avg_value_size_hint_reserve_multiplier; } else { - /** Небольшая эвристика для оценки того, что в столбце много пустых строк. - * В этом случае, для экономии оперативки, будем говорить, что средний размер значения маленький. + /** A small heuristic to evaluate that there are a lot of empty lines in the column. + * In this case, to save RAM, we will say that the average size of the value is small. */ if (istr.position() + sizeof(UInt32) <= istr.buffer().end() - && unalignedLoad(istr.position()) == 0) /// Первые 4 строки находятся в буфере и являются пустыми. + && unalignedLoad(istr.position()) == 0) /// The first 4 rows are in the buffer and are empty. { avg_chars_size = 1; } diff --git a/dbms/src/DataTypes/DataTypeTuple.cpp b/dbms/src/DataTypes/DataTypeTuple.cpp index 4472f7c45b3..191da2fe5ae 100644 --- a/dbms/src/DataTypes/DataTypeTuple.cpp +++ b/dbms/src/DataTypes/DataTypeTuple.cpp @@ -62,7 +62,7 @@ void DataTypeTuple::serializeBinary(const IColumn & column, size_t row_num, Writ template static void deserializeSafe(const DataTypes & elems, IColumn & column, ReadBuffer & istr, F && impl) { - /// Используем допущение, что кортежей нулевого размера не бывает. + /// We use the assumption that tuples of zero size do not exist. size_t old_size = extractElementColumn(column, 0).size(); try diff --git a/dbms/src/DataTypes/FieldToDataType.cpp b/dbms/src/DataTypes/FieldToDataType.cpp index e3cb11a08af..4232e34fbb7 100644 --- a/dbms/src/DataTypes/FieldToDataType.cpp +++ b/dbms/src/DataTypes/FieldToDataType.cpp @@ -69,13 +69,13 @@ DataTypePtr FieldToDataType::operator() (Array & x) const if (x.empty()) throw Exception("Cannot infer type of empty array", ErrorCodes::EMPTY_DATA_PASSED); - /** Тип массива нужно вывести по типу его элементов. - * Если элементы - числа, то нужно выбрать наименьший общий тип, если такой есть, - * или кинуть исключение. - * Код похож на NumberTraits::ResultOfIf, но тем кодом трудно здесь непосредственно воспользоваться. + /** The type of the array should be determined by the type of its elements. + * If the elements are numbers, then select the smallest common type, if any, + * or throw an exception. + * The code is similar to NumberTraits::ResultOfIf, but it's hard to use this code directly. * - * Также заметим, что Float32 не выводится, вместо этого используется только Float64. - * Это сделано потому что литералов типа Float32 не бывает в запросе. + * Also notice that Float32 is not output, only Float64 is used instead. + * This is done because Float32 type literals do not exist in the query. */ bool has_string = false; @@ -209,7 +209,7 @@ DataTypePtr FieldToDataType::operator() (Array & x) const if (max_unsigned_bits >= max_signed_bits) { - /// Беззнаковый тип не помещается в знаковый. Надо увеличить количество бит. + /// An unsigned type does not fit into a signed type. It is necessary to increase the number of bits. if (max_bits == 8) return wrap_into_array(std::make_shared()); if (max_bits == 16) @@ -221,7 +221,7 @@ DataTypePtr FieldToDataType::operator() (Array & x) const } else { - /// Беззнаковый тип помещается в знаковый. + /// An unsigned type is placed in a signed type. if (max_bits == 8) return wrap_into_array(std::make_shared()); if (max_bits == 16) diff --git a/dbms/src/Databases/DatabaseCloud.cpp b/dbms/src/Databases/DatabaseCloud.cpp index 13dabaec2b3..3ba00f16858 100644 --- a/dbms/src/Databases/DatabaseCloud.cpp +++ b/dbms/src/Databases/DatabaseCloud.cpp @@ -96,14 +96,14 @@ DatabaseCloud::DatabaseCloud( void loadTables(Context & context, ThreadPool * thread_pool, bool has_force_restore_data_flag) { - /// Ничего не делаем - все таблицы загружаются лениво. + /// Do nothing - all tables are loaded lazily. } Hash DatabaseCloud::getTableHash(const String & table_name) const { SipHash hash; - hash.update(name.data(), name.size() + 1); /// Хэшируем также нулевой байт в качестве разделителя. + hash.update(name.data(), name.size() + 1); /// Hashing also a zero byte as a separator. hash.update(table_name.data(), table_name.size()); Hash res; @@ -143,16 +143,16 @@ String DatabaseCloud::getTableDefinitionFromHash(Hash hash) const } -/** Описание одной таблицы в списке таблиц в ZooKeeper. - * Без имени таблицы (правая часть отображения). +/** Description of one table in the list of tables in ZooKeeper. + * No table name (right side of display). */ struct TableDescription { - /// Хэш от структуры таблицы. Сама структура хранится отдельно. + /// Hash of the table structure. The structure itself is stored separately. Hash definition_hash; - /// Имя локальной таблицы для хранения данных. Может быть пустым, если в таблицу ещё ничего не записывали. + /// The name of the local table to store data. It can be empty if nothing else has been written to the table. String local_table_name; - /// Список хостов, на которых расположены данные таблицы. Может быть пустым, если в таблицу ещё ничего не записывали. + /// The list of hosts on which the table data is located. It can be empty if nothing else has been written to the table. std::vector hosts; void write(WriteBuffer & buf) const @@ -169,13 +169,13 @@ struct TableDescription }; -/** Множество таблиц в ZooKeeper. - * Точнее, его кусок, относящийся к одной ноде. - * (Всё множество разбито по TABLE_TO_NODE_DIVISOR нод.) +/** Set of tables in ZooKeeper. + * More precisely, its part, referring to one node. + * (The whole set is broken into `TABLE_TO_NODE_DIVISOR` nodes.) */ struct TableSet { - /// Имя -> описание. В упорядоченном виде, данные будут лучше сжиматься. + /// Name -> description. In an ordered form, the data will be better compressed. using Container = std::map; Container map; @@ -199,7 +199,7 @@ struct TableSet { writeCString("Version 1\n", buf); - CompressedWriteBuffer out(buf); /// NOTE Можно уменьшить размер выделяемого буфера. + CompressedWriteBuffer out(buf); /// NOTE You can reduce size of allocated buffer. for (const auto & kv : map) { writeBinary(kv.first, out); @@ -223,13 +223,13 @@ struct TableSet }; -/** Множество локальных таблиц в ZooKeeper. - * Точнее, его кусок, относящийся к одной ноде. - * (Всё множество разбито по TABLE_TO_NODE_DIVISOR нод.) +/** Set of local tables in ZooKeeper. + * More precisely, its part, referring to one node. + * (The whole set is broken into `TABLE_TO_NODE_DIVISOR` nodes.) */ struct LocalTableSet { - /// Хэш от имени -> хэш от структуры. + /// Hash of name -> hash of structure. using Container = std::map; Container map; @@ -253,7 +253,7 @@ struct LocalTableSet { writeCString("Version 1\n", buf); - CompressedWriteBuffer out(buf); /// NOTE Можно уменьшить размер выделяемого буфера. + CompressedWriteBuffer out(buf); /// NOTE You can reduce size of allocated buffer. for (const auto & kv : map) { writePODBinary(kv.first, out); @@ -277,9 +277,9 @@ struct LocalTableSet }; -/** Модифицировать TableSet или LocalTableSet, сериализованный в ZooKeeper, как единое целое. - * Делается compare-and-swap. Функция transform может вызываться много раз. - * Если transform возвращает false, то считается, что модифицировать нечего и результат не сохраняется в ZK. +/** Modify TableSet or LocalTableSet, serialized in ZooKeeper, as a single unit. + * The compare-and-swap is done. `transform` function can be called many times. + * If `transform` returns false, it is considered that there is nothing to modify and the result is not saved in ZK. */ template static void modifyTableSet(zkutil::ZooKeeperPtr & zookeeper, const String & path, F && transform) @@ -300,7 +300,7 @@ static void modifyTableSet(zkutil::ZooKeeperPtr & zookeeper, const String & path if (code == ZOK) break; else if (code == ZBADVERSION) - continue; /// Узел успели поменять - попробуем ещё раз. + continue; /// Node was changed meanwhile - we'll try again. else throw zkutil::KeeperException(code, path); } @@ -343,7 +343,7 @@ static void modifyTwoTableSets(zkutil::ZooKeeperPtr & zookeeper, const String & if (code == ZOK) break; else if (code == ZBADVERSION) - continue; /// Узел успели поменять - попробуем ещё раз. + continue; /// Node was changed meanwhile - we'll try again. else throw zkutil::KeeperException(code, path1 + ", " + path2); } @@ -352,8 +352,8 @@ static void modifyTwoTableSets(zkutil::ZooKeeperPtr & zookeeper, const String & bool DatabaseCloud::isTableExist(const String & table_name) const { - /// Ищем локальную таблицу в кэше локальных таблиц или в файловой системе в path. - /// Если не нашли - ищем облачную таблицу в ZooKeeper. + /// We are looking for a local table in the local table cache or in the file system in `path`. + /// If you do not find it, look for the cloud table in ZooKeeper. { std::lock_guard lock(local_tables_mutex); @@ -378,8 +378,8 @@ bool DatabaseCloud::isTableExist(const String & table_name) const StoragePtr DatabaseCloud::tryGetTable(const String & table_name) { - /// Ищем локальную таблицу. - /// Если не нашли - ищем облачную таблицу в ZooKeeper. + /// We are looking for a local table. + /// If you do not find it, look for the cloud table in ZooKeeper. { std::lock_guard lock(local_tables_mutex); @@ -399,11 +399,11 @@ StoragePtr DatabaseCloud::tryGetTable(const String & table_name) Hash table_hash = getTableHash(table_name); String definition = getTableDefinitionFromHash(local_tables_info.map.at(table_hash)); - /// Инициализируем локальную таблицу. + /// Initialize local table. { std::lock_guard lock(local_tables_mutex); - /// А если таблицу только что создали? + /// And if the table has just been created? auto it = local_tables_cache.find(table_name); if (it != local_tables_cache.end()) return it->second; @@ -426,13 +426,13 @@ StoragePtr DatabaseCloud::tryGetTable(const String & table_name) const TableDescription & description = tables_info.at(table_name); String definition = getTableDefinitionFromHash(description.definition_hash); - /// TODO Инициализация объекта StorageCloud + /// TODO Initialization of `StorageCloud` object return {}; } } -/// Список таблиц может быть неконсистентным, так как он получается неатомарно, а по кускам, по мере итерации. +/// The list of tables can be inconsistent, as it is obtained not atomically, but in pieces, while iterating. class DatabaseCloudIterator : public IDatabaseIterator { private: @@ -467,7 +467,7 @@ private: table_set = TableSet(zookeeper->get(zookeeper_path + "/" + *nodes_iterator)); table_set_iterator = table_set.map.begin(); } - while (!table_set.map.empty()); /// Пропускаем пустые table set-ы. + while (!table_set.map.empty()); /// Skip empty table sets. return true; } @@ -504,7 +504,7 @@ public: { String definition = parent().getTableDefinitionFromHash(table_set_iterator->second.definition_hash); - /// TODO Инициализация объекта StorageCloud + /// TODO Initialization of `StorageCloud` object return {}; } }; @@ -518,7 +518,7 @@ DatabaseIteratorPtr DatabaseCloud::getIterator() bool DatabaseCloud::empty() const { - /// Есть хотя бы один непустой узел среди списков таблиц. + /// There is at least one non-empty node among the list of tables. zkutil::ZooKeeperPtr zookeeper = context.getZooKeeper(); Strings nodes = zookeeper->getChildren(zookeeper_path + "/tables/" + name); @@ -597,7 +597,7 @@ void DatabaseCloud::createTable( { zkutil::ZooKeeperPtr zookeeper = context.getZooKeeper(); - /// Добавляем в ZK информацию о структуре таблицы. + /// Add information about the table structure to ZK. String definition = getTableDefinitionFromCreateQuery(query); Hash definition_hash = getHashForTableDefinition(definition); String zookeeper_definition_path = zookeeper_path + "/table_definitions/" + hashToHex(definition_hash); @@ -610,21 +610,21 @@ void DatabaseCloud::createTable( } else { - /// Более редкая ветка, так как уникальных определений таблиц немного. - /// Есть race condition, при котором узел уже существует, но проверка на логическую ошибку (см. выше) не будет осуществлена. - /// Это не имеет значения. - /// Кстати, узлы в table_definitions никогда не удаляются. + /// A rarer branch, since there are few unique table definitions. + /// There is a race condition in which the node already exists, but a check for a logical error (see above) will not be performed. + /// It does not matter. + /// By the way, nodes in `table_definitions` are never deleted. zookeeper->tryCreate(zookeeper_definition_path, definition, zkutil::CreateMode::Persistent); } if (engine != "Cloud") { - /// Если локальная таблица. + /// If the local table. String table_name_escaped = escapeForFileName(table_name); Poco::File(data_path + table_name_escaped).createDirectory(); Hash table_hash = getTableHash(table_name); - /// Добавляем информация о локальной таблице в ZK. + /// Add information about the local table to ZK. modifyTableSet( zookeeper, zookeeper_path + "/local_tables/" + name + "/" + getNameOfNodeWithTables(table_name), @@ -635,7 +635,7 @@ void DatabaseCloud::createTable( return true; }); - /// Добавляем локальную таблицу в кэш. + /// Add the local table to the cache. { std::lock_guard lock(local_tables_mutex); if (!local_tables_cache.emplace(table_name, table).second) @@ -644,8 +644,8 @@ void DatabaseCloud::createTable( } else { - /// При создании пустой облачной таблицы, локальные таблицы не создаются и серверы для них не определяются. - /// Всё делается при первой записи в таблицу. + /// When creating an empty cloud table, no local tables are created and no servers are defined for them. + /// Everything is done when you first write to the table. TableDescription description; description.definition_hash = definition_hash; @@ -667,15 +667,15 @@ void DatabaseCloud::removeTable(const String & table_name) { zkutil::ZooKeeperPtr zookeeper = context.getZooKeeper(); - /// Ищем локальную таблицу. - /// Если не нашли - ищем облачную таблицу в ZooKeeper. + /// Looking for a local table. + /// If you do not find it, look for the cloud table in ZooKeeper. String table_name_escaped = escapeForFileName(table_name); if (Poco::File(data_path + table_name_escaped).exists()) { Hash table_hash = getTableHash(table_name); - /// Удаляем информация о локальной таблице из ZK. + /// Delete information about the local table from ZK. modifyTableSet( zookeeper, zookeeper_path + "/local_tables/" + name + "/" + getNameOfNodeWithTables(table_name), @@ -683,13 +683,13 @@ void DatabaseCloud::removeTable(const String & table_name) { auto it = set.map.find(table_hash); if (it == set.map.end()) - return false; /// Таблицу уже удалили. + return false; /// The table has already been deleted. set.map.erase(it); return true; }); - /// Удаляем локальную таблицу из кэша. + /// Delete the local table from the cache. { std::lock_guard lock(local_tables_mutex); local_tables_cache.erase(table_name); @@ -697,7 +697,7 @@ void DatabaseCloud::removeTable(const String & table_name) } else { - /// Удаляем таблицу из ZK, а также запоминаем список серверов, на которых расположены локальные таблицы. + /// Delete the table from ZK, and also remember the list of servers on which local tables are located. TableDescription description; modifyTableSet( @@ -707,7 +707,7 @@ void DatabaseCloud::removeTable(const String & table_name) { auto it = set.map.find(table_name); if (it == set.map.end()) - return false; /// Таблицу уже удалили. + return false; /// The table has already been deleted. description = it->second; set.map.erase(it); @@ -716,7 +716,7 @@ void DatabaseCloud::removeTable(const String & table_name) if (!description.local_table_name.empty() && !description.hosts.empty()) { - /// Удаление локальных таблиц. TODO То ли сразу здесь, то ли в отдельном фоновом потоке. + /// Deleting local tables. TODO Whether at once here, or in a separate background thread. } } } @@ -725,8 +725,8 @@ void DatabaseCloud::removeTable(const String & table_name) void DatabaseCloud::renameTable( const Context & context, const String & table_name, IDatabase & to_database, const String & to_table_name, const Settings & settings) { - /// Переименовывать можно только облачные таблицы. - /// Перенос между БД не поддерживается. + /// Only cloud tables can be renamed. + /// The transfer between databases is not supported. if (&to_database != this) throw Exception("Moving of tables in Cloud database between databases is not supported", ErrorCodes::NOT_IMPLEMENTED); @@ -765,8 +765,8 @@ time_t DatabaseCloud::getTableMetaModTime(const String & table_name) void DatabaseCloud::shutdown() { - /// Нельзя удерживать блокировку во время shutdown. - /// Потому что таблицы могут внутри функции shutdown работать с БД, а mutex не рекурсивный. + /// You can not hold a lock during shutdown. + /// Because inside `shutdown` function the tables can work with database, and mutex is not recursive. Tables local_tables_snapshot; { std::lock_guard lock(local_tables_mutex); diff --git a/dbms/src/Databases/DatabaseMemory.cpp b/dbms/src/Databases/DatabaseMemory.cpp index f73ecfb3a2a..e7a584daac9 100644 --- a/dbms/src/Databases/DatabaseMemory.cpp +++ b/dbms/src/Databases/DatabaseMemory.cpp @@ -99,8 +99,8 @@ ASTPtr DatabaseMemory::getCreateQuery(const String & table_name) const void DatabaseMemory::shutdown() { - /// Нельзя удерживать блокировку во время shutdown. - /// Потому что таблицы могут внутри функции shutdown работать с БД, а mutex не рекурсивный. + /// You can not hold a lock during shutdown. + /// Because inside `shutdown` function tables can work with database, and mutex is not recursive. for (auto iterator = getIterator(); iterator->isValid(); iterator->next()) iterator->table()->shutdown(); diff --git a/dbms/src/Databases/DatabaseOrdinary.cpp b/dbms/src/Databases/DatabaseOrdinary.cpp index 77ea9fb791e..e7edbe9d9d3 100644 --- a/dbms/src/Databases/DatabaseOrdinary.cpp +++ b/dbms/src/Databases/DatabaseOrdinary.cpp @@ -62,8 +62,8 @@ static void loadTable( readStringUntilEOF(s, in); } - /** Пустые файлы с метаданными образуются после грубого перезапуска сервера. - * Удаляем эти файлы, чтобы чуть-чуть уменьшить работу админов по запуску. + /** Empty files with metadata are generated after a rough restart of the server. + * Remove these files to slightly reduce the work of the admins on startup. */ if (s.empty()) { @@ -110,11 +110,11 @@ void DatabaseOrdinary::loadTables(Context & context, ThreadPool * thread_pool, b if (dir_it.name().at(0) == '.') continue; - /// Есть файлы .sql.bak - пропускаем. + /// There are .sql.bak files - skip them. if (endsWith(dir_it.name(), ".sql.bak")) continue; - /// Есть файлы .sql.tmp - удаляем. + /// There are files .sql.tmp - delete. if (endsWith(dir_it.name(), ".sql.tmp")) { LOG_INFO(log, "Removing file " << dir_it->path()); @@ -122,7 +122,7 @@ void DatabaseOrdinary::loadTables(Context & context, ThreadPool * thread_pool, b continue; } - /// Нужные файлы имеют имена вида table_name.sql + /// The required files have names like `table_name.sql` if (endsWith(dir_it.name(), ".sql")) file_names.push_back(dir_it.name()); else @@ -130,9 +130,9 @@ void DatabaseOrdinary::loadTables(Context & context, ThreadPool * thread_pool, b ErrorCodes::INCORRECT_FILE_NAME); } - /** Таблицы быстрее грузятся, если их грузить в сортированном (по именам) порядке. - * Иначе (для файловой системы ext4) DirectoryIterator перебирает их в некотором порядке, - * который не соответствует порядку создания таблиц и не соответствует порядку их расположения на диске. + /** Tables load faster if they are loaded in sorted (by name) order. + * Otherwise (for the ext4 file system), `DirectoryIterator` iterates through them in some order, + * which does not correspond to order tables creation and does not correspond to order of their location on disk. */ std::sort(file_names.begin(), file_names.end()); @@ -150,7 +150,7 @@ void DatabaseOrdinary::loadTables(Context & context, ThreadPool * thread_pool, b { const String & table = *it; - /// Сообщения, чтобы было не скучно ждать, когда сервер долго загружается. + /// Messages, so that it's not boring to wait for the server to load for a long time. if ((++tables_processed) % PRINT_MESSAGE_EACH_N_TABLES == 0 || watch.lockTestAndRestart(PRINT_MESSAGE_EACH_N_SECONDS)) { @@ -162,8 +162,8 @@ void DatabaseOrdinary::loadTables(Context & context, ThreadPool * thread_pool, b } }; - /** packaged_task используются, чтобы исключения автоматически прокидывались в основной поток. - * Недостаток - исключения попадают в основной поток только после окончания работы всех task-ов. + /** `packaged_task` is used so that exceptions are automatically passed to the main thread. + * Disadvantage - exceptions fall into the main thread only after the end of all tasks. */ const size_t bunch_size = TABLES_PARALLEL_LOAD_BUNCH_SIZE; @@ -192,17 +192,17 @@ void DatabaseOrdinary::loadTables(Context & context, ThreadPool * thread_pool, b void DatabaseOrdinary::createTable( const String & table_name, const StoragePtr & table, const ASTPtr & query, const String & engine, const Settings & settings) { - /// Создаём файл с метаданными, если нужно - если запрос не ATTACH. - /// В него записывается запрос на ATTACH таблицы. + /// Create a file with metadata if necessary - if the query is not ATTACH. + /// Write the query of `ATTACH table` to it. - /** Код исходит из допущения, что во всех потоках виден один и тот же порядок действий: - * - создание файла .sql.tmp; - * - добавление таблицы в tables; - * - переименование .sql.tmp в .sql. + /** The code is based on the assumption that all threads share the same order of operations + * - creating the .sql.tmp file; + * - adding a table to `tables`; + * - rename .sql.tmp to .sql. */ - /// Был бы возможен race condition, если таблицу с одним именем одновременно создают с помощью CREATE и с помощью ATTACH. - /// Но от него есть защита - см. использование DDLGuard в InterpreterCreateQuery. + /// A race condition would be possible if a table with the same name is simultaneously created using CREATE and using ATTACH. + /// But there is protection from it - see using DDLGuard in InterpreterCreateQuery. { std::lock_guard lock(mutex); @@ -293,7 +293,7 @@ void DatabaseOrdinary::renameTable( if (!table) throw Exception("Table " + name + "." + table_name + " doesn't exist.", ErrorCodes::TABLE_ALREADY_EXISTS); - /// Уведомляем таблицу о том, что она переименовывается. Если таблица не поддерживает переименование - кинется исключение. + /// Notify the table that it is renamed. If the table does not support renaming, exception is thrown. try { table->rename(context.getPath() + "/data/" + escapeForFileName(to_database_concrete->name) + "/", @@ -302,7 +302,7 @@ void DatabaseOrdinary::renameTable( } catch (const Poco::Exception & e) { - /// Более хорошая диагностика. + /// More good diagnostics. throw Exception{e}; } @@ -310,7 +310,7 @@ void DatabaseOrdinary::renameTable( ASTCreateQuery & ast_create_query = typeid_cast(*ast); ast_create_query.table = to_table_name; - /// NOTE Неатомарно. + /// NOTE Non-atomic. to_database_concrete->createTable(to_table_name, table, ast, table->getName(), settings); removeTable(table_name); } @@ -346,8 +346,8 @@ ASTPtr DatabaseOrdinary::getCreateQuery(const String & table_name) const void DatabaseOrdinary::shutdown() { - /// Нельзя удерживать блокировку во время shutdown. - /// Потому что таблицы могут внутри функции shutdown работать с БД, а mutex не рекурсивный. + /// You can not hold a lock during shutdown. + /// Because inside `shutdown` function the tables can work with database, and mutex is not recursive. for (auto iterator = getIterator(); iterator->isValid(); iterator->next()) iterator->table()->shutdown(); @@ -359,7 +359,7 @@ void DatabaseOrdinary::shutdown() void DatabaseOrdinary::drop() { - /// Дополнительных действий по удалению не требуется. + /// No additional removal actions are required. } @@ -372,7 +372,7 @@ void DatabaseOrdinary::alterTable( const ColumnDefaults & column_defaults, const ASTModifier & engine_modifier) { - /// Считываем определение таблицы и заменяем в нём нужные части на новые. + /// Read the definition of the table and replace the necessary parts with new ones. String table_name_escaped = escapeForFileName(name); String table_metadata_tmp_path = path + "/" + table_name_escaped + ".sql.tmp"; @@ -413,7 +413,7 @@ void DatabaseOrdinary::alterTable( try { - /// rename атомарно заменяет старый файл новым. + /// rename atomically replaces the old file with the new one. Poco::File(table_metadata_tmp_path).renameTo(table_metadata_path); } catch (...) diff --git a/dbms/src/Databases/DatabasesCommon.cpp b/dbms/src/Databases/DatabasesCommon.cpp index 03a0cb0d006..2a271323e6e 100644 --- a/dbms/src/Databases/DatabasesCommon.cpp +++ b/dbms/src/Databases/DatabasesCommon.cpp @@ -16,7 +16,7 @@ String getTableDefinitionFromCreateQuery(const ASTPtr & query) ASTPtr query_clone = query->clone(); ASTCreateQuery & create = typeid_cast(*query_clone.get()); - /// Удаляем из запроса всё, что не нужно для ATTACH. + /// We remove everything that is not needed for ATTACH from the query. create.attach = true; create.database.clear(); create.as_database.clear(); @@ -26,7 +26,7 @@ String getTableDefinitionFromCreateQuery(const ASTPtr & query) String engine = typeid_cast(*create.storage).name; - /// Для engine VIEW необходимо сохранить сам селект запрос, для остальных - наоборот + /// For engine VIEW it is necessary to save the SELECT query itself, for the rest - on the contrary if (engine != "View" && engine != "MaterializedView") create.select = nullptr; @@ -52,9 +52,9 @@ std::pair createTableFromDefinition( ast_create_query.attach = true; ast_create_query.database = database_name; - /// Не используем напрямую InterpreterCreateQuery::execute, так как: - /// - база данных ещё не создана; - /// - код проще, так как запрос уже приведён к подходящему виду. + /// We do not directly use `InterpreterCreateQuery::execute`, because + /// - the database has not been created yet; + /// - the code is simpler, since the query is already brought to a suitable form. InterpreterCreateQuery::ColumnsInfo columns_info = InterpreterCreateQuery::getColumnsInfo(ast_create_query.columns, context); diff --git a/dbms/src/Dictionaries/DictionaryStructure.cpp b/dbms/src/Dictionaries/DictionaryStructure.cpp index 65d2fb6c9d7..94dd9c90c32 100644 --- a/dbms/src/Dictionaries/DictionaryStructure.cpp +++ b/dbms/src/Dictionaries/DictionaryStructure.cpp @@ -19,9 +19,9 @@ bool isAttributeTypeConvertibleTo(AttributeUnderlyingType from, AttributeUnderly if (from == to) return true; - /** Это перечисление может быть несколько неполным и смысл может не совпадать с NumberTraits.h. - * (например тем, что целые числа нельзя преобразовать во float-ы) - * Это нормально для ограниченной области применения. + /** This enum can be somewhat incomplete and the meaning may not coincide with NumberTraits.h. + * (for example, because integers can not be converted to floats) + * This is normal for a limited usage scope. */ if ( (from == AttributeUnderlyingType::UInt8 && to == AttributeUnderlyingType::UInt16) || (from == AttributeUnderlyingType::UInt8 && to == AttributeUnderlyingType::UInt32) diff --git a/dbms/src/Dictionaries/Embedded/RegionsHierarchy.cpp b/dbms/src/Dictionaries/Embedded/RegionsHierarchy.cpp index 06fac4facda..ce22a081d86 100644 --- a/dbms/src/Dictionaries/Embedded/RegionsHierarchy.cpp +++ b/dbms/src/Dictionaries/Embedded/RegionsHierarchy.cpp @@ -69,8 +69,8 @@ void RegionsHierarchy::reload() DB::assertChar('\t', in); DB::readIntText(read_type, in); - /** Далее может быть перевод строки (старый вариант) - * или таб, население региона, перевод строки (новый вариант). + /** Then there can be a newline (old version) + * or tab, the region's population, line feed (new version). */ RegionPopulation population = 0; if (!in.eof() && *in.position() == '\t') @@ -126,7 +126,7 @@ void RegionsHierarchy::reload() new_depths .resize(max_region_id + 1); types .resize(max_region_id + 1); - /// пропишем города и страны для регионов + /// prescribe the cities and countries for the regions for (RegionID i = 0; i <= max_region_id; ++i) { if (types[i] == REGION_TYPE_CITY) diff --git a/dbms/src/Dictionaries/Embedded/RegionsNames.cpp b/dbms/src/Dictionaries/Embedded/RegionsNames.cpp index 6111253a10c..fd9c34d7e39 100644 --- a/dbms/src/Dictionaries/Embedded/RegionsNames.cpp +++ b/dbms/src/Dictionaries/Embedded/RegionsNames.cpp @@ -61,7 +61,7 @@ void RegionsNames::reload(const std::string & directory) Chars new_chars; StringRefs new_names_refs(initial_size, StringRef("", 0)); - /// Выделим непрерывный кусок памяти, которого хватит для хранения всех имён. + /// Allocate a continuous slice of memory, which is enough to store all names. new_chars.reserve(Poco::File(path).getSize()); while (!in.eof()) diff --git a/dbms/src/Dictionaries/MySQLDictionarySource.cpp b/dbms/src/Dictionaries/MySQLDictionarySource.cpp index 3b914571a99..a642b19fa88 100644 --- a/dbms/src/Dictionaries/MySQLDictionarySource.cpp +++ b/dbms/src/Dictionaries/MySQLDictionarySource.cpp @@ -52,7 +52,7 @@ BlockInputStreamPtr MySQLDictionarySource::loadAll() BlockInputStreamPtr MySQLDictionarySource::loadIds(const std::vector & ids) { - /// Здесь не логгируем и не обновляем время модификации, так как запрос может быть большим, и часто задаваться. + /// We do not log in here and do not update the modification time, as the request can be large, and often called. const auto query = query_builder.composeLoadIdsQuery(ids); return std::make_shared(pool.Get(), query, sample_block, max_block_size); @@ -61,7 +61,7 @@ BlockInputStreamPtr MySQLDictionarySource::loadIds(const std::vector & i BlockInputStreamPtr MySQLDictionarySource::loadKeys( const ConstColumnPlainPtrs & key_columns, const std::vector & requested_rows) { - /// Здесь не логгируем и не обновляем время модификации, так как запрос может быть большим, и часто задаваться. + /// We do not log in here and do not update the modification time, as the request can be large, and often called. const auto query = query_builder.composeLoadKeysQuery(key_columns, requested_rows, ExternalQueryBuilder::AND_OR_CHAIN); return std::make_shared(pool.Get(), query, sample_block, max_block_size); diff --git a/dbms/src/Functions/FunctionFactory.cpp b/dbms/src/Functions/FunctionFactory.cpp index aac5142cc77..ba89cb51a7a 100644 --- a/dbms/src/Functions/FunctionFactory.cpp +++ b/dbms/src/Functions/FunctionFactory.cpp @@ -11,8 +11,8 @@ namespace ErrorCodes } -/** Эти функции определены в отдельных translation unit-ах. - * Это сделано для того, чтобы уменьшить потребление оперативки при сборке, и ускорить параллельную сборку. +/** These functions are defined in a separate translation units. + * This is done in order to reduce the consumption of RAM during build, and to speed up the parallel build. */ void registerFunctionsArithmetic(FunctionFactory &); void registerFunctionsArray(FunctionFactory &); diff --git a/dbms/src/Functions/FunctionsArray.cpp b/dbms/src/Functions/FunctionsArray.cpp index 73d262b4fba..60a61797997 100644 --- a/dbms/src/Functions/FunctionsArray.cpp +++ b/dbms/src/Functions/FunctionsArray.cpp @@ -144,7 +144,7 @@ bool tryAddField(DataTypePtr type_res, const Field & f, Array & arr) bool FunctionArray::addField(DataTypePtr type_res, const Field & f, Array & arr) const { - /// Иначе необходимо + /// Otherwise, it is necessary if ( tryAddField(type_res, f, arr) || tryAddField(type_res, f, arr) || tryAddField(type_res, f, arr) @@ -251,14 +251,14 @@ void FunctionArray::executeImpl(Block & block, const ColumnNumbers & arguments, if (DataTypeTraits::removeNullable(elem.type)->getName() == observed_type->getName()) { - /// Если элемент такого же типа как результат, просто добавляем его в ответ + /// If an element of the same type as the result, just add it in response arr.push_back((*elem.column)[0]); } else if (elem.type->isNull()) arr.emplace_back(); else { - /// Иначе необходимо привести его к типу результата + /// Otherwise, you need to cast it to the result type addField(observed_type, (*elem.column)[0], arr); } } @@ -553,7 +553,7 @@ struct ArrayElementStringImpl } else { - /// Вставим пустую строку. + /// Insert an empty row. result_data.resize(current_result_offset + 1); result_data[current_result_offset] = 0; current_result_offset += 1; @@ -1007,20 +1007,20 @@ bool FunctionArrayElement::executeTuple(Block & block, const ColumnNumbers & arg Block & tuple_block = col_nested->getData(); size_t tuple_size = tuple_block.columns(); - /** Будем вычислять функцию для кортежа внутренностей массива. - * Для этого создадим временный блок. - * Он будет состоять из следующих столбцов: - * - индекс массива, который нужно взять; - * - массив из первых элементов кортежей; - * - результат взятия элементов по индексу для массива из первых элементов кортежей; - * - массив из вторых элементов кортежей; - * - результат взятия элементов по индексу для массива из вторых элементов кортежей; + /** We will calculate the function for the tuple of the internals of the array. + * To do this, create a temporary block. + * It will consist of the following columns + * - the index of the array to be taken; + * - an array of the first elements of the tuples; + * - the result of taking the elements by the index for an array of the first elements of the tuples; + * - array of the second elements of the tuples; + * - result of taking elements by index for an array of second elements of tuples; * ... */ Block block_of_temporary_results; block_of_temporary_results.insert(block.safeGetByPosition(arguments[1])); - /// результаты взятия элементов по индексу для массивов из каждых элементов кортежей; + /// results of taking elements by index for arrays from each element of the tuples; Block result_tuple_block; for (size_t i = 0; i < tuple_size; ++i) @@ -2168,7 +2168,7 @@ bool FunctionEmptyArrayToSingle::executeString( } else { - res_data.push_back(0); /// Пустая строка, включая ноль на конце. + res_data.push_back(0); /// An empty string, including zero at the end. ++res_string_prev_offset; res_string_offsets.push_back(res_string_prev_offset); @@ -2641,7 +2641,7 @@ void FunctionArrayReduce::getReturnTypeAndPrerequisitesImpl( DataTypePtr & out_return_type, std::vector & out_prerequisites) { - /// Первый аргумент - константная строка с именем агрегатной функции (возможно, с параметрами в скобках, например: "quantile(0.99)"). + /// The first argument is a constant string with the name of the aggregate function (possibly with parameters in parentheses, for example: "quantile(0.99)"). if (arguments.size() < 2) throw Exception("Number of arguments for function " + getName() + " doesn't match: passed " @@ -2737,7 +2737,7 @@ void FunctionArrayReduce::executeImpl(Block & block, const ColumnNumbers & argum size_t rows = block.rows(); - /// Агрегатные функции не поддерживают константные столбцы. Поэтому, материализуем их. + /// Aggregate functions do not support constant columns. Therefore, we materialize them. std::vector materialized_columns; std::vector aggregate_arguments_vec(arguments.size() - 1); diff --git a/dbms/src/Functions/FunctionsConditional.cpp b/dbms/src/Functions/FunctionsConditional.cpp index e3a2003519f..ef1db6f31cd 100644 --- a/dbms/src/Functions/FunctionsConditional.cpp +++ b/dbms/src/Functions/FunctionsConditional.cpp @@ -183,7 +183,7 @@ DataTypePtr FunctionMultiIf::getReturnTypeInternal(const DataTypes & args) const return Conditional::getReturnTypeForArithmeticArgs(args); else if (Conditional::hasArrayBranches(args)) { - /// NOTE Сообщения об ошибках будут относится к типам элементов массивов, что немного некорректно. + /// NOTE Error messages will refer to the types of array elements, which is slightly incorrect. DataTypes new_args; new_args.reserve(args.size()); diff --git a/dbms/src/Functions/FunctionsMiscellaneous.cpp b/dbms/src/Functions/FunctionsMiscellaneous.cpp index c313dede2a5..ca514a3497a 100644 --- a/dbms/src/Functions/FunctionsMiscellaneous.cpp +++ b/dbms/src/Functions/FunctionsMiscellaneous.cpp @@ -29,38 +29,38 @@ namespace ErrorCodes extern const int FUNCTION_IS_SPECIAL; } -/** Вспомогательные функции: +/** Helper functions * - * visibleWidth(x) - вычисляет приблизительную ширину при выводе значения в текстовом (tab-separated) виде на консоль. + * visibleWidth(x) - calculates the approximate width when outputting the value in a text (tab-separated) form to the console. * - * toTypeName(x) - получить имя типа - * blockSize() - получить размер блока - * materialize(x) - материализовать константу - * ignore(...) - функция, принимающая любые аргументы, и всегда возвращающая 0. - * sleep(seconds) - спит указанное количество секунд каждый блок. + * toTypeName(x) - get the type name + * blockSize() - get the block size + * materialize(x) - materialize the constant + * ignore(...) is a function that takes any arguments, and always returns 0. + * sleep(seconds) - the specified number of seconds sleeps each block. * - * in(x, set) - функция для вычисления оператора IN - * notIn(x, set) - и NOT IN. + * in(x, set) - function for evaluating the IN + * notIn(x, set) - and NOT IN. * - * tuple(x, y, ...) - функция, позволяющая сгруппировать несколько столбцов - * tupleElement(tuple, n) - функция, позволяющая достать столбец из tuple. + * tuple(x, y, ...) is a function that allows you to group several columns + * tupleElement(tuple, n) is a function that allows you to retrieve a column from tuple. * - * arrayJoin(arr) - особая функция - выполнить её напрямую нельзя; - * используется только чтобы получить тип результата соответствующего выражения. + * arrayJoin(arr) - a special function - it can not be executed directly; + * is used only to get the result type of the corresponding expression. * - * replicate(x, arr) - создаёт массив такого же размера как arr, все элементы которого равны x; - * например: replicate(1, ['a', 'b', 'c']) = [1, 1, 1]. + * replicate(x, arr) - creates an array of the same size as arr, all elements of which are equal to x; + * for example: replicate(1, ['a', 'b', 'c']) = [1, 1, 1]. * - * sleep(n) - спит n секунд каждый блок. + * sleep(n) - sleeps n seconds for each block. * - * bar(x, min, max, width) - рисует полосу из количества символов, пропорционального (x - min) и равного width при x == max. + * bar(x, min, max, width) - draws a strip from the number of characters proportional to (x - min) and equal to width for x == max. * - * version() - возвращает текущую версию сервера в строке. + * version() - returns the current version of the server on the line. * - * finalizeAggregation(agg_state) - по состоянию агрегации получить результат. + * finalizeAggregation(agg_state) - get the result from the aggregation state. * - * runningAccumulate(agg_state) - принимает состояния агрегатной функции и возвращает столбец со значениями, - * являющимися результатом накопления этих состояний для множества строк блока, от первой до текущей строки. + * runningAccumulate(agg_state) - takes the states of the aggregate function and returns a column with values, + * are the result of the accumulation of these states for a set of block lines, from the first to the current line. */ @@ -125,7 +125,7 @@ public: return 0; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument types. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { return std::make_shared(); @@ -155,7 +155,7 @@ public: return true; } - /// Получить имя функции. + /// Get the name of the function. String getName() const override { return name; @@ -166,13 +166,13 @@ public: return 1; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { return std::make_shared(); } - /// Выполнить функцию над блоком. + /// Execute the function on the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override; }; @@ -202,13 +202,13 @@ public: return 1; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { return std::make_shared(); } - /// Выполнить функцию над блоком. + /// Execute the function on the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { block.safeGetByPosition(result).column @@ -264,7 +264,7 @@ public: return std::make_shared(); } - /// Получить имя функции. + /// Get the function name. String getName() const override { return name; @@ -280,13 +280,13 @@ public: return 0; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { return std::make_shared(); } - /// Выполнить функцию над блоком. + /// apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { size_t size = block.rows(); @@ -304,7 +304,7 @@ public: return std::make_shared(); } - /// Получить имя функции. + /// Get the name of the function. String getName() const override { return name; @@ -320,13 +320,13 @@ public: return false; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { return std::make_shared(); } - /// Выполнить функцию над блоком. + /// apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { size_t size = block.rows(); @@ -341,7 +341,7 @@ public: }; -/** Инкрементальный номер блока среди вызовов этой функции. */ +/** Incremental block number among calls of this function. */ class FunctionBlockNumber : public IFunction { private: @@ -354,7 +354,7 @@ public: return std::make_shared(); } - /// Получить имя функции. + /// Get the function name. String getName() const override { return name; @@ -370,13 +370,13 @@ public: return false; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { return std::make_shared(); } - /// Выполнить функцию над блоком. + /// apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { size_t current_block_number = block_number++; @@ -398,7 +398,7 @@ public: return std::make_shared(); } - /// Получить имя функции. + /// Get the name of the function. String getName() const override { return name; @@ -414,13 +414,13 @@ public: return false; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument types. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { return std::make_shared(); } - /// Выполнить функцию над блоком. + /// apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { size_t rows_in_block = block.rows(); @@ -446,7 +446,7 @@ public: return std::make_shared(); } - /// Получить имя функции. + /// Get the name of the function. String getName() const override { return name; @@ -463,7 +463,7 @@ public: return 1; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { if (!typeid_cast(&*arguments[0]) && !typeid_cast(&*arguments[0]) @@ -477,7 +477,7 @@ public: return std::make_shared(); } - /// Выполнить функцию над блоком. + /// apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { IColumn * col = block.safeGetByPosition(arguments[0]).column.get(); @@ -505,7 +505,7 @@ public: else throw Exception("The argument of function " + getName() + " must be constant.", ErrorCodes::ILLEGAL_COLUMN); - /// Не спим, если блок пустой. + /// We do not sleep if the block is empty. if (size > 0) usleep(static_cast(seconds * 1e6)); @@ -524,7 +524,7 @@ public: return std::make_shared(); } - /// Получить имя функции. + /// Get the function name. String getName() const override { return name; @@ -535,13 +535,13 @@ public: return 1; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { return arguments[0]; } - /// Выполнить функцию над блоком. + /// Apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { const auto & src = block.safeGetByPosition(arguments[0]).column; @@ -595,13 +595,13 @@ public: return 2; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { return std::make_shared(); } - /// Выполнить функцию над блоком. + /// Apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { /// Second argument must be ColumnSet. @@ -730,7 +730,7 @@ public: out_return_type = elems[index - 1]->clone(); } - /// Выполнить функцию над блоком. + /// apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { const ColumnTuple * tuple_col = typeid_cast(block.safeGetByPosition(arguments[0]).column.get()); @@ -800,7 +800,7 @@ public: return std::make_shared(); } - /// Выполнить функцию над блоком. + /// apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { block.safeGetByPosition(result).column = std::make_shared(block.rows(), 0); @@ -808,17 +808,17 @@ public: }; -/** Функция indexHint принимает любое количество любых аргументов и всегда возвращает единицу. +/** The `indexHint` function takes any number of any arguments and always returns one. * - * Эта функция имеет особый смысл (см. ExpressionAnalyzer, PKCondition): - * - расположенные внутри неё выражения не вычисляются; - * - но при анализе индекса (выбора диапазонов для чтения), эта функция воспринимается так же, - * как если бы вместо её применения было бы само выражение. + * This function has a special meaning (see ExpressionAnalyzer, PKCondition) + * - the expressions inside it are not evaluated; + * - but when analyzing the index (selecting ranges for reading), this function is treated the same way, + * as if instead of using it the expression itself would be. * - * Пример: WHERE something AND indexHint(CounterID = 34) - * - не читать и не вычислять CounterID = 34, но выбрать диапазоны, в которых выражение CounterID = 34 может быть истинным. + * Example: WHERE something AND indexHint(CounterID = 34) + * - do not read or calculate CounterID = 34, but select ranges in which the CounterID = 34 expression can be true. * - * Функция может использоваться в отладочных целях, а также для (скрытых от пользователя) преобразований запроса. + * The function can be used for debugging purposes, as well as for (hidden from the user) query conversions. */ class FunctionIndexHint : public IFunction { @@ -852,7 +852,7 @@ public: return std::make_shared(); } - /// Выполнить функцию над блоком. + /// apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { block.safeGetByPosition(result).column = std::make_shared(block.rows(), 1); @@ -869,7 +869,7 @@ public: return std::make_shared(); } - /// Получить имя функции. + /// Get the function name. String getName() const override { return name; @@ -880,13 +880,13 @@ public: return 1; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { return arguments.front()->clone(); } - /// Выполнить функцию над блоком. + /// apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { block.safeGetByPosition(result).column = block.safeGetByPosition(arguments.front()).column; @@ -904,7 +904,7 @@ public: } - /// Получить имя функции. + /// Get the function name. String getName() const override { return name; @@ -921,7 +921,7 @@ public: return false; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { const DataTypeArray * arr = typeid_cast(&*arguments[0]); @@ -931,7 +931,7 @@ public: return arr->getNestedType()->clone(); } - /// Выполнить функцию над блоком. + /// Apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { throw Exception("Function " + getName() + " must not be executed directly.", ErrorCodes::FUNCTION_IS_SPECIAL); @@ -1004,7 +1004,7 @@ public: return 0; } - /// Получить тип результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get the result type by argument type. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { if (arguments.size() != 3 && arguments.size() != 4) @@ -1021,14 +1021,13 @@ public: return std::make_shared(); } - /// Выполнить функцию над блоком. + /// apply function to the block. void executeImpl(Block & block, const ColumnNumbers & arguments, size_t result) override { - Int64 min = extractConstant(block, arguments, 1, "Second"); /// Уровень значения, при котором полоска имеет нулевую длину. - Int64 max - = extractConstant(block, arguments, 2, "Third"); /// Уровень значения, при котором полоска имеет максимальную длину. + Int64 min = extractConstant(block, arguments, 1, "Second"); /// The level at which the line has zero length. + Int64 max = extractConstant(block, arguments, 2, "Third"); /// The level at which the line has the maximum length. - /// Максимальная ширина полоски в символах, по-умолчанию. + /// The maximum width of the bar in characters, by default. Float64 max_width = arguments.size() == 4 ? extractConstant(block, arguments, 3, "Fourth") : 80; if (max_width < 1) @@ -1109,7 +1108,7 @@ private: size_t current_offset = 0; dst_offsets.resize(size); - dst_chars.reserve(size * (UnicodeBar::getWidthInBytes(max_width) + 1)); /// строки 0-terminated. + dst_chars.reserve(size * (UnicodeBar::getWidthInBytes(max_width) + 1)); /// lines 0-terminated. for (size_t i = 0; i < size; ++i) { @@ -1440,7 +1439,7 @@ public: }; std::unique_ptr place{reinterpret_cast(malloc(agg_func.sizeOfData())), deleter}; - agg_func.create(place.get()); /// Немного не exception-safe. Если здесь выкинется исключение, то зря вызовется destroy. + agg_func.create(place.get()); /// Not much exception-safe. If an exception is thrown out, destroy will be called in vain. std::unique_ptr arena = agg_func.allocatesMemoryInArena() ? std::make_unique() : nullptr; diff --git a/dbms/src/Functions/FunctionsString.cpp b/dbms/src/Functions/FunctionsString.cpp index aeaea2388fd..a5bbc9dbc7b 100644 --- a/dbms/src/Functions/FunctionsString.cpp +++ b/dbms/src/Functions/FunctionsString.cpp @@ -61,7 +61,7 @@ struct EmptyImpl }; -/** Вычисляет длину строки в байтах. +/** Calculates the length of a string in bytes. */ struct LengthImpl { @@ -100,9 +100,9 @@ struct LengthImpl }; -/** Если строка представляет собой текст в кодировке UTF-8, то возвращает длину текста в кодовых точках. - * (не в символах: длина текста "ё" может быть как 1, так и 2, в зависимости от нормализации) - * Иначе - поведение не определено. +/** If the string is UTF-8 encoded text, it returns the length of the text in code points. + * (not in characters: the length of the text "ё" can be either 1 or 2, depending on the normalization) + * Otherwise, the behavior is undefined. */ struct LengthUTF8Impl { @@ -227,7 +227,7 @@ private: } }; -/** Разворачивает строку в байтах. +/** Expands the string in bytes. */ struct ReverseImpl { @@ -269,9 +269,9 @@ struct ReverseImpl }; -/** Разворачивает последовательность кодовых точек в строке в кодировке UTF-8. - * Результат может не соответствовать ожидаемому, так как модифицирующие кодовые точки (например, диакритика) могут примениться не к тем символам. - * Если строка не в кодировке UTF-8, то поведение не определено. +/** Expands the sequence of code points in a UTF-8 encoded string. + * The result may not match the expected result, because modifying code points (for example, diacritics) may be applied to another symbols. + * If the string is not encoded in UTF-8, then the behavior is undefined. */ struct ReverseUTF8Impl { @@ -413,14 +413,14 @@ void LowerUpperUTF8Impl(&*column)) { - /// Для фиксированной строки, только функция lengthUTF8 возвращает не константу. + /// For a fixed string only `lengthUTF8` function returns not a constant. if ("lengthUTF8" != getName()) { ResultType res = 0; @@ -793,7 +793,7 @@ public: }; -/// Также работает над массивами. +/// Also works with arrays. class FunctionReverse : public IFunction { public: @@ -997,7 +997,7 @@ private: const ColumnConstString * c0_const = typeid_cast(c0); const ColumnConstString * c1_const = typeid_cast(c1); - /// Результат - const string + /// The result is const string if (c0_const && c1_const) { auto c_res = std::make_shared(c0_const->size(), ""); diff --git a/dbms/src/Functions/FunctionsStringSearch.cpp b/dbms/src/Functions/FunctionsStringSearch.cpp index 2d1051d5ee4..e4a52e41976 100644 --- a/dbms/src/Functions/FunctionsStringSearch.cpp +++ b/dbms/src/Functions/FunctionsStringSearch.cpp @@ -58,7 +58,7 @@ struct PositionCaseSensitiveASCII struct PositionCaseInsensitiveASCII { - /// Здесь не используется Volnitsky, потому что один человек померял, что так лучше. Будет хорошо, если вы подвергнете это сомнению. + /// `Volnitsky` is not used here, because one person has measured that this is better. It will be good if you question it. using SearcherInBigHaystack = ASCIICaseInsensitiveStringSearcher; using SearcherInSmallHaystack = LibCASCIICaseInsensitiveStringSearcher; @@ -115,7 +115,7 @@ struct PositionCaseSensitiveUTF8 struct PositionCaseInsensitiveUTF8 { using SearcherInBigHaystack = VolnitskyImpl; - using SearcherInSmallHaystack = UTF8CaseInsensitiveStringSearcher; /// TODO Очень неоптимально. + using SearcherInSmallHaystack = UTF8CaseInsensitiveStringSearcher; /// TODO Very suboptimal. static SearcherInBigHaystack createSearcherInBigHaystack(const char * needle_data, size_t needle_size, size_t haystack_size_hint) { @@ -147,7 +147,7 @@ struct PositionImpl { using ResultType = UInt64; - /// Поиск одной подстроки во многих строках. + /// Find one substring in many strings. static void vector_constant(const ColumnString::Chars_t & data, const ColumnString::Offsets_t & offsets, const std::string & needle, @@ -157,22 +157,22 @@ struct PositionImpl const UInt8 * pos = begin; const UInt8 * end = pos + data.size(); - /// Текущий индекс в массиве строк. + /// Current index in the array of strings. size_t i = 0; typename Impl::SearcherInBigHaystack searcher = Impl::createSearcherInBigHaystack(needle.data(), needle.size(), end - pos); - /// Искать будем следующее вхождение сразу во всех строках. + /// We will search for the next occurrence in all strings at once. while (pos < end && end != (pos = searcher.search(pos, end - pos))) { - /// Определим, к какому индексу оно относится. + /// Determine which index it refers to. while (begin + offsets[i] <= pos) { res[i] = 0; ++i; } - /// Проверяем, что вхождение не переходит через границы строк. + /// We check that the entry does not pass through the boundaries of strings. if (pos + needle.size() < begin + offsets[i]) { size_t prev_offset = i != 0 ? offsets[i - 1] : 0; @@ -188,7 +188,7 @@ struct PositionImpl memset(&res[i], 0, (res.size() - i) * sizeof(res[0])); } - /// Поиск одной подстроки в одной строке. + /// Search for substring in string. static void constant_constant(std::string data, std::string needle, UInt64 & res) { Impl::toLowerIfNeed(data); @@ -201,7 +201,7 @@ struct PositionImpl res = 1 + Impl::countChars(data.data(), data.data() + res); } - /// Поиск каждой раз разной одной подстроки в каждой раз разной строке. + /// Search each time for a different single substring inside each time different string. static void vector_vector(const ColumnString::Chars_t & haystack_data, const ColumnString::Offsets_t & haystack_offsets, const ColumnString::Chars_t & needle_data, @@ -220,17 +220,17 @@ struct PositionImpl if (0 == needle_size) { - /// Пустая строка всегда находится в самом начале haystack. + /// An empty string is always at the very beginning of `haystack`. res[i] = 1; } else { - /// Предполагается, что StringSearcher не очень сложно инициализировать. + /// It is assumed that the StringSearcher is not very difficult to initialize. typename Impl::SearcherInSmallHaystack searcher = Impl::createSearcherInSmallHaystack(reinterpret_cast(&needle_data[prev_needle_offset]), - needle_offsets[i] - prev_needle_offset - 1); /// нулевой байт на конце + needle_offsets[i] - prev_needle_offset - 1); /// zero byte at the end - /// searcher возвращает указатель на найденную подстроку или на конец haystack. + /// searcher returns a pointer to the found substring or to the end of `haystack`. size_t pos = searcher.search(&haystack_data[prev_haystack_offset], &haystack_data[haystack_offsets[i] - 1]) - &haystack_data[prev_haystack_offset]; @@ -248,13 +248,13 @@ struct PositionImpl } } - /// Поиск многих подстрок в одной строке. + /// Find many substrings in one line. static void constant_vector(const String & haystack, const ColumnString::Chars_t & needle_data, const ColumnString::Offsets_t & needle_offsets, PaddedPODArray & res) { - // NOTE Можно было бы использовать индексацию haystack. Но это - редкий случай. + // NOTE You could use haystack indexing. But this is a rare case. ColumnString::Offset_t prev_needle_offset = 0; @@ -291,7 +291,7 @@ struct PositionImpl }; -/// Сводится ли выражение LIKE к поиску подстроки в строке? +/// Is the LIKE expression reduced to finding a substring in a string? inline bool likePatternIsStrstr(const String & pattern, String & res) { res = ""; @@ -346,30 +346,30 @@ struct MatchImpl PaddedPODArray & res) { String strstr_pattern; - /// Простой случай, когда выражение LIKE сводится к поиску подстроки в строке + /// A simple case where the LIKE expression reduces to finding a substring in a string if (like && likePatternIsStrstr(pattern, strstr_pattern)) { const UInt8 * begin = &data[0]; const UInt8 * pos = begin; const UInt8 * end = pos + data.size(); - /// Текущий индекс в массиве строк. + /// The current index in the array of strings. size_t i = 0; - /// TODO Надо сделать так, чтобы searcher был общим на все вызовы функции. + /// TODO You need to make that `searcher` is common to all the calls of the function. Volnitsky searcher(strstr_pattern.data(), strstr_pattern.size(), end - pos); - /// Искать будем следующее вхождение сразу во всех строках. + /// We will search for the next occurrence in all rows at once. while (pos < end && end != (pos = searcher.search(pos, end - pos))) { - /// Определим, к какому индексу оно относится. + /// Let's determine which index it refers to. while (begin + offsets[i] <= pos) { res[i] = revert; ++i; } - /// Проверяем, что вхождение не переходит через границы строк. + /// We check that the entry does not pass through the boundaries of strings. if (pos + strstr_pattern.size() < begin + offsets[i]) res[i] = !revert; else @@ -379,7 +379,7 @@ struct MatchImpl ++i; } - /// Хвостик, в котором не может быть подстрок. + /// Tail, in which there can be no substring. memset(&res[i], revert, (res.size() - i) * sizeof(res[0])); } else @@ -390,13 +390,13 @@ struct MatchImpl std::string required_substring; bool is_trivial; - bool required_substring_is_prefix; /// для anchored выполнения регекспа. + bool required_substring_is_prefix; /// for `anchored` execution of the regexp. regexp->getAnalyzeResult(required_substring, is_trivial, required_substring_is_prefix); if (required_substring.empty()) { - if (!regexp->getRE2()) /// Пустой регексп. Всегда матчит. + if (!Regexp->getRE2()) /// An empty regexp. Always matches. { memset(&res[0], 1, size * sizeof(res[0])); } @@ -420,31 +420,31 @@ struct MatchImpl } else { - /// NOTE Это почти совпадает со случаем likePatternIsStrstr. + /// NOTE This almost matches with the case of LikePatternIsStrstr. const UInt8 * begin = &data[0]; const UInt8 * pos = begin; const UInt8 * end = pos + data.size(); - /// Текущий индекс в массиве строк. + /// The current index in the array of strings. size_t i = 0; Volnitsky searcher(required_substring.data(), required_substring.size(), end - pos); - /// Искать будем следующее вхождение сразу во всех строках. + /// We will search for the next occurrence in all rows at once. while (pos < end && end != (pos = searcher.search(pos, end - pos))) { - /// Определим, к какому индексу оно относится. + /// Determine which index it refers to. while (begin + offsets[i] <= pos) { res[i] = revert; ++i; } - /// Проверяем, что вхождение не переходит через границы строк. + /// We check that the entry does not pass through the boundaries of strings. if (pos + strstr_pattern.size() < begin + offsets[i]) { - /// И если не переходит - при необходимости, проверяем регекспом. + /// And if it does not, if necessary, we check the regexp. if (is_trivial) res[i] = !revert; @@ -453,9 +453,9 @@ struct MatchImpl const char * str_data = reinterpret_cast(&data[i != 0 ? offsets[i - 1] : 0]); size_t str_size = (i != 0 ? offsets[i] - offsets[i - 1] : offsets[0]) - 1; - /** Даже в случае required_substring_is_prefix используем UNANCHORED проверку регекспа, - * чтобы он мог сматчиться, когда required_substring встречается в строке несколько раз, - * и на первом вхождении регексп не матчит. + /** Even in the case of `required_substring_is_prefix` use UNANCHORED check for regexp, + * so that it can match when `required_substring` occurs into the line several times, + * and at the first occurrence, the regexp is not a match. */ if (required_substring_is_prefix) @@ -769,21 +769,21 @@ struct ReplaceStringImpl size_t size = offsets.size(); res_offsets.resize(size); - /// Текущий индекс в массиве строк. + /// The current index in the array of strings. size_t i = 0; Volnitsky searcher(needle.data(), needle.size(), end - pos); - /// Искать будем следующее вхождение сразу во всех строках. + /// We will search for the next occurrence in all rows at once. while (pos < end) { const UInt8 * match = searcher.search(pos, end - pos); - /// Копируем данные без изменения + /// Copy the data without changing res_data.resize(res_data.size() + (match - pos)); memcpy(&res_data[res_offset], pos, match - pos); - /// Определим, к какому индексу оно относится. + /// Determine which index it belongs to. while (i < offsets.size() && begin + offsets[i] <= match) { res_offsets[i] = res_offset + ((begin + offsets[i]) - pos); @@ -791,14 +791,14 @@ struct ReplaceStringImpl } res_offset += (match - pos); - /// Если дошли до конца, пора остановиться + /// If you have reached the end, it's time to stop if (i == offsets.size()) break; - /// Правда ли, что с этой строкой больше не надо выполнять преобразования. + /// Is it true that this line no longer needs to perform transformations. bool can_finish_current_string = false; - /// Проверяем, что вхождение не переходит через границы строк. + /// We check that the entry does not go through the boundaries of strings. if (match + needle.size() < begin + offsets[i]) { res_data.resize(res_data.size() + replacement.size()); @@ -842,21 +842,21 @@ struct ReplaceStringImpl res_data.reserve(data.size()); res_offsets.resize(size); - /// Текущий индекс в массиве строк. + /// The current index in the string array. size_t i = 0; Volnitsky searcher(needle.data(), needle.size(), end - pos); - /// Искать будем следующее вхождение сразу во всех строках. + /// We will search for the next occurrence in all rows at once. while (pos < end) { const UInt8 * match = searcher.search(pos, end - pos); - /// Копируем данные без изменения + /// Copy the data without changing res_data.resize(res_data.size() + (match - pos)); memcpy(&res_data[res_offset], pos, match - pos); - /// Определим, к какому индексу оно относится. + /// Let's determine which index it belongs to. while (i < size && begin + n * (i + 1) <= match) { res_offsets[i] = res_offset + ((begin + n * (i + 1)) - pos) + 1; @@ -864,14 +864,14 @@ struct ReplaceStringImpl } res_offset += (match - pos); - /// Если дошли до конца, пора остановиться + /// If you have reached the end, it's time to stop if (i == size) break; - /// Правда ли, что с этой строкой больше не надо выполнять преобразования. + /// Is it true that this line no longer needs to perform conversions. bool can_finish_current_string = false; - /// Проверяем, что вхождение не переходит через границы строк. + /// We check that the entry does not pass through the boundaries of strings. if (match + needle.size() - 1 < begin + n * (i + 1)) { res_data.resize(res_data.size() + replacement.size()); diff --git a/dbms/src/Functions/tests/logical_functions_performance.cpp b/dbms/src/Functions/tests/logical_functions_performance.cpp index 14fc53a71fd..3cecf79c38a 100644 --- a/dbms/src/Functions/tests/logical_functions_performance.cpp +++ b/dbms/src/Functions/tests/logical_functions_performance.cpp @@ -43,7 +43,7 @@ using UInt8ColumnPtrs = std::vector; template struct AssociativeOperationImpl { - /// Выбрасывает N последних столбцов из in (если их меньше, то все) и кладет в result их комбинацию. + /// Throws the last N columns from `in` (if there are less, then all) and puts their combination into `result`. static void execute(UInt8ColumnPtrs & in, UInt8Container & result) { if (N > in.size()) @@ -65,11 +65,11 @@ struct AssociativeOperationImpl const UInt8Container & vec; AssociativeOperationImpl continuation; - /// Запоминает последние N столбцов из in. + /// Remembers the last N columns from in. AssociativeOperationImpl(UInt8ColumnPtrs & in) : vec(in[in.size() - N]->getData()), continuation(in) {} - /// Возвращает комбинацию значений в i-й строке всех столбцов, запомненных в конструкторе. + /// Returns a combination of values ​​in the i-th row of all columns stored in the constructor. inline UInt8 apply(size_t i) const { //return vec[i] ? continuation.apply(i) : 0; @@ -194,7 +194,7 @@ public: bool isVariadic() const override { return true; } size_t getNumberOfArguments() const override { return 0; } - /// Получить типы результата по типам аргументов. Если функция неприменима для данных аргументов - кинуть исключение. + /// Get result types by argument types. If the function does not apply to these arguments, throw an exception. DataTypePtr getReturnType(const DataTypes & arguments) const { if (arguments.size() < 2) @@ -224,11 +224,11 @@ public: } size_t n = in[0]->size(); - /// Скомбинируем все константные столбцы в одно значение. + /// Combine all constant columns into a single value. UInt8 const_val = 0; bool has_consts = extractConstColumns(in, const_val); - // Если это значение однозначно определяет результат, вернем его. + // If this value uniquely determines the result, return it. if (has_consts && (in.empty() || Impl::apply(const_val, 0) == Impl::apply(const_val, 1))) { if (!in.empty()) @@ -238,7 +238,7 @@ public: return; } - /// Если это значение - нейтральный элемент, забудем про него. + /// If this value is a neutral element, let's forget about it. if (has_consts && Impl::apply(const_val, 0) == 0 && Impl::apply(const_val, 1) == 1) has_consts = false; @@ -256,8 +256,8 @@ public: vec_res.resize(n); } - /// Разделим входные столбцы на UInt8 и остальные. Первые обработаем более эффективно. - /// col_res в каждый момент будет либо находится в конце uint8_in, либо не содержаться в uint8_in. + /// Divide the input columns into UInt8 and the rest. The first will be processed more efficiently. + /// col_res at each moment will either be at the end of uint8_in, or not contained in uint8_in. UInt8ColumnPtrs uint8_in; ColumnPlainPtrs other_in; for (IColumn * column : in) @@ -268,7 +268,7 @@ public: other_in.push_back(column); } - /// Нужен хотя бы один столбец в uint8_in, чтобы было с кем комбинировать столбцы из other_in. + /// You need at least one column in uint8_in, so that you can combine columns with other_in. if (uint8_in.empty()) { if (other_in.empty()) @@ -279,14 +279,14 @@ public: uint8_in.push_back(col_res.get()); } - /// Эффективно скомбинируем все столбцы правильного типа. + /// Effectively combine all the columns of the correct type. while (uint8_in.size() > 1) { AssociativeOperationImpl, 10>::execute(uint8_in, vec_res); uint8_in.push_back(col_res.get()); } - /// По одному добавим все столбцы неправильного типа. + /// One by one, add all the columns of the wrong type. while (!other_in.empty()) { executeUInt8Other(uint8_in[0]->getData(), other_in.back(), vec_res); @@ -294,7 +294,7 @@ public: uint8_in[0] = col_res.get(); } - /// Такое возможно, если среди аргументов ровно один неконстантный, и он имеет тип UInt8. + /// This is possible if there are exactly one non-constant among the arguments, and it is of type UInt8. if (uint8_in[0] != col_res.get()) { vec_res.assign(uint8_in[0]->getData()); diff --git a/dbms/src/IO/CachedCompressedReadBuffer.cpp b/dbms/src/IO/CachedCompressedReadBuffer.cpp index 6ccb592ed64..21b042d1da6 100644 --- a/dbms/src/IO/CachedCompressedReadBuffer.cpp +++ b/dbms/src/IO/CachedCompressedReadBuffer.cpp @@ -26,14 +26,14 @@ void CachedCompressedReadBuffer::initInput() bool CachedCompressedReadBuffer::nextImpl() { - /// Проверим наличие разжатого блока в кэше, захватим владение этим блоком, если он есть. + /// Let's check for the presence of a decompressed block in the cache, grab the ownership of this block, if it exists. UInt128 key = cache->hash(path, file_pos); owned_cell = cache->get(key); if (!owned_cell) { - /// Если нет - надо прочитать его из файла. + /// If not, read it from the file. initInput(); file_in->seek(file_pos); @@ -48,7 +48,7 @@ bool CachedCompressedReadBuffer::nextImpl() owned_cell->data.resize(size_decompressed); decompress(owned_cell->data.m_data, size_decompressed, size_compressed_without_checksum); - /// Положим данные в кэш. + /// Put data into cache. cache->set(key, owned_cell); } } diff --git a/dbms/src/IO/CompressedReadBuffer.cpp b/dbms/src/IO/CompressedReadBuffer.cpp index 964dd291312..c04450d0b4b 100644 --- a/dbms/src/IO/CompressedReadBuffer.cpp +++ b/dbms/src/IO/CompressedReadBuffer.cpp @@ -24,11 +24,11 @@ size_t CompressedReadBuffer::readBig(char * to, size_t n) { size_t bytes_read = 0; - /// Если в буфере есть непрочитанные байты, то скопируем сколько надо в to. + /// If there are unread bytes in the buffer, then we copy necessary to `to`. if (pos < working_buffer.end()) bytes_read += read(to, std::min(static_cast(working_buffer.end() - pos), n)); - /// Если надо ещё прочитать - будем, по возможности, разжимать сразу в to. + /// If you need to read more - we will, if possible, uncompress at once to `to`. while (bytes_read < n) { size_t size_decompressed; @@ -37,7 +37,7 @@ size_t CompressedReadBuffer::readBig(char * to, size_t n) if (!readCompressedData(size_decompressed, size_compressed_without_checksum)) return bytes_read; - /// Если разжатый блок помещается целиком туда, куда его надо скопировать. + /// If the decompressed block is placed entirely where it needs to be copied. if (size_decompressed <= n - bytes_read) { decompress(to + bytes_read, size_decompressed, size_compressed_without_checksum); diff --git a/dbms/src/IO/CompressedReadBufferFromFile.cpp b/dbms/src/IO/CompressedReadBufferFromFile.cpp index a5fff78e729..7a80993e271 100644 --- a/dbms/src/IO/CompressedReadBufferFromFile.cpp +++ b/dbms/src/IO/CompressedReadBufferFromFile.cpp @@ -47,7 +47,7 @@ void CompressedReadBufferFromFile::seek(size_t offset_in_compressed_file, size_t { bytes += offset(); pos = working_buffer.begin() + offset_in_decompressed_block; - /// bytes может переполниться и получиться отрицательным, но в count() все переполнится обратно и получится правильно. + /// `bytes` can overflow and get negative, but in `count()` everything will overflow back and get right. bytes -= offset(); } else @@ -72,22 +72,22 @@ size_t CompressedReadBufferFromFile::readBig(char * to, size_t n) { size_t bytes_read = 0; - /// Если в буфере есть непрочитанные байты, то скопируем сколько надо в to. + /// If there are unread bytes in the buffer, then we copy needed to `to`. if (pos < working_buffer.end()) bytes_read += read(to, std::min(static_cast(working_buffer.end() - pos), n)); - /// Если надо ещё прочитать - будем, по возможности, разжимать сразу в to. + /// If you need to read more - we will, if possible, decompress at once to `to`. while (bytes_read < n) { size_t size_decompressed = 0; size_t size_compressed_without_checksum = 0; size_t new_size_compressed = readCompressedData(size_decompressed, size_compressed_without_checksum); - size_compressed = 0; /// file_in больше не указывает на конец блока в working_buffer. + size_compressed = 0; /// file_in no longer points to the end of the block in working_buffer. if (!new_size_compressed) return bytes_read; - /// Если разжатый блок помещается целиком туда, куда его надо скопировать. + /// If the decompressed block fits entirely where it needs to be copied. if (size_decompressed <= n - bytes_read) { decompress(to + bytes_read, size_decompressed, size_compressed_without_checksum); diff --git a/dbms/src/IO/CompressedWriteBuffer.cpp b/dbms/src/IO/CompressedWriteBuffer.cpp index 1fcad7d1a3d..c45276bcd12 100644 --- a/dbms/src/IO/CompressedWriteBuffer.cpp +++ b/dbms/src/IO/CompressedWriteBuffer.cpp @@ -33,7 +33,7 @@ void CompressedWriteBuffer::nextImpl() size_t compressed_size = 0; char * compressed_buffer_ptr = nullptr; - /** Формат сжатого блока - см. CompressedStream.h + /** The format of compressed block - see CompressedStream.h */ switch (method) diff --git a/dbms/src/IO/HashingWriteBuffer.cpp b/dbms/src/IO/HashingWriteBuffer.cpp index 0f290ce7ee7..e7a88dc84f5 100644 --- a/dbms/src/IO/HashingWriteBuffer.cpp +++ b/dbms/src/IO/HashingWriteBuffer.cpp @@ -5,14 +5,14 @@ namespace DB { -/// вычисление хэша зависит от разбиения по блокам -/// поэтому нужно вычислить хэш от n полных кусочков и одного неполного +/// computation of the hash depends on the partitioning of blocks +/// so you need to compute a hash of n complete pieces and one incomplete template void IHashingBuffer::calculateHash(DB::BufferBase::Position data, size_t len) { if (len) { - /// если данных меньше, чем block_size то сложим их в свой буффер и посчитаем от них hash позже + /// if the data is less than `block_size`, then put them into buffer and calculate hash later if (block_pos + len < block_size) { memcpy(&BufferWithOwnMemory::memory[block_pos], data, len); @@ -20,7 +20,7 @@ void IHashingBuffer::calculateHash(DB::BufferBase::Position data, size_t } else { - /// если в буффер уже что-то записано, то допишем его + /// if something is already written to the buffer, then we'll add it if (block_pos) { size_t n = block_size - block_pos; @@ -38,7 +38,7 @@ void IHashingBuffer::calculateHash(DB::BufferBase::Position data, size_t data += block_size; } - /// запишем остаток в свой буфер + /// write the remainder to its buffer if (len) { memcpy(&BufferWithOwnMemory::memory[0], data, len); @@ -53,7 +53,7 @@ template class IHashingBuffer; } -/// UInt64 это 39 символов в 10 системе счисления +/// UInt64 is 39 characters in 10th number system static const size_t UINT64_DECIMAL_SIZE = 39; std::string uint128ToString(uint128 data) { diff --git a/dbms/src/IO/InterserverWriteBuffer.cpp b/dbms/src/IO/InterserverWriteBuffer.cpp index 607f66e1f8e..58bba91bd40 100644 --- a/dbms/src/IO/InterserverWriteBuffer.cpp +++ b/dbms/src/IO/InterserverWriteBuffer.cpp @@ -50,7 +50,7 @@ InterserverWriteBuffer::InterserverWriteBuffer(const std::string & host_, int po session.setPort(port); session.setKeepAlive(true); - /// устанавливаем таймаут + /// set the timeout #if POCO_CLICKHOUSE_PATCH || POCO_VERSION >= 0x02000000 session.setTimeout(connection_timeout, send_timeout, receive_timeout); #else @@ -83,7 +83,7 @@ void InterserverWriteBuffer::nextImpl() if (!offset() || finalized) return; - /// Для корректной работы с AsynchronousWriteBuffer, который подменяет буферы. + /// For correct work with AsynchronousWriteBuffer, which replaces buffers. impl->set(buffer().begin(), buffer().size()); impl->position() = pos; diff --git a/dbms/src/IO/ReadBufferAIO.cpp b/dbms/src/IO/ReadBufferAIO.cpp index b531354a31e..749ab0872e8 100644 --- a/dbms/src/IO/ReadBufferAIO.cpp +++ b/dbms/src/IO/ReadBufferAIO.cpp @@ -35,8 +35,8 @@ namespace ErrorCodes } -/// Примечание: выделяется дополнительная страница, которая содежрит те данные, которые -/// не влезают в основной буфер. +/// Note: an additional page is allocated that will contain the data that +/// does not fit into the main buffer. ReadBufferAIO::ReadBufferAIO(const std::string & filename_, size_t buffer_size_, int flags_, char * existing_memory_) : ReadBufferFromFileBase(buffer_size_ + DEFAULT_AIO_FILE_BLOCK_SIZE, existing_memory_, DEFAULT_AIO_FILE_BLOCK_SIZE), fill_buffer(BufferWithOwnMemory(internalBuffer().size(), nullptr, DEFAULT_AIO_FILE_BLOCK_SIZE)), @@ -83,8 +83,8 @@ void ReadBufferAIO::setMaxBytes(size_t max_bytes_read_) bool ReadBufferAIO::nextImpl() { - /// Если конец файла уже был достигнут при вызове этой функции, - /// то текущий вызов ошибочен. + /// If the end of the file has already been reached by calling this function, + /// then the current call is wrong. if (is_eof) return false; @@ -111,11 +111,11 @@ bool ReadBufferAIO::nextImpl() is_started = true; - /// Если конец файла только что достигнут, больше ничего не делаем. + /// If the end of the file is just reached, do nothing else. if (is_eof) return true; - /// Создать асинхронный запрос. + /// Create an asynchronous request. prepare(); request.aio_lio_opcode = IOCB_CMD_PREAD; @@ -124,7 +124,7 @@ bool ReadBufferAIO::nextImpl() request.aio_nbytes = region_aligned_size; request.aio_offset = region_aligned_begin; - /// Отправить запрос. + /// Send the request. try { future_bytes_read = AIOContextPool::instance().post(request); @@ -168,16 +168,16 @@ off_t ReadBufferAIO::doSeek(off_t off, int whence) off_t first_read_pos_in_file = first_unread_pos_in_file - static_cast(working_buffer.size()); if (hasPendingData() && (new_pos_in_file >= first_read_pos_in_file) && (new_pos_in_file <= first_unread_pos_in_file)) { - /// Свдинулись, но остались в пределах буфера. + /// Moved, but remained within the buffer. pos = working_buffer.begin() + (new_pos_in_file - first_read_pos_in_file); } else { - /// Сдвинулись за пределы буфера. + /// Moved past the buffer. pos = working_buffer.end(); first_unread_pos_in_file = new_pos_in_file; - /// Не можем использовать результат текущего асинхронного запроса. + /// We can not use the result of the current asynchronous request. skip(); } } @@ -238,7 +238,7 @@ void ReadBufferAIO::prepare() { requested_byte_count = std::min(fill_buffer.internalBuffer().size() - DEFAULT_AIO_FILE_BLOCK_SIZE, max_bytes_read); - /// Регион диска, из которого хотим читать данные. + /// Region of the disk from which we want to read data. const off_t region_begin = first_unread_pos_in_file; if ((requested_byte_count > std::numeric_limits::max()) || @@ -247,7 +247,7 @@ void ReadBufferAIO::prepare() const off_t region_end = first_unread_pos_in_file + requested_byte_count; - /// Выровненный регион диска, из которого будем читать данные. + /// The aligned region of the disk from which we will read the data. region_left_padding = region_begin % DEFAULT_AIO_FILE_BLOCK_SIZE; const size_t region_right_padding = (DEFAULT_AIO_FILE_BLOCK_SIZE - (region_end % DEFAULT_AIO_FILE_BLOCK_SIZE)) % DEFAULT_AIO_FILE_BLOCK_SIZE; @@ -267,10 +267,10 @@ void ReadBufferAIO::finalize() if ((bytes_read < 0) || (static_cast(bytes_read) < region_left_padding)) throw Exception("Asynchronous read error on file " + filename, ErrorCodes::AIO_READ_ERROR); - /// Игнорируем излишние байты слева. + /// Ignore redundant bytes on the left. bytes_read -= region_left_padding; - /// Игнорируем излишние байты справа. + /// Ignore redundant bytes on the right. bytes_read = std::min(bytes_read, static_cast(requested_byte_count)); if (bytes_read > 0) @@ -288,7 +288,7 @@ void ReadBufferAIO::finalize() if (total_bytes_read == max_bytes_read) is_eof = true; - /// Менять местами основной и дублирующий буферы. + /// Swap the main and duplicate buffers. internalBuffer().swap(fill_buffer.internalBuffer()); buffer().swap(fill_buffer.buffer()); std::swap(position(), fill_buffer.position()); diff --git a/dbms/src/IO/ReadBufferFromPocoSocket.cpp b/dbms/src/IO/ReadBufferFromPocoSocket.cpp index d35bf3c9462..69e5da0ed09 100644 --- a/dbms/src/IO/ReadBufferFromPocoSocket.cpp +++ b/dbms/src/IO/ReadBufferFromPocoSocket.cpp @@ -21,7 +21,7 @@ bool ReadBufferFromPocoSocket::nextImpl() { ssize_t bytes_read = 0; - /// Добавляем в эксепшены более подробную информацию. + /// Add more details to exceptions. try { bytes_read = socket.impl()->receiveBytes(internal_buffer.begin(), internal_buffer.size()); diff --git a/dbms/src/IO/ReadHelpers.cpp b/dbms/src/IO/ReadHelpers.cpp index 0d9c609957a..3ac5d2fe221 100644 --- a/dbms/src/IO/ReadHelpers.cpp +++ b/dbms/src/IO/ReadHelpers.cpp @@ -180,8 +180,8 @@ void readStringUntilEOF(String & s, ReadBuffer & buf) template void readStringUntilEOFInto>(PaddedPODArray & s, ReadBuffer & buf); -/** Распарсить escape-последовательность, которая может быть простой (один символ после бэкслеша) или более сложной (несколько символов). - * Предполагается, что курсор расположен на символе \ +/** Parse the escape sequence, which can be simple (one character after backslash) or more complex (multiple characters). + * It is assumed that the cursor is located on the `\` symbol */ template static void parseComplexEscapeSequence(Vector & s, ReadBuffer & buf) @@ -193,7 +193,7 @@ static void parseComplexEscapeSequence(Vector & s, ReadBuffer & buf) if (*buf.position() == 'x') { ++buf.position(); - /// escape-последовательность вида \xAA + /// escape sequence of the form \ xAA UInt8 c1; UInt8 c2; readPODBinary(c1, buf); @@ -207,14 +207,14 @@ static void parseComplexEscapeSequence(Vector & s, ReadBuffer & buf) } else { - /// Обычная escape-последовательность из одного символа. + /// The usual escape sequence of a single character. s.push_back(parseEscapeSequence(*buf.position())); ++buf.position(); } } -/// TODO Обобщить с кодом в FunctionsVisitParam.h и JSON.h +/// TODO Compute with the code in FunctionsVisitParam.h and JSON.h template static void parseJSONEscapeSequence(Vector & s, ReadBuffer & buf) { @@ -255,8 +255,8 @@ static void parseJSONEscapeSequence(Vector & s, ReadBuffer & buf) char hex_code[4]; readPODBinary(hex_code, buf); - /// \u0000 - частый случай. - if (0 == memcmp(hex_code, "0000", 4)) + /// \u0000 - special case + if (0 == memcmp(hex_code, "0000", 4)) { s.push_back(0); return; @@ -279,7 +279,7 @@ static void parseJSONEscapeSequence(Vector & s, ReadBuffer & buf) } else { - /// Суррогатная пара. + /// Surrogate pair. if (code_point >= 0xD800 && code_point <= 0xDBFF) { assertString("\\u", buf); @@ -439,7 +439,7 @@ void readCSVStringInto(Vector & s, ReadBuffer & buf, const char delimiter) char maybe_quote = *buf.position(); - /// Пустота и даже не в кавычках. + /// Emptiness and not even in quotation marks. if (maybe_quote == delimiter) return; @@ -447,7 +447,7 @@ void readCSVStringInto(Vector & s, ReadBuffer & buf, const char delimiter) { ++buf.position(); - /// Закавыченный случай. Ищем следующую кавычку. + /// The quoted case. We are looking for the next quotation mark. while (!buf.eof()) { const char * next_pos = reinterpret_cast(memchr(buf.position(), maybe_quote, buf.buffer().end() - buf.position())); @@ -461,7 +461,7 @@ void readCSVStringInto(Vector & s, ReadBuffer & buf, const char delimiter) if (!buf.hasPendingData()) continue; - /// Сейчас под курсором кавычка. Есть ли следующая? + /// Now there is a quotation mark under the cursor. Is there any following? ++buf.position(); if (buf.eof()) return; @@ -478,12 +478,12 @@ void readCSVStringInto(Vector & s, ReadBuffer & buf, const char delimiter) } else { - /// Незакавыченный случай. Ищем delimiter или \r или \n. + /// Unquoted case. Look for delimiter or \r or \n. while (!buf.eof()) { const char * next_pos = buf.position(); while (next_pos < buf.buffer().end() - && *next_pos != delimiter && *next_pos != '\r' && *next_pos != '\n') /// NOTE Можно сделать SIMD версию. + && *next_pos != delimiter && *next_pos != '\r' && *next_pos != '\n') /// NOTE You can make a SIMD version. ++next_pos; appendToStringOrVector(s, buf.position(), next_pos); @@ -492,9 +492,9 @@ void readCSVStringInto(Vector & s, ReadBuffer & buf, const char delimiter) if (!buf.hasPendingData()) continue; - /** CSV формат может содержать незначащие пробелы и табы. - * Обычно задача их пропускать - у вызывающего кода. - * Но в данном случае, сделать это будет сложно, поэтому удаляем концевые пробельные символы самостоятельно. + /** CSV format can contain insignificant spaces and tabs. + * Usually the task of skipping them is for the calling code. + * But in this case, it will be difficult to do this, so remove the trailing whitespace by yourself. */ size_t size = s.size(); while (size > 0 @@ -566,7 +566,7 @@ void readDateTimeTextFallback(time_t & datetime, ReadBuffer & buf, const DateLUT char s[DATE_TIME_BROKEN_DOWN_LENGTH]; char * s_pos = s; - /// Кусок, похожий на unix timestamp. + /// A piece similar to unix timestamp. while (s_pos < s + UNIX_TIMESTAMP_MAX_LENGTH && !buf.eof() && isNumericASCII(*buf.position())) { *s_pos = *buf.position(); diff --git a/dbms/src/IO/WriteBufferAIO.cpp b/dbms/src/IO/WriteBufferAIO.cpp index 421d9280b8b..fe0a2f71d3f 100644 --- a/dbms/src/IO/WriteBufferAIO.cpp +++ b/dbms/src/IO/WriteBufferAIO.cpp @@ -37,15 +37,15 @@ namespace ErrorCodes } -/// Примечание: выделяется дополнительная страница, которая содежрит те данные, которые -/// не влезают в основной буфер. +/// Note: an additional page is allocated that will contain data that +/// do not fit into the main buffer. WriteBufferAIO::WriteBufferAIO(const std::string & filename_, size_t buffer_size_, int flags_, mode_t mode_, char * existing_memory_) : WriteBufferFromFileBase(buffer_size_ + DEFAULT_AIO_FILE_BLOCK_SIZE, existing_memory_, DEFAULT_AIO_FILE_BLOCK_SIZE), flush_buffer(BufferWithOwnMemory(this->memory.size(), nullptr, DEFAULT_AIO_FILE_BLOCK_SIZE)), filename(filename_) { - /// Исправить информацию о размере буферов, чтобы дополнительные страницы не касались базового класса BufferBase. + /// Correct the buffer size information so that additional pages do not touch the base class `BufferBase`. this->buffer().resize(this->buffer().size() - DEFAULT_AIO_FILE_BLOCK_SIZE); this->internalBuffer().resize(this->internalBuffer().size() - DEFAULT_AIO_FILE_BLOCK_SIZE); flush_buffer.buffer().resize(this->buffer().size() - DEFAULT_AIO_FILE_BLOCK_SIZE); @@ -92,7 +92,7 @@ void WriteBufferAIO::sync() { flush(); - /// Попросим ОС сбросить данные на диск. + /// Ask OS to flush data to disk. int res = ::fsync(fd); if (res == -1) throwFromErrno("Cannot fsync " + getFileName(), ErrorCodes::CANNOT_FSYNC); @@ -106,7 +106,7 @@ void WriteBufferAIO::nextImpl() if (waitForAIOCompletion()) finalize(); - /// Создать запрос на асинхронную запись. + /// Create a request for asynchronous write. prepare(); request.aio_lio_opcode = IOCB_CMD_PWRITE; @@ -115,7 +115,7 @@ void WriteBufferAIO::nextImpl() request.aio_nbytes = region_aligned_size; request.aio_offset = region_aligned_begin; - /// Отправить запрос. + /// Send the request. while (io_submit(aio_context.ctx, request_ptrs.size(), &request_ptrs[0]) < 0) { if (errno != EINTR) @@ -201,16 +201,16 @@ bool WriteBufferAIO::waitForAIOCompletion() void WriteBufferAIO::prepare() { - /// Менять местами основной и дублирующий буферы. + /// Swap the main and duplicate buffers. buffer().swap(flush_buffer.buffer()); std::swap(position(), flush_buffer.position()); truncation_count = 0; /* - Страница на диске или в памяти + A page on disk or in memory - начальный адрес (начальная позиция в случае диска) кратен DEFAULT_AIO_FILE_BLOCK_SIZE + start address (starting position in case of disk) is a multiply of DEFAULT_AIO_FILE_BLOCK_SIZE : : +---------------+ @@ -229,10 +229,10 @@ void WriteBufferAIO::prepare() */ /* - Представление данных на диске + Representation of data on a disk - XXX : данные, которые хотим записать - ZZZ : данные, которые уже на диске или нули, если отсутствуют данные + XXX : the data you want to write + ZZZ : data that is already on disk or zeros, if there is no data region_aligned_begin region_aligned_end : region_begin region_end : @@ -258,7 +258,7 @@ void WriteBufferAIO::prepare() region_aligned_size */ - /// Регион диска, в который хотим записать данные. + /// Region of the disk in which we want to write data. const off_t region_begin = pos_in_file; if ((flush_buffer.offset() > std::numeric_limits::max()) || @@ -268,7 +268,7 @@ void WriteBufferAIO::prepare() const off_t region_end = pos_in_file + flush_buffer.offset(); const size_t region_size = region_end - region_begin; - /// Выровненный регион диска, в который хотим записать данные. + /// The aligned region of the disk into which we want to write the data. const size_t region_left_padding = region_begin % DEFAULT_AIO_FILE_BLOCK_SIZE; const size_t region_right_padding = (DEFAULT_AIO_FILE_BLOCK_SIZE - (region_end % DEFAULT_AIO_FILE_BLOCK_SIZE)) % DEFAULT_AIO_FILE_BLOCK_SIZE; @@ -283,9 +283,9 @@ void WriteBufferAIO::prepare() bytes_to_write = region_aligned_size; /* - Представление данных в буфере до обработки + Representing data in the buffer before processing - XXX : данные, которые хотим записать + XXX : the data you want to write buffer_begin buffer_end : : @@ -305,20 +305,20 @@ void WriteBufferAIO::prepare() buffer_size */ - /// Буфер данных, которые хотим записать на диск. + /// The buffer of data that we want to write to the disk. buffer_begin = flush_buffer.buffer().begin(); Position buffer_end = buffer_begin + region_size; size_t buffer_size = buffer_end - buffer_begin; - /// Обработать буфер, чтобы он отражал структуру региона диска. + /// Process the buffer so that it reflects the structure of the disk region. /* - Представление данных в буфере после обработки + Representation of data in the buffer after processing - XXX : данные, которые хотим записать - ZZZ : данные из диска или нули, если отсутствуют данные + XXX : the data you want to write + ZZZ : data from disk or zeros, if there is no data - buffer_begin buffer_end дополнительная страница + `buffer_begin` `buffer_end` extra page : : : : : : +---:-----------+---------------+---------------+---------------+--:------------+ @@ -347,7 +347,7 @@ void WriteBufferAIO::prepare() if (region_left_padding > 0) { - /// Сдвинуть данные буфера вправо. Дополнить начало буфера данными из диска. + /// Move the buffer data to the right. Complete the beginning of the buffer with data from the disk. buffer_size += region_left_padding; buffer_end = buffer_begin + buffer_size; @@ -364,7 +364,7 @@ void WriteBufferAIO::prepare() if (region_right_padding > 0) { - /// Дополнить конец буфера данными из диска. + /// Add the end of the buffer with data from the disk. ssize_t read_count = ::pread(fd, memory_page, DEFAULT_AIO_FILE_BLOCK_SIZE, region_aligned_end - DEFAULT_AIO_FILE_BLOCK_SIZE); if (read_count < 0) throw Exception("Read error", ErrorCodes::AIO_READ_ERROR); @@ -405,7 +405,7 @@ void WriteBufferAIO::finalize() if (truncation_count > 0) { - /// Укоротить файл, чтобы удалить из него излишние нули. + /// Truncate the file to remove unnecessary zeros from it. int res = ::ftruncate(fd, max_pos_in_file); if (res == -1) throwFromErrno("Cannot truncate file " + filename, ErrorCodes::CANNOT_TRUNCATE_FILE); diff --git a/dbms/src/IO/WriteBufferFromPocoSocket.cpp b/dbms/src/IO/WriteBufferFromPocoSocket.cpp index bdcf954c70e..7f61cc8a3b8 100644 --- a/dbms/src/IO/WriteBufferFromPocoSocket.cpp +++ b/dbms/src/IO/WriteBufferFromPocoSocket.cpp @@ -27,7 +27,7 @@ void WriteBufferFromPocoSocket::nextImpl() { ssize_t res = 0; - /// Добавляем в эксепшены более подробную информацию. + /// Add more details to exceptions. try { res = socket.impl()->sendBytes(working_buffer.begin() + bytes_written, offset() - bytes_written); diff --git a/dbms/src/IO/copyData.cpp b/dbms/src/IO/copyData.cpp index b934eb30584..2eeaa82d3e6 100644 --- a/dbms/src/IO/copyData.cpp +++ b/dbms/src/IO/copyData.cpp @@ -12,13 +12,13 @@ namespace void copyDataImpl(ReadBuffer & from, WriteBuffer & to, bool check_bytes, size_t bytes, std::atomic * is_cancelled) { - /// Если дочитали до конца буфера, eof() либо заполнит буфер новыми данными и переместит курсор в начало, либо вернёт false. + /// If read to the end of the buffer, eof() either fills the buffer with new data and moves the cursor to the beginning, or returns false. while (bytes > 0 && !from.eof()) { if (is_cancelled && *is_cancelled) return; - /// buffer() - кусок данных, доступных для чтения; position() - курсор места, до которого уже дочитали. + /// buffer() - a piece of data available for reading; position() - the cursor of the place to which you have already read. size_t count = std::min(bytes, static_cast(from.buffer().end() - from.position())); to.write(from.position(), count); from.position() += count; @@ -31,13 +31,13 @@ void copyDataImpl(ReadBuffer & from, WriteBuffer & to, bool check_bytes, size_t void copyDataImpl(ReadBuffer & from, WriteBuffer & to, bool check_bytes, size_t bytes, std::function cancellation_hook) { - /// Если дочитали до конца буфера, eof() либо заполнит буфер новыми данными и переместит курсор в начало, либо вернёт false. + /// If read to the end of the buffer, eof() either fills the buffer with new data and moves the cursor to the beginning, or returns false. while (bytes > 0 && !from.eof()) { if (cancellation_hook) cancellation_hook(); - /// buffer() - кусок данных, доступных для чтения; position() - курсор места, до которого уже дочитали. + /// buffer() - a piece of data available for reading; position() - the cursor of the place to which you have already read. size_t count = std::min(bytes, static_cast(from.buffer().end() - from.position())); to.write(from.position(), count); from.position() += count; diff --git a/dbms/src/IO/tests/o_direct_and_dirty_pages.cpp b/dbms/src/IO/tests/o_direct_and_dirty_pages.cpp index 2b8a2b89349..4430a418d28 100644 --- a/dbms/src/IO/tests/o_direct_and_dirty_pages.cpp +++ b/dbms/src/IO/tests/o_direct_and_dirty_pages.cpp @@ -23,7 +23,7 @@ int main(int argc, char ** argv) String test = "Hello, world! " + toString(rand); - /// Пишем в файл как обычно, читаем с O_DIRECT. + /// Write to file as usual, read with O_DIRECT. { WriteBufferFromFile wb("test1", BUF_SIZE); @@ -41,7 +41,7 @@ int main(int argc, char ** argv) std::cerr << "test: " << test << ", res: " << res << ", bytes: " << rb.count() << std::endl; } - /// Пишем в файл с O_DIRECT, читаем как обычно. + /// Write to file with O_DIRECT, read as usual. { WriteBufferFromFile wb("test2", BUF_SIZE, O_WRONLY | O_CREAT | O_TRUNC | O_DIRECT, 0666, nullptr, 4096); diff --git a/dbms/src/IO/tests/parse_int_perf.cpp b/dbms/src/IO/tests/parse_int_perf.cpp index 641c3be8775..18d720fb335 100644 --- a/dbms/src/IO/tests/parse_int_perf.cpp +++ b/dbms/src/IO/tests/parse_int_perf.cpp @@ -1044,7 +1044,7 @@ static const UInt8 length_table[10000] = 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, -/// Далее нули +/// Further zeros }; @@ -1104,7 +1104,7 @@ void writeIntTextTable(T x, DB::WriteBuffer & buf) } else if (x < 0) { - /// Особый случай для самого маленького отрицательного числа + /// A special case for the smallest negative number if (unlikely(x == std::numeric_limits::min())) { if (sizeof(x) == 1) From 3d7587cb842287eb3eef489f3fc371bdc4a6f2d6 Mon Sep 17 00:00:00 2001 From: alexey-milovidov Date: Sun, 26 Mar 2017 04:14:49 +0300 Subject: [PATCH 2/2] Update DatabaseCloud.cpp --- dbms/src/Databases/DatabaseCloud.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dbms/src/Databases/DatabaseCloud.cpp b/dbms/src/Databases/DatabaseCloud.cpp index 3ba00f16858..efc894753e6 100644 --- a/dbms/src/Databases/DatabaseCloud.cpp +++ b/dbms/src/Databases/DatabaseCloud.cpp @@ -144,7 +144,7 @@ String DatabaseCloud::getTableDefinitionFromHash(Hash hash) const /** Description of one table in the list of tables in ZooKeeper. - * No table name (right side of display). + * No table name (right side of map). */ struct TableDescription {