diff --git a/cpp/src/arrow/compute/kernels/chunked_internal.h b/cpp/src/arrow/compute/kernels/chunked_internal.h
index b007d6cbfb8..7e66e9b6403 100644
--- a/cpp/src/arrow/compute/kernels/chunked_internal.h
+++ b/cpp/src/arrow/compute/kernels/chunked_internal.h
@@ -48,6 +48,19 @@ struct ResolvedChunk {
   LogicalValueType Value() const { return V::LogicalValue(array->GetView(index)); }
 };
 
+// ResolvedChunk specialization for StructArray
+template <>
+struct ResolvedChunk<StructArray> {
+  // The target struct in chunked array.
+  const StructArray* array;
+  // The field index in the target struct.
+  const int64_t index;
+
+  ResolvedChunk(const StructArray* array, int64_t index) : array(array), index(index) {}
+
+  bool IsNull() const { return array->field(0)->IsNull(index); }
+};
+
 // ResolvedChunk specialization for untyped arrays when all is needed is null lookup
 template <>
 struct ResolvedChunk<Array> {
diff --git a/cpp/src/arrow/compute/kernels/vector_array_sort.cc b/cpp/src/arrow/compute/kernels/vector_array_sort.cc
index 1335882a252..844b7ad0c2a 100644
--- a/cpp/src/arrow/compute/kernels/vector_array_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_array_sort.cc
@@ -172,6 +172,49 @@ class ArrayCompareSorter {
   }
 };
 
+template <typename ArrowType>
+class StructArrayCompareSorter {
+  using ArrayType = typename TypeTraits<ArrowType>::ArrayType;
+
+ public:
+  // `offset` is used when this is called on a chunk of a chunked array
+  NullPartitionResult operator()(uint64_t* indices_begin, uint64_t* indices_end,
+                                 const Array& array, int64_t offset,
+                                 const ArraySortOptions& options) {
+    const auto& values = checked_cast<const ArrayType&>(array);
+    nested_value_comparator_ = std::make_shared<NestedValuesComparator>();
+
+    if (nested_value_comparator_->Prepare(values) != Status::OK()) {
+      // TODO: Improve error handling
+      return NullPartitionResult();
+    }
+
+    const auto p = PartitionNulls<ArrayType, StablePartitioner>(
+        indices_begin, indices_end, values, offset, options.null_placement);
+
+    bool asc_order = options.order == SortOrder::Ascending;
+    std::stable_sort(p.non_nulls_begin, p.non_nulls_end,
+                     [&offset, &values, asc_order, this](uint64_t left, uint64_t right) {
+                       // is better to do values.fields.size() or
+                       // values.schema().num_fields() ?
+                       for (ArrayVector::size_type fieldidx = 0;
+                            fieldidx < values.fields().size(); ++fieldidx) {
+                         int result = nested_value_comparator_->Compare(
+                             values, fieldidx, offset, asc_order ? left : right,
+                             asc_order ? right : left);
+                         if (result == -1)
+                           return true;
+                         else if (result == 1)
+                           return false;
+                       }
+                       return false;
+                     });
+    return p;
+  }
+
+  std::shared_ptr<NestedValuesComparator> nested_value_comparator_;
+};
+
 template <typename ArrowType>
 class ArrayCountSorter {
   using ArrayType = typename TypeTraits<ArrowType>::ArrayType;
@@ -410,6 +453,11 @@ struct ArraySorter<
   ArrayCompareSorter<Type> impl;
 };
 
+template <typename Type>
+struct ArraySorter<Type, enable_if_t<is_struct_type<Type>::value>> {
+  StructArrayCompareSorter<Type> impl;
+};
+
 struct ArraySorterFactory {
   ArraySortFunc sorter;
 
@@ -511,6 +559,13 @@ const ArraySortOptions* GetDefaultArraySortOptions() {
   return &kDefaultArraySortOptions;
 }
 
+template <template <typename...> class ExecTemplate>
+void AddArraySortingNestedKernels(VectorKernel base, VectorFunction* func) {
+  base.signature = KernelSignature::Make({InputType::Array(Type::STRUCT)}, uint64());
+  base.exec = ExecTemplate<UInt64Type, StructType>::Exec;
+  DCHECK_OK(func->AddKernel(base));
+}
+
 const FunctionDoc array_sort_indices_doc(
     "Return the indices that would sort an array",
     ("This function computes an array of indices that define a stable sort\n"
@@ -559,6 +614,7 @@ void RegisterVectorArraySort(FunctionRegistry* registry) {
       GetDefaultArraySortOptions());
   base.init = ArraySortIndicesState::Init;
   AddArraySortingKernels<ArraySortIndices>(base, array_sort_indices.get());
+  AddArraySortingNestedKernels<ArraySortIndices>(base, array_sort_indices.get());
   DCHECK_OK(registry->AddFunction(std::move(array_sort_indices)));
 
   // partition_nth_indices has a parameter so needs its init function
diff --git a/cpp/src/arrow/compute/kernels/vector_sort.cc b/cpp/src/arrow/compute/kernels/vector_sort.cc
index dd5bead58aa..c1b55dea765 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort.cc
+++ b/cpp/src/arrow/compute/kernels/vector_sort.cc
@@ -99,10 +99,10 @@ Result<std::vector<ResolvedSortKey>> ResolveSortKeys(
 template <typename ResolvedSortKey, typename TableOrBatch>
 Result<std::vector<ResolvedSortKey>> ResolveSortKeys(
     const TableOrBatch& table_or_batch, const std::vector<SortKey>& sort_keys) {
-  return ResolveSortKeys<ResolvedSortKey>(
-      *table_or_batch.schema(), sort_keys, [&](const SortField& f) {
-        return ResolvedSortKey{table_or_batch.column(f.field_index), f.order};
-      });
+  return ResolveSortKeys<
+      ResolvedSortKey>(*table_or_batch.schema(), sort_keys, [&](const SortField& f) {
+    return ResolvedSortKey{table_or_batch.column(f.field_index), f.order, f.field_index};
+  });
 }
 
 // Returns nullptr if no column matching `ref` is found, or if the FieldRef is
@@ -189,6 +189,8 @@ class ChunkedArraySorter : public TypeVisitor {
     return Status::OK();
   }
 
+  Status Visit(const StructType& type) override { return SortInternal<StructType>(); }
+
  private:
   template <typename Type>
   Status SortInternal() {
@@ -270,25 +272,18 @@ class ChunkedArraySorter : public TypeVisitor {
   template <typename ArrayType>
   void MergeNonNulls(uint64_t* range_begin, uint64_t* range_middle, uint64_t* range_end,
                      const std::vector<const Array*>& arrays, uint64_t* temp_indices) {
-    const ChunkedArrayResolver left_resolver(arrays);
-    const ChunkedArrayResolver right_resolver(arrays);
+    const ChunkedArrayResolver chunk_resolver(arrays);
+    ResolvedChunkComparator<ArrayType> resolved_chunk_comparator;
 
     if (order_ == SortOrder::Ascending) {
       std::merge(range_begin, range_middle, range_middle, range_end, temp_indices,
                  [&](uint64_t left, uint64_t right) {
-                   const auto chunk_left = left_resolver.Resolve<ArrayType>(left);
-                   const auto chunk_right = right_resolver.Resolve<ArrayType>(right);
-                   return chunk_left.Value() < chunk_right.Value();
+                   return resolved_chunk_comparator.Compare(chunk_resolver, left, right);
                  });
     } else {
       std::merge(range_begin, range_middle, range_middle, range_end, temp_indices,
                  [&](uint64_t left, uint64_t right) {
-                   const auto chunk_left = left_resolver.Resolve<ArrayType>(left);
-                   const auto chunk_right = right_resolver.Resolve<ArrayType>(right);
-                   // We don't use 'left > right' here to reduce required
-                   // operator. If we use 'right < left' here, '<' is only
-                   // required.
-                   return chunk_right.Value() < chunk_left.Value();
+                   return resolved_chunk_comparator.Compare(chunk_resolver, right, left);
                  });
     }
     // Copy back temp area into main buffer
@@ -355,20 +350,23 @@ class ConcreteRecordBatchColumnSorter : public RecordBatchColumnSorter {
  public:
   using ArrayType = typename TypeTraits<Type>::ArrayType;
 
-  ConcreteRecordBatchColumnSorter(std::shared_ptr<Array> array, SortOrder order,
-                                  NullPlacement null_placement,
-                                  RecordBatchColumnSorter* next_column = nullptr)
+  ConcreteRecordBatchColumnSorter(
+      const RecordBatch& batch, std::shared_ptr<Array> array, SortOrder order,
+      NullPlacement null_placement, uint64_t field_index,
+      std::shared_ptr<NestedValuesComparator> nested_values_comparator,
+      RecordBatchColumnSorter* next_column = nullptr)
       : RecordBatchColumnSorter(next_column),
+        batch_(batch),
         owned_array_(std::move(array)),
+        nested_values_comparator_(std::move(nested_values_comparator)),
         array_(checked_cast<const ArrayType&>(*owned_array_)),
         order_(order),
         null_placement_(null_placement),
-        null_count_(array_.null_count()) {}
+        null_count_(array_.null_count()),
+        field_index_(field_index) {}
 
   NullPartitionResult SortRange(uint64_t* indices_begin, uint64_t* indices_end,
                                 int64_t offset) override {
-    using GetView = GetViewType<Type>;
-
     NullPartitionResult p;
     if (null_count_ == 0) {
       p = NullPartitionResult::NoNulls(indices_begin, indices_end, null_placement_);
@@ -386,21 +384,17 @@ class ConcreteRecordBatchColumnSorter : public RecordBatchColumnSorter {
     // Also, we would like to use a counting sort if possible.  This requires
     // a counting sort compatible with indirect indexing.
     if (order_ == SortOrder::Ascending) {
-      std::stable_sort(
-          q.non_nulls_begin, q.non_nulls_end, [&](uint64_t left, uint64_t right) {
-            const auto lhs = GetView::LogicalValue(array_.GetView(left - offset));
-            const auto rhs = GetView::LogicalValue(array_.GetView(right - offset));
-            return lhs < rhs;
-          });
+      std::stable_sort(q.non_nulls_begin, q.non_nulls_end,
+                       [&](uint64_t left, uint64_t right) {
+                         return nested_values_comparator_->Compare(
+                                    batch_, field_index_, offset, left, right) == -1;
+                       });
     } else {
-      std::stable_sort(
-          q.non_nulls_begin, q.non_nulls_end, [&](uint64_t left, uint64_t right) {
-            // We don't use 'left > right' here to reduce required operator.
-            // If we use 'right < left' here, '<' is only required.
-            const auto lhs = GetView::LogicalValue(array_.GetView(left - offset));
-            const auto rhs = GetView::LogicalValue(array_.GetView(right - offset));
-            return lhs > rhs;
-          });
+      std::stable_sort(q.non_nulls_begin, q.non_nulls_end,
+                       [&](uint64_t left, uint64_t right) {
+                         return nested_values_comparator_->Compare(
+                                    batch_, field_index_, offset, left, right) == 1;
+                       });
     }
 
     if (next_column_ != nullptr) {
@@ -426,19 +420,24 @@ class ConcreteRecordBatchColumnSorter : public RecordBatchColumnSorter {
   }
 
  protected:
+  const RecordBatch& batch_;
   const std::shared_ptr<Array> owned_array_;
+  const std::shared_ptr<NestedValuesComparator> nested_values_comparator_;
   const ArrayType& array_;
   const SortOrder order_;
   const NullPlacement null_placement_;
   const int64_t null_count_;
+  const int64_t field_index_;
 };
 
 template <>
 class ConcreteRecordBatchColumnSorter<NullType> : public RecordBatchColumnSorter {
  public:
-  ConcreteRecordBatchColumnSorter(std::shared_ptr<Array> array, SortOrder order,
-                                  NullPlacement null_placement,
-                                  RecordBatchColumnSorter* next_column = nullptr)
+  ConcreteRecordBatchColumnSorter(
+      const RecordBatch& batch, std::shared_ptr<Array> array, SortOrder order,
+      NullPlacement null_placement, uint64_t field_index,
+      std::shared_ptr<NestedValuesComparator> nested_values_comparator,
+      RecordBatchColumnSorter* next_column = nullptr)
       : RecordBatchColumnSorter(next_column), null_placement_(null_placement) {}
 
   NullPartitionResult SortRange(uint64_t* indices_begin, uint64_t* indices_end,
@@ -472,7 +471,7 @@ class RadixRecordBatchSorter {
     std::vector<std::unique_ptr<RecordBatchColumnSorter>> column_sorts(sort_keys.size());
     RecordBatchColumnSorter* next_column = nullptr;
     for (int64_t i = static_cast<int64_t>(sort_keys.size() - 1); i >= 0; --i) {
-      ColumnSortFactory factory(sort_keys[i], options_, next_column);
+      ColumnSortFactory factory(batch_, sort_keys[i], options_, next_column);
       ARROW_ASSIGN_OR_RAISE(column_sorts[i], factory.MakeColumnSort());
       next_column = column_sorts[i].get();
     }
@@ -485,16 +484,26 @@ class RadixRecordBatchSorter {
   struct ResolvedSortKey {
     std::shared_ptr<Array> array;
     SortOrder order;
+    int field_index;
   };
 
   struct ColumnSortFactory {
-    ColumnSortFactory(const ResolvedSortKey& sort_key, const SortOptions& options,
-                      RecordBatchColumnSorter* next_column)
-        : physical_type(GetPhysicalType(sort_key.array->type())),
+    ColumnSortFactory(const RecordBatch& batch, const ResolvedSortKey& sort_key,
+                      const SortOptions& options, RecordBatchColumnSorter* next_column)
+        : batch_(batch),
+          physical_type(GetPhysicalType(sort_key.array->type())),
           array(GetPhysicalArray(*sort_key.array, physical_type)),
           order(sort_key.order),
           null_placement(options.null_placement),
-          next_column(next_column) {}
+          next_column(next_column),
+          field_index_(sort_key.field_index),
+          nested_values_comparator_(nullptr) {
+      nested_values_comparator_ = std::make_shared<NestedValuesComparator>();
+      auto s = nested_values_comparator_->Prepare(batch);
+      if (!s.ok()) {
+        return;
+      }
+    }
 
     Result<std::unique_ptr<RecordBatchColumnSorter>> MakeColumnSort() {
       RETURN_NOT_OK(VisitTypeInline(*physical_type, this));
@@ -517,17 +526,21 @@ class RadixRecordBatchSorter {
 
     template <typename Type>
     Status VisitGeneric(const Type&) {
-      result.reset(new ConcreteRecordBatchColumnSorter<Type>(array, order, null_placement,
-                                                             next_column));
+      result.reset(new ConcreteRecordBatchColumnSorter<Type>(
+          batch_, array, order, null_placement, field_index_, nested_values_comparator_,
+          next_column));
       return Status::OK();
     }
 
+    const RecordBatch& batch_;
     std::shared_ptr<DataType> physical_type;
     std::shared_ptr<Array> array;
     SortOrder order;
     NullPlacement null_placement;
     RecordBatchColumnSorter* next_column;
+    int64_t field_index_;
     std::unique_ptr<RecordBatchColumnSorter> result;
+    std::shared_ptr<NestedValuesComparator> nested_values_comparator_;
   };
 
   static Result<std::vector<ResolvedSortKey>> ResolveSortKeys(
@@ -690,11 +703,12 @@ class MultipleKeyRecordBatchSorter : public TypeVisitor {
  public:
   // Preprocessed sort key.
   struct ResolvedSortKey {
-    ResolvedSortKey(const std::shared_ptr<Array>& array, SortOrder order)
+    ResolvedSortKey(const std::shared_ptr<Array>& array, SortOrder order, int field_index)
         : type(GetPhysicalType(array->type())),
           owned_array(GetPhysicalArray(*array, type)),
           array(*owned_array),
           order(order),
+          field_index(field_index),
           null_count(array->null_count()) {}
 
     using LocationType = int64_t;
@@ -708,6 +722,7 @@ class MultipleKeyRecordBatchSorter : public TypeVisitor {
     std::shared_ptr<Array> owned_array;
     const Array& array;
     SortOrder order;
+    int field_index;
     int64_t null_count;
   };
 
@@ -717,11 +732,17 @@ class MultipleKeyRecordBatchSorter : public TypeVisitor {
  public:
   MultipleKeyRecordBatchSorter(uint64_t* indices_begin, uint64_t* indices_end,
                                const RecordBatch& batch, const SortOptions& options)
-      : indices_begin_(indices_begin),
+      : batch_(batch),
+        indices_begin_(indices_begin),
         indices_end_(indices_end),
         sort_keys_(ResolveSortKeys(batch, options.sort_keys, &status_)),
         null_placement_(options.null_placement),
-        comparator_(sort_keys_, null_placement_) {}
+        comparator_(sort_keys_, null_placement_) {
+    auto s = nested_values_comparator_.Prepare(batch);
+    if (!s.ok()) {
+      return;
+    }
+  }
 
   // This is optimized for the first sort key. The first sort key sort
   // is processed in this class. The second and following sort keys
@@ -753,35 +774,47 @@ class MultipleKeyRecordBatchSorter : public TypeVisitor {
 
   template <typename Type>
   enable_if_t<!is_null_type<Type>::value, Status> SortInternal() {
-    using ArrayType = typename TypeTraits<Type>::ArrayType;
-    using GetView = GetViewType<Type>;
-
-    auto& comparator = comparator_;
     const auto& first_sort_key = sort_keys_[0];
-    const ArrayType& array = checked_cast<const ArrayType&>(first_sort_key.array);
     const auto p = PartitionNullsInternal<Type>(first_sort_key);
 
     // Sort first-key non-nulls
-    std::stable_sort(
-        p.non_nulls_begin, p.non_nulls_end, [&](uint64_t left, uint64_t right) {
-          // Both values are never null nor NaN
-          // (otherwise they've been partitioned away above).
-          const auto value_left = GetView::LogicalValue(array.GetView(left));
-          const auto value_right = GetView::LogicalValue(array.GetView(right));
-          if (value_left != value_right) {
-            bool compared = value_left < value_right;
-            if (first_sort_key.order == SortOrder::Ascending) {
-              return compared;
-            } else {
-              return !compared;
-            }
-          }
-          // If the left value equals to the right value,
-          // we need to compare the second and following
-          // sort keys.
-          return comparator.Compare(left, right, 1);
-        });
-    return comparator_.status();
+    std::stable_sort(p.non_nulls_begin, p.non_nulls_end,
+                     [&](uint64_t left, uint64_t right) {
+                       // Both values are never null nor NaN
+                       // (otherwise they've been partitioned away above).
+                       int val = nested_values_comparator_.Compare(
+                           batch_, sort_keys_[0].field_index, 0, left, right);
+
+                       if (val != 0) {
+                         // this overload of compare does not take sort order
+                         // so it needs to be handled here
+                         if (sort_keys_[0].order == SortOrder::Ascending) {
+                           return val == -1;
+                         } else {
+                           return val == 1;
+                         }
+                       }
+
+                       const auto sort_keys_len = sort_keys_.size();
+                       for (size_t i = 1; i < sort_keys_len; i++) {
+                         int val = nested_values_comparator_.Compare(
+                             batch_, null_placement_, sort_keys_[i].order,
+                             sort_keys_[i].field_index, 0, left, right);
+
+                         if (val == 0) {
+                           continue;
+                         }
+
+                         // overload of compare taking in sort key order takes care of
+                         // sort order
+                         return val < 0;
+                       }
+
+                       // all column values are equal
+                       return false;
+                     });
+
+    return Status::OK();
   }
 
   template <typename Type>
@@ -825,12 +858,14 @@ class MultipleKeyRecordBatchSorter : public TypeVisitor {
     return q;
   }
 
+  const RecordBatch& batch_;
   uint64_t* indices_begin_;
   uint64_t* indices_end_;
   Status status_;
   std::vector<ResolvedSortKey> sort_keys_;
   NullPlacement null_placement_;
   Comparator comparator_;
+  NestedValuesComparator nested_values_comparator_;
 };
 
 // ----------------------------------------------------------------------
@@ -1593,7 +1628,7 @@ class RecordBatchSelecter : public TypeVisitor {
     std::vector<ResolvedSortKey> resolved;
     for (const auto& key : sort_keys) {
       auto array = key.target.GetOne(batch).ValueOr(nullptr);
-      resolved.emplace_back(array, key.order);
+      resolved.emplace_back(array, key.order, -1);
     }
     return resolved;
   }
diff --git a/cpp/src/arrow/compute/kernels/vector_sort_internal.h b/cpp/src/arrow/compute/kernels/vector_sort_internal.h
index d8b024525c8..72dae776e10 100644
--- a/cpp/src/arrow/compute/kernels/vector_sort_internal.h
+++ b/cpp/src/arrow/compute/kernels/vector_sort_internal.h
@@ -21,10 +21,12 @@
 #include <cmath>
 #include <cstdint>
 #include <functional>
+#include <iostream>
 
 #include "arrow/array.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/chunked_internal.h"
+#include "arrow/table.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
 
@@ -456,6 +458,347 @@ Status SortChunkedArray(ExecContext* ctx, uint64_t* indices_begin, uint64_t* ind
                         const ChunkedArray& values, SortOrder sort_order,
                         NullPlacement null_placement);
 
+// Common Comparator for all DataStructures with NestedValues like StructArray,
+// ChunkedArray, Table and RecordBatch
+class NestedValuesComparator {
+ public:
+  // StructArray Compare overload
+  int Compare(StructArray const& array, uint64_t field_index, uint64_t offset,
+              uint64_t leftrowidx, uint64_t rightrowidx) {
+    std::shared_ptr<Array> field = array.field(static_cast<int>(field_index));
+    return comparators_[field_index]->Compare(*field, offset, leftrowidx, rightrowidx);
+  }
+
+  // StructArray Prepare overload
+  Status Prepare(StructArray const& array) {
+    auto fields = array.fields();
+    for (auto field = fields.begin(); field != fields.end(); field++) {
+      std::shared_ptr<DataType> physical_type = GetPhysicalType((*field)->type());
+      NestedComparatorFactory comparator_factory = NestedComparatorFactory();
+      std::shared_ptr<NestedValueComparator> current_field_comparator;
+      ARROW_ASSIGN_OR_RAISE(
+          current_field_comparator,
+          NestedComparatorFactory().MakeFieldComparator(*physical_type));
+      comparators_.push_back(current_field_comparator);
+    }
+    return Status::OK();
+  }
+
+  // Table Compare overload
+  int Compare(Table const& table, uint64_t field_index, uint64_t offset,
+              uint64_t leftrowidx, uint64_t rightrowidx) {
+    std::shared_ptr<ChunkedArray> field = table.column(static_cast<int>(field_index));
+    return comparators_[field_index]->Compare(*field, offset, leftrowidx, rightrowidx);
+  }
+
+  // Table Prepare overload
+  Status Prepare(Table const& array) {
+    auto fields = array.columns();
+    for (auto field = fields.begin(); field != fields.end(); field++) {
+      std::shared_ptr<DataType> physical_type = GetPhysicalType((*field)->type());
+      NestedComparatorFactory comparator_factory = NestedComparatorFactory();
+      std::shared_ptr<NestedValueComparator> current_field_comparator;
+      ARROW_ASSIGN_OR_RAISE(
+          current_field_comparator,
+          NestedComparatorFactory().MakeFieldComparator(*physical_type));
+      comparators_.push_back(current_field_comparator);
+    }
+    return Status::OK();
+  }
+
+  // RecordBatch Compare overload
+  int Compare(RecordBatch const& batch, uint64_t field_index, uint64_t offset,
+              uint64_t leftrowidx, uint64_t rightrowidx) {
+    std::shared_ptr<Array> field = batch.column(static_cast<int>(field_index));
+    return comparators_[field_index]->Compare(*field, offset, leftrowidx, rightrowidx);
+  }
+
+  // RecordBatch Compare overload
+  int Compare(RecordBatch const& batch, NullPlacement null_placement,
+              SortOrder sort_order, uint64_t field_index, uint64_t offset,
+              uint64_t leftrowidx, uint64_t rightrowidx) {
+    std::shared_ptr<Array> field = batch.column(static_cast<int>(field_index));
+    return comparators_[field_index]->Compare(*field, null_placement, sort_order, offset,
+                                              leftrowidx, rightrowidx);
+  }
+
+  // RecordBatch Prepare overload
+  Status Prepare(RecordBatch const& batch) {
+    auto fields = batch.columns();
+    for (auto field = fields.begin(); field != fields.end(); field++) {
+      std::shared_ptr<DataType> physical_type = GetPhysicalType((*field)->type());
+      NestedComparatorFactory comparator_factory = NestedComparatorFactory();
+      std::shared_ptr<NestedValueComparator> current_field_comparator;
+      ARROW_ASSIGN_OR_RAISE(
+          current_field_comparator,
+          NestedComparatorFactory().MakeFieldComparator(*physical_type));
+      comparators_.push_back(current_field_comparator);
+    }
+    return Status::OK();
+  }
+
+  // ResolvedChunk<StructArray> Prepare overload
+  Status Prepare(const ResolvedChunk<StructArray>& chunk_left,
+                 const ResolvedChunk<StructArray>&) {
+    return Prepare(*chunk_left.array);
+  }
+
+  // ResolvedChunk<StructArray> Compare overload
+  int Compare(const ResolvedChunk<StructArray>& chunk_left,
+              const ResolvedChunk<StructArray>& chunk_right, uint64_t field_index) {
+    std::shared_ptr<Array> field_left =
+        chunk_left.array->field(static_cast<int>(field_index));
+    std::shared_ptr<Array> field_right =
+        chunk_right.array->field(static_cast<int>(field_index));
+    return comparators_[field_index]->Compare(*field_left, *field_right, chunk_left.index,
+                                              chunk_right.index);
+  }
+
+ private:
+  struct NestedValueComparator {
+    virtual int Compare(Array const& array, uint64_t offset, uint64_t leftidx,
+                        uint64_t rightidx) = 0;
+
+    virtual int Compare(Array const& left_array, Array const& right_array,
+                        uint64_t leftidx, uint64_t rightidx) = 0;
+
+    virtual int Compare(ChunkedArray const& array, uint64_t offset, uint64_t leftidx,
+                        uint64_t rightidx) = 0;
+
+    virtual int Compare(Array const& array, NullPlacement null_placement,
+                        SortOrder sort_order, uint64_t offset, uint64_t leftidx,
+                        uint64_t rightidx) = 0;
+
+    virtual ~NestedValueComparator() = default;
+  };
+
+  template <typename Type>
+  struct ConcreteNestedValueComparator : NestedValueComparator {
+    using FieldArrayType = typename TypeTraits<Type>::ArrayType;
+    using GetView = GetViewType<Type>;
+
+    virtual int Compare(Array const& array, uint64_t offset, uint64_t leftidx,
+                        uint64_t rightidx) {
+      const FieldArrayType& values = checked_cast<const FieldArrayType&>(array);
+      auto left_value = GetView::LogicalValue(values.GetView(leftidx - offset));
+      auto right_value = GetView::LogicalValue(values.GetView(rightidx - offset));
+      if (left_value == right_value)
+        return 0;
+      else if (left_value < right_value)
+        return -1;
+      else
+        return 1;
+    }
+
+    virtual int Compare(ChunkedArray const& chunked_array, uint64_t offset,
+                        uint64_t leftidx, uint64_t rightidx) {
+      using Val = decltype(GetView::LogicalValue(
+          checked_cast<const FieldArrayType&>(chunked_array.chunk(0)).GetView(0)));
+      Val l_value = 0, r_value = 0;
+
+      int n_chunks = chunked_array.num_chunks();
+      for (int i = 0; i < n_chunks; i++) {
+        auto chunk = chunked_array.chunk(i);
+        if (leftidx < static_cast<uint64_t>(chunk->length())) {
+          const FieldArrayType& values = checked_cast<const FieldArrayType&>(*chunk);
+          l_value = GetView::LogicalValue(values.GetView(leftidx));
+          break;
+        }
+        leftidx -= chunk->length();
+      }
+
+      for (int i = 0; i < n_chunks; i++) {
+        auto chunk = chunked_array.chunk(i);
+        if (rightidx < static_cast<uint64_t>(chunk->length())) {
+          const FieldArrayType& values = checked_cast<const FieldArrayType&>(*chunk);
+          r_value = GetView::LogicalValue(values.GetView(rightidx));
+          break;
+        }
+        rightidx -= chunk->length();
+      }
+
+      if (l_value == r_value)
+        return 0;
+      else if (l_value < r_value)
+        return -1;
+      else
+        return 1;
+    }
+
+    virtual int Compare(Array const& array, NullPlacement null_placement,
+                        SortOrder sort_order, uint64_t offset, uint64_t leftidx,
+                        uint64_t rightidx) {
+      // Null values
+      if (array.null_count() > 0) {
+        const bool is_null_left = array.IsNull(leftidx);
+        const bool is_null_right = array.IsNull(rightidx);
+        if (is_null_left && is_null_right) {
+          return 0;
+        } else if (is_null_left) {
+          return null_placement == NullPlacement::AtStart ? -1 : 1;
+        } else if (is_null_right) {
+          return null_placement == NullPlacement::AtStart ? 1 : -1;
+        }
+      }
+
+      const FieldArrayType& values = checked_cast<const FieldArrayType&>(array);
+      auto left_value = GetView::LogicalValue(values.GetView(leftidx - offset));
+      auto right_value = GetView::LogicalValue(values.GetView(rightidx - offset));
+
+      // Supports NaN values
+      return CompareTypeValues<Type>(left_value, right_value, sort_order, null_placement);
+    }
+
+    virtual int Compare(Array const& left_array, Array const& right_array,
+                        uint64_t leftidx, uint64_t rightidx) {
+      const FieldArrayType& left_values = checked_cast<const FieldArrayType&>(left_array);
+      const FieldArrayType& right_values =
+          checked_cast<const FieldArrayType&>(right_array);
+      auto left_value = GetView::LogicalValue(left_values.GetView(leftidx));
+      auto right_value = GetView::LogicalValue(right_values.GetView(rightidx));
+
+      if (left_value == right_value)
+        return 0;
+      else if (left_value < right_value)
+        return -1;
+      else
+        return 1;
+    }
+  };
+
+  struct ConcreteNullNestedValueComparator : NestedValueComparator {
+    virtual int Compare(Array const& array, uint64_t offset, uint64_t leftidx,
+                        uint64_t rightidx) {
+      return 0;
+    }
+
+    virtual int Compare(Array const& array, NullPlacement null_placement,
+                        SortOrder sort_order, uint64_t offset, uint64_t leftidx,
+                        uint64_t rightidx) {
+      return 0;
+    }
+
+    virtual int Compare(Array const& left_array, Array const& right_array,
+                        uint64_t leftidx, uint64_t rightidx) {
+      return 0;
+    }
+
+    virtual int Compare(ChunkedArray const& chunked_array, uint64_t offset,
+                        uint64_t leftidx, uint64_t rightidx) {
+      return 0;
+    }
+  };
+
+  /**
+   * Internal use factory whose purpose is to detect the right type
+   * of comparator that should be built to be able to compare two
+   * nested values in the same field or column
+   */
+  struct NestedComparatorFactory {
+    Result<std::shared_ptr<NestedValueComparator>> MakeFieldComparator(
+        DataType const& physical_type) {
+      RETURN_NOT_OK(VisitTypeInline(physical_type, this));
+      DCHECK_NE(current_field_comparator_, nullptr);
+      return std::move(current_field_comparator_);
+    }
+
+#define VISIT(TYPE) \
+  Status Visit(const TYPE& type) { return VisitGeneric(type); }
+
+    VISIT_SORTABLE_PHYSICAL_TYPES(VISIT)
+#undef VISIT
+
+    Status Visit(const DataType& type) {
+      return Status::TypeError("Unsupported type for NestedComparatorFactory: ",
+                               type.ToString());
+    }
+
+    template <typename Type>
+    Status VisitGeneric(const Type&) {
+      current_field_comparator_ = std::shared_ptr<NestedValueComparator>(
+          new ConcreteNestedValueComparator<Type>());
+      return Status::OK();
+    }
+
+    Status Visit(const NullType&) {
+      current_field_comparator_ =
+          std::shared_ptr<NestedValueComparator>(new ConcreteNullNestedValueComparator());
+      return Status::OK();
+    }
+
+    Status Visit(const Date32Type&) {
+      current_field_comparator_ = std::shared_ptr<NestedValueComparator>(
+          new ConcreteNestedValueComparator<Date32Type>());
+      return Status::OK();
+    }
+
+    Status Visit(const Date64Type&) {
+      current_field_comparator_ = std::shared_ptr<NestedValueComparator>(
+          new ConcreteNestedValueComparator<Date64Type>());
+      return Status::OK();
+    }
+
+    Status Visit(const Time32Type&) {
+      current_field_comparator_ = std::shared_ptr<NestedValueComparator>(
+          new ConcreteNestedValueComparator<Time32Type>());
+      return Status::OK();
+    }
+
+    Status Visit(const Time64Type&) {
+      current_field_comparator_ = std::shared_ptr<NestedValueComparator>(
+          new ConcreteNestedValueComparator<Time64Type>());
+      return Status::OK();
+    }
+
+    Status Visit(const TimestampType&) {
+      current_field_comparator_ = std::shared_ptr<NestedValueComparator>(
+          new ConcreteNestedValueComparator<TimestampType>());
+      return Status::OK();
+    }
+
+    std::shared_ptr<NestedValueComparator> current_field_comparator_;
+  };
+
+  std::vector<std::shared_ptr<NestedValueComparator>> comparators_;
+};
+
+template <typename ArrayType>
+struct ResolvedChunkComparator {
+  bool Compare(const ChunkedArrayResolver& chunk_resolver, uint64_t left,
+               uint64_t right) {
+    const auto chunk_left = chunk_resolver.Resolve<ArrayType>(left);
+    const auto chunk_right = chunk_resolver.Resolve<ArrayType>(right);
+    return chunk_left.Value() < chunk_right.Value();
+  }
+};
+
+template <>
+struct ResolvedChunkComparator<StructArray> {
+  bool Compare(const ChunkedArrayResolver& chunk_resolver, uint64_t left,
+               uint64_t right) {
+    const auto chunk_left = chunk_resolver.Resolve<StructArray>(left);
+    const auto chunk_right = chunk_resolver.Resolve<StructArray>(right);
+    NestedValuesComparator nested_values_comparator;
+    auto status = nested_values_comparator.Prepare(chunk_left, chunk_right);
+
+    if (!status.ok()) {
+      return false;
+    }
+
+    for (int i = 0; i < chunk_left.array->num_fields(); i++) {
+      int val = nested_values_comparator.Compare(chunk_left, chunk_right, i);
+
+      if (val == 0) {
+        continue;
+      }
+
+      return val == -1;
+    }
+
+    return false;
+  }
+};
+
 }  // namespace internal
 }  // namespace compute
 }  // namespace arrow
diff --git a/python/pyarrow/array.pxi b/python/pyarrow/array.pxi
index 8fff00f5edf..ade170fc876 100644
--- a/python/pyarrow/array.pxi
+++ b/python/pyarrow/array.pxi
@@ -1213,6 +1213,22 @@ cdef class Array(_PandasConvertible):
         """
         return _pc().index(self, value, start, end, memory_pool=memory_pool)
 
+    def sort(self, order="ascending"):
+        """
+        Sort the Array
+
+        Parameters
+        ----------
+        order : "ascending" or "descending"
+            The order of the sorting.
+
+        Returns
+        -------
+        result : Array
+        """
+        indices = _pc().sort_indices(self, sort_keys=[("", order)])
+        return self.take(indices)
+
     def _to_pandas(self, options, **kwargs):
         return _array_like_to_pandas(self, options)
 
@@ -2462,6 +2478,29 @@ cdef class StructArray(Array):
         result.validate()
         return result
 
+    def sort(self, order="ascending", fieldname=None):
+        """
+        Sort the StructArray
+
+        Parameters
+        ----------
+        order : "ascending" or "descending"
+            The order of the sorting.
+        fieldname : str or None, default None
+            If to sort the array by one of its fields
+            or by the whole array.
+
+        Returns
+        -------
+        result : StructArray
+        """
+        if fieldname is not None:
+            tosort = self.field(fieldname)
+        else:
+            tosort = self
+        indices = _pc().sort_indices(tosort, sort_keys=[("", order)])
+        return self.take(indices)
+
 
 cdef class ExtensionArray(Array):
     """
diff --git a/python/pyarrow/table.pxi b/python/pyarrow/table.pxi
index 0028a1f658c..a51fce46449 100644
--- a/python/pyarrow/table.pxi
+++ b/python/pyarrow/table.pxi
@@ -461,6 +461,22 @@ cdef class ChunkedArray(_PandasConvertible):
         """
         return _pc().drop_null(self)
 
+    def sort(self, order="ascending"):
+        """
+        Sort the ChunkedArray
+
+        Parameters
+        ----------
+        order : "ascending" or "descending"
+            The order of the sorting.
+
+        Returns
+        -------
+        result : ChunkedArray
+        """
+        indices = _pc().sort_indices(self, sort_keys=[("", order)])
+        return self.take(indices)
+
     def unify_dictionaries(self, MemoryPool memory_pool=None):
         """
         Unify dictionaries across all chunks.
@@ -1110,6 +1126,29 @@ cdef class RecordBatch(_PandasConvertible):
         """
         return _pc().drop_null(self)
 
+    def sort_by(self, sorting):
+        """
+        Sort the RecordBatch by one or multiple columns.
+
+        Parameters
+        ----------
+        sorting : str or list[tuple(name, order)]
+            Name of the column to use to sort (ascending), or
+            a list of multiple sorting conditions where
+            each entry is a tuple with column name
+            and sorting order ("ascending" or "descending")
+
+        Returns
+        -------
+        RecordBatch
+            A new record batch sorted according to the sort keys.
+        """
+        if isinstance(sorting, str):
+            sorting = [(sorting, "ascending")]
+
+        indices = _pc().sort_indices(self, sort_keys=sorting)
+        return self.take(indices)
+
     def to_pydict(self):
         """
         Convert the RecordBatch to a dict or OrderedDict.
diff --git a/python/pyarrow/tests/test_array.py b/python/pyarrow/tests/test_array.py
index 7e32c292ef9..148b379773f 100644
--- a/python/pyarrow/tests/test_array.py
+++ b/python/pyarrow/tests/test_array.py
@@ -724,6 +724,256 @@ def test_struct_array_from_chunked():
         pa.StructArray.from_arrays([chunked_arr], ["foo"])
 
 
+def test_array_sort():
+    arr = pa.array([5, 7, 35], type=pa.int64())
+    sorted_arr = arr.sort("descending")
+    assert sorted_arr.to_pylist() == [35, 7, 5]
+
+    arr = pa.chunked_array([[1, 2, 3], [4, 5, 6]])
+    sorted_arr = arr.sort("descending")
+    assert sorted_arr.to_pylist() == [6, 5, 4, 3, 2, 1]
+
+
+def test_struct_array_sort():
+    arr = pa.StructArray.from_arrays([
+        pa.array([5, 7, 7, 35], type=pa.int64()),
+        pa.array(["foo", "car", "bar", "foobar"])
+    ], names=["a", "b"])
+
+    sorted_arr = arr.sort("descending", fieldname="a")
+    assert sorted_arr.to_pylist() == [
+        {"a": 35, "b": "foobar"},
+        {"a": 7, "b": "car"},
+        {"a": 7, "b": "bar"},
+        {"a": 5, "b": "foo"},
+    ]
+
+    sorted_arr = arr.sort("descending")
+    assert sorted_arr.to_pylist() == [
+        {"a": 35, "b": "foobar"},
+        {"a": 7, "b": "car"},
+        {"a": 7, "b": "bar"},
+        {"a": 5, "b": "foo"},
+    ]
+
+    sorted_arr = arr.sort("ascending")
+    assert sorted_arr.to_pylist() == [
+        {"a": 5, "b": "foo"},
+        {"a": 7, "b": "bar"},
+        {"a": 7, "b": "car"},
+        {"a": 35, "b": "foobar"},
+    ]
+
+
+def test_struct_chunked_array_sort():
+    arr1 = pa.StructArray.from_arrays([
+        pa.array([5, 7, 8], type=pa.int64()),
+        pa.array(["foo", "car", "far"])
+    ], names=["a", "b"])
+
+    arr2 = pa.StructArray.from_arrays([
+        pa.array([7, 35, 9], type=pa.int64()),
+        pa.array(["bar", "foobar", "tar"])
+    ], names=["a", "b"])
+
+    chunked_arr = pa.chunked_array([arr1, arr2])
+
+    sorted_arr = chunked_arr.sort("descending")
+    assert sorted_arr.to_pylist() == [
+        {"a": 35, "b": "foobar"},
+        {"a": 9, "b": "tar"},
+        {"a": 8, "b": "far"},
+        {"a": 7, "b": "car"},
+        {"a": 7, "b": "bar"},
+        {"a": 5, "b": "foo"},
+    ]
+
+    sorted_arr = chunked_arr.sort("ascending")
+    assert sorted_arr.to_pylist() == [
+        {"a": 5, "b": "foo"},
+        {"a": 7, "b": "bar"},
+        {"a": 7, "b": "car"},
+        {"a": 8, "b": "far"},
+        {"a": 9, "b": "tar"},
+        {"a": 35, "b": "foobar"},
+    ]
+
+    arr1 = pa.StructArray.from_arrays([
+        pa.array(["foo", "car", "tar"]),
+        pa.array([5, 7, 8], type=pa.int64())
+    ], names=["a", "b"])
+
+    arr2 = pa.StructArray.from_arrays([
+        pa.array(["bar", "foobar", "far"]),
+        pa.array([7, 35, 9], type=pa.int64())
+    ], names=["a", "b"])
+
+    chunked_arr = pa.chunked_array([arr1, arr2])
+
+    sorted_arr = chunked_arr.sort("ascending")
+    assert sorted_arr.to_pylist() == [
+        {"a": "bar", "b": 7},
+        {"a": "car", "b": 7},
+        {"a": "far", "b": 9},
+        {"a": "foo", "b": 5},
+        {"a": "foobar", "b": 35},
+        {"a": "tar", "b": 8},
+    ]
+
+    sorted_arr = chunked_arr.sort("descending")
+    assert sorted_arr.to_pylist() == [
+        {"a": "tar", "b": 8},
+        {"a": "foobar", "b": 35},
+        {"a": "foo", "b": 5},
+        {"a": "far", "b": 9},
+        {"a": "car", "b": 7},
+        {"a": "bar", "b": 7},
+    ]
+
+    arr1 = pa.StructArray.from_arrays([
+        pa.array([5, 5, 5], type=pa.int64()),
+        pa.array([3, 2, 2], type=pa.int64()),
+        pa.array(["foo", "car", "tar"])
+    ], names=["a", "b", "c"])
+
+    arr2 = pa.StructArray.from_arrays([
+        pa.array([5, 5, 2], type=pa.int64()),
+        pa.array([2, 8, 3], type=pa.int64()),
+        pa.array(["bar", "foobar", "far"])
+    ], names=["a", "b", "c"])
+
+    arr3 = pa.StructArray.from_arrays([
+        pa.array([5, 5, 2], type=pa.int64()),
+        pa.array([2, 8, 1], type=pa.int64()),
+        pa.array(["cat", "dog", "mouse"])
+    ], names=["a", "b", "c"])
+
+    chunked_arr = pa.chunked_array([arr1, arr2, arr3])
+
+    sorted_arr = chunked_arr.sort("ascending")
+    assert sorted_arr.to_pylist() == [
+        {"a": 2, "b": 1, "c": "mouse"},
+        {"a": 2, "b": 3, "c": "far"},
+        {"a": 5, "b": 2, "c": "bar"},
+        {"a": 5, "b": 2, "c": "car"},
+        {"a": 5, "b": 2, "c": "cat"},
+        {"a": 5, "b": 2, "c": "tar"},
+        {"a": 5, "b": 3, "c": "foo"},
+        {"a": 5, "b": 8, "c": "dog"},
+        {"a": 5, "b": 8, "c": "foobar"}
+    ]
+
+    sorted_arr = chunked_arr.sort("descending")
+    assert sorted_arr.to_pylist() == [
+        {"a": 5, "b": 8, "c": "foobar"},
+        {"a": 5, "b": 8, "c": "dog"},
+        {"a": 5, "b": 3, "c": "foo"},
+        {"a": 5, "b": 2, "c": "tar"},
+        {"a": 5, "b": 2, "c": "cat"},
+        {"a": 5, "b": 2, "c": "car"},
+        {"a": 5, "b": 2, "c": "bar"},
+        {"a": 2, "b": 3, "c": "far"},
+        {"a": 2, "b": 1, "c": "mouse"}
+    ]
+
+
+def test_record_batch_sort():
+    rb = pa.RecordBatch.from_arrays([
+        pa.array([7, 35, 7, 5], type=pa.int64()),
+        pa.array([4, 1, 3, 2], type=pa.int64()),
+        pa.array(["foo", "car", "bar", "foobar"])
+    ], names=["a", "b", "c"])
+
+    sorted_rb = rb.sort_by([("a", "descending"), ("b", "descending")])
+    sorted_rb_dict = sorted_rb.to_pydict()
+    assert sorted_rb_dict["a"] == [35, 7, 7, 5]
+    assert sorted_rb_dict["b"] == [1, 4, 3, 2]
+    assert sorted_rb_dict["c"] == ["car", "foo", "bar", "foobar"]
+
+    sorted_rb = rb.sort_by([("a", "ascending"), ("b", "ascending")])
+    sorted_rb_dict = sorted_rb.to_pydict()
+    assert sorted_rb_dict["a"] == [5, 7, 7, 35]
+    assert sorted_rb_dict["b"] == [2, 3, 4, 1]
+    assert sorted_rb_dict["c"] == ["foobar", "bar", "foo", "car"]
+
+    # test multi-key record batch sorter (> 8 sort keys)
+    rb1_names = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
+    rb1 = pa.RecordBatch.from_arrays([
+        pa.array([4, 4, 4, 4], type=pa.int64()),
+        pa.array([4, 4, 4, 4], type=pa.int64()),
+        pa.array([4, 4, 4, 4], type=pa.int64()),
+        pa.array([4, 4, 2, 2], type=pa.int64()),
+        pa.array([4, 4, 2, 2], type=pa.int64()),
+        pa.array([4, 4, 2, 2], type=pa.int64()),
+        pa.array([4, 4, 2, 2], type=pa.int64()),
+        pa.array([4, 4, 2, 2], type=pa.int64()),
+        pa.array([2, 1, 4, 3], type=pa.int64()),
+        pa.array(["foo", "car", "bar", "foobar"])
+    ], names=rb1_names)
+
+    sort_keys_list = [(name, "ascending") for name in rb1_names]
+
+    sorted_rb1 = rb1.sort_by(sort_keys_list)
+    sorted_rb1_dict = sorted_rb1.to_pydict()
+    assert sorted_rb1_dict["a"] == [4, 4, 4, 4]
+    assert sorted_rb1_dict["b"] == [4, 4, 4, 4]
+    assert sorted_rb1_dict["c"] == [4, 4, 4, 4]
+    assert sorted_rb1_dict["d"] == [2, 2, 4, 4]
+    assert sorted_rb1_dict["e"] == [2, 2, 4, 4]
+    assert sorted_rb1_dict["f"] == [2, 2, 4, 4]
+    assert sorted_rb1_dict["g"] == [2, 2, 4, 4]
+    assert sorted_rb1_dict["h"] == [2, 2, 4, 4]
+    assert sorted_rb1_dict["i"] == [3, 4, 1, 2]
+    assert sorted_rb1_dict["j"] == ["foobar", "bar", "car", "foo"]
+
+    # test radix sort with nulls
+    rb2_names = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]
+    rb2 = pa.RecordBatch.from_arrays([
+        pa.array([None, None, None, None]),
+        pa.array([4, 4, 4, 4], type=pa.int64()),
+        pa.array([4, 4, 4, 4], type=pa.int64()),
+        pa.array([4, 4, 2, 2], type=pa.int64()),
+        pa.array([4, 4, 2, 2], type=pa.int64()),
+        pa.array([4, 4, 2, 2], type=pa.int64()),
+        pa.array([4, 4, 2, 2], type=pa.int64()),
+        pa.array([4, 4, 2, 2], type=pa.int64()),
+        pa.array([2, 1, 4, 3], type=pa.int64()),
+        pa.array([2, 1, 4, 3], type=pa.int64()),
+    ], names=rb2_names)
+
+    sort_keys_list = [("a", "ascending"), ("j", "ascending")]
+    sorted_rb2 = rb2.sort_by(sort_keys_list)
+    sorted_rb2_dict = sorted_rb2.to_pydict()
+
+    assert sorted_rb2_dict["a"] == [None, None, None, None]
+    assert sorted_rb2_dict["b"] == [4, 4, 4, 4]
+    assert sorted_rb2_dict["c"] == [4, 4, 4, 4]
+    assert sorted_rb2_dict["d"] == [4, 4, 2, 2]
+    assert sorted_rb2_dict["e"] == [4, 4, 2, 2]
+    assert sorted_rb2_dict["f"] == [4, 4, 2, 2]
+    assert sorted_rb2_dict["g"] == [4, 4, 2, 2]
+    assert sorted_rb2_dict["h"] == [4, 4, 2, 2]
+    assert sorted_rb2_dict["i"] == [1, 2, 3, 4]
+    assert sorted_rb2_dict["j"] == [1, 2, 3, 4]
+
+
+def test_table_sort():
+    tab = pa.Table.from_arrays([
+        pa.array([5, 7, 7, 35], type=pa.int64()),
+        pa.array(["foo", "car", "bar", "foobar"])
+    ], names=["a", "b"])
+
+    sorted_tab = tab.sort_by([("a", "descending")])
+    sorted_tab_dict = sorted_tab.to_pydict()
+    assert sorted_tab_dict["a"] == [35, 7, 7, 5]
+    assert sorted_tab_dict["b"] == ["foobar", "car", "bar", "foo"]
+
+    sorted_tab = tab.sort_by([("a", "ascending")])
+    sorted_tab_dict = sorted_tab.to_pydict()
+    assert sorted_tab_dict["a"] == [5, 7, 7, 35]
+    assert sorted_tab_dict["b"] == ["foo", "car", "bar", "foobar"]
+
+
 def test_dictionary_from_numpy():
     indices = np.repeat([0, 1, 2], 2)
     dictionary = np.array(['foo', 'bar', 'baz'], dtype=object)