UPPER() Function in SQL

Introduction

UPPER is a string function that converts applicable alphabetic characters to uppercase according to the database's character, locale, and collation rules. It is commonly used for report formatting, code normalization, case-normalized comparisons, grouping, profiling, and duplicate detection.

SELECT UPPER('hello sql') AS uppercase_text;

-- Result: HELLO SQL

For ordinary English ASCII, the transformation appears simple: lowercase letters become uppercase while digits, punctuation, and spaces remain unchanged. International text is more complex. Some characters have language-sensitive mappings, and an uppercase representation is not always a one-character-for-one-character conversion.

UPPER changes a query result unless it is used in UPDATE or another data-changing operation. It does not trim spaces, replace words, validate identifiers, or automatically make every search efficient. Reliable use separates presentation, comparison, and storage requirements and tests behavior on the actual DBMS and collation.

Basic UPPER Syntax

The function accepts one string expression and returns its uppercase representation.

UPPER(string_expression)

The input can be a literal, column, concatenated value, substring, or another compatible expression. NULL normally remains NULL.

SELECT UPPER('database') AS uppercase_text;

-- Result: DATABASE

A Simple Conversion

A short lowercase value demonstrates the transformation clearly.

SELECT UPPER('sql') AS uppercase_text;

-- Result: SQL

The function returns text; it does not alter the literal or any table row. Conversion rules come from the database implementation and relevant locale or collation settings.

Converting Mixed-Case Text

Every applicable lowercase letter in a mixed-case input is converted.

SELECT UPPER('Sql Tutorial') AS uppercase_text;

-- Result: SQL TUTORIAL

Letters that are already uppercase remain uppercase. The function does not preserve title-case distinctions.

Already Uppercase Text

Applying UPPER to ordinary text already in uppercase usually returns the same value.

SELECT UPPER('DATABASE') AS uppercase_text;

-- Result: DATABASE

This property makes many normalization operations idempotent: running the same uppercase conversion again does not continue changing basic ASCII output.

Using UPPER with a Column

When a column is supplied, every selected non-NULL value is converted independently.

SELECT employee_id,
       employee_name,
       UPPER(employee_name) AS uppercase_name
FROM employees;

John Smith, Mary Jones, and David Brown become JOHN SMITH, MARY JONES, and DAVID BROWN in the returned result. The table still retains its original representations.

Numbers and Punctuation

Digits and punctuation do not have letter case, so they normally remain unchanged.

SELECT UPPER('employee123') AS employee_label,
       UPPER('hello-world!') AS punctuated_label;

The expected outputs are EMPLOYEE123 and HELLO-WORLD!. UPPER does not remove, validate, or reinterpret non-letter characters.

Spaces Remain in Place

Case conversion preserves ordinary spaces.

SELECT UPPER('hello sql world') AS uppercase_text;

-- Result: HELLO SQL WORLD

Leading and trailing spaces also remain unless TRIM is applied. This distinction is important when normalization requires both case and boundary cleanup.

Combining UPPER with TRIM

Nested functions evaluate from the inside outward. TRIM removes supported boundary characters, then UPPER changes letter case.

SELECT UPPER(TRIM('   john smith   ')) AS normalized_name;

-- Result: JOHN SMITH

TRIM commonly removes ordinary spaces, not every Unicode whitespace character. Define the complete cleanup policy rather than assuming this expression handles all invisible input.

Combining UPPER with REPLACE

REPLACE can change separators before UPPER converts letters.

SELECT UPPER(REPLACE('sql-server', '-', ' ')) AS display_name;

-- Result: SQL SERVER

This is literal replacement. It does not title-case words, validate product names, or understand semantic separators.

Combining UPPER with SUBSTRING

SUBSTRING can extract a portion before conversion.

SELECT UPPER(SUBSTRING('database', 1, 4)) AS uppercase_prefix;

-- Result: DATA

Position and character semantics remain DBMS-specific. Test multilingual extraction before case conversion because some mappings can change length.

Combining UPPER with CONCAT

CONCAT can construct a full name, and UPPER can format the combined result.

SELECT employee_id,
       UPPER(CONCAT(TRIM(first_name), ' ', TRIM(last_name))) AS full_name
FROM employees;

NULL behavior depends on the database's CONCAT semantics. A missing component may produce NULL or a partial output. Define an explicit fallback only when the business rule requires it.

Converting Multiple Columns

Each selected text column can be converted separately.

SELECT UPPER(first_name) AS first_name,
       UPPER(last_name) AS last_name,
       UPPER(city) AS city
FROM customers;

This is useful for an uppercase export or report. It does not require permanent uppercase storage.

NULL Input

UPPER of NULL normally returns NULL because the source value is unknown.

SELECT UPPER(NULL) AS uppercase_text;

-- Typical result: NULL

NULL is not an empty string and should not be converted silently when missing data has separate meaning.

Using COALESCE with UPPER

COALESCE can provide a presentation fallback before conversion.

SELECT UPPER(COALESCE(employee_name, 'Unknown')) AS display_name
FROM employees;

This produces UNKNOWN for a missing name. It does not repair the source data, and quality reports should continue to count NULL separately.

Empty Strings

In databases that distinguish empty text from NULL, UPPER of an empty string returns empty text because there are no letters to convert.

SELECT UPPER('') AS uppercase_text;

Oracle treats a zero-length character string as NULL in SQL, so cross-database applications must test this state explicitly.

Formatting Report Output

UPPER is appropriate when a report specification requires uppercase labels while the system preserves preferred capitalization.

SELECT customer_id,
       UPPER(customer_name) AS report_name,
       UPPER(city) AS report_city
FROM customers;

Presentation requirements should not force destructive storage changes. Keeping original text supports user preference, branding, proper names, and future formats.

SELECT UPPER Does Not Modify Data

A SELECT expression transforms only the returned value.

SELECT employee_name,
       UPPER(employee_name) AS uppercase_name
FROM employees;

If the stored value is John Smith, a later direct query still returns John Smith. Permanent conversion requires an explicit data-changing statement.

Permanently Converting Stored Data

UPDATE can store uppercase values, but this should be done only when canonical uppercase is a documented requirement.

UPDATE products
SET product_code = UPPER(TRIM(product_code))
WHERE product_code IS NOT NULL;

Preview changes, detect collisions, verify column width, use appropriate transactions or batches, and test downstream systems before production execution.

Using UPPER in WHERE

UPPER can normalize a column during comparison.

SELECT employee_id, department
FROM employees
WHERE UPPER(department) = 'SALES';

This can match Sales, SALES, and sales under suitable mapping and comparison rules. A controlled department reference or case-insensitive collation may be a better long-term design.

Normalizing Both Comparison Sides

When a caller can provide mixed case, normalize both operands rather than requiring an already-uppercase parameter.

SELECT customer_id, city
FROM customers
WHERE UPPER(city) = UPPER(:search_city);

Parameters should still be used to prevent injection. Case conversion is not a substitute for parameterized SQL or input validation.

Using UPPER with LIKE

LIKE can operate on the uppercase result for prefix or contains searches.

SELECT employee_id, employee_name
FROM employees
WHERE UPPER(employee_name) LIKE UPPER(:name_prefix) || '%';

Concatenation syntax varies by DBMS. Leading-wildcard patterns such as %LAPTOP% commonly have greater indexing costs than anchored prefixes.

Case-Insensitive Collations

Many databases can compare text case-insensitively through collation, column type, operator, or index configuration. In such environments, wrapping both sides in UPPER may be unnecessary.

A collation defines more than case. It can also affect accents, language ordering, width, kana, and equivalence. Choose it according to application semantics rather than merely selecting a setting labeled case-insensitive.

UPPER and Index Performance

A predicate such as UPPER(email) = :normalized_email applies a function to the column. A normal index on the original email may not directly support the expression.

Actual behavior depends on the DBMS, collation, optimizer, and index. Inspect the execution plan with representative data instead of assuming every function causes a scan.

Expression and Function-Based Indexes

Several products can index an uppercase expression. PostgreSQL calls this an expression index, while Oracle commonly uses the term function-based index.

-- PostgreSQL example
CREATE INDEX ix_customer_email_upper
ON customers (UPPER(email));

The query expression should match the indexed expression. Index creation also formalizes the collation and mapping behavior in use, so migration and version upgrades require testing.

Generated or Computed Normalized Columns

A generated column can expose the normalized value for search, constraints, and indexing.

-- Conceptual pattern; syntax varies by DBMS
ALTER TABLE products
ADD normalized_code AS (UPPER(TRIM(product_code)));

This centralizes the rule but adds a schema contract. Decide whether original and normalized values both need to be visible and which is authoritative.

Sorting with UPPER

ORDER BY UPPER can normalize case before sorting.

SELECT employee_id, employee_name
FROM employees
ORDER BY UPPER(employee_name), employee_id;

Collation still controls ordering, accents, and linguistic behavior. A calculated sort can also add work on large result sets.

Grouping with UPPER

GROUP BY can combine case variants for profiling.

SELECT UPPER(TRIM(city)) AS normalized_city,
       COUNT(*) AS customer_count
FROM customers
GROUP BY UPPER(TRIM(city))
ORDER BY normalized_city;

This can group Chicago, CHICAGO, and ' chicago '. Unicode normalization and non-breaking spaces may still create distinct groups.

Distinct Uppercase Values

DISTINCT can list normalized categories or statuses.

SELECT DISTINCT UPPER(TRIM(status)) AS normalized_status
FROM orders
ORDER BY normalized_status;

This is useful during data profiling. Controlled status columns should ultimately use constraints, reference tables, or enumerated designs rather than relying only on runtime conversion.

Finding Case-Variant Duplicates

Grouping by uppercase text can expose values that differ only by case.

SELECT UPPER(TRIM(product_code)) AS normalized_code,
       COUNT(*) AS occurrence_count
FROM products
WHERE product_code IS NOT NULL
GROUP BY UPPER(TRIM(product_code))
HAVING COUNT(*) > 1;

These are collision candidates. Confirm whether the domain considers them identical before merging or enforcing uniqueness.

Normalizing Product Codes

Identifiers whose letter case is explicitly meaningless are strong candidates for uppercase normalization.

SELECT product_code,
       UPPER(TRIM(product_code)) AS normalized_code
FROM products;

Apply the same rule in forms, APIs, imports, database writes, search, and uniqueness checks. Inconsistent normalization simply moves the defect between layers.

Normalizing Status Values

UPPER can reveal Active, ACTIVE, and active as one reporting category.

SELECT UPPER(TRIM(status)) AS normalized_status,
       COUNT(*) AS row_count
FROM orders
GROUP BY UPPER(TRIM(status));

For permanent integrity, use a check constraint or reference table that permits only approved states. UPPER alone cannot reject misspellings such as ACTVE.

Using UPPER in CASE

CASE can classify a normalized value.

SELECT employee_id,
       CASE
         WHEN UPPER(TRIM(department)) = 'IT' THEN 'Technical'
         WHEN UPPER(TRIM(department)) = 'HR' THEN 'People Operations'
         ELSE 'Other'
       END AS department_type
FROM employees;

Repeated normalization in complex queries may be easier to maintain in a CTE, view, generated column, or controlled source column.

Generating Initials

SUBSTRING and UPPER can create basic initials from separate name fields.

SELECT CONCAT(
         UPPER(SUBSTRING(first_name, 1, 1)),
         UPPER(SUBSTRING(last_name, 1, 1))
       ) AS initials
FROM employees;

Real names can contain multiple parts, missing fields, combining marks, and cultural structures not represented by this demonstration.

UPPER Versus LOWER

UPPER converts applicable letters to uppercase; LOWER converts them to lowercase.

SELECT UPPER('Sql Tutorial') AS uppercase_text,
       LOWER('Sql Tutorial') AS lowercase_text;

Either can provide a comparison key when supported consistently. The choice should follow application and database conventions rather than preference alone.

UPPER Versus Title Case

UPPER does not title-case words. UPPER('john smith') returns JOHN SMITH, not John Smith.

Some databases provide INITCAP or related linguistic functions, but title casing is language-sensitive and not universally available. User-interface libraries often have better locale support.

MySQL UPPER

MySQL supports UPPER and UCASE as synonyms. Character set and collation affect available mappings and comparisons.

SELECT UPPER('hello sql') AS uppercase_text,
       UCASE('hello sql') AS uppercase_synonym;

Do not infer search behavior solely from the function result; the comparison collation remains important.

PostgreSQL UPPER

PostgreSQL supports UPPER and uses locale and collation information for case conversion.

SELECT UPPER('hello sql') AS uppercase_text;

PostgreSQL also offers the citext extension for case-insensitive text comparisons in suitable designs. Expression indexes are another option.

SQL Server UPPER

SQL Server supports UPPER, with collation playing a central role in conversion and comparison behavior.

SELECT UPPER('hello sql') AS uppercase_text;

Case-insensitive collations are common, so UPPER may be redundant for equality search. Computed columns and indexes can support deliberate normalized expressions.

Oracle UPPER

Oracle supports UPPER and provides NLS-aware functionality such as NLS_UPPER for linguistic requirements.

SELECT UPPER('hello sql') AS uppercase_text
FROM dual;

Oracle's empty-string-is-NULL behavior and linguistic settings should be included in migration and internationalization tests.

SQLite UPPER

SQLite provides upper, but built-in behavior is limited compared with full Unicode case mapping unless appropriate extensions or custom collations are available.

This is an important portability issue when a development environment uses SQLite but production uses another database. Test multilingual behavior on the actual target engine.

Cross-Database Comparison

DatabaseFunctionImportant note
MySQLUPPER / UCASECharacter set and collation matter
PostgreSQLUPPERLocale, collation, citext, and expression indexes are relevant
SQL ServerUPPERCollation strongly affects comparison behavior
OracleUPPER / NLS_UPPERLinguistic settings and empty-string behavior matter
SQLiteupperBuilt-in Unicode mapping can be limited

Unicode Case Mapping

Unicode contains scripts with special case behavior, characters without case, and mappings that depend on language. Uppercasing is not merely subtracting a numeric offset from each character.

A mapping can change code-point count or encoded byte length. Validate destination sizes and avoid assuming that substring positions remain equivalent after conversion.

Locale-Sensitive Examples

Languages such as Turkish have dotted and dotless forms of I with rules that differ from English expectations. German sharp s and other characters have historically had mappings that vary by Unicode version and implementation.

Applications serving multiple languages should define the locale used for case conversion. A database default chosen for sorting one language may not provide the desired identity rules for another.

Unicode Normalization

UPPER does not generally normalize canonically equivalent sequences. A precomposed letter and a base letter with a combining mark can remain different underlying strings after case conversion.

If canonical equivalence matters, establish a Unicode normalization policy in a capable layer and apply it consistently before comparison and uniqueness enforcement.

Case Folding Versus Uppercasing

Unicode case folding is designed for caseless matching and is not always identical to displaying uppercase text. UPPER is a presentation and transformation function, not a complete international case-folding algorithm.

For identity, login, or security-sensitive comparisons, use platform features documented for caseless matching rather than inventing a rule from UPPER alone.

Do Not Uppercase Passwords

Passwords are case-sensitive secrets unless a system explicitly defines otherwise. Converting them before hashing reduces the password space and changes user intent.

Store only secure password hashes produced by an appropriate password-hashing algorithm. UPPER belongs in display or normalized non-secret identifiers, not password handling.

Preserving Brand and Personal Name Capitalization

Names such as McDonald, van Gogh, iPhone, JavaScript, and organization-specific brands carry preferred capitalization. Permanently storing only uppercase destroys that presentation information.

Keep the original representation and create a normalized search key separately when case-insensitive matching is required. Storage, comparison, and display are independent design concerns.

Collision Analysis Before UPDATE

Values that differ only by case can become identical after permanent uppercase conversion. Check collisions before updating a unique code or username.

SELECT UPPER(TRIM(username)) AS proposed_username,
       COUNT(*) AS row_count
FROM app_users
GROUP BY UPPER(TRIM(username))
HAVING COUNT(*) > 1;

Resolve ownership through business rules. Do not automatically delete or merge rows simply because their normalized keys collide.

Safe Uppercase Migration

A controlled migration previews old and proposed values, measures affected rows, checks collisions and length expansion, evaluates constraints and indexes, and defines rollback.

SELECT product_id,
       product_code AS old_code,
       UPPER(TRIM(product_code)) AS proposed_code
FROM products
WHERE product_code <> UPPER(TRIM(product_code));

Comparison semantics can hide case-only differences on case-insensitive collations. Use DBMS-appropriate binary or case-sensitive diagnostics when necessary.

Batching and Operational Impact

A large UPDATE can hold locks, grow transaction logs, trigger audit logic, delay replication, and invalidate caches. Use stable, restartable batches when required by the production environment.

Monitor changed rows, lock waits, log usage, replication lag, application latency, and failures. Fix ingestion so new lowercase variants do not reappear after the migration.

Email Address Normalization

Email addresses are often compared without case differences, but uppercasing the entire address is not automatically the correct storage policy. Domain names are case-insensitive. The local part is technically controlled by the receiving system, even though most modern providers treat it case-insensitively.

A practical design stores the user-entered address for display and maintains a separately defined comparison key according to product policy. Verify that account lookup, uniqueness, outbound mail, identity providers, and audit logs use the same rule. Do not choose uppercase merely because it is visually obvious; lowercase comparison keys are equally possible when consistently implemented.

Usernames and Login Identifiers

Before normalizing usernames, decide whether case is meaningful. If John, JOHN, and john represent one account, enforce that rule during registration, lookup, recovery, and uniqueness checks. If case is meaningful, UPPER must not be introduced into authentication logic.

Security-sensitive identifiers also need Unicode normalization and protection against visually confusable characters. UPPER alone does not prevent spoofing, mixed-script names, or homograph attacks. Use an identity policy designed for the accepted character set and threat model.

Case-Insensitive Uniqueness

A system may need to preserve original capitalization while rejecting normalized duplicates. Depending on the DBMS, this can be implemented with a case-insensitive collation, an expression-based unique index, or a generated normalized column.

-- PostgreSQL example
CREATE UNIQUE INDEX ux_app_user_username_upper
ON app_user (UPPER(username));

Build the index only after collision analysis and cleanup. The selected collation and Unicode behavior become part of the identity contract, so database upgrades and migrations require regression tests.

UPPER in API Contracts

An API should document whether code fields are accepted in mixed case, rejected, or normalized. Silent conversion by one service and case-sensitive processing by another creates integration defects that are difficult to diagnose.

Normalize before generating signatures, hashes, or idempotency keys only when the protocol defines that canonical form. Changing case after signing changes the bytes and invalidates verification. Events and batch files should carry either canonical values or enough metadata to reproduce the agreed transformation.

Using a View During Migration

A view can expose a normalized value while consumers gradually migrate away from inconsistent legacy data.

CREATE VIEW product_code_view AS
SELECT product_id,
       product_code AS stored_code,
       UPPER(TRIM(product_code)) AS normalized_code
FROM products;

The view centralizes semantics but does not remove runtime calculation or automatically make searches index-friendly. Treat it as a compatibility layer with ownership, tests, and an exit plan.

Staging and ETL Normalization

Imports are safer when raw values enter a staging table before trusted tables. The pipeline can retain the original text, calculate uppercase candidates, classify errors, detect collisions, and load only accepted rows.

SELECT import_row_id,
       raw_product_code,
       UPPER(TRIM(raw_product_code)) AS proposed_code,
       source_file_name
FROM product_import_stage;

This preserves evidence when a source owner disputes a change and lets teams measure source quality by batch. It also prevents a failed rule from rewriting authoritative values directly.

Using a CTE for Repeated Normalization

A common table expression can calculate a normalized value once logically and make a complex query easier to review. The optimizer determines whether physical evaluation is reused.

WITH normalized_customers AS (
  SELECT customer_id,
         customer_name,
         UPPER(TRIM(city)) AS normalized_city
  FROM customers
)
SELECT normalized_city, COUNT(*) AS customer_count
FROM normalized_customers
GROUP BY normalized_city;

Use this for readability, not as a guaranteed performance optimization. Inspect the execution plan when repeated conversion affects a large workload.

Large Text and LOB Considerations

Applying UPPER to a large text or character large object can allocate substantial memory, increase CPU use, and produce a large temporary result. Support and return types differ among database products.

Convert only the portion needed for the requirement, avoid uppercasing documents merely for a contains search, and consider full-text search features with appropriate linguistic analysis. Verify maximum result sizes and driver behavior when returning transformed large objects to an application.

Caching and Normalized Keys

Applications often use text identifiers as cache keys. If the database compares them case-insensitively but the cache treats bytes exactly, John and JOHN can create separate cache entries for one record.

Define one canonical key generation rule shared by the database, application, cache, events, and background jobs. Version the rule when it changes, and invalidate or migrate old keys. UPPER is one possible component, not a complete distributed identity strategy.

Audit and Privacy Considerations

A preview or migration log may contain names, email addresses, account codes, and other sensitive text. Recording both original and uppercase values can duplicate personal data without adding useful evidence.

Log row identifiers, transformation versions, counts, timestamps, and masked samples according to access and retention policy. Keep detailed reconciliation data only where necessary and protected. A normalization project should not create a less controlled copy of the source.

Uppercasing Structured Documents

Do not apply UPPER to an entire JSON, XML, or HTML document merely to normalize one value. Case can be significant in property names, element names, attribute values, URLs, encoded tokens, scripts, and user content. Whole-document conversion can make the structure invalid or change its meaning.

Use JSON or XML functions to select the intended property, normalize only that scalar value, and write it back with a structure-aware operation. HTML and rich text should be handled by parsers that preserve markup. Validate the complete document after any transformation.

Normalizing Bound Parameters

When a query uses UPPER(column) = UPPER(:parameter), the parameter must remain bound rather than concatenated into SQL. UPPER changes case; it does not escape quotes, prevent injection, validate allowed characters, or enforce authorization.

Applications can normalize the parameter before sending it, but database and application rules must match. Passing an already normalized key may simplify SQL and improve index use when paired with a normalized column. Retain automated tests that compare both paths across locales and databases.

Verifying a Permanent Conversion

After an UPDATE, re-run collision checks, compare NULL and row counts, verify constraints and indexes, and inspect representative multilingual values. Exercise search, login, exports, APIs, reports, caches, and downstream reconciliation.

Record affected rows and unresolved exceptions. Confirm that all write paths now enforce the canonical rule; otherwise, mixed-case variants will return and the migration will need to be repeated.

Testing UPPER Logic

Tests should include lowercase, uppercase, mixed case, digits, punctuation, leading and trailing spaces, empty text, NULL, accented text, non-Latin scripts, locale-sensitive letters, combining marks, and values near column limits.

Run tests on every supported DBMS, version, character set, and collation. Verify output, length, comparisons, indexes, constraints, and downstream integrations.

Common Mistakes

Common errors include assuming SELECT changes stored data, expecting spaces to disappear, using UPPER when the collation already ignores case, and believing all languages follow English case rules.

Other risks include permanently uppercasing user-facing text, overlooking index plans, ignoring normalization and length expansion, and treating uppercase conversion as validation.

Best-Practice Checklist

  1. Separate display formatting, comparison, and canonical storage requirements.
  2. Preserve original capitalization for user-facing names and brands.
  3. Define locale, collation, character set, and Unicode normalization policy.
  4. Keep NULL distinct unless a documented fallback is required.
  5. Use constraints or reference tables for controlled values.
  6. Investigate case-insensitive collations before wrapping every predicate.
  7. Use expression indexes or normalized columns for frequent searches.
  8. Check collisions and length changes before permanent conversion.
  9. Test multilingual and locale-sensitive values on every target DBMS.
  10. Never uppercase passwords or other case-sensitive secrets.

Interview Questions and Answers

What does UPPER do? It converts applicable alphabetic characters in a string to uppercase.

Does UPPER change numbers? No. Digits remain unchanged.

Does it remove spaces? No. Use TRIM for supported boundary spaces.

What does UPPER(NULL) return? It normally returns NULL.

Does SELECT UPPER modify the table? No. It changes only the returned result.

Can UPPER be used in WHERE? Yes, but collation and index implications should be evaluated.

What is UPPER versus LOWER? UPPER converts to uppercase; LOWER converts to lowercase.

Is UPPER title case? No. It converts all applicable letters, not only initials.

Can UPPER affect index usage? Yes. Use a compatible expression index, computed column, or collation where appropriate.

Is UPPER identical across languages? Not necessarily. Unicode, locale, collation, DBMS, and version affect mappings.

Key Takeaway

UPPER converts applicable letters to uppercase and is useful for reports, normalized codes, profiling, and deliberate case-insensitive workflows. It does not clean whitespace, validate values, or guarantee efficient searching.

RELIABLE UPPERCASE LOGIC = CLEAR BUSINESS PURPOSE
                         + DEFINED LOCALE AND COLLATION
                         + PRESERVED ORIGINAL TEXT
                         + NULL AND UNICODE TESTING
                         + APPROPRIATE INDEX DESIGN
                         + SAFE STORAGE MIGRATION

Use UPPER as a focused transformation. Prefer configured comparison semantics for search when appropriate, retain preferred capitalization, and test international text on the real production database.