PostgreSQL table editor

Edit PostgreSQL table data visually.

Open a table, filter to the rows you care about, correct the values, review exactly what changed, and commit it in one transaction. PgDeck is a PostgreSQL table editor built for the everyday loop of finding a wrong row and fixing it.

Short answer: A PostgreSQL table editor lets you change row data in a grid instead of writing UPDATE statements. PgDeck holds each change as a pending edit — including inserts, duplicates, NULLs, and deletes — shows the full set for review, then commits it in one transaction, so a mistyped cell is caught before it reaches the database rather than after.

Download PgDeck View pricing

PgDeck PostgreSQL desktop client with schema navigation, table filtering, row editing, and SQL tools

Why developers use PgDeck

PgDeck is shaped around PostgreSQL tasks that happen every day: connect, inspect, filter, edit, query, manage structure, copy, and export.

Edit cells directly in the data grid, with the column type respected

Insert, duplicate, and delete rows without writing SQL

Set true NULL values rather than empty strings

Quick Look editor for long text and JSON values

Review every staged change before it is committed

Commit the whole set of edits in a single transaction

Secure connections

Save PostgreSQL connection details with encrypted passwords, SSL settings, URL import, testing, search, edit, and delete actions.

Schema and data grid

Browse schemas and tables, search the table list, pin favorites, filter rows, sort columns, resize columns, and paginate results.

SQL workspace

Run SELECT and non-SELECT statements from multi-tab SQL editors with syntax highlighting and interactive query results.

Staged editing

Edit cells, add rows, duplicate rows, set NULL, stage deletes, review pending changes, and commit everything in one transaction.

How to edit a PostgreSQL row without writing SQL

Open the table and narrow it down
Select the table in the schema tree, then filter rather than scroll. Filters are type-aware, so a boolean column offers true/false and a timestamp offers a date, and global search uses PostgreSQL ILIKE for case-insensitive matching. Editing the wrong row is nearly always a find problem, not an edit problem.
Edit the cell
Double-click a cell and type. The column type is respected, so a numeric column will not accept text and a date opens a date input. Long text and JSON open in the Quick Look editor instead of being squeezed into a grid cell. To store a real NULL rather than an empty string, use the explicit NULL action — this is the distinction that silently corrupts data in editors that treat blank as NULL.
Queue the rest of the change set
Insert new rows, duplicate an existing row as a starting point, and mark rows for deletion. Nothing has been written yet. Every pending change stays listed together, so a correction spanning six rows is one reviewable unit rather than six separate saves.
Review before committing
Check the pending set: which cells changed, which rows are new, which are marked for delete. This is the step that separates a staged editor from a grid that writes as you type, and it is the reason this workflow is safe to use on production data.
5
Commit in one transaction
Committing wraps the whole set in a single transaction, so either every change lands or none does. That matters when your edits are related — two rows that must stay consistent will never end up half-updated because something failed midway.
```
BEGIN;
UPDATE orders SET status = 'refunded' WHERE id = 4821;
UPDATE orders SET status = 'refunded' WHERE id = 4822;
DELETE FROM order_holds WHERE order_id IN (4821, 4822);
COMMIT;
```

Find the row before you edit it

Type-aware filters cover text, numbers, booleans, and dates, and global table search uses PostgreSQL ILIKE matching. Sort, paginate, and narrow to the row you actually meant to change instead of scrolling a raw result set.

Staged edits, not silent writes

Changes are held as pending edits and shown to you before anything reaches the database. Inserts, edits, duplicated rows, NULL values, and deletes are reviewed together and then committed in one transaction, so a mistyped cell is caught before it becomes a production incident.

The column details you need while editing

The column inspector shows data types, defaults, nullable state, and indexes, so you can see why a value was rejected without leaving the grid or reading the schema separately.

Drop into SQL whenever it is faster

Some edits are genuinely a query. Multi-tab SQL sits next to the grid for UPDATE and DELETE statements, and results come back in the same interactive table, so switching costs nothing.

Can I edit PostgreSQL table data without writing SQL?

Yes. PgDeck lets you edit cells, insert rows, duplicate rows, set NULL values, and delete rows directly in the data grid. The changes are staged and then committed as a transaction.

How do I set a column to NULL instead of an empty string?

PgDeck treats NULL as an explicit value in the grid, so you can set a true NULL rather than writing an empty string into the column.

Can I review changes before they are written?

Yes. Edits are staged first and shown for review, then committed in one transaction. That is the main difference from clients that write each cell as soon as you leave it.

Can I edit large JSON or text values?

Yes. The Quick Look editor opens long text and JSON values in a dedicated editor rather than a single grid cell.