{

/// A `Sparse` column is structurally interchangeable with the full column of the same type it

/// wraps, and this holds at any depth, not only at the top level: one branch can materialize a

/// nested subcolumn (`recursiveRemoveSparse`) while another keeps it sparse. Unwrap `Sparse` on

/// either side independently, mirroring the top-level unwrap in `checkColumnStructure`.

if (const auto * actual_sparse = typeid_cast<const ColumnSparse *>(&actual))

return haveCompatibleColumnStructure(actual_sparse->getValuesColumn(), expected);

if (const auto * expected_sparse = typeid_cast<const ColumnSparse *>(&expected))

return haveCompatibleColumnStructure(actual, expected_sparse->getValuesColumn());

const auto * actual_agg = typeid_cast<const ColumnAggregateFunction *>(&actual);

const auto * expected_agg = typeid_cast<const ColumnAggregateFunction *>(&expected);

if (actual_agg && expected_agg)

return actual_agg->getAggregateFunction()->haveSameStateRepresentation(*expected_agg->getAggregateFunction());

if (typeid(actual) != typeid(expected))

return false;

/// `Variant` is compositional too: its type equality (checked before this point) already

/// fixes the set and the global order of alternatives, so the only thing that can differ

/// between two structurally-equal-typed `Variant` columns is an aggregate state nested

/// inside an alternative, which is exactly what we want to relax. But the local order of

/// the nested variant columns (the order `forEachSubcolumn` iterates them in) is a property

/// of a particular column, not of the type, and `getName` lists the variants in the global

/// order — so compare the alternatives pairwise by global discriminator, like `getName` does.

if (const auto * actual_variant = typeid_cast<const ColumnVariant *>(&actual))

{

const auto & expected_variant = assert_cast<const ColumnVariant &>(expected);

const size_t num_variants = actual_variant->getNumVariants();

if (num_variants != expected_variant.getNumVariants())

return false;

for (size_t global_discr = 0; global_discr < num_variants; ++global_discr)

if (!haveCompatibleColumnStructure(

actual_variant->getVariantByGlobalDiscriminator(global_discr),

expected_variant.getVariantByGlobalDiscriminator(global_discr)))

return false;

return true;

}

/// `Replicated` is compositional too, but only its nested column is structural: the internal

/// indexes column is a variable-width encoding detail (`UInt8` .. `UInt64`, widened lazily)

/// that `getName` does not include, yet `forEachSubcolumn` exposes — so descending into all

/// subcolumns would make the check stricter than the name comparison and reject a valid

/// runtime block against its header. Compare only the nested column, like

/// `ColumnReplicated::structureEquals` does.

if (const auto * actual_replicated = typeid_cast<const ColumnReplicated *>(&actual))

{

const auto & expected_replicated = assert_cast<const ColumnReplicated &>(expected);

return haveCompatibleColumnStructure(*actual_replicated->getNestedColumn(), *expected_replicated.getNestedColumn());

}

/// Descend only into the plain container columns whose name is a pure composition of the

/// nested column names, so that for everything else the comparison stays exactly as strict

/// as comparing full column names. `Dynamic`/`Object` are deliberately left strict because

/// their nested structure is not fixed by the type.

const bool is_compositional = typeid_cast<const ColumnTuple *>(&actual) || typeid_cast<const ColumnArray *>(&actual)

|| typeid_cast<const ColumnMap *>(&actual) || typeid_cast<const ColumnNullable *>(&actual)

|| typeid_cast<const ColumnConst *>(&actual);

if (!is_compositional)

return actual.getName() == expected.getName();

std::vector<const IColumn *> actual_children;

std::vector<const IColumn *> expected_children;

actual.forEachSubcolumn([&](const auto & subcolumn) { actual_children.push_back(subcolumn.get()); });

expected.forEachSubcolumn([&](const auto & subcolumn) { expected_children.push_back(subcolumn.get()); });

if (actual_children.size() != expected_children.size())

return false;

for (size_t i = 0; i < actual_children.size(); ++i)

if (!haveCompatibleColumnStructure(*actual_children[i], *expected_children[i]))

return false;

return true;

{

if (actual.size() != expected.size())

return false;

for (size_t i = 0; i < actual.size(); ++i)

if (!haveCompatibleConstantValues(actual[i], expected[i], strict_aggregate_states))

return false;

return true;

{

if (actual.getType() != expected.getType())

return false;

switch (actual.getType())

{

case Field::Types::AggregateFunctionState:

{

const auto & actual_state = actual.safeGet<AggregateFunctionStateData>();

const auto & expected_state = expected.safeGet<AggregateFunctionStateData>();

if (strict_aggregate_states && actual_state.name != expected_state.name)

return false;

return actual_state.data == expected_state.data;

}

case Field::Types::Array:

return haveCompatibleConstantValueVectors(actual.safeGet<Array>(), expected.safeGet<Array>(), strict_aggregate_states);

case Field::Types::Tuple:

return haveCompatibleConstantValueVectors(actual.safeGet<Tuple>(), expected.safeGet<Tuple>(), strict_aggregate_states);

case Field::Types::Map:

return haveCompatibleConstantValueVectors(actual.safeGet<Map>(), expected.safeGet<Map>(), strict_aggregate_states);

default:

return actual == expected;

}

{

if (isVariant(type) || isDynamic(type) || isObject(type))

return true;

bool result = false;

type.forEachChild([&](const IDataType & child)

{

result = result || typeCanHideTheValueType(child);

});

return result;

std::string_view context_description, bool allow_materialize, int code)

{

if (actual.name != expected.name)

return onError<ReturnType>(code, "Block structure mismatch in {} stream: different names of columns:\n{}\n{}",

context_description, actual.dumpStructure(), expected.dumpStructure());

if ((actual.type && !expected.type) || (!actual.type && expected.type)

|| (actual.type && expected.type && !actual.type->equals(*expected.type)))

return onError<ReturnType>(code, "Block structure mismatch in {} stream: different types:\n{}\n{}",

context_description, actual.dumpStructure(), expected.dumpStructure());

if (!actual.column || !expected.column)

return ReturnType(true);

const IColumn * actual_column = actual.column.get();

const IColumn * expected_column = expected.column.get();

/// A Sparse column is structurally equal to the full column of the same type it wraps, and every

/// consumer can process sparse, so it must compare equal to a non-sparse column even in the

/// strict path. Unwrap Sparse on both sides here; Const and Replicated stay strict unless

/// allow_materialize.

if (const auto * actual_sparse = typeid_cast<const ColumnSparse *>(actual_column))

actual_column = &actual_sparse->getValuesColumn();

if (const auto * expected_sparse = typeid_cast<const ColumnSparse *>(expected_column))

expected_column = &expected_sparse->getValuesColumn();

/// If we allow to materialize columns, omit Const and Replicated columns too.

if (allow_materialize)

{

actual_column = getActualColumn(actual_column);

expected_column = getActualColumn(expected_column);

}

if (!haveCompatibleColumnStructure(*actual_column, *expected_column))

{

return onError<ReturnType>(code,

"Block structure mismatch in {} stream: different columns:\n{}\n{}",

context_description,

actual.dumpStructure(),

expected.dumpStructure());

}

if (isColumnConst(*actual.column) && isColumnConst(*expected.column)

&& !actual.column->empty() && !expected.column->empty()) /// don't check values in empty columns

{

Field actual_value = assert_cast<const ColumnConst &>(*actual.column).getField();

Field expected_value = assert_cast<const ColumnConst &>(*expected.column).getField();

/// The types are already checked to be equal at this point.

const bool strict_aggregate_states = actual.type && typeCanHideTheValueType(*actual.type);

if (!haveCompatibleConstantValues(actual_value, expected_value, strict_aggregate_states))

return onError<ReturnType>(code,

"Block structure mismatch in {} stream: different values of constants in column '{}': actual: {}, expected: {}",

context_description,

actual.name,

applyVisitor(FieldVisitorToString(), actual_value),

applyVisitor(FieldVisitorToString(), expected_value));

}

return ReturnType(true);

{

/// It's common to have common SharedHeaders in the pipeline

if (&lhs == &rhs)

return ReturnType(true);

size_t columns = rhs.columns();

if (lhs.columns() != columns)

return onError<ReturnType>(ErrorCodes::LOGICAL_ERROR, "Block structure mismatch in {} stream: different number of columns:\n{}\n{}",

context_description, lhs.dumpStructure(), rhs.dumpStructure());

for (size_t i = 0; i < columns; ++i)

{

const auto & actual = lhs.getByPosition(i);

const auto & expected = rhs.getByPosition(i);

if constexpr (std::is_same_v<ReturnType, bool>)

{

if (!checkColumnStructure<ReturnType>(actual, expected, context_description, allow_materialize, ErrorCodes::LOGICAL_ERROR))

return false;

}

else

checkColumnStructure<ReturnType>(actual, expected, context_description, allow_materialize, ErrorCodes::LOGICAL_ERROR);

}

return ReturnType(true);

{

for (size_t i = 0, size = data.size(); i < size; ++i)

index_by_name.emplace(data[i].name, i);

{

index_by_name.reserve(count);

data.reserve(count);

{

if (position > data.size())

throw Exception(ErrorCodes::POSITION_OUT_OF_BOUND, "Position out of bound in Block::insert(), max position = {}",

data.size());

if (elem.name.empty())

throw Exception(ErrorCodes::AMBIGUOUS_COLUMN_NAME, "Column name in Block cannot be empty");

auto [new_it, inserted] = index_by_name.emplace(elem.name, position);

if (!inserted)

checkColumnStructure<void>(data[new_it->second], elem,

"(columns with identical name must have identical structure)", true, ErrorCodes::AMBIGUOUS_COLUMN_NAME);

for (auto it = index_by_name.begin(); it != index_by_name.end(); ++it)

{

if (it->second >= position && (!inserted || it != new_it))

++it->second;

}

data.emplace(data.begin() + position, std::move(elem));

{

if (elem.name.empty())

throw Exception(ErrorCodes::AMBIGUOUS_COLUMN_NAME, "Column name in Block cannot be empty");

auto [it, inserted] = index_by_name.emplace(elem.name, data.size());

if (!inserted)

checkColumnStructure<void>(data[it->second], elem,

"(columns with identical name must have identical structure)", true, ErrorCodes::AMBIGUOUS_COLUMN_NAME);

data.emplace_back(std::move(elem));

{

if (elem.name.empty())

throw Exception(ErrorCodes::AMBIGUOUS_COLUMN_NAME, "Column name in Block cannot be empty");

if (!index_by_name.contains(elem.name))

insert(std::move(elem));

{

if (positions.empty())

return;

if (*positions.rbegin() >= data.size())

throw Exception(ErrorCodes::POSITION_OUT_OF_BOUND, "Position out of bound in Block::erase(), max position = {}",

data.empty() ? 0 : data.size() - 1);

/// Compact `data` in a single pass, dropping the erased positions, then rebuild the name index once.

/// This is O(columns) instead of O(columns * erased) that repeated single-position erases would cost.

size_t next = 0;

auto pos_it = positions.begin();

for (size_t i = 0; i < data.size(); ++i)

{

if (pos_it != positions.end() && *pos_it == i)

{

++pos_it;

continue;

}

if (next != i)

data[next] = std::move(data[i]);

++next;

}

data.resize(next);

index_by_name.clear();

for (size_t i = 0; i < data.size(); ++i)

index_by_name.emplace(data[i].name, i);

{

if (data.empty())

throw Exception(ErrorCodes::POSITION_OUT_OF_BOUND, "Block is empty");

if (position >= data.size())

throw Exception(ErrorCodes::POSITION_OUT_OF_BOUND, "Position out of bound in Block::erase(), max position = {}",

data.size() - 1);

eraseImpl(position);

{

data.erase(data.begin() + position);

for (auto it = index_by_name.begin(); it != index_by_name.end();)

{

if (it->second == position)

it = index_by_name.erase(it);

else

{

if (it->second > position)

--it->second;

++it;

}

}

{

auto index_it = index_by_name.find(name);

if (index_it == index_by_name.end())

throw Exception(ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK, "No such name in Block::erase(): '{}'", name);

eraseImpl(index_it->second);

{

for (auto [column_name, subcolumn_name] : Nested::getAllColumnAndSubcolumnPairs(name))

{

const auto * column = findByName(column_name, false);

if (!column)

continue;

auto subcolumn_type = column->type->tryGetSubcolumnType(subcolumn_name);

auto subcolumn = column->type->tryGetSubcolumn(subcolumn_name, column->column);

if (subcolumn_type && subcolumn)

return ColumnWithTypeAndName(subcolumn, subcolumn_type, name);

}

return std::nullopt;

{

if (const auto * column = findByName(name, false))

return *column;

return findSubcolumnByName(name);

{

auto result = findSubcolumnByName(name);

if (!result)

throw Exception(

ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK,

"Not found subcolumn {} in block. There are only columns: {}",

name,

dumpNames());

return *result;

{

auto result = findColumnOrSubcolumnByName(name);

if (!result)

throw Exception(

ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK,

"Not found column or subcolumn {} in block. There are only columns: {}",

name,

dumpNames());

return *result;

{

if (case_insensitive)

{

auto found = std::find_if(data.begin(), data.end(), [&](const auto & column) { return boost::iequals(column.name, name); });

if (found == data.end())

{

return std::nullopt;

}

return found - data.begin();

}

auto it = index_by_name.find(name);

if (index_by_name.end() == it)

{

return std::nullopt;

}

return it->second;

{

const auto pos = findPositionByName(name, case_insensitive);

if (!pos.has_value())

throw Exception(

ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK, "Not found column {} in block. There are only columns: {}", name, dumpNames());

return pos.value();

{

ssize_t rows = -1;

for (const auto & elem : data)

{

if (!elem.column && allow_null_columns)

continue;

if (!elem.column)

throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Column {} in block is nullptr, in method checkNumberOfRows." , elem.name);

ssize_t size = elem.column->size();

if (rows == -1)

rows = size;

else if (rows != size)

throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Sizes of columns doesn't match: {}: {}, {}: {}",

data.front().name, rows, elem.name, toString(size));

}

{

for (const auto & elem : data)

if (elem.column)

return elem.column->size();

return 0;

{

size_t res = 0;

for (const auto & elem : data)

if (elem.column)

res += elem.column->byteSize();

return res;

{

size_t res = 0;

for (const auto & elem : data)

if (elem.column)

res += elem.column->allocatedBytes();

return res;

{

WriteBufferFromOwnString out;

for (auto it = data.begin(); it != data.end(); ++it)

{

if (it != data.begin())

out << ", ";

out << it->name;

}

return out.str();

{

WriteBufferFromOwnString out;

for (auto it = data.begin(); it != data.end(); ++it)

{

if (it != data.begin())

out << ", ";

it->dumpStructure(out);

}

return out.str();

{

WriteBufferFromOwnString out;

bool first = true;

for (const auto & [name, pos] : index_by_name)

{

if (!first)

out << ", ";

first = false;

out << name << ' ' << pos;

}

return out.str();

{

Block res;

res.reserve(data.size());

for (const auto & elem : data)

res.insert(elem.cloneEmpty());

return res;

{

size_t num_columns = data.size();

MutableColumns columns(num_columns);

for (size_t i = 0; i < num_columns; ++i)

columns[i] = data[i].column ? data[i].column->cloneEmpty() : data[i].type->createColumn();

return columns;

{

size_t num_columns = data.size();

MutableColumns columns(num_columns);

for (size_t i = 0; i < num_columns; ++i)

columns[i] = data[i].type->createColumn(*serializations[i]);

return columns;

{

size_t num_columns = data.size();

Columns columns(num_columns);

for (size_t i = 0; i < num_columns; ++i)

columns[i] = data[i].column;

return columns;

{

size_t num_columns = data.size();

MutableColumns columns(num_columns);

for (size_t i = 0; i < num_columns; ++i)

columns[i] = data[i].column ? IColumn::mutate(std::move(data[i].column)) : data[i].type->createColumn();

return columns;

{

size_t num_columns = data.size();

Columns columns(num_columns);

for (size_t i = 0; i < num_columns; ++i)

columns[i] = data[i].column ? std::move(data[i].column) : data[i].type->createColumn();

return columns;

{

/// TODO: assert if |columns| doesn't match |data|!

size_t num_columns = data.size();

for (size_t i = 0; i < num_columns; ++i)

data[i].column = std::move(columns[i]);

{

/// TODO: assert if |columns| doesn't match |data|!

size_t num_columns = data.size();

for (size_t i = 0; i < num_columns; ++i)

data[i].column = columns[i];

{

if (position >= data.size())

throw Exception(ErrorCodes::POSITION_OUT_OF_BOUND, "Position {} out of bound in Block::setColumn(), max position {}",

position, data.size());

if (data[position].name != column.name)

{

index_by_name.erase(data[position].name);

index_by_name.emplace(column.name, position);

}

data[position] = std::move(column);

{

Block res;

size_t num_columns = data.size();

if (num_columns != columns.size())

{

auto dump_columns = std::views::transform([](const auto & col) { return col->dumpStructure(); });

throw Exception(

ErrorCodes::LOGICAL_ERROR,

"Cannot clone block with columns because block [{}] has {} columns, but {} columns given [{}]",

dumpStructure(), num_columns,

columns.size(), fmt::join(columns | dump_columns, ", "));

}

res.reserve(num_columns);

for (size_t i = 0; i < num_columns; ++i)

res.insert({ std::move(columns[i]), data[i].type, data[i].name });

return res;

{

Block res;

size_t num_columns = data.size();

if (num_columns != columns.size())

{

auto dump_columns = std::views::transform([](const auto & col) { return col->dumpStructure(); });

throw Exception(

ErrorCodes::LOGICAL_ERROR,

"Cannot clone block with columns because block [{}] has {} columns, but {} columns given [{}]",

dumpStructure(), num_columns,

columns.size(), fmt::join(columns | dump_columns, ", "));

}

res.reserve(num_columns);

for (size_t i = 0; i < num_columns; ++i)

res.insert({ columns[i], data[i].type, data[i].name });

return res;

{

Block res;

size_t num_columns = data.size();

res.reserve(num_columns);

for (size_t i = 0; i < num_columns; ++i)

res.insert({ nullptr, data[i].type, data[i].name });

return res;

{

Block copy = *this;

for (auto & column_to_cut : copy.data)

column_to_cut.column = column_to_cut.column->cut(start, length);

return copy;

{

Block sorted_block;

/// std::unordered_map (index_by_name) cannot be used to guarantee the sort order

VectorWithMemoryTracking<IndexByName::const_iterator> sorted_index_by_name(index_by_name.size());

{

size_t i = 0;

for (auto it = index_by_name.begin(); it != index_by_name.end(); ++it)

sorted_index_by_name[i++] = it;

}

::sort(sorted_index_by_name.begin(), sorted_index_by_name.end(), [](const auto & lhs, const auto & rhs)

{

return lhs->first < rhs->first;

});

for (const auto & it : sorted_index_by_name)

sorted_block.insert(data[it->second]);

return sorted_block;

{

Columns new_columns(data.size(), nullptr);

for (size_t i = 0; i < data.size(); ++i)

new_columns[i] = data[i].column->cloneResized(data[i].column->size());

return cloneWithColumns(new_columns);

{

size_t num_columns = data.size();

Columns new_columns(num_columns);

for (size_t i = 0; i < num_columns; ++i)

new_columns[i] = data[i].column->compress(/*force_compression=*/false);

return cloneWithColumns(new_columns);

{

size_t num_columns = data.size();

Columns new_columns(num_columns);

for (size_t i = 0; i < num_columns; ++i)

new_columns[i] = data[i].column->decompress();

return cloneWithColumns(new_columns);

{

NamesAndTypesList res;

for (const auto & elem : data)

res.emplace_back(elem.name, elem.type);

return res;

{

NamesAndTypes res;

res.reserve(columns());

for (const auto & elem : data)

res.emplace_back(elem.name, elem.type);

return res;

{

Names res;

res.reserve(columns());

for (const auto & elem : data)

res.push_back(elem.name);

return res;

{

NameSet res;

res.reserve(columns());

for (const auto & elem : data)

res.insert(elem.name);

return res;

{

DataTypes res;

res.reserve(columns());

for (const auto & elem : data)

res.push_back(elem.type);

return res;

{

Names res;

res.reserve(columns());

for (const auto & elem : data)

res.push_back(elem.type->getName());

return res;