Inflector DuckDB Extension

The Inflector extension, developed by Query.Farm, brings powerful string case transformation and inflection capabilities directly to your SQL queries in DuckDB. Transform column names, validate naming conventions, handle pluralization, and more—all without leaving your database environment.

Whether you’re normalizing API responses, migrating schemas between naming conventions, or ensuring consistent data formatting, Inflector makes string manipulation in SQL simple and efficient.

Use Cases

The Inflector extension is perfect for:

Data normalization: Standardize column names and values to a consistent case style
ETL pipelines: Transform and clean data during ingestion or export
API and report generation: Match naming conventions for downstream systems
Schema migration: Convert between naming conventions (snake_case, camelCase, etc.)
Data validation: Check if strings conform to required case or format
Pluralization/Singularization: Automatically convert between singular and plural forms
Foreign key and module name handling: Generate or validate foreign key names and Ruby-style module paths

Installation

inflector is a DuckDB Community Extension.

You can install and load it with:

INSTALL inflector FROM community;
LOAD inflector;

Quick Start

-- Install and load the extension
INSTALL inflector FROM community;
LOAD inflector;

-- Transform a single string
SELECT inflector_to_camel_case('hello_world');  -- helloWorld

-- Transform all column names in a struct
SELECT inflect('snake', {'firstName': 'John', 'lastName': 'Doe'});
-- {'first_name': John, 'last_name': Doe}

-- Transform all column names from a table or query
SELECT * FROM inflect('kebab', read_csv('data.csv'));

Functions

Case Transformation Functions

Transform a string to a specific case style:

inflector_to_class_case(str) → ClassCase
inflector_to_camel_case(str) → camelCase
inflector_to_pascal_case(str) → PascalCase
inflector_to_screamingsnake_case(str) → SCREAMING_SNAKE_CASE
inflector_to_snake_case(str) → snake_case
inflector_to_kebab_case(str) → kebab-case
inflector_to_train_case(str) → Train-Case
inflector_to_sentence_case(str) → Sentence case
inflector_to_title_case(str) → Title Case
inflector_to_table_case(str) → table_names
inflector_to_upper_case(str) → UPPERCASE
inflector_to_lower_case(str) → lowercase

Examples:

SELECT inflector_to_camel_case('hello_world') as v;
┌────────────┐
│     v      │
│  varchar   │
├────────────┤
│ helloWorld │
└────────────┘

SELECT inflector_to_snake_case('HelloWorld') as v;
┌─────────────┐
│      v      │
│   varchar   │
├─────────────┤
│ hello_world │
└─────────────┘

SELECT inflector_to_title_case('hello_world') as v;
┌─────────────┐
│      v      │
│   varchar   │
├─────────────┤
│ Hello World │
└─────────────┘

Pluralization and Singularization

inflector_to_plural(str) → plural form
inflector_to_singular(str) → singular form

SELECT inflector_to_plural('person') as v;
┌─────────┐
│    v    │
│ varchar │
├─────────┤
│ people  │
└─────────┘

SELECT inflector_to_singular('ducks') as v;
┌─────────┐
│    v    │
│ varchar │
├─────────┤
│ duck    │
└─────────┘

Ordinalization

inflector_ordinalize(str) → ordinal string (e.g., 1st, 2nd)
inflector_deordinalize(str) → number string (e.g., 1st → 1)

SELECT inflector_ordinalize('5') as v;
┌─────────┐
│    v    │
│ varchar │
├─────────┤
│ 5th     │
└─────────┘

SELECT inflector_deordinalize('21st') as v;
┌─────────┐
│    v    │
│ varchar │
├─────────┤
│ 21      │
└─────────┘

Foreign Key and Module Functions

inflector_to_foreign_key(str) → foreign key name (e.g., User → user_id)
inflector_demodulize(str) → last module/class name (e.g., A::B::C → C)
inflector_deconstantize(str) → parent module path (e.g., A::B::C → A::B)

SELECT inflector_to_foreign_key('User') as v;
┌─────────┐
│    v    │
│ varchar │
├─────────┤
│ user_id │
└─────────┘

SELECT inflector_demodulize('ActiveRecord::CoreExtensions::String::Inflections') as v;
┌────────────┐
│     v      │
│  varchar   │
├────────────┤
│ Inflection │
└────────────┘

SELECT inflector_deconstantize('ActiveRecord::CoreExtensions::String::Inflections') as v;
┌─────────┐
│    v    │
│ varchar │
├─────────┤
│ String  │
└─────────┘

Predicate Functions

Check if a string matches a specific case or format:

inflector_is_class_case(str)
inflector_is_camel_case(str)
inflector_is_pascal_case(str)
inflector_is_screamingsnake_case(str)
inflector_is_snake_case(str)
inflector_is_kebab_case(str)
inflector_is_train_case(str)
inflector_is_sentence_case(str)
inflector_is_title_case(str)
inflector_is_table_case(str)
inflector_is_foreign_key(str)

Returns true or false.

Examples:

SELECT inflector_is_snake_case('hello_world') as v;
┌─────────┐
│    v    │
│ boolean │
├─────────┤
│ true    │
└─────────┘

SELECT inflector_is_camel_case('HelloWorld') as v;
┌─────────┐
│    v    │
│ boolean │
├─────────┤
│ false   │
└─────────┘

SELECT inflector_is_foreign_key('user_id') as v;
┌─────────┐
│    v    │
│ boolean │
├─────────┤
│ true    │
└─────────┘

Struct and Table Column Inflection

The inflect() function is the most powerful feature, allowing you to transform all column names in a struct or table result at once.

Inflect the keys of a STRUCT or table’s column names to a target case style:

Syntax:

inflect('case_style', struct_or_table)

Supported case styles:

'camel' / 'camel_case' → camelCase
'class' / 'class_case' → ClassCase
'snake' / 'snake_case' → snake_case
'kebab' / 'kebab_case' → kebab-case
'train' / 'train_case' → Train-Case
'title' / 'title_case' → Title Case
'table' / 'table_case' → table_names (pluralized snake_case)
'sentence' / 'sentence_case' → Sentence case
'upper' / 'upper_case' → UPPERCASE
'lower' / 'lower_case' → lowercase

Examples:

SELECT inflect('snake', {'firstName': 1, 'lastName': 2}) as v;
┌───────────────────────────────────────────────┐
│                       v                       │
│ struct(first_name integer, last_name integer) │
├───────────────────────────────────────────────┤
│ {'first_name': 1, 'last_name': 2}             │
└───────────────────────────────────────────────┘

SELECT inflect('class', {'first_name': 1, 'last_name': 2}) as v;
┌─────────────────────────────────────────────┐
│                      v                      │
│ struct(firstname integer, lastname integer) │
├─────────────────────────────────────────────┤
│ {'FirstName': 1, 'LastName': 2}             │
└─────────────────────────────────────────────┘

-- Table returning function.
SELECT n FROM inflect('camel', (SELECT 1 AS counterValue, 't' AS first_name)) AS n;
┌─────────────────────────────────────────────────┐
│                        n                        │
│ struct(countervalue integer, firstname varchar) │
├─────────────────────────────────────────────────┤
│ {'counterValue': 1, 'firstName': t}             │
└─────────────────────────────────────────────────┘

Real-World Examples

Normalize CSV Column Names

-- Convert PascalCase CSV headers to snake_case
SELECT * FROM inflect('snake', read_csv('UserData.csv'));
-- FirstName, LastName, EmailAddress → first_name, last_name, email_address

Transform API Response Data

-- Convert camelCase JSON keys to snake_case for database storage
CREATE TABLE users AS
SELECT * FROM inflect('snake',
  read_json('api_response.json')
);

Validate Naming Conventions

-- Check if all column names follow snake_case convention
SELECT
  column_name,
  inflector_is_snake_case(column_name) as is_valid
FROM information_schema.columns
WHERE table_name = 'my_table';

Schema Migration Between Conventions

-- Convert a Ruby on Rails style table to JavaScript convention
CREATE TABLE users_camel AS
SELECT * FROM inflect('camel', users);

Generate Foreign Key Names

-- Create foreign key column names from table names
SELECT
  table_name,
  inflector_to_foreign_key(table_name) as fk_column
FROM information_schema.tables;

Pluralize Table Names

-- Ensure all table names are plural
SELECT
  table_name,
  inflector_to_plural(table_name) as plural_name
FROM information_schema.tables;

Clean and Standardize Text Data

-- Standardize mixed-case product categories
UPDATE products
SET category = inflector_to_title_case(category);

Generate Display Labels

-- Convert snake_case column names to human-readable titles
SELECT
  'first_name' as column,
  inflector_to_title_case('first_name') as label;  -- First Name

Advanced Usage

Nested Struct Transformation

-- Inflect nested struct keys recursively
SELECT inflect('camel', {
  'user_info': {
    'first_name': 'John',
    'last_name': 'Doe'
  }
}) as result;

Bulk Column Validation

-- Find all columns that don't follow snake_case
WITH column_check AS (
  SELECT
    table_name,
    column_name,
    inflector_is_snake_case(column_name) as is_snake_case
  FROM information_schema.columns
)
SELECT * FROM column_check WHERE NOT is_snake_case;

Data Pipeline Transformation

SELECT * FROM inflect('snake', read_csv('example.csv'));

Performance Considerations

Transformation functions are highly optimized and work efficiently on large datasets
The inflect() function operates on column metadata, not data, making it very fast
Predicate functions can be used in WHERE clauses and are optimized for filtering

Tips and Best Practices

Use the right case for your project: Consistent naming improves maintainability and reduces errors
Validate data early: Use predicate functions in data quality checks during ETL
Automate schema migrations: Use inflect() to convert column names in bulk rather than manual renaming
Combine with DuckDB’s JSON/struct features: Inflect nested data structures from APIs and config files
Standardize imports: Apply inflection when reading external data (CSV, JSON, Parquet)
Use table_case for database tables: Automatically pluralizes and converts to snake_case
Document your conventions: Choose a case style and stick with it across your project

Error Handling

The extension provides clear error messages for common issues:

-- Unknown case style
SELECT inflect('unknown', {'foo': 1});
-- Error: Unknown inflection 'unknown'. Supported: camel, class, snake, kebab, train, title, table, sentence, upper, lower

-- Invalid arguments
SELECT inflect('snake');
-- Error: inflect() requires exactly two arguments: function name and value to inflect

Frequently Asked Questions

Q: What’s the difference between class_case and pascal_case?

A: They’re the same! Both produce PascalCase output.

Q: Can I use inflect() on a table with millions of rows?

A: Yes! The inflect() function only transforms column names, not the data itself, so it’s extremely fast regardless of table size.

Q: Does table_case always pluralize?

A: Yes, table_case converts to snake_case and pluralizes the name (e.g., User → users).

Q: Can I chain transformations?

A: Yes! You can nest inflect() calls or pipe results through multiple transformations.

Contributing

The Inflector extension is open source and developed by Query.Farm.

License

MIT License

Love ❤️ this DuckDB extension? You’ll Love This.

Get the best from Query.Farm — smart tips, powerful tools, and project updates sent directly to your inbox, but only when we’ve got something great to share.