NULL, empty strings, time zones and big numbers

Alcuin reads each value as the text Postgres sent. It never rounds a number or converts a time to another zone, and a copy gives the server’s text. On screen, some types are laid out to read more easily, as this page says for each. This page shows how to read and enter the values that most often go wrong.

Tell NULL from an empty string

In the grid and the row panel:

• NULL shows as NULL, in muted italics in the grid.
• An empty string shows as ''.
• Any other text shows as itself. A cell that reads NULL in plain type is the four-letter string.

In the row panel, three or more fields that are NULL or empty fold into one line, such as 3 empty: email, phone, note. Click Show to see each one.

To find the NULLs in a column, open a row in the row panel, then use the field’s menu: on a NULL it offers Filter to email is NULL.

When you copy

Copying one cell, with the copy key or Copy cell in its right-click menu, gives its value exactly as Postgres sent it. NULL and an empty string both copy as nothing, so a plain copy cannot tell them apart. To keep the difference, right-click and use Copy as:

Format	NULL	Empty string
CSV	empty field	""
JSON	null	""
SQL values list	NULL	''

Import and export lists what each format keeps.

Set a value to NULL or to an empty string

Edit in the row panel, where each field has a menu:

1. Open the row in the row panel, and hover the field.
2. Open the field’s menu.
3. Choose Set NULL to make it NULL. On a NULL, Set a value opens the editor.
4. To store an empty string in a text column, choose Edit, clear the text, and stage it.

A NULL you open and leave without typing stays NULL: nothing is staged. The field shows the old value beside the new one, such as was NULL or was '', until you commit. Review SQL shows the exact statement, with NULL or ''. See Edit, add and delete rows.

Read a timestamp

Postgres has two timestamp types, and Alcuin shows each as Postgres writes it:

• timestamptz (timestamp with time zone) is a moment. Postgres shows it in the session’s time zone, with the offset: 2026-10-09 14:00:11-05. The row panel names the zone, 2026-10-09 14:00:11 UTC-05.
• timestamp (timestamp without time zone) is a wall-clock time with no zone. The row panel adds (no zone) after it.

The session’s time zone is the server’s TimeZone setting, or the one set for the database or your role. Alcuin does not change it, so two people connected as the same role see the same text, wherever their computers are.

Seconds are padded to the column’s precision, so a column of timestamptz(6) reads 07:22:19.305180 and 17:12:46.000000, not ragged. Padding adds only zeros: the value is the same.

In the row panel, a time within the last or next 30 days reads relative instead, such as 3 days ago. Hover it for the exact value and zone.

Enter a timestamp

When you edit a timestamp in the row panel, a hint under the field reads what you typed as a date and time in your computer’s time zone, and names that zone, such as in Europe/London. Check it before you stage.

Postgres reads the text, not Alcuin. A timestamptz typed without an offset is read in the session’s time zone, which may not be your computer’s. Type the offset to be sure: 2026-10-09 14:00:11+00.

Keep big numbers exact

Numbers are shown as Postgres sent them, right-aligned:

• A bigint keeps all its digits: 9223372036854775807.
• A numeric keeps its full precision and scale: 0.10000000000000000001.
• NaN and Infinity show as written.

When you edit a number, Alcuin checks only that the text is a number, and says Not a number otherwise. Postgres checks the range and scale when you commit.

Exports and copies keep the digits too. CSV, INSERT and the SQL values list write the text as it came; INSERT quotes every value, numbers too, and Postgres casts it. JSON writes every value that isn’t json as a string, numbers and booleans included, so no reader rounds them on the way in.

Read and edit JSON

A json or jsonb value shows on one line in the grid. In the row panel it reads as a tree whose objects and arrays fold.

The tree and copies keep the value’s numbers exactly, however long. A json value, which Postgres stores as typed, keeps its spacing and repeated keys when you copy or export it.

The JSON editor checks the text before you stage it. Invalid JSON is not staged: the editor says what is wrong and where, ending with the place, such as at line 3, column 7. Valid JSON is staged in compact form.

SQL NULL and a JSON null are different values. The grid shows SQL NULL as NULL, and a JSON null as null.

Long text and binary

• Long text in the row panel shows its first four lines, with Show all and how many characters it has. Text keeps its line breaks: in the editor, Enter starts a new line.
• A bytea value shows as its size and its first bytes in hex, such as 512 bytes 0x89504e470d0a1a0a0000000d…. A copy gives the whole value in hex. The row panel offers no Edit for it; Set NULL still works.
• A boolean shows as true or false, and copies as Postgres sends it, t or f.

If a value looks wrong

• A time looks hours off: compare the offset in the value with your own. The session’s time zone, not yours, decides how timestamptz is written.
• A number looks rounded in another tool after export: that tool rounded it on import. The file holds every digit.
• Your edit was refused when you committed: the bar shows Postgres’ message. Nothing was changed.