AI PM Ready
Back to the Digest

SQLite Extension Performance: C vs. Rust for parse_number() Function

Simon WillisonEngineering Context4 min readImportantOriginal source ↗

When building SQLite extensions, a C implementation of a `parse_number()` function achieved 16–19 ns per row, significantly outperforming Rust versions and native SQL functions. While Rust extensions were larger (298-321 KB vs. 14 KB for C), a specialized C implementation using a fast path matched or beat Rust's performance. This highlights critical engineering tradeoffs for PMs: raw performance (C) versus code size and potentially easier development (Rust), especially when dealing with string parsing for numerical data. This week, when scoping data processing tasks that involve string-to-number conversions in databases, ensure your engineering team evaluates both C and Rust implementations for performance and size implications. Watch for new benchmarks on complex string parsing tasks across different languages in database contexts.

What happened

An investigation into creating a SQLite extension for parsing numbers from strings (e.g., '-$1,234.56') revealed performance differences between C and Rust implementations. The optimized C version achieved 16–19 ns per row, outperforming Rust (which was about twice as fast as C's standard `strtod()` but slower overall) and SQL's `replace()` function. A key finding was that a compact C implementation using a "fast path" closed the performance gap with Rust, resulting in a much smaller binary size (14 KB for C vs. 298-321 KB for Rust).

A scenario you might face

A Series B fintech company is developing a new reporting feature that requires parsing millions of financial transaction strings (e.g., '$1,234.56') within a SQLite database to generate summary statistics. The PM must decide whether to use a Rust-based extension for ease of development or a C-based extension for maximum performance and minimal footprint. The engineering team presents data showing the C extension is 14 KB and runs at 16 ns/row, while Rust versions are over 300 KB and slower. The PM needs to weigh the faster development cycle of Rust against the significant performance and size benefits of an optimized C implementation for this critical path.

What changes in your practice

In your next technical discussion about performance-critical data processing features, ask your engineering team to present comparative benchmarks for string-to-number parsing, specifically evaluating C and Rust implementations with potential fast paths. Ensure that binary size is also a key consideration alongside latency. Before your next feature kickoff that involves database extensions, explicitly add a requirement for evaluating performance and size tradeoffs between language options like C and Rust.

Questions for your team

  1. 01What is the acceptable range for string parsing latency per row in our specific application context, and how does this C vs. Rust data align with it?
  2. 02Beyond performance and size, what are the long-term maintenance and security implications of choosing a C extension versus a Rust extension for this SQLite function?
  3. 03How much time savings in development effort can we realistically expect from using Rust compared to an optimized C implementation for this particular `parse_number()` task?
  4. 04Can we quantify the potential impact of the larger binary size of the Rust extension on our application's deployment and memory footprint?

Practise this

Interviewers ask about stories like this one. Rehearse your answer in a timed mock interview.

Start a mock interview →
All stories
Was this page useful?