{

auto context = Context::getGlobalContextInstance();

return context && context->getSettingsRef()[Setting::allow_nullable_tuple_in_extracted_subcolumns];

{

if (checkAndGetColumn<ColumnTuple>(column.get()))

return isNullableTupleInExtractedSubcolumnsEnabledByGlobalSetting();

return column->canBeInsideNullable();

{

if (isTuple(type))

return isNullableTupleInExtractedSubcolumnsEnabledByGlobalSetting();

return type->canBeInsideNullable();

{

if (!canExtractedSubcolumnsBeInsideNullableOrLowCardinalityNullable(type))

return type;

return makeNullableOrLowCardinalityNullableSafe(type);

{

ColumnPtr null_map_holder;

auto addNullMap = [&](const ColumnNullable * column_nullable)

{

if (!null_map_holder)

{

/// First nullable column: just take its null map as the base

null_map_holder = column_nullable->getNullMapColumnPtr();

}

else

{

/// Subsequent nullable columns: OR their null maps into the accumulated one

MutableColumnPtr mutable_null_map_holder = IColumn::mutate(std::move(null_map_holder));

PaddedPODArray<UInt8> & mutable_null_map = assert_cast<ColumnUInt8 &>(*mutable_null_map_holder).getData();

const PaddedPODArray<UInt8> & other_null_map = column_nullable->getNullMapData();

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

mutable_null_map[i] |= other_null_map[i];

null_map_holder = std::move(mutable_null_map_holder);

}

};

for (auto & column : key_columns)

{

if (const auto * column_nullable = checkAndGetColumn<ColumnNullable>(&*column))

{

/// Top-level Nullable(...) always contributes to the combined null map

addNullMap(column_nullable);

const IColumn * nested_column = &column_nullable->getNestedColumn();

column = nested_column;

/// Special case: Nullable(Tuple(...))

/// If the nested column is a tuple, also fold in null maps of nullable tuple elements

if (const auto * tuple = checkAndGetColumn<ColumnTuple>(nested_column))

{

const auto & tuple_columns = tuple->getColumns();

for (const auto & element : tuple_columns)

{

if (const auto * elem_nullable = checkAndGetColumn<ColumnNullable>(element.get()))

{

addNullMap(elem_nullable);

}

}

}

}

}

null_map = null_map_holder ? &assert_cast<const ColumnUInt8 &>(*null_map_holder).getData() : nullptr;

return null_map_holder;

IColumn & column, const NullMap & parent_null_map, size_t column_offset, size_t parent_null_map_offset)

{

chassert(column_offset <= column.size());

const size_t length = column.size() - column_offset;

chassert(parent_null_map_offset + length <= parent_null_map.size());

/// A non-nullable `LowCardinality(T)` read from disk has no NULL placeholder in its dictionary, so

/// promote it to `LowCardinality(Nullable(T))` in place. The extracted subcolumn's type is

/// `LowCardinality(Nullable(T))` (see `create(DataTypePtr)`), so this keeps the (type, column) pair

/// consistent even for ranges that contain no parent NULLs (handled before the early-out below).

if (auto * low_cardinality_to_promote = typeid_cast<ColumnLowCardinality *>(&column);

low_cardinality_to_promote && !low_cardinality_to_promote->nestedIsNullable())

low_cardinality_to_promote->convertDictionaryToNullableInplace();

/// When no row of the range is NULL in the parent, the subcolumn already holds the correct values and

/// nothing needs to be marked NULL.

if (memoryIsZero(parent_null_map.data(), parent_null_map_offset, parent_null_map_offset + length))

return;

/// Build a keep-mask that covers only the applied range: zero for the rows that are NULL in the parent

/// and one elsewhere.

IColumn::Filter keep_mask(length);

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

keep_mask[i] = !parent_null_map[parent_null_map_offset + i];

if (auto * nullable = typeid_cast<ColumnNullable *>(&column))

{

nullable->applyNegatedNullMap(keep_mask, column_offset);

return;

}

if (auto * variant = typeid_cast<ColumnVariant *>(&column))

{

variant->applyNegatedNullMap(keep_mask, column_offset);

return;

}

if (auto * dynamic = typeid_cast<ColumnDynamic *>(&column))

{

dynamic->applyNegatedNullMap(keep_mask, column_offset);

return;

}

if (auto * low_cardinality = typeid_cast<ColumnLowCardinality *>(&column))

{

low_cardinality->applyNegatedNullMap(keep_mask, column_offset);

return;

}

throw Exception(

ErrorCodes::LOGICAL_ERROR, "Cannot apply the parent null map to subcolumn {} that cannot represent NULL values", column.getName());

{

/// Wrap into `Nullable(...)` when possible, or `LowCardinality(Nullable(T))` for a non-nullable

/// `LowCardinality(T)` element (which cannot be wrapped in plain `Nullable`) so it can still

/// represent the outer column's NULLs. Returns `prev` unchanged for types that can do neither.

return makeExtractedSubcolumnsNullableOrLowCardinalityNullableSafe(prev);

{

if (prev_type && !canExtractedSubcolumnsBeInsideNullable(prev_type))

{

/// The extracted subcolumn cannot be wrapped into Nullable, but some types can represent NULL

/// themselves: Nullable (possibly inside LowCardinality), Dynamic and Variant. For them return a

/// serialization that also reads the outer null map and marks the corresponding rows as NULL in

/// the subcolumn's own null representation.

///

/// A non-nullable `LowCardinality(T)` cannot represent NULL as-is, but its extracted subcolumn's

/// type is promoted to `LowCardinality(Nullable(T))` (see `create(DataTypePtr)`). Wrap the original

/// (non-nullable) serialization so the on-disk stream layout is unchanged; the wrapper reads the

/// `LowCardinality(T)` column and `applyParentNullMapToExtractedSubcolumn` promotes it to

/// `LowCardinality(Nullable(T))` before folding in the outer null map, keeping the read

/// (type, column) pair consistent with the in-memory one. `prev_type` is passed to the wrapper in

/// that case, because the promoted result column is not the on-disk representation to deserialize

/// into.

if (canContainNull(*prev_type))

return SerializationNullableWithParentNullMap::create(prev_serialization);

if (prev_type->lowCardinality())

return SerializationNullableWithParentNullMap::create(prev_serialization, prev_type);

return prev_serialization;

}

return SerializationNullable::create(prev_serialization);

{

if (canExtractedSubcolumnsBeInsideNullable(prev))

return ColumnNullable::create(prev, null_map);

if (null_map)

{

const auto & outer_null_map_data = assert_cast<const ColumnUInt8 &>(*null_map).getData();

/// The extracted subcolumn cannot be wrapped into Nullable, but if it can already represent NULL

/// itself, mark rows that are NULL in the outer column as NULL in it.

if (canContainNull(*prev))

{

auto mutable_column = IColumn::mutate(prev);

applyParentNullMapToExtractedSubcolumn(*mutable_column, outer_null_map_data, 0, 0);

return mutable_column;

}

/// A non-nullable `LowCardinality(T)` cannot represent NULL as-is, but it can once promoted to

/// `LowCardinality(Nullable(T))` -- which is what the type `create(DataTypePtr)` returns. Promote the

/// column the same way with `cloneNullable()` before folding in the outer null map, so the extracted

/// (type, column) pair stays consistent.

if (const auto * prev_lc = checkAndGetColumn<ColumnLowCardinality>(prev.get()))

{

auto mutable_column = prev_lc->cloneNullable();

applyParentNullMapToExtractedSubcolumn(*mutable_column, outer_null_map_data, 0, 0);

return mutable_column;

}

}

return prev;