diff --git a/src/Interpreters/Cache/QueryCache.cpp b/src/Interpreters/Cache/QueryCache.cpp
index 3118f386111..364a740abe0 100644
--- a/src/Interpreters/Cache/QueryCache.cpp
+++ b/src/Interpreters/Cache/QueryCache.cpp
@@ -263,23 +263,23 @@ void QueryCache::Writer::finalizeWrite()
 
     if (auto entry = cache.getWithKey(key); entry.has_value() && !IsStale()(entry->key))
     {
-        /// same check as in ctor because a parallel Writer could have inserted the current key in the meantime
+        /// Same check as in ctor because a parallel Writer could have inserted the current key in the meantime
         LOG_TRACE(&Poco::Logger::get("QueryCache"), "Skipped insert (non-stale entry found), query: {}", key.queryStringFromAst());
         return;
     }
 
     if (squash_partial_results)
     {
-        // Squash partial result chunks to chunks of size 'max_block_size' each. This costs some performance but provides a more natural
-        // compression of neither too small nor big blocks. Also, it will look like 'max_block_size' is respected when the query result is
-        // served later on from the query cache.
+        /// Squash partial result chunks to chunks of size 'max_block_size' each. This costs some performance but provides a more natural
+        /// compression of neither too small nor big blocks. Also, it will look like 'max_block_size' is respected when the query result is
+        /// served later on from the query cache.
 
         Chunks squashed_chunks;
         size_t rows_remaining_in_squashed = 0; /// how many further rows can the last squashed chunk consume until it reaches max_block_size
 
         for (auto & chunk : query_result->chunks)
         {
-            convertToFullIfSparse(chunk);
+            convertToFullIfNeeded(chunk);
 
             const size_t rows_chunk = chunk.getNumRows();
             if (rows_chunk == 0)
diff --git a/src/Processors/Chunk.cpp b/src/Processors/Chunk.cpp
index 0a4b2413e4c..24181866087 100644
--- a/src/Processors/Chunk.cpp
+++ b/src/Processors/Chunk.cpp
@@ -2,6 +2,7 @@
 #include <IO/WriteHelpers.h>
 #include <IO/Operators.h>
 #include <Columns/ColumnSparse.h>
+#include <DataTypes/DataTypeLowCardinality.h>
 
 namespace DB
 {
@@ -202,6 +203,24 @@ const ChunkMissingValues::RowsBitMask & ChunkMissingValues::getDefaultsBitmask(s
     return none;
 }
 
+void convertToFullIfConst(Chunk & chunk)
+{
+    size_t num_rows = chunk.getNumRows();
+    auto columns = chunk.detachColumns();
+    for (auto & column : columns)
+        column = column->convertToFullColumnIfConst();
+    chunk.setColumns(std::move(columns), num_rows);
+}
+
+void convertToFullIfLowCardinality(Chunk & chunk)
+{
+    size_t num_rows = chunk.getNumRows();
+    auto columns = chunk.detachColumns();
+    for (auto & column : columns)
+        column = recursiveRemoveLowCardinality(column);
+    chunk.setColumns(std::move(columns), num_rows);
+}
+
 void convertToFullIfSparse(Chunk & chunk)
 {
     size_t num_rows = chunk.getNumRows();
@@ -212,4 +231,11 @@ void convertToFullIfSparse(Chunk & chunk)
     chunk.setColumns(std::move(columns), num_rows);
 }
 
+void convertToFullIfNeeded(Chunk & chunk)
+{
+    convertToFullIfSparse(chunk);
+    convertToFullIfConst(chunk);
+    convertToFullIfLowCardinality(chunk);
+}
+
 }
diff --git a/src/Processors/Chunk.h b/src/Processors/Chunk.h
index 6f2097b71f1..45610ae3276 100644
--- a/src/Processors/Chunk.h
+++ b/src/Processors/Chunk.h
@@ -149,6 +149,9 @@ private:
 /// It's needed, when you have to access to the internals of the column,
 /// or when you need to perform operation with two columns
 /// and their structure must be equal (e.g. compareAt).
+void convertToFullIfConst(Chunk & chunk);
+void convertToFullIfLowCardinality(Chunk & chunk);
 void convertToFullIfSparse(Chunk & chunk);
+void convertToFullIfNeeded(Chunk & chunk);
 
 }