diff --git a/cpp/src/arrow/compute/exec_internal.h b/cpp/src/arrow/compute/exec_internal.h
index 8beff2a6c63..7e4f364a928 100644
--- a/cpp/src/arrow/compute/exec_internal.h
+++ b/cpp/src/arrow/compute/exec_internal.h
@@ -46,7 +46,7 @@ class ARROW_EXPORT ExecSpanIterator {
  public:
   ExecSpanIterator() = default;
 
-  /// \brief Initialize itertor iterator and do basic argument validation
+  /// \brief Initialize iterator and do basic argument validation
   ///
   /// \param[in] batch the input ExecBatch
   /// \param[in] max_chunksize the maximum length of each ExecSpan. Depending
diff --git a/cpp/src/arrow/compute/kernel.h b/cpp/src/arrow/compute/kernel.h
index d8960308dff..077bdcb31fa 100644
--- a/cpp/src/arrow/compute/kernel.h
+++ b/cpp/src/arrow/compute/kernel.h
@@ -538,7 +538,7 @@ struct ScalarKernel : public Kernel {
 // ----------------------------------------------------------------------
 // VectorKernel (for VectorFunction)
 
-/// \brief Kernel data structure for implementations of VectorFunction. In
+/// \brief Kernel data structure for implementations of VectorFunction. It
 /// contains an optional finalizer function, the null handling and memory
 /// pre-allocation preferences (which have different defaults from
 /// ScalarKernel), and some other execution-related options.
diff --git a/cpp/src/arrow/compute/kernels/vector_selection.cc b/cpp/src/arrow/compute/kernels/vector_selection.cc
index 5060b06465b..b1f54e68c69 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection.cc
@@ -28,6 +28,7 @@
 #include "arrow/array/builder_primitive.h"
 #include "arrow/array/concatenate.h"
 #include "arrow/buffer_builder.h"
+#include "arrow/chunk_resolver.h"
 #include "arrow/chunked_array.h"
 #include "arrow/compute/api_vector.h"
 #include "arrow/compute/kernels/common.h"
@@ -43,6 +44,7 @@
 #include "arrow/util/bitmap_ops.h"
 #include "arrow/util/bitmap_reader.h"
 #include "arrow/util/int_util.h"
+#include "arrow/util/vector.h"
 
 namespace arrow {
 
@@ -50,8 +52,11 @@ using internal::BinaryBitBlockCounter;
 using internal::BitBlockCount;
 using internal::BitBlockCounter;
 using internal::CheckIndexBounds;
+using internal::ChunkLocation;
+using internal::ChunkResolver;
 using internal::CopyBitmap;
 using internal::CountSetBits;
+using internal::MapVector;
 using internal::OptionalBitBlockCounter;
 using internal::OptionalBitIndexer;
 
@@ -257,6 +262,155 @@ Status PreallocateData(KernelContext* ctx, int64_t length, int bit_width,
   return Status::OK();
 }
 
+/// \brief Wrapper for getting values from ArraySpan and ChunkedArray.
+/// \tparam ArrayKind either ArraySpan or ChunkedArray.
+/// \tparam ValueType C types from array values.
+template <typename ArrayKind, typename ValueType>
+struct PrimitiveGetter {};
+
+template <>
+struct PrimitiveGetter<ArraySpan, bool> {
+  // For boolean, we can't add offset at beginning because values is a bitmap.
+  explicit PrimitiveGetter(ArraySpan&& array)
+      : inner(std::move(array)), values(array.GetValues<uint8_t>(1, 0)) {
+    inner.GetNullCount();
+  }
+
+  explicit PrimitiveGetter(const ArraySpan& array)
+      : inner(array), values(array.GetValues<uint8_t>(1, 0)) {
+    inner.GetNullCount();
+  }
+
+  bool IsValid(int64_t i) const {
+    return bit_util::GetBit(inner.buffers[0].data, inner.offset + i);
+  }
+
+  bool GetValue(int64_t i) const { return bit_util::GetBit(values, inner.offset + i); }
+
+  int64_t null_count() const { return inner.null_count; }
+  int64_t length() const { return inner.length; }
+
+  ArraySpan inner;
+  const uint8_t* values;
+};
+
+template <typename ValueType>
+struct PrimitiveGetter<ArraySpan, ValueType> {
+  explicit PrimitiveGetter(ArraySpan&& array)
+      : inner(std::move(array)), values(array.GetValues<ValueType>(1)) {
+    inner.GetNullCount();
+  }
+
+  explicit PrimitiveGetter(const ArraySpan& array)
+      : inner(array), values(array.GetValues<ValueType>(1)) {
+    inner.GetNullCount();
+  }
+
+  bool IsValid(int64_t i) const {
+    return bit_util::GetBit(inner.buffers[0].data, inner.offset + i);
+  }
+
+  ValueType GetValue(int64_t i) const { return values[i]; }
+
+  int64_t null_count() const { return inner.null_count; }
+  int64_t length() const { return inner.length; }
+
+  ArraySpan inner;
+  const ValueType* values;
+};
+
+template <>
+struct PrimitiveGetter<ChunkedArray, bool> {
+  explicit PrimitiveGetter(const ChunkedArray& array)
+      : inner(array),
+        resolver(ChunkResolver(array.chunks())),
+        null_count_(array.null_count()),
+        length_(array.length()) {
+    values_data = MapVector(
+        [](const auto& x) { return x->data()->template GetValues<uint8_t>(1, 0); },
+        array.chunks());
+    values_is_valid =
+        MapVector([](const auto& x) { return x->null_bitmap_data(); }, array.chunks());
+    values_offset = MapVector([](const auto& x) { return x->offset(); }, array.chunks());
+    chunk_lengths = MapVector([](const auto& x) { return x->length(); }, array.chunks());
+  }
+
+  bool IsValid(int64_t i) const {
+    ChunkLocation loc = resolver.Resolve(i);
+    const uint8_t* validity_bitmap = values_is_valid[loc.chunk_index];
+    if (validity_bitmap == nullptr) {
+      return true;
+    } else {
+      return bit_util::GetBit(validity_bitmap,
+                              values_offset[loc.chunk_index] + loc.index_in_chunk);
+    }
+  }
+
+  bool GetValue(int64_t i) const {
+    ChunkLocation loc = resolver.Resolve(i);
+    return bit_util::GetBit(values_data[loc.chunk_index],
+                            values_offset[loc.chunk_index] + loc.index_in_chunk);
+  }
+
+  int64_t null_count() const { return null_count_; }
+  int64_t length() const { return length_; }
+
+  const ChunkedArray& inner;
+  ChunkResolver resolver;
+  int64_t null_count_;
+  int64_t length_;
+  std::vector<int64_t> chunk_lengths;
+  std::vector<const uint8_t*> values_data;
+  std::vector<const uint8_t*> values_is_valid;
+  std::vector<int64_t> values_offset;
+};
+
+template <typename ValueType>
+struct PrimitiveGetter<ChunkedArray, ValueType> {
+  explicit PrimitiveGetter(const ChunkedArray& array)
+      : inner(array),
+        resolver(ChunkResolver(array.chunks())),
+        null_count_(array.null_count()),
+        length_(array.length()) {
+    values_data = MapVector(
+        [](const auto& x) { return x->data()->template GetValues<ValueType>(1); },
+        array.chunks());
+    values_is_valid =
+        MapVector([](const auto& x) { return x->null_bitmap_data(); }, array.chunks());
+    values_offset = MapVector([](const auto& x) { return x->offset(); }, array.chunks());
+    chunk_lengths = MapVector([](const auto& x) { return x->length(); }, array.chunks());
+  }
+
+  bool IsValid(int64_t i) const {
+    ChunkLocation loc = resolver.Resolve(i);
+    const uint8_t* validity_bitmap = values_is_valid[loc.chunk_index];
+    if (validity_bitmap == nullptr) {
+      return true;
+    } else {
+      return bit_util::GetBit(validity_bitmap,
+                              values_offset[loc.chunk_index] + loc.index_in_chunk);
+    }
+  }
+
+  ValueType GetValue(int64_t i) const {
+    ChunkLocation loc = resolver.Resolve(i);
+    const ValueType* data = values_data[loc.chunk_index];
+    return data[loc.index_in_chunk];
+  }
+
+  int64_t null_count() const { return null_count_; }
+  int64_t length() const { return length_; }
+
+  const ChunkedArray& inner;
+  ChunkResolver resolver;
+  int64_t null_count_;
+  int64_t length_;
+  std::vector<int64_t> chunk_lengths;
+  std::vector<const ValueType*> values_data;
+  std::vector<const uint8_t*> values_is_valid;
+  std::vector<int64_t> values_offset;
+};
+
 // ----------------------------------------------------------------------
 // Implement optimized take for primitive types from boolean to 1/2/4/8-byte
 // C-type based types. Use common implementation for every byte width and only
@@ -271,12 +425,9 @@ Status PreallocateData(KernelContext* ctx, int64_t length, int bit_width,
 /// This function assumes that the indices have been boundschecked.
 template <typename IndexCType, typename ValueCType>
 struct PrimitiveTakeImpl {
-  static void Exec(const ArraySpan& values, const ArraySpan& indices,
-                   ArrayData* out_arr) {
-    const ValueCType* values_data = values.GetValues<ValueCType>(1);
-    const uint8_t* values_is_valid = values.buffers[0].data;
-    auto values_offset = values.offset;
-
+  template <typename T>
+  static void ExecImpl(PrimitiveGetter<T, ValueCType>& values, const ArraySpan& indices,
+                       ArrayData* out_arr) {
     const IndexCType* indices_data = indices.GetValues<IndexCType>(1);
     const uint8_t* indices_is_valid = indices.buffers[0].data;
     auto indices_offset = indices.offset;
@@ -288,7 +439,7 @@ struct PrimitiveTakeImpl {
     // If either the values or indices have nulls, we preemptively zero out the
     // out validity bitmap so that we don't have to use ClearBit in each
     // iteration for nulls.
-    if (values.null_count != 0 || indices.null_count != 0) {
+    if (values.null_count() != 0 || indices.null_count != 0) {
       bit_util::SetBitsTo(out_is_valid, out_offset, indices.length, false);
     }
 
@@ -298,14 +449,14 @@ struct PrimitiveTakeImpl {
     int64_t valid_count = 0;
     while (position < indices.length) {
       BitBlockCount block = indices_bit_counter.NextBlock();
-      if (values.null_count == 0) {
+      if (values.null_count() == 0) {
         // Values are never null, so things are easier
         valid_count += block.popcount;
         if (block.popcount == block.length) {
           // Fastest path: neither values nor index nulls
           bit_util::SetBitsTo(out_is_valid, out_offset + position, block.length, true);
           for (int64_t i = 0; i < block.length; ++i) {
-            out[position] = values_data[indices_data[position]];
+            out[position] = values.GetValue(indices_data[position]);
             ++position;
           }
         } else if (block.popcount > 0) {
@@ -314,7 +465,7 @@ struct PrimitiveTakeImpl {
             if (bit_util::GetBit(indices_is_valid, indices_offset + position)) {
               // index is not null
               bit_util::SetBit(out_is_valid, out_offset + position);
-              out[position] = values_data[indices_data[position]];
+              out[position] = values.GetValue(indices_data[position]);
             } else {
               out[position] = ValueCType{};
             }
@@ -329,10 +480,9 @@ struct PrimitiveTakeImpl {
         if (block.popcount == block.length) {
           // Faster path: indices are not null but values may be
           for (int64_t i = 0; i < block.length; ++i) {
-            if (bit_util::GetBit(values_is_valid,
-                                 values_offset + indices_data[position])) {
+            if (values.IsValid(indices_data[position])) {
               // value is not null
-              out[position] = values_data[indices_data[position]];
+              out[position] = values.GetValue(indices_data[position]);
               bit_util::SetBit(out_is_valid, out_offset + position);
               ++valid_count;
             } else {
@@ -346,10 +496,9 @@ struct PrimitiveTakeImpl {
           // one.
           for (int64_t i = 0; i < block.length; ++i) {
             if (bit_util::GetBit(indices_is_valid, indices_offset + position) &&
-                bit_util::GetBit(values_is_valid,
-                                 values_offset + indices_data[position])) {
+                values.IsValid(indices_data[position])) {
               // index is not null && value is not null
-              out[position] = values_data[indices_data[position]];
+              out[position] = values.GetValue(indices_data[position]);
               bit_util::SetBit(out_is_valid, out_offset + position);
               ++valid_count;
             } else {
@@ -365,16 +514,31 @@ struct PrimitiveTakeImpl {
     }
     out_arr->null_count = out_arr->length - valid_count;
   }
-};
 
-template <typename IndexCType>
-struct BooleanTakeImpl {
   static void Exec(const ArraySpan& values, const ArraySpan& indices,
                    ArrayData* out_arr) {
-    const uint8_t* values_data = values.buffers[1].data;
-    const uint8_t* values_is_valid = values.buffers[0].data;
-    auto values_offset = values.offset;
+    auto getter = PrimitiveGetter<ArraySpan, ValueCType>(values);
+    ExecImpl(getter, indices, out_arr);
+  }
+
+  static void Exec(const ChunkedArray& values, const ChunkedArray& indices_chunked,
+                   ArrayDataVector* out_chunks) {
+    auto getter = PrimitiveGetter<ChunkedArray, ValueCType>(values);
+
+    for (int i = 0; i < indices_chunked.num_chunks(); ++i) {
+      ArraySpan indices_chunk(*indices_chunked.chunk(i)->data().get());
+      ArrayData* out_arr = (*out_chunks)[i].get();
+
+      ExecImpl(getter, indices_chunk, out_arr);
+    }
+  }
+};
 
+template <typename IndexCType>
+struct BooleanTakeImpl {
+  template <typename T>
+  static void ExecImpl(PrimitiveGetter<T, bool>& values, const ArraySpan& indices,
+                       ArrayData* out_arr) {
     const IndexCType* indices_data = indices.GetValues<IndexCType>(1);
     const uint8_t* indices_is_valid = indices.buffers[0].data;
     auto indices_offset = indices.offset;
@@ -386,15 +550,14 @@ struct BooleanTakeImpl {
     // If either the values or indices have nulls, we preemptively zero out the
     // out validity bitmap so that we don't have to use ClearBit in each
     // iteration for nulls.
-    if (values.null_count != 0 || indices.null_count != 0) {
+    if (values.null_count() != 0 || indices.null_count != 0) {
       bit_util::SetBitsTo(out_is_valid, out_offset, indices.length, false);
     }
     // Avoid uninitialized data in values array
     bit_util::SetBitsTo(out, out_offset, indices.length, false);
 
     auto PlaceDataBit = [&](int64_t loc, IndexCType index) {
-      bit_util::SetBitTo(out, out_offset + loc,
-                         bit_util::GetBit(values_data, values_offset + index));
+      bit_util::SetBitTo(out, out_offset + loc, values.GetValue(index));
     };
 
     OptionalBitBlockCounter indices_bit_counter(indices_is_valid, indices_offset,
@@ -403,7 +566,7 @@ struct BooleanTakeImpl {
     int64_t valid_count = 0;
     while (position < indices.length) {
       BitBlockCount block = indices_bit_counter.NextBlock();
-      if (values.null_count == 0) {
+      if (values.null_count() == 0) {
         // Values are never null, so things are easier
         valid_count += block.popcount;
         if (block.popcount == block.length) {
@@ -431,8 +594,7 @@ struct BooleanTakeImpl {
         if (block.popcount == block.length) {
           // Faster path: indices are not null but values may be
           for (int64_t i = 0; i < block.length; ++i) {
-            if (bit_util::GetBit(values_is_valid,
-                                 values_offset + indices_data[position])) {
+            if (values.IsValid(indices_data[position])) {
               // value is not null
               bit_util::SetBit(out_is_valid, out_offset + position);
               PlaceDataBit(position, indices_data[position]);
@@ -447,8 +609,7 @@ struct BooleanTakeImpl {
           for (int64_t i = 0; i < block.length; ++i) {
             if (bit_util::GetBit(indices_is_valid, indices_offset + position)) {
               // index is not null
-              if (bit_util::GetBit(values_is_valid,
-                                   values_offset + indices_data[position])) {
+              if (values.IsValid(indices_data[position])) {
                 // value is not null
                 PlaceDataBit(position, indices_data[position]);
                 bit_util::SetBit(out_is_valid, out_offset + position);
@@ -464,6 +625,24 @@ struct BooleanTakeImpl {
     }
     out_arr->null_count = out_arr->length - valid_count;
   }
+
+  static void Exec(const ArraySpan& values, const ArraySpan& indices,
+                   ArrayData* out_arr) {
+    auto getter = PrimitiveGetter<ArraySpan, bool>(values);
+    ExecImpl(getter, indices, out_arr);
+  }
+
+  static void Exec(const ChunkedArray& values, const ChunkedArray& indices_chunked,
+                   ArrayDataVector* out_chunks) {
+    auto getter = PrimitiveGetter<ChunkedArray, bool>(values);
+
+    for (int i = 0; i < indices_chunked.num_chunks(); ++i) {
+      ArraySpan indices_chunk(*indices_chunked.chunk(i)->data().get());
+      ArrayData* out_arr = (*out_chunks)[i].get();
+
+      ExecImpl(getter, indices_chunk, out_arr);
+    }
+  }
 };
 
 template <template <typename...> class TakeImpl, typename... Args>
@@ -489,6 +668,29 @@ void TakeIndexDispatch(const ArraySpan& values, const ArraySpan& indices,
   }
 }
 
+template <template <typename...> class TakeImpl, typename... Args>
+void TakeIndexDispatch(const ChunkedArray& values, const ChunkedArray& indices,
+                       ArrayDataVector* out) {
+  // With the simplifying assumption that boundschecking has taken place
+  // already at a higher level, we can now assume that the index values are all
+  // non-negative. Thus, we can interpret signed integers as unsigned and avoid
+  // having to generate double the amount of binary code to handle each integer
+  // width.
+  switch (indices.type()->byte_width()) {
+    case 1:
+      return TakeImpl<uint8_t, Args...>::Exec(values, indices, out);
+    case 2:
+      return TakeImpl<uint16_t, Args...>::Exec(values, indices, out);
+    case 4:
+      return TakeImpl<uint32_t, Args...>::Exec(values, indices, out);
+    case 8:
+      return TakeImpl<uint64_t, Args...>::Exec(values, indices, out);
+    default:
+      DCHECK(false) << "Invalid indices byte width";
+      break;
+  }
+}
+
 Status PrimitiveTake(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
   const ArraySpan& values = batch[0].array;
   const ArraySpan& indices = batch[1].array;
@@ -530,6 +732,57 @@ Status PrimitiveTake(KernelContext* ctx, const ExecSpan& batch, ExecResult* out)
   return Status::OK();
 }
 
+Status ChunkedPrimitiveTake(KernelContext* ctx, const ExecBatch& batch, Datum* out) {
+  const ChunkedArray& values = *batch[0].chunked_array();
+  const ChunkedArray& indices = *batch[1].chunked_array();
+
+  if (TakeState::Get(ctx).boundscheck) {
+    RETURN_NOT_OK(CheckIndexBounds(indices, values.length()));
+  }
+
+  const int bit_width = values.type()->bit_width();
+
+  ArrayDataVector out_data;
+
+  // We will match the chunking structure of the indices
+  for (const auto& chunk : indices.chunks()) {
+    auto chunk_out = ArrayData::Make(values.type(), indices.length());
+    // TODO: When neither values nor indices contain nulls, we can skip
+    // allocating the validity bitmap altogether and save time and space. A
+    // streamlined PrimitiveTakeImpl would need to be written that skips all
+    // interactions with the output validity bitmap, though.
+    RETURN_NOT_OK(PreallocateData(ctx, chunk->length(), bit_width,
+                                  /*allocate_validity=*/true, chunk_out.get()));
+
+    out_data.push_back(chunk_out);
+  }
+
+  switch (bit_width) {
+    case 1:
+      TakeIndexDispatch<BooleanTakeImpl>(values, indices, &out_data);
+      break;
+    case 8:
+      TakeIndexDispatch<PrimitiveTakeImpl, int8_t>(values, indices, &out_data);
+      break;
+    case 16:
+      TakeIndexDispatch<PrimitiveTakeImpl, int16_t>(values, indices, &out_data);
+      break;
+    case 32:
+      TakeIndexDispatch<PrimitiveTakeImpl, int32_t>(values, indices, &out_data);
+      break;
+    case 64:
+      TakeIndexDispatch<PrimitiveTakeImpl, int64_t>(values, indices, &out_data);
+      break;
+    default:
+      DCHECK(false) << "Invalid values byte width";
+      break;
+  }
+
+  *out = std::make_shared<ChunkedArray>(MapVector(MakeArray, out_data), values.type());
+
+  return Status::OK();
+}
+
 // ----------------------------------------------------------------------
 // Optimized and streamlined filter for primitive types
 
@@ -578,12 +831,12 @@ class PrimitiveFilterImpl {
                       ArrayData* out_arr)
       : values_is_valid_(values.buffers[0].data),
         values_data_(reinterpret_cast<const T*>(values.buffers[1].data)),
-        values_null_count_(values.null_count),
+        values_null_count_(values.GetNullCount()),
         values_offset_(values.offset),
         values_length_(values.length),
         filter_is_valid_(filter.buffers[0].data),
         filter_data_(filter.buffers[1].data),
-        filter_null_count_(filter.null_count),
+        filter_null_count_(filter.GetNullCount()),
         filter_offset_(filter.offset),
         null_selection_(null_selection) {
     if (values.type->id() != Type::BOOL) {
@@ -795,6 +1048,10 @@ Status PrimitiveFilter(KernelContext* ctx, const ExecSpan& batch, ExecResult* ou
   FilterOptions::NullSelectionBehavior null_selection =
       FilterState::Get(ctx).null_selection_behavior;
 
+  // Make sure we compute the null counts
+  values.GetNullCount();
+  filter.GetNullCount();
+
   int64_t output_length = GetFilterOutputSize(filter, null_selection);
 
   ArrayData* out_arr = out->array_data().get();
@@ -1997,6 +2254,8 @@ class FilterMetaFunction : public MetaFunction {
 // R -> RecordBatch
 // T -> Table
 
+bool chunked_take_supported(const DataType& type) { return is_primitive(type); }
+
 Result<std::shared_ptr<ArrayData>> TakeAA(const std::shared_ptr<ArrayData>& values,
                                           const std::shared_ptr<ArrayData>& indices,
                                           const TakeOptions& options, ExecContext* ctx) {
@@ -2005,70 +2264,77 @@ Result<std::shared_ptr<ArrayData>> TakeAA(const std::shared_ptr<ArrayData>& valu
   return result.array();
 }
 
-Result<std::shared_ptr<ChunkedArray>> TakeCA(const ChunkedArray& values,
-                                             const Array& indices,
+Result<std::shared_ptr<ChunkedArray>> TakeAC(std::shared_ptr<Array> values,
+                                             const ChunkedArray& indices,
                                              const TakeOptions& options,
                                              ExecContext* ctx) {
-  auto num_chunks = values.num_chunks();
-  std::shared_ptr<Array> current_chunk;
-
-  // Case 1: `values` has a single chunk, so just use it
-  if (num_chunks == 1) {
-    current_chunk = values.chunk(0);
-  } else {
-    // TODO Case 2: See if all `indices` fall in the same chunk and call Array Take on it
-    // See
-    // https://github.com/apache/arrow/blob/6f2c9041137001f7a9212f244b51bc004efc29af/r/src/compute.cpp#L123-L151
-    // TODO Case 3: If indices are sorted, can slice them and call Array Take
-
-    // Case 4: Else, concatenate chunks and call Array Take
-    if (values.chunks().empty()) {
-      ARROW_ASSIGN_OR_RAISE(current_chunk, MakeArrayOfNull(values.type(), /*length=*/0,
-                                                           ctx->memory_pool()));
-    } else {
-      ARROW_ASSIGN_OR_RAISE(current_chunk,
-                            Concatenate(values.chunks(), ctx->memory_pool()));
-    }
+  ArrayVector out_arrays(indices.num_chunks());
+  // Match the chunking structure of the indices.
+  for (int i = 0; i < indices.num_chunks(); ++i) {
+    const std::shared_ptr<Array>& ind_chunk = indices.chunk(i);
+    std::shared_ptr<ArrayData> result_chunk;
+    ARROW_ASSIGN_OR_RAISE(result_chunk,
+                          TakeAA(values->data(), ind_chunk->data(), options, ctx));
+    out_arrays[i] = MakeArray(result_chunk);
   }
-  // Call Array Take on our single chunk
-  ARROW_ASSIGN_OR_RAISE(std::shared_ptr<ArrayData> new_chunk,
-                        TakeAA(current_chunk->data(), indices.data(), options, ctx));
-  std::vector<std::shared_ptr<Array>> chunks = {MakeArray(new_chunk)};
-  return std::make_shared<ChunkedArray>(std::move(chunks));
+
+  return std::make_shared<ChunkedArray>(std::move(out_arrays));
 }
 
 Result<std::shared_ptr<ChunkedArray>> TakeCC(const ChunkedArray& values,
                                              const ChunkedArray& indices,
                                              const TakeOptions& options,
                                              ExecContext* ctx) {
-  auto num_chunks = indices.num_chunks();
-  std::vector<std::shared_ptr<Array>> new_chunks(num_chunks);
-  for (int i = 0; i < num_chunks; i++) {
-    // Take with that indices chunk
-    // Note that as currently implemented, this is inefficient because `values`
-    // will get concatenated on every iteration of this loop
-    ARROW_ASSIGN_OR_RAISE(std::shared_ptr<ChunkedArray> current_chunk,
-                          TakeCA(values, *indices.chunk(i), options, ctx));
-    // Concatenate the result to make a single array for this chunk
-    ARROW_ASSIGN_OR_RAISE(new_chunks[i],
-                          Concatenate(current_chunk->chunks(), ctx->memory_pool()));
-  }
-  return std::make_shared<ChunkedArray>(std::move(new_chunks), values.type());
+  if (chunked_take_supported(*values.type().get())) {
+    ARROW_ASSIGN_OR_RAISE(
+        Datum result,
+        CallFunction("array_take", {Datum(values), Datum(indices)}, &options, ctx));
+    return result.chunked_array();
+  } else {
+    // Concatenate values into one array, so we can use TakeAC.
+    ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Array> values_array,
+                          Concatenate(values.chunks(), ctx->memory_pool()));
+    return TakeAC(values_array, indices, options, ctx);
+  }
 }
 
-Result<std::shared_ptr<ChunkedArray>> TakeAC(const Array& values,
-                                             const ChunkedArray& indices,
+Result<std::shared_ptr<ChunkedArray>> TakeCA(const ChunkedArray& values,
+                                             std::shared_ptr<Array> indices,
                                              const TakeOptions& options,
                                              ExecContext* ctx) {
-  auto num_chunks = indices.num_chunks();
-  std::vector<std::shared_ptr<Array>> new_chunks(num_chunks);
-  for (int i = 0; i < num_chunks; i++) {
-    // Take with that indices chunk
-    ARROW_ASSIGN_OR_RAISE(std::shared_ptr<ArrayData> chunk,
-                          TakeAA(values.data(), indices.chunk(i)->data(), options, ctx));
-    new_chunks[i] = MakeArray(chunk);
-  }
-  return std::make_shared<ChunkedArray>(std::move(new_chunks), values.type());
+  auto num_chunks = values.num_chunks();
+
+  // If `values` has zero or one chunks, just use the AA implementation
+  if (num_chunks <= 1) {
+    std::shared_ptr<Array> current_chunk;
+    // Case 1: `values` has a single chunk, so just use it
+    if (num_chunks == 1) {
+      current_chunk = values.chunk(0);
+    } else {
+      // Case 2: `values` has no chunks, so create an empty one
+      ARROW_ASSIGN_OR_RAISE(current_chunk, MakeArrayOfNull(values.type(), /*length=*/0,
+                                                           ctx->memory_pool()));
+    }
+    // Call Array Take on our single chunk
+    ARROW_ASSIGN_OR_RAISE(std::shared_ptr<ArrayData> new_chunk,
+                          TakeAA(current_chunk->data(), indices->data(), options, ctx));
+    std::vector<std::shared_ptr<Array>> chunks = {MakeArray(new_chunk)};
+    return std::make_shared<ChunkedArray>(std::move(chunks));
+    // Case 3: We have support for take on chunked arrays
+  } else if (chunked_take_supported(*values.type().get())) {
+    ChunkedArray indices_chunked(indices);
+    return TakeCC(values, indices_chunked, options, ctx);
+    // Case 4: We don't directly support chunked array take, so concat.
+  } else {
+    // Concatenate values into one array, so we can use TakeAA.
+    ARROW_ASSIGN_OR_RAISE(std::shared_ptr<Array> values_array,
+                          Concatenate(values.chunks(), ctx->memory_pool()));
+    std::shared_ptr<ArrayData> result_chunk;
+    ARROW_ASSIGN_OR_RAISE(result_chunk,
+                          TakeAA(values_array->data(), indices->data(), options, ctx));
+
+    return std::make_shared<ChunkedArray>(MakeArray(result_chunk));
+  }
 }
 
 Result<std::shared_ptr<RecordBatch>> TakeRA(const RecordBatch& batch,
@@ -2086,7 +2352,7 @@ Result<std::shared_ptr<RecordBatch>> TakeRA(const RecordBatch& batch,
   return RecordBatch::Make(batch.schema(), nrows, std::move(columns));
 }
 
-Result<std::shared_ptr<Table>> TakeTA(const Table& table, const Array& indices,
+Result<std::shared_ptr<Table>> TakeTA(const Table& table, std::shared_ptr<Array> indices,
                                       const TakeOptions& options, ExecContext* ctx) {
   auto ncols = table.num_columns();
   std::vector<std::shared_ptr<ChunkedArray>> columns(ncols);
@@ -2138,12 +2404,12 @@ class TakeMetaFunction : public MetaFunction {
         if (index_kind == Datum::ARRAY) {
           return TakeAA(args[0].array(), args[1].array(), take_opts, ctx);
         } else if (index_kind == Datum::CHUNKED_ARRAY) {
-          return TakeAC(*args[0].make_array(), *args[1].chunked_array(), take_opts, ctx);
+          return TakeAC(args[0].make_array(), *args[1].chunked_array(), take_opts, ctx);
         }
         break;
       case Datum::CHUNKED_ARRAY:
         if (index_kind == Datum::ARRAY) {
-          return TakeCA(*args[0].chunked_array(), *args[1].make_array(), take_opts, ctx);
+          return TakeCA(*args[0].chunked_array(), args[1].make_array(), take_opts, ctx);
         } else if (index_kind == Datum::CHUNKED_ARRAY) {
           return TakeCC(*args[0].chunked_array(), *args[1].chunked_array(), take_opts,
                         ctx);
@@ -2156,7 +2422,7 @@ class TakeMetaFunction : public MetaFunction {
         break;
       case Datum::TABLE:
         if (index_kind == Datum::ARRAY) {
-          return TakeTA(*args[0].table(), *args[1].make_array(), take_opts, ctx);
+          return TakeTA(*args[0].table(), args[1].make_array(), take_opts, ctx);
         } else if (index_kind == Datum::CHUNKED_ARRAY) {
           return TakeTC(*args[0].table(), *args[1].chunked_array(), take_opts, ctx);
         }
@@ -2338,6 +2604,7 @@ Status TakeExec(KernelContext* ctx, const ExecSpan& batch, ExecResult* out) {
 struct SelectionKernelData {
   InputType input;
   ArrayKernelExec exec;
+  VectorKernel::ChunkedExec exec_chunked;
 };
 
 void RegisterSelectionFunction(const std::string& name, FunctionDoc doc,
@@ -2351,6 +2618,7 @@ void RegisterSelectionFunction(const std::string& name, FunctionDoc doc,
     base_kernel.signature =
         KernelSignature::Make({std::move(kernel_data.input), selection_type}, FirstType);
     base_kernel.exec = kernel_data.exec;
+    base_kernel.exec_chunked = kernel_data.exec_chunked;
     DCHECK_OK(func->AddKernel(base_kernel));
   }
   DCHECK_OK(registry->AddFunction(std::move(func)));
@@ -2473,22 +2741,22 @@ std::shared_ptr<VectorFunction> MakeIndicesNonZeroFunction(std::string name,
 void RegisterVectorSelection(FunctionRegistry* registry) {
   // Filter kernels
   std::vector<SelectionKernelData> filter_kernels = {
-      {InputType(match::Primitive()), PrimitiveFilter},
-      {InputType(match::BinaryLike()), BinaryFilter},
-      {InputType(match::LargeBinaryLike()), BinaryFilter},
-      {InputType(Type::FIXED_SIZE_BINARY), FilterExec<FSBImpl>},
-      {InputType(null()), NullFilter},
-      {InputType(Type::DECIMAL128), FilterExec<FSBImpl>},
-      {InputType(Type::DECIMAL256), FilterExec<FSBImpl>},
-      {InputType(Type::DICTIONARY), DictionaryFilter},
-      {InputType(Type::EXTENSION), ExtensionFilter},
-      {InputType(Type::LIST), FilterExec<ListImpl<ListType>>},
-      {InputType(Type::LARGE_LIST), FilterExec<ListImpl<LargeListType>>},
-      {InputType(Type::FIXED_SIZE_LIST), FilterExec<FSLImpl>},
-      {InputType(Type::DENSE_UNION), FilterExec<DenseUnionImpl>},
-      {InputType(Type::STRUCT), StructFilter},
+      {InputType(match::Primitive()), PrimitiveFilter, NULLPTR},
+      {InputType(match::BinaryLike()), BinaryFilter, NULLPTR},
+      {InputType(match::LargeBinaryLike()), BinaryFilter, NULLPTR},
+      {InputType(Type::FIXED_SIZE_BINARY), FilterExec<FSBImpl>, NULLPTR},
+      {InputType(null()), NullFilter, NULLPTR},
+      {InputType(Type::DECIMAL128), FilterExec<FSBImpl>, NULLPTR},
+      {InputType(Type::DECIMAL256), FilterExec<FSBImpl>, NULLPTR},
+      {InputType(Type::DICTIONARY), DictionaryFilter, NULLPTR},
+      {InputType(Type::EXTENSION), ExtensionFilter, NULLPTR},
+      {InputType(Type::LIST), FilterExec<ListImpl<ListType>>, NULLPTR},
+      {InputType(Type::LARGE_LIST), FilterExec<ListImpl<LargeListType>>, NULLPTR},
+      {InputType(Type::FIXED_SIZE_LIST), FilterExec<FSLImpl>, NULLPTR},
+      {InputType(Type::DENSE_UNION), FilterExec<DenseUnionImpl>, NULLPTR},
+      {InputType(Type::STRUCT), StructFilter, NULLPTR},
       // TODO: Reuse ListType kernel for MAP
-      {InputType(Type::MAP), FilterExec<ListImpl<MapType>>},
+      {InputType(Type::MAP), FilterExec<ListImpl<MapType>>, NULLPTR},
   };
 
   VectorKernel filter_base;
@@ -2501,27 +2769,29 @@ void RegisterVectorSelection(FunctionRegistry* registry) {
 
   // Take kernels
   std::vector<SelectionKernelData> take_kernels = {
-      {InputType(match::Primitive()), PrimitiveTake},
-      {InputType(match::BinaryLike()), TakeExec<VarBinaryImpl<BinaryType>>},
-      {InputType(match::LargeBinaryLike()), TakeExec<VarBinaryImpl<LargeBinaryType>>},
-      {InputType(Type::FIXED_SIZE_BINARY), TakeExec<FSBImpl>},
-      {InputType(null()), NullTake},
-      {InputType(Type::DECIMAL128), TakeExec<FSBImpl>},
-      {InputType(Type::DECIMAL256), TakeExec<FSBImpl>},
-      {InputType(Type::DICTIONARY), DictionaryTake},
-      {InputType(Type::EXTENSION), ExtensionTake},
-      {InputType(Type::LIST), TakeExec<ListImpl<ListType>>},
-      {InputType(Type::LARGE_LIST), TakeExec<ListImpl<LargeListType>>},
-      {InputType(Type::FIXED_SIZE_LIST), TakeExec<FSLImpl>},
-      {InputType(Type::DENSE_UNION), TakeExec<DenseUnionImpl>},
-      {InputType(Type::STRUCT), TakeExec<StructImpl>},
+      {InputType(match::Primitive()), PrimitiveTake, ChunkedPrimitiveTake},
+      {InputType(match::BinaryLike()), TakeExec<VarBinaryImpl<BinaryType>>, NULLPTR},
+      {InputType(match::LargeBinaryLike()), TakeExec<VarBinaryImpl<LargeBinaryType>>,
+       NULLPTR},
+      {InputType(Type::FIXED_SIZE_BINARY), TakeExec<FSBImpl>, NULLPTR},
+      {InputType(null()), NullTake, NULLPTR},
+      {InputType(Type::DECIMAL128), TakeExec<FSBImpl>, NULLPTR},
+      {InputType(Type::DECIMAL256), TakeExec<FSBImpl>, NULLPTR},
+      {InputType(Type::DICTIONARY), DictionaryTake, NULLPTR},
+      {InputType(Type::EXTENSION), ExtensionTake, NULLPTR},
+      {InputType(Type::LIST), TakeExec<ListImpl<ListType>>, NULLPTR},
+      {InputType(Type::LARGE_LIST), TakeExec<ListImpl<LargeListType>>, NULLPTR},
+      {InputType(Type::FIXED_SIZE_LIST), TakeExec<FSLImpl>, NULLPTR},
+      {InputType(Type::DENSE_UNION), TakeExec<DenseUnionImpl>, NULLPTR},
+      {InputType(Type::STRUCT), TakeExec<StructImpl>, NULLPTR},
       // TODO: Reuse ListType kernel for MAP
-      {InputType(Type::MAP), TakeExec<ListImpl<MapType>>},
+      {InputType(Type::MAP), TakeExec<ListImpl<MapType>>, NULLPTR},
   };
 
   VectorKernel take_base;
   take_base.init = TakeState::Init;
   take_base.can_execute_chunkwise = false;
+  take_base.output_chunked = false;
   RegisterSelectionFunction("array_take", array_take_doc, take_base,
                             /*selection_type=*/match::Integer(), take_kernels,
                             GetDefaultTakeOptions(), registry);
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_benchmark.cc b/cpp/src/arrow/compute/kernels/vector_selection_benchmark.cc
index 25e30e65a35..0933b796c1d 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_benchmark.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_benchmark.cc
@@ -120,6 +120,16 @@ struct TakeBenchmark {
     Bench(values);
   }
 
+  void ChunkedInt64() {
+    const int64_t n_chunks = 10;
+    const int64_t array_size = args.size / n_chunks / sizeof(int64_t);
+    ArrayVector chunks;
+    for (int64_t i = 0; i < n_chunks; ++i) {
+      chunks.push_back(rand.Int64(array_size, -100, 100, args.null_proportion));
+    }
+    BenchChunked(std::make_shared<ChunkedArray>(chunks));
+  }
+
   void FSLInt64() {
     auto int_array = rand.Int64(args.size, -100, 100, args.null_proportion);
     auto values = std::make_shared<FixedSizeListArray>(
@@ -150,6 +160,28 @@ struct TakeBenchmark {
       ABORT_NOT_OK(Take(values, indices).status());
     }
   }
+
+  void BenchChunked(const std::shared_ptr<ChunkedArray>& values) {
+    const int64_t n_chunks = 10;
+    const int64_t array_size = args.size / n_chunks / sizeof(int64_t);
+    ArrayVector chunks;
+    double indices_null_proportion = indices_have_nulls ? args.null_proportion : 0;
+    for (int64_t i = 0; i < n_chunks; ++i) {
+      chunks.push_back(rand.Int32(values->length(), 0,
+                                  static_cast<int32_t>(values->length() - 1),
+                                  indices_null_proportion));
+    }
+    auto indices = std::make_shared<ChunkedArray>(chunks);
+
+    if (monotonic_indices) {
+      std::shared_ptr<Array> arg_sorter = *SortIndices(*indices);
+      indices = (*Take(Datum(indices), Datum(arg_sorter))).chunked_array();
+    }
+
+    for (auto _ : state) {
+      ABORT_NOT_OK(Take(values, indices).status());
+    }
+  }
 };
 
 struct FilterBenchmark {
@@ -283,6 +315,18 @@ static void TakeInt64MonotonicIndices(benchmark::State& state) {
   TakeBenchmark(state, /*indices_with_nulls=*/false, /*monotonic=*/true).Int64();
 }
 
+static void TakeChunkedInt64RandomIndicesNoNulls(benchmark::State& state) {
+  TakeBenchmark(state, false).ChunkedInt64();
+}
+
+static void TakeChunkedInt64RandomIndicesWithNulls(benchmark::State& state) {
+  TakeBenchmark(state, true).ChunkedInt64();
+}
+
+static void TakeChunkedInt64MonotonicIndices(benchmark::State& state) {
+  TakeBenchmark(state, /*indices_with_nulls=*/false, /*monotonic=*/true).ChunkedInt64();
+}
+
 static void TakeFSLInt64RandomIndicesNoNulls(benchmark::State& state) {
   TakeBenchmark(state, false).FSLInt64();
 }
@@ -343,6 +387,9 @@ void TakeSetArgs(benchmark::internal::Benchmark* bench) {
 BENCHMARK(TakeInt64RandomIndicesNoNulls)->Apply(TakeSetArgs);
 BENCHMARK(TakeInt64RandomIndicesWithNulls)->Apply(TakeSetArgs);
 BENCHMARK(TakeInt64MonotonicIndices)->Apply(TakeSetArgs);
+BENCHMARK(TakeChunkedInt64RandomIndicesNoNulls)->Apply(TakeSetArgs);
+BENCHMARK(TakeChunkedInt64RandomIndicesWithNulls)->Apply(TakeSetArgs);
+BENCHMARK(TakeChunkedInt64MonotonicIndices)->Apply(TakeSetArgs);
 BENCHMARK(TakeFSLInt64RandomIndicesNoNulls)->Apply(TakeSetArgs);
 BENCHMARK(TakeFSLInt64RandomIndicesWithNulls)->Apply(TakeSetArgs);
 BENCHMARK(TakeFSLInt64MonotonicIndices)->Apply(TakeSetArgs);
diff --git a/cpp/src/arrow/compute/kernels/vector_selection_test.cc b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
index f98af93eef3..e7eb009e679 100644
--- a/cpp/src/arrow/compute/kernels/vector_selection_test.cc
+++ b/cpp/src/arrow/compute/kernels/vector_selection_test.cc
@@ -1659,6 +1659,14 @@ TEST_F(TestTakeKernelWithChunkedArray, TakeChunkedArray) {
   this->AssertChunkedTake(int8(), {"[7]", "[8, 9]"}, {"[0, 1, 0]", "[]", "[2]"},
                           {"[7, 8, 7]", "[]", "[9]"});
   this->AssertTake(int8(), {"[7]", "[8, 9]"}, "[2, 1]", {"[9, 8]"});
+  this->AssertChunkedTake(boolean(), {"[true]", "[false, true]"},
+                          {"[0, 1, 0]", "[]", "[2]"},
+                          {"[true, false, true]", "[]", "[true]"});
+  this->AssertChunkedTake(int32(), {"[7, null]", "[8, 9, 10]", "[21, null, 42]"},
+                          {"[2, 1]", "[7, 6, 6, 4]"},
+                          {"[8, null]", "[42, null, null, 10]"});
+  this->AssertTake(int32(), {"[7, null]", "[8, 9, 10]", "[21, null, 42]"},
+                   "[2, 1, 7, 6, 6, 4]", {"[8, null, 42, null, null, 10]"});
 
   std::shared_ptr<ChunkedArray> arr;
   ASSERT_RAISES(IndexError,
diff --git a/cpp/src/arrow/util/int_util.cc b/cpp/src/arrow/util/int_util.cc
index 1a48c7a3ec8..4b83e59e5bc 100644
--- a/cpp/src/arrow/util/int_util.cc
+++ b/cpp/src/arrow/util/int_util.cc
@@ -22,6 +22,7 @@
 #include <limits>
 
 #include "arrow/array/data.h"
+#include "arrow/chunked_array.h"
 #include "arrow/datum.h"
 #include "arrow/type.h"
 #include "arrow/type_traits.h"
@@ -590,6 +591,13 @@ Status CheckIndexBounds(const ArraySpan& values, uint64_t upper_limit) {
   }
 }
 
+Status CheckIndexBounds(const ChunkedArray& values, uint64_t upper_limit) {
+  for (const auto& chunk : values.chunks()) {
+    RETURN_NOT_OK(CheckIndexBounds(ArraySpan(*chunk->data()), upper_limit));
+  }
+  return Status::OK();
+}
+
 // ----------------------------------------------------------------------
 // Utilities for casting from one integer type to another
 
diff --git a/cpp/src/arrow/util/int_util.h b/cpp/src/arrow/util/int_util.h
index 5ce9dc2820e..97fb1c3b8f9 100644
--- a/cpp/src/arrow/util/int_util.h
+++ b/cpp/src/arrow/util/int_util.h
@@ -29,6 +29,7 @@ namespace arrow {
 class DataType;
 struct ArraySpan;
 struct Scalar;
+class ChunkedArray;
 
 namespace internal {
 
@@ -99,6 +100,8 @@ Status TransposeInts(const DataType& src_type, const DataType& dest_type,
 /// limit (which is usually the length of an array that is being indexed-into).
 ARROW_EXPORT
 Status CheckIndexBounds(const ArraySpan& values, uint64_t upper_limit);
+ARROW_EXPORT
+Status CheckIndexBounds(const ChunkedArray& values, uint64_t upper_limit);
 
 /// \brief Boundscheck integer values to determine if they are all between the
 /// passed upper and lower limits (inclusive). Upper and lower bounds must be