Delim Converter

Convert lists between comma, pipe, tab, and custom delimiters with advanced options.

Input 0 items

Output 0 items

⚙️ Settings

Tidy Up Remove newlines

Attack clones Remove duplicates

Explode

Quotes

None Double " " Single ' '

Delimiter

SQL CASE Statement Builder — Build CASE WHEN Statements Visually

The CASE Builder lets you construct a SQL CASE WHEN statement visually, one condition at a time, without memorizing the exact syntax. It's built for analysts and developers who need to build a SQL CASE WHEN statement to turn status codes or numeric ranges into readable labels, without writing the WHEN/THEN structure by hand or worrying about a missing comma or END keyword.

⚡ Key Takeaways

Builds a full CASE WHEN statement from simple, visual condition rows.
Only the first matching WHEN clause is used — condition order matters.
An empty ELSE returns NULL for unmatched rows, not an empty string.
Eliminates missing commas and mismatched END keywords from hand-written CASE statements.

What, Who, When & Why

What it's for	Builds a SQL CASE WHEN statement visually, one condition at a time, without hand-writing the syntax.
Who it's for	Analysts and developers who need to turn status codes or value ranges into readable labels in a query.
When to use it	Whenever you need conditional logic in a SELECT statement — translating codes, bucketing values, or building a calculated column.
Why it's needed	Hand-writing a CASE statement risks a missing comma, mismatched END, or incorrect condition order, especially with several conditions.
Best way to use it	List your most specific conditions first, since only the first matching WHEN clause is used, and always set a meaningful ELSE value.

How to Use the CASE Builder

Enter the column or expression name the CASE statement should evaluate.
Click "+ Add condition" to add a WHEN/THEN row, then fill in the condition and its resulting value.
Add as many conditions as you need — each becomes its own WHEN clause.
Set an ELSE value for anything that doesn't match a condition.
The generated SQL updates live — click Copy when it's ready.

Example

With column status, a condition of 'active' → 'Active', and an ELSE value of 'Unknown', the builder generates:

CASE status
    WHEN 'active' THEN 'Active'
    ELSE 'Unknown'
END AS status_category

Adding a second condition, like 'pending' → 'Pending', extends the WHEN list automatically:

CASE status
    WHEN 'active' THEN 'Active'
    WHEN 'pending' THEN 'Pending'
    ELSE 'Unknown'
END AS status_category

Every added condition slots in with correct syntax and indentation, so there's no risk of a missing comma or mismatched END keyword as the statement grows.

Key Features

Visual, row-based interface — no need to hand-write WHEN/THEN syntax.
Add or remove conditions individually without breaking the overall structure.
Configurable ELSE clause for unmatched values.
Live-updating SQL output as you build.

Practical Use Cases

Translating status codes: convert numeric or short-code statuses into human-readable labels in a report.
Bucketing values: group ranges of values (like ages or scores) into named categories.
Building calculated columns: create a derived column that depends on conditional logic for a dashboard query.
Learning SQL CASE syntax: see correctly-formatted CASE statements generated as you build, useful as a reference while learning.
Standardizing labels across reports: quickly rebuild the same CASE logic for a different column without retyping the whole structure.

Tips for Best Results

List your most specific or highest-priority conditions first, since only the first matching WHEN clause is used.
Always set a meaningful ELSE value rather than leaving it blank, so unexpected or new values don't silently produce NULL in your results.
Copy the generated SQL into the SQL Formatter afterward if you're embedding it in a larger, more complex query.

Related Terminology

A CASE statement is SQL's conditional expression — similar to an if/else structure in programming — that evaluates a series of WHEN conditions in order and returns the THEN value for the first match, falling back to the ELSE value if none match. This is commonly used to create a derived or calculated column based on existing data.

Important Considerations

Conditions are evaluated in the order they're listed, and only the first matching WHEN clause is used — if two conditions could both match the same value, only the first one listed will take effect, so condition order matters for overlapping logic. If you leave the ELSE value blank, non-matching rows will return NULL rather than an empty string, which is worth confirming matches your intended behavior.

Related Tools

Once your CASE statement is built, format the surrounding query with the SQL Formatter. For more SQL boilerplate patterns, browse the SQL Query Templates. To understand an existing query that already uses a CASE statement, try the SQL Query Explainer.

Frequently Asked Questions

How do I build a SQL CASE WHEN statement without writing it by hand?

Enter your column name, add WHEN/THEN condition rows using the "+ Add condition" button, and the correctly-formatted CASE statement is generated automatically.

What does the ELSE clause do?

The ELSE value is returned when none of your WHEN conditions match — it acts as a fallback/default value for the CASE expression.

Does the order of conditions matter?

Yes, conditions are evaluated top to bottom, and only the first matching condition is used — this matters if your conditions could overlap.

What happens if I leave the ELSE value blank?

Rows that don't match any condition will return NULL instead of a label — set a meaningful ELSE value if you want a specific fallback instead.

Query Sanitizer

Strip comments, SET statements, and trailing semicolons from SQL.

Input SQL

Output

📌 Sticky Notes

Organize your thoughts, tasks, and ideas with drag-and-drop sticky notes.

📌

Click "+ Add Note" to create your first sticky note.

Text Comparator

Compare two texts and see the differences highlighted.

Text A

Text B

Ignore case Ignore whitespace

Differences

Click "Compare" to see differences highlighted.

Ready to compare

Text Statistics

Get detailed statistics about your text: words, characters, paragraphs, sentences, and more.

Input Text

📝 Words

🔤 Characters

📏 Characters (no spaces)

📄 Sentences

📑 Paragraphs

📃 Lines

📊 Avg word length

📊 Avg sentence length

Detailed Results

SQL Query Templates

Ready-to-use boilerplate for common query patterns — CTEs, joins, date rollups, window functions, and stored procedures. Click Copy and adapt the table/column names.

CTE

Basic CTE (Common Table Expression)

Break a query into a readable, reusable named block.

WITH recent_orders AS (
    SELECT
        customer_id,
        order_id,
        order_date,
        total_amount
    FROM orders
    WHERE order_date >= DATEADD(day, -30, GETDATE())
)
SELECT
    customer_id,
    COUNT(order_id)   AS order_count,
    SUM(total_amount) AS total_spent
FROM recent_orders
GROUP BY customer_id
ORDER BY total_spent DESC;

Recursive CTE (hierarchy / org chart)

Walk a parent-child tree, e.g. an employee/manager hierarchy.

WITH RECURSIVE employee_hierarchy AS (
    -- Anchor: top-level rows (no manager)
    SELECT
        employee_id,
        manager_id,
        employee_name,
        1 AS level
    FROM employees
    WHERE manager_id IS NULL

    UNION ALL

    -- Recursive: join children to their parent's result
    SELECT
        e.employee_id,
        e.manager_id,
        e.employee_name,
        eh.level + 1
    FROM employees e
    INNER JOIN employee_hierarchy eh
        ON e.manager_id = eh.employee_id
)
SELECT *
FROM employee_hierarchy
ORDER BY level, employee_name;
-- Note: SQL Server / Oracle: drop the RECURSIVE keyword (just WITH employee_hierarchy AS (...))

Joins

INNER / LEFT JOIN across multiple tables

Combine orders with customers and line items in one query.

SELECT
    o.order_id,
    c.customer_name,
    o.order_date,
    p.product_name,
    oi.quantity
FROM orders o
INNER JOIN customers c
    ON o.customer_id = c.customer_id
LEFT JOIN order_items oi
    ON o.order_id = oi.order_id
LEFT JOIN products p
    ON oi.product_id = p.product_id
WHERE o.order_date >= '2026-01-01'
ORDER BY o.order_date DESC;

GROUP BY / Dates

Monthly rollup with GROUP BY on a date

Aggregate a date column by month (swap the truncation line for your engine).

SELECT
    DATE_TRUNC('month', order_date) AS order_month,     -- PostgreSQL
    -- FORMAT(order_date, 'yyyy-MM')  AS order_month,    -- SQL Server
    -- DATE_FORMAT(order_date, '%Y-%m') AS order_month,  -- MySQL
    COUNT(*)          AS order_count,
    SUM(total_amount) AS revenue
FROM orders
GROUP BY DATE_TRUNC('month', order_date)
ORDER BY order_month;

Window Functions

ROW_NUMBER + running total

Rank each customer's orders and compute a running total.

SELECT
    customer_id,
    order_id,
    order_date,
    total_amount,
    ROW_NUMBER() OVER (
        PARTITION BY customer_id
        ORDER BY order_date DESC
    ) AS order_rank,
    SUM(total_amount) OVER (
        PARTITION BY customer_id
        ORDER BY order_date
        ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW
    ) AS running_total
FROM orders;

Stored Procedures

Parameterized stored procedure

A basic proc with optional date-range filters (T-SQL syntax).

CREATE PROCEDURE GetCustomerOrders
    @CustomerId INT,
    @StartDate  DATE = NULL,
    @EndDate    DATE = NULL
AS
BEGIN
    SET NOCOUNT ON;

    SELECT
        order_id,
        order_date,
        total_amount
    FROM orders
    WHERE customer_id = @CustomerId
        AND (@StartDate IS NULL OR order_date >= @StartDate)
        AND (@EndDate   IS NULL OR order_date <= @EndDate)
    ORDER BY order_date DESC;
END;
-- Call it: EXEC GetCustomerOrders @CustomerId = 101, @StartDate = '2026-01-01';

Upsert / Merge

MERGE (upsert) from a staging table

Insert new rows and update matching ones in a single statement.

MERGE INTO customers AS target
USING staging_customers AS source
    ON target.customer_id = source.customer_id
WHEN MATCHED THEN
    UPDATE SET
        target.customer_name = source.customer_name,
        target.email         = source.email,
        target.updated_at    = GETDATE()
WHEN NOT MATCHED THEN
    INSERT (customer_id, customer_name, email, created_at)
    VALUES (source.customer_id, source.customer_name, source.email, GETDATE());

🎨 Color Picker & Converter

Pick a color (or type a value) and get HEX, RGB, HSL, HSV, and CMYK instantly — copy any format with one click.

HEX

#FACC15

RGB

rgb(250, 204, 21)

RGB Percent

rgb(98%, 80%, 8%)

HSL

hsl(46, 96%, 53%)

HSV / HSB

hsv(46, 92%, 98%)

CMYK

cmyk(0%, 18%, 92%, 2%)

CSV ⇄ JSON Converter

Paste CSV or JSON and convert between them. Handles quoted fields, embedded commas, and nested-safe escaping.

Input

Output

SQL Query Explainer

Paste a SQL query and get a plain-English, structured breakdown of what it does. Pattern-based — works fully offline, no AI involved.

SQL Query

Plain-English Breakdown

Unit Converter

Convert data sizes and time durations. Pick a category, enter a value, and see it converted to every other unit.

Tools for analysts, developers & QA engineers

33 free, browser-based utilities — text and list tools, SQL helpers, converters, and small productivity apps. Everything runs locally; nothing you type or paste is ever uploaded.

📊

For Analysts

Clean lists, build SQL fragments, and reshape data without opening a spreadsheet.

💻

For Developers

Format SQL, convert data formats, and handle everyday text and encoding tasks.

🧪

For QA Engineers

Generate test data, compare text output, and sanitize queries before sharing them.