Keybindings

Keys resolve from the current context outwards to root; the first binding found wins. Dialogs (overlay.*) sit directly under root, so only root keys pass through them. The cell viewer is not modal: it sits under workspace, so the workspace keys (run, …) keep working.

• [text] text input: letters, digits, symbols and Space are typed. No leader, no Hangul mapping.
• [editor] the query editor: its keys may hide keys of the contexts around it, except protected keys.
• grid.matches the result grid while a search is on: its keys (n, N, Esc) hide the grid’s until the search ends.
• Hangul: outside text input a Korean 2-set jamo or syllable counts as the QWERTY key(s) at its place (U+3153 = j, U+D558 = g k); the status bar then shows the Korean input-source mark. The character vim’s f t F T r wait for is taken as typed.
• R: repeats while the key is held (terminal auto-repeat).
• Key guide: after Space a which-key popup lists the keys that may follow (after 300 ms; Backspace goes up a level, Esc closes). Space ? or F1 open the keyboard help, the same way everywhere (? alone is left to the backward search of the editor and of the result grid). The help is one list: the sections of the current context first and open, every other context closed below (Enter/l/h or a click opens and closes a section); / searches all of them. The status bar shows the most relevant keys of the current context.
• Commands: : (outside text input) or Ctrl+K (everywhere) opens the command line: a popup near the top of the screen, or the last line with [commands] position = "bottom" (the settings screen, :set commands.position=bottom). It runs the commands listed at the end (:conn <profile>, :set <setting>=<value>, …) and finds every action by name; see the tables at the end.
• Vim: the editor has vim keys. i starts typing and Esc stops (the hint line says so). Implemented, all with counts: the motions h j k l w b e W B E ge gE 0 ^ $ gg G, f F t T ; , (the character is taken as typed, Hangul included), % (the matching bracket of ( ) [ ] { }, brackets in strings and comments left out; 50% goes to the middle line), { }, H M L, the arrows, Home and End; the operators d c y, gu gU g~ (case) and > < (indent by 4 columns, written with spaces as Tab types them) with any motion or text object, doubled for whole lines (dd cc yy guu gUU g~~ >> <<), counts before and after (3dd, d2w, 2d3w); the text objects iw aw iW aW, i( a( (ib ab), i[ a[, i{ a{ (iB aB), i< a<, i" a" i' a', i` a` and ip ap; x X s S D C Y p P r J gJ ~ u Ctrl+R; . (the last change again, what was typed in Insert mode included; 3. with a new count, except for a Visual mode operator, which keeps its own as in Vim); i a I A o O (a count types the text that many times); scrolling with Ctrl+D Ctrl+U Ctrl+F Ctrl+B zz zt zb; search with / and ? (a prompt on the editor’s last line: the cursor shows the match while the pattern is typed, Enter searches, Esc or any key of the app goes back, Ctrl+W deletes a word; an empty pattern takes the last one), n N, * # (the word under the cursor, as a whole word) and g* g# (also inside longer words), with counts and after an operator (d/from Enter, yn: up to the match, without it; a match at the end of a line stops on its last character, as in Vim); the matches on screen stay highlighted until :nohlsearch (:noh) and the next search shows them again. Search patterns are Rust regular expressions (https://docs.rs/regex/latest/regex/#syntax), not Vim’s: case-sensitive ((?i) at the start ignores case), \b for a word boundary (Vim’s \< \>), . * + ? ( ) | without a backslash; a match lies within one line, and search offsets (/foo/e) are not supported; marks: m{a-z} sets one at the cursor, '{a-z} goes to its line (the first non-blank) and `{a-z} to its place, also after an operator (d'a takes whole lines, y`a the characters up to it); '' and `` go back to where the last jump left from (G, gg, %, {, }, H, M, L, a search, a mark; m' sets it), '< '> (`< `>) to the ends of the last Visual selection and '. to the last change; marks move with their lines as lines are added or deleted above them and go with a deleted line, an undo puts them back, and 'A-'Z, '0-'9, '[ '] '^ are not kept (they say so); gc comments lines out with -- or back in, as Neovim’s built-in commenting does: gcc (with a count), gc with a motion or text object and gc in Visual mode take whole lines; when every line that is not blank starts with -- they lose it, otherwise each gets -- after the smallest indent (a blank line --), and . repeats it (the action editor.comment_toggle, Space e c, is the same as gcc, or gc in Visual mode); editor commands on the : line (see the end); & runs the last :s again on the cursor’s line with its flags (as Neovim’s &, Vim’s :&&) and g& on every line with the last search pattern; Visual mode by character (v) and by line (V) with the motions and text objects, y d x c, Y D X C S (whole lines), r J gJ u U ~ > <, o (the other end) and p P (a register in place of the selection; P keeps the replaced text out of the registers); Visual mode by block (Ctrl+V; v, V and Ctrl+V switch between the three, the same key again leaves): screen columns, a wide character or a tab partly inside handled as Vim does, $ to the end of every line, o and O (the other corners), y Y d x X D (D to the ends of the lines), c s C, I and A (what Insert mode types goes on every line of the block when it ends; A fills short lines with blanks first, $A appends at each line’s end; a count types it that many times), r (r Enter breaks the lines), ~ u U gu gU g~, > < with a count, J gJ, S R (whole lines) and p P (a block register as a block, lines below or above, text of one line on every line of the block); . repeats a block operator on a block of the same size from the cursor (after p only the delete); a paste from the terminal replaces the block; in Insert mode Ctrl+W (the word before the cursor), Ctrl+U (the line before the cursor), Ctrl+R {register} (its text), Enter keeping the indent, Tab (4 spaces) and Backspace, which deletes the spaces before the cursor back to the tab stop (every 4 columns) at once when there is nothing else between, as Vim with softtabstop=4 does then (with anything else between it deletes one character; [editor] soft_tab_backspace = "off" always one); with [editor] auto_pairs = "on" (off by default, as Vim types) ( [ { ' " `` `` also put their closing character after the cursor, typing it there steps over it and Backspace deletes the empty pair (only pairs it put in; never inside strings, quoted names, comments or dollar bodies, before a word, or for a paste; . repeats what it did). One command is one undo step. Registers as in Vim: "x before a command in Normal and Visual mode ("ayy, 2"ap), the unnamed one, "a-"z ("A-"Z append), "0 (the last yank), "1-"9 (the last deletes of lines; . after "1p puts "2), "- (small deletes), "_ (nothing kept), ". (the text last typed in Insert mode), "/ (the last search pattern) and "+ "* (the system clipboard); ": "% "# are not kept (a put from them says the register is empty). As in Vim with clipboard=unnamedplus, a yank, delete or change without a register also goes to the system clipboard, through the clipboard setting’s way ([editor] clipboard = "off" keeps them in the editor); "a and "_ never do. "+p reads the system clipboard only when typed, and not over OSC 52 (the terminal’s own paste works there). A paste from the terminal goes in at the cursor in every mode (over the selection in Visual mode). Unlike Vim, a tab is 4 columns wide and a completion taken from the popup is not part of what . repeats. The other reserved vim keys do nothing yet.
• Your editor and suspending: Ctrl+G opens the tab’s query in your own editor ($VISUAL, else $EDITOR, else vi; split into words like a shell does, code -w included, but no shell runs it) on a private file in the state directory, removed afterwards. What it saves replaces the text as one undo step; quitting without saving changes nothing, and an editor that fails (Vim’s :cq) leaves the text as it was. A table tab’s query goes as a copy, and an edited copy opens in a new console. Ctrl+Z (and :suspend, :sus, :stop) stops datarig as Ctrl+Z stops Vim; the shell’s fg brings it back (Unix only; on Windows :suspend says it is not supported). Ctrl+C stays the query cancel. Meanwhile a running query goes on on the server: with the editor open its results arrive and wait; while suspended the whole program is stopped, so they are read after fg.
• Reserved keys belong to a widget (vim, a dialog) or to an action that is not implemented yet. They cannot be remapped.

Protected keys (no inner context may hide them): Ctrl+Q Ctrl+K Ctrl+E Ctrl+Enter Ctrl+S Ctrl+T Ctrl+O Ctrl+G F1 F6 Shift+F6 Ctrl+PageDown Ctrl+PageUp Space.

Remap in config.toml with [keymap.<context>] tables: "<keys>" = "<action id>", or "none" to unbind. Key notation: ctrl+e, shift+tab, f4, pagedown, space c n (a space separates the keys of a sequence), G = shift+g. Invalid entries are skipped and reported at startup.

[keymap.explorer]
"x" = "explorer.refresh"
"q" = "none"

root

Works everywhere, also while a dialog is open.

workspace

The workspace without a dialog, including text input in the editor. Inside root.

nav

Every pane that is not text input (explorer, results, vim Normal/Visual). Inside workspace.

Leader groups (the which-key popup lists what follows):

explorer

The explorer: folders, connection profiles, their databases and schema trees. Inside nav.

explorer.filter [text]

The / filter of the explorer: profiles (name, host, database), folders, tunnels, environments, Startup SQL (name, statements) and saved queries, and under connected profiles the databases, schemas, tables, views and structure items already loaded. Inside workspace.

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

grid

The result grid. The wheel scrolls the rows; a sideways wheel (a trackpad) or Shift+wheel scrolls the view sideways, four characters a step, the columns at its edges partly shown, until a key or a click moves the cell (h/l bring its column into view, moving the view as little as it takes). / searches the fetched rows forward, ? backward (a Rust regular expression, case sensitive unless it starts with (?i); NULL never matches). Inside nav.

grid.matches

The result grid while a search is on (after / or ?): n goes to the next matching cell in the search’s direction, N the other way, from page to page through every fetched row (in the spill file too), around the ends with a warning; Esc ends the search, and n shows the next page again. Inside grid.

grid.search [text]

The search prompt of / and ? on the line under the grid: the cursor goes to the first matching cell while the pattern is typed, Enter searches (an empty pattern: the last one), Esc goes back to where the cursor was, Ctrl+W deletes the word before the cursor. The full values are searched as fetched (not the shown cut), cell by cell, row by row. Inside workspace.

Reserved (grid search): Esc Enter Ctrl+W

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

grid.edit [text]

The cell editor (e in the grid) over the cell: one line, the cell’s pending value or its value as read. Enter keeps the text (an empty text is the empty string, never NULL), Esc cancels, Ctrl+N sets NULL, Ctrl+D the column’s default. With cells of one column selected, each takes the value, as one change (u undoes it). Ctrl+L takes the text typed so far to the editor of several lines. A value of several lines, and a JSON column’s, opens that editor instead; an enum or boolean column lists its values. Inside workspace.

Reserved (cell editor): Esc Enter Ctrl+N Ctrl+D Ctrl+L

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

inspector

The result inspector next to the grid, after a click on it: j/k move between the columns and the grid’s cell follows (on the Row tab, a click on a column moves it there too), Enter shows the value whole. Inside nav.

plan

The Plan tab of the results pane (a plan result: PostgreSQL’s JSON, MySQL’s tree): j/k select a node, h/l close and open its children, Enter shows its detail, v/V and the digits pick a view, y copies the plan as the raw view shows it, Y as the server sent it. Inside nav.

chart

The Chart tab of the results pane (c in the grid, or its tab in the strip; it is drawn only once viewed): the fetched rows of the shown result as bars or lines, nothing run again. The arrows and h/j/k/l move the cursor along the bars or points (the other direction picks a series), Enter shows the point’s row in the grid, v/V and the digits pick the kind, x/s/b choose the X column, the values and a column that splits them into series, S a logarithmic scale, y/Y copy the numbers as TSV or the drawing as text; a click picks a point, a kind or a column choice. Inside nav.

changes

The Changes tab of the results pane (:changes, Space d p, or its tab in the strip while the shown result has pending changes): one line per changed cell, every reason they can’t be applied first, or (s) the statements that apply them. j/k select a line (scroll the statements), Ctrl+D/Ctrl+U half a page, g g/G the first and the last, Enter shows the line’s row and column in the grid, s switches between the list and the statements for this run, c copies the statements as they would be sent. The Space d keys work here as in the grid. Inside nav.

monitor

The Monitor tab of a profile (monitor.open: M on a connection in the explorer, :monitor, the connection’s menu): what its server says about its load and its sessions, read by a connection of the tab’s own, only while the tab is shown. 1 the Overview (the server, its load as charts, the longest running sessions), 2 the Sessions, 3 the Locks (who waits for whom, root blockers first; b goes to the root blocker of the selected wait), 4 the Replication (what the server takes changes from, the servers that take changes from it, slots), v the next view; i shows the server in full over any view (i or Esc closes it); j/k select a session (a line in the Locks view; they scroll the Replication view, the server pane and the details), s sorts by the next column (S the other way; a click on a column’s name sorts by it), / filters, a shows idle sessions too, Enter shows the session in full, o opens its statement in a new console (never run), y copies it (both the server’s text), f shows statements laid out for reading or as the server sent them; c cancels its statement and X ends it (asked first: y sends, a dialog’s Enter keeps it; refused on a read-only environment and on the monitor’s own connection; on PostgreSQL the question names your own tab), L shows or hides the list of what was sent and what became of it; p pauses, r reads at once, +/- read more or less often. Inside nav.

monitor.filter [text]

The filter of the Monitor tab’s sessions (/): the sessions whose user, database, application, client, state or statement contain the text, as it is typed; Enter keeps it, Esc too (Esc again in the list clears it). Inside workspace.

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

welcome

The welcome panel shown while there is no connection profile. Inside nav.

editor.vim.normal [editor]

Query editor, vim Normal mode (i starts typing). Inside nav.

Reserved (vim): h j k l w W b B e E g e g E 0 ^ $ g g G f F t T ; , % { } ( ) [ ] H M L Left Right Up Down Home End d c y > < = g ~ g u g U 1 2 3 4 5 6 7 8 9 . " x X D C Y s S r R p P u Ctrl+R J g J ~ i a I A o O v V Ctrl+V Esc / ? n N * # g * g # m ' ` g c & g & Ctrl+D Ctrl+U Ctrl+F Ctrl+B z z z t z b z Enter q

editor.vim.visual [editor]

Query editor, vim Visual mode (v by character, V by line, Ctrl+V by block). Inside nav.

Reserved (vim): h j k l w W b B e E g e g E 0 ^ $ g g G f F t T ; , % { } ( ) [ ] H M L Left Right Up Down Home End d c y > < = g ~ g u g U 1 2 3 4 5 6 7 8 9 . " x X D C Y s S r R p P u Ctrl+R J g J ~ i a I A o O v V Ctrl+V Esc / ? n N * # g * g # m ' ` g c & g & Ctrl+D Ctrl+U Ctrl+F Ctrl+B z z z t z b z Enter q

editor.vim.insert [editor] [text]

Query editor, vim Insert mode: typing (Esc goes back to Normal). Inside workspace.

Reserved (vim Insert): Esc Enter Tab Backspace Delete Left Right Up Down Home End Ctrl+W Ctrl+U Ctrl+R Ctrl+P

editor.vim.search [editor] [text]

The search prompt of / and ? on the editor’s last line: Enter searches, Esc goes back to where the cursor was. Inside workspace.

Reserved (vim search): Esc Enter Ctrl+W

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

editor.ddl [editor]

A DDL tab in vim Normal mode: its text is read-only (moving, selecting, searching and yanking work; edits are refused); r reads it again, o opens it in a new console. Inside editor.vim.normal.

overlay.commands [text]

The : command line: commands with arguments, and a search over every action; a click runs an entry, the wheel moves the selection. Inside root.

Reserved (command line): Esc Enter Up Down Ctrl+P Ctrl+N Tab Shift+Tab

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

overlay.quick_connect [text]

Quick connect: a fuzzy list of the connection profiles; a click picks a row (on ▸ it lists the databases), the wheel selects, the pointer only highlights. Inside root.

Reserved (quick connect): Esc Enter Up Down Ctrl+P Ctrl+N

Reserved (quick connect: databases and schemas): Right Left

Reserved (text input): Backspace Delete Home End Ctrl+U Ctrl+A

overlay.tab_list [text]

The tab list (Space t t, :tabs, :ls, :buffers): the open tabs, the most recently active first, then the tabs closed in this run. Typing filters by name, connection, database, schema, kind or number; the arrows, Ctrl+N/Ctrl+P and Tab move, Enter goes to the tab (brings a closed one back), Ctrl+D closes the selected tab (asking as Ctrl+W does), Esc closes the list (Backspace on an empty filter does not). A click picks an entry, the wheel selects, the pointer only highlights. Inside root.

Reserved (tab list): Down Up Ctrl+N Ctrl+P Tab Shift+Tab Enter Esc Ctrl+D

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

overlay.profile_form [text]

Connection profile form (also the SSH tunnel, environment, default rules and Startup SQL forms). Esc or Cancel closes it; with changes not saved it asks first (Enter keeps editing, y discards), and so does quitting the app while it is open (y discards and the quit goes on). With the mouse: a click focuses a field (in a text, the cursor goes there), picks a value, opens the list of a value ▾, steps a ‹ value › (its arrows; the value opens a list), switches the section or presses a button. A Startup SQL list (the preset form’s statements, a profile’s own startup SQL) has one statement per row: Enter after a filled row adds one below, on an empty row removes it and moves on; ↑/↓ go from row to row and leave the list at its first and last; Tab leaves it; Backspace on an empty row and Ctrl+D remove a row; a paste of several statements makes a row of each. With the mouse: a click on a row puts the cursor there, × removes it, “+ Add statement” adds one at the end (both on the release), the wheel scrolls a list longer than its room. Inside root.

Reserved (profile form): Tab Shift+Tab Down Up Enter Esc Ctrl+S Ctrl+T Ctrl+N Ctrl+P

Reserved (profile form: Startup SQL list): Ctrl+D

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

overlay.settings

The settings screen: one list by category, each setting with its description; a click selects a row and its ‹/› change the value, the wheel selects, the pointer only highlights. Inside root.

Reserved (settings screen; c on the theme row: copy the theme to a new theme file): j k Down Up h l Left Right Enter Space Esc q c

overlay.export [text]

The export dialog (results.export, :export alone): the rows (every row, the rows fetched, the selection while there is one), the format, CSV’s options and the file. Tab/Shift+Tab and the arrows move between the fields, Enter or Space on a value lists what it can be (←/→ step through them), Space, Enter or ←/→ tick the header line, Enter in a text field or Enter/Space on Export exports (on Cancel: closes), Esc cancels. Under the rows it says how they will be read, under the format what it cannot do here (a format that comes later, an INSERT or UPDATE the result’s keys do not allow, struck through in the list). In the file’s field Tab first completes a name (again: lists the names, then puts each in turn); [Browse…] picks where the file goes in a tree. A click focuses a field, puts the cursor in a text, opens a value’s list or ticks the checkbox; Export and Cancel act on the release. Inside root.

Reserved (export dialog): Tab Shift+Tab Down Up Enter Esc

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

overlay.chooser

A list to pick from: a profile’s colour, icon or folder, a chart’s columns (the values’ list stays open: Enter adds or removes one); a click picks a row, the wheel selects, the pointer only highlights. Inside root.

Reserved (chooser): j k Down Up Enter / Esc q

overlay.chooser.filter [text]

The / filter of a list to pick from. Inside root.

Reserved (chooser filter): Esc Enter Down Up

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

overlay.picker [text]

A list to pick from with a typed filter: a field of the profile form (Enter on it: its driver, SSL mode, password storage, bastion login and its secret’s storage, SSH tunnel or environment), each value with what it means; the tunnel’s and the environment’s end with the entry that makes a new one (“New SSH tunnel…”, “New environment…”), and a value that cannot be picked (a driver the app has none for, the keychain while it does not work) is struck through. Typing filters it as the action menu is filtered; the arrows, Ctrl+N/Ctrl+P and Tab move, Enter picks, Esc closes it and changes nothing. A click picks a row, the wheel selects, the pointer only highlights. Inside root.

Reserved (list picker): Down Up Ctrl+N Ctrl+P Tab Shift+Tab Enter Esc

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

overlay.name_input [text]

A name to type: a new or renamed folder; OK and Cancel take a click. Inside root.

Reserved (name input): Enter Esc

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

overlay.script_tree

The folder tree of the saved queries (save as, open), of the file system (the SSH key file, where an export goes) or of folders only (the folder chooser): the tree has the keyboard. j/k and the arrows move; l/Right opens the selected folder (one of the file system is read first); h/Left closes an open folder, else selects the folder the row is in. In a file system tree, h/Left on ../ or on the folder shown (and l/Right on ../) goes up to the parent of the folder shown. Enter: save as saves into the selected folder, the folder chooser picks it; the other trees open or close a folder, go up on ../, and pick a file (the saved query to open, the key file, the file the export replaces). In the export tree the top row (Enter) and Ctrl+S (any folder) save there, and . shows hidden names; n makes a folder (save as, folder chooser, export). Tab (and / in the folder chooser and the export tree) gives the keyboard to the name or filter field; Esc closes (q too in the folder chooser and the export tree). The mouse: a click selects a row, one on a folder’s arrow opens or closes it; a second click on the selected row does what Enter does there, except in save as, where it only opens or closes a folder, and in the key file tree, where a path typed in the field is taken only by Enter; the wheel scrolls. Inside root.

Reserved (tree): j k h l Up Down Left Right Enter n / q Tab Shift+Tab Esc . Ctrl+S

overlay.script_tree.name [text]

The folder tree of the saved queries: its name field (save as) or filter (open); of the folder chooser: its filter; of the file system: its filter, where a text with / or a leading ~ is a path Enter goes to. While the field is empty, Left/Right on a folder or file act as in the tree: they close or open the folder, Left selects the folder the row is in. Inside root.

Reserved (tree: name or filter): Up Down Enter Tab Shift+Tab Esc Ctrl+S

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

overlay.context_menu [text]

The action menu: a right click (an explorer node, the grid, a tab, the editor) opens it at the pointer; Space Space, Shift+F10 or the Menu key next to the selection, Space t m under the active tab. The selection’s actions come first, then the pane’s, each with its key in that pane. Typing filters it (when nothing in it matches, every action is searched); the arrows, Ctrl+N/Ctrl+P and Tab move, Enter runs, Esc closes (Backspace on an empty filter does not); a shown key that is not a character (Ctrl+…, F…) runs its item; the pointer selects the item under it. Inside root.

Reserved (action menu): Down Up Ctrl+N Ctrl+P Tab Shift+Tab Enter Esc

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

overlay.password [text]

Password prompt; a click on the field, the checkbox, OK or Cancel. Inside root.

Reserved (password prompt): Esc Enter Tab Shift+Tab

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

overlay.confirm

Yes/no confirmation: y does it; Enter keeps what the answer would lose (quit, delete, disconnect, close, switch, replace, discard); for a copy it says yes. A button acts on its release (pressed and released on it, not right after the question appeared) and does what its key does; the pointer only lights its background (Enter stays on the safe one). Inside root.

Reserved (confirmation (Enter keeps what would be lost)): y n Enter Esc

overlay.run_confirm

Before statements that may do harm run: each is listed; Cancel has the focus, y or Enter on Run runs them, as a click on Run does (the pointer does not move the focus). Inside root.

Reserved (run confirmation (Cancel has the focus)): y n Enter Esc Tab Shift+Tab Left Right h l

overlay.tx_summary

What the open transaction did (its statements that may have written, rows, time; how long it has been open and idle): c commits, r rolls back, Esc closes; a click on a button does what its key does. Inside root.

Reserved (transaction summary): c r Esc q Enter j k Down Up

overlay.edit_preview

The statements an Apply is about to send, when they must be seen first (a choice among identical rows, an Apply whose result is not known, an environment that confirms writes); Cancel has the focus: y applies, c copies the statements, 1/a answer which of several identical rows a change is for, j/k scroll, Esc or Enter closes; a click on a button does what its key does. While the changes are applied the dialog says so, and the query’s cancel key cancels; it closes once they are applied, else it says why nothing was. After an Apply whose result is not known, the first y warns and the second applies again. Inside root.

Reserved (pending changes preview): y c 1 a Esc q Enter j k Down Up

overlay.session_view

What a profile’s query sessions start with (:session or :startup; in the profile form Ctrl+E, for its unsaved values), in the order they are applied, each with where it comes from: the app’s limits, the Startup SQL’s statements, the profile’s own; behind a pooler in transaction mode, how each PostgreSQL statement goes there. j/k scroll, Esc closes; a click on Close closes too. Inside root.

Reserved (session settings): Esc q Enter j k Down Up

overlay.whats_new

The release notes this build carries (:whatsnew; once by itself after an update, unless [updates] whats_new = "off"), newest version first: j/k scroll a row, Ctrl+D/Ctrl+U half a page, PageDown/Space/PageUp a page, g/G to the top or the end, ]/[ to the next or previous version, Esc, q or Enter closes; the wheel scrolls and a click on Close closes. Inside root.

Reserved (what’s new): Esc q Enter j k Down Up Ctrl+D Ctrl+U PageDown PageUp Space g G Home End ] [

overlay.update_notice

A newer release is out (at launch, from the last check; or :update): the version, the command that updates this install, and how to turn the checks off. Close has the focus: Enter presses the focused button, Esc or q closes (told again after a week), s skips this version, o turns the checks off ([updates] check = "off"); Tab, the arrows and h/l move the focus; a click on a button does what its key does. Inside root.

Reserved (the update notice (Close has the focus)): Esc q Enter s o Tab Shift+Tab Left Right h l

overlay.icons_ask

Whether the terminal shows the Nerd Font icons (asked once, with a preview); No has the focus; a click on Yes or No answers. Inside root.

Reserved (the icons question (No has the focus)): y n Enter Esc Tab Shift+Tab Left Right h l

overlay.busy

A notice that waits for background work (the launch-time move of passwords to the keychain); Ctrl+C quits there too. Inside root.

overlay.cell_viewer

Cell value viewer. Inside workspace.

Reserved (cell viewer): j k Down Up PageDown PageUp Space g g G Esc q

overlay.cell_editor [text]

The editor of a cell’s value of several lines (a value with line breaks, a JSON column’s, or Ctrl+L in the cell editor), in a box over the screen: the query editor’s vim modes, its / search, :s and registers (a yank goes to the system clipboard as [editor] clipboard says). In Normal mode Enter or :w (:wq, :x) keeps the text, as Enter in the cell editor does (line breaks as typed); Esc or :q (:q!) cancels. With cells of one column selected, each takes the value, as one change. A click outside the box or the wheel closes it, changing nothing. Inside root.

Reserved (cell editor of several lines): Esc Enter Tab Backspace Delete Left Right Up Down Home End Ctrl+W Ctrl+U Ctrl+R Ctrl+P Ctrl+V Ctrl+D Ctrl+F Ctrl+B

overlay.completion [text]

Completion popup in the editor (keys it does not use go to the editor). Inside root.

Reserved (completion popup): Up Down Ctrl+P Ctrl+N Tab Enter Esc

overlay.which_key

Which-key popup of an unfinished leader sequence (other keys continue the sequence). Inside root.

Reserved (which-key popup): Esc Backspace

overlay.help

Keyboard help: one list of every context; the sections of the context it was opened from come first, open; the pointer selects the row under it. Inside root.

Reserved (keyboard help): j k Down Up PageDown PageUp Enter l Right h Left / Esc q

overlay.help.filter [text]

The / filter of the keyboard help. Inside root.

Reserved (keyboard help filter): Esc Enter Down Up

Reserved (text input): Backspace Delete Left Right Home End Ctrl+U Ctrl+A

status.ask

The status bar’s one-line question before an Apply of a result’s changes: y applies them; any other key, a click or a paste cancels, and does nothing else. Inside root.

Reserved (the status bar’s question: y does it (c or 1: text with commas read as CSV or one column), any other key cancels): y c 1

Command line only

Actions without a default key (the command line finds them by name).