index condition

dbms/src/Storages/MergeTree/MergeTreeDataPart.h

@@ -4,6 +4,7 @@
 #include <Core/Block.h>
 #include <Core/Types.h>
 #include <Core/NamesAndTypes.h>
+#include <Storages/MergeTree/MergeTreeIndexes.h>
 #include <Storages/MergeTree/MergeTreePartInfo.h>
 #include <Storages/MergeTree/MergeTreePartition.h>
 #include <Storages/MergeTree/MergeTreeDataPartChecksum.h>
@@ -207,6 +208,8 @@ struct MergeTreeDataPart
 
     MinMaxIndex minmax_idx;
 
+    MergeTreeIndexParts index_parts;
+
     Checksums checksums;
 
     /// Columns description.

dbms/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp

@@ -886,7 +886,8 @@ MarkRanges MergeTreeDataSelectExecutor::markRangesFromPKRange(
         Row index_left(used_key_size);
         Row index_right(used_key_size);
 
-        while (!ranges_stack.empty())
+        while (!ranges_stack.empty())/// In other words, it removes subranges from whole range, that definitely could not contain required keys.
+
         {
             MarkRange range = ranges_stack.back();
             ranges_stack.pop_back();

dbms/src/Storages/MergeTree/MergeTreeIndexes.cpp

@@ -7,8 +7,30 @@ namespace ErrorCodes
 {
     extern const int LOGICAL_ERROR;
     extern const int INCORRECT_QUERY;
+    extern const int UNKNOWN_EXCEPTION;
 }
 
+void MergeTreeIndexPart::update(const Block & block, const Names & column_names) {
+    updateImpl(block, column_names);
+}
+
+void MergeTreeIndexPart::merge(const MergeTreeIndexPart & other) {
+    if (other.indexType() != indexType()) {
+        throw Exception("MergeTreeIndexPart: Merging index part with another index type.",
+                        ErrorCodes::LOGICAL_ERROR);
+    }
+    mergeImpl(other);
+}
+
+INDEX_TYPE MergeTreeIndexPart::indexType() const {
+    return owner->indexType();
+}
+
+INDEX_TYPE IndexCondition::indexType() const {
+    return owner->indexType();
+}
+
+
 void MergeTreeIndexFactory::registerIndex(const std::string &name, Creator creator) {
     if (!indexes.emplace(name, std::move(creator)).second)
         throw Exception("MergeTreeIndexFactory: the Index creator name '" + name + "' is not unique",

dbms/src/Storages/MergeTree/MergeTreeIndexes.h

@@ -6,42 +6,74 @@
 #include <memory>
 #include <Core/Block.h>
 #include <ext/singleton.h>
+#include <Storages/SelectQueryInfo.h>
+#include <Storages/MergeTree/MarkRange.h>
 #include <Interpreters/ExpressionActions.h>
 #include <Parsers/ASTIndexDeclaration.h>
 
 namespace DB
 {
 
-enum class INDEX_TYPES {
+enum class INDEX_TYPE {
     NONE = 0
 };
 
 
 class MergeTreeIndex;
 
+using MergeTreeIndexPtr = std::shared_ptr<MergeTreeIndex>;
+using MergeTreeIndexes = std::vector<MergeTreeIndexPtr>;
 
+
+/// Data structure storing some data for each MergeTreeDataPart
 struct MergeTreeIndexPart
 {
     friend MergeTreeIndex;
 
 public:
-    virtual ~MergeTreeIndexPart() {};
+    virtual ~MergeTreeIndexPart() = default;
 
-    virtual void update(const Block & block, const Names & column_names) = 0;
+    virtual INDEX_TYPE indexType() const;
-    virtual void merge(const MergeTreeIndexPart & other) = 0;
 
-    virtual INDEX_TYPES indexType() const {
+    void update(const Block & block, const Names & column_names);
-        return INDEX_TYPES::NONE;
+    void merge(const MergeTreeIndexPart & other);
-    }
 
 protected:
-    MergeTreeIndexPart() {};
+    MergeTreeIndexPart() = default;
+
+    virtual void updateImpl(const Block & block, const Names & column_names) = 0;
+    virtual void mergeImpl(const MergeTreeIndexPart & other) = 0;
+
+    MergeTreeIndexPtr owner;
 };
 
-using MergeTreeIndexPartPtr = std::unique_ptr<MergeTreeIndexPart>;
+using MergeTreeIndexPartPtr = std::shared_ptr<MergeTreeIndexPart>;
 using MergeTreeIndexParts = std::vector<MergeTreeIndexPartPtr>;
 
 
+/// Condition on the index.
+class IndexCondition {
+    friend MergeTreeIndex;
+
+public:
+    virtual ~IndexCondition() = default;
+
+    virtual INDEX_TYPE indexType() const;
+
+    // methods like KeyCondition
+    virtual bool alwaysUnknownOrTrue() const = 0;
+    virtual bool maybeTrueInRange(const MarkRange & range) const = 0;
+
+protected:
+    IndexCondition() = default;
+
+    MergeTreeIndexPtr owner;
+};
+
+using IndexConditionPtr = std::shared_ptr<IndexCondition>;
+
+
+/// Structure for storing index info like columns, expression, arguments, ...
 class MergeTreeIndex
 {
 public:
@@ -50,22 +82,19 @@ public:
 
     virtual ~MergeTreeIndex() {};
 
-    virtual INDEX_TYPES indexType() const {
+    virtual INDEX_TYPE indexType() const = 0;
-        return INDEX_TYPES::NONE;
-    }
-
-    virtual bool alwaysUnknownOrTrue() const = 0;
-    virtual bool maybeTrueOn(MergeTreeIndexPartPtr part) const = 0;
 
     virtual MergeTreeIndexPartPtr createEmptyIndexPart() const = 0;
+    virtual IndexConditionPtr createIndexCondition(const SelectQueryInfo & query_info,
+                                                const Context & context,
+                                                const Names & key_column_names,
+                                                const ExpressionActionsPtr & key_expr) const = 0;
 
     String name;
     ExpressionActionsPtr expr;
     Block sample;
 };
 
-using MergeTreeIndexPtr = std::unique_ptr<MergeTreeIndex>;
-using MergeTreeIndexes = std::vector<MergeTreeIndexPtr>;
 
 class MergeTreeIndexFactory : public ext::singleton<MergeTreeIndexFactory>
 {
@@ -83,7 +112,7 @@ public:
     }
 
 protected:
-    MergeTreeIndexFactory() {};
+    MergeTreeIndexFactory() = default;
 
 private:
     using Indexes = std::unordered_map<std::string, Creator>;