map_from_arrays

src/Columns/ColumnLowCardinality.cpp

@@ -832,4 +832,39 @@ void ColumnLowCardinality::Dictionary::compact(ColumnPtr & positions)
     shared = false;
 }
 
+ColumnPtr ColumnLowCardinality::cloneWithDefaultOnNull() const
+{
+    if (!nestedIsNullable())
+        return getPtr();
+
+    auto res = cloneEmpty();
+    auto & lc_res = assert_cast<ColumnLowCardinality &>(*res);
+    lc_res.nestedRemoveNullable();
+    size_t end = size();
+    size_t start = 0;
+    while (start < end)
+    {
+        size_t next_null_index = start;
+        while (next_null_index < end && !isNullAt(next_null_index))
+            ++next_null_index;
+
+        if (next_null_index != start)
+            lc_res.insertRangeFrom(*this, start, next_null_index - start);
+
+        if (next_null_index < end)
+            lc_res.insertDefault();
+
+        start = next_null_index + 1;
+    }
+
+    return res;
+}
+
+bool isColumnLowCardinalityNullable(const IColumn & column)
+{
+    if (const auto * lc_column = checkAndGetColumn<ColumnLowCardinality>(&column))
+        return lc_column->nestedIsNullable();
+    return false;
+}
+
 }

src/Columns/ColumnLowCardinality.h

@@ -221,6 +221,8 @@ class ColumnLowCardinality final : public COWHelper<IColumn, ColumnLowCardinalit
     void nestedToNullable() { dictionary.getColumnUnique().nestedToNullable(); }
     void nestedRemoveNullable() { dictionary.getColumnUnique().nestedRemoveNullable(); }
 
+    ColumnPtr cloneWithDefaultOnNull() const;
+
     const IColumnUnique & getDictionary() const { return dictionary.getColumnUnique(); }
     IColumnUnique & getDictionary() { return dictionary.getColumnUnique(); }
     const ColumnPtr & getDictionaryPtr() const { return dictionary.getColumnUniquePtr(); }
@@ -365,5 +367,6 @@ class ColumnLowCardinality final : public COWHelper<IColumn, ColumnLowCardinalit
     void getPermutationImpl(IColumn::PermutationSortDirection direction, IColumn::PermutationSortStability stability, size_t limit, int nan_direction_hint, Permutation & res, const Collator * collator = nullptr) const;
 };
 
+bool isColumnLowCardinalityNullable(const IColumn & column);
 
 }

src/Columns/IColumn.cpp

@@ -2,6 +2,7 @@
 #include <IO/Operators.h>
 #include <Columns/IColumn.h>
 #include <Columns/ColumnNullable.h>
+#include <Columns/ColumnLowCardinality.h>
 #include <Columns/ColumnConst.h>
 #include <Core/Field.h>
 #include <DataTypes/Serializations/SerializationInfo.h>
@@ -83,6 +84,11 @@ bool isColumnNullable(const IColumn & column)
     return checkColumn<ColumnNullable>(column);
 }
 
+bool isColumnNullableOrLowCardinalityNullable(const IColumn & column)
+{
+    return isColumnNullable(column) || isColumnLowCardinalityNullable(column);
+}
+
 bool isColumnConst(const IColumn & column)
 {
     return checkColumn<ColumnConst>(column);

src/Columns/IColumn.h

@@ -650,4 +650,7 @@ bool isColumnConst(const IColumn & column);
 /// True if column's an ColumnNullable instance. It's just a syntax sugar for type check.
 bool isColumnNullable(const IColumn & column);
 
+/// True if column's is ColumnNullable or ColumnLowCardinality with nullable nested column.
+bool isColumnNullableOrLowCardinalityNullable(const IColumn & column);
+
 }

src/Common/ErrorCodes.cpp

@@ -627,6 +627,7 @@
     M(677, THREAD_WAS_CANCELED) \
     M(678, IO_URING_INIT_FAILED) \
     M(679, IO_URING_SUBMIT_ERROR) \
+    M(680, SIZES_OF_ARRAYS_DONT_MATCH) \
     M(997, UNSUPPORTED) \
     M(998, INVALID_INTEGER_STRING) \
     \

src/DataTypes/DataTypeNullable.cpp

@@ -1,6 +1,7 @@
 #include <DataTypes/DataTypeNullable.h>
 #include <DataTypes/DataTypeNothing.h>
 #include <DataTypes/DataTypeFactory.h>
+#include <DataTypes/DataTypeLowCardinality.h>
 #include <DataTypes/Serializations/SerializationNullable.h>
 #include <Columns/ColumnNullable.h>
 #include <Core/Field.h>
@@ -103,4 +104,19 @@ DataTypePtr removeNullable(const DataTypePtr & type)
     return type;
 }
 
+DataTypePtr removeNullableOrLowCardinalityNullable(const DataTypePtr & type)
+{
+    if (type->isNullable())
+        return static_cast<const DataTypeNullable &>(*type).getNestedType();
+
+    if (type->isLowCardinalityNullable())
+    {
+        auto dict_type = removeNullable(static_cast<const DataTypeLowCardinality &>(*type).getDictionaryType());
+        return std::make_shared<DataTypeLowCardinality>(dict_type);
+    }
+
+    return type;
+
+}
+
 }

src/DataTypes/DataTypeNullable.h

@@ -53,5 +53,6 @@ class DataTypeNullable final : public IDataType
 DataTypePtr makeNullable(const DataTypePtr & type);
 DataTypePtr makeNullableSafe(const DataTypePtr & type);
 DataTypePtr removeNullable(const DataTypePtr & type);
-
+/// Nullable(T) -> T, LowCardinality(Nullable(T)) -> T
+DataTypePtr removeNullableOrLowCardinalityNullable(const DataTypePtr & type);
 }