Convert Text to UPPERCASE

UPPERCASE Converter,Convert Text to All Caps

With UPPERCASE, every letter changes and no word boundary matters. It works on any text: code, prose, UI labels, or raw strings. SQL keywords are conventionally written in UPPERCASE for readability.¹ Constants, headings for certain design contexts, and abbreviations all call for all-caps output.

Converting prose or mixed-case text to UPPERCASE is a character-level operation, not a word-level one. The tool does not split on word boundaries or add separators: it simply maps every character to uppercase for review or export.

Where UPPERCASE text is used

SQL conventionally writes keywords in UPPERCASE: SELECT, FROM, WHERE, JOIN, GROUP BY.¹ Constants in many languages (C, Python, JavaScript) follow SCREAMING_SNAKE, which is uppercase with underscores, but when you need just the casing without underscores, this converter handles it. Building on this, design contexts like banner text, navigation section labels, and monospace UI headers often use all-caps for visual weight. Acronyms (API, URL, HTTP) are written in UPPERCASE in documentation. HTTP/2 and HTTP/3 protocol specifications render header field names in lowercase, but the older HTTP/1.1 convention of capitalized headers (Content-Type, Accept-Encoding) persists in many codebases and documentation examples.² Legal disclaimers, terms-of-service headers, and license agreement summaries frequently use UPPERCASE for emphasis, and some government forms require all-caps entries for machine readability.

Edge cases: non-letter characters and locale-sensitive casing

Numbers, punctuation, and special characters are not affected: they pass through unchanged. The converter uses JavaScript's built-in toUpperCase(), which is locale-aware but uses the browser's default locale.³ Consequently, locale-specific characters (like the German ß or Turkish i/I distinction) may produce unexpected results if the browser locale does not match the expected language. For ASCII text, this is never an issue. The German ß is a notable edge case: in most browser locales, toUpperCase() converts it to "SS", which changes the string length and may affect character-count-sensitive contexts like fixed-width displays. For Turkish text, the dotted/dotless I distinction means that "i" uppercases to "İ" (dotted I) in a Turkish locale but to "I" (standard I) in most other locales.⁴ If your application serves Turkish users, test uppercase conversion with Turkish-specific input to verify the output matches expectations.

Workflow: formatting SQL query keywords

Building on this, a practical use: when writing SQL queries in a text editor that does not auto-capitalize keywords, you can draft the query in mixed case and then use the UPPERCASE converter on just the keyword portions. CapyToolkit processes whatever you paste, so selecting specific lines and converting only those is the cleanest approach. For SCREAMING_SNAKE constants, use the CONSTANT_CASE converter instead: this converter does not add underscores. When formatting SQL for documentation or code review, paste the keyword list (SELECT, FROM, WHERE, etc.) to get the canonical uppercase form, then manually recombine them with your identifiers. SQL linters like sqlfluff enforce uppercase keywords by default,⁵ and running your query through this converter before pasting it into a migration file or stored procedure ensures it passes linting on the first attempt without manual keyword-by-keyword correction.

SQL keyword capitalization conventions across database systems

SQL keyword capitalization is not enforced by any database engine, but all major style guides recommend UPPERCASE for reserved words. Understanding why the convention exists helps you decide when to apply it and when to skip it. The convention persists across decades of database tooling because it makes SQL significantly more readable when scanning complex queries with multiple joins and nested conditions. When you uppercase a block of SQL keywords in one pass, the output gives you the canonical form that every major style guide expects, which means your query formatting matches what reviewers and automated linters look for before a migration reaches production.

PostgreSQL, MySQL, and SQLite treat SQL keywords as case-insensitive by the SQL standard.⁶ You can write select, Select, or SELECT and all three execute identically. The UPPERCASE convention survives because it creates a visual split between language keywords and your identifiers: SELECT user_id FROM users WHERE is_active = true scans faster than select user_id from users where is_active = true when reading unfamiliar queries. Linters like sqlfluff enforce uppercase keywords by default.⁵

When to skip UPPERCASE keywords

Query builders, ORMs, and code-generated SQL typically produce lowercase or mixed-case keywords because the output is not intended for human reading. If your SQL goes directly to an ORM method call or a query-builder chain, UPPERCASE keywords add no value. Apply UPPERCASE when the SQL is written or read by humans: in migration files, in database documentation, and in ad-hoc query tools like psql or TablePlus.

One more reason to skip automatic UPPERCASE is locale sensitivity. JavaScript's toUpperCase() depends on the browser's default locale, and for Turkish text the lowercase i maps to a dotted İ rather than a plain I. If you uppercase user-submitted names or labels that may contain Turkish characters, the result can look wrong to those users, so a targeted or language-aware transform is safer than a blanket conversion.

Comparing UPPERCASE output to CONSTANT_CASE for the right use

UPPERCASE and CONSTANT_CASE (SCREAMING_SNAKE) are easy to confuse because both produce all-capital letters. They serve different purposes and are not interchangeable. Choosing the wrong one produces output that either breaks identifier validation or fails to format SQL correctly. Knowing the distinction before you start saves the round-trip of converting the same text again. The key difference is whether you need separators between words: UPPERCASE keeps the original spacing while CONSTANT_CASE replaces spaces and word boundaries with underscores to produce a valid identifier. If you need a valid environment variable name or a Python constant, CONSTANT_CASE is the right choice because the underscores make it a legal identifier in every major programming language.

When UPPERCASE is the right tool

UPPERCASE converts a word or phrase without adding separators, which distinguishes it from CONSTANT_CASE formats. Acronyms (HTML, CSS, API), SQL keywords (SELECT, FROM, WHERE), and display-only all-caps text like banner headings all benefit from this simple transformation. The output has no underscores added: "background color" becomes "BACKGROUND COLOR", not "BACKGROUND_COLOR". Use this converter when you need visual emphasis or SQL formatting, not identifier naming.

When CONSTANT_CASE is the right tool

CONSTANT_CASE adds underscores between words while also converting every letter to uppercase: "background color" becomes "BACKGROUND_COLOR". This is the correct format for environment variable names, configuration constants in Python and JavaScript, and preprocessor macros in C and C++. If you need the output to be a valid identifier in a shell or programming language, use the CONSTANT_CASE converter instead of this one.

When to use this

Use this when formatting SQL keywords, converting abbreviations to their standard uppercase form, or producing all-caps text for banner headings or constants that should not have underscores.

Examples

select id, name from users where active = true

SELECT ID, NAME FROM USERS WHERE ACTIVE = TRUE

html
css
api
url
http

HTML
CSS
API
URL
HTTP