Inflector

Caveats — read these first

Inflector is intentionally a rule engine, not a linguist. The transforms are mechanical and English-only, which is the right trade-off for naming work but a trap if you expect semantic or multilingual behavior.

• • Pluralization is English-only: Singular/plural rules come from the upstream cruet crate, whose ruleset and irregular-word table are English. It handles real English irregulars well — person ↔ people, mouse ↔ mice, analysis ↔ analyses — but has no awareness of French, German, Spanish, or any other language. Non-English input silently produces mechanical English-rule output. For multilingual content, inflect upstream and store the result.
• • Case transforms are mechanical, not semantic: The tokenizer treats acronyms as runs of capitals, so inflector_to_snake_case('XMLHttpRequest') yields xml_http_request. That is correct for column-naming work; if you need acronym-preservation rules tuned to your domain, do that step in application code first.
• • Pluralization isn't always reversible: people → person round-trips fine, but English has true ambiguities — data is both singular and plural in modern usage, and species and series are unchanged. Don't round-trip a value through plural-then-singular and assume identity.
• • Single-character tokens are skipped: The case tokenizer requires a two-character minimum and ignores 1-character runs, which matters for inputs like aB or single-letter prefixes — those tokens are dropped rather than preserved.

How it works

Inflector is a thin DuckDB binding over the cruet and convert_case Rust crates — the same Rails / ActiveSupport-Inflector heritage, exposed through DuckDB's function system. The interesting part is not the catalog of helpers (those are enumerated in the Function Reference below) but the dispatch model: how the same conceptual operation is reached three different ways depending on what you're transforming.

• • Upstream provenance: The actual rule engine — case tokenization, pluralization, the irregular-word tables, the ActiveSupport-style helpers — lives in cruet and convert_case. Inflector is a binding layer that surfaces those crates as DuckDB functions, so behavior tracks the upstream crates rather than being reimplemented.
• • Scalar functions for a known target: When the target case is known at parse time, there's a dedicated scalar function per case, plus a matching is_* predicate for routing a value based on its current shape. String in, string out — vectorized like any other DuckDB scalar.
• • One polymorphic dispatcher across shapes: inflect takes the case as a runtime argument and is polymorphic on its payload: a VARCHAR returns a transformed string, a STRUCT returns the same struct with every key renamed (values untouched), and a parenthesized query becomes a table function that rewrites every column name. Same function, three shapes — the headline path for normalizing a whole result set in one call.

Inflector vs. RapidFuzz

Both extensions live in the Matching & casing group, but they answer different questions — and the line between them is clean.

• • Inflector: deterministic transformation: Reach for Inflector when you know exactly what shape you want — snake_case, kebab-case, plural, a foreign-key name — and need to mechanically produce it from a single input. The output is fully determined by the input and the chosen rule.
• • RapidFuzz: fuzzy comparison: Reach for rapidfuzz when you have two strings and want a similarity score — record linkage, dedupe, spell-check. That's comparison, not transformation. The two compose well: normalize naming with Inflector, then fuzzy-match across the normalized values with RapidFuzz.

Single-value case transforms

SELECT inflector_to_camel_case('hello_world');   -- helloWorld
SELECT inflector_to_snake_case('HelloWorld');    -- hello_world
SELECT inflector_to_kebab_case('helloWorld');    -- hello-world

Pluralize / singularize English words

SELECT inflector_to_plural('person');            -- people
SELECT inflector_to_singular('mice');            -- mouse

Rewrite every key in a struct / result set

SELECT inflect('snake', {'firstName':'John','lastName':'Doe'});
SELECT * FROM inflect('kebab', (FROM read_csv('data.csv')));