SQL editor & workspace

Overview

The workspace ties an editor tab to a connection, gives every statement a CodeLens row of one‑click actions, and surfaces results in dedicated panels. You can pin queries as SQL Favorites or save them as files under a connection in the tree. For the recommended order of actions, see SQL workspace — action priority.

SQL workspace — action priority

Use this order for day-to-day work in a .sql tab. Higher numbers are for tuning, reuse, or advanced flows — not your first step.

Priority 1 — Write SQL & run a script

Start here: open or create a file, bind the database, write SQL, then run the whole script when you have multiple statements.

Priority 2 — Run one query

When you are iterating on a single statement, put the caret inside it and run only that block.

Results open in Query Results; errors and timings in SQL STATUS (panels).

Priority 3 — Write & run PL/SQL / DELIMITER blocks

Stored procedures, functions, and triggers use a custom delimiter so semicolons inside BEGIN … END do not split the script.

Details: DELIMITER & stored‑program blocks.

Other actions (when you need them)

These are important but secondary to write → run script → run one query → PL/SQL.

Open & create SQL files

SQLLens.AI works on normal .sql files in VS Code. Ways to start a new editor tab:

Syntax highlighting

SQLLens.AI registers a MySQL‑aware grammar for .sql files. Colors follow your VS Code theme; optional sqllens.ai Dark / sqllens.ai Light themes tune the editor chrome.

Typical highlighting in the editor:

• Keywords — SELECT, FROM, WHERE, JOIN, INSERT, CREATE, and other DML/DDL/control words.
• Strings — single‑quoted, double‑quoted, and backtick‑quoted identifiers (`column`).
• Comments — -- line, # line (MySQL), and /* … */ block comments (often muted).
• Numbers — numeric literals and decimals.
• Qualified names — schema.table and multi‑part names when spelled out.
• Functions — built‑ins such as COUNT, CONCAT, NOW before (.

The header comment on new SQL files (connection hint, tips) uses the comment style so it stays separate from executable SQL.

-- connection hint (comment — not executed)
SELECT emp_no, last_name          -- keyword + identifiers
FROM employees.employees AS e     -- qualified table + alias
WHERE hire_date > '2000-01-01'    -- string literal + comparison
  AND last_name LIKE 'K%';        -- pattern match

Explorer & active database

Each connection in the explorer expands into databases, tables, views, routines and triggers. The Active badge marks the database that new statements will run against. Double‑click any other database to switch.

The bar under the tab title shows Switch Database and the active target (for example hr_demo @ 127.0.0.1:3306) — click it to rebind without opening the tree.

Per‑file / Active database context

Every .sql file remembers the connection and database it was last run against. The status bar shows the binding; click it to rebind, or use SQL: Change Active Database in the Command Palette.

Saved queries in the tree vs SQL Favorites

CodeLens overview

CodeLens are the small clickable links that appear above lines in the SQL editor. SQLLens.AI uses them for run/optimize actions on the statement at your caret, database context at the top of the file, and (when enabled) AI helpers.

Turn CodeLens on

• In VS Code / Cursor: Settings → search Code Lens → enable Editor: Code Lens (editor.codeLens).
• To hide only SQLLens.AI lenses: set Disable Sql Code lens (skyline-mysql.disableSqlCodeLen) to true in Settings, then reload the window.

Which statement gets a row?

Statement CodeLens follow your caret (text cursor). SQLLens.AI parses the file into blocks (split on ; or the active connection delimiter) and shows one link row on the first line of the block that contains the caret.

• Move the caret into a different query to switch which row appears.
• Inside a CREATE PROCEDURE / TRIGGER body, lenses usually appear only on the opening line of that routine (not on every inner line).
• If the statement is empty or CodeLens is disabled, the row is hidden.

Where links appear

Line 1 of the file — Switch Database and the database @ connection chip (fixed; does not follow the caret).

Above the statement that contains your caret — links appear left → right in this order:

1. 🤖 Generate SQL (AI — when the line is a natural-language prompt; see AI CodeLens)
2. ▶ Run SQL
3. 🤖 Fix SQL Error with AI (after a failed run — see AI CodeLens)
4. ⚡ Optimize (only for SELECT, WITH, UPDATE, DELETE)
5. ✨ Beautify
6. 📖 Expand or 📕 Collapse (layout — when the statement is long enough)
7. ❌ Quick Fix or ⚠️ Quick Fix (static syntax hints — when analysis finds issues)
8. ☆ Save as Favorite (when the query is not already saved as a favorite)

EXPLAIN is not on the CodeLens row — use the editor right‑click menu or Command Palette (Explain Query).

Top of file — database & connection

On line 1 of every .sql file, SQLLens.AI shows which database this file runs against:

These chips stay at the top while you edit; they do not move with the caret. Per-file binding is described under per-file database context.

Statement row — full reference

AI CodeLens

Requires AI to be configured (see SQL with AI). If AI is off, these links do not appear.

When the caret is inside normal SQL (for example mid-SELECT), Generate SQL is hidden so it does not clash with run/optimize links.

Sample AI prompt lines

Put the caret on a prompt line and click 🤖 Generate SQL in CodeLens (or use the right‑click AI commands):

-- @ask: employees in Finance with salary above department average

@sql: list open tickets assigned to me with priority and due date

Which tables reference employees.employee_id?

AI: "create a report query: revenue by region for Q3"

Block-comment @AI with generated SQL

Keep the request in a block comment; generated SQL goes after */. Use 🔄 Regenerate SQL (AI) after editing the quoted prompt:

/* @AI "
List active employees in Engineering hired after 2023-01-01.
" */
SELECT e.emp_no, e.first_name, e.last_name
FROM employees e
JOIN dept_emp de ON de.emp_no = e.emp_no AND de.to_date = '9999-01-01'
JOIN departments d ON d.dept_no = de.dept_no
WHERE d.dept_name = 'Engineering' AND e.hire_date > '2023-01-01';

DELIMITER & stored‑program blocks

MySQL client scripts often use DELIMITER // … DELIMITER ; around routines. SQLLens.AI detects these blocks so Run sends the whole body, not one line at a time.

▶ RUN PLSQL Block

On each opening DELIMITER <token> line (where the token is not ;), an extra CodeLens appears:

• ▶ RUN PLSQL Block — runs from that DELIMITER line through the matching DELIMITER ;, including CREATE PROCEDURE, CREATE TRIGGER, and similar bodies.
• There is no CodeLens on the closing DELIMITER ; line itself.
• Very large files (thousands of lines) may skip delimiter scanning for performance; use normal ▶ Run SQL with the caret inside the block when needed.

DELIMITER //
CREATE PROCEDURE list_dept_headcount(IN p_dept_no CHAR(4))
BEGIN
  SELECT d.dept_name, COUNT(*) AS headcount
  FROM employees.dept_emp AS de
  INNER JOIN employees.departments AS d ON d.dept_no = de.dept_no
  WHERE de.dept_no = p_dept_no
    AND de.to_date = '9999-01-01'
  GROUP BY d.dept_name;
END //
DELIMITER ;

Place the caret on the procedure’s opening line or use ▶ RUN PLSQL Block on the DELIMITER // line to execute the entire script (including both DELIMITER lines and the CREATE PROCEDURE body). Semicolons inside BEGIN … END do not split the block.

Format & Beautify

Use the Beautify CodeLens, SQL: Format Query from the Command Palette, or expand/collapse layout commands to tidy multi‑line SQL.

SQL editor — right‑click menu

Right‑click anywhere in a .sql editor tab to open the full context menu. The list below matches the menu top to bottom when the file is in SQL language mode and connected to a database. The same SQLLens.AI actions appear on CodeLens above each statement.

On Windows and Linux, use Ctrl where this page shows ⌘ (Command).

Complete menu reference

Items that appear in other cases

• Set as SQL File — shown at the top when the document is not in SQL language mode (for example a plain-text file). Switches the editor to SQL so Run, CodeLens, and autocomplete work.
• Chat / Copilot rows — depend on which AI extensions you have installed (Cursor, GitHub Copilot, etc.). If you do not see them, use SQLLens.AI AI entries above or SQL with AI.

Query Results — right‑click menu

After you Run a query, right‑click a cell or row in the QUERY RESULTS grid (see result panels). Menus are context‑sensitive: edit actions require a result set that allows editing (for example a single-table SELECT).

Filter & copy

• Filter by column = 'value' — adds a WHERE filter using the clicked cell and re-runs (handy for drilling into one value).
• Copy → Cell Value — copies the cell to the clipboard.
• Copy → Row (Tab) — tab-separated row values.
• Copy → Row as INSERT / Row as UPDATE — SQL statements for that row.
• Copy → All Rows — Tab, CSV, JSON, or SQL for the full result set.

Edit rows (when enabled)

• Edit → Open Edit Dialog — form editor for the row.
• Edit → Set NULL / Set Empty String / Set to Default — quick cell edits in the grid.
• Insert New Row / Duplicate Row / Delete Row — row CRUD when the grid is editable.

Export, refresh & appearance

• Export — Excel (.xlsx), CSV, JSON, or SQL (INSERT) for all rows in the result.
• Refresh — re-runs the query that produced the grid.
• Appearance → Header Border Color — Blue, Green, Red, Purple, Orange, Yellow, Rainbow gradient, or reset to default.
• Appearance → Row Background Color — Default (transparent), light blue/green/yellow/purple/pink/orange tints, or reset to default. These only change how the grid looks in your session.

SQL Status — right‑click menu

Right‑click in the SQL STATUS panel (query log, errors, timings) for:

• Copy Selection — copies highlighted text in the panel.
• Copy All — copies the full log content.
• Export to Text… / Export to CSV… — saves the log to a file.
• Clear All — empties the status panel.

Individual error rows may also offer inline actions (for example copy SQL, search the error on the web, or ask AI for help) from buttons on the row — separate from this panel menu.

Autocomplete (IntelliSense)

While you type in a .sql file connected to MySQL/MariaDB, SQLLens.AI adds schema‑aware suggestions on top of VS Code’s editor. For the full reference — @com / @dba channels, screenshots, JOIN ON lines, favorites, and keyboard shortcuts — see SQL autocomplete.

How to open the list

• Implicit — keep typing; suggestions appear when VS Code’s Quick Suggestions are on.
• Explicit — Ctrl+Space (macOS may use ⌃+Space or ⌘+Space depending on your keymap).
• Filtering — more characters narrow the list; labels show whether a row is a table, column, favorite, diagnostic template, or keyword.
• Snippets — some rows insert multi‑line SQL; use Tab to jump placeholders like any VS Code snippet.

What you get

For drag‑and‑drop statement assembly, see Query builder; autocomplete and the builder share vocabulary but different gestures.

Example: after SELECT from a table, invoke suggestions (Ctrl+Space) to pick columns; after INNER JOIN employees.departments AS d ON accept a suggested ON line from foreign-key metadata:

SELECT e.emp_no, e.last_name, d.dept_name
FROM employees.employees AS e
INNER JOIN employees.dept_emp AS de ON de.emp_no = e.emp_no
INNER JOIN employees.departments AS d ON d.dept_no = de.dept_no
WHERE e.hire_date > '1990-01-01';

More copy-paste examples: Sample queries.

SQL Favorites

The SQL FAVORITES panel lists snippets you star for quick reuse. Open it from the bottom/side panel tabs (same row as QUERY RESULTS). For overall workflow order, see action priority — favorites are for reuse after you have working SQL (Priority 2 run, or save from Priority 1).

Favorites panel — suggested order

1. Run — double‑click a favorite or use the panel run action when you already trust the snippet (same as Priority 2).
2. Insert — click a row to paste into the editor, then edit and ▶ Run SQL.
3. Save / manage — star from CodeLens ☆ Save as Favorite or add from the panel; rename, folder, delete via Manage.

Save a favorite

• Click Favorite on the CodeLens row above a statement, or run ★ Favorites: Add Current Query (mysql.favorite.add) from the Command Palette.
• Give the snippet a name and optional shortcuts — favorites can also appear in the completion list when you type the name prefix.

Insert or run a favorite

• Panel — expand a folder, click a row to insert, or use run actions from the panel toolbar.
• Drag — drag a favorite into the editor to insert at the drop position.
• Autocomplete — type the favorite name or shortcut at the start of a line (or after ;); pick the row marked as a user favorite to expand the full SQL.
• Keyboard — ★ Favorites: Insert Query (mysql.favorite.insert): default ⌘+K then F (see shortcuts).
• Manage — ★ Favorites: Manage renames, folders, and deletes without leaving VS Code.

Example snippet worth starring (safe read-only pattern):

SELECT emp_no, first_name, last_name, hire_date
FROM employees.employees
ORDER BY hire_date DESC
LIMIT 100;

Run, EXPLAIN & Optimize

Use CodeLens or the right‑click menu to work with the statement at your caret:

• ▶ Run SQL (CodeLens) or Run SQL Query (menu) — executes one statement; rows appear in Query Results (see panels below).
• Run All Queries — menu or shortcut only; runs every statement in the file in order.
• Explain Query — right‑click or Command Palette; sends EXPLAIN or EXPLAIN ANALYZE when supported.
• ⚡ Optimize (CodeLens) or Optimize Query (Visual Explain) (menu) — opens the Query Optimizer workbench with Visual Explain and index suggestions.

Place the caret inside this statement, then use ▶ Run SQL, Explain Query, or ⚡ Optimize:

SELECT
    e.emp_no,
    e.first_name,
    e.last_name,
    d.dept_name
FROM employees.employees AS e
INNER JOIN employees.dept_emp AS de
    ON de.emp_no = e.emp_no AND de.to_date = '9999-01-01'
INNER JOIN employees.departments AS d ON d.dept_no = de.dept_no
WHERE e.last_name LIKE 'K%'
ORDER BY d.dept_name, e.last_name
LIMIT 50;

Query Results, SQL Status & side panels

Result sets appear in the Query Results view (grid or tab per skyline-mysql.resultDisplayMode). Status messages, notices and client errors show in the SQL / MySQL output channel. Pin panels next to the editor when you want results visible while editing the next statement.

Tree search

Use the filter at the top of the explorer to fuzzy‑find a table, view or routine across all databases on the connection.

Sample queries

These examples use the public employees sample schema (MySQL employees database). Adjust schema/table names if your server uses a different database name. Pair with Query builder drags or SQL with AI to build variants faster.

Connection probe

Run after connecting to confirm the database is reachable:

SELECT 1;

SELECT COUNT(*) AS employee_rows
FROM employees.employees;

Simple SELECT

List ten employees with name and hire date — use ▶ Run SQL on this block:

SELECT
    emp_no,
    first_name,
    last_name,
    hire_date
FROM employees.employees
ORDER BY hire_date DESC
LIMIT 10;

Joins (department per employee)

Current assignment uses to_date = '9999-01-01' in the sample data. Good for ⚡ Optimize and JOIN autocomplete demos:

SELECT
    e.emp_no,
    e.first_name,
    e.last_name,
    d.dept_name
FROM employees.employees AS e
INNER JOIN employees.dept_emp AS de
    ON de.emp_no = e.emp_no AND de.to_date = '9999-01-01'
INNER JOIN employees.departments AS d ON d.dept_no = de.dept_no
WHERE e.last_name LIKE 'K%'
ORDER BY d.dept_name, e.last_name
LIMIT 50;

Average salary by department

SELECT
    d.dept_name,
    ROUND(AVG(s.salary), 2) AS avg_salary
FROM employees.salaries AS s
INNER JOIN employees.employees AS e ON e.emp_no = s.emp_no
INNER JOIN employees.dept_emp AS de
    ON de.emp_no = e.emp_no AND de.to_date = '9999-01-01'
INNER JOIN employees.departments AS d ON d.dept_no = de.dept_no
WHERE s.to_date = '9999-01-01'
GROUP BY d.dept_name
ORDER BY avg_salary DESC;

Subquery (salary above company average)

SELECT
    e.first_name,
    e.last_name,
    s.salary
FROM employees.employees AS e
INNER JOIN employees.salaries AS s
    ON s.emp_no = e.emp_no AND s.to_date = '9999-01-01'
WHERE s.salary > (
    SELECT AVG(s2.salary)
    FROM employees.salaries AS s2
    WHERE s2.to_date = '9999-01-01'
)
ORDER BY s.salary DESC
LIMIT 25;

CTE (salary above department average)

WITH dept_avg AS (
    SELECT
        de.dept_no,
        ROUND(AVG(s.salary), 2) AS avg_salary
    FROM employees.salaries AS s
    INNER JOIN employees.employees AS e ON e.emp_no = s.emp_no
    INNER JOIN employees.dept_emp AS de
        ON de.emp_no = e.emp_no AND de.to_date = '9999-01-01'
    WHERE s.to_date = '9999-01-01'
    GROUP BY de.dept_no
)
SELECT
    e.emp_no,
    e.first_name,
    e.last_name,
    d.dept_name,
    s.salary,
    da.avg_salary
FROM employees.employees AS e
INNER JOIN employees.salaries AS s
    ON s.emp_no = e.emp_no AND s.to_date = '9999-01-01'
INNER JOIN employees.dept_emp AS de
    ON de.emp_no = e.emp_no AND de.to_date = '9999-01-01'
INNER JOIN employees.departments AS d ON d.dept_no = de.dept_no
INNER JOIN dept_avg AS da ON da.dept_no = de.dept_no
WHERE s.salary > da.avg_salary
ORDER BY s.salary DESC
LIMIT 40;

DML patterns (review before run)

Use on a sandbox database only. Type ins / u / del before dragging tables in the Query builder, or paste these templates:

INSERT

INSERT INTO employees.departments (dept_no, dept_name)
VALUES ('d010', 'AI Research');

UPDATE

UPDATE employees.employees
SET first_name = 'Ann'
WHERE emp_no = 10001;

DELETE

DELETE FROM employees.departments
WHERE dept_no = 'd010';

DELIMITER blocks (procedures, functions, triggers)

MySQL client tools change the statement terminator so semicolons inside BEGIN … END are allowed. SQLLens.AI treats everything from an opening DELIMITER <token> through DELIMITER ; as one unit. Use ▶ RUN PLSQL Block on the opening DELIMITER line (see DELIMITER & stored‑program blocks).

Stored procedure (// token)

DELIMITER //
DROP PROCEDURE IF EXISTS list_dept_headcount //
CREATE PROCEDURE list_dept_headcount(IN p_dept_no CHAR(4))
BEGIN
  SELECT d.dept_name, COUNT(*) AS headcount
  FROM employees.dept_emp AS de
  INNER JOIN employees.departments AS d ON d.dept_no = de.dept_no
  WHERE de.dept_no = p_dept_no
    AND de.to_date = '9999-01-01'
  GROUP BY d.dept_name;
END //
DELIMITER ;

-- Run separately after the block is created:
CALL list_dept_headcount('d001');

Function ($$ token)

DELIMITER $$
DROP FUNCTION IF EXISTS current_title$$
CREATE FUNCTION current_title(p_emp_no INT)
RETURNS VARCHAR(50)
READS SQL DATA
BEGIN
  DECLARE v_title VARCHAR(50);
  SELECT t.title INTO v_title
  FROM employees.titles AS t
  WHERE t.emp_no = p_emp_no
    AND t.to_date = '9999-01-01'
  ORDER BY t.from_date DESC
  LIMIT 1;
  RETURN v_title;
END$$
DELIMITER ;

SELECT emp_no, current_title(10001) AS title FROM employees.employees LIMIT 5;

Trigger ($$ token)

Use on a sandbox table only — adjust the table name if needed:

DELIMITER $$
DROP TRIGGER IF EXISTS employees.trg_employees_trim_name$$
CREATE TRIGGER trg_employees_trim_name
BEFORE UPDATE ON employees.employees
FOR EACH ROW
BEGIN
  SET NEW.last_name = TRIM(NEW.last_name);
  SET NEW.first_name = TRIM(NEW.first_name);
END$$
DELIMITER ;

Mixed file: plain SQL + DELIMITER block

Regular statements end with ;. The routine block keeps inner semicolons — do not rely on Run All for the whole file when a DELIMITER section is present; run the probe query, then ▶ RUN PLSQL Block on the opening DELIMITER line, then CALL:

SELECT COUNT(*) AS employee_rows FROM employees.employees;

DELIMITER //
CREATE PROCEDURE list_dept_headcount(IN p_dept_no CHAR(4))
BEGIN
  SELECT d.dept_name, COUNT(*) AS headcount
  FROM employees.dept_emp AS de
  INNER JOIN employees.departments AS d ON d.dept_no = de.dept_no
  WHERE de.dept_no = p_dept_no AND de.to_date = '9999-01-01'
  GROUP BY d.dept_name;
END //
DELIMITER ;

CALL list_dept_headcount('d005');

Multiple statements in one file

Use Run All Queries (⌘+Shift+↵) to execute each statement in order; status for each appears in SQL STATUS:

SELECT COUNT(*) AS n FROM employees.employees;

SELECT COUNT(*) AS n FROM employees.departments;

SELECT COUNT(*) AS n FROM employees.salaries WHERE to_date = '9999-01-01';

EXISTS (engineers with a current title)

SELECT e.emp_no, e.first_name, e.last_name
FROM employees.employees AS e
WHERE EXISTS (
    SELECT 1
    FROM employees.titles AS t
    WHERE t.emp_no = e.emp_no
      AND t.to_date = '9999-01-01'
      AND t.title LIKE '%Engineer%'
)
ORDER BY e.emp_no
LIMIT 50;

Related

• Query builder
• LLMs & AI
• Settings reference
• Schema & database objects
• Data import, export & schema tools