Fixed merge issues

dbms/src/Storages/MergeTree/MergeTreeData.cpp

@@ -3124,7 +3124,7 @@ MergeTreeData::MutableDataPartsVector MergeTreeData::tryLoadPartsToAttach(const
 namespace
 {
 
-inline DiskSpace::ReservationPtr checkAndReturnReservation(UInt64 expected_size, ReservationPtr reservation)
+inline ReservationPtr checkAndReturnReservation(UInt64 expected_size, ReservationPtr reservation)
 {
     if (reservation)
         return reservation;
@@ -3135,7 +3135,7 @@ inline DiskSpace::ReservationPtr checkAndReturnReservation(UInt64 expected_size,
 
 }
 
-DiskSpace::ReservationPtr MergeTreeData::reserveSpace(UInt64 expected_size) const
+ReservationPtr MergeTreeData::reserveSpace(UInt64 expected_size) const
 {
     expected_size = std::max(RESERVATION_MIN_ESTIMATION_SIZE, expected_size);
 
@@ -3144,7 +3144,7 @@ DiskSpace::ReservationPtr MergeTreeData::reserveSpace(UInt64 expected_size) cons
     return checkAndReturnReservation(expected_size, std::move(reservation));
 }
 
-DiskSpace::ReservationPtr MergeTreeData::reserveSpace(UInt64 expected_size, DiskSpace::SpacePtr space) const
+ReservationPtr MergeTreeData::reserveSpace(UInt64 expected_size, SpacePtr space) const
 {
     expected_size = std::max(RESERVATION_MIN_ESTIMATION_SIZE, expected_size);
 
@@ -3153,36 +3153,36 @@ DiskSpace::ReservationPtr MergeTreeData::reserveSpace(UInt64 expected_size, Disk
     return checkAndReturnReservation(expected_size, std::move(reservation));
 }
 
-DiskSpace::ReservationPtr MergeTreeData::tryReserveSpace(UInt64 expected_size, DiskSpace::SpacePtr space) const
+ReservationPtr MergeTreeData::tryReserveSpace(UInt64 expected_size, SpacePtr space) const
 {
     expected_size = std::max(RESERVATION_MIN_ESTIMATION_SIZE, expected_size);
 
     return space->reserve(expected_size);
 }
 
-DiskSpace::ReservationPtr MergeTreeData::reserveSpacePreferringTTLRules(UInt64 expected_size,
+ReservationPtr MergeTreeData::reserveSpacePreferringTTLRules(UInt64 expected_size,
         const MergeTreeDataPart::TTLInfos & ttl_infos,
         time_t time_of_move) const
 {
     expected_size = std::max(RESERVATION_MIN_ESTIMATION_SIZE, expected_size);
 
-    DiskSpace::ReservationPtr reservation = tryReserveSpacePreferringTTLRules(expected_size, ttl_infos, time_of_move);
+    ReservationPtr reservation = tryReserveSpacePreferringTTLRules(expected_size, ttl_infos, time_of_move);
 
     return checkAndReturnReservation(expected_size, std::move(reservation));
 }
 
-DiskSpace::ReservationPtr MergeTreeData::tryReserveSpacePreferringTTLRules(UInt64 expected_size,
+ReservationPtr MergeTreeData::tryReserveSpacePreferringTTLRules(UInt64 expected_size,
         const MergeTreeDataPart::TTLInfos & ttl_infos,
         time_t time_of_move) const
 {
     expected_size = std::max(RESERVATION_MIN_ESTIMATION_SIZE, expected_size);
 
-    DiskSpace::ReservationPtr reservation;
+    ReservationPtr reservation;
 
     auto ttl_entry = selectTTLEntryForTTLInfos(ttl_infos, time_of_move);
     if (ttl_entry != nullptr)
     {
-        DiskSpace::SpacePtr destination_ptr = ttl_entry->getDestination(storage_policy);
+        SpacePtr destination_ptr = ttl_entry->getDestination(storage_policy);
         if (!destination_ptr)
         {
             if (ttl_entry->destination_type == PartDestinationType::VOLUME)
@@ -3207,7 +3207,7 @@ DiskSpace::ReservationPtr MergeTreeData::tryReserveSpacePreferringTTLRules(UInt6
     return reservation;
 }
 
-DiskSpace::SpacePtr MergeTreeData::TTLEntry::getDestination(const DiskSpace::StoragePolicyPtr & policy) const
+SpacePtr MergeTreeData::TTLEntry::getDestination(const StoragePolicyPtr & policy) const
 {
     if (destination_type == PartDestinationType::VOLUME)
         return policy->getVolumeByName(destination_name);
@@ -3217,7 +3217,7 @@ DiskSpace::SpacePtr MergeTreeData::TTLEntry::getDestination(const DiskSpace::Sto
         return {};
 }
 
-bool MergeTreeData::TTLEntry::isPartInDestination(const DiskSpace::StoragePolicyPtr & policy, const MergeTreeDataPart & part) const
+bool MergeTreeData::TTLEntry::isPartInDestination(const StoragePolicyPtr & policy, const MergeTreeDataPart & part) const
 {
     if (destination_type == PartDestinationType::VOLUME)
     {

dbms/src/Storages/MergeTree/MergeTreeData.h

 #pragma once
 
 #include <Common/SimpleIncrement.h>
-#include <Common/DiskSpaceMonitor.h>
 #include <Interpreters/Context.h>
 #include <Interpreters/ExpressionActions.h>
 #include <Storages/IStorage.h>
@@ -679,14 +678,14 @@ public:
     ReservationPtr reserveSpace(UInt64 expected_size) const;
 
     /// Reserves space at least 1MB on specific disk or volume.
-    DiskSpace::ReservationPtr reserveSpace(UInt64 expected_size, DiskSpace::SpacePtr space) const;
-    DiskSpace::ReservationPtr tryReserveSpace(UInt64 expected_size, DiskSpace::SpacePtr space) const;
+    ReservationPtr reserveSpace(UInt64 expected_size, SpacePtr space) const;
+    ReservationPtr tryReserveSpace(UInt64 expected_size, SpacePtr space) const;
 
     /// Reserves space at least 1MB preferring best destination according to `ttl_infos`.
-    DiskSpace::ReservationPtr reserveSpacePreferringTTLRules(UInt64 expected_size,
+    ReservationPtr reserveSpacePreferringTTLRules(UInt64 expected_size,
                                                                 const MergeTreeDataPart::TTLInfos & ttl_infos,
                                                                 time_t time_of_move) const;
-    DiskSpace::ReservationPtr tryReserveSpacePreferringTTLRules(UInt64 expected_size,
+    ReservationPtr tryReserveSpacePreferringTTLRules(UInt64 expected_size,
                                                                 const MergeTreeDataPart::TTLInfos & ttl_infos,
                                                                 time_t time_of_move) const;
     /// Choose disk with max available free space
@@ -740,10 +739,10 @@ public:
         ASTPtr entry_ast;
 
         /// Returns destination disk or volume for this rule.
-        DiskSpace::SpacePtr getDestination(const DiskSpace::StoragePolicyPtr & policy) const;
+        SpacePtr getDestination(const StoragePolicyPtr & policy) const;
 
         /// Checks if given part already belongs destination disk or volume for this rule.
-        bool isPartInDestination(const DiskSpace::StoragePolicyPtr & policy, const MergeTreeDataPart & part) const;
+        bool isPartInDestination(const StoragePolicyPtr & policy, const MergeTreeDataPart & part) const;
     };
 
     const TTLEntry * selectTTLEntryForTTLInfos(const MergeTreeDataPart::TTLInfos & ttl_infos, time_t time_of_move) const;

dbms/src/Storages/MergeTree/MergeTreeDataWriter.cpp

@@ -228,7 +228,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataWriter::writeTempPart(BlockWithPa
     for (const auto & ttl_entry : data.move_ttl_entries)
         updateTTL(ttl_entry, move_ttl_infos, move_ttl_infos.moves_ttl[ttl_entry.result_column], block, false);
 
-    DiskSpace::ReservationPtr reservation = data.reserveSpacePreferringTTLRules(expected_size, move_ttl_infos, time(nullptr));
+    ReservationPtr reservation = data.reserveSpacePreferringTTLRules(expected_size, move_ttl_infos, time(nullptr));
 
     MergeTreeData::MutableDataPartPtr new_data_part =
         std::make_shared<MergeTreeData::DataPart>(data, reservation->getDisk(), part_name, new_part_info);

dbms/src/Storages/MergeTree/MergeTreePartsMover.cpp

@@ -125,7 +125,7 @@ bool MergeTreePartsMover::selectPartsForMove(
 
         const MergeTreeData::TTLEntry * ttl_entry_ptr = part->storage.selectTTLEntryForTTLInfos(part->ttl_infos, time_of_move);
         auto to_insert = need_to_move.find(part->disk);
-        DiskSpace::ReservationPtr reservation;
+        ReservationPtr reservation;
         if (ttl_entry_ptr)
         {
             auto destination = ttl_entry_ptr->getDestination(policy);