Altinity
diff --git a/‎src/Columns/ColumnConstable.cpp‎
Lines changed: 227 additions & 0 deletions b/‎src/Columns/ColumnConstable.cpp‎
Lines changed: 227 additions & 0 deletions
@@ -0,0 +1,227 @@
+#include <IO/WriteHelpers.h>
+
+#include <Columns/ColumnConstable.h>
+#include <Columns/ColumnConst.h>
+#include <Columns/ColumnsCommon.h>
+#include <Common/HashTable/Hash.h>
+#include <Common/WeakHash.h>
+#include <Common/iota.h>
+#include <Common/typeid_cast.h>
+
+#include <base/defines.h>
+
+#if defined(MEMORY_SANITIZER)
+    #include <sanitizer/msan_interface.h>
+#endif
+
+
+namespace DB
+{
+
+namespace ErrorCodes
+{
+extern const int LOGICAL_ERROR;
+extern const int NOT_IMPLEMENTED;
+extern const int SIZES_OF_COLUMNS_DOESNT_MATCH;
+}
+
+ColumnConstable::ColumnConstable(const ColumnPtr & data_, size_t s_)
+    : data(data_), s(s_)
+{
+    /// Squash Constable of Const or Constable.
+    while (true)
+    {
+        if (const ColumnConstable * const_data = typeid_cast<const ColumnConstable *>(data.get()))
+        {
+            data = const_data->getDataColumnPtr();
+            continue;
+        }
+        if (const ColumnConst * const_data = typeid_cast<const ColumnConst *>(data.get()))
+        {
+            data = const_data->getDataColumnPtr();
+            continue;
+        }
+        break;
+    }
+
+    is_const = (data->size() == 1);
+
+    /// Check that the value is initialized. We do it earlier, before it will be used, to ease debugging.
+#if defined(MEMORY_SANITIZER)
+    if (data->isFixedAndContiguous())
+    {
+        StringRef value = data->getDataAt(0);
+        __msan_check_mem_is_initialized(value.data, value.size);
+    }
+#endif
+}
+
+void ColumnConstable::convertDataToFullColumn()
+{
+    if (!is_const)
+        return;
+    if (s != 1)
+        data = data->replicate(Offsets(1, s));
+    is_const = false;
+}
+
+ColumnPtr ColumnConstable::convertToFullColumn() const
+{
+    if (!is_const || s == 1)
+        return data;
+    return data->replicate(Offsets(1, s));
+}
+
+ColumnPtr ColumnConstable::removeLowCardinality() const
+{
+    return ColumnConstable::create(data->convertToFullColumnIfLowCardinality(), s);
+}
+
+ColumnPtr ColumnConstable::filter(const Filter & filt, ssize_t result_size_hint) const
+{
+    if (!is_const)
+        return data->filter(filt, result_size_hint);
+
+    if (s != filt.size())
+        throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})",
+            filt.size(), toString(s));
+
+    size_t new_size = countBytesInFilter(filt);
+    return cloneResized(new_size);
+}
+
+void ColumnConstable::expand(const Filter & mask, bool inverted)
+{
+    if (mask.size() < s)
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Mask size should be no less than data size.");
+
+    size_t bytes_count = countBytesInFilter(mask);
+    if (inverted)
+        bytes_count = mask.size() - bytes_count;
+
+    if (bytes_count < s)
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Not enough bytes in mask");
+    if (bytes_count > s)
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Too many bytes in mask");
+
+    s = mask.size();
+}
+
+
+ColumnPtr ColumnConstable::replicate(const Offsets & offsets) const
+{
+    if (!is_const)
+        return data->replicate(offsets);
+
+    if (s != offsets.size())
+        throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of offsets ({}) doesn't match size of column ({})",
+            offsets.size(), toString(s));
+
+    size_t replicated_size = 0 == s ? 0 : offsets.back();
+    return ColumnConst::create(data, replicated_size);
+}
+
+ColumnPtr ColumnConstable::permute(const Permutation & perm, size_t limit) const
+{
+    if (!is_const)
+        return data->permute(perm, limit);
+
+    limit = getLimitForPermutation(size(), perm.size(), limit);
+    return ColumnConst::create(data, limit);
+}
+
+ColumnPtr ColumnConstable::index(const IColumn & indexes, size_t limit) const
+{
+    if (!is_const)
+        return data->index(indexes, limit);
+
+    if (limit == 0)
+        limit = indexes.size();
+
+    if (indexes.size() < limit)
+        throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of indexes ({}) is less than required ({})",
+                        indexes.size(), toString(limit));
+
+    return ColumnConst::create(data, limit);
+}
+
+MutableColumns ColumnConstable::scatter(ColumnIndex num_columns, const Selector & selector) const
+{
+    if (!is_const)
+        return data->scatter(num_columns, selector);
+
+    if (s != selector.size())
+        throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of selector ({}) doesn't match size of column ({})",
+            selector.size(), toString(s));
+
+    std::vector<size_t> counts = countColumnsSizeInSelector(num_columns, selector);
+
+    MutableColumns res(num_columns);
+    for (size_t i = 0; i < num_columns; ++i)
+        res[i] = cloneResized(counts[i]);
+
+    return res;
+}
+
+void ColumnConstable::gather(ColumnGathererStream &)
+{
+    throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Cannot gather into constant column {}", getName());
+}
+
+void ColumnConstable::getPermutation(PermutationSortDirection /*direction*/, PermutationSortStability /*stability*/,
+                                size_t /*limit*/, int /*nan_direction_hint*/, Permutation & res) const
+{
+    res.resize_exact(s);
+    iota(res.data(), s, IColumn::Permutation::value_type(0));
+}
+
+void ColumnConstable::updatePermutation(PermutationSortDirection /*direction*/, PermutationSortStability /*stability*/,
+                                size_t, int, Permutation &, EqualRanges &) const
+{
+}
+
+WeakHash32 ColumnConstable::getWeakHash32() const
+{
+    WeakHash32 element_hash = data->getWeakHash32();
+    if (!is_const)
+        return element_hash;
+    return WeakHash32(s, element_hash.getData()[0]);
+}
+
+void ColumnConstable::compareColumn(
+    const IColumn & rhs,
+    size_t rhs_row_num,
+    PaddedPODArray<UInt64> * row_indexes,
+    PaddedPODArray<Int8> & compare_results,
+    int direction,
+    int nan_direction_hint) const
+{
+    if (!is_const)
+        return data->compareColumn(rhs, rhs_row_num, row_indexes, compare_results, direction, nan_direction_hint);
+    Int8 res = compareAt(1, 1, rhs, nan_direction_hint);
+    std::fill(compare_results.begin(), compare_results.end(), res);
+}
+
+ColumnConstable::Ptr createColumnConstable(const ColumnPtr & column, Field value)
+{
+    auto data = column->cloneEmpty();
+    data->insert(value);
+    return ColumnConstable::create(std::move(data), 1);
+}
+
+ColumnConstable::Ptr createColumnConstable(const ColumnPtr & column, size_t const_value_index)
+{
+    auto data = column->cloneEmpty();
+    data->insertFrom(*column, const_value_index);
+    return ColumnConstable::create(std::move(data), 1);
+}
+
+ColumnConstable::Ptr createColumnConstableWithDefaultValue(const ColumnPtr & column)
+{
+    auto data = column->cloneEmpty();
+    data->insertDefault();
+    return ColumnConstable::create(std::move(data), 1);
+}
+
+
+}