Results

When a run returns rows, they appear under the editor in a Data Output tab. Everything else the server says (command tags, notices, errors) goes to the Messages tab beside it. This page covers reading results. Changing rows in place is on Edit data, and saving them to a file on Save results to a file.

The result bar

The bar between the editor and the results holds the result tabs, a line about the last run, and the buttons that act on the result in front.

1 The result tabs. A statement that returns rows gets a Data Output tab. When a script returns several results, each gets a tab, numbered Data Output 1, Data Output 2 and so on, in the order the statements ran. Messages is always there. Explain appears once you have explained a statement in this tab (see Explain a query), and History lists the queries run on this server (see Files, drafts and history). A data tab, which shows a table’s rows, has only Data Output and Messages.
2 What the last run did: how many rows the result in front holds and how long the run took, for example 50 rows · 24 ms. It says Running… while the script runs, Saving… while changed rows are being saved, Showing 100,000 of 250,000 rows when the result was cut at the row limit (see Row limits) and, in red, how many statements failed (1 error). For a few seconds after you copy or export, it says what happened instead: Copied 50 rows, Exported 50 rows to shop-export.csv, or why it could not (Could not copy: …).
3 How to show the result: Grid, Text, and Map when the result has a PostGIS geometry or geography column. The switch shows while a result is in front, in a query tab only. Each query tab keeps its choice for its next runs.
4 Copy puts every row the result kept on the clipboard as tab-separated text, with the column names on the first line. While the result shows as text, it copies the text as you see it.
5 Export writes the result to a CSV or JSON file. It is greyed out while the tab is running something. See Save results to a file.
6 Editable · public.orders appears in a query tab when pgjumbo can save changes to these rows: they come from one table, with its primary key. Double-click a value or press F2 to change it. A data tab says the same beside its SELECT instead (see View data).
7 Add row adds an empty row to that table, saved with your other changes. Editing is explained on Edit data.

While the Explain tab is in front, the bar shows Copy JSON (or Copy text) and Ask about this plan instead; they are explained on Explain a query.

Which tab comes to the front:

A run starts on Messages. Its first result comes forward as soon as it starts to arrive; later results wait in their own tabs.
A run that returns no rows (an UPDATE, a CREATE TABLE) stays on Messages.
When a statement fails, the results of the statements before it stay on screen. The editor underlines the error and the bar says 1 error; open Messages to read it.

Before anything has run, the results area says “No result set. Ctrl+Enter runs the selection, or the whole tab; Shift+Enter in the editor runs the statement at the cursor.” On a Mac it names ⌘↩ instead of Ctrl+Enter. Running is explained on The Query Tool.

Read the grid

The orders table in the grid: a # column, headings with the column name and its type, an FK tag on customer_id, NULL in grey italics, and a block of cells selected.

1 The Data Output tab of this result.
2 The # column numbers the rows from 1. Click a number to select its row.
3 Each heading shows the column’s name and, under it, its type as PostgreSQL writes it (timestamp with time zone, numeric(12,2)). Hover over a heading to see both on one line.
4 An FK tag marks a column that is part of a foreign key. Hover over it to see the table it references (“References public.customers”). See Follow a foreign key.
5 NULL shows in grey italics, so you can tell it from the text 'NULL'. You can choose another word in Settings, under Results › Show NULL as. An empty string shows as an empty cell.
6 Selected cells are shaded. The cell with the outline is the one the keyboard moves from.

Other things to know about the grid:

Numbers (smallint, integer, bigint, oid, real, double precision, numeric) line up on the right; everything else lines up on the left. Every other row has a light stripe.
A cell shows the start of a long value. To read all of it, open the cell viewer or switch to Text.
pgjumbo sizes each column from its name, its type and the first 100 rows, between 64 and 360 pixels. When the columns are narrower than the pane, they grow (to at most twice their width) to fill it. You cannot drag a column’s edge to resize it.
Clicking a heading selects the column; it does not sort. Add an ORDER BY to the query instead. Data tabs, which show a table’s rows, do have sort buttons: see View data.
The height of the rows follows Density in Settings, under Appearance (Compact or Comfortable).
The grid draws only the rows and columns on screen and fetches the rows from pgjumbo’s engine 500 at a time as you scroll, so a long result costs the window no more than a short one.

Select cells, rows and columns

Click into the grid first, so it has the keyboard.

To select	Mouse	Keys
One cell	Click it	The arrow keys move one cell
A block of cells	Drag across them, or click one corner and Shift+click the other	Shift with the arrow keys, Page Up, Page Down, Home or End
A whole row	Click its number in the # column; Shift+click another number for several rows
A whole column	Click its heading; Shift+click another heading for several columns
Everything	Click the # heading	`⌘ A` (Ctrl+A on Windows and Linux)

To move without selecting more: Page Up and Page Down move a screen of rows, Home and End go to the first and last column of the row, and ⌘ Home (Ctrl+Home on Windows and Linux) and ⌘ End (Ctrl+End on Windows and Linux) go to the first and last cell of the result. Enter opens the cell viewer on a result that cannot be edited.

Copy

⌘ C (Ctrl+C on Windows and Linux) in the grid copies the selected cells, without the column names.
Right-click and choose Copy with headers to copy them with the column names on the first line.
Copy in the result bar copies the whole result with its column names.

The copy is tab-separated text, one line per row, which a spreadsheet pastes into separate cells. A NULL becomes an empty field. A value that holds a tab, a line break or a double quote is put in double quotes, with its own double quotes doubled, the way spreadsheets read it. pgjumbo builds the text in its engine from the rows it kept, so copying 100,000 rows does not slow the window down. Rows past the row limit, and rows you added but have not saved, are not part of it.

After a copy, the result bar says what went to the clipboard: Copied 3 rows × 2 columns, or Copied 50 rows.

Right-click a cell. If it is outside the selection, pgjumbo selects it first; inside the selection, the selection stays.

The right-click menu of a cell in the customer_id column: Copy, Copy with headers, View value, Follow to public.customers, Edit value, Set to NULL, Set to DEFAULT, Revert changes, Add row and Delete rows.

1 Copy copies the selection without column names (⌘ C (Ctrl+C on Windows and Linux)).
2 Copy with headers copies it with the column names on the first line.
3 View value opens the cell viewer on the cell with the outline. Its key, Enter, shows in the menu when the result cannot be edited. It is greyed out on a row you added and have not saved.
4 Follow to public.customers opens the row this value refers to. It appears only on a column with an FK tag, once for each foreign key the column belongs to. See Follow a foreign key.
5 Edit value, Set to NULL, Set to DEFAULT, Revert changes, Add row and Delete rows appear only when the result can be edited. They are explained on Edit data.

See a whole value

Open the cell viewer in one of these ways:

Right-click a cell and choose View value. This works on every result.
Double-click a cell, or select it and press Enter, on a result that cannot be edited. On a result that can (the bar shows Editable), a double-click and Enter start editing the value instead.

The cell viewer for the prefs column, jsonb, row 1: the JSON value laid out over several lines, 36 bytes, and the Copy and Done buttons.

1 The column’s name, with its type and the row number under it.
2 The whole value, in a monospaced font. A json or jsonb value is laid out with indentation; pgjumbo keeps the keys in the order the server sent them and every digit of the numbers. A NULL shows as your Show NULL as word. Values are always shown as plain text, never as a web page. The viewer says Loading… while the value is on its way.
3 The value’s size in bytes. For bytea, it is the size of the binary data, not of its hex text. A value larger than one megabyte shows only its first megabyte, without the JSON indentation, and the size line adds “showing the first megabyte”.
4 Copy puts the value, as shown, on the clipboard. The button says Copied for a moment. It is greyed out for a NULL.
5 Done, Esc or the × closes the viewer.

Show results as text

Click Text in the result bar, choose QueryResults as Text, or choose Results as Text in the toolbar’s More (…) menu. The menu items are ticked while the tab shows text, and choosing one again goes back to the grid. None of them has a key.

The orders result as text: a header line with the column names, a dashed line under it, and the rows with their values separated by vertical bars.

1 Text is selected in the result bar.
2 The result is laid out the way psql prints it: the column names centred over their values, a line under them, numbers on the right and everything else on the left. A value with line breaks goes on over several lines, each marked with + where the column ends, and a tab in a value becomes four spaces. A NULL is written NULL here, whatever Show NULL as says.
3 Copy copies the text as you see it, ready to paste into a ticket or a chat.

The last line counts the rows: (50 rows). The text holds at most the first 10,000 kept rows and then says so, for example (the first 10000 of 50000 rows). When the row or memory limit cut a result at 10,000 rows or fewer, the last line says how many the server sent, for example (8000 rows of the 250000 the server sent were kept).

Text and Map are for query tabs. A data tab always shows its rows in the grid.

Show geometry on a map

When a finished result has a PostGIS geometry or geography column, the result bar offers Map. pgjumbo reads the kept rows’ values (PostgreSQL sends them as hex EWKB) in its engine and draws their points, lines and polygons. Only x and y are drawn; Z and M are left out.

Three places on a map: a line, a point on it and a filled polygon, on a plain grid labelled in degrees, with the details of the chosen polygon in a card at the top right.

1 Map in the result bar.
2 What was drawn: the number of shapes and the SRID of the first value that names one (or “no SRID”); a geography column is always SRID 4326. The line also says when some values were empty or NULL (2 empty), could not be read (1 not readable), or when the drawing stopped after 250,000 points (the rest left out: too many points). It says Reading shapes… while pgjumbo reads them.
3 Zoom in (+), Zoom out (−) and Fit, which shows every shape again.
4 A shape. Hover over it to see its row number; click it to see the row.
5 The row of the shape you clicked, with up to eight of its other columns (a NULL shows as an empty value). The × closes the card.
6 The grid lines are labelled in the data’s own units: degrees (16.4°E, 43.5°N) for longitude and latitude, plain numbers for other coordinate systems.

With the mouse, the wheel zooms in and out around the pointer, dragging moves the map, and a double-click zooms in two times around that spot. When a result has more than one geometry column, a list at the start of the map’s bar picks the column to draw. If every value is empty or NULL, the map says “Nothing to draw: every value is empty or NULL.”

Map tiles

By default the shapes sit on a plain grid and pgjumbo downloads nothing. To see them over a street map, enter a tile server’s address in Settings, under Results › Map tiles under geometry, for example https://tile.openstreetmap.org/{z}/{x}/{y}.png. The address must start with https:// and contain {z}, {x} and {y}.

Tiles are used only for longitude and latitude (SRID 4326, which geography always is). The map then draws in Web Mercator over the tiles without grid lines, shows the coordinates of its centre in the map’s bar, and names the tile server at the bottom (Tiles: tile.openstreetmap.org). For data in another SRID, the bar says “tiles need longitude and latitude (SRID 4326)” and the map keeps its plain grid.

Row limits

pgjumbo keeps a result’s rows in its engine, not in the window. It keeps at most 100,000 rows or 200 MB per result, whichever comes first. Rows past the limit are counted but not kept, and the result bar says so:

The result bar after SELECT generate_series(1, 250000): Showing 100,000 of 250,000 rows.

1 Showing 100,000 of 250,000 rows: the server sent 250,000 rows and pgjumbo kept the first 100,000.

Rows arrive in batches while the query runs, so the first ones show in the grid while the rest are still coming. There is no “fetch more” button: to see rows past the limit, narrow the query (WHERE, LIMIT and OFFSET), or raise the limit and run it again. The Export dialog can also run a read-only query again with COPY and write every row to a CSV file without keeping them; see Save results to a file.

Change the limits in Settings, under Results:

Setting	Default	Range
Rows kept per result	100,000	1,000 to 10,000,000
Memory per result (MB)	200	16 to 4,096

Read the Messages tab

Messages lists every statement of the last run, in order, with what the server said about it.

A two-statement script where the second fails: the editor underlines nowhere_orders, and Messages shows statement 1 with SELECT 1, statement 2 with the error, SQLSTATE 42P01 and a line and column link, Fix with the Assistant, and the transaction line.

1 The editor underlines the spot where the server found the error. Beside the line numbers, a ✓ marks each statement that ran and a ✕ the one that failed.
2 The Messages tab.
3 A statement that succeeded: a green check, Statement 1 and a link to its line (line 1, or lines 3–9 for a longer statement), then its command tag and how long it took (SELECT 1 · 2 ms). Click the line link to put the cursor at the start of the statement in the editor.
4 A statement that failed: a red cross and the server’s error, with its severity: ERROR: relation "nowhere_orders" does not exist.
5 Under the error: its SQLSTATE code (42P01), a link to the exact line and column in the editor (when the server says where), and the time. When the server sends them, DETAIL:, HINT: and CONTEXT: lines follow.
6 Fix with the Assistant selects the failed statement in the editor and asks the Assistant to correct it. It shows only while the Assistant is turned on and the run has ended; see SQL help in the editor.
7 The transaction line: a coloured dot and the state of this tab’s session, then whether auto-commit is on.

More about the entries:

A script stops at the first statement that fails. The statements after it do not run and are not listed.
A statement still running shows a spinner and running….
Notices and warnings, for example from RAISE NOTICE in a DO block or a function, appear in the list where they arrived, with an ⓘ icon, their severity (NOTICE:, WARNING:), and their DETAIL: and HINT: lines in grey.
After Commit or Rollback, from the toolbar or the Query menu, an entry Transaction says COMMIT · 3 ms or ROLLBACK · 2 ms, and Messages comes to the front.
When the script could not start at all, one red line says why.
Before anything has run, the tab shows the same “No result set” line as the grid. A run with nothing to report leaves “No messages.”

The transaction line reads, for example, Transaction: idle · auto-commit on. Its states are idle, active (running), in transaction (manual commit, with changes not committed yet), failed, roll back to continue (a statement failed inside a transaction) and disconnected (pgjumbo cannot tell the connection’s state). The line shows only while the tab is connected. What to do in each state is on Transactions and sessions.

Follow a foreign key

When a result holds every column of a foreign key, read straight from the table that has the key, the grid marks those columns with an FK tag. From any row you can open the row that the key refers to.

Right-click a cell in a column with an FK tag.
Choose Follow to and the table’s name, for example Follow to public.customers. A column in several foreign keys has one item for each.

A new customers · data tab, opened beside Query 1 · shop and in front, with the filter id = '2' in its WHERE field.

1 A new data tab opens on the referenced table, for example customers · data, on a connection of its own. Each Follow to opens a new tab.
2 Its filter holds the key of the row you started from, for example id = '2' (for a key of several columns, one condition per column joined with AND), so the tab shows that row. pgjumbo writes the filter in its engine from the values it kept, with the column names as the server quotes them; nothing you typed goes into it.

The data tab’s controls (filter, sort, row limit) are on View data. If the key is NULL in that row, nothing opens and the result bar says, for example, “This row’s customer_id is NULL: it references no row of public.customers.”

Following works from query results and from data tabs, on rows the result kept (not on rows you added). There is no FK tag when a column of the key is computed (an expression), comes through a view, or is missing from the result.

Rows saved since they were read

When you change rows in a query tab’s result and save them (see Edit data), pgjumbo does not run your query again by itself: it never re-runs anything in a Query Tool tab without you. The result keeps showing the rows as they were read, and says so.

The orders result after a change was saved: the bar says Saved: 1 updated, a banner says the rows are as they were read, before the changes were saved, with a Run again button, and the first total still shows 19.50.

1 For a few seconds, the result bar says what was saved, for example Saved: 1 updated. In manual-commit mode it adds “in the open transaction. Commit to keep it.”
2 The banner says “These rows are as they were read, before the changes were saved.” Run again runs the statement that returned this result once more, as it was when it ran, and shows the rows as they are now.
3 The grid still shows the old value (here 19.50, saved as 21.50).

Until you run it again, the result takes no more changes: the Editable tag and Add row are gone, and trying to edit a value says “These rows were saved since they were read. Run the query again to change them.”