Introduction

Suppressing column headers for one query is usually a client-tool problem, not a SQL language feature. SQL describes what data to return, while the client decides how to print it. That is why the right answer depends on whether you are using psql, mysql, sqlcmd, sqlite3, or some other shell.

Why SQL Itself Usually Does Not Control Headers

A SELECT statement returns a result set with column metadata. Whether those names appear in terminal output is decided by the client rendering the result.

So the question is really: how do I tell my SQL client to hide headers for just one command without changing the whole session permanently?

That is a formatting concern, not a query-logic concern.

Common Client-Specific Solutions

For PostgreSQL psql, use tuple-only mode for a single command.

psql "$DATABASE_URL" -t -c "SELECT count(*) FROM users;"

For MySQL, -N or --skip-column-names removes headers.

mysql -u app -p -N -e "SELECT id, email FROM users WHERE active = 1;" app_db

For SQL Server sqlcmd, -h -1 suppresses headers.

sqlcmd -S localhost -d appdb -Q "SET NOCOUNT ON; SELECT id FROM users;" -h -1

For SQLite, turn headers off in the client session.

1sqlite3 app.db <<'SQL'
2.headers off
3.mode list
4SELECT id, email FROM users WHERE active = 1;
5SQL

Scope the Change to One Command Block

The safest pattern is to make the formatting change local to the specific execution. For example, in psql you can bracket one query with output settings:

1psql "$DATABASE_URL" <<'SQL'
2\pset tuples_only on
3SELECT id FROM users LIMIT 3;
4\pset tuples_only off
5SQL

That keeps interactive defaults intact and prevents later commands from silently changing format.

Prefer Application-Level Formatting in Code

If the query is being executed from application code, suppressing headers is irrelevant because drivers return rows, not terminal tables. Format the result yourself.

1import sqlite3
2
3conn = sqlite3.connect("app.db")
4cur = conn.cursor()
5cur.execute("SELECT id, email FROM users WHERE active = 1")
6
7for row in cur.fetchall():
8    print(f"{row[0]},{row[1]}")

This is more reliable than shell parsing because you control the output exactly.

Think About Machine Parsing, Not Just Headers

When a query feeds another script, column headers are only one part of the problem. You may also need to control:

• row-count footers
• delimiters
• quoting
• NULL rendering
• whitespace trimming

A command that hides headers but still prints decorative table borders is not actually machine-friendly.

That is why it is often better to pair header suppression with a stable output mode such as tuple-only, list, CSV, or delimiter-separated format.

For one-off shell pipelines, it is worth testing the exact command output with a sample query before wiring it into automation. That catches formatting surprises early.

Common Pitfalls

• Looking for a universal SQL clause to suppress headers when the feature belongs to the client.
• Disabling headers globally and forgetting to restore the setting.
• Parsing pretty-printed table output in automation scripts.
• Hiding headers but leaving row-count footers or formatting noise in place.

Summary

• Header suppression is usually controlled by the SQL client, not by SQL syntax itself.
• Use client-specific flags such as -t, -N, or -h -1 for one-off command output.
• Keep formatting changes scoped to a single execution when possible.
• In application code, format rows directly instead of relying on shell output rules.
• For automation, consider the whole output format, not only the headers.