void NativeBlockOutputStream::writeData(const IDataType & type, const ColumnPtr & column, WriteBuffer & ostr, size_t offset, size_t limit) { /** If there are columns-constants - then we materialize them. * (Since the data type does not know how to serialize / deserialize constants.) */ ColumnPtr full_column; if (auto converted = column->convertToFullColumnIfConst()) full_column = converted; else full_column = column; if (type.isNullable()) { const DataTypeNullable & nullable_type = static_cast<const DataTypeNullable &>(type); const IDataType & nested_type = *nullable_type.getNestedType(); const ColumnNullable & nullable_col = static_cast<const ColumnNullable &>(*full_column.get()); const ColumnPtr & nested_col = nullable_col.getNestedColumn(); const IColumn & null_map = nullable_col.getNullMapConcreteColumn(); DataTypeUInt8{}.serializeBinaryBulk(null_map, ostr, offset, limit); writeData(nested_type, nested_col, ostr, offset, limit); } else if (const DataTypeArray * type_arr = typeid_cast<const DataTypeArray *>(&type)) { /** For arrays, you first need to serialize the offsets, and then the values. */ const ColumnArray & column_array = typeid_cast<const ColumnArray &>(*full_column); type_arr->getOffsetsType()->serializeBinaryBulk(*column_array.getOffsetsColumn(), ostr, offset, limit); if (!typeid_cast<const ColumnArray &>(*full_column).getData().empty()) { const ColumnArray::Offsets_t & offsets = column_array.getOffsets(); if (offset > offsets.size()) return; /** offset - from which array to write. * limit - how many arrays should be written, or 0, if you write everything that is. * end - up to which array written part finishes. * * nested_offset - from which nested element to write. * nested_limit - how many nested elements to write, or 0, if you write everything that is. */ size_t end = std::min(offset + limit, offsets.size()); size_t nested_offset = offset ? offsets[offset - 1] : 0; size_t nested_limit = limit ? offsets[end - 1] - nested_offset : 0; const DataTypePtr & nested_type = type_arr->getNestedType(); DataTypePtr actual_type; if (nested_type->isNull()) { /// Special case: an array of Null is actually an array of Nullable(UInt8). actual_type = std::make_shared<DataTypeNullable>(std::make_shared<DataTypeUInt8>()); } else actual_type = nested_type; if (limit == 0 || nested_limit) writeData(*actual_type, typeid_cast<const ColumnArray &>(*full_column).getDataPtr(), ostr, nested_offset, nested_limit); } } else type.serializeBinaryBulk(*full_column, ostr, offset, limit); }
bool DataTypeNullable::equals(const IDataType & rhs) const { return rhs.isNullable() && nested_data_type->equals(*static_cast<const DataTypeNullable &>(rhs).nested_data_type); }