Fixed wording [#CLICKHOUSE-2].

dbms/src/Interpreters/ProcessList.h

@@ -245,7 +245,7 @@ public:
     using EntryPtr = std::shared_ptr<ProcessListEntry>;
 
     /** Register running query. Returns refcounted object, that will remove element from list in destructor.
-      * If too much running queries - wait for not more than specified (see settings) amount of time.
+      * If too many running queries - wait for not more than specified (see settings) amount of time.
       * If timeout is passed - throw an exception.
       * Don't count KILL QUERY queries.
       */

dbms/src/Storages/MergeTree/PKCondition.cpp

@@ -512,7 +512,7 @@ static void castValueToType(const DataTypePtr & desired_type, Field & src_value,
 bool PKCondition::atomFromAST(const ASTPtr & node, const Context & context, Block & block_with_constants, RPNElement & out)
 {
     /** Functions < > = != <= >= in `notIn`, where one argument is a constant, and the other is one of columns of primary key,
-      *  or itself, wrapped in a chain of possibly-monotone functions,
+      *  or itself, wrapped in a chain of possibly-monotonic functions,
       *  or constant expression - number.
       */
     Field const_value;
@@ -525,7 +525,7 @@ bool PKCondition::atomFromAST(const ASTPtr & node, const Context & context, Bloc
             return false;
 
         DataTypePtr key_expr_type;    /// Type of expression containing primary key column
-        size_t key_arg_pos;            /// Position of argument with primary key column (non-const argument)
+        size_t key_arg_pos;           /// Position of argument with primary key column (non-const argument)
         size_t key_column_num;        /// Number of a primary key column (inside sort_descr array)
         RPNElement::MonotonicFunctionsChain chain;
         bool is_set_const = false;

dbms/src/Storages/MergeTree/ReplicatedMergeTreePartCheckThread.cpp

@@ -192,7 +192,7 @@ void ReplicatedMergeTreePartCheckThread::searchForMissingPart(const String & par
     size_t part_length_in_blocks = part_info.max_block + 1 - part_info.min_block;
     if (part_length_in_blocks > 1000)
     {
-        LOG_ERROR(log, "Won't add nonincrement_block_numbers because part spans too much blocks (" << part_length_in_blocks << ")");
+        LOG_ERROR(log, "Won't add nonincrement_block_numbers because part spans too many blocks (" << part_length_in_blocks << ")");
         return;
     }
 

dbms/src/Storages/MergeTree/SimpleMergeSelector.cpp

@@ -148,7 +148,7 @@ void selectWithinPartition(
 
     for (size_t begin = 0; begin < parts_count; ++begin)
     {
-        /// If too much parts, select only from first, to avoid complexity.
+        /// If too many parts, select only from first, to avoid complexity.
         if (begin > 1000)
             break;
 

dbms/src/Storages/MergeTree/SimpleMergeSelector.h

@@ -29,8 +29,8 @@ public:
 
         /** Base is lowered until 1 (effectively means "merge any two parts") depending on several variables:
           *
-          * 1. Total number of parts in partition. If too much - then base is lowered.
-          * It means: when too much parts - do merges more urgently.
+          * 1. Total number of parts in partition. If too many - then base is lowered.
+          * It means: when too many parts - do merges more urgently.
           *
           * 2. Minimum age of parts participating in merge. If higher age - then base is lowered.
           * It means: do less wide merges only rarely.

dbms/src/Storages/StorageBuffer.cpp

@@ -474,7 +474,7 @@ void StorageBuffer::flushBuffer(Buffer & buffer, bool check_thresholds)
         return;
 
     /** For simplicity, buffer is locked during write.
-        * We could unlock buffer temporary, but it would lead to too much difficulties:
+        * We could unlock buffer temporary, but it would lead to too many difficulties:
         * - data, that is written, will not be visible for SELECTs;
         * - new data could be appended to buffer, and in case of exception, we must merge it with old data, that has not been written;
         * - this could lead to infinite memory growth.