@@ -158,10 +158,16 @@ pub struct PyPhysicalPartitioning {
 impl PyPhysicalPartitioning {
     /// Which partitioning scheme this is.
     ///
-    /// One of `RoundRobinBatch`, `Hash`, `Range`, or `UnknownPartitioning`.
     /// `UnknownPartitioning` is what a plan reports when it knows how many
     /// partitions it has but nothing about how rows are distributed between
-    /// them, which is the common case for a file scan.
+    /// them, which is the common case for a file scan. `RoundRobinBatch` and
+    /// `Hash` come from a `RepartitionExec`.
+    ///
+    /// `Range` is in the upstream enum but no plan reports it yet: optimizer
+    /// and execution support is deliberately unimplemented, per
+    /// <https://github.com/apache/datafusion/issues/22395>. The arm is here so
+    /// this getter keeps compiling when that lands, not because it is
+    /// reachable today.
     #[getter]
     pub fn scheme(&self) -> &'static str {
         match self.partitioning {
 
@@ -346,10 +346,11 @@ def __init__(self, partitioning: df_internal.PhysicalPartitioning) -> None:
     def scheme(self) -> str:
         """Which partitioning scheme this is.
 
-        One of ``"RoundRobinBatch"``, ``"Hash"``, ``"Range"``, or
-        ``"UnknownPartitioning"``. A plan reports ``"UnknownPartitioning"``
-        when it knows how many partitions it has but nothing about how rows
-        are distributed between them, which is the usual case for a file scan.
+        ``"UnknownPartitioning"`` means the plan knows how many partitions it
+        has but nothing about how rows are distributed between them, which is
+        the usual case for a file scan. ``"RoundRobinBatch"`` and ``"Hash"``
+        come from a repartition the optimizer inserted. ``"Range"`` is defined
+        upstream but no plan reports it yet.
 
         Examples:
             >>> from datafusion import SessionContext
 
@@ -18,6 +18,7 @@
 import datetime
 
 import pyarrow as pa
+import pyarrow.parquet as pq
 import pytest
 from datafusion import (
     ExecutionPlan,
@@ -144,6 +145,32 @@ def test_output_partitioning_reports_the_scheme_not_just_the_count() -> None:
     assert repr(partitioning) == "Hash([a@0], 4)"
 
 
+def test_output_partitioning_reports_round_robin(tmp_path) -> None:
+    """A round-robin repartition reports `RoundRobinBatch`.
+
+    The optimizer only inserts one above a source with fewer partitions than
+    `target_partitions` and CPU work above it to parallelize, and it never
+    survives at the root, so reach it by walking `children`.
+    """
+    path = tmp_path / "rr.parquet"
+    pq.write_table(pa.table({"a": list(range(2000)), "b": [1] * 2000}), path)
+
+    ctx = SessionContext(SessionConfig().with_target_partitions(8))
+    ctx.register_parquet("t", str(path))
+    plan = ctx.sql("select a, sum(b) from t where a > 5 group by a").execution_plan()
+
+    schemes = set()
+    stack = [plan]
+    while stack:
+        node = stack.pop()
+        schemes.add(node.output_partitioning.scheme)
+        stack.extend(node.children())
+
+    # The single-file scan, the round-robin above it, and the hash repartition
+    # for the grouping are all in one tree.
+    assert schemes == {"UnknownPartitioning", "RoundRobinBatch", "Hash"}
+
+
 def test_execute_rejects_an_out_of_range_partition() -> None:
     """An out-of-range partition index raises instead of panicking."""
     ctx = SessionContext()