Published: 2026-04-06

SQL Editor IntelliSense Beyond Autocomplete

Every SQL editor autocompletes table and column names. It's table stakes. But if that's where your editor's intelligence ends, you're still doing a surprising amount of manual work — checking parameter order for stored procedures, cross-referencing INSERT columns with VALUES lists, running throwaway queries to check intermediate results. Jam SQL Studio 1.4 ships three features that push SQL IntelliSense well beyond the autocomplete dropdown.

Function Parameter Hints

You're calling a stored procedure or function. You know the name, but was the date parameter second or third? What type does it expect?

In most SQL editors, you'd open the procedure definition in another tab, scan the parameter list, then switch back. Or you'd google the function signature. With function parameter hints, the editor answers the question inline — as you type.

When you type an opening parenthesis after a function or procedure name, Jam SQL Studio shows a tooltip with the full signature: parameter names, data types, default values, and which parameter you're currently filling in. As you type commas to move between arguments, the active parameter highlight follows along.

This works across all five supported engines:

• SQL Server — reads from sys.parameters and sys.types
• PostgreSQL — reads from pg_proc and pg_type
• MySQL — reads from information_schema.parameters
• Oracle — reads from ALL_ARGUMENTS
• SQLite — built-in function signatures (SQLite doesn't have stored procedures, but its 150+ built-in functions all have hints)

The signatures are fetched from the database catalog on first use and cached for the session, so there's no lag after the initial lookup.

Why This Matters More Than You'd Think

Parameter order errors in SQL are silent. If you swap two VARCHAR parameters, the query runs fine and returns wrong results. If you swap a DATE and an INT, you get a runtime error that might not surface until production. Parameter hints catch these mistakes before execution — the same way a compiler catches type errors in application code.

This is particularly valuable for Oracle packages, where a single package body might contain dozens of procedures, and SQL Server's system functions, where the parameter order is not always intuitive (CHARINDEX(substring, string) vs POSITION(substring IN string) in PostgreSQL).

Column Inlay Hints

Consider this INSERT statement:

INSERT INTO orders VALUES (1001, 42, '2026-04-06', 'pending', 149.99, NULL, 1);

Quick: what's the NULL for? Is 42 the customer ID or the product ID? Without checking the table definition, you can't tell. This is a readability problem that every SQL developer hits daily, especially when reading someone else's code or reviewing a migration script.

Column inlay hints solve this by showing ghost column names directly in the VALUES clause:

INSERT INTO orders VALUES (order_id: 1001, customer_id: 42, order_date: '2026-04-06', status: 'pending', total: 149.99, discount: NULL, warehouse_id: 1);

The hints are rendered as faded ghost text — visible enough to read, subtle enough not to clutter. They don't modify your code. They appear automatically when the editor detects an INSERT...VALUES pattern and can resolve the target table's columns.

SELECT * Expansion

The same system handles SELECT *. Hover over the asterisk and you'll see the full column list that * expands to. This is useful when you're exploring a table and want to know what columns are there without running a separate DESCRIBE or checking the Object Explorer.

Peek Results

You're building a complex query — maybe a chain of CTEs, maybe a subquery three levels deep. Something's off in the output. The debugging process usually looks like this: comment out everything below the suspicious CTE, run it, check the intermediate results, uncomment, repeat for the next CTE.

Peek Results skips this ritual. Select any SELECT statement or CTE in your editor, and preview its results in a floating panel. Your main results grid stays untouched.

This is especially useful when:

• Debugging CTEs — check each CTE's output without commenting out the rest
• Verifying subqueries — select the inner SELECT and peek at what it returns
• Exploring data — quickly preview a table without opening a new tab or losing your current results
• Code review — when reading someone else's query, peek at intermediate results to understand the data flow

The floating panel is draggable, resizable, and dismissible. It runs the selected SQL as a separate query, so it doesn't interfere with your main execution context.

How This Compares

Basic autocomplete is universal. Function parameter hints exist in DataGrip and SSMS. But column inlay hints and Peek Results are rare — and the combination of all three across five database engines in a single tool is, as far as we know, unique to Jam SQL Studio.

Try It

All three features are available in Jam SQL Studio 1.4 for SQL Server, PostgreSQL, MySQL, Oracle, and SQLite. Parameter hints and inlay hints activate automatically. For Peek Results, select a statement in the editor and use the peek action from the context menu or toolbar.