Backport #87140 to 25.7: fix: fix server level max temporary size limit

robot-clickhouse · robot-clickhouse · commit fce211ff07ed · 2025-09-22T11:10:50.000Z
diff --git a/src/Interpreters/Aggregator.cpp b/src/Interpreters/Aggregator.cpp
@@ -1762,7 +1762,7 @@ void Aggregator::writeToTemporaryFile(AggregatedDataVariants & data_variants, si
     auto & out_stream = [this, max_temp_file_size]() -> TemporaryBlockStreamHolder &
     {
         std::lock_guard lk(tmp_files_mutex);
-        return tmp_files.emplace_back(std::make_shared<const Block>(getHeader(false)), tmp_data.get(), max_temp_file_size);
+        return tmp_files.emplace_back(std::make_shared<const Block>(getHeader(false)), tmp_data, max_temp_file_size);
     }();
 
     ProfileEvents::increment(ProfileEvents::ExternalAggregationWritePart);
diff --git a/src/Interpreters/GraceHashJoin.cpp b/src/Interpreters/GraceHashJoin.cpp
@@ -386,8 +386,8 @@ void GraceHashJoin::addBuckets(const size_t bucket_count)
     for (size_t i = 0; i < bucket_count; ++i)
         try
         {
-            TemporaryBlockStreamHolder left_file(left_sample_block, tmp_data.get());
-            TemporaryBlockStreamHolder right_file(std::make_shared<const Block>(prepareRightBlock(*right_sample_block)), tmp_data.get());
+            TemporaryBlockStreamHolder left_file(left_sample_block, tmp_data);
+            TemporaryBlockStreamHolder right_file(std::make_shared<const Block>(prepareRightBlock(*right_sample_block)), tmp_data);
 
             BucketPtr new_bucket = std::make_shared<FileBucket>(current_size + i, std::move(left_file), std::move(right_file), log);
             tmp_buckets.emplace_back(std::move(new_bucket));
diff --git a/src/Interpreters/HashJoin/HashJoin.cpp b/src/Interpreters/HashJoin/HashJoin.cpp
@@ -655,7 +655,7 @@ bool HashJoin::addBlockToJoin(ScatteredBlock & source_block, bool check_limits)
             || (max_rows_in_join && getTotalRowCount() + block_to_save.rows() >= max_rows_in_join)))
     {
         if (!tmp_stream)
-            tmp_stream.emplace(std::make_shared<const Block>(right_sample_block), tmp_data.get());
+            tmp_stream.emplace(std::make_shared<const Block>(right_sample_block), tmp_data);
 
         chassert(!source_block.wasScattered()); /// We don't run parallel_hash for cross join
         tmp_stream.value()->write(block_to_save);
diff --git a/src/Interpreters/SortedBlocksWriter.cpp b/src/Interpreters/SortedBlocksWriter.cpp
@@ -40,7 +40,7 @@ void updateProfileEvents(TemporaryDataBuffer::Stat stat)
 
 TemporaryBlockStreamHolder flushBlockToFile(const TemporaryDataOnDiskScopePtr & tmp_data, const Block & block)
 {
-    TemporaryBlockStreamHolder stream_holder(std::make_shared<const Block>(block.cloneEmpty()), tmp_data.get());
+    TemporaryBlockStreamHolder stream_holder(std::make_shared<const Block>(block.cloneEmpty()), tmp_data);
     stream_holder->write(block);
 
     auto stat = stream_holder.finishWriting();
@@ -52,7 +52,7 @@ TemporaryBlockStreamHolder flushBlockToFile(const TemporaryDataOnDiskScopePtr &
 
 TemporaryBlockStreamHolder flushToFile(const TemporaryDataOnDiskScopePtr & tmp_data, const Block & header, QueryPipelineBuilder pipeline)
 {
-    TemporaryBlockStreamHolder stream_holder(std::make_shared<const Block>(header), tmp_data.get());
+    TemporaryBlockStreamHolder stream_holder(std::make_shared<const Block>(header), tmp_data);
 
     auto exec_pipeline = QueryPipelineBuilder::getPipeline(std::move(pipeline));
     PullingPipelineExecutor executor(exec_pipeline);
diff --git a/src/Interpreters/TemporaryDataOnDisk.cpp b/src/Interpreters/TemporaryDataOnDisk.cpp
@@ -219,7 +219,7 @@ bool TemporaryDataReadBuffer::nextImpl()
     return true;
 }
 
-TemporaryDataBuffer::TemporaryDataBuffer(TemporaryDataOnDiskScope * parent_, size_t reserve_size)
+TemporaryDataBuffer::TemporaryDataBuffer(std::shared_ptr<TemporaryDataOnDiskScope> parent_, size_t reserve_size)
     : WriteBuffer(nullptr, 0)
     , parent(parent_)
     , file_holder(parent->file_provider(reserve_size))
@@ -313,6 +313,15 @@ void TemporaryDataBuffer::updateAllocAndCheck()
     stat.uncompressed_size = new_uncompressed_size;
 }
 
+
+void TemporaryDataBuffer::freeAlloc()
+{
+    if (parent)
+        parent->deltaAllocAndCheck(-stat.compressed_size, -stat.uncompressed_size);
+    stat.compressed_size = 0;
+    stat.uncompressed_size = 0;
+}
+
 void TemporaryDataOnDiskScope::deltaAllocAndCheck(ssize_t compressed_delta, ssize_t uncompressed_delta)
 {
     if (parent)
@@ -334,7 +343,7 @@ void TemporaryDataOnDiskScope::deltaAllocAndCheck(ssize_t compressed_delta, ssiz
     stat.uncompressed_size += uncompressed_delta;
 }
 
-TemporaryBlockStreamHolder::TemporaryBlockStreamHolder(SharedHeader header_, TemporaryDataOnDiskScope * parent_, size_t reserve_size)
+TemporaryBlockStreamHolder::TemporaryBlockStreamHolder(SharedHeader header_, std::shared_ptr<TemporaryDataOnDiskScope> parent_, size_t reserve_size)
     : WrapperGuard(std::make_unique<TemporaryDataBuffer>(parent_, reserve_size), DBMS_TCP_PROTOCOL_VERSION, header_)
 {
     /// Constant columns must be avoided since they are not supported in (de/)serialization, but we have to keep lazy columns
@@ -363,5 +372,6 @@ TemporaryDataBuffer::~TemporaryDataBuffer()
 {
     if (!finalized)
         cancel();
+    freeAlloc();
 }
 }
diff --git a/src/Interpreters/TemporaryDataOnDisk.h b/src/Interpreters/TemporaryDataOnDisk.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <atomic>
+#include <memory>
 #include <mutex>
 #include <boost/noncopyable.hpp>
 
@@ -184,7 +185,7 @@ class TemporaryDataBuffer : public WriteBuffer
         size_t uncompressed_size = 0;
     };
 
-    explicit TemporaryDataBuffer(TemporaryDataOnDiskScope * parent_, size_t reserve_size = 0);
+    explicit TemporaryDataBuffer(std::shared_ptr<TemporaryDataOnDiskScope> parent_, size_t reserve_size = 0);
     ~TemporaryDataBuffer() override;
 
     void nextImpl() override;
@@ -198,8 +199,9 @@ class TemporaryDataBuffer : public WriteBuffer
 
 private:
     void updateAllocAndCheck();
+    void freeAlloc();
 
-    TemporaryDataOnDiskScope * parent;
+    std::shared_ptr<TemporaryDataOnDiskScope> parent;
     std::unique_ptr<TemporaryFileHolder> file_holder;
     WrapperGuard<CompressedWriteBuffer, WriteBuffer> out_compressed_buf;
     std::once_flag write_finished;
@@ -214,7 +216,7 @@ using TemporaryBlockStreamReaderHolder = WrapperGuard<NativeReader, ReadBuffer>;
 class TemporaryBlockStreamHolder : public WrapperGuard<NativeWriter, TemporaryDataBuffer>
 {
 public:
-    TemporaryBlockStreamHolder(SharedHeader header_, TemporaryDataOnDiskScope * parent_, size_t reserve_size = 0);
+    TemporaryBlockStreamHolder(SharedHeader header_, std::shared_ptr<TemporaryDataOnDiskScope> parent_, size_t reserve_size = 0);
 
     TemporaryBlockStreamReaderHolder getReadStream() const;
 
diff --git a/src/Interpreters/tests/gtest_filecache.cpp b/src/Interpreters/tests/gtest_filecache.cpp
@@ -1015,13 +1015,13 @@ try
 
 
     {
-        TemporaryBlockStreamHolder stream(std::make_shared<const Block>(generateBlock()), tmp_data_scope.get());
+        TemporaryBlockStreamHolder stream(std::make_shared<const Block>(generateBlock()), tmp_data_scope);
         ASSERT_TRUE(stream);
         /// Do nothing with stream, just create it and destroy.
     }
 
     {
-        TemporaryBlockStreamHolder stream(std::make_shared<const Block>(generateBlock()), tmp_data_scope.get());
+        TemporaryBlockStreamHolder stream(std::make_shared<const Block>(generateBlock()), tmp_data_scope);
         ASSERT_GT(stream->write(generateBlock(100)), 0);
 
         ASSERT_GT(file_cache.getUsedCacheSize(), 0);
@@ -1041,7 +1041,7 @@ try
 
     {
         size_t before_used_size = file_cache.getUsedCacheSize();
-        auto write_buf_stream = std::make_unique<TemporaryDataBuffer>(tmp_data_scope.get());
+        auto write_buf_stream = std::make_unique<TemporaryDataBuffer>(tmp_data_scope);
 
         write_buf_stream->write("1234567890", 10);
         write_buf_stream->write("abcde", 5);
@@ -1058,7 +1058,7 @@ try
     }
 
     {
-        TemporaryBlockStreamHolder stream(std::make_shared<const Block>(generateBlock()), tmp_data_scope.get());
+        TemporaryBlockStreamHolder stream(std::make_shared<const Block>(generateBlock()), tmp_data_scope);
 
         ASSERT_GT(stream->write(generateBlock(100)), 0);
 
@@ -1193,7 +1193,7 @@ TEST_F(FileCacheTest, TemporaryDataReadBufferSize)
         auto tmp_data_scope = std::make_shared<TemporaryDataOnDiskScope>(&file_cache, TemporaryDataOnDiskSettings{});
 
         auto block = generateBlock(/*size=*/3);
-        TemporaryBlockStreamHolder stream(std::make_shared<const Block>(block), tmp_data_scope.get());
+        TemporaryBlockStreamHolder stream(std::make_shared<const Block>(block), tmp_data_scope);
 
         stream->write(block);
         auto stat = stream.finishWriting();
@@ -1219,7 +1219,7 @@ TEST_F(FileCacheTest, TemporaryDataReadBufferSize)
         auto tmp_data_scope = std::make_shared<TemporaryDataOnDiskScope>(volume, TemporaryDataOnDiskSettings{});
 
         auto block = generateBlock(/*size=*/3);
-        TemporaryBlockStreamHolder stream(std::make_shared<const Block>(block), tmp_data_scope.get());
+        TemporaryBlockStreamHolder stream(std::make_shared<const Block>(block), tmp_data_scope);
         stream->write(block);
         auto stat = stream.finishWriting();
 
diff --git a/src/Processors/Transforms/MergeSortingTransform.cpp b/src/Processors/Transforms/MergeSortingTransform.cpp
@@ -243,7 +243,7 @@ void MergeSortingTransform::consume(Chunk chunk)
             /// If there's less free disk space than reserve_size, an exception will be thrown
             size_t reserve_size = sum_bytes_in_blocks + min_free_disk_space;
             SharedHeader shared_header_without_constants = std::make_shared<const Block>(header_without_constants);
-            TemporaryBlockStreamHolder tmp_stream(shared_header_without_constants, tmp_data.get(), reserve_size);
+            TemporaryBlockStreamHolder tmp_stream(shared_header_without_constants, tmp_data, reserve_size);
             size_t max_merged_block_size = this->max_merged_block_size;
             if (max_block_bytes > 0 && sum_rows_in_blocks > 0 && sum_bytes_in_blocks > 0)
             {
diff --git a/src/Server/HTTPHandler.cpp b/src/Server/HTTPHandler.cpp
@@ -384,7 +384,7 @@ void HTTPHandler::processQuery(
             auto tmp_data = server.context()->getTempDataOnDisk();
             cascade_buffers_lazy.emplace_back([tmp_data](const WriteBufferPtr &) -> WriteBufferPtr
             {
-                return std::make_unique<TemporaryDataBuffer>(tmp_data.get());
+                return std::make_unique<TemporaryDataBuffer>(tmp_data);
             });
         }
         else
diff --git a/src/Storages/MergeTree/MergeTask.cpp b/src/Storages/MergeTree/MergeTask.cpp
@@ -192,7 +192,7 @@ class RowsSourcesTemporaryFile : public ITemporaryFileLookup
         if (tmp_data_buffer)
             throw Exception(ErrorCodes::LOGICAL_ERROR, "Temporary file was already requested for writing, there musto be only one writer");
 
-        tmp_data_buffer = std::make_unique<TemporaryDataBuffer>(temporary_data_on_disk.get());
+        tmp_data_buffer = std::make_unique<TemporaryDataBuffer>(temporary_data_on_disk);
         return *tmp_data_buffer;
     }
 
diff --git a/tests/queries/0_stateless/03622_max_temporary_data_size_on_disk.config.xml b/tests/queries/0_stateless/03622_max_temporary_data_size_on_disk.config.xml
@@ -0,0 +1,35 @@
+<clickhouse>
+    <max_temporary_data_on_disk_size>10240</max_temporary_data_on_disk_size>
+    <logger>
+        <level>trace</level>
+        <console>true</console>
+    </logger>
+
+    <tcp_port>9000</tcp_port>
+
+    <path>./</path>
+
+    <mark_cache_size>0</mark_cache_size>
+
+    <users>
+        <default>
+            <password></password>
+
+            <networks>
+                <ip>::/0</ip>
+            </networks>
+
+            <profile>default</profile>
+            <quota>default</quota>
+            <access_management>1</access_management>
+        </default>
+    </users>
+
+    <profiles>
+        <default/>
+    </profiles>
+
+    <quotas>
+        <default />
+    </quotas>
+</clickhouse>
diff --git a/tests/queries/0_stateless/03622_max_temporary_data_size_on_disk.reference b/tests/queries/0_stateless/03622_max_temporary_data_size_on_disk.reference
diff --git a/tests/queries/0_stateless/03622_max_temporary_data_size_on_disk.sh b/tests/queries/0_stateless/03622_max_temporary_data_size_on_disk.sh
@@ -0,0 +1,72 @@
+#!/usr/bin/env bash
+# Tags: long, no-parallel
+
+CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+# shellcheck source=../shell_config.sh
+. "$CUR_DIR"/../shell_config.sh
+
+server_opts=(
+    "--config-file=$CUR_DIR/03622_max_temporary_data_size_on_disk.config.xml"
+    "--"
+    # to avoid multiple listen sockets (complexity for port discovering)
+    "--listen_host=127.1"
+    # we will discover the real port later.
+    "--tcp_port=0"
+    "--shutdown_wait_unfinished=0"
+)
+CLICKHOUSE_WATCHDOG_ENABLE=0 $CLICKHOUSE_SERVER_BINARY "${server_opts[@]}" >& clickhouse-server.log &
+server_pid=$!
+
+trap cleanup EXIT
+# Shellcheck wrongly process "trap" https://www.shellcheck.net/wiki/SC2317
+# shellcheck disable=SC2317
+function cleanup()
+{
+    kill -9 "$server_pid"
+    kill -9 "$client_pid"
+
+    echo "Test failed. Server log:"
+    cat clickhouse-server.log
+    rm -f clickhouse-server.log
+
+    exit 1
+}
+
+server_port=
+i=0 retries=300
+# wait until server will start to listen (max 30 seconds)
+while [[ -z $server_port ]] && [[ $i -lt $retries ]]; do
+    server_port=$(lsof -n -a -P -i tcp -s tcp:LISTEN -p $server_pid 2>/dev/null | awk -F'[ :]' '/LISTEN/ { print $(NF-1) }')
+    ((++i))
+    sleep 0.1
+done
+if [[ -z $server_port ]]; then
+    echo "Cannot wait for LISTEN socket" >&2
+    exit 1
+fi
+
+# wait for the server to start accepting tcp connections (max 30 seconds)
+i=0 retries=300
+while ! $CLICKHOUSE_CLIENT_BINARY --host 127.1 --port "$server_port" --format Null -q 'select 1' 2>/dev/null && [[ $i -lt $retries ]]; do
+    sleep 0.1
+done
+if ! $CLICKHOUSE_CLIENT_BINARY --host 127.1 --port "$server_port" --format Null -q 'select 1'; then
+    echo "Cannot wait until server will start accepting connections on <tcp_port>" >&2
+    exit 1
+fi
+
+$CLICKHOUSE_CLIENT_BINARY --host 127.1 --port "$server_port" --format Null -q 'DROP TABLE IF EXISTS default.t_proj_external'
+$CLICKHOUSE_CLIENT_BINARY --host 127.1 --port "$server_port" --format Null -q 'CREATE TABLE default.t_proj_external ( `k1` UInt32, `k2` UInt32, `k3` UInt32, `value` UInt32 ) ENGINE = MergeTree ORDER BY tuple() SETTINGS index_granularity = 8192'
+$CLICKHOUSE_CLIENT_BINARY --host 127.1 --port "$server_port" --format Null -q 'INSERT INTO t_proj_external SELECT 1, number%2, number%4, number FROM numbers(50000)'
+
+for i in {1..10}
+do
+    $CLICKHOUSE_CLIENT_BINARY --host 127.1 --port "$server_port" --format Null -q 'SELECT k1, k2, k3, sum(value) v FROM t_proj_external GROUP BY k1, k2, k3 ORDER BY k1, k2, k3 SETTINGS optimize_aggregation_in_order = 0, max_bytes_before_external_group_by = 1, max_bytes_ratio_before_external_group_by = 0, group_by_two_level_threshold = 1'
+done
+$CLICKHOUSE_CLIENT_BINARY --host 127.1 --port "$server_port" --format Null -q 'DROP TABLE IF EXISTS default.t_proj_external'
+
+# send TERM and save the error code to ensure that it is 0 (EXIT_SUCCESS)
+kill $server_pid
+wait $server_pid
+
+trap '' EXIT

Original file line number	Diff line number	Diff line change
`@@ -1762,7 +1762,7 @@ void Aggregator::writeToTemporaryFile(AggregatedDataVariants & data_variants, si`
`1762`	`1762`	`auto & out_stream = [this, max_temp_file_size]() -> TemporaryBlockStreamHolder &`
`1763`	`1763`	`{`
`1764`	`1764`	`std::lock_guard lk(tmp_files_mutex);`
`1765`		`- return tmp_files.emplace_back(std::make_shared<const Block>(getHeader(false)), tmp_data.get(), max_temp_file_size);`
	`1765`	`+ return tmp_files.emplace_back(std::make_shared<const Block>(getHeader(false)), tmp_data, max_temp_file_size);`
`1766`	`1766`	`}();`
`1767`	`1767`
`1768`	`1768`	`ProfileEvents::increment(ProfileEvents::ExternalAggregationWritePart);`
Original file line number	Diff line number	Diff line change
`@@ -655,7 +655,7 @@ bool HashJoin::addBlockToJoin(ScatteredBlock & source_block, bool check_limits)`
`655`	`655`	`\|\| (max_rows_in_join && getTotalRowCount() + block_to_save.rows() >= max_rows_in_join)))`
`656`	`656`	`{`
`657`	`657`	`if (!tmp_stream)`
`658`		`- tmp_stream.emplace(std::make_shared<const Block>(right_sample_block), tmp_data.get());`
	`658`	`+ tmp_stream.emplace(std::make_shared<const Block>(right_sample_block), tmp_data);`
`659`	`659`
`660`	`660`	`chassert(!source_block.wasScattered()); /// We don't run parallel_hash for cross join`
`661`	`661`	`tmp_stream.value()->write(block_to_save);`
Original file line number	Diff line number	Diff line change
`@@ -40,7 +40,7 @@ void updateProfileEvents(TemporaryDataBuffer::Stat stat)`
`40`	`40`
`41`	`41`	`TemporaryBlockStreamHolder flushBlockToFile(const TemporaryDataOnDiskScopePtr & tmp_data, const Block & block)`
`42`	`42`	`{`
`43`		`- TemporaryBlockStreamHolder stream_holder(std::make_shared<const Block>(block.cloneEmpty()), tmp_data.get());`
	`43`	`+ TemporaryBlockStreamHolder stream_holder(std::make_shared<const Block>(block.cloneEmpty()), tmp_data);`
`44`	`44`	`stream_holder->write(block);`
`45`	`45`
`46`	`46`	`auto stat = stream_holder.finishWriting();`
`@@ -52,7 +52,7 @@ TemporaryBlockStreamHolder flushBlockToFile(const TemporaryDataOnDiskScopePtr &`
`52`	`52`
`53`	`53`	`TemporaryBlockStreamHolder flushToFile(const TemporaryDataOnDiskScopePtr & tmp_data, const Block & header, QueryPipelineBuilder pipeline)`
`54`	`54`	`{`
`55`		`- TemporaryBlockStreamHolder stream_holder(std::make_shared<const Block>(header), tmp_data.get());`
	`55`	`+ TemporaryBlockStreamHolder stream_holder(std::make_shared<const Block>(header), tmp_data);`
`56`	`56`
`57`	`57`	`auto exec_pipeline = QueryPipelineBuilder::getPipeline(std::move(pipeline));`
`58`	`58`	`PullingPipelineExecutor executor(exec_pipeline);`
Original file line number	Diff line number	Diff line change
`@@ -219,7 +219,7 @@ bool TemporaryDataReadBuffer::nextImpl()`
`219`	`219`	`return true;`
`220`	`220`	`}`
`221`	`221`
`222`		`-TemporaryDataBuffer::TemporaryDataBuffer(TemporaryDataOnDiskScope * parent_, size_t reserve_size)`
	`222`	`+TemporaryDataBuffer::TemporaryDataBuffer(std::shared_ptr<TemporaryDataOnDiskScope> parent_, size_t reserve_size)`
`223`	`223`	`: WriteBuffer(nullptr, 0)`
`224`	`224`	`, parent(parent_)`
`225`	`225`	`, file_holder(parent->file_provider(reserve_size))`
`@@ -313,6 +313,15 @@ void TemporaryDataBuffer::updateAllocAndCheck()`
`313`	`313`	`stat.uncompressed_size = new_uncompressed_size;`
`314`	`314`	`}`
`315`	`315`
	`316`	`+`
	`317`	`+void TemporaryDataBuffer::freeAlloc()`
	`318`	`+{`
	`319`	`+ if (parent)`
	`320`	`+ parent->deltaAllocAndCheck(-stat.compressed_size, -stat.uncompressed_size);`
	`321`	`+ stat.compressed_size = 0;`
	`322`	`+ stat.uncompressed_size = 0;`
	`323`	`+}`
	`324`	`+`
`316`	`325`	`void TemporaryDataOnDiskScope::deltaAllocAndCheck(ssize_t compressed_delta, ssize_t uncompressed_delta)`
`317`	`326`	`{`
`318`	`327`	`if (parent)`
`@@ -334,7 +343,7 @@ void TemporaryDataOnDiskScope::deltaAllocAndCheck(ssize_t compressed_delta, ssiz`
`334`	`343`	`stat.uncompressed_size += uncompressed_delta;`
`335`	`344`	`}`
`336`	`345`
`337`		`-TemporaryBlockStreamHolder::TemporaryBlockStreamHolder(SharedHeader header_, TemporaryDataOnDiskScope * parent_, size_t reserve_size)`
	`346`	`+TemporaryBlockStreamHolder::TemporaryBlockStreamHolder(SharedHeader header_, std::shared_ptr<TemporaryDataOnDiskScope> parent_, size_t reserve_size)`
`338`	`347`	`: WrapperGuard(std::make_unique<TemporaryDataBuffer>(parent_, reserve_size), DBMS_TCP_PROTOCOL_VERSION, header_)`
`339`	`348`	`{`
`340`	`349`	`/// Constant columns must be avoided since they are not supported in (de/)serialization, but we have to keep lazy columns`
`@@ -363,5 +372,6 @@ TemporaryDataBuffer::~TemporaryDataBuffer()`
`363`	`372`	`{`
`364`	`373`	`if (!finalized)`
`365`	`374`	`cancel();`
	`375`	`+ freeAlloc();`
`366`	`376`	`}`
`367`	`377`	`}`
Original file line number	Diff line number	Diff line change
`@@ -243,7 +243,7 @@ void MergeSortingTransform::consume(Chunk chunk)`
`243`	`243`	`/// If there's less free disk space than reserve_size, an exception will be thrown`
`244`	`244`	`size_t reserve_size = sum_bytes_in_blocks + min_free_disk_space;`
`245`	`245`	`SharedHeader shared_header_without_constants = std::make_shared<const Block>(header_without_constants);`
`246`		`- TemporaryBlockStreamHolder tmp_stream(shared_header_without_constants, tmp_data.get(), reserve_size);`
	`246`	`+ TemporaryBlockStreamHolder tmp_stream(shared_header_without_constants, tmp_data, reserve_size);`
`247`	`247`	`size_t max_merged_block_size = this->max_merged_block_size;`
`248`	`248`	`if (max_block_bytes > 0 && sum_rows_in_blocks > 0 && sum_bytes_in_blocks > 0)`
`249`	`249`	`{`
Original file line number	Diff line number	Diff line change
`@@ -384,7 +384,7 @@ void HTTPHandler::processQuery(`
`384`	`384`	`auto tmp_data = server.context()->getTempDataOnDisk();`
`385`	`385`	`cascade_buffers_lazy.emplace_back([tmp_data](const WriteBufferPtr &) -> WriteBufferPtr`
`386`	`386`	`{`
`387`		`- return std::make_unique<TemporaryDataBuffer>(tmp_data.get());`
	`387`	`+ return std::make_unique<TemporaryDataBuffer>(tmp_data);`
`388`	`388`	`});`
`389`	`389`	`}`
`390`	`390`	`else`
Original file line number	Diff line number	Diff line change
`@@ -192,7 +192,7 @@ class RowsSourcesTemporaryFile : public ITemporaryFileLookup`
`192`	`192`	`if (tmp_data_buffer)`
`193`	`193`	`throw Exception(ErrorCodes::LOGICAL_ERROR, "Temporary file was already requested for writing, there musto be only one writer");`
`194`	`194`
`195`		`- tmp_data_buffer = std::make_unique<TemporaryDataBuffer>(temporary_data_on_disk.get());`
	`195`	`+ tmp_data_buffer = std::make_unique<TemporaryDataBuffer>(temporary_data_on_disk);`
`196`	`196`	`return *tmp_data_buffer;`
`197`	`197`	`}`
`198`	`198`