Merge pull request ClickHouse#79591 from Avogar/fix-sort-by-json

Fix order by JSON column with other columns

Author: Avogar

src/Columns/ColumnObject.cpp

@@ -1192,11 +1192,50 @@ MutableColumns ColumnObject::scatter(ColumnIndex num_columns, const Selector & s
     return result_columns;
 }
 
-void ColumnObject::getPermutation(PermutationSortDirection, PermutationSortStability, size_t, int, Permutation & res) const
+struct ColumnObject::ComparatorBase
 {
-    /// Values in ColumnObject are not comparable.
-    res.resize(size());
-    iota(res.data(), res.size(), size_t(0));
+    const ColumnObject & parent;
+    int nan_direction_hint;
+
+    ComparatorBase(const ColumnObject & parent_, int nan_direction_hint_)
+        : parent(parent_), nan_direction_hint(nan_direction_hint_)
+    {
+    }
+
+    ALWAYS_INLINE int compare(size_t lhs, size_t rhs) const
+    {
+        int res = parent.compareAt(lhs, rhs, parent, nan_direction_hint);
+
+        return res;
+    }
+};
+
+void ColumnObject::getPermutation(PermutationSortDirection direction, PermutationSortStability stability,
+                                  size_t limit, int nan_direction_hint, Permutation & res) const
+{
+    if (direction == IColumn::PermutationSortDirection::Ascending && stability == IColumn::PermutationSortStability::Unstable)
+        getPermutationImpl(limit, res, ComparatorAscendingUnstable(*this, nan_direction_hint), DefaultSort(), DefaultPartialSort());
+    else if (direction == IColumn::PermutationSortDirection::Ascending && stability == IColumn::PermutationSortStability::Stable)
+        getPermutationImpl(limit, res, ComparatorAscendingStable(*this, nan_direction_hint), DefaultSort(), DefaultPartialSort());
+    else if (direction == IColumn::PermutationSortDirection::Descending && stability == IColumn::PermutationSortStability::Unstable)
+        getPermutationImpl(limit, res, ComparatorDescendingUnstable(*this, nan_direction_hint), DefaultSort(), DefaultPartialSort());
+    else if (direction == IColumn::PermutationSortDirection::Descending && stability == IColumn::PermutationSortStability::Stable)
+        getPermutationImpl(limit, res, ComparatorDescendingStable(*this, nan_direction_hint), DefaultSort(), DefaultPartialSort());
+}
+
+void ColumnObject::updatePermutation(PermutationSortDirection direction, PermutationSortStability stability,
+                                     size_t limit, int nan_direction_hint, Permutation & res, EqualRanges & equal_ranges) const
+{
+    auto comparator_equal = ComparatorEqual(*this, nan_direction_hint);
+
+    if (direction == IColumn::PermutationSortDirection::Ascending && stability == IColumn::PermutationSortStability::Unstable)
+        updatePermutationImpl(limit, res, equal_ranges, ComparatorAscendingUnstable(*this, nan_direction_hint), comparator_equal, DefaultSort(), DefaultPartialSort());
+    else if (direction == IColumn::PermutationSortDirection::Ascending && stability == IColumn::PermutationSortStability::Stable)
+        updatePermutationImpl(limit, res, equal_ranges, ComparatorAscendingStable(*this, nan_direction_hint), comparator_equal, DefaultSort(), DefaultPartialSort());
+    else if (direction == IColumn::PermutationSortDirection::Descending && stability == IColumn::PermutationSortStability::Unstable)
+        updatePermutationImpl(limit, res, equal_ranges, ComparatorDescendingUnstable(*this, nan_direction_hint), comparator_equal, DefaultSort(), DefaultPartialSort());
+    else if (direction == IColumn::PermutationSortDirection::Descending && stability == IColumn::PermutationSortStability::Stable)
+        updatePermutationImpl(limit, res, equal_ranges, ComparatorDescendingStable(*this, nan_direction_hint), comparator_equal, DefaultSort(), DefaultPartialSort());
 }
 
 void ColumnObject::reserve(size_t n)

src/Columns/ColumnObject.h

@@ -40,6 +40,22 @@ class ColumnObject final : public COWHelper<IColumnHelper<ColumnObject>, ColumnO
 
     using StatisticsPtr = std::shared_ptr<const Statistics>;
 
+    struct ComparatorBase;
+
+    using ComparatorAscendingUnstable = ComparatorAscendingUnstableImpl<ComparatorBase>;
+    using ComparatorAscendingStable = ComparatorAscendingStableImpl<ComparatorBase>;
+    using ComparatorDescendingUnstable = ComparatorDescendingUnstableImpl<ComparatorBase>;
+    using ComparatorDescendingStable = ComparatorDescendingStableImpl<ComparatorBase>;
+    using ComparatorEqual = ComparatorEqualImpl<ComparatorBase>;
+
+    struct ComparatorCollationBase;
+
+    using ComparatorCollationAscendingUnstable = ComparatorAscendingUnstableImpl<ComparatorCollationBase>;
+    using ComparatorCollationAscendingStable = ComparatorAscendingStableImpl<ComparatorCollationBase>;
+    using ComparatorCollationDescendingUnstable = ComparatorDescendingUnstableImpl<ComparatorCollationBase>;
+    using ComparatorCollationDescendingStable = ComparatorDescendingStableImpl<ComparatorCollationBase>;
+    using ComparatorCollationEqual = ComparatorEqualImpl<ComparatorCollationBase>;
+
 private:
     friend class COWHelper<IColumnHelper<ColumnObject>, ColumnObject>;
 
@@ -142,11 +158,11 @@ class ColumnObject final : public COWHelper<IColumnHelper<ColumnObject>, ColumnO
     ColumnPtr replicate(const Offsets & replicate_offsets) const override;
     MutableColumns scatter(ColumnIndex num_columns, const Selector & selector) const override;
 
-    void getPermutation(PermutationSortDirection, PermutationSortStability, size_t, int, Permutation &) const override;
-    void updatePermutation(PermutationSortDirection, PermutationSortStability, size_t, int, Permutation &, EqualRanges &) const override {}
+    void getPermutation(PermutationSortDirection direction, PermutationSortStability stability,
+                        size_t limit, int nan_direction_hint, Permutation & res) const override;
+    void updatePermutation(PermutationSortDirection direction, PermutationSortStability stability,
+                           size_t limit, int nan_direction_hint, Permutation & res, EqualRanges & equal_ranges) const override;
 
-    /// Values of ColumnObject are not comparable for less and greater functions.
-    /// But we still support equal comparison.
 #if !defined(DEBUG_OR_SANITIZER_BUILD)
     int compareAt(size_t, size_t, const IColumn &, int nan_direction_hint) const override;
 #else

tests/queries/0_stateless/03447_order_by_json_and_other_column.reference

@@ -0,0 +1,4 @@
+{"a":"1"}	
+{"a":"2"}	
+{"a":"2"}	
+{"a":"4"}	

tests/queries/0_stateless/03447_order_by_json_and_other_column.sql

@@ -0,0 +1,6 @@
+drop table if exists test;
+create table test (json JSON) engine=Memory;
+insert into test values ('{"a" : 1}'), ('{"a" : 2}'), ('{"a" : 2}'), ('{"a" : 4}');
+select json, materialize('') from test order by all asc;
+drop table test;
+