Autocomplete

Schema-aware SQL autocomplete for keywords, tables, columns, and functions

Autocomplete suggests keywords, tables, columns, and functions based on where your cursor is and what tables are in scope.

Context-aware autocomplete

Suggestions appear as you type, from the first character, and after . or a space, with a 50ms debounce. There is no minimum prefix. With nothing typed yet, the popup stays hidden in clauses where listing everything is noise (for example after a comma in a SELECT list); it still opens automatically after FROM, JOIN, ON, and other clauses where browsing helps.

Key	Action
Ctrl+Space	Open the popup anywhere, even with an empty prefix
Up Down	Move through suggestions
Return / Tab	Accept the selected suggestion
Escape	Dismiss and keep typing

Completion Types

SQL Keywords

SEL|  -- SELECT
FROM users WH|  -- WHERE
SELECT * FROM users WHERE name LIKE '%test%' ORD|  -- ORDER BY

Table Names

Tables appear after FROM, JOIN, INSERT INTO, and similar keywords:

SELECT * FROM |  -- All tables
SELECT * FROM us|  -- Tables starting with "us": users, user_roles
SELECT * FROM a JOIN b ON a.id = b.id JOIN |  -- All tables, even after an ON condition

The clause is detected at the cursor, so a second or third JOIN suggests tables even when an ON condition comes before it. In a table position, tables lead the list ahead of keywords.

Column Names

Columns are suggested in SELECT, WHERE, ORDER BY, GROUP BY, and other column contexts.

If a FROM clause exists anywhere in the statement (even after the cursor), columns come from those tables. If no FROM clause exists yet, columns from all cached tables appear as fallback; ambiguous names are qualified: users.id, orders.id.

SELECT na|  -- Columns matching "na" from all cached tables
SELECT | FROM users  -- Columns from users
SELECT u.| FROM users u  -- Columns from users via alias
SELECT * FROM users WHERE |  -- Columns from users

Alias Resolution

Type an alias followed by . to see that table’s columns:

SELECT
    u.|  -- id, name, email, created_at (from users)
FROM users u
JOIN orders o ON u.id = o.|  -- id, user_id, total (from orders)

Derived Tables and CTEs

An alias for a subquery (derived table) or a WITH table completes the columns that subquery’s SELECT list produces, including AS renames:

SELECT ahs.|  -- country, avg_score
FROM happiness_scores hs
LEFT JOIN (
    SELECT country, AVG(score) AS avg_score
    FROM happiness_scores
    GROUP BY country
) ahs ON hs.country = ahs.country

WITH totals AS (
    SELECT region, SUM(amount) AS total FROM sales GROUP BY region
)
SELECT t.| FROM totals t  -- region, total

Explicit (AS name), bare (country), and qualified (t.col) columns resolve. A SELECT * subquery and unaliased expressions like AVG(score) have no name to suggest, so they are skipped.

Functions

SQL functions appear in SELECT, WHERE, and expression contexts:

SELECT |  -- COUNT, SUM, AVG, MAX, MIN, etc.
SELECT COUNT(|  -- Columns and *
WHERE date_column > |  -- NOW(), CURRENT_DATE, etc.

Functions from the connection’s SQL dialect (e.g. CONVERT_TIMEZONE on Snowflake, SAFE_CAST on BigQuery) appear alongside the common SQL functions.

Operators

Operators the connection’s dialect declares appear in WHERE, ON, HAVING, and AND contexts, each with what it does and the types it works on.

On PostgreSQL that covers the JSON operators, array and range containment, regex matching, full-text search, and the network operators:

WHERE data -|            -- ->  (field as json), ->>  (field as text)
WHERE payload @|         -- @>  contains, @?  JSON path returns any item
WHERE tags &|            -- &&  arrays overlap
WHERE email ~|           -- ~   POSIX regex, ~* case insensitive

The list distinguishes operators that only work on jsonb from the ones json accepts too, so @> is not offered as if it worked on a json column.

Casts

Typing :: offers the dialect’s type names, in the spelling you write rather than the internal catalog name:

SELECT id::|             -- integer, bigint, text, timestamptz, jsonb, uuid, ...
SELECT payload::js|      -- json, jsonb, jsonpath

MongoDB

MongoDB connections use MQL instead of SQL, and the popup follows the shape of the query rather than SQL clauses. What you get depends on exactly where the cursor is:

db.|                                  // collections, plus getCollectionNames(), createCollection(), ...
db.users.|                            // find(), aggregate(), updateOne(), insertMany(), ...
db.users.find({ |                     // field names, then $eq, $gt, $in, $exists, $regex, ...
db.users.find({}, { |                 // field names, then $slice, $elemMatch, $meta
db.users.updateOne({}, { |            // $set, $unset, $inc, $push, $addToSet, ...
db.users.updateOne({}, [{ |           // the six stages an update pipeline allows
db.orders.aggregate([{ |              // $match, $group, $lookup, $unwind, $facet, ...
db.orders.aggregate([{ $group: { |    // $sum, $avg, $first, $push, and the expression operators

The operator sets are kept apart on purpose. Offering $match inside a filter document, or $gte where a pipeline stage belongs, is worse than offering nothing. $set and $unset mean different things as an update operator and as a pipeline stage, and the popup describes whichever one applies at the cursor.

Field names come from a sample of the collection’s documents and include nested paths, so a document with address: { city, zip } suggests address, address.city and address.zip. Objects inside an array contribute paths too. Shallower fields sort first. Nothing in the query is executed to build the list.

The sample is cached per collection and cleared when you switch database or refresh the connection.

Completion is suppressed inside comments, and braces or brackets inside a string literal do not count as opening a document.

Favorite Keywords

Favorites you’ve assigned a keyword to (DB-stored or linked-file @keyword frontmatter) appear in the popup as a top-priority match. Type the keyword, accept the suggestion, and the favorite’s full SQL replaces the keyword inline. A ;; in the favorite’s SQL sets where the cursor lands after expansion. See Favorites for how to assign keywords and place the marker.

Schema Names

For databases with multiple schemas (PostgreSQL):

SELECT * FROM |  -- public, schema1, schema2
SELECT * FROM public.|  -- Tables in public schema

Schema-qualified names like public.users resolve in FROM, JOIN, UPDATE, INSERT INTO, and CREATE INDEX.

For databases organized as database, schema, table (Snowflake, BigQuery), every segment completes. Tables of schemas you haven’t opened in the sidebar are fetched on demand:

SELECT * FROM ANALYTICS_|                      -- databases
SELECT * FROM ANALYTICS_PROD.|                 -- schemas
SELECT * FROM ANALYTICS_PROD.DBT_MARTS.|       -- tables in that schema
SELECT * FROM ANALYTICS_PROD.DBT_MARTS.ORDERS o WHERE o.|  -- columns

Schema Cache

On connection, TablePro fetches table names and loads columns in the background. The column cache holds up to 50 tables with LRU eviction. There is no time-based expiry: cached columns stay until you switch databases or refresh the connection. A failed schema load waits 30 seconds before retrying, to avoid hammering the server.

After external schema changes (migrations, CLI work), press Cmd+R (Query > Refresh) to reload it. Right-clicking the sidebar’s Tables header and choosing Refresh does the same.

Performance

Works on files of any size, including multi-megabyte dumps. For files over 500 KB, only a ~10 KB window around the cursor is analyzed.