dbt-labs/dbt-core · error · InvalidOperation

Table.limit: {e}

Error message

Table.limit: {e}

What it means

Thrown by the `Table.limit()` method binding when the underlying `limit(n)` operation fails, wrapping the inner error as an InvalidOperation error prefixed with `Table.limit:`. Note only the single-argument `limit(n)` form is supported in the Rust port; failures come from the internal row-slicing step.

Source

Thrown at crates/dbt-agate/src/table.rs:1343

                    require_match,
                    columns,
                )?;
                Ok(Value::from_object(table))
            }
            // ```python
            // def limit(self, start_or_stop=None, stop=None, step=None):
            //     """
            //     Filter data to a subset of all rows.
            //     """
            // ```
            //
            // Only the single-arg `limit(n)` form is supported on the rust port.
            "limit" => {
                let iter = ArgsIter::new("Table.limit", &["n"], args);
                let n = iter.next_arg::<i64>()?;
                iter.finish()?;
                let table = self.as_ref().limit(n).map_err(|e| {
                    Error::new(ErrorKind::InvalidOperation, format!("Table.limit: {e}"))
                })?;
                Ok(Value::from_object(table))
            }
            // ```python
            // def distinct(self, key=None):
            //     """
            //     Create a new table with only unique rows.
            //
            //     :param key:
            //         Either the name of a single column to use to identify unique rows, a
            //         sequence of such column names, a :class:`function` that takes a
            //         row and returns a value to identify unique rows, or `None`, in
            //         which case the entire row will be checked for uniqueness.
            //     :returns:
            //     A new :class:`.Table`.
            //     """
            // ```
            "distinct" => {

View on GitHub (pinned to 0267ce9170)

Solutions

1. Read the wrapped inner message after `Table.limit:` for the root cause
2. Ensure `n` is a non-negative integer within the table's row count
3. Use only the single-argument form `limit(n)`; the two-arg form is unsupported in this port
4. Guard the value before calling: `if n >= 0 { table.limit(n) }`

Example fix

// before
table.limit(-5)
// after
let n = 5; // must be >= 0
table.limit(n)

if not isinstance(n, int) or n < 0:
    raise ValueError(f'limit n must be a non-negative int, got {n!r}')

null

try:
    limited = table.limit(n)
except Exception as e:
    if str(e).startswith('Table.limit:'):
        raise ValueError(f'invalid limit n={n!r}: {e}') from e
    raise

When it happens

Trigger: Calling `table.limit(n)` where the internal `limit` implementation returns an error — e.g. an out-of-range or negative `n` rejected by the implementation, or an internal slicing failure.

Common situations: Computing the limit from a variable that is negative or zero; porting Python agate code that used `limit(n=..., offset=...)` (unsupported form here) or passing oversized counts.

Related errors

• Table.distinct: {e}
• Table.distinct: error selecting rows: {e}
• Table.select: key must be a string or an array of strings: {
• Table.select: key must be a string or an array of strings: {
• Table.group_by: {e}

AI-assisted analysis of dbt-labs/dbt-core@0267ce9170 (2026-09-07). Data as JSON: /api/errors/8e41cc4908206cbd. Report an issue: GitHub.