diff --git a/dbms/src/Functions/FunctionsMiscellaneous.cpp b/dbms/src/Functions/FunctionsMiscellaneous.cpp
index f69dad39b52..4660f78bebf 100644
--- a/dbms/src/Functions/FunctionsMiscellaneous.cpp
+++ b/dbms/src/Functions/FunctionsMiscellaneous.cpp
@@ -813,7 +813,7 @@ public:
 
 /** The `indexHint` function takes any number of any arguments and always returns one.
   *
-  * This function has a special meaning (see ExpressionAnalyzer, PKCondition)
+  * This function has a special meaning (see ExpressionAnalyzer, KeyCondition)
   * - 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.
diff --git a/dbms/src/Interpreters/ExpressionAnalyzer.cpp b/dbms/src/Interpreters/ExpressionAnalyzer.cpp
index 5dad9c4f323..a56e7df74a7 100644
--- a/dbms/src/Interpreters/ExpressionAnalyzer.cpp
+++ b/dbms/src/Interpreters/ExpressionAnalyzer.cpp
@@ -2021,7 +2021,7 @@ void ExpressionAnalyzer::getActionsImpl(const ASTPtr & ast, bool no_subqueries,
         }
 
         /// A special function `indexHint`. Everything that is inside it is not calculated
-        /// (and is used only for index analysis, see PKCondition).
+        /// (and is used only for index analysis, see KeyCondition).
         if (node->name == "indexHint")
         {
             actions_stack.addAction(ExpressionAction::addColumn(ColumnWithTypeAndName(
@@ -2888,7 +2888,7 @@ void ExpressionAnalyzer::getRequiredSourceColumnsImpl(const ASTPtr & ast,
         }
 
         /// A special function `indexHint`. Everything that is inside it is not calculated
-        /// (and is used only for index analysis, see PKCondition).
+        /// (and is used only for index analysis, see KeyCondition).
         if (node->name == "indexHint")
             return;
     }
diff --git a/dbms/src/Interpreters/Set.cpp b/dbms/src/Interpreters/Set.cpp
index 931019739b0..0d9536da409 100644
--- a/dbms/src/Interpreters/Set.cpp
+++ b/dbms/src/Interpreters/Set.cpp
@@ -21,7 +21,7 @@
 #include <Interpreters/evaluateConstantExpression.h>
 #include <Interpreters/NullableUtils.h>
 
-#include <Storages/MergeTree/PKCondition.h>
+#include <Storages/MergeTree/KeyCondition.h>
 
 
 namespace DB
@@ -396,14 +396,14 @@ MergeTreeSetIndex::MergeTreeSetIndex(const SetElements & set_elements, std::vect
     std::sort(indexes_mapping.begin(), indexes_mapping.end(),
         [](const PKTuplePositionMapping & l, const PKTuplePositionMapping & r)
         {
-            return std::forward_as_tuple(l.pk_index, l.tuple_index) < std::forward_as_tuple(r.pk_index, r.tuple_index);
+            return std::forward_as_tuple(l.key_index, l.tuple_index) < std::forward_as_tuple(r.key_index, r.tuple_index);
         });
 
     indexes_mapping.erase(std::unique(
         indexes_mapping.begin(), indexes_mapping.end(),
         [](const PKTuplePositionMapping & l, const PKTuplePositionMapping & r)
         {
-            return l.pk_index == r.pk_index;
+            return l.key_index == r.key_index;
         }), indexes_mapping.end());
 
     for (size_t i = 0; i < set_elements.size(); ++i)
@@ -435,10 +435,10 @@ BoolMask MergeTreeSetIndex::mayBeTrueInRange(const std::vector<Range> & key_rang
 
     for (size_t i = 0; i < indexes_mapping.size(); ++i)
     {
-        std::optional<Range> new_range = PKCondition::applyMonotonicFunctionsChainToRange(
-            key_ranges[indexes_mapping[i].pk_index],
+        std::optional<Range> new_range = KeyCondition::applyMonotonicFunctionsChainToRange(
+            key_ranges[indexes_mapping[i].key_index],
             indexes_mapping[i].functions,
-            data_types[indexes_mapping[i].pk_index]);
+            data_types[indexes_mapping[i].key_index]);
 
         if (!new_range)
             return {true, true};
diff --git a/dbms/src/Interpreters/Set.h b/dbms/src/Interpreters/Set.h
index 620fe1ee3f7..4f40f3205de 100644
--- a/dbms/src/Interpreters/Set.h
+++ b/dbms/src/Interpreters/Set.h
@@ -170,7 +170,7 @@ public:
     struct PKTuplePositionMapping
     {
         size_t tuple_index;
-        size_t pk_index;
+        size_t key_index;
         std::vector<FunctionBasePtr> functions;
     };
 
diff --git a/dbms/src/Storages/MergeTree/PKCondition.cpp b/dbms/src/Storages/MergeTree/KeyCondition.cpp
similarity index 93%
rename from dbms/src/Storages/MergeTree/PKCondition.cpp
rename to dbms/src/Storages/MergeTree/KeyCondition.cpp
index bc879e770ea..60b0699d4a0 100644
--- a/dbms/src/Storages/MergeTree/PKCondition.cpp
+++ b/dbms/src/Storages/MergeTree/KeyCondition.cpp
@@ -1,4 +1,4 @@
-#include <Storages/MergeTree/PKCondition.h>
+#include <Storages/MergeTree/KeyCondition.h>
 #include <Storages/MergeTree/BoolMask.h>
 #include <DataTypes/DataTypesNumber.h>
 #include <Interpreters/ExpressionAnalyzer.h>
@@ -105,7 +105,7 @@ static String firstStringThatIsGreaterThanAllStringsWithPrefix(const String & pr
 
 
 /// A dictionary containing actions to the corresponding functions to turn them into `RPNElement`
-const PKCondition::AtomMap PKCondition::atom_map
+const KeyCondition::AtomMap KeyCondition::atom_map
 {
     {
         "notEquals",
@@ -249,7 +249,7 @@ bool FieldWithInfinity::operator==(const FieldWithInfinity & other) const
 /** Calculate expressions, that depend only on constants.
   * For index to work when something like "WHERE Date = toDate(now())" is written.
   */
-Block PKCondition::getBlockWithConstants(
+Block KeyCondition::getBlockWithConstants(
     const ASTPtr & query, const Context & context, const NamesAndTypesList & all_columns)
 {
     Block result
@@ -265,19 +265,19 @@ Block PKCondition::getBlockWithConstants(
 }
 
 
-PKCondition::PKCondition(
+KeyCondition::KeyCondition(
     const SelectQueryInfo & query_info,
     const Context & context,
     const NamesAndTypesList & all_columns,
     const SortDescription & sort_descr_,
-    const ExpressionActionsPtr & pk_expr_)
-    : sort_descr(sort_descr_), pk_expr(pk_expr_), prepared_sets(query_info.sets)
+    const ExpressionActionsPtr & key_expr_)
+    : sort_descr(sort_descr_), key_expr(key_expr_), prepared_sets(query_info.sets)
 {
     for (size_t i = 0; i < sort_descr.size(); ++i)
     {
         std::string name = sort_descr[i].column_name;
-        if (!pk_columns.count(name))
-            pk_columns[name] = i;
+        if (!key_columns.count(name))
+            key_columns[name] = i;
     }
 
     /** Evaluation of expressions that depend only on constants.
@@ -307,11 +307,11 @@ PKCondition::PKCondition(
     }
 }
 
-bool PKCondition::addCondition(const String & column, const Range & range)
+bool KeyCondition::addCondition(const String & column, const Range & range)
 {
-    if (!pk_columns.count(column))
+    if (!key_columns.count(column))
         return false;
-    rpn.emplace_back(RPNElement::FUNCTION_IN_RANGE, pk_columns[column], range);
+    rpn.emplace_back(RPNElement::FUNCTION_IN_RANGE, key_columns[column], range);
     rpn.emplace_back(RPNElement::FUNCTION_AND);
     return true;
 }
@@ -368,7 +368,7 @@ static void applyFunction(
 }
 
 
-void PKCondition::traverseAST(const ASTPtr & node, const Context & context, Block & block_with_constants)
+void KeyCondition::traverseAST(const ASTPtr & node, const Context & context, Block & block_with_constants)
 {
     RPNElement element;
 
@@ -401,7 +401,7 @@ void PKCondition::traverseAST(const ASTPtr & node, const Context & context, Bloc
 }
 
 
-bool PKCondition::canConstantBeWrappedByMonotonicFunctions(
+bool KeyCondition::canConstantBeWrappedByMonotonicFunctions(
     const ASTPtr & node,
     size_t & out_primary_key_column_num,
     DataTypePtr & out_primary_key_column_type,
@@ -409,12 +409,12 @@ bool PKCondition::canConstantBeWrappedByMonotonicFunctions(
     DataTypePtr & out_type)
 {
     String expr_name = node->getColumnName();
-    const auto & sample_block = pk_expr->getSampleBlock();
+    const auto & sample_block = key_expr->getSampleBlock();
     if (!sample_block.has(expr_name))
         return false;
 
     bool found_transformation = false;
-    for (const ExpressionAction & a : pk_expr->getActions())
+    for (const ExpressionAction & a : key_expr->getActions())
     {
         /** The primary key functional expression constraint may be inferred from a plain column in the expression.
           * For example, if the primary key contains `toStartOfHour(Timestamp)` and query contains `WHERE Timestamp >= now()`,
@@ -447,8 +447,8 @@ bool PKCondition::canConstantBeWrappedByMonotonicFunctions(
             expr_name = a.result_name;
 
             // Transformation results in a primary key expression, accept
-            auto it = pk_columns.find(expr_name);
-            if (pk_columns.end() != it)
+            auto it = key_columns.find(expr_name);
+            if (key_columns.end() != it)
             {
                 out_primary_key_column_num = it->second;
                 out_primary_key_column_type = sample_block.getByName(it->first).type;
@@ -461,7 +461,7 @@ bool PKCondition::canConstantBeWrappedByMonotonicFunctions(
     return found_transformation;
 }
 
-void PKCondition::getPKTuplePositionMapping(
+void KeyCondition::getPKTuplePositionMapping(
     const ASTPtr & node,
     const Context & context,
     std::vector<MergeTreeSetIndex::PKTuplePositionMapping> & indexes_mapping,
@@ -472,20 +472,20 @@ void PKCondition::getPKTuplePositionMapping(
     index_mapping.tuple_index = tuple_index;
     DataTypePtr data_type;
     if (isPrimaryKeyPossiblyWrappedByMonotonicFunctions(
-        node, context, index_mapping.pk_index,
+        node, context, index_mapping.key_index,
         data_type, index_mapping.functions))
     {
         indexes_mapping.push_back(index_mapping);
-        if (out_primary_key_column_num < index_mapping.pk_index)
+        if (out_primary_key_column_num < index_mapping.key_index)
         {
-            out_primary_key_column_num = index_mapping.pk_index;
+            out_primary_key_column_num = index_mapping.key_index;
         }
     }
 }
 
 
 /// Try to prepare PKTuplePositionMapping for tuples from IN expression.
-bool PKCondition::isTupleIndexable(
+bool KeyCondition::isTupleIndexable(
     const ASTPtr & node,
     const Context & context,
     RPNElement & out,
@@ -530,7 +530,7 @@ bool PKCondition::isTupleIndexable(
 }
 
 
-bool PKCondition::isPrimaryKeyPossiblyWrappedByMonotonicFunctions(
+bool KeyCondition::isPrimaryKeyPossiblyWrappedByMonotonicFunctions(
     const ASTPtr & node,
     const Context & context,
     size_t & out_primary_key_column_num,
@@ -561,7 +561,7 @@ bool PKCondition::isPrimaryKeyPossiblyWrappedByMonotonicFunctions(
     return true;
 }
 
-bool PKCondition::isPrimaryKeyPossiblyWrappedByMonotonicFunctionsImpl(
+bool KeyCondition::isPrimaryKeyPossiblyWrappedByMonotonicFunctionsImpl(
     const ASTPtr & node,
     size_t & out_primary_key_column_num,
     DataTypePtr & out_primary_key_column_type,
@@ -570,11 +570,11 @@ bool PKCondition::isPrimaryKeyPossiblyWrappedByMonotonicFunctionsImpl(
     /** By itself, the primary key column can be a functional expression. for example, `intHash32(UserID)`.
       * Therefore, use the full name of the expression for search.
       */
-    const auto & sample_block = pk_expr->getSampleBlock();
+    const auto & sample_block = key_expr->getSampleBlock();
     String name = node->getColumnName();
 
-    auto it = pk_columns.find(name);
-    if (pk_columns.end() != it)
+    auto it = key_columns.find(name);
+    if (key_columns.end() != it)
     {
         out_primary_key_column_num = it->second;
         out_primary_key_column_type = sample_block.getByName(it->first).type;
@@ -620,7 +620,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)
+bool KeyCondition::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-monotonic functions,
@@ -736,7 +736,7 @@ bool PKCondition::atomFromAST(const ASTPtr & node, const Context & context, Bloc
     return false;
 }
 
-bool PKCondition::operatorFromAST(const ASTFunction * func, RPNElement & out)
+bool KeyCondition::operatorFromAST(const ASTFunction * func, RPNElement & out)
 {
     /// Functions AND, OR, NOT.
     /** Also a special function `indexHint` - works as if instead of calling a function there are just parentheses
@@ -764,7 +764,7 @@ bool PKCondition::operatorFromAST(const ASTFunction * func, RPNElement & out)
     return true;
 }
 
-String PKCondition::toString() const
+String KeyCondition::toString() const
 {
     String res;
     for (size_t i = 0; i < rpn.size(); ++i)
@@ -896,7 +896,7 @@ static bool forAnyParallelogram(
 }
 
 
-bool PKCondition::mayBeTrueInRange(
+bool KeyCondition::mayBeTrueInRange(
     size_t used_key_size,
     const Field * left_pk,
     const Field * right_pk,
@@ -933,7 +933,7 @@ bool PKCondition::mayBeTrueInRange(
     });
 }
 
-std::optional<Range> PKCondition::applyMonotonicFunctionsChainToRange(
+std::optional<Range> KeyCondition::applyMonotonicFunctionsChainToRange(
     Range key_range,
     RPNElement::MonotonicFunctionsChain & functions,
     DataTypePtr current_type
@@ -970,7 +970,7 @@ std::optional<Range> PKCondition::applyMonotonicFunctionsChainToRange(
     return key_range;
 }
 
-bool PKCondition::mayBeTrueInRangeImpl(const std::vector<Range> & key_ranges, const DataTypes & data_types) const
+bool KeyCondition::mayBeTrueInRangeImpl(const std::vector<Range> & key_ranges, const DataTypes & data_types) const
 {
     std::vector<BoolMask> rpn_stack;
     for (size_t i = 0; i < rpn.size(); ++i)
@@ -1054,30 +1054,30 @@ bool PKCondition::mayBeTrueInRangeImpl(const std::vector<Range> & key_ranges, co
             rpn_stack.emplace_back(true, false);
         }
         else
-            throw Exception("Unexpected function type in PKCondition::RPNElement", ErrorCodes::LOGICAL_ERROR);
+            throw Exception("Unexpected function type in KeyCondition::RPNElement", ErrorCodes::LOGICAL_ERROR);
     }
 
     if (rpn_stack.size() != 1)
-        throw Exception("Unexpected stack size in PKCondition::mayBeTrueInRange", ErrorCodes::LOGICAL_ERROR);
+        throw Exception("Unexpected stack size in KeyCondition::mayBeTrueInRange", ErrorCodes::LOGICAL_ERROR);
 
     return rpn_stack[0].can_be_true;
 }
 
 
-bool PKCondition::mayBeTrueInRange(
+bool KeyCondition::mayBeTrueInRange(
     size_t used_key_size, const Field * left_pk, const Field * right_pk, const DataTypes & data_types) const
 {
     return mayBeTrueInRange(used_key_size, left_pk, right_pk, data_types, true);
 }
 
-bool PKCondition::mayBeTrueAfter(
+bool KeyCondition::mayBeTrueAfter(
     size_t used_key_size, const Field * left_pk, const DataTypes & data_types) const
 {
     return mayBeTrueInRange(used_key_size, left_pk, nullptr, data_types, false);
 }
 
 
-String PKCondition::RPNElement::toString() const
+String KeyCondition::RPNElement::toString() const
 {
     auto print_wrapped_column = [this](std::ostringstream & ss)
     {
@@ -1129,7 +1129,7 @@ String PKCondition::RPNElement::toString() const
 }
 
 
-bool PKCondition::alwaysUnknownOrTrue() const
+bool KeyCondition::alwaysUnknownOrTrue() const
 {
     std::vector<UInt8> rpn_stack;
 
@@ -1166,14 +1166,14 @@ bool PKCondition::alwaysUnknownOrTrue() const
             rpn_stack.back() = arg1 | arg2;
         }
         else
-            throw Exception("Unexpected function type in PKCondition::RPNElement", ErrorCodes::LOGICAL_ERROR);
+            throw Exception("Unexpected function type in KeyCondition::RPNElement", ErrorCodes::LOGICAL_ERROR);
     }
 
     return rpn_stack[0];
 }
 
 
-size_t PKCondition::getMaxKeyColumn() const
+size_t KeyCondition::getMaxKeyColumn() const
 {
     size_t res = 0;
     for (const auto & element : rpn)
diff --git a/dbms/src/Storages/MergeTree/PKCondition.h b/dbms/src/Storages/MergeTree/KeyCondition.h
similarity index 98%
rename from dbms/src/Storages/MergeTree/PKCondition.h
rename to dbms/src/Storages/MergeTree/KeyCondition.h
index 17f54745b39..d82b0715919 100644
--- a/dbms/src/Storages/MergeTree/PKCondition.h
+++ b/dbms/src/Storages/MergeTree/KeyCondition.h
@@ -224,16 +224,16 @@ private:
   * Constructs a reverse polish notation from these conditions
   *  and can calculate (interpret) its satisfiability over key ranges.
   */
-class PKCondition
+class KeyCondition
 {
 public:
     /// Does not take into account the SAMPLE section. all_columns - the set of all columns of the table.
-    PKCondition(
+    KeyCondition(
         const SelectQueryInfo & query_info,
         const Context & context,
         const NamesAndTypesList & all_columns,
         const SortDescription & sort_descr,
-        const ExpressionActionsPtr & pk_expr);
+        const ExpressionActionsPtr & key_expr);
 
     /// Whether the condition is feasible in the key range.
     /// left_pk and right_pk must contain all fields in the sort_descr in the appropriate order.
@@ -374,8 +374,8 @@ private:
     RPN rpn;
 
     SortDescription sort_descr;
-    ColumnIndices pk_columns;
-    ExpressionActionsPtr pk_expr;
+    ColumnIndices key_columns;
+    ExpressionActionsPtr key_expr;
     PreparedSets prepared_sets;
 };
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeData.h b/dbms/src/Storages/MergeTree/MergeTreeData.h
index 2c2ea67dc85..004bd8f9354 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeData.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeData.h
@@ -502,7 +502,7 @@ public:
     Names minmax_idx_columns;
     DataTypes minmax_idx_column_types;
     Int64 minmax_idx_date_column_pos = -1; /// In a common case minmax index includes a date column.
-    SortDescription minmax_idx_sort_descr; /// For use with PKCondition.
+    SortDescription minmax_idx_sort_descr; /// For use with KeyCondition.
 
     /// Limiting parallel sends per one table, used in DataPartsExchange
     std::atomic_uint current_table_sends {0};
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
index d8cfac7eb9e..333f9c7cc60 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp
@@ -6,7 +6,7 @@
 #include <Storages/MergeTree/MergeTreeBlockInputStream.h>
 #include <Storages/MergeTree/MergeTreeReadPool.h>
 #include <Storages/MergeTree/MergeTreeThreadBlockInputStream.h>
-#include <Storages/MergeTree/PKCondition.h>
+#include <Storages/MergeTree/KeyCondition.h>
 #include <Parsers/ASTIdentifier.h>
 #include <Parsers/ASTFunction.h>
 #include <Parsers/ASTSampleRatio.h>
@@ -85,7 +85,7 @@ static Block getBlockWithPartColumn(const MergeTreeData::DataPartsVector & parts
 
 
 size_t MergeTreeDataSelectExecutor::getApproximateTotalRowsToRead(
-    const MergeTreeData::DataPartsVector & parts, const PKCondition & key_condition, const Settings & settings) const
+    const MergeTreeData::DataPartsVector & parts, const KeyCondition & key_condition, const Settings & settings) const
 {
     size_t full_marks_count = 0;
 
@@ -198,7 +198,7 @@ BlockInputStreams MergeTreeDataSelectExecutor::read(
     const Settings & settings = context.getSettingsRef();
     SortDescription sort_descr = data.getPrimarySortDescription();
 
-    PKCondition key_condition(query_info, context, available_real_and_virtual_columns, sort_descr,
+    KeyCondition key_condition(query_info, context, available_real_and_virtual_columns, sort_descr,
         data.getPrimaryExpression());
 
     if (settings.force_primary_key && key_condition.alwaysUnknownOrTrue())
@@ -212,7 +212,7 @@ BlockInputStreams MergeTreeDataSelectExecutor::read(
         throw Exception(exception_message.str(), ErrorCodes::INDEX_NOT_USED);
     }
 
-    std::optional<PKCondition> minmax_idx_condition;
+    std::optional<KeyCondition> minmax_idx_condition;
     if (data.minmax_idx_expr)
     {
         minmax_idx_condition.emplace(
@@ -843,7 +843,7 @@ void MergeTreeDataSelectExecutor::createPositiveSignCondition(
 /// Calculates a set of mark ranges, that could possibly contain keys, required by condition.
 /// In other words, it removes subranges from whole range, that definitely could not contain required keys.
 MarkRanges MergeTreeDataSelectExecutor::markRangesFromPKRange(
-    const MergeTreeData::DataPart::Index & index, const PKCondition & key_condition, const Settings & settings) const
+    const MergeTreeData::DataPart::Index & index, const KeyCondition & key_condition, const Settings & settings) const
 {
     size_t min_marks_for_seek = (settings.merge_tree_min_rows_for_seek + data.index_granularity - 1) / data.index_granularity;
 
@@ -866,7 +866,7 @@ MarkRanges MergeTreeDataSelectExecutor::markRangesFromPKRange(
             */
         std::vector<MarkRange> ranges_stack{ {0, marks_count} };
 
-        /// NOTE Creating temporary Field objects to pass to PKCondition.
+        /// NOTE Creating temporary Field objects to pass to KeyCondition.
         Row index_left(used_key_size);
         Row index_right(used_key_size);
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
index 7bb5d8d8dfc..e40baa9c6da 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
+++ b/dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h
@@ -9,7 +9,7 @@
 namespace DB
 {
 
-class PKCondition;
+class KeyCondition;
 
 
 /** Executes SELECT queries on data from the merge tree.
@@ -60,7 +60,7 @@ private:
     /// Get the approximate value (bottom estimate - only by full marks) of the number of rows falling under the index.
     size_t getApproximateTotalRowsToRead(
         const MergeTreeData::DataPartsVector & parts,
-        const PKCondition & key_condition,
+        const KeyCondition & key_condition,
         const Settings & settings) const;
 
     /// Create the expression "Sign == 1".
@@ -71,7 +71,7 @@ private:
 
     MarkRanges markRangesFromPKRange(
         const MergeTreeData::DataPart::Index & index,
-        const PKCondition & key_condition,
+        const KeyCondition & key_condition,
         const Settings & settings) const;
 };
 
diff --git a/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp b/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
index 077ea9fed5d..3b35c127511 100644
--- a/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
+++ b/dbms/src/Storages/MergeTree/MergeTreeWhereOptimizer.cpp
@@ -1,6 +1,6 @@
 #include <Storages/MergeTree/MergeTreeWhereOptimizer.h>
 #include <Storages/MergeTree/MergeTreeData.h>
-#include <Storages/MergeTree/PKCondition.h>
+#include <Storages/MergeTree/KeyCondition.h>
 #include <Parsers/ASTSelectQuery.h>
 #include <Parsers/ASTFunction.h>
 #include <Parsers/ASTIdentifier.h>
@@ -43,7 +43,7 @@ MergeTreeWhereOptimizer::MergeTreeWhereOptimizer(
             [] (const SortColumnDescription & col) { return col.column_name; })},
         table_columns{ext::map<std::unordered_set>(data.getColumns().getAllPhysical(),
             [] (const NameAndTypePair & col) { return col.name; })},
-        block_with_constants{PKCondition::getBlockWithConstants(query_info.query, context, data.getColumns().getAllPhysical())},
+        block_with_constants{KeyCondition::getBlockWithConstants(query_info.query, context, data.getColumns().getAllPhysical())},
         prepared_sets(query_info.sets),
         log{log}
 {
@@ -321,7 +321,7 @@ bool MergeTreeWhereOptimizer::isPrimaryKeyAtom(const IAST * const ast) const
 {
     if (const auto func = typeid_cast<const ASTFunction *>(ast))
     {
-        if (!PKCondition::atom_map.count(func->name))
+        if (!KeyCondition::atom_map.count(func->name))
             return false;
 
         const auto & args = func->arguments->children;