Last updated: 2026-11-07
Query Editor
Write, execute, and analyze SQL queries with Jam SQL Studio's powerful query editor. Get IntelliSense suggestions, view multiple result sets, analyze execution plans, edit results inline (UPDATE), and export results to various formats.
Writing Queries
The query editor provides a full-featured SQL editing experience with syntax highlighting and intelligent code completion.
Query a table from a blank line
With the Visual Query Editor beta on, a blank line shows a small table-with-plus glyph in the gutter (also when the inline run bar is on). It opens a searchable picker of the database's tables and views; Enter writes a capped SELECT * for the pick, runs it, and opens the compact visual editor so filters, sorting, and column selection are a click away. See Start from a table.
Starter query on your first connection
On a brand-new install, if your first connection has no obvious table to browse, Jam SQL Studio opens a query tab prefilled with a short, dialect-correct starter query (a capped SELECT using the right TOP, LIMIT or FETCH FIRST for your engine) plus a comment reminding you of the run shortcut. Nothing is executed for you — edit it and press Cmd/Ctrl + E when you are ready. When a suitable table is found, you land in Table Explorer instead.
A query tab with no connection
A query tab that isn't connected to anything says Not connected at the top, with a button to fix it. When a connection is connected, the button is Choose a connection…: with one connected connection the tab runs on it, with several you pick one. When none is connected, the button opens the same dialog as Add Connection on the start page: Add a connection… opens the New Connection dialog while nothing is saved, and Choose a connection… opens your saved connections otherwise. Until a database of your own has connected, the same line also offers Open the sample database, which opens the bundled sample in a new tab with an example query already run. In the Visual view the tab shows the Visual Query Editor's own "not connected" banner instead, with the same sample button.
IntelliSense and Autocomplete
As you type, Jam SQL Studio suggests relevant completions based on your database schema and SQL context:
- Table names - Suggested after FROM, JOIN, INSERT INTO, UPDATE. An unqualified name resolves the way the server resolves it: along the
search_pathon PostgreSQL, in your login's default schema and thendboon SQL Server. When the PostgreSQLsearch_pathwas read from the server or set in the script, a table outside it supplies no columns to an unqualified name. On PostgreSQL,ordersand"Orders"are listed as two tables, each with its own columns - JOIN templates - After
JOIN, a table linked to one already in the query by a foreign key or a loose foreign key is offered with its wholeONcondition. Table and column names are quoted where the engine needs it ("Orders" o ON o."CustomerId" = c.id,dbo.[Order Details]). Tables whose names differ only by case each offer their own foreign-key JOINs, and an unqualified table follows the foreign keys of the table the server resolves it to - Column names - Suggested after SELECT, WHERE, ORDER BY, or when typing after a table alias. A qualifier typed before the
FROMclause exists also completes:SELECT customers.lists the columns ofcustomers, andSELECT c.lists the columns of the table another statement in the same editor bindscto (the nearest statement above wins; when statements bindcto different tables, each table's columns are listed with the table name next to them). A qualifier that names no table and no alias anywhere in the editor still lists nothing. A column name typed before the statement has aFROMclause (SELECT first_n) completes from the columns of the database's tables and views, with the table names next to each column (on PostgreSQL and Oracle,nameand"Name"are listed as two columns); the alias you type afterASgets no suggestions - SQL keywords - Context-aware keyword suggestions (FROM after SELECT, WHERE after FROM, etc.)
- Functions - Built-in SQL functions with parameter hints
- Values - Suggested wherever a scalar value belongs — comparison RHS (
WHERE column =,HAVING, joinON),BETWEENbounds,IN-list elements,UPDATE ... SET, andINSERT ... VALUES. Instead of flooding the list with every table and column, Jam SQL Studio ranks type-compatible columns first (a matching foreign-key column ranks highest), followed by relevant functions; declared enum values (read from the table the server resolves an unqualified name to),NULL, andDEFAULTare suggested insideVALUES, andRETURNING/OUTPUTonly offer the target table's own columns - Filter conditions - At the start of a
WHERE,HAVING, or joinONclause, and right afterAND/OR/NOT, Jam no longer offers table, view, schema, database, or CTE names (illegal at that position) — instead you get the in-scope columns for that clause with boolean-looking columns ranked first, table/alias qualifiers,EXISTS (SELECT …)/NOT EXISTS (SELECT …)/(SELECT …)snippets, a bareNOT, and boolean-returning functions ranked above other functions.TRUE/FALSEare suggested on PostgreSQL, MySQL, and SQLite (not SQL Server or Oracle)
Suggestions use the engine and schema of the connection the tab is bound to. If you switch the tab to another connection, for example from the connection picker in the status bar, IntelliSense reloads for that connection's engine and database.
A tab can open before its connection does, for example when a session is restored at startup or a Microsoft Entra sign-in is still in progress. IntelliSense then waits for the connection: the indicator in the status bar shows IntelliSense as unavailable until the connection opens, and the schema loads as soon as it does, with no Refresh needed.
Which statement the suggestions read
Suggestions read only the statement the caret is in, so the tables and aliases of other statements in the same editor do not mix into the list. The one exception is a qualifier the current statement does not declare: after x., when no table or alias of the current statement is called x, the columns come from the nearest statement that declares the alias x. A statement ends at a semicolon, at a GO line on SQL Server, and where a statement keyword such as SELECT, INSERT, UPDATE, DELETE, MERGE or WITH starts a new line (a comment in front of it on that line does not change this), so scripts written without semicolons work the same way. On SQL Server, DECLARE, SET, IF, WHILE, EXEC, PRINT, RETURN and USE start a statement too, also inside a procedure body. A keyword that continues the statement does not split it: UNION SELECT, INSERT … SELECT, WITH … AS (…) SELECT (also after CREATE TABLE … AS), UPDATE … SET, the WHEN … THEN UPDATE arms of a MERGE, on SQL Server the SELECT on the line after a FROM-first query's table (FROM t, then SELECT …, also in a UNION, EXCEPT or INTERSECT branch; a blank line between them still separates two statements), and anything inside parentheses. On SQL Server a FROM-first query after a blank line starts a new statement when the statement above it already has its FROM or never takes one (SET NOCOUNT ON, DECLARE, …). When the schema-aware list has nothing for the caret, the plain word suggestions come from the current tab only, never from other open tabs.
Positions beyond the basic clauses
Suggestions are scoped to the slot the caret is in, not just to the surrounding clause. Inside a CREATE TABLE or ALTER TABLE, constraint lists (PRIMARY KEY (…), FOREIGN KEY (…), CHECK (…), PARTITION BY RANGE (…), functional index expressions) offer the table's own columns (a quoted target such as "Orders" is that table, not its lowercase sibling orders), including columns declared a few lines up in the same statement or added by an earlier ALTER TABLE … ADD COLUMN in the script. Data-type slots (DECLARE, routine parameters and RETURNS, TABLE OF, composite-type attributes, CAST(… AS) offer type names, with engine specifics such as trigger for a PostgreSQL trigger function, SYS_REFCURSOR for an Oracle RETURN, or OUTPUT after a T-SQL parameter type. Trigger definitions offer the target table's columns after UPDATE OF and the event keywords after AFTER; trigger bodies offer NEW / OLD (or inserted / deleted) row qualifiers. Savepoint names declared earlier complete at ROLLBACK TO and RELEASE; * is offered in select lists and RETURNING; window PARTITION BY / ORDER BY and WITHIN GROUP offer the FROM relation's columns; and closed vocabularies such as CONVERT style codes, DATE_TRUNC fields, sequence options and range-type options are offered where they belong. Tables, functions, domains and other user-defined types, and CREATE TABLE … AS SELECT results created earlier in the script complete before the schema cache has caught up, and typing the first letters of a name never changes what a position offers, only which entries match. On PostgreSQL the sequence-name string of nextval('…'), currval('…') and setval('…') lists the schema's sequences (including one the script's own CREATE SEQUENCE declares); a column's type slot after a schema qualifier lists that schema's domains, range types, composite types and enums instead of its tables (including one the script's own CREATE DOMAIN or CREATE TYPE declares a few lines up); REFRESH MATERIALIZED VIEW <schema>. lists only materialized views, while ALTER TABLE, DROP TABLE and TRUNCATE list only base tables; and inside an INSERT column list a SERIAL or identity column is ranked last rather than first, since the engine assigns its value — it stays offered, because an explicit value is still legal. In a MERGE … WHEN NOT MATCHED THEN INSERT … VALUES (…) on PostgreSQL, SQL Server and Oracle, the USING source's columns are offered in their qualified src.column form, and a name both the source and the target carry is offered only qualified — a bare reference to it would be ambiguous. On SQL Server an IDENTITY column and a computed column are ranked the same way inside an INSERT column list — below the columns you can insert into, still in the list, because a migration script that runs SET IDENTITY_INSERT … ON needs the name. Index names complete where an index rather than a table or column belongs: MySQL's FORCE INDEX (…), USE INDEX (…) and IGNORE INDEX (…) hints (including the FOR JOIN / FOR ORDER BY / FOR GROUP BY forms), ALTER TABLE … DROP INDEX, and DROP INDEX — narrowed to one table's indexes when the statement names a table, listed with their key columns either way. And the column declarations inside JSON_TABLE(… COLUMNS (…)), XMLTABLE(… COLUMNS (…)) and SQL Server's OPENJSON(…) WITH (…) are data-type slots, so the type names are offered there instead of the surrounding query's relations.
How suggestions are ranked
Suggestions are grouped into tiers by how likely they are at the caret (bound-alias columns and foreign-key join templates first, then other tables, then keywords and functions), and inside a tier the best prefix match wins. When several entries match equally, these tie-breakers decide the order:
- What the caret is editing leads. With the caret on an existing table, view, or CTE name in a
FROM,JOIN,UPDATE, orDELETEslot, that relation and its join template come first. Join templates that would reference an alias bound only later in the statement are moved down. - Already-written names stop leading. A name you have already typed in the current clause or list — a named procedure parameter, a value in an
IN (…)list, a column in aPRIMARY KEY (…)list — is still offered but no longer sits at the top. - What you accepted before floats up. Completions you accepted earlier on the same connection and database are ranked ahead of never-accepted siblings, most recent first. This memory is per app session and is not written to disk or shared.
- Context defaults. Inside a
CATCHblock on SQL Server theERROR_*functions lead the local variables; insideANY(),ALL(), andarray_*calls on PostgreSQL the array-typed columns lead; and the name slot ofCREATE VIEW,CREATE TABLE,CREATE PROCEDUREand friends lists schemas with the connection's default schema first. - Grouping narrows what a bare column may be. Once the statement has a
GROUP BY,HAVINGandORDER BYoffer the grouped columns, the select-list aliases and the aggregate functions — the remaining raw columns are dropped on PostgreSQL, SQL Server, and Oracle, where a bare reference to one is an error, and ranked down on MySQL and SQLite, where it is accepted but reads an arbitrary row of the group; inside an aggregate's parentheses (HAVING SUM() every column is offered again, and groupings Jam cannot read as a plain column list —GROUPING SETS,ROLLUP,CUBE,GROUP BY ALL, an expression with a function call — leave the list untouched.
Turning the suggestion popup off
If you would rather the popup never opened on its own, untick Settings → Advanced → SQL autocomplete → Suggest while typing. The editor then stops opening suggestions as you type (including after a dot or an opening parenthesis), and Ctrl+Space opens the list only when you ask for it. The change applies to every open editor immediately. This is separate from the Semantic completions safe-mode switch below, which keeps the popup but swaps the schema-aware list for plain word-based suggestions.
Turning IntelliSense off entirely
To switch off every language feature at once, untick Settings → Advanced → SQL autocomplete → Enable IntelliSense. With it off, the editor offers no suggestions (Ctrl+Space included), no hover tooltips, signature help, inlay hints or quick fixes, and no squiggles of any kind; markers already on screen are cleared. The finer options in that section are greyed out until you tick it again. Syntax highlighting, formatting and query execution are unaffected. To keep autocomplete but drop only the squiggles, use the Live diagnostics safe-mode switch described below.
Keyword case on insert
Configure how keywords are cased when you accept a suggestion in Settings → Advanced → SQL autocomplete → Keyword case on insert:
- Match what you type (default) - The case follows the prefix you typed (typing
selinsertsselect; typingSELinsertsSELECT). When the prefix has no clear case, the dominant case already used in the buffer wins. - UPPER CASE - Always insert keywords in upper case.
- lower case - Always insert keywords in lower case.
The setting only affects SQL keywords. Identifier casing (table and column names) is governed by the database engine and any quoting in your script.
Version-incompatible suggestions
Jam knows which keywords and built-in functions ship in each server version (for example, STRING_AGG needs SQL Server 2017+; MERGE needs PostgreSQL 15+; RETURNING needs SQLite 3.35+). Configure how Jam handles entries that don't fit the connection's reported version in Settings → Advanced → SQL autocomplete → Version-incompatible suggestions:
- Show with badges (default, recommended) - Every suggestion is visible. Items that aren't yet available carry a right-aligned tag like
≥ 2017and are demoted in the ranked list. Items removed at the current compatibility level render with a strikethrough and rank last. - Hide unavailable, badge deprecated - Drops "not yet available" suggestions completely. Removed-at-compat items remain visible with a strikethrough so paste-from-legacy workflows still inform.
- Show everything, no badges - The pre-versioning behavior. All suggestions are displayed at full weight regardless of server version.
The catalog covers MSSQL, PostgreSQL, MySQL, Oracle, and SQLite. The setting applies to the suggestion list. On SQL Server the version is the SQL Server release the server reports, so year badges such as ≥ 2017 appear only on SQL Server itself and on Azure SQL Edge. Azure SQL Database, Azure SQL Managed Instance, SQL database in Fabric, Azure Synapse Analytics and Fabric Data Warehouse are not tied to a SQL Server release, so their suggestions carry no year badges. A few suggestions depend on the platform instead of the version: the Fabric Warehouse syntax gets a Fabric badge on a server that is known not to be Fabric Data Warehouse (see Fabric Warehouse T-SQL syntax).
T-SQL Procedural Intellisense (SQL Server)
SQL Server connections get a dedicated procedural-grammar layer that understands the bodies of stored procedures, functions, triggers, MERGE, OUTPUT clauses, and dynamic SQL. The layer activates the first time you connect to an MSSQL server in a session — non-MSSQL connections never pay the parse cost.
- Local declarations —
DECLARE @var INT,DECLARE @t TABLE (…),CREATE TABLE #temp (…), andDECLARE c CURSOR FOR …all surface their names with batch-scoped (or session-wide for##gtemp) visibility. - Trigger pseudo-tables — inside a trigger body,
inserted/deletedresolve against the trigger's target table. - OUTPUT clause + MERGE —
$ACTION,inserted.col, anddeleted.colresolve against the carrier statement's target table; MERGE WHEN-clauses know which action keyword (UPDATE/DELETE/INSERT) is legal. - TRY / CATCH — inside a CATCH block,
ERROR_MESSAGE(),ERROR_NUMBER(),ERROR_LINE(),ERROR_PROCEDURE(),ERROR_SEVERITY(),ERROR_STATE(), andXACT_STATE()are recognized; outside CATCH they are not promoted. - Dynamic SQL —
EXEC(@sql)andsp_executesqlcallsites are recognized so completion knows the difference between a statement-levelEXEC dbo.usp_Thingand a string-literal payload that is itself SQL. - GO batches — declarations are batch-scoped:
@vardeclared above aGOseparator does not leak into the next batch's completion list.
Performance budget: for a 1500-line procedural buffer, the suggestion list is delivered without blocking the UI. Heavy parsing runs in a background worker; the editor stays responsive between keystrokes.
PL/SQL Procedural Intellisense (Oracle)
Oracle connections get a dedicated procedural-grammar layer that understands the bodies of packages, package bodies, standalone functions / procedures, triggers (including row-level and compound), anonymous blocks, object-type bodies, exception handlers, and dynamic SQL. The layer activates the first time you connect to an Oracle server in a session — non-Oracle connections never pay the parse cost.
- Local declarations — variables (
v_x NUMBER), explicit cursors (CURSOR c IS …), records (TYPE r IS RECORD (…)), collections (TYPE t IS TABLE OF …, VARRAY, associative arrays), and locally-declared exceptions all surface their names with block-scoped visibility. %TYPE/%ROWTYPE—v_salary employees.salary%TYPEresolves the inferred shape against the connected catalog;r employees%ROWTYPEexposes the table's columns through dot-completion (r.|).- Trigger pseudo-rows — inside a row-level trigger,
:NEW.and:OLD.resolve against the trigger'sON <table>clause, surfacing the host table's columns. - Cursor attributes —
c%FOUND,c%NOTFOUND,c%ISOPEN,c%ROWCOUNT, andSQL%FOUND/SQL%NOTFOUND/SQL%ROWCOUNTare recognized after a declared cursor or implicit-DML reference. - Package members —
PKG.memberdot-completion surfaces the public procedures and functions declared in the package spec (resolved throughALL_PROCEDURES/ALL_ARGUMENTS). - Exception handlers — inside a
WHEN exception_name THENclause, locally-declared andPRAGMA EXCEPTION_INIT-bound exception names rank above unrelated identifiers; the predefined names (NO_DATA_FOUND,TOO_MANY_ROWS,OTHERS, …) remain available. - Dynamic SQL —
EXECUTE IMMEDIATEcallsites are recognized so completion knows the difference between the surrounding PL/SQL block and the string-literal payload that is itself SQL;USINGbind-variable references are best-effort. - Editioning & AUTHID — editioning keywords (
EDITIONABLE/NONEDITIONABLE) andAUTHID CURRENT_USER/AUTHID DEFINERdeclarations are parsed as part of the create header and don't perturb body completion.
Performance budget: for a 1500-line PL/SQL buffer, the suggestion list is delivered without blocking the UI. The procedural-grammar bundle is loaded lazily on first Oracle connect; Heavy parsing runs in a background worker; the editor stays responsive between keystrokes.
PL/pgSQL Procedural Intellisense (PostgreSQL)
PostgreSQL connections get a dedicated procedural-grammar layer that understands the bodies of CREATE FUNCTION … LANGUAGE plpgsql, CREATE PROCEDURE … LANGUAGE plpgsql, trigger functions (row-level and statement-level, plus event triggers), and anonymous DO $$ … $$ blocks. The layer activates the first time you connect to a PostgreSQL server in a session — non-PG connections never pay the parse cost.
- Local declarations — variables (
v_x INTEGER),CONSTANTvalues,ALIAS FOR $Npositional-parameter aliases, refcursors (c REFCURSOR,CURSOR FOR SELECT …), andRECORDvariables all surface their names with block-scoped visibility. %TYPE/%ROWTYPE—v_salary employees.salary%TYPEresolves the inferred shape against the connected catalog;r employees%ROWTYPEexposes the table's columns through dot-completion (r.|). PG's flexible declaration syntax (:=,=, andDEFAULTare all accepted) is recognized.- RECORD shape inference — a bare
r RECORD;declared variable picks up its shape at the firstSELECT … INTO r FROM <table>; subsequentr.dot-completion surfaces the inferred row's columns. Mirrors PG's runtime inference rule. - Trigger pseudo-rows — inside a row-level trigger function,
NEW.andOLD.resolve against the trigger'sON <table>clause, surfacing the host table's columns.TG_OP,TG_NAME,TG_WHEN,TG_LEVEL,TG_TABLE_NAME,TG_TABLE_SCHEMA,TG_RELID,TG_NARGS,TG_ARGV, and the event-trigger-onlyTG_EVENT_OBJECT_*variables are recognized in trigger function bodies; outside a trigger function they are not promoted. - Exception handlers — inside a
WHEN <condition_name> THENclause, the SQLSTATE condition-name table (unique_violation,foreign_key_violation,division_by_zero,raise_exception,OTHERS, …) is recognized.GET STACKED DIAGNOSTICSassignments surface the per-handler diagnostic names (RETURNED_SQLSTATE,MESSAGE_TEXT,PG_EXCEPTION_DETAIL,PG_EXCEPTION_CONTEXT, …);GET CURRENT DIAGNOSTICSoutside a handler surfacesROW_COUNTandPG_CONTEXT. - FOUND — the implicit
FOUNDboolean is auto-scoped at every BEGIN block frame, soIF FOUND THEN …andIF NOT FOUND THEN …resolve cleanly. - Refcursors — bound (
CURSOR FOR SELECT …) and unbound (REFCURSOR) cursor declarations surface their names.FETCHandMOVEdirection keywords (NEXT,PRIOR,FIRST,LAST,ABSOLUTE,RELATIVE,FORWARD,BACKWARD) are recognized in their syntactic slots. - Control flow with labels —
<<label>>-decoratedBEGIN/LOOP/WHILE/FOR/FOREACH/IF/CASEblocks contribute to the in-scope label list visible toEXIT <label>/CONTINUE <label>at every nesting depth (innermost-first). - FOREACH array iteration —
FOREACH r IN ARRAY arr LOOPandFOREACH r SLICE n IN ARRAY arr LOOPare recognized; iteration variables get block-scoped visibility. - Positional parameter refs (
$N) — body references like$1/$2resolve against the function's parameter list;v_id ALIAS FOR $1;legacy aliases cross-link to the parameter. - RAISE / ASSERT —
RAISE [level] '…' USING …recognizes the fixed USING-option set (MESSAGE,DETAIL,HINT,ERRCODE,COLUMN,CONSTRAINT,DATATYPE,TABLE,SCHEMA) and the level keywords (DEBUG,LOG,INFO,NOTICE,WARNING,EXCEPTION); bareRAISE;re-raise inside an exception handler is recognized;ASSERTis recognized as a separate statement kind. - Dynamic SQL —
EXECUTEcallsites (includingEXECUTE … INTO …,EXECUTE … USING …,OPEN c FOR EXECUTE …,FOR r IN EXECUTE …,RETURN QUERY EXECUTE …) are recognized so completion knows the difference between the surrounding PL/pgSQL block and the string-literal payload that is itself SQL. - Transaction control (PG 11+) —
COMMIT,ROLLBACK,SAVEPOINT, andRELEASE SAVEPOINTare recognized insideCREATE PROCEDUREbodies (PG 11+); they are not promoted insideCREATE FUNCTIONbodies where PG forbids them.
Performance budget: for a 1500-line PL/pgSQL buffer, the suggestion list is delivered without blocking the UI. The procedural-grammar bundle is loaded lazily on first PostgreSQL connect; heavy parsing runs in a background worker; the editor stays responsive between keystrokes.
MySQL Stored-Routine Intellisense (MySQL)
MySQL connections get a dedicated procedural-grammar layer that understands the bodies of stored procedures, stored functions, triggers, events, and standalone BEGIN…END compound statements typed under a DELIMITER // directive. The layer activates the first time you connect to a MySQL server in a session — non-MySQL connections never pay the parse cost. MariaDB connections fall back to best-effort tree-sitter extraction (the ANTLR layer stays dormant) because MariaDB's procedural extensions diverge from MySQL 8.0.
- Local declarations — variables (
DECLARE v_x INT DEFAULT 0;with optionalCHARACTER SET/COLLATE), comma-separated multi-name DECLAREs, named conditions (DECLARE no_data CONDITION FOR SQLSTATE '02000';), cursors (DECLARE c CURSOR FOR SELECT …;), and handlers (DECLARE CONTINUE | EXIT | UNDO HANDLER FOR …;) all surface their names with block-scoped visibility per MySQL §15.6's BEGIN…END frame rule. The MySQL §15.6.4 ordering rule (variables → conditions → cursors → handlers) is surfaced as an advisory warning when violated. - Trigger pseudo-rows — inside a row-level trigger,
NEW.andOLD.resolve against the trigger'sON <table>clause, surfacing the host table's columns.NEWis unavailable inBEFORE DELETE/AFTER DELETE;OLDis unavailable inBEFORE INSERT/AFTER INSERT. MySQL has only row-level triggers (no statement-level FOR EACH STATEMENT). - Handler conditions — completion after
DECLARE … HANDLER FORrecognizesSQLEXCEPTION,SQLWARNING,NOT FOUND,SQLSTATE '<code>',MySQL error number, and named-condition references in scope. Continuing-after-comma in multi-conditionHANDLER FOR a, b, cfilters out previously-listed conditions. - User vs. routine variables —
@user_varsession-scoped variables are recognized distinct from bareroutine_varroutine-local references. The scope-merge rule per § 2.9 surfaces both kinds at every cursor position with the correct kind annotation;SET @x = …targets the session variable whileSET v_count = …targets the routine local. - Control flow with labels — labeled
LOOP,WHILE … DO,REPEAT … UNTIL, and labeledBEGIN…ENDblocks contribute to the in-scope label list visible toLEAVE <label>/ITERATE <label>. Innermost-first matching at every nesting depth; case-folded per MySQL's identifier policy. - SIGNAL / RESIGNAL / GET DIAGNOSTICS — the SET-item slot (
MESSAGE_TEXT,MYSQL_ERRNO,SCHEMA_NAME,TABLE_NAME,COLUMN_NAME,CURSOR_NAME,CONSTRAINT_CATALOG,CONSTRAINT_SCHEMA,CONSTRAINT_NAME,CATALOG_NAME,CLASS_ORIGIN,SUBCLASS_ORIGIN) is recognized;GET [STACKED] DIAGNOSTICScondition-information items (NUMBER,ROW_COUNT, plus the per-condition fields above) populate the right-hand-side slot. - Dynamic SQL —
PREPARE stmt FROM @sql/EXECUTE stmt USING @a, @b/DEALLOCATE PREPARE stmtare recognized so completion knows the difference between the surrounding routine block and the string-literal payload that is itself SQL;USING @varbind-variable references are best-effort. - SELECT … INTO — multi-row single-assignment
SELECT col_list INTO var_list FROM …recognizes the variable-list slot's routine locals + user variables (SELECT a, b INTO @ua, v_local FROM t). - Parameters —
IN,OUT, andINOUTparameter modes are recognized in the procedure / function signature; parameter names participate in body-level scope alongsideDECLARE'd locals. - DELIMITER interop — when the outer buffer carries a
DELIMITER //directive, MySQL's procedural-grammar layer cooperates with the SqlGrammar parse-options state so the routine body parses as a single unit despite embedded semicolons. Non-procedural statements at the same buffer level still parse independently.
Performance budget: for a 1500-line MySQL routine buffer, the suggestion list is delivered without blocking the UI. The procedural-grammar bundle is loaded lazily on first MySQL connect; heavy parsing runs in a background worker; the editor stays responsive between keystrokes.
SQL/PGQ Property Graph Intellisense (Oracle 23ai+)
On Oracle 23ai+ connections — and on the PostgreSQL 19 beta 1–3 builds, which carried a first SQL/PGQ implementation until PostgreSQL 19 Beta 4 reverted it on September 24, 2026 — the editor recognizes SQL/PGQ property-graph syntax — the GRAPH_TABLE table function, GPML (Graph Pattern Matching Language) node/edge pattern matching, and CREATE / ALTER / DROP PROPERTY GRAPH DDL — and offers schema-aware completions once at least one property graph exists on the connected server:
- Graph names — suggested right after
GRAPH_TABLE (, sourced from the graphs defined on the connected database. - Labels — suggested inside node patterns
(a IS …)and edge patterns-[e IS …]-, scoped to the selected graph. - Element properties — dot-completion on a pattern variable (
a.…) surfaces the properties available on that vertex or edge. - COLUMNS projections — inside
COLUMNS ( … ), completion offers the in-scope element variables (forvar.prop AS aliasnavigation) plusAS. On Oracle 23ai+ it additionally offers the PGQ scalar/row functions (VERTEX_ID,EDGE_ID,VERTEX_EQUAL,EDGE_EQUAL,BINDING_COUNT,MATCHNUM,ELEMENT_NUMBER,PATH_NAME,PROPERTY_EXISTS), each version-gated to the Oracle release update it actually shipped in (for exampleMATCHNUMneeds 23.8+) with a badge under the same version-gating setting described above. The PostgreSQL 19 beta implementation had no equivalent scalar function library, so on PostgreSQL theCOLUMNSslot offers only element-variable property navigation. - Columns derived from
GRAPH_TABLEaliases — once aGRAPH_TABLE(…) AS galias is in scope, downstream clauses (SELECT g.…,WHERE g.…) complete against the columns actually projected in that graph query'sCOLUMNSlist, not the underlying tables.
On PostgreSQL, the bundled language server predates SQL/PGQ and would otherwise flag valid GRAPH_TABLE queries with a false "syntax error" squiggle; Jam SQL Studio suppresses that false positive for the common GRAPH_TABLE ... MATCH (...) COLUMNS (...) shape when the server reports version 19 or later. The check reads only the major version, so it also applies on PostgreSQL 19 Beta 4 and later, where the server itself rejects GRAPH_TABLE when the query runs. Pattern quantifiers ({1,3}, *, +), path modes (WALK/TRAIL/ACYCLIC/SIMPLE), and search prefixes (ANY/SHORTEST/ALL SHORTEST) fall outside the currently-verified subset, so queries using them keep whatever squiggle the language server raises rather than risk hiding a real error.
The Visual Query Editor can't edit GRAPH_TABLE queries structurally — it shows a read-only summary with an Edit-as-SQL hand-off back to this editor, the same as any other statement shape it doesn't yet model.
Scope-Aware Completion (USE, search_path, ATTACH)
IntelliSense follows the scope-changing statements written above the cursor, the same way the engine does when the script runs top to bottom. Typing USE OtherDB; on line 1 makes line 2's SELECT * FROM see OtherDB's tables. The same applies to PostgreSQL SET search_path TO …, Oracle ALTER SESSION SET CURRENT_SCHEMA = …, and SQLite ATTACH DATABASE '…' AS … — later statements complete against the accumulated database, schema, search path, or attached databases. A buffer without any scope-changing statement simply resolves against the connection's default database and schema.
Large databases
The schema loads in tiers. Table and view names are read first and the IntelliSense pill turns ready as soon as they arrive, usually within a couple of seconds even on a database with tens of thousands of tables. Columns, keys, indexes, routines and types stream in behind them in small pages, and the editor stays responsive while they do. Once loaded, the schema is kept for the whole session: it is re-read only after you run DDL, refresh it yourself, or reconnect, never on a timer. The identifier index behind Find References and Rename is built in the background once the schema is complete and the editor is idle, in small slices, so it never delays a tab from opening; a Find References or Rename request starts the build at once instead of waiting for that moment. If a database holds more definition text than the index reads, the References tab says so.
Refreshing IntelliSense after changes made outside the app
When a table, column or routine is added by a migration tool, a teammate or another client, the loaded schema does not know about it. Press Cmd+Shift+R / Ctrl+Shift+R in a query tab (or pick Refresh IntelliSense from the Command Palette) to re-read the schema for that tab's connection and database, the same way Refresh Local Cache works in SQL Server Management Studio. Choosing Refresh on a database in the Object Explorer re-reads it as well, alongside the tree itself. While the reload runs, the IntelliSense indicator in the status bar of every query tab on that database shows a spinner, and so does the database row in the Object Explorer; completion keeps working against the previous snapshot until the new one lands.
When only part of the schema loads
Very large databases can hold more objects than IntelliSense loads in one pass, so the schema snapshot is capped. When a cap is reached, the IntelliSense indicator in the status bar turns amber and stays that way: completion keeps working against everything that did load, and the indicator names what was cut — for example “Schema partially loaded — columns and indexes exceeded the cap; some completions may be missing.” Click the indicator to read the message and press Reload schema to fetch the schema again for the current connection and database. If the fresh load fits, the indicator returns to its normal ready state.
Fabric Warehouse T-SQL syntax
Microsoft Fabric Data Warehouse and the SQL analytics endpoint accept T-SQL that other SQL Server platforms do not: the aggregate functions ANY_VALUE, MEDIAN, QUANTILE, APPROX_MEDIAN and APPROX_QUANTILE, the QUALIFY clause, a bare GROUP BY ALL, ORDER BY ALL, and FROM-first queries (FROM t SELECT …). ANY_VALUE is generally available there; the others are in preview. The query editor recognizes all of them on every SQL Server connection:
SELECT Color, COUNT(*) AS Products, MEDIAN(ListPrice) AS MedianListPrice
FROM Production.Product
GROUP BY ALL
ORDER BY ALL;
FROM Production.Product
SELECT Name, Color
WHERE Color = 'Red';
SELECT CustomerID, OrderDate,
ROW_NUMBER() OVER (PARTITION BY CustomerID ORDER BY OrderDate DESC) AS rn
FROM Sales.SalesOrderHeader
QUALIFY rn = 1;- Autocomplete — the five functions are offered with the other built-ins, as are SQL Server 2022's
APPROX_PERCENTILE_CONTandAPPROX_PERCENTILE_DISC.QUALIFYis offered after the table list, a join'sON,WHERE,GROUP BYandHAVING; afterQUALIFYthe list holds the columns, the aggregate and window functions (ROW_NUMBER,RANK, …) and the select-list aliases, the same as afterHAVING. AtGROUP BYandORDER BY,ALLis listed below the columns with a note on what it does. In a FROM-first query,SELECTis offered after the table, the select list offers the columns of the tables you started from, and after the select list you getWHERE,GROUP BY,HAVING,QUALIFY,ORDER BYand the set operators instead ofFROM. A FROM-first derived table or CTE exposes its columns to the outer query (d.lists them). - Signature help and hover — signature help follows T-SQL's argument order, so
QUANTILEandAPPROX_QUANTILEtake the quantile (0 to 1) first. Hovering a call shows the function's parameters, return type and description, including that it runs on Fabric Data Warehouse and the SQL analytics endpoint only. - Coloring — the five functions are colored as functions, and
QUALIFY,WITHINand theALLofGROUP BY ALL/ORDER BY ALLas keywords (theALLwhen the phrase is written on one line). Newer SQL Server built-ins such asSTRING_AGG,JSON_VALUE,OPENJSONandDATETRUNCare colored as functions too. - No false syntax errors — live syntax checking accepts the new syntax on every SQL Server platform, including FROM-first queries in CTEs, subqueries,
EXISTS,INSERT INTO … FROM … SELECT, views and procedures.qualify,medianand the other new words stay valid as column and table names. - Running one statement — F5 and Cmd/Ctrl+Enter run a FROM-first query, or a statement that ends in
GROUP BY ALLorORDER BY ALL, on its own rather than the whole editor, and a selected FROM-first query switches the toolbar button to Selection. A statement that starts withFROMand has noSELECT(FROM t WHERE …) counts as a query only when the server is Fabric Data Warehouse; elsewhere it stays theFROMclause of the statement above it, so aSELECTseparated from itsFROMby a blank line runs as before. The inline Execute / Peek bar offers Execute but not Peek for a FROM-first query. End statements with;when you mix FROM-first and SELECT-first queries: without it,SELECT afollowed byFROM t SELECT breads asSELECT a FROM tand a secondSELECT b, as it does on the server. - Format SQL — writes the new functions without a space before
(, keepsGROUP BY ALLandORDER BY ALL [ASC | DESC]on the clause line, and puts aQUALIFYclause on its own line. A column namedqualifystays where it is. - Visual mode — shows
QUALIFY,GROUP BY ALLandORDER BY ALLread-only and keeps them exactly as written when you edit the rest of the query; a FROM-first query is edited in SQL view. See Visual Query Editor.
Where it runs. The editor accepts this syntax on every SQL Server connection, and no squiggle depends on the platform. The server decides when the query runs: SQL Server (2025 included), Azure SQL Database, Azure SQL Managed Instance and SQL database in Fabric reject it. Once the editor has read the server's platform and it is not Fabric Data Warehouse, autocomplete marks the new functions, QUALIFY, the ALL after GROUP BY / ORDER BY and the SELECT after a FROM-first table with a Fabric badge and the note Fabric Data Warehouse / SQL analytics endpoint only, and ranks them lower; with Hide unavailable, badge deprecated (see Version-incompatible suggestions) the badged entries are hidden. On such a server GROUP BY ALL is followed by column suggestions, because only SQL Server's older GROUP BY ALL column form runs there. Nothing is badged on Fabric Data Warehouse, on the SQL analytics endpoint, on Azure Synapse serverless SQL pools (they report the same platform), or before the platform has been read.
Oracle. Oracle Database 26ai runs QUALIFY, a bare GROUP BY ALL, ANY_VALUE, MEDIAN and APPROX_MEDIAN. On Oracle connections QUALIFY is completed and colored the same way, a statement ending in GROUP BY ALL runs on its own, ANY_VALUE, MEDIAN, APPROX_MEDIAN and APPROX_PERCENTILE autocomplete and show hover documentation, Format SQL lays out QUALIFY and GROUP BY ALL, and Visual mode keeps both read-only. Of the engines Jam SQL Studio supports, only Fabric has ORDER BY ALL and FROM-first queries. On PostgreSQL, MySQL and SQLite, qualify is an ordinary name; ANY_VALUE autocompletes there as well (PostgreSQL 16+, MySQL 5.7+).
SQL Snippets
Speed up common SQL patterns with built-in snippets. Type a prefix and press Tab to expand:
sel- SELECT statement templateselw- SELECT with WHERE clauseins- INSERT statement templateupd- UPDATE statement templatedel- DELETE statement template
You can also create custom snippets in Settings > Snippets.
Function Signature Help
When you type the opening parenthesis of a function or stored procedure call, Jam SQL Studio shows a parameter-hints popup with the full signature and highlights the currently active argument. As you type commas, the highlight advances to the next parameter.
- Schema-qualified calls —
dbo.ufnGetProductListPrice(resolves with the explicit schema - Unqualified calls —
substring(resolves against the default schema (dbofor MSSQL,publicfor PostgreSQL, current database for MySQL, login schema for Oracle) - Package-qualified calls (Oracle) —
DBMS_OUTPUT.PUT_LINE(resolves package routines - SQLite built-ins — 50+ built-in functions including
substr,json_extract,datetime, and more - SQL Server built-ins — hovering a built-in function call (
DATEADD(,MEDIAN() shows the same signature as a card, with the return type and a description
Supported across all five relational engines: SQL Server, PostgreSQL, MySQL/MariaDB, Oracle, and SQLite. You can also trigger the popup manually with Cmd+Shift+Space (macOS) or Ctrl+Shift+Space (Windows/Linux) when the cursor is inside a function call.
Column Inlay Hints
When writing INSERT INTO ... VALUES (...) statements, Jam SQL Studio shows ghost column names before each value as inlay hints, so you don't have to mentally map column positions.
- With column list —
INSERT INTO table (a, b, c) VALUES (1, 2, 3)shows hints matching the listed columns - Without column list —
INSERT INTO table VALUES (1, 2, 3)resolves column order from the schema cache - Multiple tuples — hints appear for each row in multi-row INSERT statements
The names appear when you pause typing. To choose how they show, use Settings → Advanced → SQL autocomplete → Column names in INSERT … VALUES: Show, Show while holding Ctrl+Alt (Ctrl+Option on macOS), or Hide. The setting applies to every SQL editor, including notebook cells. On SQL Server, the table's columns are fetched as soon as you type its name, so the names and the column list at VALUES ( don't wait for the server.
Hover over * in SELECT * to see the columns it returns, with their data types, in the order your database returns them — grouped by table when the query reads more than one. A JOIN … USING or NATURAL JOIN column that both tables share is listed once, marked shared by both tables. The hover covers a * inside a CTE or subquery too, and lists only the tables of the query under the pointer; when a source's columns aren't known (a CTE, a derived table, a table not in the schema cache) no list is shown. The list is the one the Visual Query Editor's Choose columns writes.
Live Syntax Errors
Genuine syntax errors are underlined as you type on SQL Server, MySQL, Oracle, and SQLite — before you run the query. The check is deliberately conservative so valid SQL is never flagged: on SQL Server a span is marked only where two independent grammars both reject it; on MySQL, Oracle, and SQLite the engine grammar's verdict must be corroborated by an independent lexical check — a misspelled structural keyword (SELECT * FORM t, UPDATE t STE x = 1, INSERT … VAULES (…)), unbalanced parentheses, or a dangling operator (WHERE id = AND …). Squiggles never appear mid-keystroke on an unfinished statement, and fixing the error clears the squiggle. On SQL Server the message reads the way SQL Server reports the error, for example Incorrect syntax near 'SET'. or Incomplete statement. Toggle under Settings → Advanced → SQL autocomplete → Live syntax errors. (PostgreSQL syntax checking comes from its bundled language server.)
When the squiggle is a misspelled keyword, the message already names the keyword you meant — so it comes with a one-keystroke repair. Put the cursor on the squiggle and press Cmd+. (macOS) / Ctrl+. (Windows & Linux), or click Quick Fix… in the hover, and pick Change "FORM" to "FROM". The replacement follows your buffer's own casing, so a lowercase query gets from, not FROM.
Type-Mismatch Warnings
When a comparison can't work because of the types involved, Jam SQL Studio underlines it with a warning — before you run the query. The check is coercion-aware: it only flags mismatches that are genuinely a bug, so valid SQL is never marked.
- What it catches — a numeric column compared to non-numeric text, e.g.
WHERE total = 'free'. That raises a conversion error on PostgreSQL, SQL Server, and Oracle, and silently matches nothing on MySQL and SQLite. On PostgreSQL it additionally warns on a text column compared to a bare number (WHERE code = 5) — with a "Quote the number" quick-fix that rewrites it tocode = '5'— and a boolean column compared to a non-boolean string (WHERE enabled = 'maybe'). - What it leaves alone — numeric-looking strings such as
WHERE total = '50'coerce cleanly on every engine, so they are never flagged; nor are valid boolean strings like'yes'/'off'. - When it runs — only with a loaded schema for the connection; disconnected editors stay quiet. Only the editor on screen is checked: a tab in the background gets its warnings when you switch to it, and a long script is checked in small steps, so typing and clicking stay responsive while it runs. The message names the exact consequence on your engine.
Turn the warnings off under Settings → Advanced → SQL autocomplete → Type-mismatch warnings.
Type-on-Hover
Hover over a column reference to see its declared data type and coarse category, or over a completed function call (e.g. UPPER(name), my_total(id)) to see its inferred result type. It reads the loaded schema and composes with the engine's own hover, so you get column lists from the server and quick type read-outs from Jam in the same tooltip. Toggle it under Settings → Advanced → SQL autocomplete → Type-on-hover.
If any of the above ever misbehaves, three master switches under Settings → Advanced → SQL autocomplete → Safe mode turn off a whole feature category at once (the Enable IntelliSense switch above them turns off all three plus completion): Live diagnostics clears every squiggle (syntax errors, type-mismatch warnings, language-server markers), Hover & signature help disables every hover tooltip and signature-help popup, and Semantic completions skips the schema-aware resolver so autocomplete falls back to plain word-based suggestions.
Go to Definition, Find References, and Rename
The editor understands your schema well enough to jump to a definition, list every place an identifier is used, and safely rename it — familiar IDE code-navigation gestures, applied to SQL. Go to Definition is editor-cursor only; Find References and Rename also work from the Object Explorer's table/view context menu.
Go to Definition
Press F12 (or Cmd+Click / Ctrl+Click) on an identifier to jump to what it refers to. Holding Cmd / Ctrl while the mouse is over a name underlines it and shows where it leads; nothing opens until you click. Right-click → Peek Definition previews aliases and CTEs inline without moving your cursor; for tables/views, columns, and routines the peek shows a one-line description of the target, and opening that row (double-click or Enter) runs the same navigation as F12 and closes the peek. Go to Definition also works inside the stored-object previews that Peek References shows, and in the other SQL editors tied to a connection (the job step editor, the PL/SQL editor and debugger, and the schema and data compare script previews), where names resolve against that editor's own connection.
- Table or view — reveals and selects the object in the Object Explorer.
- Alias (the
uinWHERE u.id = 1) — jumps to its declaration in theFROM/JOINclause, inline in the same buffer. - CTE reference (
FROM recent_orders) — jumps to the matchingWITH recent_orders AS (…)body, inline in the same buffer. - Column qualified by an alias or table (
u.email,users.email) — for a table column, opens Table Designer with that column focused; for a view column, opens the view's CREATE script in a new query tab. Bare, unqualified column names aren't resolved. - Procedure or function call — opens its CREATE script in a new query tab. On engines that allow overloaded routine names (PostgreSQL, Oracle), landing on 2+ matches opens a picker to choose which one.
The name a statement defines is the definition itself, so F12 and Cmd+Click / Ctrl+Click do nothing there and the name isn't underlined: p in CREATE PROCEDURE dbo.p, a view in its own CREATE VIEW, a table in its own CREATE TABLE. SQL Server's ALTER PROCEDURE, ALTER FUNCTION, ALTER VIEW and ALTER TRIGGER and MySQL's ALTER VIEW restate the whole definition and count the same way; any other ALTER, such as ALTER TABLE, still navigates to the object it changes.
WITH declaration without leaving the buffer; aliases behave the same way, while for tables/views, columns, and routines the peek lists the target and opening its row runs F12's navigation.Find References
Press Shift+F12 on a column, table/view name, or routine call — or right-click → Peek References / Go to References — to open the inline peek panel listing every object that uses it. Each referencing view, scalar function, inline table-valued function, stored procedure, trigger, or constraint appears as its own entry, and selecting one previews that object's stored body right inside the peek with the reference highlighted. Occurrences in the query tab you're editing are listed alongside them (from the buffer's SELECT statements — hits inside INSERT/UPDATE/DELETE statements aren't indexed yet).
The previewed body is read-only — it's the definition as the database currently stores it, not an editable buffer. Double-click a row (or press Enter) to load that object's CREATE script into a new query tab, scrolled to the reference; edit and run it from there if you want to change the object. On SQL Server the script ends with a GO line, and on PostgreSQL and SQLite with a ;, so a query you type below it runs on its own (see How a script ends).
For a wider audit that stays open while you work, right-click in the editor and pick Find All References in Tab. That opens a dedicated References tab grouping hits per referencing object with a code snippet per row. It includes objects the peek can't preview because the engine exposes no DDL text for them, and — unlike the peek — it lists only what the database stores, so occurrences in the query tab you're editing aren't included until you run the statement that creates them. Running it again on the same identifier in the same database reuses the existing tab instead of piling up new ones; the same identifier in another database opens its own tab, because a tab shows the database named in its header. The Object Explorer's Find references… entries open the same tab.
References are searched in the database the object belongs to: the Object Explorer node's database, the database a fully qualified name in the editor spells out (MandTob.dbo.ARD is searched in MandTob even from a tab on another database), or otherwise the query tab's current database. On a SQL Server or PostgreSQL connection each database gets its own identifier index the first time you search it, so you can search any of them without changing the connection's default database. While a database is indexed for the first time the References tab shows a searching state; later searches on that database reuse the index. If the index can't be built at all, the tab says so instead of reporting no references — on a live connection an empty References tab means nothing referenced the identifier, never that nothing was searched (Peek References, and a tab whose connection dropped mid-search, answer from what they have). On MySQL and Oracle, where a connection sees every schema the login can reach, one index covers the connection and references from other schemas are listed as well; a SQLite connection is a single file and works the same way.
On SQL Server, object names are compared using each database's own collation. In a case-sensitive database dbo.V and dbo.v are two different views, and Find References, Rename and the automatic index refresh after DDL keep them apart; in the usual case-insensitive database they are one view, as before. On MySQL the same follows the server's lower_case_table_names setting: when it is 0 (the Linux default), Users and users are two tables and Find References keeps them apart, whether a view spells the name backticked or bare; when it is 1 or 2 they are one table.
Find References also looks inside stored procedure and trigger bodies on SQL Server, PostgreSQL, MySQL, and Oracle — not just views, scalar functions, and inline table-valued functions. A bare, unqualified reference inside a procedural body (for example WHERE user_id = p_user_id) is only captured when its FROM scope contains exactly one relation; ambiguous bare names in a multi-table join are honestly skipped rather than risk a false-positive hit. On PostgreSQL this covers SQL-language functions; PL/pgSQL function bodies aren't indexed yet. SQLite has no stored procedures, and although it does have triggers their bodies aren't part of this index either, so procedural-body coverage doesn't apply there.
Find References on a function or procedure matches its calls however a body spells them: a schema-qualified dbo.fn() and a bare fn() are the same routine when the bare call resolves to that schema (dbo on SQL Server, public on PostgreSQL, the current database on MySQL, your own schema on Oracle), and a call to a same-named routine in another schema or database is not listed.
Rename Symbol
Press F2 to open Monaco's inline rename box. One key, two outcomes, decided by what the cursor names.
Renaming something that only exists in the buffer
On a table alias (the o in FROM orders o), a derived-table alias, or a CTE name, submitting a new name rewrites every scope-correct occurrence in the buffer straight away — no dialog, no database round-trip, and a single Ctrl+Z puts it all back. Occurrences come from the SQL parser, not a text search: an alias called o never touches the o inside orders or inside a string literal, an inner subquery that reuses the same alias name keeps its own binding, and a second statement in the same tab is left alone. Renaming a recursive CTE updates its declaration, its self-reference inside the body, and every later reference together. If the new name is already taken by another alias, CTE, or table visible in that statement, the rename is refused with an explanation instead of silently producing ambiguous SQL.
Renaming a database object
On a column, table, or view, submitting a new name opens the Rename preview dialog, showing every per-object ALTER the rename would run — nothing changes in the database until you click Apply. Routines aren't renamable this way. Inside a dependent view or routine body a column rename replaces only the column itself and keeps its alias or table qualifier and its quoting: u.id becomes u.user_id, [u].[id] becomes [u].[user_id]. A reference the index could not attribute to the renamed table with certainty — an unqualified column in a multi-table query, or a FROM name without a schema — is counted as ambiguous and left out of the rewrite until you tick the preview's include-ambiguous option, so the preview never rewrites a same-named column of another table unasked. When the name under the cursor points at another database — B.dbo.users typed in a tab connected to A — a line under the preview's header names the database the rename will run in, because that is where the ALTERs execute.
MySQL rename scripts preserve backslashes, quotes, and Unicode in dependent CHECK definitions and constraint names. The CHECK expression itself must be supported by your server and its current SQL mode.
Once the rename is applied, open query tabs on the same connection and database are updated too: references to the renamed object are rewritten in place and a banner tells you how many changed, with Ctrl+Z in that tab restoring the buffer. Aliases keep their own names — renaming orders turns FROM orders o into FROM sales_orders o and leaves every o.total as it was. A tab bound to another database is updated only where it spells the renamed object's database explicitly (Sales.dbo.users in a tab connected to Hr on SQL Server, sales.users on MySQL) — a bare dbo.users there is left alone, since it names that tab's own database. Column renames never reach tabs on another database. A tab whose references can't be resolved with certainty gets a warning banner rather than a silent edit. Query history is never rewritten.
From the Object Explorer
Right-click a table, view or routine in the Object Explorer for the same Find references… action available in the editor; tables and views also offer Rename… there. Column nodes offer neither — column find-references and rename are both editor-only (Shift+F12 and F2).
Go to Definition and Rename work across SQL Server, PostgreSQL, MySQL, Oracle, and SQLite; Find References' procedural-body coverage is SQL Server, PostgreSQL, MySQL, and Oracle. See Keyboard Shortcuts for the full key list.
Compact DDL Editor
When the cursor sits inside a top-level DDL statement, a pencil Edit affordance appears next to it. Click it to open the Compact DDL editor — the entry point to the Visual DDL Editor. For CREATE TABLE / ALTER TABLE it opens a mini structure editor with Columns / Constraints / Indexes / Storage tabs; for every other supported kind (views, sequences, types, schemas, triggers, routines, security objects, databases) it opens directly into that kind's edit form. Submitting a form writes changes back into the buffer byte-for-byte, preserving whitespace, comments, and identifier quoting. The Compact DDL editor and the Visual Query Editor's compact popover (which opens on DML cursors) are mutually exclusive: only the one that matches the cursor's statement kind opens.
The Compact DDL editor opens the Visual DDL Editor for any CREATE / ALTER / DROP statement — tables, views, materialized views, sequences, types/domains, schemas, triggers, procedures/functions, logins/users/roles, GRANT/REVOKE, and databases. It mutates the buffer only — it never executes the resulting DDL on its own. Run the buffer with Execute (F5 or Cmd/Ctrl+Enter) when you are ready. Editing works without a live database connection; only connection-dependent affordances (Design Table, dependency lookups) disable individually with a reason tooltip. See the Visual DDL Editor guide for the full per-object breakdown, source-preserving guarantee, preview dialog, dependency checks before a drop, and engine-support matrix.
Executing Queries
Oracle stored programs retain their local procedures and functions as one execution unit. Execution errors use the original editor position, including leading blank lines in SQL Server batches and Unicode text before Oracle errors, when the database reports a location.
Run your queries and view results with multiple execution options.
Basic Execution
- Write your SQL query in the editor
- Press
F5, or click the Execute button in the toolbar.Cmd/Ctrl+EnterorShift+Enterruns only the statement under the cursor - View results in the grid below the editor
USE switches the tab's database. On SQL Server and MySQL, when a run contains USE, the database picker moves to the database the server reports once the run finishes, Messages shows This tab now runs in <database>., and the tab's next run runs there. On Oracle the picker selects a schema, so ALTER SESSION SET CURRENT_SCHEMA does the same. The picker stays where it was when the USE failed or you stopped the run. It also follows inside an open transaction, in Auto, Manual and Smart mode, and the transaction stays open. On SQL Server a USE anywhere in the script counts, also on a new line without a ; or inside IF / BEGIN … END, and a database name that differs only in letter case is the same database: the picker takes the server's spelling without a message. Results of a run that switched databases can't be edited (see Which database a Save writes to).
Other session settings a run changes — SET, ALTER SESSION, SET ROLE, a temporary table — are reset when the run finishes, so they do not carry into the tab's next run or into any other tab. The first time that happens in a tab, Messages says so. Use Manual transaction mode or a SQL Notebook to keep settings across runs. While a statement you ran leaves a transaction open, the tab keeps its connection and its settings until that transaction ends (see A transaction a statement left open).
Destructive-statement confirmation
Some statements are held back by a confirmation dialog before they run. It names the connection and database they would hit, shows the statement, and explains what it does; Cancel leaves the query in the tab without executing it.
What triggers it:
DROP TABLE/DATABASE/SCHEMA/INDEX,TRUNCATE TABLE(on PostgreSQL and MySQL, whereTABLEis optional, alsoTRUNCATE orders),ALTER TABLE … TRUNCATE PARTITIONon MySQL and Oracle, Oracle’sTRUNCATE CLUSTER, andALTER TABLE … DROP(a column, a constraint or a partition, also whenDROPis on a later line) — plus each engine's own equivalents (DROP TABLESPACEandSHUTDOWNon Oracle,LOAD DATA INFILEon MySQL, and so on).DELETEorUPDATEwith noWHEREclause, which affects every row in the table.DROP VIEW/PROCEDURE/FUNCTION/TRIGGER— a milder warning, since these destroy code rather than rows. The dialog names the kind of object the script actually drops (“Confirm Stored Procedure Drop”, “Confirm View Drop”), and lists all of them when a script drops more than one kind.- System-level commands such as
sp_configure,xp_cmdshell, orDBCC SHRINK. - A column change that would destroy stored data — see below.
- Any statement an AI agent wrote on the execute-with-confirm path, held to a stricter standard (see AI Integrations & MCP).
Column changes. A plain ALTER … COLUMN does not raise the dialog on its own — most column changes (widening a varchar, adding decimal places, relaxing NOT NULL) are harmless, and a prompt on all of them would be noise. What does raise it is a script generated by Schema Compare or Database Blueprint in which a column loses precision it currently holds — decimal(10,4) to decimal(10,2), datetime2(7) to datetime2(3), a numeric column to an integer type. SQL Server, PostgreSQL and MySQL all accept those without any error: every stored value is rounded in place, and widening the column again does not bring the digits back. The comparison knows the column's before and after shapes, so it marks exactly those statements with a -- [REVIEW] [DATA LOSS] line, and that line is what the dialog reacts to. Deleting the line from the script also removes the confirmation.
Statements inside a routine body (CREATE OR ALTER PROCEDURE … BEGIN DELETE FROM … END) never trigger the dialog: submitting the routine changes no rows, only calling it later does. On MySQL this includes a body with no BEGIN that is an IF, REPEAT, LOOP, WHILE or CASE statement (CREATE PROCEDURE p() IF … THEN DELETE FROM t; END IF), a trigger body after FOLLOWS or PRECEDES, and the statement of a DECLARE … HANDLER; such a definition also runs as one statement.
Temporary tables. Dropping, truncating or altering a table that only your session can see does not raise the dialog, so a script that drops and re-creates its temp tables can be run again without a prompt each time. That covers SQL Server local temp tables (#orders, tempdb..#orders), PostgreSQL tables named with the pg_temp schema (pg_temp.orders), SQLite temp.orders, and on MySQL and SQLite a table created earlier in the same script with CREATE TEMPORARY TABLE or CREATE TEMP TABLE. On Oracle it covers dropping or truncating a private temporary table the same script created with CREATE PRIVATE TEMPORARY TABLE … ON COMMIT PRESERVE DEFINITION; an ORA$PTT_ name alone still asks, because the prefix is a database setting and a permanent table can carry it.
On PostgreSQL, write pg_temp.orders in the statements that drop, truncate or alter the table: a plain DROP TABLE orders asks even right after CREATE TEMP TABLE orders, because a search_path that lists pg_temp after public (a role or database setting) makes it drop public.orders. Only a CREATE the script itself runs counts: one under EXPLAIN or inside a procedural block does not, and a rollback, a rename, a CALL or an EXECUTE in between makes the later drops ask. So does any SQLite PRAGMA temp_store or temp_store_directory (changing it deletes every temporary table) and an Oracle ALTER SESSION SET CURRENT_SCHEMA (the name then points at another schema). Temp tables that other sessions can see still ask: SQL Server ##global tables and Oracle global temporary tables. So does a statement that also names a real table.
Comments are skipped, by your engine's rules. Only statements the engine will run are examined. A destructive verb that appears only in a comment — a banner above a procedure, a runbook note, Jam's own [REVIEW] lines — does not raise the dialog, and neither does punctuation in one: a lone apostrophe in a comment above a procedure (-- Agrega un tag a una noticia del d'ía) no longer makes the whole script read as unparseable. Which text counts as a comment follows the connected engine rather than a lowest common denominator: MySQL's # line comments are comments, and MySQL's rule that -- must be followed by a space is respected, so SELECT 1--1 is read as arithmetic there and anything after it on the line is still checked. MySQL's version-gated /*!50000 … */ is the deliberate exception: the server executes it, so Jam scans it too.
The tip at the bottom of the dialog matches the reason it opened: adding a WHERE clause is only suggested for the missing-WHERE case, and a structural (DDL) script gets advice about backups and reading the statements instead.
Execute Selection
To run only part of your query, select the SQL text you want to execute. When the selection qualifies (see below), the toolbar Execute button morphs into Selection — the icon and label change in place, with a subtle pulse, without the button changing size — and clicking it runs only the selected SQL. Pressing F5, Cmd/Ctrl+Enter or Shift+Enter does the same while such a selection is active.
When the button switches to Selection:
- Your selection must parse as a complete, runnable statement — it starts with a known SQL keyword (
SELECT,WITH,INSERT,UPDATE,DELETE,CREATE,EXEC,PRAGMA, etc.). Fragments likeFROM users, typos likeelect *, or selections ending with a trailing comma do not qualify. On SQL Server a selection that starts withFROMqualifies when it is a FROM-first query with aSELECT(FROM users SELECT name), and on Fabric Data Warehouse also without one (see Fabric Warehouse T-SQL syntax). - Your selection must not cover the full editor content — if it does, the toolbar Execute already does the same thing.
Prefer a floating button next to the selection instead? Turn on Inline Execute / Peek bar in the query toolbar's Options menu. A floating action bar then appears above (or below) the selection — click its Execute to run only the selected SQL, and for safe read-only statements (e.g. SELECT, WITH) use its Peek button to preview the selection inline without disturbing your main results. The same runnable-statement rules decide when the floating Execute shows (for a selection covering the full editor content it's hidden as redundant, though Peek stays available since inline preview is a distinct action; when neither qualifies, the whole bar stays hidden). The toolbar Execute button keeps its Selection behaviour while this bar is on — the floating bar is an extra surface next to the selection, not a replacement — so Shift+F5 stays the way to run the entire editor content. The floating Execute intentionally skips Format on execute so your selection isn't lost during formatting.
Note: F5 runs the narrowest available scope — the runnable selection if there is one, else the statement under the cursor, else the entire editor content. Cmd/Ctrl+Enter and Shift+Enter run the current statement, never the entire editor content of a multi-statement script (see Execute Current Statement). Shift+F5 always runs the entire editor content.
Execute Current Statement
Press Cmd/Ctrl+Enter or Shift+Enter to execute the statement at the cursor. This command differs from F5: any non-empty selection wins, the selected or current statement is sent without a completeness check, and a cursor on a blank line uses the nearest statement above it. If the editor is empty, Jam SQL Studio runs nothing and shows No statement to execute. in the status bar.
Inside the Query Editor, Cmd/Ctrl+Enter replaces Monaco's Insert Line Below command. Shift+Enter replaces newline insertion and alternative-suggestion acceptance; use plain Enter to insert a newline.
Execution Plan Options
Analyze query performance by capturing execution plans:
- Execute with Estimated Plan - Shows the query plan without running the query
- Execute with Actual Plan - Runs the query and shows the actual execution statistics
Cancelling Queries
To cancel a long-running query, click the Stop button in the toolbar.
The first Stop asks the server to cancel the statement, and the button changes to Stopping…. It stays clickable: if the server hasn't honoured the cancel, click Stop again to force the stop. On Oracle that drops the connection the statement was running on, so the query comes back as cancelled straight away — which is what makes Stop work on a statement queued behind another session's lock, where Oracle never sees an ordinary cancel at all. The other engines keep their normal cancel, so a second click there changes nothing. The same two-press behaviour applies to the Stop button on the status line above the results grid, and to the Stop button on Table Explorer's pagination strip.
One thing to know about the forced stop: it ends the wait at Jam SQL Studio's end, not on the server. Dropping the connection does not cancel what the database is already doing — the session stays in its wait until that wait ends on its own (when the lock frees, or when a SLEEP runs out), and a statement Oracle has already accepted and auto-committed then completes, because a dropped connection cannot retract it. So a forced Stop on an UPDATE queued behind a lock can still leave the row updated. Use the Session Browser to see what the server is really running and to kill a session outright if you need to.
Disconnecting the connection cancels its running queries too — the same forced stop, sent to every query and Table Explorer fetch the connection has in flight — so a disconnect does not sit behind work you have walked away from. A transaction a tab holds open on that connection is ended too, and the database rolls it back. One thing it does not cover: long-running app operations like a Schema Compare or a data copy, which carry their own Cancel. See Disconnecting.
Long-Running Query Affordances
When a query has been running for more than 8 seconds, two subtle cues appear — neither shifts the toolbar:
- The execution-time timer in the bottom status bar turns amber and pulses gently once per second so you can see at a glance that the query has crossed the threshold.
- The “Executing query…” indicator above the results grid changes to “Executing query… taking longer” (amber) and exposes a one-click Stop button.
The toolbar Stop button is always available during execution if you'd rather cancel from there.
Query Timeout
The default query execution timeout is 5 minutes. You can change it in Settings > Query Execution — set a longer value for heavy maintenance scripts, or a shorter one if you want runaway queries to fail fast. A value of 0 disables the timeout entirely.
For SQL Server, multi-batch scripts (separated by GO) execute each batch independently and the configured timeout applies to each batch, not to the whole script — a long maintenance script split into many short batches will not be killed even if its total wall-clock time exceeds the timeout.
The same setting governs transaction-mode (BEGIN TRANSACTION) tabs, Table Explorer browsing and editing, and estimated-plan capture. A query that exceeds the timeout fails with a clear timeout message (and a tip pointing back to the setting); a connection that drops mid-query is reported as a connection failure with a reconnect banner instead.
Peek Results
Select a SQL query in the editor and a floating Peek results button appears above the selection. Click it to preview results inline without replacing your main result set.
- Results appear in a compact inline panel below the selection (max 50 rows)
- An automatic row limit is added to keep previews fast (TOP 50 for SQL Server, LIMIT 50 for others)
- Peek results do not affect your main results or query history
- Click Open in results to run the full query in the main editor
- Peek is not offered for a FROM-first query (
FROM t SELECT …); run it with Execute
Working with Results
Query results appear in a tabbed grid below the editor with powerful viewing and export options.
Multiple Result Sets
When your query returns multiple result sets (e.g., multiple SELECT statements), each appears in its own tab. You can also switch to a stacked view to see all results vertically.
On Oracle, an anonymous PL/SQL block returns result sets the way SQL*Plus does: every OPEN :cursor FOR SELECT … into a bind variable (no VARIABLE declaration needed) and every DBMS_SQL.RETURN_RESULT implicit result becomes its own result tab, in order, streamed like any other query.
Collapsing the Results Pane
When you're writing or reviewing long SQL, you can hide the results pane to give the editor the full height. Click the chevron button on the right side of the results tab bar (next to the zoom controls), press Cmd+J / Ctrl+J, or run Toggle Results Pane from the Command Palette (Cmd+Shift+P / Ctrl+Shift+P).
To restore, use any of the same actions, or just click one of the tab labels (Results / Messages / Plan / Chart) — Jam SQL Studio reopens the pane and switches to the clicked tab. Dragging the resizer also restores the pane. Each query tab remembers its own collapsed state while it is open.
Messages and Output
When a query fails, Jam classifies the error and adds a short tip under the message for common causes (object not found, missing permission, lock contention, type-conversion issues). Where the next step exists in the app, the tip also carries a one-click action: Switch database… opens the database selector when a table, view or procedure isn't found in the current database, and Find the blocking session opens the Session Browser when a query is waiting on a lock. An unknown column or table alias (for example SQL Server's Invalid column name, MySQL's Unknown column or Oracle's ORA-00904) gets a tip about the column name instead, without the database action, because the table itself was found.
When a table, view, column or table alias isn't found, the tip suggests the closest existing names instead: Did you mean Customers?, or up to three, as in Did you mean one of: customer, customers? The names come from the schema IntelliSense has already loaded for the tab's connection and database, so no extra query runs. A column is matched against the columns of the tables the statement reads (only the aliased table's columns for o.Custmer), a misspelled alias gets the aliases in the query, and a table that exists under the same name in another schema is suggested with its schema. A column read through a derived table's or a CTE's alias gets the column tip and no suggestion, because the loaded schema does not list those columns. When there is one best match and the misspelled name appears once in the query (a table name: once after FROM, JOIN, INTO, UPDATE or TABLE or later in the FROM list, also after a derived table, PostgreSQL's and Oracle's ONLY included, and not inside a SELECT item such as (customers); a keyword inside a string, such as 'FROM', does not count), Replace with … writes it into the editor as a single undo step, in quotes where the engine needs them (a reserved word such as order); it does not run the query. Replace works until you edit the query; after an edit, run it again. An edit you undo doesn't count. With Format on execute on, a run of the whole editor shows the suggestion without Replace, because the formatting changes the text after the query starts. It also works when you ran one statement of a script (Ctrl/Cmd+Enter or a selection), with or without semicolons. It isn't offered for SQL that an AI agent or the Visual view ran. Schema names are compared the way the engine compares them: on PostgreSQL and Oracle a quoted "Sales" is not sales. When the table exists, in the schema the query names, only in another database whose schema is loaded, Switch to <database> switches the tab to that database. With no close match, the tip stays as described above. If the query ran while IntelliSense was still loading the schema, for example right after you opened the tab, the error shows at once and the tip line changes to the suggestion when the tables and columns it needs have loaded, up to 5 seconds later; after that, or when no schema is loading, the tip stays as described above. Suggestions work on SQL Server, PostgreSQL, MySQL, Oracle and SQLite; Oracle names the missing table only from 23ai on, and Azure Data Explorer gets none, because its schema lives only in the KQL editor.
Three common query mistakes also get a tip on every SQL engine:
- Ambiguous column — a column name that two of the query's tables share (SQL Server's Ambiguous column name, PostgreSQL's column reference … is ambiguous, Oracle's
ORA-00918). The tip says to qualify the column with its table name or alias. - GROUP BY — a selected column that is neither in
GROUP BYnor inside an aggregate such asCOUNT()orMAX(), or an aggregate used inWHERE. The tip states the rule and points toHAVINGfor conditions on an aggregate. - Name already exists — a
CREATEof a table, view, index or other object whose name is taken. The tip gives the engine's own way to run it again:CREATE OR ALTERorDROP … IF EXISTSon SQL Server,CREATE … IF NOT EXISTSon PostgreSQL, MySQL and SQLite,CREATE OR REPLACEfor views and code on Oracle.
When a syntax error or an unknown function comes from another SQL dialect, the tip says what the current engine uses instead, for example LIMIT isn't SQL Server syntax — use SELECT TOP (n) …, or ORDER BY … OFFSET 0 ROWS FETCH NEXT n ROWS ONLY. Jam reads the token from the server's error message where the engine names one, and otherwise looks at the statement that failed; text inside strings (Oracle q'[…]' literals included) and comments is ignored, and so are the script's other statements. On SQL Server, a batch whose statements are not separated by semicolons is read as a whole, the way SQL Server compiles it. When a script's error does not say which statement failed, only the server's message is read. The recognised patterns are:
- SQL Server —
LIMIT, backtick quotes,ILIKE,::casts,RETURNING, and the functionsIFNULL,NVL,NOW()andLENGTH. - PostgreSQL —
TOP n,[name]and backtick quotes, aGOline, and the functionsGETDATE(),ISNULL(a, b),IFNULL,NVLandLEN. - MySQL —
TOP n,[name]quotes,::casts,FULL OUTER JOIN,ILIKE,RETURNING, aGOline, and the functionsGETDATE(),ISNULL(a, b),NVLandLEN. - Oracle —
LIMIT nandTOP n(useFETCH FIRST n ROWS ONLY), backtick and[name]quotes,ASbefore a table alias,ILIKE, aGOline, aSELECTwithoutFROMon servers before 23ai, and the functionsGETDATE(),NOW(),ISNULL,IFNULLandLEN. - SQLite —
TOP n,ILIKE,::casts, aGOline, and the functionsGETDATE(),NOW(),ISNULL(a, b),NVLandLEN.
Other syntax errors get no tip. An unknown function from this list gets its tip in place of the not-found tip or a Did you mean …? suggestion, unless the database has a function or procedure of that name (from the schema IntelliSense has loaded); on PostgreSQL the call must also have the other dialect's number of arguments, so your own getdate(1) gets no tip.
The bottom pane always shows a Messages tab with status messages, errors, warnings, and row-count notes. When your script also emits user PRINT statements alongside multiple result sets, an extra Output tab appears in the result-set tab strip, to the left of Result 1. Activating it shows an interleaved view of the script: each PRINT line appears at its script position, with clickable [Result N] references where each result set landed — clicking a reference jumps to that result-set tab. In Stacked view, the Output content collapses to a 3-line preview at the top of the stack; expand it to see the full interleaved output.
Rows returned and rows affected
Each successful run adds one summary line to Messages. A script whose INSERT, UPDATE, DELETE or MERGE statements changed rows reports their total there — Query executed successfully. 5 rows affected in 00:00:01. — summed across every statement and every GO batch, and a statement that matched nothing counts as 0. A script that also returns rows reports both, for example 20 rows returned, 5 rows affected. When nothing was returned, the row counter in the status bar shows the affected total instead of 0 rows. Each statement's own count stays in Messages as a separate N row(s) affected line. This works the same in Manual and Smart transaction tabs. On SQL Server, the rows a SELECT returns are not counted as affected, even though the server reports a count for them. The one exception is a SQL Server connection over named pipes or shared memory: there, a script that mixes SELECT with data changes reports only the rows returned.
Where PRINT output lands
Text a script prints alongside its rows appears in Messages as an Info row. Messages lists the newest line first, so a script's output reads bottom-to-top there; the Output view under Results keeps the order the server produced it in, which is why that is the one to read a long script in.
What each engine reports:
- SQL Server —
PRINT, andRAISERRORwith a severity of 10 or lower. Higher severities are errors and appear as such. - PostgreSQL —
RAISE NOTICEandRAISE INFO, plus the server's own notices (for example table … does not exist, skipping).RAISE WARNINGappears as a Warning row in Messages; warnings alone do not open the Output view, which keys on Info rows. - Oracle —
DBMS_OUTPUTfrom an anonymousBEGIN/DECLAREblock, one Info row per line. Output from a stored procedure called on its own (CALL my_proc()) is not captured; wrap the call in a block —BEGIN my_proc; END;— to see it.
A script with no result sets — PRINT ('Hello'); on its own — opens Messages and shows the same lines under Results as a plain Output view. The strip Output tab described above is for scripts that return several result sets, where the lines have to be placed between them.
On SQL Server and PostgreSQL, output a script produced before a statement failed is kept rather than replaced by the error — a procedure that prints its progress and then raises an error still tells you how far it got. In the Output view it reads above the error; in Messages, which is newest-first, it reads below it. Oracle is the exception: DBMS_OUTPUT is read back only once the block finishes, so a block that raises loses what it printed.
The same output reaches tabs running in a transaction, and AI agents can read it over MCP with query_get_messages. SQL Notebook cells show it on SQL Server and PostgreSQL; an Oracle notebook cell does not capture DBMS_OUTPUT yet.
MySQL, SQLite and Kusto show nothing here. SQLite and Kusto have no server-side equivalent at all; MySQL does — SIGNAL SQLSTATE '01000' raises a warning — but the server only reports it in answer to a separate SHOW WARNINGS, which Jam SQL Studio does not issue.
Grid Features
- Column sorting - Click column headers to sort
- Column resizing - Drag column borders to resize
- Duplicate column names - When multiple columns share the same name (e.g.,
SELECT *with JOINs), Jam shows each column separately and displays the source table above the column name (including inside a Manual or Smart transaction) - Copy as CSV - Copy the active result set to your clipboard from the results toolbar
- Row side panel - Select a row and open the side panel (or double-click a row) to view values in a vertical layout (drag the divider to resize). When results include columns from multiple tables, Jam shows the source table next to each field.
- Edit results (UPDATE) - Toggle edit mode (pencil icon) to update editable cells inline (requires a primary key in the result)
- JSON viewer - Click JSON cells to view formatted JSON in a dialog (with a Copy button). If the value is not valid JSON, the dialog shows an error and the raw value as text.
- Expanded text viewer - Cells with multiple lines (newlines) show an expand icon to open the value in a read-only dialog (with a Copy button and JSON/Text mode tabs)
- NULL indicators - NULL values shown with distinct styling
- PostgreSQL array columns - An array result column reports its type as
int4[],varchar(20)[]and so on (the Type row of the column profile tooltip shows it), so Add to WHERE on an array cell writes contains, as Table Explorer does - Numeric alignment - Numeric columns right-align and display with thousands separators (e.g.
1,234,567) for readability. Identifier-like numeric columns — primary keys, foreign keys, and columns named like an ID, code, or year — stay ungrouped since they're not quantities, whichever separator style is selected. Pick that style in Settings → UI → Behavior → Thousands separators in results: Locale (1,234,567) is the default, Thin space (1 234 567) groups digits with a narrow space and keeps the.decimal point as stored, and Off (1234567) shows the raw value. Right-clicking any numeric cell offers the same three choices under Number display — the submenu appears on identifier columns too, though picking a style there leaves them ungrouped. The setting is global and applies to the Query Editor results grid and the Table Explorer grid together. This is display-only: copy, export, and edit always use the exact underlying value. - Date and time display - Date and time columns show the stored value as
2019-07-19 18:04:16.930: adatecolumn shows the date alone, atimecolumn the time of day, and an OracleDATE(which holds a time to the second) the date and time without milliseconds. Types that store a time zone (datetimeoffset,timestamptz,TIMESTAMP WITH TIME ZONE) add the offset; the drivers return these as UTC, so the offset shows+00:00. Pick the format in Settings → UI → Behavior → Date and time in results: SQL (2019-07-19 18:04:16.930) is the default, ISO 8601 shows2019-07-19T18:04:16.930, and System format uses your operating system's date and time format. Right-clicking a date or time cell offers the same choices under Date and time display. The setting applies to the Query Editor results grid (including the stack and text views) and the Table Explorer grid. Copying cells and the CSV and Markdown exports write the text the grid shows; the Excel export writes date cells. SQLite columns, which store dates as text, show the stored text.
Cell Selection and Aggregates
Select cells in the results grid to see instant aggregate statistics in a status bar at the bottom, similar to Excel's status bar.
- Click a cell to select it
- Shift+Click to select a rectangular range of cells
- Cmd+Click / Ctrl+Click to add individual cells to the selection
- Click+Drag across cells to select a range
The aggregate bar shows Count for all selected cells. When numeric cells are selected, it also shows Sum, Avg, Min, and Max.
Press Cmd+C / Ctrl+C to copy selected cell values to the clipboard as tab-separated text (paste-friendly into Excel and Google Sheets). Right-click and choose Copy value to do the same from the context menu.
Save a binary value to a file
The grid shows a binary value as 0x and its hex digits (the first 256 bytes), and Copy value, Copy and Export write the whole value that way. SQL Server results show [binary N bytes] instead, except in a SQL Notebook, a tab with an open transaction, and on connections that run through SQL Tools Service, which show the 0x hex.
Right-click a cell that holds binary data and choose Save value to file… to write the value to disk exactly as it is stored — a PDF, an image or any other file kept in a binary column. The item appears on non-NULL cells of SQL Server varbinary, binary and image columns, PostgreSQL bytea, MySQL BLOB and VARBINARY, Oracle BLOB, RAW and LONG RAW, and SQLite BLOB. Kusto has no binary column type.
- The grid shows a binary value as
[binary N bytes]or a shortened hex preview, so the app reads the full value from the database again, by the row's primary key. The result must include every column of the table's primary key — the same rule as editing results. When the row cannot be read again this way (no primary key in the result, a self-join, the cases below), the value the grid holds is saved as the query returned it: PostgreSQL, MySQL, Oracle and SQLite grids hold the whole value. SQL Server Query Editor cells hold only[binary N bytes], so there the item is disabled and its tooltip says why, for example to include the primary key; in a SQL Notebook or a tab with an open transaction SQL Server cells hold the value too. - A computed column such as
DECOMPRESS(DocumentBlob)orCAST(… AS varbinary(max))names no table row to read again, so its value is saved as the query returned it, with or without the primary key in the result. On SQL Server, where the cell shows only[binary N bytes], the app keeps a computed column's values while the query runs: up to 100 MB each and 128 MB across the most recent results. When a value was not kept, or is no longer kept, the save says so; run the query again, for fewer rows if needed. Results too large for the grid to hold (more than 50,000 rows, or about 20 MB) do not keep these values, and the item's tooltip asks for fewer rows. The save dialog suggests<column>-row<N>. - When the result reads the same table twice (a self-join), the key in the row may belong to the other side. The item is disabled and says so when the two sides' key columns differ in that row, and on SQL Server, MySQL and Oracle whenever the database reports the table twice — unless the cell holds its whole value, which is then saved as the query returned it. A table that appears a second time only inside a
WHEREsubquery (IN (SELECT …),EXISTS (SELECT …)) does not count: those rows cannot become result columns. Select the value's own key column, or open the table in Table Explorer. - On SQL Server, a column of a table in another database (
SELECT … FROM OtherDb.dbo.Files) cannot be read again from the tab's database, so the item is disabled there; save the value from Table Explorer on that database. A key column read from another database's table of the same name does not count as this table's key. A column of a temporary table (#files) cannot be read again at all, and the item says so. The same goes for a table read through a linked server (SELECT … FROM Remote.AppDb.dbo.Files): the tab's connection would find the local table of that name, so the item is disabled and its tooltip says so. - The value read again must be the one the cell shows. When it is not — the row changed since the query ran, the result does not say which row the value came from (a self-join on PostgreSQL or SQLite), or the row's primary key matches more than one row (SQLite allows several
NULLs in a primary key that is not anINTEGERone) — nothing is saved and a message says why. Run the query again, or save the value from Table Explorer. This also holds for large results, whose grid keeps only[binary N bytes]or the first bytes of each value: the app records a fingerprint of every value as the result loads and checks the value read against it. On SQLite, text spelled like hex ('0x4142') and binary data with those bytes count as different values, and a cell the query read as such text has nothing binary to save: the item is disabled and its tooltip says the value is text. - The value is read from the database the query ran in, also after you pick another database for the tab with the database picker.
- A primary key that is itself binary works when the grid holds it in full (PostgreSQL, MySQL, SQLite). SQL Server shows a binary key only as
[binary N bytes], so the item is disabled there; Table Explorer's item is disabled for the same reason. - The save dialog suggests
<table>-<column>-<key>with an extension that matches the content when its first bytes identify it (.pdf,.png,.jpg,.gif,.zip), otherwise.bin. You can change the name and the type in the dialog. - In a tab with an open transaction the value is read inside that transaction, so you save what the tab sees. In a SQL Notebook the value is read on the notebook's own session, so a change a cell left uncommitted is what you save; a cell you run while the value is read is refused with a message rather than queued behind the read, so run it again when the read finishes. A read that fails there does not affect the transaction: on PostgreSQL, where a failed statement would end the transaction, the read runs under a savepoint, so you can still commit your other changes.
- On SQL Server connections that run through SQL Tools Service (Windows, a local instance reached over shared memory or named pipes), Query Editor results don't say which table and primary key a column comes from, so the value is saved as the result holds it, computed columns included; the save dialog suggests
<column>-row<N>. The grid shows a shortened hex preview there, and the app reads the whole value from the result before it writes the file. A value of exactly 65,535 bytes is not saved from these results and a message says why: SQL Tools Service shortens longer values to that size by default, and the app cannot confirm that limit is lifted. Save such a value from Table Explorer on a table with a primary key, which reads it from the database again. - Values up to 100 MB can be saved this way.
The same item is in the results grids of SQL Notebooks, pinned results (read inside the tab's open transaction, like the live result) and the FK preview (Table Explorer → row details → Related data; when the related table has no primary key the item says so), and in the Table Explorer.
Column Profiling
Toggle column profiling (bar chart icon in the results toolbar) to see per-column statistics displayed below each column header.
- Null indicator bar — green (all values), amber (some nulls), red (all nulls)
- Hover tooltip — shows Total count, Null %, Distinct count, Min, Max, and Avg (for numeric columns)
- Stats are computed client-side from loaded rows — no additional database round-trip
Result Filtering
Toggle the filter row (funnel icon in the results toolbar) to filter already-loaded results without re-executing the query.
- Per-column filters — type in individual column filter inputs for targeted filtering
- Global search — use the leftmost input to search across all columns simultaneously
- Filtering is instant with a 150ms debounce — results update as you type
- The toolbar shows "X of Y rows" when a filter is active
- Cell aggregates and sorting operate on filtered rows only
- Press Escape or clear all inputs to restore the full result set
FK Navigation
Foreign key columns in query results are highlighted in blue with a link icon. Click a value to peek the referenced row and navigate to it.
- FK columns are automatically detected from query metadata — no configuration needed
- Clicking a value opens a popover showing the referenced row's data
- Click Open in the popover to jump to the referenced table in Table Explorer with the row pre-filtered
- FK constraint metadata is fetched lazily on first click and cached for subsequent lookups
- NULL values are not clickable
- Columns whose names differ only in case or punctuation (
"ref-id"and"ref id") each keep their own foreign key. A column with more than one foreign-key constraint uses one target everywhere — the preview, the cell editor's Search row in …, the enum editor's Search rows and the lookup filter: a single-column constraint before a multi-column one, then the constraint whose name sorts first (the same rule Table Explorer uses)
Quick WHERE Builder
Right-click any cell in the results grid and select Add to WHERE to add a filter condition to the statement that produced the results. The condition is the one Table Explorer's Add to filter starts from, written by the same filter code:
- An empty cell becomes
IS NULL, a PostgreSQL array cell becomes contains (2 = ANY(tags)), and any other value an=condition. - Values use each engine's literals: MySQL text with a backslash is written as a hex literal, so the backslash stays, Oracle dates use
TO_DATE/TO_TIMESTAMP, SQL Server dates carry the seconds it requires. - The column is named the way the statement names it:
o.customer_idin a join overorders o, the name a derived table or CTE exposes (s.xforSELECT * FROM (SELECT id AS x FROM t) s), the bare name in a one-table query. - Adds
AND …when the statement already has a WHERE clause, including one writtenWHERE(with no space; a WHERE whose conditions are joined by OR is wrapped first, soWHERE a = 1 OR b = 2becomesWHERE (a = 1 OR b = 2) AND …. - Otherwise inserts
WHERE …beforeGROUP BY,ORDER BY,WINDOW,FOR UPDATE/FOR SHARE, MySQL'sLOCK IN SHARE MODE, SQL Server'sFOR XML/FOR JSONandOPTION (…), andRETURNING. Text inside strings, comments and subqueries is skipped, and a new line starts after a trailing--(or MySQL#) comment so the comment can't swallow the condition. - It edits the selected text when there is a selection, otherwise the statement you last ran on its own (while it is still in the buffer), otherwise the buffer's last statement.
- The query is not run — review the condition and run it when ready.
Nothing is added when WHERE can't hold the condition: the column is computed by an aggregate or window function, the statement doesn't say which table the column comes from, or the statement has no WHERE to add to (a procedure call, PRAGMA, INSERT, or a Kusto query). A SELECT inside IF, WHILE or a BEGIN … END block isn't edited either; highlight the SELECT and use Add to WHERE again. A Not added to WHERE message says which. In the Visual view, Add to WHERE opens the WHERE condition editor pre-filled with the condition instead of editing text.
Add to Filter on a column header
With the Visual Query Editor turned on, the first item of a result column header's right-click menu is Add to Filter, as in Table Explorer. It opens the column's condition in the Visual Query Editor with the column's default operator and no value: in the Visual view, the WHERE condition editor for that column; in the SQL view, the compact editor on the statement the results came from, with the condition draft open. The item is disabled, with the reason in its tooltip, for an aggregate, window or expression column, for a column of a derived table, CTE or table function (the condition editor lists table columns only), for UNION / INTERSECT / EXCEPT results, and for results that don't come from a SELECT the Visual Query Editor can edit. In the SQL view it is also disabled for a SELECT with a named WINDOW or a derived table in FROM, which the compact editor can't edit — use it from the Visual view there. A column it can't place in the statement gets the same Not added to WHERE message as Add to WHERE.
Pin Results
Pin the current result set (pin icon in the results toolbar) to create a snapshot tab that survives re-execution.
- Each pin creates a new Pinned tab with a pin icon and a close (X) button
- Pin multiple result sets — there is no limit on the number of pinned tabs
- Running a new query switches back to the Results tab; all pinned tabs stay intact
- Close a pinned tab by clicking its X button
- Pinned tabs are ephemeral — they are not saved across sessions
Pin to a Dashboard
The Pin to dashboard button in the results toolbar (also available from a result cell's right-click menu) turns the current query into a live dashboard tile. A confirm sheet shows exactly which query and connection the tile will carry, lets you pick the target dashboard and tile type, and the tile then refreshes independently on the dashboard — unlike ephemeral pinned result tabs, it persists.
Editing Results (UPDATE)
For queries that return rows from a base table with a primary key, Jam SQL Studio can update cells directly in the results grid (similar to DBeaver).
- Run a SELECT query that includes the table’s primary key columns
- Click the Pencil icon in the results toolbar to enter edit mode
- Double-click an editable cell (or use the pencil icon in the row side panel) to edit
- Confirm or cancel the edit (in the row side panel, use the confirm/cancel buttons next to the input)
- Click Save to apply changes, or Discard to cancel
Notes: This supports UPDATE only (no INSERT/DELETE). Columns without a single source table (computed/aggregates) are read-only. On SQLite, columns of tables in an attached or temporary database are read-only. In Manual or Smart mode, saving begins the tab's transaction first when none is active (as running an UPDATE would), so you can commit or roll the changes back; while the connection is reconnecting, the save is refused and your edits stay pending. In Auto-commit mode, changes are applied immediately.
What Save runs: Save writes only your edits: the UPDATE statements shown in the preview. The query in the editor is not run again, so other statements in the tab (an INSERT or DELETE below your SELECT, for example) never run because of a Save. After the UPDATEs, Save reads the saved rows back by their primary key and shows them as the database now holds them. When your query reads the edited table once, every column of that table in a saved row is refreshed, including values set by defaults, triggers and computed columns. When it may read the table more than once (a self-join, a CTE, a UNION, a view), or another query in the tab that could have returned these results does, only the cells you edited are refreshed, because the other columns can show a different row of the same table (in a UNION, a column can show another column of the table in each branch); the confirmation says so, and running the query again refreshes the rest. In Manual or Smart mode the rows are read inside the tab's transaction, which stays open; a read that fails there does not affect the transaction. If a saved row cannot be read back (it was deleted meanwhile, or its key changed), the grid keeps the values you saved and a notice says so. The same happens when other rows share the saved row's key: SQLite allows more than one NULL in a primary key that is not an INTEGER PRIMARY KEY, and the Save then updates every row with that key. If the tab's transaction ends before the Save finishes (the connection was reconnected or disconnected, even while the saved rows were being read back), the Save is not confirmed: your edits stay pending, so you can save them again in a new transaction or discard them. While a Save runs, Commit and Rollback wait for it, and running the query is refused with a notice; run it again once the Save finishes. Results of more than 50,000 rows or 20 MB are read-only.
Which database a Save writes to: the database the query ran in, also after you pick another database for the tab while the results stay on screen. In Manual or Smart mode, or while the tab holds a transaction, such results are read-only, because the tab's transaction is in the other database; run the query again to edit. When the query itself switched databases (a USE, or ALTER SESSION SET CURRENT_SCHEMA on Oracle), its results are read-only, because their rows may come from either database; the pencil's tooltip says Editing is off for this result because the query switched databases. Run it again to edit.
Smart inputs for enum, foreign-key, and boolean columns
When you edit a cell whose source column is a declared/native enum, a real / loose foreign key, or a boolean type, the input expands into a smart editor:
- Enum columns show a values peek with live filtering. Click a value to commit, or type free text and press
Enter— the peek is a hint, not a constraint. A settings/gear button opens the Enum values details dialog. - Foreign-key columns show a Search row in … link that opens the same row picker used by the
lookupfilter operator. Polymorphic loose FKs list one entry per matching declaration. Free text +Enterremains the always-available fallback. - Boolean columns (
bit,boolean,tinyint(1)) render an inline segmented toggle withTRUE/FALSEoptions. Nullable columns get a thirdNULLoption. Clicking an option commits immediately;Escapecancels. Free-text typing is intentionally not offered — booleans are a closed set.
The same smart inputs are applied consistently in the Table Explorer grid, its inline Row details panel, and the Single-Row Details View — so editing semantics don't change as you move between surfaces.
Plaintext View
Switch to plaintext view to see results as formatted ASCII text, useful for copying into documentation or chat.
Each execution replaces the previous plaintext output.
Large Query Results
Jam SQL Studio can display and export query results of any size — millions of rows — with no hard row cap. The app automatically chooses the optimal rendering strategy based on result size:
- Small results (≤50K rows, ≤20MB) — render instantly in the grid with client-side sorting, filtering, copy, and export. This is the same fast path used in previous versions — no change in behavior.
- Large results (>50K rows or >20MB) — use windowed virtualization. Rows stream from the backend through a sliding buffer, and the grid fetches new windows as you scroll.
When a large result set is loading:
- A progress bar shows the number of rows received so far
- You can scroll and browse partial results while they continue loading
- Click Cancel to stop population and keep the rows received so far
- Column headers are available immediately — the grid renders as soon as the first batch arrives
For large results, sort and filter operate on the full dataset via the backend (not just the loaded buffer). A brief "Sorting..." or "Filtering..." overlay appears while the operation completes. Sort and filter are not available while results are still loading — wait for population to finish.
The grid uses a proportional virtual scrollbar that maps scroll position to row index. This allows smooth navigation through millions of rows without hitting browser scroll-height limits.
Exporting Results
Export your query results in multiple formats:
- CSV — Comma-separated values for spreadsheets
- JSON — JavaScript Object Notation for APIs
- Excel — Native .xlsx format with formatting
- SQL (INSERT) — INSERT statements as a .sql file with engine-aware identifier quoting and value formatting
You can also copy results to clipboard as CSV, Markdown, or INSERT statements from the copy dropdown in the results toolbar.
Dates in exports. The Excel export writes date and time columns as Excel date cells with a yyyy-mm-dd hh:mm:ss.000 number format (yyyy-mm-dd for a date column), so Excel can sort, filter and calculate on them. Excel has no time zones, so a value of a type with a time zone is written as its UTC date and time, and a date before 1900 (where Excel's calendar starts) is written as text. CSV, Markdown and Copy write dates in the Date and time in results format. JSON and SQL (INSERT) keep the full ISO value.
SQL (INSERT) to the clipboard or a new query. Under Export SQL (INSERT), the Export menu has two more rows for the same script: Copy SQL (INSERT) puts it on the clipboard (up to 10,000 rows, like Copy INSERT), and Open SQL (INSERT) opens it in a new query tab on the connection and database the results came from (also after you switch the tab to another database) without running it. A script larger than the editor's 50 MB limit does not open in a tab; use Export SQL (INSERT) to save it to a file. On a large result, whose grid loads its rows as you scroll, both rows write the rows the grid has loaded: the clipboard toast gives both counts, and the new tab's script starts with a comment that does (-- 2,000 of 50,001 rows: …). The grid shows long text values of such a result shortened, so every INSERT script from it (these two rows, Export SQL (INSERT) and Copy INSERT) reads the loaded rows again and writes each value whole; if their values add up to more than 64 MB, no script is written and a message says so. If you run the query again or sort or filter the grid while they are read, no script is written either, and a message asks you to try again. If they cannot be read again (for example, the connection was lost), no script is written and the message says so. Both rows follow Skip identity columns.
SQL Server values in INSERT scripts. On SQL Server, an INSERT script writes numbers with a dot as the decimal separator and no other marks, and dates and times in the ISO form ('2026-11-10T17:17:24.3174937'), so the script stores the same values whatever language or date format the session that runs it uses. This matters on a connection on Windows that leaves the port unset, or uses Windows authentication: the results there show numbers and times in your computer's regional format (in Finnish, 2,5 and 17.17.24), and the script still writes '2.5' and '…T17:17:24'. Text with characters outside plain ASCII is written as N'…', so a varchar column whose collation uses another code page than the database (Cyrillic or UTF-8, for example) keeps its characters. A number or date the app cannot read exactly is not guessed: it is written as NULL with a comment beside it, and the script's first line says how many values were written that way.
Binary values in INSERT scripts. Binary columns (SQL Server varbinary / image, PostgreSQL bytea, MySQL BLOB, Oracle BLOB / RAW / LONG RAW, SQLite BLOB) are written as the engine's binary literal holding the stored bytes. The grid often shows only [binary 247748 bytes] or a shortened hex preview, so the app reads those values again by the row's primary key before it writes the script — include the table's primary key in the query. They are read from the database the query ran in, also after you pick another database for the tab, and each value read is checked against the one the result held. On Oracle, a value over 2,000 bytes is written as a short PL/SQL block, because an Oracle SQL literal cannot hold it; for RAW and LONG RAW columns the block can hold up to 32,767 bytes. A value the grid holds whole is written as it is, also when its row cannot be read again; a computed SQL Server column (DECOMPRESS(…)) is written from the values the app kept while the query ran. A value the app cannot read is written as NULL with a comment, and a warning names the column, how many values were left out and why: the results have no primary key, they read the table twice (a self-join), they don't say which table and primary key the column comes from (SQL Server over SQL Tools Service), the table is in another database (SQL Server three-part names), is read through a linked server, or is a temporary table, the primary key is a binary value the grid doesn't hold, the value read is not the one the grid shows (the row changed since, or its primary key matches more than one row), an Oracle RAW / LONG RAW value is over 32,767 bytes, or the script would carry more than 64 MB of binary data — counted for every row it is written into, so a value repeated by a join counts each time, and values the grid already holds count too. In a SQL Notebook the values are read on the notebook's own session, and a cell you run while they are read is refused with a message (run it again when they are done). SQLite lets a BLOB column hold text spelled like hex ('0x4142'), which the grid shows exactly like a binary value; the app notes which values were text when the query ran, so text is written as text and binary data as binary data, also when the row changes before you export. While the values are read, the export button shows that it is busy and a toast counts the values being read; a second export or Copy INSERT waits until it finishes. Text and JSON columns are written as they are stored, whatever they contain.
- Oracle: the grid shows an empty BLOB (
EMPTY_BLOB()) asNULL. When the results include the primary key, the app checks those cells and writesEMPTY_BLOB()for an empty value andNULLfor a NULL one. Without the key it cannot tell the two apart, so such a cell is written asNULLwith a comment and counted in the warning. ARAWcolumn has no empty value in Oracle. - Oracle Table Explorer: the page shows a BLOB's first 2,000 bytes as hex. A shorter value is written as the page shows it; a longer one is read again by key and must start with the bytes the page shows, otherwise it is written as
NULLwith the warning (the row changed since the page loaded). - SQLite: a BLOB-declared column can also hold text. The app notes which values were text spelled like hex (
0x4142) when the query ran — also in a tab with an open transaction — and those stay text, while the others are written as binary data, with or without the primary key, even if the row changed since. Only when the results hold the same bytes both as text and as binary data does the app read such a value again by key to tell which it is; without the key it is written asNULLwith the warning. In a large result whose grid shows only the first 1,024 characters of a long text value, the text is read again by key and written whole. - MySQL: a
VARCHARorTEXTvalue that reads like the grid's placeholder ([binary 12 bytes]) is written as that text. - MySQL: one value larger than the server's
max_allowed_packet(64 MB by default) makes its INSERT statement too large for the server; raise the setting before running such a script.
Identity columns. Generated INSERTs keep identity values by default — on SQL Server the script is wrapped in SET IDENTITY_INSERT <table> ON/OFF so it runs instead of failing with "Cannot insert explicit value for identity column" (Msg 544). Tick Skip identity columns in the copy or export dropdown to leave identity columns out and let the target assign fresh values. The choice is remembered across restarts. The copy and export menus work from the keyboard like any other menu: Enter opens one, the arrow keys move between the formats, Enter runs the highlighted one and Esc closes it; ticking Skip identity columns keeps the menu open. If identity metadata can't be checked, a warning toast tells you the script was generated without identity handling.
Where files are saved. Every save dialog in the app — exports, Save Query, notebooks, charts, plans, backups — opens in the folder you last saved into, and in your Downloads folder until you have saved somewhere (or if that folder was deleted).
For large (windowed) result sets, use Export All to CSV to stream the full dataset to a CSV file. The export runs in the background with a progress toast showing rows written, percent complete, and an estimated time remaining, and it can be cancelled at any time. Long exports also show their progress on the app’s dock / taskbar icon, so you can switch to another app while millions of rows stream out. JSON, Excel, and SQL INSERT exports are available only for small (in-memory) results.
On SQL Server, Export All to CSV is written by the bundled SQL Tools Service straight to disk in large chunks — the row data no longer travels through the app’s per-batch requests, which were what used to time out, so exports of millions of rows or very large text cells complete reliably and substantially faster. Progress ticks per chunk, Cancel takes effect at the next chunk boundary, and resume works as before. If the chunked write can’t complete for any reason, the export automatically falls back to the streaming method below and picks up where it left off. One thing to know: on this SQL Server path, NULL values are written as the literal text NULL (the same convention SSMS and Azure Data Studio use), rather than an empty field — other engines’ CSV exports are unchanged.
Large exports are built to survive a slow server: if a batch takes a while the toast says so instead of freezing, and a batch that times out is automatically retried. If the same rows keep timing out — typically rows holding very large text, JSON, or binary values — the export doesn’t give up: it works through the difficult spot by fetching smaller and smaller batches, down to a single row at a time, and the toast narrates the recovery. If a row still can’t be read after that, the export skips it and keeps going, then finishes with a warning listing the skipped row numbers — up to 20 skipped rows; past that the export stops and keeps the partial file, resumable as below. Whenever rows were skipped, a Skipped rows tab appears beside Results and Messages listing every missing row with a short preview of its values — click any row to jump to it in the grid, selected and centred, so you can see what is in the row the server refused to hand over without hunting for it by hand; a row that still can’t be read even one-by-one shows a “Still unreadable” badge with a per-row Retry. The warning itself offers a direct Show row jump when exactly one row was skipped, or a Review skipped rows button that opens the tab. The tab lives as long as that result set: re-running the query or switching result sets clears it (and if you have since closed the tab or switched result sets, the warning’s buttons say so instead of scrolling somewhere unrelated). If an export fails partway, the rows already written are kept on disk — the toast tells you how many rows were saved and offers Resume export, which continues from the last saved row without starting over, alongside the usual Show in folder button.
Transaction Management
Control how your queries interact with transactions using the toolbar controls. Each query tab has its own independent transaction state.
In Manual and Smart mode, transaction controls are grouped with a subtle shared tint: transaction mode and isolation sit on the first row, and commit/rollback controls sit on the second row.
When the toolbar gets narrow, right-side File/Format/Options collapse first; if space is still tight, Plan/Result/Recent collapse to icon-only buttons.
With two-row transaction controls visible, right-side actions move into that second row beside commit/rollback only after File/Format/Options and Plan/Result/Recent have already collapsed and space is still insufficient.
Transaction Modes
Click the transaction mode button in the toolbar to switch between three modes:
- Auto (default) - Every statement auto-commits immediately. This is the standard behavior.
- Manual - A transaction begins automatically on your first query. You decide when to commit or rollback using the toolbar buttons.
- Smart - Read-only queries (SELECT) run in auto-commit, while data-modifying statements (INSERT, UPDATE, DELETE) automatically begin a transaction.
On Oracle and MySQL, a COMMIT or ROLLBACK in an Auto-mode run often has nothing to act on, because every statement before it was already committed, and neither database reports it. Messages then shows a warning: Auto mode commits each statement as it runs, so ROLLBACK had nothing to undo. Switch the tab to Manual mode to commit or roll back yourself. SQL Server, PostgreSQL and SQLite report such a statement themselves.
Oracle transactions
On Oracle, Manual and Smart mode keep the tab on one database session from its first statement until you click Commit or Rollback. Oracle has no BEGIN statement: the transaction starts with the first statement that changes data, and other tabs see those changes only after you commit. PL/SQL blocks run inside the transaction like any other statement, and their DBMS_OUTPUT appears in Messages.
- A
COMMITorROLLBACKyou type in the editor ends the current transaction there. The tab keeps its session, and the next change starts a new transaction on it until you use the toolbar's Commit or Rollback. - DDL such as
CREATE TABLEorALTER TABLEcommits the open transaction, as it does in every Oracle tool. - Session settings you change, such as
ALTER SESSION SET CURRENT_SCHEMAor an NLS setting, stay in effect for the tab's later runs until the transaction ends. - A statement that fails rolls back only itself; the earlier changes stay in the transaction.
- Stopping a statement cancels only that statement, and the transaction keeps the earlier changes. A statement that waits on a lock does not respond to a cancel, so after a few seconds Jam closes the session instead: the database rolls the transaction back and the tab says the transaction ended.
- Smart mode starts a transaction for a top-level
INSERT,UPDATE,DELETEorMERGE. A PL/SQL block runs in auto-commit; switch to Manual mode to run one inside a transaction.
A transaction a statement left open
In Auto mode you can still run BEGIN, START TRANSACTION or BEGIN TRAN yourself. When a run ends with a transaction still open, the tab keeps that database connection to itself until a later run in the same tab ends the transaction with COMMIT or ROLLBACK. Stopping a run, a timeout or a statement that fails does not end it: the transaction stays open in the tab until you commit or roll it back. On PostgreSQL a statement that fails inside the transaction puts it in the failed state, where you can still run ROLLBACK TO SAVEPOINT and continue, or ROLLBACK. Your next runs in the tab use that connection, so they see your uncommitted changes and any SET or USE you ran. Other tabs, the Object Explorer and AI agents use other connections: they see only committed data and none of your settings.
While the transaction is open, the toolbar shows Transaction open with Commit and Rollback buttons, and the status bar shows Tx: Auto (Open). Commit and Rollback are disabled while a statement in the tab is still running. Closing the tab asks first, the same way as for a Manual-mode transaction, and disconnecting rolls the transaction back. If you close the tab while its run is still starting the transaction, the transaction is rolled back when the run finishes. Reloading the window keeps every open transaction of the tabs it restores, in Auto and Manual mode alike; a transaction whose tab is not restored is rolled back. Once the transaction ends, the connection goes back to the pool and the settings the tab changed are reset.
- SQL Server — a batch that contains
BEGIN TRANis sent as a plain batch, the way SSMS sends it, so it can leave a transaction open for a laterCOMMIT. While the tab holds a transaction, Explain with the actual plan is not available, because SQL Server captures it on a connection of its own; the estimated plan still works. Include Actual Plan also refuses a batch that starts a transaction (BEGIN TRAN,SET IMPLICIT_TRANSACTIONS), for the same reason; turn it off to keep the transaction open in the tab. On connections that run through SQL Tools Service, a large result inside an open transaction streams into the grid as usual and Stop works while it loads; if the connection holding the transaction is lost (for example, killed on the server), the next statement is refused with a message that the transaction is no longer open, and it does not run outside the transaction. - SQLite — a run that starts a transaction gets its own handle to the database file, kept while the transaction is open; Manual and Smart mode transactions and SQL Notebooks run on handles of their own too. Other tabs read the committed data. If another tab tries to write while your transaction holds the write lock, it stops at once with The database is locked by an open transaction in another query tab; commit or roll back in the tab that holds it, then run the statement again. When the connection has attached databases or temporary tables, the transaction runs on the connection's shared handle instead, and until it ends everything else that uses that connection — other tabs, notebooks, the Schema Overview, the Object Explorer — is refused with This database has a transaction open in another query tab. If Jam could not load its native SQLite driver and runs the connection on its fallback driver,
BEGINandSAVEPOINTare refused there, because that driver cannot keep a transaction open. - Oracle — Auto mode commits every statement as it runs, and Oracle has no
BEGINstatement to start a transaction, so no transaction stays open between runs. Use Manual or Smart mode to commit or roll back yourself (see Oracle transactions).
Commit and Rollback
When a transaction is active in Manual or Smart mode, use the toolbar buttons or keyboard shortcuts:
- Commit - Save all changes in the current transaction (
Cmd+Shift+C/Ctrl+Shift+C) - Rollback - Discard all changes in the current transaction (
Cmd+Shift+X/Ctrl+Shift+X)
If no transaction is active yet, the toolbar shows a short hint telling you to run a query first to start one.
The status bar shows the current transaction state with color indicators: amber for an active transaction, red for an error state.
Isolation Levels
In Manual or Smart mode, you can set a transaction isolation level per tab:
- Default - Use the database engine's default level
- Read Uncommitted - Allows dirty reads
- Read Committed - Prevents dirty reads (SQL Server and PostgreSQL default)
- Repeatable Read - Prevents non-repeatable reads
- Serializable - Full isolation (SQLite only supports this level)
On Oracle the picker lists only the levels Oracle supports: Default, Read Committed (Oracle's default) and Serializable. The level covers every transaction on the tab's session, including the ones that start after a COMMIT you type. A tab that comes back with another level, for example from a saved session, is refused with a message naming the supported levels; pick one of them and run again.
The isolation level applies when the next transaction begins. Changing it during an active transaction takes effect on the next one.
Tab Close Safety
If you try to close a tab with an active transaction, a dialog gives you three choices: Commit and Close, Rollback and Close, or Cancel. The same dialog appears when Close others, Close tabs to the right or Close besides pinned would close a tab with an open transaction, and when you switch sessions. If a commit or rollback fails, that tab stays open and a notice names it and gives the error; the other tabs close as chosen (a session switch does not happen until every tab can close). A failed commit or rollback always ends the transaction — the database rolls it back — so the tab's toolbar returns to idle and the error stays in its Messages. If a statement fails and the database rolls the whole transaction back (PostgreSQL after any error, SQL Server with XACT_ABORT, MySQL for a deadlock), Commit reports that the transaction was rolled back instead of committing. On MySQL, statements run after a deadlock are refused until you roll back, because MySQL would otherwise commit each one on its own. If MySQL cannot confirm whether a transaction survived a lock wait timeout, the tab says so, Commit is disabled and Rollback is the only option. While a tab's transaction is still starting, the toolbar shows Stop: it gives up on the transaction and runs nothing. When the app quits or its window closes, all active transactions are rolled back automatically; a transaction whose statement is still running is ended by closing its connection, which the database also rolls back.
The query status bar uses compact 12px text for improved readability during long editing sessions.
Connection and Database in the Status Bar
The status bar shows the tab's connection and database as one control, connection › database, inside a rounded box. Each half is its own dropdown: click the connection name to run the tab on another connected connection of the same engine, or the database name to switch databases on the same connection. Hovering a half shows a tooltip that says what it changes; the connection's tooltip also names the server host, which the status bar leaves out to keep the control short. When the connection has a colour, a small square in that colour sits before the connection name. A tab with no connection shows only the connection half.
Database Switcher
The database name in the status bar is a dropdown — click it to run the tab against another database on the same connection. Once Object Explorer has listed a connection, the dropdown opens with that list already in it instead of showing “Loading databases…” again, and re-reads the list in the background while you pick. So a database you created since the last time you opened the dropdown still shows up.
The same applies to every other database picker in the app: the Table Explorer's database dropdown, the Schema Overview header, the Select Database dialog a toolbar action opens when it needs one, the Table Designer, Clone Table, the Schema Overview's Compare Schemas dialog, Data Import's Target step, the cross-engine migration target, the Database Blueprint “Add linked database” dialog, and the database button on the collapsed Object Explorer rail.
When the list can't be read at all — a login without permission to see the server's databases, for example — the picker says so and offers Show details, which opens the connection diagnostics. Below that it still lists the database this connection is configured for and any it has opened before, each marked with a ? so it's clear the server didn't confirm them. Those entries are selectable, so an action that needs a database — Table Designer, Clone Table, Table Explorer — is not blocked by a listing you can't read. Jam never fills the gap with a guessed list of system database names. Because the server hasn't confirmed those names, the Select Database dialog's Set as default database for this connection option is not offered over them: saving a default changes what the connection dials, so it waits until a listing has confirmed the name. For the same reason it stays switched off for the moment the dialog spends re-reading the list in the background — it reads Checking the database list… until the fresh list arrives. Picking a database for the job at hand is never held up; only saving it as the default is.
Data Import's Target step is the one picker that does not offer those unconfirmed entries. Its Database field reports “Couldn't list databases.” with a Retry link instead, because the import needs a database the server can actually be asked about before it writes to it.
The collapsed rail's database button used to show only what the Object Explorer tree happened to hold, which left system databases out of it. It now offers the same list as every other picker.
Editor Options
Customize the query editor to match your preferences.
Formatting
- Format SQL - Press
Shift+Alt+Fto format your SQL code. On SQL Server, where statements need no;, every statement starts on its own line —IF,ELSE,WHILE,EXEC,PRINT,RETURN,BEGIN/END,DECLARE, transaction statements,GOTOlabels — and the lines inside aBEGIN…ENDblock are indented. Formatting only changes whitespace, so the formatted script runs the same way. It never adds aGOline: a batch where formatting would leave a wordgo(a column, alias or procedure namedgo) alone on a line is left as you wrote it. - Word wrap - Toggle word wrap for long lines
- Tab size - By default, pressing Tab in the query editor inserts 2 spaces. You can change this to 4 or 8 in Settings → UI → Editor → Tab Size. The choice is global and persists across restarts. It applies to the main query editor and the PL/SQL debugger edit view.
Color Scheme
Settings → UI → Appearance → Editor colors shows a button with the current scheme's name and swatches; clicking it opens an Editor colors dialog. The dialog shows two preview panes — Dark and Light — rendering a sample SQL query in each scheme's colors, above a scheme dropdown with five presets (Default, High contrast, GitHub, Solarized, and Atom One) plus a Custom option. Hovering a scheme in the open dropdown previews it in both panes without changing anything; clicking a scheme (or editing Custom's color pickers) updates the panes and the dialog's staged selection, but nothing reaches your editors yet. Confirm applies the staged scheme to every open SQL editor at once — the Query Editor, notebook cells, and diff viewers; Cancel (or Escape, or the dialog's close button) discards it. Only the syntax token colors change; the editor background stays matched to your app theme, and the app's Theme setting (System/Light/Dark) picks which preset variant is active elsewhere in the app.
High contrast keeps every token at least 7:1 against the editor background, for anyone who finds the default colors too dim to read. The other presets meet a 4.2:1 floor for keywords, strings, and numbers, and 3.5:1 for comments.
Selecting Custom opens color pickers inside the dialog, seeded from whichever scheme was active the first time you pick it. Seven pickers — Keywords, Functions, Strings, Numbers, Identifiers, Operators, and Comments — each pair a color swatch with a hex text field, and both preview panes update live as you edit. An Edit variant: Dark / Light toggle picks which variant the pickers are editing, independent of the app's theme setting. A Copy from… control re-seeds both variants from any of the five presets. Custom colors carry no contrast floor — that's your choice — but a color below 3:1 against the edited variant's editor background shows a small warning triangle.
The selected scheme — including custom colors — travels with a settings export and is validated on import; see Moving Your Settings to Another Machine.
File Operations
- Open file - click the Open button in the query toolbar to open a .sql file
- Save file -
Cmd+S/Ctrl+Sto save - Save as -
Cmd+Shift+S/Ctrl+Shift+Sto save with a new name
File-backed tabs show an asterisk (* filename.sql) in the tab title when there are unsaved changes. The indicator disappears after saving.
Size limit. The editor accepts scripts up to 50 MB. Opening a larger .sql file is refused with a message that names the size and has a Run SQL File… button, which runs the file from disk without opening it (see Run SQL File). Pasting or dropping text that would push a tab past 50 MB is refused too; save that text to a .sql file and run it with Run SQL File, or with your database's command-line tool (sqlcmd, psql, mysql, sqlplus, sqlite3). If a file you have open grows past 50 MB on disk, the tab keeps its current text and tells you. A tab holding a script over 1 MB keeps working during the session, but its text is not saved with the workspace: after a restart a file-backed tab reloads the script from its file, and an unsaved tab shows a comment explaining that the script was too large to keep, so save large scripts to a file.
Run SQL File
Run SQL File… runs the statements in a .sql file on a connection without opening the file in the editor, so it also runs files over the editor's 50 MB limit, such as a dump made by mysqldump or pg_dump --inserts. Open it from More → Run SQL File…, from the command palette, or with the Run SQL File… button on the message shown when a file is too large to open. It is available in the desktop app, for SQL Server, PostgreSQL, MySQL and MariaDB, Oracle and SQLite connections; it is not offered for Azure Data Explorer (Kusto) or Azure Storage connections, and it is disabled while the active tab is on one of them.
The dialog shows the file's name and size, the connection and the database the file runs in. Both start as the active query tab's; without one, the dialog starts on a connected connection and that connection's own database. You can pick another connected connection or another database; picking another connection resets the database to that connection's own. For a connection that names no database, the field shows The connection's default: the run names no database, so the server uses the login's default. Pressing Run confirms the whole file; the run does not stop to ask about individual statements.
- One connection per run. The file runs on its own connection, opened for the run and closed when it ends, in autocommit mode: each statement is committed as it runs. It stays the same session for the whole run, so a
USE, aSET, a temporary table or a transaction the file opens carries on to the statements after it, however long the pause between them. AUSEorSETin the file does not change your query tabs, and a tab's open transaction is not used. One file runs at a time. - Errors. The run stops at the first statement that fails. Tick Continue after errors to run the rest of the file and list every failure. Statements that ran before an error, or before you pressed Stop, stay applied. If the connection to the server is lost (a server restart, a network drop, a session ended by an administrator), the run ends there and names the line, with or without Continue after errors; nothing after it runs.
- Statements. The file is cut into statements where the server would cut it: a
;inside a string, a comment or a routine body does not end a statement, including MySQL strings with backslash escapes asmysqldumpwrites them and SQLite trigger bodies. A MySQL routine, trigger or event is one statement whatever its body is, also a body with noBEGINsuch asCREATE PROCEDURE p() IF … END IF. The client commands work as they do in the database's own client: after aDELIMITERline on MySQL, the new delimiter ends a statement wherever it appears outside a string or comment, as in themysqlclient — a delimiter made of letters, such asDELIMITER abc, also inside a word. As in themysqlclient, aDELIMITERline between statements sets the first word after it as the delimiter and ignores the rest of the line (DELIMITER $$ /* routines */sets$$; a quote in that rest still opens a string, so the file is refused as ending inside one); a line such asdelimiter = 5;that continues a statement is SQL.GObatches on SQL Server (GO 2runs its batch twice); a/line after a PL/SQL block on Oracle. On SQL Server each batch is sent as one unit, so the dialog counts batches instead of statements, and the next batch starts only when the previous one has finished, also after an error raised partway through a batch. - Encoding. Files saved as UTF-8 (with or without a byte order mark) and as UTF-16 with a byte order mark run; UTF-16 is what SQL Server Management Studio's Generate Scripts saves by default.
- Stop. Stop asks the database to cancel the statement in progress and runs nothing after it. On MySQL and PostgreSQL the request goes on a second connection, which gets as long to open as any connection to that server (30 seconds). If the request cannot be sent, or the database does not stop the statement within a few seconds of it, Run SQL File closes its connection; a statement the server was still running may still finish or roll back on the server. On SQLite, Stop takes effect between statements. On SQL Server connections that run through SQL Tools Service (a connection on Windows that leaves the port unset, or uses Windows authentication), the connection cannot be closed that way: the run ends as stopped with a message that the statement may still be running, and its session closes once the server has ended the statement. On those connections, rows affected does not count a batch that also returns rows.
The run reads the file twice and never holds all of it in memory. The first pass counts the statements without running any of them; the second runs them. The second pass runs only what the first pass checked: if the file changes on disk after the first pass, the run stops before running anything from the changed part, and a file that changes while the first pass reads it is not run at all. While it runs, the dialog shows a progress bar, the statements run out of the total, failed statements, rows affected, the elapsed time and the line of the statement in progress. You can close the dialog and keep working: closing during a run asks whether to stop it, Keep running lets it finish, a message appears when it ends, and More → Run SQL File… opens it again. When the run ends, the dialog shows the statements run, rows affected, the duration and each failed statement with its line number, the server's message and the start of the statement; Copy puts that list on the clipboard.
Files that are not run. The first pass refuses the whole file, before any statement runs, and names the line, when:
- the file ends inside an unclosed string, quoted name or comment — usually a file that was cut off;
- it holds a PostgreSQL
COPY … FROM stdindata block, which is howpg_dumpwrites table data by default, or anotherpsqlbackslash command such as\connect, anywhere outside a string or comment — also after a query on the same line, as inSELECT 1 \g. The\restrictand\unrestrictlines that recentpg_dumpversions write are skipped when each stands alone on its line with its key; a line where one is followed by anything else is refused. Create the dump again withpg_dump --inserts, or run it withpsql; - one statement, with the comments right before it, takes more than 64 MB of the file, the most Run SQL File sends at once (MySQL's default
max_allowed_packet); - a UTF-16 file ends in half a character.
A SQLite connection set to Open read-only runs nothing either; turn that setting off for the connection to run the file.
Scripts Panel
Use the Scripts panel in the sidebar to manage and reopen your .sql files:
- Recent - Quickly reopen recently opened scripts
- Pinned - Pin frequently used scripts for each script workspace
- Mounted folders - Mount a folder from disk and browse .sql files in a tree
- Rename mounted folders - Right-click a mounted folder and choose Rename in Jam SQL (label only)
- Filter scripts - Search across Recent/Pinned and mounted folders
When you open a script from the Scripts panel, Jam SQL Studio uses your current connection context from Object Explorer. If no connection is selected, you'll be prompted to choose one.
AI Chat Sidebar
The Query Editor includes a built-in AI Chat sidebar powered by your locally installed Claude CLI or Codex CLI. Click the AI button in the toolbar to open the chat panel alongside your editor.
- Ask questions about your SQL, get suggestions, and let the AI interact with your database via MCP tools
- The AI can update your editor directly using the
ui_set_editor_texttool - @-mentions — type
@to reference database objects (tables, views, procedures) from the Object Explorer - Session continuity — conversations persist across tab switches and session restores
- Multi-backend — supports both Claude CLI and Codex CLI; switch between them with a segmented control when both are installed
See AI Integrations & MCP for setup details.
Pin queries to the Object Explorer
Pin a query you come back to often to the Object Explorer tree, grouped under its database next to pinned tables. Click the pin button in the query toolbar, or right-click the tab and choose Pin to Object Explorer (distinct from Pin tab, which only keeps the tab open). The button is disabled with a tooltip when a tab can't be pinned — for example, before you've connected it to a database.
Queries pin in one of two flavors, decided when you pin:
- Snapshot — for an unsaved (scratch) query, the pin stores the SQL text as it is at that moment.
- File — for a query backed by a
.sqlfile on disk, the pin stores the file path, and reopening re-reads the current file contents from disk.
To reopen, double-click the pinned row (or select it and press Enter). Jam SQL Studio opens a query tab with the saved SQL — it does not run the query automatically, so you stay in control of execution. Opening a pin that's already open just focuses its tab.
If you edit a pinned tab so it no longer matches the pin, the toolbar pin button shows a divergence dot; click Update to re-capture. To unpin, click the pin icon at the right-hand end of the pinned row. Right-click it for Rename, Update from the open tab, or Unpin. Pins are saved per connection and database and persist across restarts. You can pin Table Explorer views and notebooks the same way — see Table Explorer and SQL Notebooks.
Query History Search
Search across all your query history with full-text search and filters. Open it via:
- Keyboard shortcut —
Cmd+Shift+Y(macOS) /Ctrl+Shift+Y(Windows/Linux) - Command Palette — type "history" and select "Search Query History"
- Toolbar button — click the history search icon in the query toolbar
Filter results by connection, database, success/error status, and date range (today, last 7 days, last 30 days, or all time). Results show the SQL preview, connection name, timestamp, duration, and row count.
Click a result to insert its SQL into the current editor. Up to 200 queries are stored per connection/database context.
Keyboard Shortcuts
The Query Editor supports these shortcuts:
| Action | macOS | Windows/Linux |
|---|---|---|
| Execute query | F5 | F5 |
| Execute current statement | Cmd+Enter or Shift+Enter | Ctrl+Enter or Shift+Enter |
| Format SQL | Shift+Alt+F | Shift+Alt+F |
| Save file | Cmd+S | Ctrl+S |
| Comment line | Cmd+/ | Ctrl+/ |
| Find | Cmd+F | Ctrl+F |
| Find and replace | Cmd+Alt+F | Ctrl+H |
| Search query history | Cmd+Shift+Y | Ctrl+Shift+Y |
| Copy selected cells | Cmd+C | Ctrl+C |
| Commit transaction | Cmd+Shift+C | Ctrl+Shift+C |
| Rollback transaction | Cmd+Shift+X | Ctrl+Shift+X |
| Refresh IntelliSense | Cmd+Shift+R | Ctrl+Shift+R |
| Toggle Results Pane | Cmd+J | Ctrl+J |
| Go to definition | F12 | F12 |
| Find references | Shift+F12 | Shift+F12 |
| Rename symbol | F2 | F2 |
Frequently asked questions
How do I execute a SQL query in Jam SQL Studio?
Press F5, or click the Execute button in the toolbar, to run the SQL in the editor. To execute only a portion, select the text — the toolbar button switches to Selection and runs just the selected SQL, and F5 does the same. Cmd/Ctrl+Enter and Shift+Enter run the selection or the statement under the cursor; Shift+F5 always runs the full editor content.
Does Jam SQL Studio have SQL autocomplete?
Yes, Jam SQL Studio provides IntelliSense with context-aware suggestions for table names, column names, SQL keywords, and functions based on your database schema.
How do I export query results?
Click the Export button in the results toolbar and choose your format: CSV, JSON, or Excel (.xlsx). For JSON and Excel, you can export the active result set or all result sets.
Can I view the execution plan for my query?
Yes, click the Execute dropdown and select 'Execute with Actual Plan' or 'Execute with Estimated Plan'. The execution plan opens in a visual tree/graph view for analysis.
How do I cancel a running query?
Click the Stop button in the toolbar while a query is running. Jam SQL Studio requests cancellation, and the button changes to Stopping… — click it again to force the stop. A statement already waiting on the server may run until its wait ends: on Oracle the forced stop drops the connection so the query returns at once, but the database session finishes what it had already started.
Can I run SQL/PGQ property graph queries?
Yes — queries are sent to your database as-is, so SQL/PGQ (SQL:2023 property graph queries) such as GRAPH_TABLE on Oracle 23ai, and SQL Server's graph MATCH syntax, execute normally and results appear in the standard results grid. On Oracle 23ai+, the editor also recognizes GRAPH_TABLE syntax and offers schema-aware completions for graph names, labels, and properties — see SQL/PGQ Property Graph Intellisense above — and property graphs appear in the Object Explorer with scripting and a GRAPH_TABLE query template, see the Scripting guide. PostgreSQL 19 carried SQL/PGQ in betas 1 to 3, but Beta 4 (September 24, 2026) reverted it, so PostgreSQL 19 will be released without GRAPH_TABLE. Visually editing a GRAPH_TABLE query in the Visual Query Editor is not yet supported.
Does the query editor support Microsoft Fabric Warehouse T-SQL?
Yes. On SQL Server connections the editor recognizes ANY_VALUE, MEDIAN, QUANTILE, APPROX_MEDIAN, APPROX_QUANTILE, QUALIFY, GROUP BY ALL, ORDER BY ALL and FROM-first queries: they autocomplete, are colored, get no false syntax errors, and F5 runs a FROM-first statement on its own. They run on Fabric Data Warehouse and the SQL analytics endpoint; SQL Server and Azure SQL reject them when the query runs, and autocomplete marks them with a Fabric badge once it knows the server is not Fabric Data Warehouse. See Fabric Warehouse T-SQL syntax.
Ready to Write Queries?
Download Jam SQL Studio and start writing SQL with powerful IntelliSense.




















