---
title: "SSMS IntelliSense Not Working: Why SQL Autocomplete Shows Nothing"
description: "SSMS IntelliSense fixes for stale caches, SQLCMD mode and disabled suggestions, plus documented checks for VS Code, MySQL Workbench and DBeaver."
url: "https://jamsql.com/blog/2026-10-17-ssms-intellisense-autocomplete-not-working/"
html_url: "https://jamsql.com/blog/2026-10-17-ssms-intellisense-autocomplete-not-working/"
generated: "2026-10-25T01:35:22.693Z"
---

Published: 2026-10-17

# SSMS IntelliSense Not Working: Why SQL Autocomplete Shows Nothing

When SQL Server Management Studio stops suggesting tables and columns, Microsoft’s documentation points to a short list of causes: the query window’s object cache was read before the table existed (fix: **Edit → IntelliSense → Refresh Local Cache** or Ctrl+Shift+R), IntelliSense is switched off (Ctrl+B, Ctrl+I turns it back on), the window is in SQLCMD mode, an unfinished statement above the cursor keeps IntelliSense from parsing the code, or the script is larger than the *Maximum script size* option. This post goes through each cause with its fix, then the same checks for Azure Data Studio, the VS Code MSSQL extension, MySQL Workbench and DBeaver, from each vendor’s documentation as of October 17, 2026. The second half measures where autocomplete comes back empty in Jam SQL Studio: 51,010 completion requests from 209 installations over 10 days, by database engine and by where the cursor was.

## The short answer for SSMS

What you see

Cause

Fix

A table or column created after you connected is missing

The window’s object cache predates it

**Edit → IntelliSense → Refresh Local Cache**, Ctrl+Shift+R, or disconnect the window and reconnect

No suggestions in any query window

IntelliSense is turned off

Ctrl+B, Ctrl+I or **IntelliSense Enabled** on the SQL Editor toolbar; **Tools → Options → Text Editor → Transact-SQL → IntelliSense**

The list opens only when you press Ctrl+J

Automatic statement completion is turned off

**Tools → Options → Text Editor → Transact-SQL → General**, *Statement completion* check boxes; open a new query window

No suggestions in a window that runs `:setvar` or other SQLCMD commands

SQLCMD mode turns IntelliSense off

**Query → SQLCMD Mode** to turn it off; clear *By default, open new queries in SQLCMD Mode* under **Tools → Options → Query Execution → SQL Server → General**

Suggestions work above a certain line and not below it

An incomplete statement or other error above the cursor

Finish or comment out that code

No suggestions in one very large script

The script is larger than *Maximum script size*

Pick a larger size under **Tools → Options → Text Editor → Transact-SQL → IntelliSense**

Nothing inside quotes or after `--`

IntelliSense is not offered inside comments and string literals

None needed; this is by design

A table you know exists is never listed

Your login has no permission on it

Completion lists leave out objects you can’t access; ask for access or use a login that has it

Nothing at all on one particular server

SQL Server 2005 or earlier, or Azure Synapse Analytics

Not supported: IntelliSense needs SQL Server 2008 or later, and Azure Synapse Analytics doesn’t support it

Suggestions stopped in the middle of a session

The connection to the server was lost

Reconnect the window

The causes and fixes are from Microsoft’s [Identify issues with IntelliSense](https://learn.microsoft.com/en-us/ssms/scripting/troubleshooting-intellisense), [Configure IntelliSense](https://learn.microsoft.com/en-us/ssms/scripting/configure-intellisense-sql-server-management-studio), [SSMS Query Editor](https://learn.microsoft.com/en-us/ssms/f1-help/database-engine-query-editor-sql-server-management-studio), [keyboard shortcuts](https://learn.microsoft.com/en-us/ssms/sql-server-management-studio-keyboard-shortcuts), [SQLCMD scripts](https://learn.microsoft.com/en-us/ssms/scripting/sqlcmd-scripts-query-editor) and [Query Execution options](https://learn.microsoft.com/en-us/ssms/menu-help/options-query-execution) pages, read on October 17, 2026. We did not reproduce them in SSMS.

## The SSMS causes in more detail

### New objects: Refresh Local Cache

SSMS keeps a cache of the database’s objects for each query window. Microsoft’s troubleshooting page says IntelliSense “doesn’t cover database objects created by another connection after your editor window connected to the database”, so a table added by a migration, a deployment or a colleague, or from a second SSMS window, is missing from the list until you refresh. The page gives three ways to refresh: **Edit → IntelliSense → Refresh Local Cache**, Ctrl+Shift+R, or disconnecting the window from the server and connecting again.

### IntelliSense or automatic completion turned off

The **IntelliSense Enabled** button on the SQL Editor toolbar, also in the query window’s context menu, turns IntelliSense on and off; Ctrl+B, Ctrl+I does the same. It is on by default. Two settings pages control the rest:

-   **Tools → Options → Text Editor → Transact-SQL → General** (or *All Languages*): the *Statement completion* check boxes. With automatic completion off, IntelliSense still works when you ask for it: Ctrl+J lists members.
-   **Tools → Options → Text Editor → Transact-SQL → IntelliSense**: the IntelliSense options, the *Maximum script size* list and the casing of built-in function names.

Microsoft notes that some of these changes don’t take effect in an editor that is already open: open a new query window to see them.

### SQLCMD mode

SQLCMD mode lets a query window run `:setvar`, `:connect`, `!!` and the other SQLCMD commands the query editor supports. Microsoft’s SQLCMD page says that “when you enable SQLCMD mode, IntelliSense and the Transact-SQL debugger are turned off in the query editor.” It is off by default and is switched per window with the **SQLCMD Mode** toolbar button or **Query → SQLCMD Mode**. If every new window opens in SQLCMD mode, check *By default, open new queries in SQLCMD Mode* under **Tools → Options → Query Execution → SQL Server → General**; Microsoft’s page for that option lists “IntelliSense in the Database Engine Query Editor is turned off” as a limitation of the option.

### An error above the cursor

If a statement above the cursor is incomplete or has an error, “IntelliSense might be unable to parse the code elements, and therefore doesn’t work.” Microsoft’s suggestion is to comment out that code.

### Large scripts

The *Maximum script size* list sets the script size up to which IntelliSense works. The current Configure IntelliSense page does not explain the option further. Microsoft’s [SQL Server 2008 R2 description of it](https://learn.microsoft.com/en-us/previous-versions/sql/sql-server-2008-r2/bb964729\(v=sql.105\)) does: above the limit SSMS shows a warning and turns off every IntelliSense feature except color coding for that window, until enough text is deleted to bring the script under the limit again. That release offered 100 KB, 500 KB, 1 MB, 2 MB and Unlimited, with 1 MB as the default, and gave the reason for the limit: IntelliSense on large scripts can slow down slow computers. The current page states neither the sizes nor the default, so check what yours is set to before opening a large migration or deployment script.

### Other cases Microsoft lists

-   **Comments and string literals.** Nothing is offered inside a comment or inside quotes, for example in `WHERE FirstName LIKE 'Patri%'`.
-   **Objects you can’t access.** Completion lists leave out objects your login has no permission on. In a script written by someone else, references to objects they can access and you can’t are flagged as errors.
-   **Old or unsupported servers.** IntelliSense needs SQL Server 2008 or later, and Microsoft’s Configure IntelliSense page says Azure Synapse Analytics doesn’t support it.
-   **Some statements.** Microsoft’s [list of supported Transact-SQL syntax](https://learn.microsoft.com/en-us/ssms/scripting/transact-sql-syntax-supported-by-intellisense) says IntelliSense covers “only the most commonly used” statements. Its examples: no IntelliSense for a `SELECT` inside a `CREATE FUNCTION`, none for encrypted procedures and functions, and no columns from a `CREATE VIEW` until the view has been created.
-   **A lost connection.** Completion lists can stop working when the window loses its connection; reconnect it.

## Azure Data Studio and the VS Code MSSQL extension

Azure Data Studio was [retired on February 28, 2026](https://learn.microsoft.com/en-us/azure-data-studio/whats-happening-azure-data-studio) and no longer gets updates or security fixes. Its last version, 1.52.0, has a **Refresh IntelliSense Cache** command in the Command Palette ([`keyboardQueryActions.ts`](https://github.com/microsoft/azuredatastudio/blob/1.52.0/src/sql/workbench/contrib/query/browser/keyboardQueryActions.ts) at tag 1.52.0). In that release the results pane is shown or hidden with Win+Shift+R on Windows and Ctrl+Shift+R on macOS (the action is registered with `KeyMod.WinCtrl`), so the SSMS key is not a refresh there.

Microsoft recommends Visual Studio Code with the MSSQL extension instead. In version 1.46.0 of the extension (September 28, 2026), from its [`package.json`](https://github.com/microsoft/vscode-mssql/blob/mssql-v1.46.0/extensions/mssql/package.json):

-   **MS SQL: Refresh IntelliSense Cache** in the Command Palette refreshes the cache; the extension gives it no default key.
-   `mssql.intelliSense.enableIntelliSense` and `mssql.intelliSense.enableSuggestions` turn IntelliSense and its suggestions on and off. Both are on by default.
-   `mssql.intelliSense.completionTimeoutMilliseconds`, 2000 by default, is the “maximum time in milliseconds to wait for one IntelliSense completion operation before it times out.”
-   The file’s language mode has to be SQL. Microsoft’s [VS Code quickstart](https://learn.microsoft.com/en-us/azure/azure-sql/database/connect-query-vscode?view=azuresql) says to “set the language mode to SQL to enable mssql commands and T-SQL IntelliSense”: a new file opens as Plain Text, and clicking *Plain Text* in the status bar lets you pick SQL.

If you are moving off Azure Data Studio, the [migration guide](/docs/migrate-from-azure-data-studio/) covers connections and what replaces each feature.

## MySQL Workbench and DBeaver

**MySQL Workbench.** The manual’s [SQL Editor preferences](https://dev.mysql.com/doc/workbench/en/wb-preferences-sql-editor.html) page puts automatic completion under **Preferences → SQL Editor → Query Editor → Automatically Start Code Completion**, “enabled by default.” When it is off, Modifier+Space opens the list by hand.

**DBeaver.** From DBeaver’s [SQL Assist and Auto Complete](https://dbeaver.com/docs/dbeaver/SQL-Assist-and-Auto-Complete/) and [preferences reference](https://dbeaver.com/docs/dbeaver/Admin-Manage-Preferences/) pages:

-   Ctrl+Space opens the list. Automatic activation while typing is on by default.
-   DBeaver has three completion engines, chosen under **Window → Preferences → Editor → SQL Editor → Code Completion**. The recommended *Semantic* engine needs *Enable semantic analysis* and *Read database table/columns for semantic analysis* turned on in the Code Editor settings, and “may not work correctly with certain database-specific syntax”; the docs suggest switching to *Legacy* if it misbehaves.
-   The Database Navigator’s **Refresh** (F5) “refreshes the selected node and its children.” We did not test whether DBeaver’s completion needs it after another tool changes the schema.

## Where autocomplete comes back empty: 51,010 requests

Jam SQL Studio counts, per database engine, how often its editor asked for suggestions and how many answers were empty. Since version 1.5.4 (October 6, 2026) it also records where the cursor was when an answer was empty. The numbers below are from October 7 to 16, 2026 (10 full UTC days), app versions 1.5.4 to 1.5.6: 51,010 answered requests from 209 installations.

### How the counting works

-   **Request.** With *Suggest while typing* on (the default), the editor asks for suggestions when you start typing a word and after a space, dot, colon or comma. While a list is open it mostly filters that list itself; while the answer is empty, it asks again on every character you type.
-   **Empty answer.** The answer held no suggestions. Jam SQL Studio filters its answer by what you have typed (a prefix, initials, part of a name, or from four typed characters the letters in order with gaps), so an empty answer means nothing offered at that position matched.
-   **Blank.** Because the editor re-asks on each keystroke, typing a ten-letter name into an empty list counts up to ten empty answers. A *blank* counts that run once: an empty answer starts a new blank unless the previous answer in the same editor was also empty and on the same word.
-   **Accepted share.** Accepted suggestions divided by accepted suggestions plus dismissals (Esc, a click elsewhere, the cursor moving, more typing). Every time the suggestion widget hides without an accept counts as a dismissal, including when the editor cancelled an empty answer and no list was ever shown, so this is not the share of visible lists that were used.

### Empty answers by engine

Engine

Installations

Requests

Empty answers

Blanks per 100 requests

Accepted share

SQL Server

112

24,719

24.6%

9.8

14.3%

MySQL / MariaDB

66

23,716

33.6%

11.4

10.0%

of which the Thursday group

27

17,389

33.3%

11.5

9.9%

of which all other MySQL installations

39

6,327

34.5%

11.3

10.4%

PostgreSQL

28

1,593

30.1%

10.0

12.1%

Oracle

14

583

23.7%

10.5

9.4%

SQLite

5

399

74.9%

18.0

6.0%

**All engines**

**209**

**51,010**

**29.4%**

**10.6**

**12.2%**

Roughly three answers in ten were empty, but because an empty list is re-asked on every keystroke, that is about one blank per ten requests, with 2.8 empty answers per blank on average. An installation that uses several engines counts once per engine, so the engine rows add up to more than 209.

MySQL is dominated by one group: 27 installations whose summaries were recorded together on Thursday afternoons (15:00–17:00 UTC on October 8 and 15), which looks like a class. They sent 73% of the MySQL requests. Their empty share (33.3%) is close to that of the other 39 MySQL installations (34.5%), but where the cursor was differs, as the next table shows. Per installation: among the 42 SQL Server installations with at least 100 requests, the median one had 21.1% empty answers and the middle half 15.2% to 27.9%. PostgreSQL, Oracle and SQLite are small samples. SQLite especially: one of its five installations sent 250 of the 399 requests.

### Where the cursor was

Each empty answer is attributed to a closed set of position kinds. The definitions are from the app’s code. Each example was checked by running the editor’s completion code on a three-table test schema for all five engines, and each returned an empty list on all five, except `DECLARE @tot`, a SQL Server example, which returned nothing on SQL Server, MySQL and PostgreSQL.

Position kind

What it covers, with tested examples

SQL Server (6,080 empty)

MySQL (7,978)

PostgreSQL (479)

Oracle (138)

`unknown`

Not classified: inside a comment (`-- totals per ci`) or a string literal (typing `Ro` in `city = 'Ro'`), a new column name in `CREATE TABLE people (person_na`, and statements the classifier does not name, such as a new variable in `DECLARE @tot`

51.0%

20.0%

40.7%

45.7%

`other`

Any other named clause: `FROM`, `JOIN`, `WHERE`, `GROUP BY`, `ORDER BY`, `SET`, `LIMIT` / `TOP`, a CTE name, a data type. Examples: a table not in the loaded schema (`FROM invoices`), a typo (`FROM custmoers`), a number (`WHERE customer_id = 42`, `LIMIT 10`, `TOP 10`)

24.4%

19.7%

36.3%

23.9%

`select_list`

The select list: a column alias (`first_name AS given_na`), or a bare column name typed before the `FROM` clause exists (`SELECT first_na`)

8.6%

33.7%

3.3%

3.6%

`dotted_unbound`

After a dot, where the fallback that looks for columns of the name before the dot found none. Typically that name is no alias, CTE, schema or table and no other statement binds it (`SELECT s.na` before any `s` exists). The flag is also set after a dot in a table-name position such as `FROM customers.`, even when `customers` exists, so the group over-counts nonexistent qualifiers by an amount the counters cannot show

2.6%

18.7%

6.1%

24.6%

`dotted`

Any other position after a dot: a misspelled column after a known alias (`c.frist`), a decimal number (`SELECT 1.5`)

10.8%

6.4%

4.0%

0.0%

`ddl`

Slots inside DDL: an index’s column list, a `REFERENCES` target, the name of a new object

1.6%

0.6%

9.2%

0.0%

`scalar_value`

A value position the editor recognises, such as some comparison right-hand sides

0.5%

1.0%

0.4%

2.2%

`values`

An `INSERT` statement’s target, column list or `VALUES` list (`VALUES (7`)

0.6%

0.0%

0.0%

0.0%

Within MySQL, the Thursday group’s empty answers were 36.8% `select_list`, 20.3% `dotted_unbound` and 16.9% `unknown`; the other MySQL installations’ were 25.3%, 14.2% and 28.0%. SQLite’s were 97% `unknown`, from the five installations above.

### Which empty lists are expected

Several kinds of empty answer are correct behaviour, with nothing that could be suggested:

-   **Comments and string literals.** Like SSMS, Jam SQL Studio offers nothing inside a comment. Inside a string it offers suggestions only where the string holds a value, path or name it knows, such as declared [enum values](/docs/enum-columns/#autocomplete), [JSON paths](/docs/json-columns/#autocomplete) and PostgreSQL sequence names in `nextval('…')`. The editor still asks for suggestions while you type in comments and strings, and those empty answers land in `unknown`.
-   **New names.** A column alias, a new column in `CREATE TABLE` or the name of a new object has nothing to complete to, unless it happens to match an existing name.
-   **Numbers.** `WHERE customer_id = 42`, `LIMIT 10`, `VALUES (7` and the decimal number `1.5` give empty answers under `other`, `values` and `dotted`.

On SQL Server, half of the empty answers are `unknown`. That group mixes the expected cases above with T-SQL statements the classifier does not name, such as `DECLARE`, and the counters cannot separate them, so we can’t say how much of it is a gap.

### Which ones are gaps

-   **A table that is not in the loaded schema.** `FROM invoices`, where `invoices` was created after the editor read the schema, is the SSMS stale-cache case. It counts as `other`. The fix is the same as in SSMS: refresh, see the next section.
-   **Typos.** `FROM custmoers` and `c.frist` get nothing: matching accepts prefixes, initials, parts of names and letters in order with gaps, but not swapped letters.
-   **A column typed before `FROM`.** In Jam SQL Studio, on all five engines, `SELECT first_na` with no `FROM` clause written yet gets no columns: until the query names a table, the editor does not know whose columns to offer. With the `FROM` clause written after the cursor, or the name qualified (`customers.first_na`), `first_name` is offered. This case is counted in the `select_list` group, together with the expected aliases; that group is the largest on MySQL.
-   **A qualifier that names nothing.** Typing `SELECT s.name` before writing `FROM students s` in an editor where no statement binds `s` gives `dotted_unbound`. The group as a whole is 18.7% of MySQL’s empty answers and 2.6% of SQL Server’s, but it also holds dots typed in table-name positions (`FROM customers.`), so it is an upper bound for this case, not a count of it.

Version 1.5.4 narrowed the qualifier case: a qualifier typed before the `FROM` clause exists now completes when it is a table name (`SELECT customers.` lists the columns of `customers`) or an alias another statement in the same editor binds (`SELECT c.` after `SELECT * FROM customers c` on the line above). A qualifier that names nothing anywhere in the editor still gets nothing; Jam SQL Studio does not guess a table from an alias’s initials. For a before-and-after view, we took the installations with at least 100 requests both on 1.5.3 and on 1.5.4 or later between October 2 and 16. For the 18 SQL Server installations, empty answers went from 28.0% to 22.6% (median installation 25.2% to 20.9%; 12 of 18 lower). For the 15 MySQL installations, 10 of them in the Thursday group, they went from 29.7% to 31.1%. Other changes shipped in the same releases and people write different SQL from week to week, so neither figure measures the 1.5.4 change on its own.

### How people refresh the schema

Jam SQL Studio re-reads the schema behind autocomplete when you press Cmd+Shift+R / Ctrl+Shift+R in a query tab, pick **Refresh IntelliSense** in the Command Palette, choose **Refresh** on a database in the Object Explorer, or press **Reload schema** on the status-bar indicator after a partial load. In the same 10 days, 62 installations started 255 schema refreshes (3 of them on Kusto, which the completion figures above leave out): 250 through Refresh in the Object Explorer, 4 through Reload schema and once from the Command Palette. The event is recorded when a refresh starts, so some of these may have failed or found nothing to reload. No refresh through the keyboard shortcut was recorded on versions 1.5.4 to 1.5.6 in that window. On older versions, from September 19 to October 16, 2026, four installations used it (versions 1.5.0 to 1.5.3). Two installations, one on SQL Server and one on Oracle, hit the cap on how much schema is loaded.

### Speed

Answers were fast: 94.8% were ready within 25 ms of the completion run starting, and 99.0% within 250 ms. SQL Server had the largest share taking 250 ms or longer (2.0%, including 0.8%, 193 requests, at 750 ms or more), with 90.7% under 25 ms; Oracle had the smallest share under 25 ms (72.0% of 583); MySQL answered 99.5% within 25 ms. These timings exclude the 182 SQL Server requests that were still running when the next keystroke replaced them.

## The same checks in Jam SQL Studio

Cause

In Jam SQL Studio

Objects created elsewhere are missing

[Refresh IntelliSense](/docs/query-editor/#refresh-intellisense): Cmd+Shift+R / Ctrl+Shift+R in a query tab (the SSMS key), the Command Palette, or Refresh on a database in the Object Explorer. DDL you run in the app re-reads the schema by itself, and objects created earlier in the same script complete before the schema has caught up.

IntelliSense turned off

**Settings → Advanced → SQL autocomplete → Enable IntelliSense** turns off suggestions, hovers, signature help and squiggles together ([docs](/docs/query-editor/#disable-intellisense)).

List only opens on request

**Suggest while typing** in the same section; with it off, Ctrl+Space opens the list ([docs](/docs/query-editor/#turn-off-suggestions)).

Wrong or odd suggestions

Turning off **Semantic completions** (under *Safe mode* in the same section) switches to plain word-based suggestions.

Very large databases

If the schema is larger than what IntelliSense loads, the status-bar indicator turns amber, names what was cut, and offers **Reload schema** ([docs](/docs/query-editor/#partially-loaded-schema)).

Comments and strings

Nothing in comments; in strings only where the string holds something it knows, such as enum values, JSON paths and PostgreSQL sequence names.

Column typed before `FROM`

Nothing for a bare name; write the `FROM` clause first, or qualify the column with its table name.

For what the editor offers beyond names, such as parameter hints and column hints in `INSERT` statements, see [SQL editor IntelliSense beyond autocomplete](/blog/sql-editor-intellisense-beyond-autocomplete/) and the [IntelliSense section of the Query Editor docs](/docs/query-editor/#intellisense-and-autocomplete).

## Methodology

-   **Other tools.** SSMS, Azure Data Studio, VS Code, MySQL Workbench and DBeaver behaviour is from the vendor pages and source files linked above, read on October 17, 2026: Microsoft Learn pages, the MSSQL extension’s `package.json` at release 1.46.0, Azure Data Studio’s source at tag 1.52.0, the MySQL Workbench manual and DBeaver’s documentation. We did not test those tools.
-   **Source and window.** Jam SQL Studio’s anonymous in-app usage events from October 7 to 16, 2026 (10 full UTC days), app versions 1.5.4 to 1.5.6. The app adds up its completion counts per engine and sends a summary every 10 minutes while there is activity, but only for the first 12 intervals of a run that emit summaries (one interval can emit one per engine); after that the counts keep adding up and are sent when the app closes, so a long session can arrive late, and counts not yet sent when it crashes are lost. The figures cover summaries recorded on those days; the requests inside a summary can be older than its timestamp, so a day boundary can cut across them.
-   **What is not collected.** No SQL text, no typed text, and no table, column, schema or database names: only the engine, counts and the position kind. Usage analytics can be turned off in *Settings → Privacy*, and installations that did so are not in these numbers. The [privacy policy](/legal/privacy-policy/) describes the telemetry.
-   **Installations, not people.** Each installation sends an anonymous identifier. One person on two machines counts twice.
-   **Requests.** Answered requests only. A request the user typed past before it finished is counted separately (182, all SQL Server) and is not in the totals or the timings. Timings run from the start of the completion run to its list being ready.
-   **Position kinds.** Definitions from the app’s source (`completionSessionAggregate.ts`). The examples were run through the same completion code the editor uses, outside the user interface, on a test schema with three tables (customers, categories, orders) for SQL Server, PostgreSQL, MySQL, Oracle and SQLite.
-   **The Thursday group.** MySQL installations with a summary recorded between 15:00 and 16:59 UTC on Thursday October 8 or Thursday October 15, 2026; all their MySQL summaries in the window are in that row, whatever the time of day the requests were made.
-   **Before and after.** Installations with at least 100 requests for the same engine on 1.5.3 and on 1.5.4 to 1.5.6, October 2 to 16, 2026. Not a controlled comparison.
-   **Engines.** MySQL and MariaDB share one engine in the app. Azure Data Explorer (KQL) is not included: its completion requests are not recorded in these counters.

## Quick Answers

### Q: Why does SSMS IntelliSense not show a table I just created?

A: SSMS keeps a cache of database objects for each query window, and Microsoft’s documentation says IntelliSense does not cover objects created by another connection after the window connected. Refresh the cache with Edit → IntelliSense → Refresh Local Cache or Ctrl+Shift+R, or disconnect the window and reconnect. If the table still does not appear, check your permissions: completion lists leave out objects you cannot access.

### Q: How do I turn IntelliSense back on in SSMS?

A: Press Ctrl+B, Ctrl+I, or click IntelliSense Enabled on the SQL Editor toolbar. If IntelliSense is on but the list only opens when you press Ctrl+J, check the Statement completion options under Tools → Options → Text Editor → Transact-SQL → General and the options under Text Editor → Transact-SQL → IntelliSense; some changes apply only to new query windows. Also check that the window is not in SQLCMD mode (Query → SQLCMD Mode), which turns IntelliSense off.

### Q: Does IntelliSense work in SQLCMD mode?

A: No. Microsoft’s documentation says IntelliSense and the Transact-SQL debugger are turned off while SQLCMD mode is on. Turn SQLCMD mode off for the window from the Query menu or the SQLCMD Mode toolbar button. If every new window starts in SQLCMD mode, clear By default, open new queries in SQLCMD Mode under Tools → Options → Query Execution → SQL Server → General.

### Q: How do I refresh the IntelliSense cache in VS Code or Azure Data Studio?

A: In VS Code with the MSSQL extension, run MS SQL: Refresh IntelliSense Cache from the Command Palette; the extension gives it no default key. T-SQL IntelliSense in VS Code also needs the file’s language mode set to SQL. Azure Data Studio, retired on February 28, 2026, has Refresh IntelliSense Cache in its Command Palette; in its last release the shortcut that shows or hides the results pane is Win+Shift+R on Windows and Ctrl+Shift+R on macOS, so the SSMS key is not a refresh there.

### Q: Why does autocomplete not open in MySQL Workbench or DBeaver?

A: In MySQL Workbench, check Preferences → SQL Editor → Query Editor → Automatically Start Code Completion, which is on by default; Modifier+Space opens the list by hand. In DBeaver, Ctrl+Space opens the list, automatic activation is on by default, and the completion settings are under Window → Preferences → Editor → SQL Editor → Code Completion. DBeaver’s recommended Semantic engine needs Enable semantic analysis and Read database table/columns for semantic analysis turned on; its documentation suggests the Legacy engine if Semantic misbehaves.

### Q: How often does SQL autocomplete come back empty?

A: In Jam SQL Studio’s anonymous usage summaries recorded October 7 to 16, 2026 (versions 1.5.4 to 1.5.6), 29.4% of 51,010 completion requests from 209 installations returned an empty list: 24.6% on SQL Server, 33.6% on MySQL and 30.1% on PostgreSQL. The editor asks again on every character while the list is empty, so those requests make up 5,412 separate blanks, about one per ten requests. Some are expected, such as typing in comments, string literals, new names and numbers. The gaps we could name include tables missing from the loaded schema, typos, a column typed before the FROM clause exists and a qualifier that names no table or alias.

## Summary

In SSMS, a table created after the query window connected needs *Refresh Local Cache* (Ctrl+Shift+R). No suggestions at all points to IntelliSense switched off (Ctrl+B, Ctrl+I), SQLCMD mode, an error above the cursor, or a script over *Maximum script size*. VS Code’s MSSQL extension refreshes with *MS SQL: Refresh IntelliSense Cache* and needs the SQL language mode; MySQL Workbench and DBeaver have an automatic-completion setting and a key to open the list by hand. In Jam SQL Studio’s data, about one request in ten started an empty list. Some of those are expected, such as comments, strings, new names and numbers. The gaps we could name are tables missing from the loaded schema, typos, columns typed before `FROM`, and qualifiers that name nothing.

### Refresh IntelliSense in Jam SQL Studio

Cmd/Ctrl+Shift+R re-reads the schema behind autocomplete for SQL Server, PostgreSQL, MySQL, Oracle and SQLite, on Windows, macOS and Linux. Free for personal use.

[Download Free](/#download) [Refreshing IntelliSense](/docs/query-editor/#refresh-intellisense)

### Related

-   [IntelliSense and Autocomplete Docs](/docs/query-editor/#intellisense-and-autocomplete)
-   [IntelliSense Beyond Autocomplete](/blog/sql-editor-intellisense-beyond-autocomplete/)
-   [Execute Query Shortcuts](/blog/2026-10-14-run-query-keyboard-shortcuts-sql-ides/)
-   [Common SQL Server Errors](/blog/2026-09-26-common-sql-server-errors/)
-   [Migrate from Azure Data Studio](/docs/migrate-from-azure-data-studio/)
-   [SSMS Alternative](/alternatives/ssms/)

## Refresh IntelliSense with Cmd/Ctrl+Shift+R

In a Jam SQL Studio query tab, Cmd+Shift+R (Ctrl+Shift+R on Windows and Linux) or Refresh on a database in the Object Explorer re-reads the schema behind autocomplete, the job Refresh Local Cache does in SSMS.

[Download Jam SQL Studio Free](/#download) [Refreshing IntelliSense](/docs/query-editor/#refresh-intellisense)

Free for personal use • No account required • Mac, Windows, Linux