@@ -17,7 +17,7 @@
 
 use crate::logical_plan::producer::SubstraitProducer;
 use datafusion::common::DFSchema;
-use datafusion::logical_expr::Limit;
+use datafusion::logical_expr::{FetchType, Limit, LogicalPlan, SkipType};
 use std::sync::Arc;
 use substrait::proto::rel::RelType;
 use substrait::proto::{FetchRel, Rel, fetch_rel};
@@ -26,7 +26,22 @@ pub fn from_limit(
     producer: &mut impl SubstraitProducer,
     limit: &Limit,
 ) -> datafusion::common::Result<Box<Rel>> {
-    let input = producer.handle_plan(limit.input.as_ref())?;
+    // Pushing down LIMIT + OFFSET can produce a scan fetch above i64::MAX.
+    // It is redundant when this Limit requests no rows beyond that bound.
+    // Remove only that redundant fetch; retain the scan's exact offset.
+    let mut input_plan = None;
+    if let LogicalPlan::TableScan(scan) = limit.input.as_ref()
+        && let Some(scan_fetch) = scan.fetch
+        && i64::try_from(scan_fetch).is_err()
+        && let FetchType::Literal(Some(fetch)) = limit.get_fetch_type()?
+        && let SkipType::Literal(skip) = limit.get_skip_type()?
+        && skip.checked_add(fetch).is_some_and(|end| end <= scan_fetch)
+    {
+        let mut scan = scan.clone();
+        scan.fetch = None;
+        input_plan = Some(LogicalPlan::TableScan(scan));
+    }
+    let input = producer.handle_plan(input_plan.as_ref().unwrap_or(&limit.input))?;
     let empty_schema = Arc::new(DFSchema::empty());
 
     let offset_mode = limit
 
@@ -16,7 +16,9 @@
 // under the License.
 
 use crate::logical_plan::producer::{SubstraitProducer, to_substrait_named_struct};
-use datafusion::common::{DFSchema, ToDFSchema, substrait_datafusion_err};
+use datafusion::common::{
+    DFSchema, ToDFSchema, not_impl_datafusion_err, substrait_datafusion_err,
+};
 use datafusion::logical_expr::utils::conjunction;
 use datafusion::logical_expr::{EmptyRelation, Expr, TableScan, Values, lit};
 use datafusion::scalar::ScalarValue;
@@ -61,6 +63,12 @@ pub fn from_table_scan(
     producer: &mut impl SubstraitProducer,
     scan: &TableScan,
 ) -> datafusion::common::Result<Box<Rel>> {
+    let skip = scan.skip.map(i64::try_from).transpose().map_err(|_| {
+        not_impl_datafusion_err!("TableScan offset exceeds the supported Int64 range")
+    })?;
+    let fetch = scan.fetch.map(i64::try_from).transpose().map_err(|_| {
+        not_impl_datafusion_err!("TableScan fetch exceeds the supported Int64 range")
+    })?;
     let projection = scan.projection.as_ref().map(|p| {
         p.iter()
             .map(|i| StructItem {
@@ -116,15 +124,13 @@ pub fn from_table_scan(
         return Ok(read);
     }
     let empty_schema = Arc::new(DFSchema::empty());
-    let offset_mode = scan
-        .skip
-        .map(|skip| producer.handle_expr(&lit(skip as i64), &empty_schema))
+    let offset_mode = skip
+        .map(|skip| producer.handle_expr(&lit(skip), &empty_schema))
         .transpose()?
         .map(Box::new)
         .map(fetch_rel::OffsetMode::OffsetExpr);
-    let count_mode = scan
-        .fetch
-        .map(|fetch| producer.handle_expr(&lit(fetch as i64), &empty_schema))
+    let count_mode = fetch
+        .map(|fetch| producer.handle_expr(&lit(fetch), &empty_schema))
         .transpose()?
         .map(Box::new)
         .map(fetch_rel::CountMode::CountExpr);
 
@@ -398,6 +398,127 @@ async fn roundtrip_table_scan_offset_and_fetch() -> Result<()> {
     Ok(())
 }
 
+// Limit expressions use Int64, but limit pushdown can produce a larger usize fetch.
+#[tokio::test]
+#[cfg(target_pointer_width = "64")]
+async fn roundtrip_table_scan_fetch_above_i64_max() -> Result<()> {
+    use datafusion::arrow::array::Int64Array;
+    use datafusion::arrow::record_batch::RecordBatch;
+    use datafusion::dataframe::DataFrame;
+
+    let ctx = SessionContext::new();
+    ctx.register_batch(
+        "t",
+        RecordBatch::try_from_iter(vec![(
+            "x",
+            Arc::new(Int64Array::from(vec![0, 1, 2])) as ArrayRef,
+        )])?,
+    )?;
+    let plan = ctx
+        .sql("SELECT * FROM t LIMIT 9223372036854775807 OFFSET 1")
+        .await?
+        .into_optimized_plan()?;
+    let LogicalPlan::Limit(limit) = &plan else {
+        panic!("expected Limit")
+    };
+    let LogicalPlan::TableScan(scan) = limit.input.as_ref() else {
+        panic!("expected TableScan")
+    };
+    assert_eq!(scan.fetch, Some(i64::MAX as usize + 1));
+    let proto = to_substrait_plan(&plan, &ctx.state())?;
+    let restored = from_substrait_plan(&ctx.state(), &proto).await?;
+    for plan in [plan, restored] {
+        let batches = DataFrame::new(ctx.state(), plan).collect().await?;
+        datafusion::assert_batches_eq!(
+            ["+---+", "| x |", "+---+", "| 1 |", "| 2 |", "+---+"],
+            &batches
+        );
+    }
+    Ok(())
+}
+
+#[tokio::test]
+#[cfg(target_pointer_width = "64")]
+async fn roundtrip_table_scan_signed_range() -> Result<()> {
+    use datafusion::arrow::array::Int64Array;
+    use datafusion::dataframe::DataFrame;
+    use datafusion::datasource::provider_as_source;
+    use datafusion::logical_expr::TableScanBuilder;
+
+    let ctx = SessionContext::new();
+    let temp = tempfile::tempdir()?;
+    let path = temp.path().join("data.csv");
+    std::fs::write(&path, "x\n0\n1\n2\n")?;
+    ctx.register_csv("t", path.to_str().unwrap(), CsvReadOptions::new())
+        .await?;
+    let source = provider_as_source(ctx.table_provider("t").await?);
+    let max = i64::MAX as usize;
+    for (skip, fetch, parent, succeeds) in [
+        (None, Some(max), None, true),
+        (Some(max), None, None, true),
+        (None, Some(max + 1), None, false),
+        (None, Some(usize::MAX), None, false),
+        (Some(max + 1), None, None, false),
+        (Some(usize::MAX), None, None, false),
+        // The parent covers the scan bound exactly, or imposes a tighter bound.
+        (None, Some(max + 1), Some((1, Some(max))), true),
+        (None, Some(usize::MAX), Some((1, Some(2))), true),
+        (Some(1), Some(max + 1), Some((0, Some(2))), true),
+        // These parents do not make the scan fetch redundant.
+        (None, Some(max + 1), Some((max, Some(max))), false),
+        (None, Some(max + 1), Some((1, None)), false),
+    ] {
+        let scan = TableScanBuilder::new("t", source.clone())
+            .with_skip(skip)
+            .with_fetch(fetch)
+            .build()?;
+        let mut builder = LogicalPlanBuilder::from(LogicalPlan::TableScan(scan));
+        if let Some((skip, fetch)) = parent {
+            builder = builder.limit(skip, fetch)?;
+        }
+        let plan = builder.build()?;
+        let proto = to_substrait_plan(&plan, &ctx.state());
+        if !succeeds {
+            let error = proto.unwrap_err().to_string();
+            let field = if skip.is_some() { "offset" } else { "fetch" };
+            assert!(
+                error.contains(&format!(
+                    "TableScan {field} exceeds the supported Int64 range"
+                )),
+                "{error}"
+            );
+            continue;
+        }
+        let proto = proto?;
+        let restored = from_substrait_plan(&ctx.state(), &proto).await?;
+        let expected = if skip == Some(max) {
+            vec![]
+        } else if parent.is_some() {
+            vec![1, 2]
+        } else {
+            vec![0, 1, 2]
+        };
+        for plan in [plan, restored] {
+            let batches = DataFrame::new(ctx.state(), plan).collect().await?;
+            let actual = batches
+                .iter()
+                .flat_map(|batch| {
+                    batch
+                        .column(0)
+                        .as_any()
+                        .downcast_ref::<Int64Array>()
+                        .unwrap()
+                        .values()
+                        .iter()
+                        .copied()
+                })
+                .collect::<Vec<_>>();
+            assert_eq!(actual, expected);
+        }
+    }
+    Ok(())
+}
+
 #[tokio::test]
 async fn select_with_limit_offset() -> Result<()> {
     roundtrip("SELECT * FROM data LIMIT 200 OFFSET 10").await?;