fix code style & rename minmax, set

dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp

@@ -518,7 +518,7 @@ BlockInputStreams MergeTreeDataSelectExecutor::readFromParts(
 
     RangesInDataParts parts_with_ranges;
 
-    std::vector<std::pair<MergeTreeIndexPtr, IndexConditionPtr>> useful_indices;
+    std::vector<std::pair<MergeTreeIndexPtr, MergeTreeIndexConditionPtr>> useful_indices;
     for (const auto & index : data.skip_indices)
     {
         auto condition = index->createIndexCondition(query_info, context);
@@ -998,7 +998,7 @@ MarkRanges MergeTreeDataSelectExecutor::markRangesFromPKRange(
 
 MarkRanges MergeTreeDataSelectExecutor::filterMarksUsingIndex(
     MergeTreeIndexPtr index,
-    IndexConditionPtr condition,
+    MergeTreeIndexConditionPtr condition,
     MergeTreeData::DataPartPtr part,
     const MarkRanges & ranges,
     const Settings & settings) const

dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h

@@ -84,7 +84,7 @@ private:
 
     MarkRanges filterMarksUsingIndex(
         MergeTreeIndexPtr index,
-        IndexConditionPtr condition,
+        MergeTreeIndexConditionPtr condition,
         MergeTreeData::DataPartPtr part,
         const MarkRanges & ranges,
         const Settings & settings) const;

dbms/src/Storages/MergeTree/MergeTreeIndexBloomFilter.cpp

@@ -58,12 +58,12 @@ MergeTreeIndexAggregatorPtr MergeTreeIndexBloomFilter::createIndexAggregator() c
     return std::make_shared<MergeTreeIndexAggregatorBloomFilter>(bits_per_row, hash_functions, columns);
 }
 
-IndexConditionPtr MergeTreeIndexBloomFilter::createIndexCondition(const SelectQueryInfo & query_info, const Context & context) const
+MergeTreeIndexConditionPtr MergeTreeIndexBloomFilter::createIndexCondition(const SelectQueryInfo & query_info, const Context & context) const
 {
     return std::make_shared<MergeTreeIndexConditionBloomFilter>(query_info, context, header, hash_functions);
 }
 
-static void assertIndexColumnsType(const Block &header)
+static void assertIndexColumnsType(const Block & header)
 {
     if (!header || !header.columns())
         throw Exception("Index must have columns.", ErrorCodes::INCORRECT_QUERY);
@@ -81,7 +81,8 @@ static void assertIndexColumnsType(const Block &header)
     }
 }
 
-std::unique_ptr<IMergeTreeIndex> bloomFilterIndexCreatorNew(const NamesAndTypesList & columns, std::shared_ptr<ASTIndexDeclaration> node, const Context & context)
+std::unique_ptr<IMergeTreeIndex> bloomFilterIndexCreatorNew(
+    const NamesAndTypesList & columns, std::shared_ptr<ASTIndexDeclaration> node, const Context & context)
 {
     if (node->name.empty())
         throw Exception("Index must have unique name.", ErrorCodes::INCORRECT_QUERY);

dbms/src/Storages/MergeTree/MergeTreeIndexBloomFilter.h

@@ -19,7 +19,7 @@ public:
 
     MergeTreeIndexAggregatorPtr createIndexAggregator() const override;
 
-    IndexConditionPtr createIndexCondition(const SelectQueryInfo & query_info, const Context & context) const override;
+    MergeTreeIndexConditionPtr createIndexCondition(const SelectQueryInfo & query_info, const Context & context) const override;
 
     bool mayBenefitFromIndexForIn(const ASTPtr & node) const override;
 

dbms/src/Storages/MergeTree/MergeTreeIndexConditionBloomFilter.h

@@ -9,7 +9,7 @@
 namespace DB
 {
 
-class MergeTreeIndexConditionBloomFilter : public IIndexCondition
+class MergeTreeIndexConditionBloomFilter : public IMergeTreeIndexCondition
 {
 public:
     struct RPNElement
@@ -44,9 +44,7 @@ public:
     bool mayBeTrueOnGranule(MergeTreeIndexGranulePtr granule) const override
     {
         if (const auto & bf_granule = typeid_cast<const MergeTreeIndexGranuleBloomFilter *>(granule.get()))
-        {
             return mayBeTrueOnGranule(bf_granule);
-        }
 
         throw Exception("LOGICAL ERROR: require bloom filter index granule.", ErrorCodes::LOGICAL_ERROR);
     }
@@ -66,9 +64,11 @@ private:
 
     bool traverseASTIn(const String & function_name, const ASTPtr & key_ast, const SetPtr & prepared_set, RPNElement & out);
 
-    bool traverseASTIn(const String & function_name, const ASTPtr & key_ast, const DataTypePtr & type, const ColumnPtr & column, RPNElement & out);
+    bool traverseASTIn(
+        const String & function_name, const ASTPtr & key_ast, const DataTypePtr & type, const ColumnPtr & column, RPNElement & out);
 
-    bool traverseASTEquals(const String & function_name, const ASTPtr & key_ast, const DataTypePtr & value_type, const Field & value_field, RPNElement & out);
+    bool traverseASTEquals(
+        const String & function_name, const ASTPtr & key_ast, const DataTypePtr & value_type, const Field & value_field, RPNElement & out);
 };
 
 }

dbms/src/Storages/MergeTree/MergeTreeIndexFullText.cpp

@@ -486,7 +486,7 @@ MergeTreeIndexAggregatorPtr MergeTreeIndexFullText::createIndexAggregator() cons
     return std::make_shared<MergeTreeIndexAggregatorFullText>(*this);
 }
 
-IndexConditionPtr MergeTreeIndexFullText::createIndexCondition(
+MergeTreeIndexConditionPtr MergeTreeIndexFullText::createIndexCondition(
         const SelectQueryInfo & query, const Context & context) const
 {
     return std::make_shared<MergeTreeConditionFullText>(query, context, *this);

dbms/src/Storages/MergeTree/MergeTreeIndexFullText.h

@@ -49,7 +49,7 @@ struct MergeTreeIndexAggregatorFullText : IMergeTreeIndexAggregator
 };
 
 
-class MergeTreeConditionFullText : public IIndexCondition
+class MergeTreeConditionFullText : public IMergeTreeIndexCondition
 {
 public:
     MergeTreeConditionFullText(
@@ -189,7 +189,7 @@ public:
     MergeTreeIndexGranulePtr createIndexGranule() const override;
     MergeTreeIndexAggregatorPtr createIndexAggregator() const override;
 
-    IndexConditionPtr createIndexCondition(
+    MergeTreeIndexConditionPtr createIndexCondition(
             const SelectQueryInfo & query, const Context & context) const override;
 
     bool mayBenefitFromIndexForIn(const ASTPtr & node) const override;

dbms/src/Storages/MergeTree/MergeTreeMinMaxIndex.cpp → dbms/src/Storages/MergeTree/MergeTreeIndexMinMax.cpp

-#include <Storages/MergeTree/MergeTreeMinMaxIndex.h>
+#include <Storages/MergeTree/MergeTreeIndexMinMax.h>
 
 #include <Interpreters/ExpressionActions.h>
 #include <Interpreters/ExpressionAnalyzer.h>
@@ -16,14 +16,14 @@ namespace ErrorCodes
 }
 
 
-MergeTreeMinMaxGranule::MergeTreeMinMaxGranule(const MergeTreeMinMaxIndex & index)
+MergeTreeIndexGranuleMinMax::MergeTreeIndexGranuleMinMax(const MergeTreeIndexMinMax & index)
     : IMergeTreeIndexGranule(), index(index), parallelogram() {}
 
-MergeTreeMinMaxGranule::MergeTreeMinMaxGranule(
-    const MergeTreeMinMaxIndex & index, std::vector<Range> && parallelogram)
+MergeTreeIndexGranuleMinMax::MergeTreeIndexGranuleMinMax(
+    const MergeTreeIndexMinMax & index, std::vector<Range> && parallelogram)
     : IMergeTreeIndexGranule(), index(index), parallelogram(std::move(parallelogram)) {}
 
-void MergeTreeMinMaxGranule::serializeBinary(WriteBuffer & ostr) const
+void MergeTreeIndexGranuleMinMax::serializeBinary(WriteBuffer & ostr) const
 {
     if (empty())
         throw Exception(
@@ -50,7 +50,7 @@ void MergeTreeMinMaxGranule::serializeBinary(WriteBuffer & ostr) const
     }
 }
 
-void MergeTreeMinMaxGranule::deserializeBinary(ReadBuffer & istr)
+void MergeTreeIndexGranuleMinMax::deserializeBinary(ReadBuffer & istr)
 {
     parallelogram.clear();
     Field min_val;
@@ -83,15 +83,15 @@ void MergeTreeMinMaxGranule::deserializeBinary(ReadBuffer & istr)
 }
 
 
-MergeTreeMinMaxAggregator::MergeTreeMinMaxAggregator(const MergeTreeMinMaxIndex & index)
+MergeTreeIndexAggregatorMinMax::MergeTreeIndexAggregatorMinMax(const MergeTreeIndexMinMax & index)
     : index(index) {}
 
-MergeTreeIndexGranulePtr MergeTreeMinMaxAggregator::getGranuleAndReset()
+MergeTreeIndexGranulePtr MergeTreeIndexAggregatorMinMax::getGranuleAndReset()
 {
-    return std::make_shared<MergeTreeMinMaxGranule>(index, std::move(parallelogram));
+    return std::make_shared<MergeTreeIndexGranuleMinMax>(index, std::move(parallelogram));
 }
 
-void MergeTreeMinMaxAggregator::update(const Block & block, size_t * pos, size_t limit)
+void MergeTreeIndexAggregatorMinMax::update(const Block & block, size_t * pos, size_t limit)
 {
     if (*pos >= block.rows())
         throw Exception(
@@ -122,21 +122,21 @@ void MergeTreeMinMaxAggregator::update(const Block & block, size_t * pos, size_t
 }
 
 
-MinMaxCondition::MinMaxCondition(
+MergeTreeIndexConditionMinMax::MergeTreeIndexConditionMinMax(
     const SelectQueryInfo &query,
     const Context &context,
-    const MergeTreeMinMaxIndex &index)
-    : IIndexCondition(), index(index), condition(query, context, index.columns, index.expr) {}
+    const MergeTreeIndexMinMax &index)
+    : IMergeTreeIndexCondition(), index(index), condition(query, context, index.columns, index.expr) {}
 
-bool MinMaxCondition::alwaysUnknownOrTrue() const
+bool MergeTreeIndexConditionMinMax::alwaysUnknownOrTrue() const
 {
     return condition.alwaysUnknownOrTrue();
 }
 
-bool MinMaxCondition::mayBeTrueOnGranule(MergeTreeIndexGranulePtr idx_granule) const
+bool MergeTreeIndexConditionMinMax::mayBeTrueOnGranule(MergeTreeIndexGranulePtr idx_granule) const
 {
-    std::shared_ptr<MergeTreeMinMaxGranule> granule
-        = std::dynamic_pointer_cast<MergeTreeMinMaxGranule>(idx_granule);
+    std::shared_ptr<MergeTreeIndexGranuleMinMax> granule
+        = std::dynamic_pointer_cast<MergeTreeIndexGranuleMinMax>(idx_granule);
     if (!granule)
         throw Exception(
             "Minmax index condition got a granule with the wrong type.", ErrorCodes::LOGICAL_ERROR);
@@ -147,25 +147,25 @@ bool MinMaxCondition::mayBeTrueOnGranule(MergeTreeIndexGranulePtr idx_granule) c
 }
 
 
-MergeTreeIndexGranulePtr MergeTreeMinMaxIndex::createIndexGranule() const
+MergeTreeIndexGranulePtr MergeTreeIndexMinMax::createIndexGranule() const
 {
-    return std::make_shared<MergeTreeMinMaxGranule>(*this);
+    return std::make_shared<MergeTreeIndexGranuleMinMax>(*this);
 }
 
 
-MergeTreeIndexAggregatorPtr MergeTreeMinMaxIndex::createIndexAggregator() const
+MergeTreeIndexAggregatorPtr MergeTreeIndexMinMax::createIndexAggregator() const
 {
-    return std::make_shared<MergeTreeMinMaxAggregator>(*this);
+    return std::make_shared<MergeTreeIndexAggregatorMinMax>(*this);
 }
 
 
-IndexConditionPtr MergeTreeMinMaxIndex::createIndexCondition(
+MergeTreeIndexConditionPtr MergeTreeIndexMinMax::createIndexCondition(
     const SelectQueryInfo & query, const Context & context) const
 {
-    return std::make_shared<MinMaxCondition>(query, context, *this);
+    return std::make_shared<MergeTreeIndexConditionMinMax>(query, context, *this);
 };
 
-bool MergeTreeMinMaxIndex::mayBenefitFromIndexForIn(const ASTPtr & node) const
+bool MergeTreeIndexMinMax::mayBenefitFromIndexForIn(const ASTPtr & node) const
 {
     const String column_name = node->getColumnName();
 
@@ -210,7 +210,7 @@ std::unique_ptr<IMergeTreeIndex> minmaxIndexCreator(
         data_types.emplace_back(column.type);
     }
 
-    return std::make_unique<MergeTreeMinMaxIndex>(
+    return std::make_unique<MergeTreeIndexMinMax>(
         node->name, std::move(minmax_expr), columns, data_types, sample, node->granularity);
 }
 

dbms/src/Storages/MergeTree/MergeTreeMinMaxIndex.h → dbms/src/Storages/MergeTree/MergeTreeIndexMinMax.h

@@ -10,62 +10,62 @@
 namespace DB
 {
 
-class MergeTreeMinMaxIndex;
+class MergeTreeIndexMinMax;
 
 
-struct MergeTreeMinMaxGranule : public IMergeTreeIndexGranule
+struct MergeTreeIndexGranuleMinMax : public IMergeTreeIndexGranule
 {
-    explicit MergeTreeMinMaxGranule(const MergeTreeMinMaxIndex & index);
-    MergeTreeMinMaxGranule(const MergeTreeMinMaxIndex & index, std::vector<Range> && parallelogram);
-    ~MergeTreeMinMaxGranule() override = default;
+    explicit MergeTreeIndexGranuleMinMax(const MergeTreeIndexMinMax & index);
+    MergeTreeIndexGranuleMinMax(const MergeTreeIndexMinMax & index, std::vector<Range> && parallelogram);
+    ~MergeTreeIndexGranuleMinMax() override = default;
 
     void serializeBinary(WriteBuffer & ostr) const override;
     void deserializeBinary(ReadBuffer & istr) override;
 
     bool empty() const override { return parallelogram.empty(); }
 
-    const MergeTreeMinMaxIndex & index;
+    const MergeTreeIndexMinMax & index;
     std::vector<Range> parallelogram;
 };
 
 
-struct MergeTreeMinMaxAggregator : IMergeTreeIndexAggregator
+struct MergeTreeIndexAggregatorMinMax : IMergeTreeIndexAggregator
 {
-    explicit MergeTreeMinMaxAggregator(const MergeTreeMinMaxIndex & index);
-    ~MergeTreeMinMaxAggregator() override = default;
+    explicit MergeTreeIndexAggregatorMinMax(const MergeTreeIndexMinMax & index);
+    ~MergeTreeIndexAggregatorMinMax() override = default;
 
     bool empty() const override { return parallelogram.empty(); }
     MergeTreeIndexGranulePtr getGranuleAndReset() override;
     void update(const Block & block, size_t * pos, size_t limit) override;
 
-    const MergeTreeMinMaxIndex & index;
+    const MergeTreeIndexMinMax & index;
     std::vector<Range> parallelogram;
 };
 
 
-class MinMaxCondition : public IIndexCondition
+class MergeTreeIndexConditionMinMax : public IMergeTreeIndexCondition
 {
 public:
-    MinMaxCondition(
+    MergeTreeIndexConditionMinMax(
         const SelectQueryInfo & query,
         const Context & context,
-        const MergeTreeMinMaxIndex & index);
+        const MergeTreeIndexMinMax & index);
 
     bool alwaysUnknownOrTrue() const override;
 
     bool mayBeTrueOnGranule(MergeTreeIndexGranulePtr idx_granule) const override;
 
-    ~MinMaxCondition() override = default;
+    ~MergeTreeIndexConditionMinMax() override = default;
 private:
-    const MergeTreeMinMaxIndex & index;
+    const MergeTreeIndexMinMax & index;
     KeyCondition condition;
 };
 
 
-class MergeTreeMinMaxIndex : public IMergeTreeIndex
+class MergeTreeIndexMinMax : public IMergeTreeIndex
 {
 public:
-    MergeTreeMinMaxIndex(
+    MergeTreeIndexMinMax(
         String name_,
         ExpressionActionsPtr expr_,
         const Names & columns_,
@@ -74,12 +74,12 @@ public:
         size_t granularity_)
         : IMergeTreeIndex(name_, expr_, columns_, data_types_, header_, granularity_) {}
 
-    ~MergeTreeMinMaxIndex() override = default;
+    ~MergeTreeIndexMinMax() override = default;
 
     MergeTreeIndexGranulePtr createIndexGranule() const override;
     MergeTreeIndexAggregatorPtr createIndexAggregator() const override;
 
-    IndexConditionPtr createIndexCondition(
+    MergeTreeIndexConditionPtr createIndexCondition(
         const SelectQueryInfo & query, const Context & context) const override;
 
     bool mayBenefitFromIndexForIn(const ASTPtr & node) const override;

dbms/src/Storages/MergeTree/MergeTreeSetSkippingIndex.cpp → dbms/src/Storages/MergeTree/MergeTreeIndexSet.cpp

-#include <Storages/MergeTree/MergeTreeSetSkippingIndex.h>
+#include <Storages/MergeTree/MergeTreeIndexSet.h>
 
 #include <Interpreters/ExpressionActions.h>
 #include <Interpreters/ExpressionAnalyzer.h>
@@ -21,18 +21,18 @@ namespace ErrorCodes
 const Field UNKNOWN_FIELD(3u);
 
 
-MergeTreeSetIndexGranule::MergeTreeSetIndexGranule(const MergeTreeSetSkippingIndex & index)
+MergeTreeIndexGranuleSet::MergeTreeIndexGranuleSet(const MergeTreeIndexSet & index)
     : IMergeTreeIndexGranule()
     , index(index)
     , block(index.header.cloneEmpty()) {}
 
-MergeTreeSetIndexGranule::MergeTreeSetIndexGranule(
-    const MergeTreeSetSkippingIndex & index, MutableColumns && mutable_columns)
+MergeTreeIndexGranuleSet::MergeTreeIndexGranuleSet(
+    const MergeTreeIndexSet & index, MutableColumns && mutable_columns)
     : IMergeTreeIndexGranule()
     , index(index)
     , block(index.header.cloneWithColumns(std::move(mutable_columns))) {}
 
-void MergeTreeSetIndexGranule::serializeBinary(WriteBuffer & ostr) const
+void MergeTreeIndexGranuleSet::serializeBinary(WriteBuffer & ostr) const
 {
     if (empty())
         throw Exception(
@@ -64,7 +64,7 @@ void MergeTreeSetIndexGranule::serializeBinary(WriteBuffer & ostr) const
     }
 }
 
-void MergeTreeSetIndexGranule::deserializeBinary(ReadBuffer & istr)
+void MergeTreeIndexGranuleSet::deserializeBinary(ReadBuffer & istr)
 {
     block.clear();
 
@@ -94,7 +94,7 @@ void MergeTreeSetIndexGranule::deserializeBinary(ReadBuffer & istr)
 }
 
 
-MergeTreeSetIndexAggregator::MergeTreeSetIndexAggregator(const MergeTreeSetSkippingIndex & index)
+MergeTreeIndexAggregatorSet::MergeTreeIndexAggregatorSet(const MergeTreeIndexSet & index)
     : index(index), columns(index.header.cloneEmptyColumns())
 {
     ColumnRawPtrs column_ptrs;
@@ -111,7 +111,7 @@ MergeTreeSetIndexAggregator::MergeTreeSetIndexAggregator(const MergeTreeSetSkipp
     columns = index.header.cloneEmptyColumns();
 }
 
-void MergeTreeSetIndexAggregator::update(const Block & block, size_t * pos, size_t limit)
+void MergeTreeIndexAggregatorSet::update(const Block & block, size_t * pos, size_t limit)
 {
     if (*pos >= block.rows())
         throw Exception(
@@ -164,7 +164,7 @@ void MergeTreeSetIndexAggregator::update(const Block & block, size_t * pos, size
 }
 
 template <typename Method>
-bool MergeTreeSetIndexAggregator::buildFilter(
+bool MergeTreeIndexAggregatorSet::buildFilter(
     Method & method,
     const ColumnRawPtrs & column_ptrs,
     IColumn::Filter & filter,
@@ -190,9 +190,9 @@ bool MergeTreeSetIndexAggregator::buildFilter(
     return has_new_data;
 }
 
-MergeTreeIndexGranulePtr MergeTreeSetIndexAggregator::getGranuleAndReset()
+MergeTreeIndexGranulePtr MergeTreeIndexAggregatorSet::getGranuleAndReset()
 {
-    auto granule = std::make_shared<MergeTreeSetIndexGranule>(index, std::move(columns));
+    auto granule = std::make_shared<MergeTreeIndexGranuleSet>(index, std::move(columns));
 
     switch (data.type)
     {
@@ -212,11 +212,11 @@ MergeTreeIndexGranulePtr MergeTreeSetIndexAggregator::getGranuleAndReset()
 }
 
 
-SetIndexCondition::SetIndexCondition(
+MergeTreeIndexConditionSet::MergeTreeIndexConditionSet(
         const SelectQueryInfo & query,
         const Context & context,
-        const MergeTreeSetSkippingIndex &index)
-        : IIndexCondition(), index(index)
+        const MergeTreeIndexSet &index)
+        : IMergeTreeIndexCondition(), index(index)
 {
     for (size_t i = 0, size = index.columns.size(); i < size; ++i)
     {
@@ -253,14 +253,14 @@ SetIndexCondition::SetIndexCondition(
     actions = ExpressionAnalyzer(expression_ast, syntax_analyzer_result, context).getActions(true);
 }
 
-bool SetIndexCondition::alwaysUnknownOrTrue() const
+bool MergeTreeIndexConditionSet::alwaysUnknownOrTrue() const
 {
     return useless;
 }
 
-bool SetIndexCondition::mayBeTrueOnGranule(MergeTreeIndexGranulePtr idx_granule) const
+bool MergeTreeIndexConditionSet::mayBeTrueOnGranule(MergeTreeIndexGranulePtr idx_granule) const
 {
-    auto granule = std::dynamic_pointer_cast<MergeTreeSetIndexGranule>(idx_granule);
+    auto granule = std::dynamic_pointer_cast<MergeTreeIndexGranuleSet>(idx_granule);
     if (!granule)
         throw Exception(
                 "Set index condition got a granule with the wrong type.", ErrorCodes::LOGICAL_ERROR);
@@ -294,7 +294,7 @@ bool SetIndexCondition::mayBeTrueOnGranule(MergeTreeIndexGranulePtr idx_granule)
     return false;
 }
 
-void SetIndexCondition::traverseAST(ASTPtr & node) const
+void MergeTreeIndexConditionSet::traverseAST(ASTPtr & node) const
 {
     if (operatorFromAST(node))
     {
@@ -309,7 +309,7 @@ void SetIndexCondition::traverseAST(ASTPtr & node) const
         node = std::make_shared<ASTLiteral>(UNKNOWN_FIELD);
 }
 
-bool SetIndexCondition::atomFromAST(ASTPtr & node) const
+bool MergeTreeIndexConditionSet::atomFromAST(ASTPtr & node) const
 {
     /// Function, literal or column
 
@@ -340,7 +340,7 @@ bool SetIndexCondition::atomFromAST(ASTPtr & node) const
     return false;
 }
 
-bool SetIndexCondition::operatorFromAST(ASTPtr & node) const
+bool MergeTreeIndexConditionSet::operatorFromAST(ASTPtr & node) const
 {
     /// Functions AND, OR, NOT. Replace with bit*.
     auto * func = node->as<ASTFunction>();
@@ -416,7 +416,7 @@ static bool checkAtomName(const String & name)
     return atoms.find(name) != atoms.end();
 }
 
-bool SetIndexCondition::checkASTUseless(const ASTPtr &node, bool atomic) const
+bool MergeTreeIndexConditionSet::checkASTUseless(const ASTPtr &node, bool atomic) const
 {
     if (const auto * func = node->as<ASTFunction>())
     {
@@ -446,23 +446,23 @@ bool SetIndexCondition::checkASTUseless(const ASTPtr &node, bool atomic) const
 }
 
 
-MergeTreeIndexGranulePtr MergeTreeSetSkippingIndex::createIndexGranule() const
+MergeTreeIndexGranulePtr MergeTreeIndexSet::createIndexGranule() const
 {
-    return std::make_shared<MergeTreeSetIndexGranule>(*this);
+    return std::make_shared<MergeTreeIndexGranuleSet>(*this);
 }
 
-MergeTreeIndexAggregatorPtr MergeTreeSetSkippingIndex::createIndexAggregator() const
+MergeTreeIndexAggregatorPtr MergeTreeIndexSet::createIndexAggregator() const
 {
-    return std::make_shared<MergeTreeSetIndexAggregator>(*this);
+    return std::make_shared<MergeTreeIndexAggregatorSet>(*this);
 }
 
-IndexConditionPtr MergeTreeSetSkippingIndex::createIndexCondition(
+MergeTreeIndexConditionPtr MergeTreeIndexSet::createIndexCondition(
     const SelectQueryInfo & query, const Context & context) const
 {
-    return std::make_shared<SetIndexCondition>(query, context, *this);
+    return std::make_shared<MergeTreeIndexConditionSet>(query, context, *this);
 };
 
-bool MergeTreeSetSkippingIndex::mayBenefitFromIndexForIn(const ASTPtr &) const
+bool MergeTreeIndexSet::mayBenefitFromIndexForIn(const ASTPtr &) const
 {
     return false;
 }
@@ -506,7 +506,7 @@ std::unique_ptr<IMergeTreeIndex> setIndexCreator(
         header.insert(ColumnWithTypeAndName(column.type->createColumn(), column.type, column.name));
     }
 
-    return std::make_unique<MergeTreeSetSkippingIndex>(
+    return std::make_unique<MergeTreeIndexSet>(
         node->name, std::move(unique_expr), columns, data_types, header, node->granularity, max_rows);
 }
 

dbms/src/Storages/MergeTree/MergeTreeSetSkippingIndex.h → dbms/src/Storages/MergeTree/MergeTreeIndexSet.h

@@ -12,12 +12,12 @@
 namespace DB
 {
 
-class MergeTreeSetSkippingIndex;
+class MergeTreeIndexSet;
 
-struct MergeTreeSetIndexGranule : public IMergeTreeIndexGranule
+struct MergeTreeIndexGranuleSet : public IMergeTreeIndexGranule
 {
-    explicit MergeTreeSetIndexGranule(const MergeTreeSetSkippingIndex & index);
-    MergeTreeSetIndexGranule(const MergeTreeSetSkippingIndex & index, MutableColumns && columns);
+    explicit MergeTreeIndexGranuleSet(const MergeTreeIndexSet & index);
+    MergeTreeIndexGranuleSet(const MergeTreeIndexSet & index, MutableColumns && columns);
 
     void serializeBinary(WriteBuffer & ostr) const override;
     void deserializeBinary(ReadBuffer & istr) override;
@@ -25,17 +25,17 @@ struct MergeTreeSetIndexGranule : public IMergeTreeIndexGranule
     size_t size() const { return block.rows(); }
     bool empty() const override { return !size(); }
 
-    ~MergeTreeSetIndexGranule() override = default;
+    ~MergeTreeIndexGranuleSet() override = default;
 
-    const MergeTreeSetSkippingIndex & index;
+    const MergeTreeIndexSet & index;
     Block block;
 };
 
 
-struct MergeTreeSetIndexAggregator : IMergeTreeIndexAggregator
+struct MergeTreeIndexAggregatorSet : IMergeTreeIndexAggregator
 {
-    explicit MergeTreeSetIndexAggregator(const MergeTreeSetSkippingIndex & index);
-    ~MergeTreeSetIndexAggregator() override = default;
+    explicit MergeTreeIndexAggregatorSet(const MergeTreeIndexSet & index);
+    ~MergeTreeIndexAggregatorSet() override = default;
 
     size_t size() const { return data.getTotalRowCount(); }
     bool empty() const override { return !size(); }
@@ -55,26 +55,26 @@ private:
             size_t limit,
             ClearableSetVariants & variants) const;
 
-    const MergeTreeSetSkippingIndex & index;
+    const MergeTreeIndexSet & index;
     ClearableSetVariants data;
     Sizes key_sizes;
     MutableColumns columns;
 };
 
 
-class SetIndexCondition : public IIndexCondition
+class MergeTreeIndexConditionSet : public IMergeTreeIndexCondition
 {
 public:
-    SetIndexCondition(
+    MergeTreeIndexConditionSet(
             const SelectQueryInfo & query,
             const Context & context,
-            const MergeTreeSetSkippingIndex & index);
+            const MergeTreeIndexSet & index);
 
     bool alwaysUnknownOrTrue() const override;
 
     bool mayBeTrueOnGranule(MergeTreeIndexGranulePtr idx_granule) const override;
 
-    ~SetIndexCondition() override = default;
+    ~MergeTreeIndexConditionSet() override = default;
 private:
     void traverseAST(ASTPtr & node) const;
     bool atomFromAST(ASTPtr & node) const;
@@ -82,7 +82,7 @@ private:
 
     bool checkASTUseless(const ASTPtr &node, bool atomic = false) const;
 
-    const MergeTreeSetSkippingIndex & index;
+    const MergeTreeIndexSet & index;
 
     bool useless;
     std::set<String> key_columns;
@@ -91,10 +91,10 @@ private:
 };
 
 
-class MergeTreeSetSkippingIndex : public IMergeTreeIndex
+class MergeTreeIndexSet : public IMergeTreeIndex
 {
 public:
-    MergeTreeSetSkippingIndex(
+    MergeTreeIndexSet(
         String name_,
         ExpressionActionsPtr expr_,
         const Names & columns_,
@@ -104,12 +104,12 @@ public:
         size_t max_rows_)
         : IMergeTreeIndex(std::move(name_), std::move(expr_), columns_, data_types_, header_, granularity_), max_rows(max_rows_) {}
 
-    ~MergeTreeSetSkippingIndex() override = default;
+    ~MergeTreeIndexSet() override = default;
 
     MergeTreeIndexGranulePtr createIndexGranule() const override;
     MergeTreeIndexAggregatorPtr createIndexAggregator() const override;
 
-    IndexConditionPtr createIndexCondition(
+    MergeTreeIndexConditionPtr createIndexCondition(
             const SelectQueryInfo & query, const Context & context) const override;
 
     bool mayBenefitFromIndexForIn(const ASTPtr & node) const override;

dbms/src/Storages/MergeTree/MergeTreeIndices.h

@@ -59,17 +59,17 @@ using MergeTreeIndexAggregators = std::vector<MergeTreeIndexAggregatorPtr>;
 
 
 /// Condition on the index.
-class IIndexCondition
+class IMergeTreeIndexCondition
 {
 public:
-    virtual ~IIndexCondition() = default;
+    virtual ~IMergeTreeIndexCondition() = default;
     /// Checks if this index is useful for query.
     virtual bool alwaysUnknownOrTrue() const = 0;
 
     virtual bool mayBeTrueOnGranule(MergeTreeIndexGranulePtr granule) const = 0;
 };
 
-using IndexConditionPtr = std::shared_ptr<IIndexCondition>;
+using MergeTreeIndexConditionPtr = std::shared_ptr<IMergeTreeIndexCondition>;
 
 
 /// Structure for storing basic index info like columns, expression, arguments, ...
@@ -101,7 +101,7 @@ public:
     virtual MergeTreeIndexGranulePtr createIndexGranule() const = 0;
     virtual MergeTreeIndexAggregatorPtr createIndexAggregator() const = 0;
 
-    virtual IndexConditionPtr createIndexCondition(
+    virtual MergeTreeIndexConditionPtr createIndexCondition(
             const SelectQueryInfo & query_info, const Context & context) const = 0;
 
     String name;

dbms/src/Storages/MergeTree/registerStorageMergeTree.cpp

@@ -2,8 +2,8 @@
 #include <Storages/StorageMergeTree.h>
 #include <Storages/StorageReplicatedMergeTree.h>
 #include <Storages/MergeTree/MergeTreeIndices.h>
-#include <Storages/MergeTree/MergeTreeMinMaxIndex.h>
-#include <Storages/MergeTree/MergeTreeSetSkippingIndex.h>
+#include <Storages/MergeTree/MergeTreeIndexMinMax.h>
+#include <Storages/MergeTree/MergeTreeIndexSet.h>
 
 #include <Common/typeid_cast.h>
 #include <Common/OptimizedRegularExpression.h>