@enjoys/context-engine 1.0.7 → 1.0.8

package/data/completion/sql.json

@@ -4,884 +4,3016 @@
     {
       "label": "SELECT",
       "kind": 14,
-      "detail": "Select rows from tables",
-      "documentation": { "value": "Retrieves rows from one or more tables. Supports filtering, grouping, ordering, and limiting results." },
-      "insertText": "SELECT ${1:columns} FROM ${2:table}",
+      "detail": "Select statement",
+      "documentation": {
+        "value": "Retrieve data from one or more tables.\n\n```sql\nSELECT name, email FROM users WHERE active = true;\n```"
+      },
+      "insertText": "SELECT ${1:columns}\nFROM ${2:table}\nWHERE ${3:condition};",
       "insertTextRules": 4,
-      "sortText": "00_SELECT"
+      "sortText": "00_select"
+    },
+    {
+      "label": "SELECT WHERE",
+      "kind": 15,
+      "detail": "Select with WHERE",
+      "documentation": {
+        "value": "Query with a filter condition.\n\n```sql\nSELECT * FROM orders WHERE status = 'shipped';\n```"
+      },
+      "insertText": "SELECT ${1:*}\nFROM ${2:table}\nWHERE ${3:column} = ${4:'value'};",
+      "insertTextRules": 4,
+      "sortText": "00_select_where"
+    },
+    {
+      "label": "SELECT JOIN",
+      "kind": 15,
+      "detail": "Select with JOIN",
+      "documentation": {
+        "value": "Query joining two tables.\n\n```sql\nSELECT u.name, o.total\nFROM users u\nJOIN orders o ON u.id = o.user_id;\n```"
+      },
+      "insertText": "SELECT ${1:a.column}, ${2:b.column}\nFROM ${3:table1} ${4:a}\nJOIN ${5:table2} ${6:b} ON ${4:a}.${7:id} = ${6:b}.${8:foreign_id};",
+      "insertTextRules": 4,
+      "sortText": "00_select_join"
+    },
+    {
+      "label": "SELECT GROUP BY",
+      "kind": 15,
+      "detail": "Select with GROUP BY / HAVING",
+      "documentation": {
+        "value": "Aggregate query with grouping.\n\n```sql\nSELECT department, COUNT(*)\nFROM employees\nGROUP BY department\nHAVING COUNT(*) > 5;\n```"
+      },
+      "insertText": "SELECT ${1:column}, ${2:COUNT(*)} \nFROM ${3:table}\nGROUP BY ${1:column}\nHAVING ${4:condition};",
+      "insertTextRules": 4,
+      "sortText": "00_select_group_by"
+    },
+    {
+      "label": "SELECT ORDER BY LIMIT",
+      "kind": 15,
+      "detail": "Select with ORDER BY and LIMIT",
+      "documentation": {
+        "value": "Sorted and paginated query.\n\n```sql\nSELECT * FROM products ORDER BY price DESC LIMIT 10;\n```"
+      },
+      "insertText": "SELECT ${1:*}\nFROM ${2:table}\nORDER BY ${3:column} ${4|ASC,DESC|}\nLIMIT ${5:10};",
+      "insertTextRules": 4,
+      "sortText": "00_select_order_by_limit"
     },
     {
       "label": "SELECT DISTINCT",
       "kind": 15,
-      "detail": "Select unique rows",
-      "documentation": { "value": "Retrieves only distinct (unique) rows from a query result, eliminating duplicate records." },
-      "insertText": "SELECT DISTINCT ${1:columns} FROM ${2:table}",
+      "detail": "Select distinct rows",
+      "documentation": {
+        "value": "Return only unique rows.\n\n```sql\nSELECT DISTINCT category FROM products;\n```"
+      },
+      "insertText": "SELECT DISTINCT ${1:columns}\nFROM ${2:table};",
+      "insertTextRules": 4,
+      "sortText": "00_select_distinct"
+    },
+    {
+      "label": "SELECT aliases",
+      "kind": 15,
+      "detail": "Select with aliases",
+      "documentation": {
+        "value": "Use column and table aliases.\n\n```sql\nSELECT u.name AS user_name, o.total AS order_total\nFROM users AS u\nJOIN orders AS o ON u.id = o.user_id;\n```"
+      },
+      "insertText": "SELECT ${1:t}.${2:column} AS ${3:alias}\nFROM ${4:table} AS ${1:t};",
+      "insertTextRules": 4,
+      "sortText": "00_select_aliases"
+    },
+    {
+      "label": "SELECT subquery",
+      "kind": 15,
+      "detail": "Subquery in SELECT",
+      "documentation": {
+        "value": "Scalar subquery in the SELECT list.\n\n```sql\nSELECT name,\n  (SELECT COUNT(*) FROM orders o WHERE o.user_id = u.id) AS order_count\nFROM users u;\n```"
+      },
+      "insertText": "SELECT ${1:column},\n  (SELECT ${2:COUNT(*)} FROM ${3:table2} ${4:b} WHERE ${4:b}.${5:fk} = ${6:a}.${7:pk}) AS ${8:alias}\nFROM ${9:table1} ${6:a};",
+      "insertTextRules": 4,
+      "sortText": "00_select_subquery"
+    },
+    {
+      "label": "SELECT EXISTS",
+      "kind": 15,
+      "detail": "EXISTS subquery",
+      "documentation": {
+        "value": "Check for the existence of rows.\n\n```sql\nSELECT * FROM users u\nWHERE EXISTS (\n  SELECT 1 FROM orders o WHERE o.user_id = u.id\n);\n```"
+      },
+      "insertText": "SELECT ${1:*}\nFROM ${2:table1} ${3:a}\nWHERE EXISTS (\n  SELECT 1 FROM ${4:table2} ${5:b}\n  WHERE ${5:b}.${6:fk} = ${3:a}.${7:pk}\n);",
+      "insertTextRules": 4,
+      "sortText": "00_select_exists"
+    },
+    {
+      "label": "Correlated subquery",
+      "kind": 15,
+      "detail": "Correlated subquery",
+      "documentation": {
+        "value": "Subquery that references the outer query.\n\n```sql\nSELECT e.name, e.salary\nFROM employees e\nWHERE e.salary > (\n  SELECT AVG(salary) FROM employees WHERE dept = e.dept\n);\n```"
+      },
+      "insertText": "SELECT ${1:a}.${2:column}\nFROM ${3:table} ${1:a}\nWHERE ${1:a}.${4:col} ${5:>} (\n  SELECT ${6:AGG(col)} FROM ${3:table}\n  WHERE ${7:group_col} = ${1:a}.${7:group_col}\n);",
+      "insertTextRules": 4,
+      "sortText": "00_correlated_subquery"
+    },
+    {
+      "label": "SELECT INTO",
+      "kind": 15,
+      "detail": "Select into new table",
+      "documentation": {
+        "value": "Create a new table from query results.\n\n```sql\nSELECT * INTO new_table FROM old_table WHERE condition;\n```"
+      },
+      "insertText": "SELECT ${1:*}\nINTO ${2:new_table}\nFROM ${3:old_table}\nWHERE ${4:condition};",
+      "insertTextRules": 4,
+      "sortText": "00_select_into"
+    },
+    {
+      "label": "INSERT",
+      "kind": 14,
+      "detail": "Insert statement",
+      "documentation": {
+        "value": "Insert a row into a table.\n\n```sql\nINSERT INTO users (name, email) VALUES ('Alice', 'alice@example.com');\n```"
+      },
+      "insertText": "INSERT INTO ${1:table} (${2:columns})\nVALUES (${3:values});",
+      "insertTextRules": 4,
+      "sortText": "00_insert"
+    },
+    {
+      "label": "INSERT multiple rows",
+      "kind": 15,
+      "detail": "Insert multiple rows",
+      "documentation": {
+        "value": "Insert several rows at once.\n\n```sql\nINSERT INTO products (name, price)\nVALUES ('A', 10), ('B', 20), ('C', 30);\n```"
+      },
+      "insertText": "INSERT INTO ${1:table} (${2:columns})\nVALUES\n  (${3:values1}),\n  (${4:values2}),\n  (${5:values3});",
+      "insertTextRules": 4,
+      "sortText": "00_insert_multiple_rows"
+    },
+    {
+      "label": "INSERT SELECT",
+      "kind": 15,
+      "detail": "Insert from select",
+      "documentation": {
+        "value": "Insert rows from a query.\n\n```sql\nINSERT INTO archive (id, name)\nSELECT id, name FROM users WHERE active = false;\n```"
+      },
+      "insertText": "INSERT INTO ${1:target} (${2:columns})\nSELECT ${2:columns}\nFROM ${3:source}\nWHERE ${4:condition};",
+      "insertTextRules": 4,
+      "sortText": "00_insert_select"
+    },
+    {
+      "label": "INSERT ON CONFLICT",
+      "kind": 15,
+      "detail": "Insert on conflict (upsert, PostgreSQL)",
+      "documentation": {
+        "value": "Upsert using ON CONFLICT.\n\n```sql\nINSERT INTO users (id, name, email)\nVALUES (1, 'Alice', 'a@b.com')\nON CONFLICT (id)\nDO UPDATE SET name = EXCLUDED.name, email = EXCLUDED.email;\n```"
+      },
+      "insertText": "INSERT INTO ${1:table} (${2:columns})\nVALUES (${3:values})\nON CONFLICT (${4:conflict_column})\nDO UPDATE SET ${5:column} = EXCLUDED.${5:column};",
+      "insertTextRules": 4,
+      "sortText": "00_insert_on_conflict"
+    },
+    {
+      "label": "INSERT ON DUPLICATE KEY",
+      "kind": 15,
+      "detail": "Insert on duplicate key (MySQL)",
+      "documentation": {
+        "value": "Upsert using ON DUPLICATE KEY UPDATE.\n\n```sql\nINSERT INTO users (id, name)\nVALUES (1, 'Alice')\nON DUPLICATE KEY UPDATE name = VALUES(name);\n```"
+      },
+      "insertText": "INSERT INTO ${1:table} (${2:columns})\nVALUES (${3:values})\nON DUPLICATE KEY UPDATE ${4:column} = VALUES(${4:column});",
+      "insertTextRules": 4,
+      "sortText": "00_insert_on_duplicate_key"
+    },
+    {
+      "label": "INSERT RETURNING",
+      "kind": 15,
+      "detail": "Insert with RETURNING (PostgreSQL)",
+      "documentation": {
+        "value": "Return inserted data.\n\n```sql\nINSERT INTO users (name) VALUES ('Alice') RETURNING id, name;\n```"
+      },
+      "insertText": "INSERT INTO ${1:table} (${2:columns})\nVALUES (${3:values})\nRETURNING ${4:*};",
+      "insertTextRules": 4,
+      "sortText": "00_insert_returning"
+    },
+    {
+      "label": "UPDATE",
+      "kind": 14,
+      "detail": "Update statement",
+      "documentation": {
+        "value": "Modify existing rows.\n\n```sql\nUPDATE users SET active = false WHERE last_login < '2024-01-01';\n```"
+      },
+      "insertText": "UPDATE ${1:table}\nSET ${2:column} = ${3:value}\nWHERE ${4:condition};",
+      "insertTextRules": 4,
+      "sortText": "00_update"
+    },
+    {
+      "label": "UPDATE JOIN",
+      "kind": 15,
+      "detail": "Update with JOIN",
+      "documentation": {
+        "value": "Update using a joined table.\n\n```sql\nUPDATE orders o\nSET o.status = 'cancelled'\nFROM users u\nWHERE o.user_id = u.id AND u.active = false;\n```"
+      },
+      "insertText": "UPDATE ${1:table1} ${2:a}\nSET ${2:a}.${3:column} = ${4:value}\nFROM ${5:table2} ${6:b}\nWHERE ${2:a}.${7:fk} = ${6:b}.${8:pk}\n  AND ${9:condition};",
+      "insertTextRules": 4,
+      "sortText": "00_update_join"
+    },
+    {
+      "label": "UPDATE subquery",
+      "kind": 15,
+      "detail": "Update with subquery",
+      "documentation": {
+        "value": "Update using a subquery.\n\n```sql\nUPDATE products\nSET price = price * 1.1\nWHERE category_id IN (\n  SELECT id FROM categories WHERE name = 'Electronics'\n);\n```"
+      },
+      "insertText": "UPDATE ${1:table}\nSET ${2:column} = ${3:value}\nWHERE ${4:column} IN (\n  SELECT ${5:column} FROM ${6:table2} WHERE ${7:condition}\n);",
+      "insertTextRules": 4,
+      "sortText": "00_update_subquery"
+    },
+    {
+      "label": "UPDATE RETURNING",
+      "kind": 15,
+      "detail": "Update with RETURNING (PostgreSQL)",
+      "documentation": {
+        "value": "Return updated rows.\n\n```sql\nUPDATE users SET active = true WHERE id = 1 RETURNING *;\n```"
+      },
+      "insertText": "UPDATE ${1:table}\nSET ${2:column} = ${3:value}\nWHERE ${4:condition}\nRETURNING ${5:*};",
+      "insertTextRules": 4,
+      "sortText": "00_update_returning"
+    },
+    {
+      "label": "DELETE",
+      "kind": 14,
+      "detail": "Delete statement",
+      "documentation": {
+        "value": "Remove rows from a table.\n\n```sql\nDELETE FROM users WHERE active = false;\n```"
+      },
+      "insertText": "DELETE FROM ${1:table}\nWHERE ${2:condition};",
+      "insertTextRules": 4,
+      "sortText": "00_delete"
+    },
+    {
+      "label": "DELETE JOIN",
+      "kind": 15,
+      "detail": "Delete with JOIN",
+      "documentation": {
+        "value": "Delete using a joined table.\n\n```sql\nDELETE o\nFROM orders o\nJOIN users u ON o.user_id = u.id\nWHERE u.active = false;\n```"
+      },
+      "insertText": "DELETE ${1:a}\nFROM ${2:table1} ${1:a}\nJOIN ${3:table2} ${4:b} ON ${1:a}.${5:fk} = ${4:b}.${6:pk}\nWHERE ${7:condition};",
+      "insertTextRules": 4,
+      "sortText": "00_delete_join"
+    },
+    {
+      "label": "DELETE RETURNING",
+      "kind": 15,
+      "detail": "Delete with RETURNING (PostgreSQL)",
+      "documentation": {
+        "value": "Return deleted rows.\n\n```sql\nDELETE FROM users WHERE active = false RETURNING id, name;\n```"
+      },
+      "insertText": "DELETE FROM ${1:table}\nWHERE ${2:condition}\nRETURNING ${3:*};",
+      "insertTextRules": 4,
+      "sortText": "00_delete_returning"
+    },
+    {
+      "label": "TRUNCATE",
+      "kind": 14,
+      "detail": "Truncate table",
+      "documentation": {
+        "value": "Remove all rows from a table (fast, non-logged).\n\n```sql\nTRUNCATE TABLE logs;\n```"
+      },
+      "insertText": "TRUNCATE TABLE ${1:table};",
+      "insertTextRules": 4,
+      "sortText": "00_truncate"
+    },
+    {
+      "label": "MERGE",
+      "kind": 15,
+      "detail": "Merge / upsert (SQL:2003)",
+      "documentation": {
+        "value": "ANSI MERGE statement.\n\n```sql\nMERGE INTO target t\nUSING source s ON t.id = s.id\nWHEN MATCHED THEN UPDATE SET t.name = s.name\nWHEN NOT MATCHED THEN INSERT (id, name) VALUES (s.id, s.name);\n```"
+      },
+      "insertText": "MERGE INTO ${1:target} ${2:t}\nUSING ${3:source} ${4:s} ON ${2:t}.${5:id} = ${4:s}.${5:id}\nWHEN MATCHED THEN\n  UPDATE SET ${2:t}.${6:col} = ${4:s}.${6:col}\nWHEN NOT MATCHED THEN\n  INSERT (${7:columns}) VALUES (${8:values});",
+      "insertTextRules": 4,
+      "sortText": "00_merge"
+    },
+    {
+      "label": "CREATE TABLE",
+      "kind": 15,
+      "detail": "Create table",
+      "documentation": {
+        "value": "Create a new table.\n\n```sql\nCREATE TABLE users (\n  id SERIAL PRIMARY KEY,\n  name VARCHAR(100) NOT NULL\n);\n```"
+      },
+      "insertText": "CREATE TABLE ${1:table_name} (\n  ${2:id} ${3:SERIAL} PRIMARY KEY,\n  ${4:column} ${5:VARCHAR(255)} ${6:NOT NULL}\n);",
+      "insertTextRules": 4,
+      "sortText": "00_create_table"
+    },
+    {
+      "label": "CREATE TABLE constraints",
+      "kind": 15,
+      "detail": "Create table with constraints",
+      "documentation": {
+        "value": "Table with multiple constraints.\n\n```sql\nCREATE TABLE orders (\n  id SERIAL PRIMARY KEY,\n  user_id INT NOT NULL REFERENCES users(id),\n  amount NUMERIC(10,2) CHECK (amount > 0),\n  status VARCHAR(20) DEFAULT 'pending'\n);\n```"
+      },
+      "insertText": "CREATE TABLE ${1:table_name} (\n  ${2:id} SERIAL PRIMARY KEY,\n  ${3:foreign_col} INT NOT NULL REFERENCES ${4:parent}(${5:id}),\n  ${6:col} ${7:NUMERIC(10,2)} CHECK (${6:col} ${8:> 0}),\n  ${9:col2} ${10:VARCHAR(50)} DEFAULT ${11:'value'}\n);",
+      "insertTextRules": 4,
+      "sortText": "00_create_table_constraints"
+    },
+    {
+      "label": "CREATE TABLE FK",
+      "kind": 15,
+      "detail": "Create table with foreign key",
+      "documentation": {
+        "value": "Table with explicit foreign key constraint.\n\n```sql\nCREATE TABLE order_items (\n  id SERIAL PRIMARY KEY,\n  order_id INT NOT NULL,\n  product_id INT NOT NULL,\n  CONSTRAINT fk_order FOREIGN KEY (order_id) REFERENCES orders(id) ON DELETE CASCADE\n);\n```"
+      },
+      "insertText": "CREATE TABLE ${1:table_name} (\n  ${2:id} SERIAL PRIMARY KEY,\n  ${3:fk_col} INT NOT NULL,\n  CONSTRAINT ${4:fk_name} FOREIGN KEY (${3:fk_col})\n    REFERENCES ${5:parent_table}(${6:parent_col})\n    ON DELETE ${7|CASCADE,SET NULL,RESTRICT,NO ACTION|}\n);",
+      "insertTextRules": 4,
+      "sortText": "00_create_table_fk"
+    },
+    {
+      "label": "CREATE TABLE composite PK",
+      "kind": 15,
+      "detail": "Create table with composite primary key",
+      "documentation": {
+        "value": "Table with a multi-column primary key.\n\n```sql\nCREATE TABLE enrollment (\n  student_id INT,\n  course_id INT,\n  enrolled_at TIMESTAMP DEFAULT NOW(),\n  PRIMARY KEY (student_id, course_id)\n);\n```"
+      },
+      "insertText": "CREATE TABLE ${1:table_name} (\n  ${2:col1} ${3:INT},\n  ${4:col2} ${5:INT},\n  ${6:col3} ${7:TIMESTAMP} DEFAULT ${8:NOW()},\n  PRIMARY KEY (${2:col1}, ${4:col2})\n);",
+      "insertTextRules": 4,
+      "sortText": "00_create_table_composite_pk"
+    },
+    {
+      "label": "CREATE TABLE IF NOT EXISTS",
+      "kind": 15,
+      "detail": "Create table if not exists",
+      "documentation": {
+        "value": "Create only if table doesn't exist.\n\n```sql\nCREATE TABLE IF NOT EXISTS logs (\n  id SERIAL PRIMARY KEY,\n  message TEXT,\n  created_at TIMESTAMP DEFAULT NOW()\n);\n```"
+      },
+      "insertText": "CREATE TABLE IF NOT EXISTS ${1:table_name} (\n  ${2:id} SERIAL PRIMARY KEY,\n  ${3:column} ${4:TEXT},\n  ${5:created_at} TIMESTAMP DEFAULT NOW()\n);",
+      "insertTextRules": 4,
+      "sortText": "00_create_table_if_not_exists"
+    },
+    {
+      "label": "CREATE TABLE AS SELECT",
+      "kind": 15,
+      "detail": "Create table as select",
+      "documentation": {
+        "value": "Create a table from a query.\n\n```sql\nCREATE TABLE active_users AS\nSELECT * FROM users WHERE active = true;\n```"
+      },
+      "insertText": "CREATE TABLE ${1:new_table} AS\nSELECT ${2:*}\nFROM ${3:source_table}\nWHERE ${4:condition};",
+      "insertTextRules": 4,
+      "sortText": "00_create_table_as_select"
+    },
+    {
+      "label": "CREATE TEMP TABLE",
+      "kind": 15,
+      "detail": "Create temporary table",
+      "documentation": {
+        "value": "Create a session-scoped temporary table.\n\n```sql\nCREATE TEMPORARY TABLE tmp_results (\n  id INT, value TEXT\n);\n```"
+      },
+      "insertText": "CREATE TEMPORARY TABLE ${1:tmp_table} (\n  ${2:id} ${3:INT},\n  ${4:column} ${5:TEXT}\n);",
+      "insertTextRules": 4,
+      "sortText": "00_create_temp_table"
+    },
+    {
+      "label": "CREATE TABLE partitioned",
+      "kind": 15,
+      "detail": "Create partitioned table (PostgreSQL)",
+      "documentation": {
+        "value": "Create a table with range partitioning.\n\n```sql\nCREATE TABLE measurements (\n  id SERIAL,\n  measured_at DATE NOT NULL,\n  value NUMERIC\n) PARTITION BY RANGE (measured_at);\n```"
+      },
+      "insertText": "CREATE TABLE ${1:table_name} (\n  ${2:id} SERIAL,\n  ${3:partition_col} ${4:DATE} NOT NULL,\n  ${5:col} ${6:NUMERIC}\n) PARTITION BY ${7|RANGE,LIST,HASH|} (${3:partition_col});",
+      "insertTextRules": 4,
+      "sortText": "00_create_table_partitioned"
+    },
+    {
+      "label": "ALTER TABLE ADD COLUMN",
+      "kind": 15,
+      "detail": "Add column",
+      "documentation": {
+        "value": "Add a new column to a table.\n\n```sql\nALTER TABLE users ADD COLUMN phone VARCHAR(20);\n```"
+      },
+      "insertText": "ALTER TABLE ${1:table}\nADD COLUMN ${2:column_name} ${3:data_type};",
+      "insertTextRules": 4,
+      "sortText": "00_alter_table_add_column"
+    },
+    {
+      "label": "ALTER TABLE DROP COLUMN",
+      "kind": 15,
+      "detail": "Drop column",
+      "documentation": {
+        "value": "Remove a column.\n\n```sql\nALTER TABLE users DROP COLUMN phone;\n```"
+      },
+      "insertText": "ALTER TABLE ${1:table}\nDROP COLUMN ${2:column_name};",
+      "insertTextRules": 4,
+      "sortText": "00_alter_table_drop_column"
+    },
+    {
+      "label": "ALTER TABLE RENAME COLUMN",
+      "kind": 15,
+      "detail": "Rename column",
+      "documentation": {
+        "value": "Rename a column.\n\n```sql\nALTER TABLE users RENAME COLUMN name TO full_name;\n```"
+      },
+      "insertText": "ALTER TABLE ${1:table}\nRENAME COLUMN ${2:old_name} TO ${3:new_name};",
+      "insertTextRules": 4,
+      "sortText": "00_alter_table_rename_column"
+    },
+    {
+      "label": "ALTER TABLE ALTER TYPE",
+      "kind": 15,
+      "detail": "Alter column type",
+      "documentation": {
+        "value": "Change a column's data type.\n\n```sql\nALTER TABLE users ALTER COLUMN age TYPE BIGINT;\n```"
+      },
+      "insertText": "ALTER TABLE ${1:table}\nALTER COLUMN ${2:column} TYPE ${3:new_type};",
+      "insertTextRules": 4,
+      "sortText": "00_alter_table_alter_type"
+    },
+    {
+      "label": "ALTER TABLE ADD CONSTRAINT",
+      "kind": 15,
+      "detail": "Add constraint",
+      "documentation": {
+        "value": "Add a constraint to a table.\n\n```sql\nALTER TABLE orders ADD CONSTRAINT chk_amount CHECK (amount > 0);\n```"
+      },
+      "insertText": "ALTER TABLE ${1:table}\nADD CONSTRAINT ${2:constraint_name} ${3|CHECK,UNIQUE,FOREIGN KEY|} (${4:column});",
+      "insertTextRules": 4,
+      "sortText": "00_alter_table_add_constraint"
+    },
+    {
+      "label": "ALTER TABLE DROP CONSTRAINT",
+      "kind": 15,
+      "detail": "Drop constraint",
+      "documentation": {
+        "value": "Remove a constraint.\n\n```sql\nALTER TABLE orders DROP CONSTRAINT chk_amount;\n```"
+      },
+      "insertText": "ALTER TABLE ${1:table}\nDROP CONSTRAINT ${2:constraint_name};",
+      "insertTextRules": 4,
+      "sortText": "00_alter_table_drop_constraint"
+    },
+    {
+      "label": "ALTER TABLE RENAME",
+      "kind": 15,
+      "detail": "Rename table",
+      "documentation": {
+        "value": "Rename a table.\n\n```sql\nALTER TABLE old_name RENAME TO new_name;\n```"
+      },
+      "insertText": "ALTER TABLE ${1:old_name}\nRENAME TO ${2:new_name};",
+      "insertTextRules": 4,
+      "sortText": "00_alter_table_rename"
+    },
+    {
+      "label": "ALTER TABLE ADD INDEX",
+      "kind": 15,
+      "detail": "Add index (MySQL)",
+      "documentation": {
+        "value": "Add an index to a table.\n\n```sql\nALTER TABLE users ADD INDEX idx_email (email);\n```"
+      },
+      "insertText": "ALTER TABLE ${1:table}\nADD INDEX ${2:idx_name} (${3:column});",
+      "insertTextRules": 4,
+      "sortText": "00_alter_table_add_index"
+    },
+    {
+      "label": "DROP TABLE",
+      "kind": 14,
+      "detail": "Drop table",
+      "documentation": {
+        "value": "Remove a table.\n\n```sql\nDROP TABLE users;\n```"
+      },
+      "insertText": "DROP TABLE ${1:table_name};",
+      "insertTextRules": 4,
+      "sortText": "00_drop table"
+    },
+    {
+      "label": "DROP TABLE IF EXISTS",
+      "kind": 15,
+      "detail": "Drop table if exists",
+      "documentation": {
+        "value": "Drop table only if it exists.\n\n```sql\nDROP TABLE IF EXISTS temp_data;\n```"
+      },
+      "insertText": "DROP TABLE IF EXISTS ${1:table_name};",
+      "insertTextRules": 4,
+      "sortText": "00_drop_table_if_exists"
+    },
+    {
+      "label": "DROP TABLE CASCADE",
+      "kind": 15,
+      "detail": "Drop table cascade",
+      "documentation": {
+        "value": "Drop table and all dependent objects.\n\n```sql\nDROP TABLE IF EXISTS users CASCADE;\n```"
+      },
+      "insertText": "DROP TABLE IF EXISTS ${1:table_name} CASCADE;",
+      "insertTextRules": 4,
+      "sortText": "00_drop_table_cascade"
+    },
+    {
+      "label": "CREATE INDEX",
+      "kind": 15,
+      "detail": "Create index",
+      "documentation": {
+        "value": "Create an index on a column.\n\n```sql\nCREATE INDEX idx_users_email ON users (email);\n```"
+      },
+      "insertText": "CREATE INDEX ${1:idx_name} ON ${2:table} (${3:column});",
+      "insertTextRules": 4,
+      "sortText": "00_create_index"
+    },
+    {
+      "label": "CREATE UNIQUE INDEX",
+      "kind": 15,
+      "detail": "Create unique index",
+      "documentation": {
+        "value": "Create a unique index.\n\n```sql\nCREATE UNIQUE INDEX idx_users_email ON users (email);\n```"
+      },
+      "insertText": "CREATE UNIQUE INDEX ${1:idx_name} ON ${2:table} (${3:column});",
+      "insertTextRules": 4,
+      "sortText": "00_create_unique_index"
+    },
+    {
+      "label": "CREATE INDEX partial",
+      "kind": 15,
+      "detail": "Create partial index (PostgreSQL)",
+      "documentation": {
+        "value": "Index only matching rows.\n\n```sql\nCREATE INDEX idx_active_users ON users (email) WHERE active = true;\n```"
+      },
+      "insertText": "CREATE INDEX ${1:idx_name} ON ${2:table} (${3:column})\nWHERE ${4:condition};",
+      "insertTextRules": 4,
+      "sortText": "00_create_index_partial"
+    },
+    {
+      "label": "CREATE INDEX expression",
+      "kind": 15,
+      "detail": "Create expression index",
+      "documentation": {
+        "value": "Index on an expression.\n\n```sql\nCREATE INDEX idx_lower_email ON users (LOWER(email));\n```"
+      },
+      "insertText": "CREATE INDEX ${1:idx_name} ON ${2:table} (${3:LOWER(column)});",
+      "insertTextRules": 4,
+      "sortText": "00_create_index_expression"
+    },
+    {
+      "label": "CREATE INDEX GIN",
+      "kind": 15,
+      "detail": "Create GIN index (PostgreSQL)",
+      "documentation": {
+        "value": "GIN index for full-text search or JSONB.\n\n```sql\nCREATE INDEX idx_data_gin ON documents USING GIN (data);\n```"
+      },
+      "insertText": "CREATE INDEX ${1:idx_name} ON ${2:table} USING GIN (${3:column});",
+      "insertTextRules": 4,
+      "sortText": "00_create_index_gin"
+    },
+    {
+      "label": "CREATE INDEX GiST",
+      "kind": 15,
+      "detail": "Create GiST index (PostgreSQL)",
+      "documentation": {
+        "value": "GiST index for geometric or range types.\n\n```sql\nCREATE INDEX idx_location ON places USING GIST (location);\n```"
+      },
+      "insertText": "CREATE INDEX ${1:idx_name} ON ${2:table} USING GIST (${3:column});",
+      "insertTextRules": 4,
+      "sortText": "00_create_index_gist"
+    },
+    {
+      "label": "CREATE INDEX INCLUDE",
+      "kind": 15,
+      "detail": "Create covering index (PostgreSQL 11+)",
+      "documentation": {
+        "value": "Include non-key columns in the index.\n\n```sql\nCREATE INDEX idx_orders ON orders (user_id) INCLUDE (total, status);\n```"
+      },
+      "insertText": "CREATE INDEX ${1:idx_name} ON ${2:table} (${3:key_column})\nINCLUDE (${4:included_columns});",
+      "insertTextRules": 4,
+      "sortText": "00_create_index_include"
+    },
+    {
+      "label": "DROP INDEX",
+      "kind": 14,
+      "detail": "Drop index",
+      "documentation": {
+        "value": "Remove an index.\n\n```sql\nDROP INDEX idx_users_email;\n```"
+      },
+      "insertText": "DROP INDEX ${1:index_name};",
+      "insertTextRules": 4,
+      "sortText": "00_drop index"
+    },
+    {
+      "label": "CREATE VIEW",
+      "kind": 15,
+      "detail": "Create view",
+      "documentation": {
+        "value": "Create a named view.\n\n```sql\nCREATE VIEW active_users AS\nSELECT id, name FROM users WHERE active = true;\n```"
+      },
+      "insertText": "CREATE VIEW ${1:view_name} AS\nSELECT ${2:columns}\nFROM ${3:table}\nWHERE ${4:condition};",
+      "insertTextRules": 4,
+      "sortText": "00_create_view"
+    },
+    {
+      "label": "CREATE MATERIALIZED VIEW",
+      "kind": 15,
+      "detail": "Create materialized view (PostgreSQL)",
+      "documentation": {
+        "value": "Create a materialized view.\n\n```sql\nCREATE MATERIALIZED VIEW mv_sales AS\nSELECT product_id, SUM(amount) AS total\nFROM sales GROUP BY product_id;\n```"
+      },
+      "insertText": "CREATE MATERIALIZED VIEW ${1:mv_name} AS\nSELECT ${2:columns}\nFROM ${3:table}\n${4:WHERE condition}\nGROUP BY ${5:column};",
+      "insertTextRules": 4,
+      "sortText": "00_create_materialized_view"
+    },
+    {
+      "label": "CREATE VIEW WITH CHECK OPTION",
+      "kind": 15,
+      "detail": "Create view with check option",
+      "documentation": {
+        "value": "View that validates inserts/updates.\n\n```sql\nCREATE VIEW active_users AS\nSELECT * FROM users WHERE active = true\nWITH CHECK OPTION;\n```"
+      },
+      "insertText": "CREATE VIEW ${1:view_name} AS\nSELECT ${2:*}\nFROM ${3:table}\nWHERE ${4:condition}\nWITH CHECK OPTION;",
+      "insertTextRules": 4,
+      "sortText": "00_create_view_with_check_option"
+    },
+    {
+      "label": "DROP VIEW",
+      "kind": 14,
+      "detail": "Drop view",
+      "documentation": {
+        "value": "Remove a view.\n\n```sql\nDROP VIEW IF EXISTS active_users;\n```"
+      },
+      "insertText": "DROP VIEW IF EXISTS ${1:view_name};",
+      "insertTextRules": 4,
+      "sortText": "00_drop view"
+    },
+    {
+      "label": "REFRESH MATERIALIZED VIEW",
+      "kind": 15,
+      "detail": "Refresh materialized view",
+      "documentation": {
+        "value": "Refresh data in a materialized view.\n\n```sql\nREFRESH MATERIALIZED VIEW CONCURRENTLY mv_sales;\n```"
+      },
+      "insertText": "REFRESH MATERIALIZED VIEW ${1|CONCURRENTLY ,|}${2:mv_name};",
+      "insertTextRules": 4,
+      "sortText": "00_refresh_materialized_view"
+    },
+    {
+      "label": "CREATE SCHEMA",
+      "kind": 14,
+      "detail": "Create schema",
+      "documentation": {
+        "value": "Create a new schema.\n\n```sql\nCREATE SCHEMA IF NOT EXISTS app;\n```"
+      },
+      "insertText": "CREATE SCHEMA IF NOT EXISTS ${1:schema_name};",
+      "insertTextRules": 4,
+      "sortText": "00_create schema"
+    },
+    {
+      "label": "DROP SCHEMA",
+      "kind": 14,
+      "detail": "Drop schema",
+      "documentation": {
+        "value": "Remove a schema.\n\n```sql\nDROP SCHEMA IF EXISTS app CASCADE;\n```"
+      },
+      "insertText": "DROP SCHEMA IF EXISTS ${1:schema_name} CASCADE;",
+      "insertTextRules": 4,
+      "sortText": "00_drop schema"
+    },
+    {
+      "label": "CREATE SEQUENCE",
+      "kind": 15,
+      "detail": "Create sequence",
+      "documentation": {
+        "value": "Create an auto-incrementing sequence.\n\n```sql\nCREATE SEQUENCE user_id_seq START WITH 1 INCREMENT BY 1;\n```"
+      },
+      "insertText": "CREATE SEQUENCE ${1:seq_name}\n  START WITH ${2:1}\n  INCREMENT BY ${3:1}\n  ${4:NO MINVALUE}\n  ${5:NO MAXVALUE}\n  CACHE ${6:1};",
+      "insertTextRules": 4,
+      "sortText": "00_create_sequence"
+    },
+    {
+      "label": "ALTER SEQUENCE",
+      "kind": 14,
+      "detail": "Alter sequence",
+      "documentation": {
+        "value": "Modify a sequence.\n\n```sql\nALTER SEQUENCE user_id_seq RESTART WITH 1000;\n```"
+      },
+      "insertText": "ALTER SEQUENCE ${1:seq_name} RESTART WITH ${2:1000};",
+      "insertTextRules": 4,
+      "sortText": "00_alter sequence"
+    },
+    {
+      "label": "COMMENT ON",
+      "kind": 15,
+      "detail": "Comment on object",
+      "documentation": {
+        "value": "Add a comment to a database object.\n\n```sql\nCOMMENT ON TABLE users IS 'Application users table';\n```"
+      },
+      "insertText": "COMMENT ON ${1|TABLE,COLUMN,INDEX,VIEW,FUNCTION|} ${2:object_name} IS '${3:comment}';",
+      "insertTextRules": 4,
+      "sortText": "00_comment_on"
+    },
+    {
+      "label": "INNER JOIN",
+      "kind": 15,
+      "detail": "Inner join",
+      "documentation": {
+        "value": "Return rows that match in both tables.\n\n```sql\nSELECT * FROM orders o\nINNER JOIN users u ON o.user_id = u.id;\n```"
+      },
+      "insertText": "INNER JOIN ${1:table} ${2:alias} ON ${3:condition}",
+      "insertTextRules": 4,
+      "sortText": "00_inner_join"
+    },
+    {
+      "label": "LEFT JOIN",
+      "kind": 15,
+      "detail": "Left outer join",
+      "documentation": {
+        "value": "Return all rows from the left table plus matches.\n\n```sql\nSELECT u.name, o.total\nFROM users u\nLEFT JOIN orders o ON u.id = o.user_id;\n```"
+      },
+      "insertText": "LEFT JOIN ${1:table} ${2:alias} ON ${3:condition}",
+      "insertTextRules": 4,
+      "sortText": "00_left_join"
+    },
+    {
+      "label": "RIGHT JOIN",
+      "kind": 15,
+      "detail": "Right outer join",
+      "documentation": {
+        "value": "Return all rows from the right table plus matches.\n\n```sql\nSELECT u.name, o.total\nFROM orders o\nRIGHT JOIN users u ON o.user_id = u.id;\n```"
+      },
+      "insertText": "RIGHT JOIN ${1:table} ${2:alias} ON ${3:condition}",
+      "insertTextRules": 4,
+      "sortText": "00_right_join"
+    },
+    {
+      "label": "FULL OUTER JOIN",
+      "kind": 15,
+      "detail": "Full outer join",
+      "documentation": {
+        "value": "Return all rows from both tables.\n\n```sql\nSELECT a.name, b.name\nFROM table_a a\nFULL OUTER JOIN table_b b ON a.id = b.a_id;\n```"
+      },
+      "insertText": "FULL OUTER JOIN ${1:table} ${2:alias} ON ${3:condition}",
+      "insertTextRules": 4,
+      "sortText": "00_full_outer_join"
+    },
+    {
+      "label": "CROSS JOIN",
+      "kind": 15,
+      "detail": "Cross join",
+      "documentation": {
+        "value": "Cartesian product of two tables.\n\n```sql\nSELECT * FROM colors CROSS JOIN sizes;\n```"
+      },
+      "insertText": "CROSS JOIN ${1:table}",
+      "insertTextRules": 4,
+      "sortText": "00_cross_join"
+    },
+    {
+      "label": "NATURAL JOIN",
+      "kind": 15,
+      "detail": "Natural join",
+      "documentation": {
+        "value": "Join on all columns with the same name.\n\n```sql\nSELECT * FROM employees NATURAL JOIN departments;\n```"
+      },
+      "insertText": "NATURAL JOIN ${1:table}",
+      "insertTextRules": 4,
+      "sortText": "00_natural_join"
+    },
+    {
+      "label": "Self join",
+      "kind": 15,
+      "detail": "Self join",
+      "documentation": {
+        "value": "Join a table to itself.\n\n```sql\nSELECT e.name AS employee, m.name AS manager\nFROM employees e\nJOIN employees m ON e.manager_id = m.id;\n```"
+      },
+      "insertText": "SELECT ${1:a}.${2:column} AS ${3:alias1}, ${4:b}.${5:column} AS ${6:alias2}\nFROM ${7:table} ${1:a}\nJOIN ${7:table} ${4:b} ON ${1:a}.${8:fk} = ${4:b}.${9:pk};",
+      "insertTextRules": 4,
+      "sortText": "00_self_join"
+    },
+    {
+      "label": "Multiple JOINs",
+      "kind": 15,
+      "detail": "Multiple joins",
+      "documentation": {
+        "value": "Join three or more tables.\n\n```sql\nSELECT u.name, o.id, p.name\nFROM users u\nJOIN orders o ON u.id = o.user_id\nJOIN products p ON o.product_id = p.id;\n```"
+      },
+      "insertText": "SELECT ${1:a}.${2:col}, ${3:b}.${4:col}, ${5:c}.${6:col}\nFROM ${7:table1} ${1:a}\nJOIN ${8:table2} ${3:b} ON ${1:a}.${9:id} = ${3:b}.${10:fk}\nJOIN ${11:table3} ${5:c} ON ${3:b}.${12:id} = ${5:c}.${13:fk};",
+      "insertTextRules": 4,
+      "sortText": "00_multiple_joins"
+    },
+    {
+      "label": "LATERAL JOIN",
+      "kind": 15,
+      "detail": "Lateral join (PostgreSQL)",
+      "documentation": {
+        "value": "Subquery that can reference preceding FROM items.\n\n```sql\nSELECT u.name, recent.total\nFROM users u\nLEFT JOIN LATERAL (\n  SELECT total FROM orders WHERE user_id = u.id ORDER BY created_at DESC LIMIT 1\n) recent ON true;\n```"
+      },
+      "insertText": "LEFT JOIN LATERAL (\n  SELECT ${1:columns}\n  FROM ${2:table}\n  WHERE ${3:fk} = ${4:outer_alias}.${5:pk}\n  ORDER BY ${6:col} DESC\n  LIMIT ${7:1}\n) ${8:alias} ON true",
+      "insertTextRules": 4,
+      "sortText": "00_lateral_join"
+    },
+    {
+      "label": "COUNT",
+      "kind": 1,
+      "detail": "Count rows",
+      "documentation": {
+        "value": "Count the number of rows.\n\n```sql\nSELECT COUNT(*) FROM users;\n```"
+      },
+      "insertText": "COUNT(${1:*})",
+      "insertTextRules": 4,
+      "sortText": "01_count"
+    },
+    {
+      "label": "SUM",
+      "kind": 1,
+      "detail": "Sum values",
+      "documentation": {
+        "value": "Calculate the sum.\n\n```sql\nSELECT SUM(amount) FROM orders;\n```"
+      },
+      "insertText": "SUM(${1:column})",
+      "insertTextRules": 4,
+      "sortText": "01_sum"
+    },
+    {
+      "label": "AVG",
+      "kind": 1,
+      "detail": "Average value",
+      "documentation": {
+        "value": "Calculate the average.\n\n```sql\nSELECT AVG(salary) FROM employees;\n```"
+      },
+      "insertText": "AVG(${1:column})",
+      "insertTextRules": 4,
+      "sortText": "01_avg"
+    },
+    {
+      "label": "MIN",
+      "kind": 1,
+      "detail": "Minimum value",
+      "documentation": {
+        "value": "Find the minimum.\n\n```sql\nSELECT MIN(price) FROM products;\n```"
+      },
+      "insertText": "MIN(${1:column})",
+      "insertTextRules": 4,
+      "sortText": "01_min"
+    },
+    {
+      "label": "MAX",
+      "kind": 1,
+      "detail": "Maximum value",
+      "documentation": {
+        "value": "Find the maximum.\n\n```sql\nSELECT MAX(price) FROM products;\n```"
+      },
+      "insertText": "MAX(${1:column})",
+      "insertTextRules": 4,
+      "sortText": "01_max"
+    },
+    {
+      "label": "COUNT DISTINCT",
+      "kind": 1,
+      "detail": "Count distinct values",
+      "documentation": {
+        "value": "Count unique non-null values.\n\n```sql\nSELECT COUNT(DISTINCT category) FROM products;\n```"
+      },
+      "insertText": "COUNT(DISTINCT ${1:column})",
+      "insertTextRules": 4,
+      "sortText": "01_count distinct"
+    },
+    {
+      "label": "STRING_AGG",
+      "kind": 1,
+      "detail": "String aggregate (PostgreSQL)",
+      "documentation": {
+        "value": "Concatenate strings with delimiter.\n\n```sql\nSELECT STRING_AGG(name, ', ' ORDER BY name) FROM users;\n```"
+      },
+      "insertText": "STRING_AGG(${1:column}, '${2:, }' ORDER BY ${3:column})",
+      "insertTextRules": 4,
+      "sortText": "01_string_agg"
+    },
+    {
+      "label": "GROUP_CONCAT",
+      "kind": 1,
+      "detail": "Group concat (MySQL)",
+      "documentation": {
+        "value": "Concatenate strings in a group.\n\n```sql\nSELECT GROUP_CONCAT(name ORDER BY name SEPARATOR ', ') FROM users;\n```"
+      },
+      "insertText": "GROUP_CONCAT(${1:column} ORDER BY ${2:column} SEPARATOR '${3:, }')",
+      "insertTextRules": 4,
+      "sortText": "01_group_concat"
+    },
+    {
+      "label": "ARRAY_AGG",
+      "kind": 1,
+      "detail": "Array aggregate (PostgreSQL)",
+      "documentation": {
+        "value": "Collect values into an array.\n\n```sql\nSELECT ARRAY_AGG(name ORDER BY name) FROM users;\n```"
+      },
+      "insertText": "ARRAY_AGG(${1:column} ORDER BY ${2:column})",
+      "insertTextRules": 4,
+      "sortText": "01_array_agg"
+    },
+    {
+      "label": "JSON_AGG",
+      "kind": 1,
+      "detail": "JSON aggregate (PostgreSQL)",
+      "documentation": {
+        "value": "Aggregate values as a JSON array.\n\n```sql\nSELECT JSON_AGG(row_to_json(u)) FROM users u;\n```"
+      },
+      "insertText": "JSON_AGG(${1:expression})",
+      "insertTextRules": 4,
+      "sortText": "01_json_agg"
+    },
+    {
+      "label": "BOOL_AND",
+      "kind": 1,
+      "detail": "Boolean AND aggregate (PostgreSQL)",
+      "documentation": {
+        "value": "TRUE if all values are true.\n\n```sql\nSELECT BOOL_AND(active) FROM users;\n```"
+      },
+      "insertText": "BOOL_AND(${1:column})",
+      "insertTextRules": 4,
+      "sortText": "01_bool_and"
+    },
+    {
+      "label": "BOOL_OR",
+      "kind": 1,
+      "detail": "Boolean OR aggregate (PostgreSQL)",
+      "documentation": {
+        "value": "TRUE if any value is true.\n\n```sql\nSELECT BOOL_OR(active) FROM users;\n```"
+      },
+      "insertText": "BOOL_OR(${1:column})",
+      "insertTextRules": 4,
+      "sortText": "01_bool_or"
+    },
+    {
+      "label": "ROW_NUMBER",
+      "kind": 1,
+      "detail": "Row number",
+      "documentation": {
+        "value": "Assign sequential integers to rows.\n\n```sql\nSELECT name, ROW_NUMBER() OVER (ORDER BY salary DESC) AS rn\nFROM employees;\n```"
+      },
+      "insertText": "ROW_NUMBER() OVER (${1:PARTITION BY col} ORDER BY ${2:column})",
+      "insertTextRules": 4,
+      "sortText": "01_row_number"
+    },
+    {
+      "label": "RANK",
+      "kind": 1,
+      "detail": "Rank",
+      "documentation": {
+        "value": "Rank with gaps on ties.\n\n```sql\nSELECT name, RANK() OVER (ORDER BY score DESC) FROM students;\n```"
+      },
+      "insertText": "RANK() OVER (${1:PARTITION BY col} ORDER BY ${2:column})",
+      "insertTextRules": 4,
+      "sortText": "01_rank"
+    },
+    {
+      "label": "DENSE_RANK",
+      "kind": 1,
+      "detail": "Dense rank",
+      "documentation": {
+        "value": "Rank without gaps on ties.\n\n```sql\nSELECT name, DENSE_RANK() OVER (ORDER BY score DESC) FROM students;\n```"
+      },
+      "insertText": "DENSE_RANK() OVER (${1:PARTITION BY col} ORDER BY ${2:column})",
+      "insertTextRules": 4,
+      "sortText": "01_dense_rank"
+    },
+    {
+      "label": "NTILE",
+      "kind": 1,
+      "detail": "N-tile",
+      "documentation": {
+        "value": "Divide rows into N buckets.\n\n```sql\nSELECT name, NTILE(4) OVER (ORDER BY salary) AS quartile\nFROM employees;\n```"
+      },
+      "insertText": "NTILE(${1:n}) OVER (ORDER BY ${2:column})",
+      "insertTextRules": 4,
+      "sortText": "01_ntile"
+    },
+    {
+      "label": "LAG",
+      "kind": 1,
+      "detail": "Lag",
+      "documentation": {
+        "value": "Access previous row value.\n\n```sql\nSELECT date, value, LAG(value) OVER (ORDER BY date) AS prev_value\nFROM metrics;\n```"
+      },
+      "insertText": "LAG(${1:column}, ${2:1}, ${3:NULL}) OVER (ORDER BY ${4:column})",
+      "insertTextRules": 4,
+      "sortText": "01_lag"
+    },
+    {
+      "label": "LEAD",
+      "kind": 1,
+      "detail": "Lead",
+      "documentation": {
+        "value": "Access next row value.\n\n```sql\nSELECT date, value, LEAD(value) OVER (ORDER BY date) AS next_value\nFROM metrics;\n```"
+      },
+      "insertText": "LEAD(${1:column}, ${2:1}, ${3:NULL}) OVER (ORDER BY ${4:column})",
+      "insertTextRules": 4,
+      "sortText": "01_lead"
+    },
+    {
+      "label": "FIRST_VALUE",
+      "kind": 1,
+      "detail": "First value",
+      "documentation": {
+        "value": "Get first value in the window frame.\n\n```sql\nSELECT name, FIRST_VALUE(salary) OVER (PARTITION BY dept ORDER BY salary DESC)\nFROM employees;\n```"
+      },
+      "insertText": "FIRST_VALUE(${1:column}) OVER (${2:PARTITION BY col} ORDER BY ${3:column})",
+      "insertTextRules": 4,
+      "sortText": "01_first_value"
+    },
+    {
+      "label": "LAST_VALUE",
+      "kind": 1,
+      "detail": "Last value",
+      "documentation": {
+        "value": "Get last value in the window frame.\n\n```sql\nSELECT name, LAST_VALUE(salary) OVER (\n  PARTITION BY dept ORDER BY salary\n  ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n) FROM employees;\n```"
+      },
+      "insertText": "LAST_VALUE(${1:column}) OVER (${2:PARTITION BY col} ORDER BY ${3:column} ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)",
+      "insertTextRules": 4,
+      "sortText": "01_last_value"
+    },
+    {
+      "label": "NTH_VALUE",
+      "kind": 1,
+      "detail": "Nth value",
+      "documentation": {
+        "value": "Get Nth value in the window frame.\n\n```sql\nSELECT name, NTH_VALUE(salary, 2) OVER (PARTITION BY dept ORDER BY salary DESC)\nFROM employees;\n```"
+      },
+      "insertText": "NTH_VALUE(${1:column}, ${2:n}) OVER (${3:PARTITION BY col} ORDER BY ${4:column})",
+      "insertTextRules": 4,
+      "sortText": "01_nth_value"
+    },
+    {
+      "label": "PERCENT_RANK",
+      "kind": 1,
+      "detail": "Percent rank",
+      "documentation": {
+        "value": "Relative rank as a fraction (0 to 1).\n\n```sql\nSELECT name, PERCENT_RANK() OVER (ORDER BY salary) FROM employees;\n```"
+      },
+      "insertText": "PERCENT_RANK() OVER (ORDER BY ${1:column})",
+      "insertTextRules": 4,
+      "sortText": "01_percent_rank"
+    },
+    {
+      "label": "CUME_DIST",
+      "kind": 1,
+      "detail": "Cumulative distribution",
+      "documentation": {
+        "value": "Cumulative distribution value.\n\n```sql\nSELECT name, CUME_DIST() OVER (ORDER BY salary) FROM employees;\n```"
+      },
+      "insertText": "CUME_DIST() OVER (ORDER BY ${1:column})",
+      "insertTextRules": 4,
+      "sortText": "01_cume_dist"
+    },
+    {
+      "label": "Window frame ROWS",
+      "kind": 15,
+      "detail": "Window frame clause",
+      "documentation": {
+        "value": "Specify a window frame.\n\n```sql\nSUM(amount) OVER (\n  ORDER BY date\n  ROWS BETWEEN 6 PRECEDING AND CURRENT ROW\n)\n```"
+      },
+      "insertText": "${1:SUM}(${2:column}) OVER (\n  ${3:PARTITION BY col}\n  ORDER BY ${4:column}\n  ${5|ROWS,RANGE|} BETWEEN ${6|UNBOUNDED PRECEDING,n PRECEDING,CURRENT ROW|} AND ${7|CURRENT ROW,n FOLLOWING,UNBOUNDED FOLLOWING|}\n)",
+      "insertTextRules": 4,
+      "sortText": "00_window_frame_rows"
+    },
+    {
+      "label": "CONCAT",
+      "kind": 1,
+      "detail": "Concatenate strings",
+      "documentation": {
+        "value": "Join strings together.\n\n```sql\nSELECT CONCAT(first_name, ' ', last_name) FROM users;\n```"
+      },
+      "insertText": "CONCAT(${1:str1}, ${2:str2})",
+      "insertTextRules": 4,
+      "sortText": "01_concat"
+    },
+    {
+      "label": "SUBSTRING",
+      "kind": 1,
+      "detail": "Substring",
+      "documentation": {
+        "value": "Extract part of a string.\n\n```sql\nSELECT SUBSTRING(name FROM 1 FOR 3) FROM users;\n```"
+      },
+      "insertText": "SUBSTRING(${1:string} FROM ${2:start} FOR ${3:length})",
+      "insertTextRules": 4,
+      "sortText": "01_substring"
+    },
+    {
+      "label": "LENGTH",
+      "kind": 1,
+      "detail": "String length",
+      "documentation": {
+        "value": "Get length of a string.\n\n```sql\nSELECT LENGTH(name) FROM users;\n```"
+      },
+      "insertText": "LENGTH(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_length"
+    },
+    {
+      "label": "CHAR_LENGTH",
+      "kind": 1,
+      "detail": "Character length",
+      "documentation": {
+        "value": "Get character count.\n\n```sql\nSELECT CHAR_LENGTH(name) FROM users;\n```"
+      },
+      "insertText": "CHAR_LENGTH(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_char_length"
+    },
+    {
+      "label": "UPPER",
+      "kind": 1,
+      "detail": "Uppercase",
+      "documentation": {
+        "value": "Convert to uppercase.\n\n```sql\nSELECT UPPER(name) FROM users;\n```"
+      },
+      "insertText": "UPPER(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_upper"
+    },
+    {
+      "label": "LOWER",
+      "kind": 1,
+      "detail": "Lowercase",
+      "documentation": {
+        "value": "Convert to lowercase.\n\n```sql\nSELECT LOWER(email) FROM users;\n```"
+      },
+      "insertText": "LOWER(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_lower"
+    },
+    {
+      "label": "TRIM",
+      "kind": 1,
+      "detail": "Trim whitespace",
+      "documentation": {
+        "value": "Remove leading/trailing whitespace.\n\n```sql\nSELECT TRIM(name) FROM users;\n```"
+      },
+      "insertText": "TRIM(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_trim"
+    },
+    {
+      "label": "LTRIM",
+      "kind": 1,
+      "detail": "Left trim",
+      "documentation": {
+        "value": "Remove leading whitespace.\n\n```sql\nSELECT LTRIM(name) FROM users;\n```"
+      },
+      "insertText": "LTRIM(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_ltrim"
+    },
+    {
+      "label": "RTRIM",
+      "kind": 1,
+      "detail": "Right trim",
+      "documentation": {
+        "value": "Remove trailing whitespace.\n\n```sql\nSELECT RTRIM(name) FROM users;\n```"
+      },
+      "insertText": "RTRIM(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_rtrim"
+    },
+    {
+      "label": "REPLACE",
+      "kind": 1,
+      "detail": "Replace",
+      "documentation": {
+        "value": "Replace occurrences of a substring.\n\n```sql\nSELECT REPLACE(url, 'http:', 'https:') FROM links;\n```"
+      },
+      "insertText": "REPLACE(${1:string}, ${2:'old'}, ${3:'new'})",
+      "insertTextRules": 4,
+      "sortText": "01_replace"
+    },
+    {
+      "label": "POSITION",
+      "kind": 1,
+      "detail": "Position / STRPOS",
+      "documentation": {
+        "value": "Find substring position.\n\n```sql\nSELECT POSITION('@' IN email) FROM users;\n```"
+      },
+      "insertText": "POSITION(${1:'substr'} IN ${2:string})",
+      "insertTextRules": 4,
+      "sortText": "01_position"
+    },
+    {
+      "label": "LEFT",
+      "kind": 1,
+      "detail": "Left substring",
+      "documentation": {
+        "value": "Get leftmost characters.\n\n```sql\nSELECT LEFT(name, 5) FROM users;\n```"
+      },
+      "insertText": "LEFT(${1:string}, ${2:n})",
+      "insertTextRules": 4,
+      "sortText": "01_left"
+    },
+    {
+      "label": "RIGHT",
+      "kind": 1,
+      "detail": "Right substring",
+      "documentation": {
+        "value": "Get rightmost characters.\n\n```sql\nSELECT RIGHT(phone, 4) FROM contacts;\n```"
+      },
+      "insertText": "RIGHT(${1:string}, ${2:n})",
+      "insertTextRules": 4,
+      "sortText": "01_right"
+    },
+    {
+      "label": "REVERSE",
+      "kind": 1,
+      "detail": "Reverse string",
+      "documentation": {
+        "value": "Reverse a string.\n\n```sql\nSELECT REVERSE('hello');\n```"
+      },
+      "insertText": "REVERSE(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_reverse"
+    },
+    {
+      "label": "REPEAT",
+      "kind": 1,
+      "detail": "Repeat string",
+      "documentation": {
+        "value": "Repeat a string N times.\n\n```sql\nSELECT REPEAT('-', 40);\n```"
+      },
+      "insertText": "REPEAT(${1:string}, ${2:n})",
+      "insertTextRules": 4,
+      "sortText": "01_repeat"
+    },
+    {
+      "label": "LPAD",
+      "kind": 1,
+      "detail": "Left pad",
+      "documentation": {
+        "value": "Pad string on the left.\n\n```sql\nSELECT LPAD(CAST(id AS TEXT), 5, '0') FROM orders;\n```"
+      },
+      "insertText": "LPAD(${1:string}, ${2:length}, ${3:'pad'})",
+      "insertTextRules": 4,
+      "sortText": "01_lpad"
+    },
+    {
+      "label": "RPAD",
+      "kind": 1,
+      "detail": "Right pad",
+      "documentation": {
+        "value": "Pad string on the right.\n\n```sql\nSELECT RPAD(name, 20, '.') FROM users;\n```"
+      },
+      "insertText": "RPAD(${1:string}, ${2:length}, ${3:'pad'})",
+      "insertTextRules": 4,
+      "sortText": "01_rpad"
+    },
+    {
+      "label": "SPLIT_PART",
+      "kind": 1,
+      "detail": "Split part (PostgreSQL)",
+      "documentation": {
+        "value": "Split a string and return Nth part.\n\n```sql\nSELECT SPLIT_PART(email, '@', 2) AS domain FROM users;\n```"
+      },
+      "insertText": "SPLIT_PART(${1:string}, '${2:delimiter}', ${3:part_number})",
+      "insertTextRules": 4,
+      "sortText": "01_split_part"
+    },
+    {
+      "label": "REGEXP_REPLACE",
+      "kind": 1,
+      "detail": "Regex replace",
+      "documentation": {
+        "value": "Replace using regex.\n\n```sql\nSELECT REGEXP_REPLACE(phone, '[^0-9]', '', 'g') FROM contacts;\n```"
+      },
+      "insertText": "REGEXP_REPLACE(${1:string}, '${2:pattern}', '${3:replacement}', '${4:flags}')",
+      "insertTextRules": 4,
+      "sortText": "01_regexp_replace"
+    },
+    {
+      "label": "REGEXP_MATCHES",
+      "kind": 1,
+      "detail": "Regex matches (PostgreSQL)",
+      "documentation": {
+        "value": "Extract all regex matches.\n\n```sql\nSELECT REGEXP_MATCHES(text, '(\\d+)', 'g') FROM documents;\n```"
+      },
+      "insertText": "REGEXP_MATCHES(${1:string}, '${2:pattern}', '${3:flags}')",
+      "insertTextRules": 4,
+      "sortText": "01_regexp_matches"
+    },
+    {
+      "label": "TRANSLATE",
+      "kind": 1,
+      "detail": "Translate characters",
+      "documentation": {
+        "value": "Replace characters one-to-one.\n\n```sql\nSELECT TRANSLATE('abc', 'abc', 'xyz');\n```"
+      },
+      "insertText": "TRANSLATE(${1:string}, '${2:from}', '${3:to}')",
+      "insertTextRules": 4,
+      "sortText": "01_translate"
+    },
+    {
+      "label": "INITCAP",
+      "kind": 1,
+      "detail": "Initial capitals (PostgreSQL)",
+      "documentation": {
+        "value": "Capitalize first letter of each word.\n\n```sql\nSELECT INITCAP('hello world');\n```"
+      },
+      "insertText": "INITCAP(${1:string})",
+      "insertTextRules": 4,
+      "sortText": "01_initcap"
+    },
+    {
+      "label": "FORMAT",
+      "kind": 1,
+      "detail": "Format string (PostgreSQL)",
+      "documentation": {
+        "value": "Printf-style formatting.\n\n```sql\nSELECT FORMAT('Hello, %s! You have %s orders.', name, order_count) FROM users;\n```"
+      },
+      "insertText": "FORMAT('${1:template}', ${2:args})",
+      "insertTextRules": 4,
+      "sortText": "01_format"
+    },
+    {
+      "label": "NOW",
+      "kind": 1,
+      "detail": "Current timestamp",
+      "documentation": {
+        "value": "Get current date and time.\n\n```sql\nSELECT NOW();\n```"
+      },
+      "insertText": "NOW()",
+      "insertTextRules": 4,
+      "sortText": "01_now"
+    },
+    {
+      "label": "CURRENT_TIMESTAMP",
+      "kind": 1,
+      "detail": "Current timestamp",
+      "documentation": {
+        "value": "ANSI current timestamp.\n\n```sql\nSELECT CURRENT_TIMESTAMP;\n```"
+      },
+      "insertText": "CURRENT_TIMESTAMP",
+      "insertTextRules": 4,
+      "sortText": "01_current_timestamp"
+    },
+    {
+      "label": "CURRENT_DATE",
+      "kind": 1,
+      "detail": "Current date",
+      "documentation": {
+        "value": "Get current date.\n\n```sql\nSELECT CURRENT_DATE;\n```"
+      },
+      "insertText": "CURRENT_DATE",
+      "insertTextRules": 4,
+      "sortText": "01_current_date"
+    },
+    {
+      "label": "CURRENT_TIME",
+      "kind": 1,
+      "detail": "Current time",
+      "documentation": {
+        "value": "Get current time.\n\n```sql\nSELECT CURRENT_TIME;\n```"
+      },
+      "insertText": "CURRENT_TIME",
+      "insertTextRules": 4,
+      "sortText": "01_current_time"
+    },
+    {
+      "label": "DATE_TRUNC",
+      "kind": 1,
+      "detail": "Truncate date (PostgreSQL)",
+      "documentation": {
+        "value": "Truncate to specified precision.\n\n```sql\nSELECT DATE_TRUNC('month', created_at) FROM orders;\n```"
+      },
+      "insertText": "DATE_TRUNC('${1|year,quarter,month,week,day,hour,minute,second|}', ${2:timestamp})",
+      "insertTextRules": 4,
+      "sortText": "01_date_trunc"
+    },
+    {
+      "label": "EXTRACT",
+      "kind": 1,
+      "detail": "Extract date part",
+      "documentation": {
+        "value": "Extract a field from a date/timestamp.\n\n```sql\nSELECT EXTRACT(YEAR FROM created_at) FROM orders;\n```"
+      },
+      "insertText": "EXTRACT(${1|YEAR,MONTH,DAY,HOUR,MINUTE,SECOND,DOW,DOY,EPOCH|} FROM ${2:timestamp})",
+      "insertTextRules": 4,
+      "sortText": "01_extract"
+    },
+    {
+      "label": "DATE_PART",
+      "kind": 1,
+      "detail": "Date part (PostgreSQL)",
+      "documentation": {
+        "value": "Get a date/time field.\n\n```sql\nSELECT DATE_PART('hour', created_at) FROM events;\n```"
+      },
+      "insertText": "DATE_PART('${1:field}', ${2:timestamp})",
+      "insertTextRules": 4,
+      "sortText": "01_date_part"
+    },
+    {
+      "label": "AGE",
+      "kind": 1,
+      "detail": "Age between dates (PostgreSQL)",
+      "documentation": {
+        "value": "Calculate interval between timestamps.\n\n```sql\nSELECT AGE(NOW(), hire_date) FROM employees;\n```"
+      },
+      "insertText": "AGE(${1:timestamp1}, ${2:timestamp2})",
+      "insertTextRules": 4,
+      "sortText": "01_age"
+    },
+    {
+      "label": "DATE_ADD",
+      "kind": 1,
+      "detail": "Add to date (MySQL)",
+      "documentation": {
+        "value": "Add an interval to a date.\n\n```sql\nSELECT DATE_ADD(created_at, INTERVAL 30 DAY) FROM orders;\n```"
+      },
+      "insertText": "DATE_ADD(${1:date}, INTERVAL ${2:n} ${3|DAY,MONTH,YEAR,HOUR,MINUTE,SECOND|})",
+      "insertTextRules": 4,
+      "sortText": "01_date_add"
+    },
+    {
+      "label": "INTERVAL",
+      "kind": 1,
+      "detail": "Interval literal",
+      "documentation": {
+        "value": "Interval expression.\n\n```sql\nSELECT NOW() - INTERVAL '30 days';\n```"
+      },
+      "insertText": "INTERVAL '${1:30} ${2|days,hours,minutes,months,years|}'",
+      "insertTextRules": 4,
+      "sortText": "01_interval"
+    },
+    {
+      "label": "TO_CHAR",
+      "kind": 1,
+      "detail": "To char (PostgreSQL)",
+      "documentation": {
+        "value": "Format date/number as string.\n\n```sql\nSELECT TO_CHAR(created_at, 'YYYY-MM-DD HH24:MI') FROM events;\n```"
+      },
+      "insertText": "TO_CHAR(${1:timestamp}, '${2:YYYY-MM-DD}')",
+      "insertTextRules": 4,
+      "sortText": "01_to_char"
+    },
+    {
+      "label": "TO_DATE",
+      "kind": 1,
+      "detail": "To date",
+      "documentation": {
+        "value": "Parse string to date.\n\n```sql\nSELECT TO_DATE('2024-01-15', 'YYYY-MM-DD');\n```"
+      },
+      "insertText": "TO_DATE('${1:string}', '${2:YYYY-MM-DD}')",
+      "insertTextRules": 4,
+      "sortText": "01_to_date"
+    },
+    {
+      "label": "TO_TIMESTAMP",
+      "kind": 1,
+      "detail": "To timestamp",
+      "documentation": {
+        "value": "Parse string to timestamp.\n\n```sql\nSELECT TO_TIMESTAMP('2024-01-15 10:30:00', 'YYYY-MM-DD HH24:MI:SS');\n```"
+      },
+      "insertText": "TO_TIMESTAMP('${1:string}', '${2:YYYY-MM-DD HH24:MI:SS}')",
+      "insertTextRules": 4,
+      "sortText": "01_to_timestamp"
+    },
+    {
+      "label": "MAKE_DATE",
+      "kind": 1,
+      "detail": "Make date (PostgreSQL)",
+      "documentation": {
+        "value": "Construct a date from parts.\n\n```sql\nSELECT MAKE_DATE(2024, 1, 15);\n```"
+      },
+      "insertText": "MAKE_DATE(${1:year}, ${2:month}, ${3:day})",
+      "insertTextRules": 4,
+      "sortText": "01_make_date"
+    },
+    {
+      "label": "MAKE_INTERVAL",
+      "kind": 1,
+      "detail": "Make interval (PostgreSQL)",
+      "documentation": {
+        "value": "Construct an interval.\n\n```sql\nSELECT MAKE_INTERVAL(days => 30, hours => 12);\n```"
+      },
+      "insertText": "MAKE_INTERVAL(${1:days} => ${2:0})",
+      "insertTextRules": 4,
+      "sortText": "01_make_interval"
+    },
+    {
+      "label": "DATEDIFF",
+      "kind": 1,
+      "detail": "Date difference (MySQL/SQL Server)",
+      "documentation": {
+        "value": "Calculate difference between dates.\n\n```sql\nSELECT DATEDIFF(end_date, start_date) FROM projects;\n```"
+      },
+      "insertText": "DATEDIFF(${1:date1}, ${2:date2})",
+      "insertTextRules": 4,
+      "sortText": "01_datediff"
+    },
+    {
+      "label": "ABS",
+      "kind": 1,
+      "detail": "Absolute value",
+      "documentation": {
+        "value": "Return absolute value.\n\n```sql\nSELECT ABS(-42);\n```"
+      },
+      "insertText": "ABS(${1:number})",
+      "insertTextRules": 4,
+      "sortText": "01_abs"
+    },
+    {
+      "label": "CEIL",
+      "kind": 1,
+      "detail": "Ceiling",
+      "documentation": {
+        "value": "Round up to nearest integer.\n\n```sql\nSELECT CEIL(4.2);\n```"
+      },
+      "insertText": "CEIL(${1:number})",
+      "insertTextRules": 4,
+      "sortText": "01_ceil"
+    },
+    {
+      "label": "FLOOR",
+      "kind": 1,
+      "detail": "Floor",
+      "documentation": {
+        "value": "Round down to nearest integer.\n\n```sql\nSELECT FLOOR(4.9);\n```"
+      },
+      "insertText": "FLOOR(${1:number})",
+      "insertTextRules": 4,
+      "sortText": "01_floor"
+    },
+    {
+      "label": "ROUND",
+      "kind": 1,
+      "detail": "Round",
+      "documentation": {
+        "value": "Round to specified decimals.\n\n```sql\nSELECT ROUND(price, 2) FROM products;\n```"
+      },
+      "insertText": "ROUND(${1:number}, ${2:decimals})",
+      "insertTextRules": 4,
+      "sortText": "01_round"
+    },
+    {
+      "label": "TRUNC",
+      "kind": 1,
+      "detail": "Truncate number",
+      "documentation": {
+        "value": "Truncate to specified decimals.\n\n```sql\nSELECT TRUNC(3.14159, 2);\n```"
+      },
+      "insertText": "TRUNC(${1:number}, ${2:decimals})",
+      "insertTextRules": 4,
+      "sortText": "01_trunc"
+    },
+    {
+      "label": "MOD",
+      "kind": 1,
+      "detail": "Modulo",
+      "documentation": {
+        "value": "Remainder of division.\n\n```sql\nSELECT MOD(10, 3);\n```"
+      },
+      "insertText": "MOD(${1:dividend}, ${2:divisor})",
+      "insertTextRules": 4,
+      "sortText": "01_mod"
+    },
+    {
+      "label": "POWER",
+      "kind": 1,
+      "detail": "Power",
+      "documentation": {
+        "value": "Raise to a power.\n\n```sql\nSELECT POWER(2, 10);\n```"
+      },
+      "insertText": "POWER(${1:base}, ${2:exponent})",
+      "insertTextRules": 4,
+      "sortText": "01_power"
+    },
+    {
+      "label": "SQRT",
+      "kind": 1,
+      "detail": "Square root",
+      "documentation": {
+        "value": "Calculate square root.\n\n```sql\nSELECT SQRT(144);\n```"
+      },
+      "insertText": "SQRT(${1:number})",
+      "insertTextRules": 4,
+      "sortText": "01_sqrt"
+    },
+    {
+      "label": "LOG",
+      "kind": 1,
+      "detail": "Logarithm",
+      "documentation": {
+        "value": "Calculate logarithm.\n\n```sql\nSELECT LOG(10, 1000);\n```"
+      },
+      "insertText": "LOG(${1:base}, ${2:number})",
+      "insertTextRules": 4,
+      "sortText": "01_log"
+    },
+    {
+      "label": "LN",
+      "kind": 1,
+      "detail": "Natural logarithm",
+      "documentation": {
+        "value": "Natural log (base e).\n\n```sql\nSELECT LN(2.718);\n```"
+      },
+      "insertText": "LN(${1:number})",
+      "insertTextRules": 4,
+      "sortText": "01_ln"
+    },
+    {
+      "label": "EXP",
+      "kind": 1,
+      "detail": "Exponential",
+      "documentation": {
+        "value": "Raise e to a power.\n\n```sql\nSELECT EXP(1);\n```"
+      },
+      "insertText": "EXP(${1:number})",
+      "insertTextRules": 4,
+      "sortText": "01_exp"
+    },
+    {
+      "label": "SIGN",
+      "kind": 1,
+      "detail": "Sign",
+      "documentation": {
+        "value": "Return sign of number (-1, 0, 1).\n\n```sql\nSELECT SIGN(-42);\n```"
+      },
+      "insertText": "SIGN(${1:number})",
+      "insertTextRules": 4,
+      "sortText": "01_sign"
+    },
+    {
+      "label": "GREATEST",
+      "kind": 1,
+      "detail": "Greatest value",
+      "documentation": {
+        "value": "Return the largest value.\n\n```sql\nSELECT GREATEST(a, b, c) FROM t;\n```"
+      },
+      "insertText": "GREATEST(${1:value1}, ${2:value2})",
+      "insertTextRules": 4,
+      "sortText": "01_greatest"
+    },
+    {
+      "label": "LEAST",
+      "kind": 1,
+      "detail": "Least value",
+      "documentation": {
+        "value": "Return the smallest value.\n\n```sql\nSELECT LEAST(a, b, c) FROM t;\n```"
+      },
+      "insertText": "LEAST(${1:value1}, ${2:value2})",
+      "insertTextRules": 4,
+      "sortText": "01_least"
+    },
+    {
+      "label": "RANDOM",
+      "kind": 1,
+      "detail": "Random value (PostgreSQL)",
+      "documentation": {
+        "value": "Generate random float between 0 and 1.\n\n```sql\nSELECT RANDOM();\n```"
+      },
+      "insertText": "RANDOM()",
+      "insertTextRules": 4,
+      "sortText": "01_random"
+    },
+    {
+      "label": "CASE WHEN",
+      "kind": 15,
+      "detail": "Case expression",
+      "documentation": {
+        "value": "Conditional logic.\n\n```sql\nSELECT name,\n  CASE\n    WHEN score >= 90 THEN 'A'\n    WHEN score >= 80 THEN 'B'\n    ELSE 'C'\n  END AS grade\nFROM students;\n```"
+      },
+      "insertText": "CASE\n  WHEN ${1:condition} THEN ${2:result}\n  WHEN ${3:condition2} THEN ${4:result2}\n  ELSE ${5:default}\nEND",
+      "insertTextRules": 4,
+      "sortText": "00_case_when"
+    },
+    {
+      "label": "COALESCE",
+      "kind": 1,
+      "detail": "Coalesce",
+      "documentation": {
+        "value": "Return first non-null value.\n\n```sql\nSELECT COALESCE(nickname, name, 'Anonymous') FROM users;\n```"
+      },
+      "insertText": "COALESCE(${1:value1}, ${2:value2})",
+      "insertTextRules": 4,
+      "sortText": "01_coalesce"
+    },
+    {
+      "label": "NULLIF",
+      "kind": 1,
+      "detail": "Null if equal",
+      "documentation": {
+        "value": "Return NULL if both values are equal.\n\n```sql\nSELECT NULLIF(discount, 0) FROM products;\n```"
+      },
+      "insertText": "NULLIF(${1:value1}, ${2:value2})",
+      "insertTextRules": 4,
+      "sortText": "01_nullif"
+    },
+    {
+      "label": "IFNULL",
+      "kind": 1,
+      "detail": "If null (MySQL)",
+      "documentation": {
+        "value": "Return alternative if NULL.\n\n```sql\nSELECT IFNULL(phone, 'N/A') FROM contacts;\n```"
+      },
+      "insertText": "IFNULL(${1:expression}, ${2:alternative})",
+      "insertTextRules": 4,
+      "sortText": "01_ifnull"
+    },
+    {
+      "label": "NVL",
+      "kind": 1,
+      "detail": "NVL (Oracle)",
+      "documentation": {
+        "value": "Return alternative if NULL.\n\n```sql\nSELECT NVL(commission, 0) FROM sales;\n```"
+      },
+      "insertText": "NVL(${1:expression}, ${2:alternative})",
+      "insertTextRules": 4,
+      "sortText": "01_nvl"
+    },
+    {
+      "label": "IIF",
+      "kind": 1,
+      "detail": "Inline if (SQL Server)",
+      "documentation": {
+        "value": "Ternary conditional.\n\n```sql\nSELECT IIF(score >= 60, 'Pass', 'Fail') FROM exams;\n```"
+      },
+      "insertText": "IIF(${1:condition}, ${2:true_val}, ${3:false_val})",
+      "insertTextRules": 4,
+      "sortText": "01_iif"
+    },
+    {
+      "label": "CAST",
+      "kind": 1,
+      "detail": "Cast type",
+      "documentation": {
+        "value": "Convert a value to a specified type.\n\n```sql\nSELECT CAST(price AS INTEGER) FROM products;\n```"
+      },
+      "insertText": "CAST(${1:expression} AS ${2|INTEGER,BIGINT,NUMERIC,VARCHAR,TEXT,DATE,TIMESTAMP,BOOLEAN|})",
+      "insertTextRules": 4,
+      "sortText": "01_cast"
+    },
+    {
+      "label": "::type (PostgreSQL)",
+      "kind": 15,
+      "detail": "PostgreSQL cast operator",
+      "documentation": {
+        "value": "Cast using `::` syntax.\n\n```sql\nSELECT '2024-01-01'::DATE;\nSELECT price::INTEGER FROM products;\n```"
+      },
+      "insertText": "${1:expression}::${2|INTEGER,BIGINT,NUMERIC,VARCHAR,TEXT,DATE,TIMESTAMP,BOOLEAN,JSONB|}",
+      "insertTextRules": 4,
+      "sortText": "00_::type_(postgresql)"
+    },
+    {
+      "label": "CONVERT",
+      "kind": 1,
+      "detail": "Convert (MySQL/SQL Server)",
+      "documentation": {
+        "value": "Convert expression to a type.\n\n```sql\nSELECT CONVERT(price, SIGNED) FROM products;\n```"
+      },
+      "insertText": "CONVERT(${1:expression}, ${2:type})",
+      "insertTextRules": 4,
+      "sortText": "01_convert"
+    },
+    {
+      "label": "JSON_EXTRACT",
+      "kind": 1,
+      "detail": "JSON extract (MySQL)",
+      "documentation": {
+        "value": "Extract value from JSON.\n\n```sql\nSELECT JSON_EXTRACT(data, '$.name') FROM documents;\n```"
+      },
+      "insertText": "JSON_EXTRACT(${1:json_col}, '${2:\\$.path}')",
+      "insertTextRules": 4,
+      "sortText": "01_json_extract"
+    },
+    {
+      "label": "JSON_OBJECT",
+      "kind": 1,
+      "detail": "JSON object",
+      "documentation": {
+        "value": "Create a JSON object.\n\n```sql\nSELECT JSON_OBJECT('name', name, 'email', email) FROM users;\n```"
+      },
+      "insertText": "JSON_OBJECT(${1:'key'}, ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "01_json_object"
+    },
+    {
+      "label": "JSON_ARRAY",
+      "kind": 1,
+      "detail": "JSON array",
+      "documentation": {
+        "value": "Create a JSON array.\n\n```sql\nSELECT JSON_ARRAY(1, 2, 3);\n```"
+      },
+      "insertText": "JSON_ARRAY(${1:values})",
+      "insertTextRules": 4,
+      "sortText": "01_json_array"
+    },
+    {
+      "label": "JSON_SET",
+      "kind": 1,
+      "detail": "JSON set (MySQL)",
+      "documentation": {
+        "value": "Set value in JSON.\n\n```sql\nSELECT JSON_SET(data, '$.status', 'active') FROM documents;\n```"
+      },
+      "insertText": "JSON_SET(${1:json_col}, '${2:\\$.path}', ${3:value})",
+      "insertTextRules": 4,
+      "sortText": "01_json_set"
+    },
+    {
+      "label": "JSON_REMOVE",
+      "kind": 1,
+      "detail": "JSON remove (MySQL)",
+      "documentation": {
+        "value": "Remove key from JSON.\n\n```sql\nSELECT JSON_REMOVE(data, '$.temp') FROM documents;\n```"
+      },
+      "insertText": "JSON_REMOVE(${1:json_col}, '${2:\\$.path}')",
+      "insertTextRules": 4,
+      "sortText": "01_json_remove"
+    },
+    {
+      "label": "jsonb -> operator",
+      "kind": 15,
+      "detail": "JSONB get object (PostgreSQL)",
+      "documentation": {
+        "value": "Get JSON object field by key.\n\n```sql\nSELECT data -> 'name' FROM documents;\nSELECT data ->> 'name' FROM documents; -- as text\n```"
+      },
+      "insertText": "${1:column} ->> '${2:key}'",
+      "insertTextRules": 4,
+      "sortText": "00_jsonb_->_operator"
+    },
+    {
+      "label": "jsonb #> operator",
+      "kind": 15,
+      "detail": "JSONB path extract (PostgreSQL)",
+      "documentation": {
+        "value": "Get JSON value at path.\n\n```sql\nSELECT data #> '{address,city}' FROM users;\nSELECT data #>> '{address,city}' FROM users; -- as text\n```"
+      },
+      "insertText": "${1:column} #>> '{${2:path}}'",
+      "insertTextRules": 4,
+      "sortText": "00_jsonb_#>_operator"
+    },
+    {
+      "label": "jsonb @> operator",
+      "kind": 15,
+      "detail": "JSONB containment (PostgreSQL)",
+      "documentation": {
+        "value": "Check if JSONB contains another.\n\n```sql\nSELECT * FROM documents WHERE data @> '{\"status\": \"active\"}';\n```"
+      },
+      "insertText": "${1:column} @> '${2:{\"key\": \"value\"}}'",
+      "insertTextRules": 4,
+      "sortText": "00_jsonb_@>_operator"
+    },
+    {
+      "label": "jsonb ? operator",
+      "kind": 15,
+      "detail": "JSONB key exists (PostgreSQL)",
+      "documentation": {
+        "value": "Check if key exists in JSONB.\n\n```sql\nSELECT * FROM documents WHERE data ? 'email';\n```"
+      },
+      "insertText": "${1:column} ? '${2:key}'",
+      "insertTextRules": 4,
+      "sortText": "00_jsonb_?_operator"
+    },
+    {
+      "label": "JSON_BUILD_OBJECT",
+      "kind": 1,
+      "detail": "Build JSON object (PostgreSQL)",
+      "documentation": {
+        "value": "Build a JSON object from pairs.\n\n```sql\nSELECT JSON_BUILD_OBJECT('id', id, 'name', name) FROM users;\n```"
+      },
+      "insertText": "JSON_BUILD_OBJECT(${1:'key'}, ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "01_json_build_object"
+    },
+    {
+      "label": "JSON_EACH",
+      "kind": 1,
+      "detail": "JSON each (PostgreSQL)",
+      "documentation": {
+        "value": "Expand JSON to set of key-value pairs.\n\n```sql\nSELECT * FROM JSON_EACH('{\"a\":1,\"b\":2}');\n```"
+      },
+      "insertText": "JSON_EACH(${1:json_expression})",
+      "insertTextRules": 4,
+      "sortText": "01_json_each"
+    },
+    {
+      "label": "JSON_TYPEOF",
+      "kind": 1,
+      "detail": "JSON typeof (PostgreSQL)",
+      "documentation": {
+        "value": "Get the type of a JSON value.\n\n```sql\nSELECT JSON_TYPEOF(data -> 'count') FROM documents;\n```"
+      },
+      "insertText": "JSON_TYPEOF(${1:json_expression})",
+      "insertTextRules": 4,
+      "sortText": "01_json_typeof"
+    },
+    {
+      "label": "JSON_ARRAY_LENGTH",
+      "kind": 1,
+      "detail": "JSON array length (PostgreSQL)",
+      "documentation": {
+        "value": "Get length of a JSON array.\n\n```sql\nSELECT JSON_ARRAY_LENGTH(data -> 'items') FROM orders;\n```"
+      },
+      "insertText": "JSON_ARRAY_LENGTH(${1:json_array})",
+      "insertTextRules": 4,
+      "sortText": "01_json_array_length"
+    },
+    {
+      "label": "WITH CTE",
+      "kind": 15,
+      "detail": "Common table expression",
+      "documentation": {
+        "value": "Define a named subquery.\n\n```sql\nWITH active_users AS (\n  SELECT * FROM users WHERE active = true\n)\nSELECT * FROM active_users;\n```"
+      },
+      "insertText": "WITH ${1:cte_name} AS (\n  SELECT ${2:columns}\n  FROM ${3:table}\n  WHERE ${4:condition}\n)\nSELECT ${5:*}\nFROM ${1:cte_name};",
+      "insertTextRules": 4,
+      "sortText": "00_with_cte"
+    },
+    {
+      "label": "WITH RECURSIVE",
+      "kind": 15,
+      "detail": "Recursive CTE",
+      "documentation": {
+        "value": "Recursive common table expression.\n\n```sql\nWITH RECURSIVE hierarchy AS (\n  SELECT id, name, parent_id, 1 AS level\n  FROM categories WHERE parent_id IS NULL\n  UNION ALL\n  SELECT c.id, c.name, c.parent_id, h.level + 1\n  FROM categories c\n  JOIN hierarchy h ON c.parent_id = h.id\n)\nSELECT * FROM hierarchy;\n```"
+      },
+      "insertText": "WITH RECURSIVE ${1:cte_name} AS (\n  -- Base case\n  SELECT ${2:id}, ${3:columns}, 1 AS ${4:level}\n  FROM ${5:table}\n  WHERE ${6:parent_id IS NULL}\n  UNION ALL\n  -- Recursive case\n  SELECT ${7:t}.${2:id}, ${7:t}.${3:columns}, ${8:r}.${4:level} + 1\n  FROM ${5:table} ${7:t}\n  JOIN ${1:cte_name} ${8:r} ON ${7:t}.${9:parent_id} = ${8:r}.${2:id}\n)\nSELECT * FROM ${1:cte_name};",
+      "insertTextRules": 4,
+      "sortText": "00_with_recursive"
+    },
+    {
+      "label": "Multiple CTEs",
+      "kind": 15,
+      "detail": "Multiple CTEs",
+      "documentation": {
+        "value": "Chain several CTEs.\n\n```sql\nWITH\n  users_cte AS (SELECT * FROM users WHERE active),\n  orders_cte AS (SELECT * FROM orders WHERE total > 100)\nSELECT u.name, o.total\nFROM users_cte u JOIN orders_cte o ON u.id = o.user_id;\n```"
+      },
+      "insertText": "WITH\n  ${1:cte1} AS (\n    SELECT ${2:*} FROM ${3:table1} WHERE ${4:condition1}\n  ),\n  ${5:cte2} AS (\n    SELECT ${6:*} FROM ${7:table2} WHERE ${8:condition2}\n  )\nSELECT ${9:columns}\nFROM ${1:cte1}\nJOIN ${5:cte2} ON ${10:join_condition};",
+      "insertTextRules": 4,
+      "sortText": "00_multiple_ctes"
+    },
+    {
+      "label": "UNION",
+      "kind": 14,
+      "detail": "Union",
+      "documentation": {
+        "value": "Combine results removing duplicates.\n\n```sql\nSELECT name FROM customers\nUNION\nSELECT name FROM suppliers;\n```"
+      },
+      "insertText": "SELECT ${1:columns} FROM ${2:table1}\nUNION\nSELECT ${1:columns} FROM ${3:table2};",
+      "insertTextRules": 4,
+      "sortText": "00_union"
+    },
+    {
+      "label": "UNION ALL",
+      "kind": 14,
+      "detail": "Union all",
+      "documentation": {
+        "value": "Combine results keeping duplicates.\n\n```sql\nSELECT name FROM customers\nUNION ALL\nSELECT name FROM suppliers;\n```"
+      },
+      "insertText": "SELECT ${1:columns} FROM ${2:table1}\nUNION ALL\nSELECT ${1:columns} FROM ${3:table2};",
+      "insertTextRules": 4,
+      "sortText": "00_union all"
+    },
+    {
+      "label": "INTERSECT",
+      "kind": 14,
+      "detail": "Intersect",
+      "documentation": {
+        "value": "Return rows present in both queries.\n\n```sql\nSELECT id FROM table_a\nINTERSECT\nSELECT id FROM table_b;\n```"
+      },
+      "insertText": "SELECT ${1:columns} FROM ${2:table1}\nINTERSECT\nSELECT ${1:columns} FROM ${3:table2};",
+      "insertTextRules": 4,
+      "sortText": "00_intersect"
+    },
+    {
+      "label": "EXCEPT",
+      "kind": 14,
+      "detail": "Except",
+      "documentation": {
+        "value": "Return rows in first query but not second.\n\n```sql\nSELECT id FROM all_users\nEXCEPT\nSELECT id FROM banned_users;\n```"
+      },
+      "insertText": "SELECT ${1:columns} FROM ${2:table1}\nEXCEPT\nSELECT ${1:columns} FROM ${3:table2};",
+      "insertTextRules": 4,
+      "sortText": "00_except"
+    },
+    {
+      "label": "BEGIN",
+      "kind": 14,
+      "detail": "Begin transaction",
+      "documentation": {
+        "value": "Start a transaction.\n\n```sql\nBEGIN;\n```"
+      },
+      "insertText": "BEGIN;",
+      "insertTextRules": 4,
+      "sortText": "00_begin"
+    },
+    {
+      "label": "COMMIT",
+      "kind": 14,
+      "detail": "Commit transaction",
+      "documentation": {
+        "value": "Save all changes made in the transaction.\n\n```sql\nCOMMIT;\n```"
+      },
+      "insertText": "COMMIT;",
+      "insertTextRules": 4,
+      "sortText": "00_commit"
+    },
+    {
+      "label": "ROLLBACK",
+      "kind": 14,
+      "detail": "Rollback transaction",
+      "documentation": {
+        "value": "Undo all changes made in the transaction.\n\n```sql\nROLLBACK;\n```"
+      },
+      "insertText": "ROLLBACK;",
       "insertTextRules": 4,
-      "sortText": "00_SELECT_DISTINCT"
+      "sortText": "00_rollback"
     },
     {
-      "label": "SELECT * FROM",
-      "kind": 15,
-      "detail": "Select all columns from a table",
-      "documentation": { "value": "Retrieves all columns from the specified table." },
-      "insertText": "SELECT * FROM ${1:table}",
+      "label": "SAVEPOINT",
+      "kind": 14,
+      "detail": "Savepoint",
+      "documentation": {
+        "value": "Create a savepoint within a transaction.\n\n```sql\nSAVEPOINT my_savepoint;\n```"
+      },
+      "insertText": "SAVEPOINT ${1:name};",
       "insertTextRules": 4,
-      "sortText": "00_SELECT_ALL"
+      "sortText": "00_savepoint"
     },
     {
-      "label": "INSERT INTO",
+      "label": "RELEASE SAVEPOINT",
       "kind": 14,
-      "detail": "Insert rows into a table",
-      "documentation": { "value": "Inserts one or more rows into a table with specified column values." },
-      "insertText": "INSERT INTO ${1:table} (${2:columns}) VALUES (${3:values})",
+      "detail": "Release savepoint",
+      "documentation": {
+        "value": "Release a savepoint.\n\n```sql\nRELEASE SAVEPOINT my_savepoint;\n```"
+      },
+      "insertText": "RELEASE SAVEPOINT ${1:name};",
       "insertTextRules": 4,
-      "sortText": "01_INSERT"
+      "sortText": "00_release savepoint"
     },
     {
-      "label": "INSERT INTO SELECT",
+      "label": "Transaction block",
       "kind": 15,
-      "detail": "Insert rows from a query",
-      "documentation": { "value": "Inserts rows into a table using the result of a SELECT statement." },
-      "insertText": "INSERT INTO ${1:target_table} (${2:columns})\nSELECT ${3:columns} FROM ${4:source_table}\nWHERE ${5:condition}",
+      "detail": "Full transaction block",
+      "documentation": {
+        "value": "Complete transaction with error handling.\n\n```sql\nBEGIN;\n  UPDATE accounts SET balance = balance - 100 WHERE id = 1;\n  UPDATE accounts SET balance = balance + 100 WHERE id = 2;\nCOMMIT;\n```"
+      },
+      "insertText": "BEGIN;\n  ${1:-- statements}\n  ${2:UPDATE ${3:table} SET ${4:col} = ${5:val} WHERE ${6:cond};}\nCOMMIT;",
       "insertTextRules": 4,
-      "sortText": "01_INSERT_SELECT"
+      "sortText": "00_transaction_block"
     },
     {
-      "label": "UPDATE",
+      "label": "GRANT",
       "kind": 14,
-      "detail": "Update rows in a table",
-      "documentation": { "value": "Modifies existing rows in a table that match an optional WHERE condition." },
-      "insertText": "UPDATE ${1:table} SET ${2:column} = ${3:value} WHERE ${4:condition}",
+      "detail": "Grant privileges",
+      "documentation": {
+        "value": "Grant permissions.\n\n```sql\nGRANT SELECT, INSERT ON users TO app_role;\n```"
+      },
+      "insertText": "GRANT ${1|SELECT,INSERT,UPDATE,DELETE,ALL PRIVILEGES|} ON ${2:table} TO ${3:role};",
       "insertTextRules": 4,
-      "sortText": "01_UPDATE"
+      "sortText": "00_grant"
     },
     {
-      "label": "DELETE FROM",
+      "label": "REVOKE",
       "kind": 14,
-      "detail": "Delete rows from a table",
-      "documentation": { "value": "Removes rows from a table that match the specified WHERE condition. Omitting WHERE deletes all rows." },
-      "insertText": "DELETE FROM ${1:table} WHERE ${2:condition}",
+      "detail": "Revoke privileges",
+      "documentation": {
+        "value": "Remove permissions.\n\n```sql\nREVOKE INSERT ON users FROM app_role;\n```"
+      },
+      "insertText": "REVOKE ${1|SELECT,INSERT,UPDATE,DELETE,ALL PRIVILEGES|} ON ${2:table} FROM ${3:role};",
       "insertTextRules": 4,
-      "sortText": "01_DELETE"
+      "sortText": "00_revoke"
     },
     {
-      "label": "CREATE TABLE",
+      "label": "EXPLAIN",
       "kind": 15,
-      "detail": "Create a new table",
-      "documentation": { "value": "Creates a new table with the specified columns, data types, and constraints." },
-      "insertText": "CREATE TABLE ${1:table_name} (\n\t${2:id} INT PRIMARY KEY AUTO_INCREMENT,\n\t${3:column_name} ${4:VARCHAR(255)} ${5:NOT NULL},\n\tCREATED_AT TIMESTAMP DEFAULT CURRENT_TIMESTAMP\n)",
+      "detail": "Explain query plan",
+      "documentation": {
+        "value": "Show the execution plan.\n\n```sql\nEXPLAIN SELECT * FROM users WHERE email = 'a@b.com';\n```"
+      },
+      "insertText": "EXPLAIN ${1:SELECT * FROM ${2:table} WHERE ${3:condition}};",
       "insertTextRules": 4,
-      "sortText": "02_CREATE_TABLE"
+      "sortText": "00_explain"
     },
     {
-      "label": "CREATE TABLE IF NOT EXISTS",
+      "label": "EXPLAIN ANALYZE",
       "kind": 15,
-      "detail": "Create table if it doesn't exist",
-      "documentation": { "value": "Creates a new table only if a table with the same name does not already exist." },
-      "insertText": "CREATE TABLE IF NOT EXISTS ${1:table_name} (\n\t${2:id} INT PRIMARY KEY AUTO_INCREMENT,\n\t${3:column_name} ${4:VARCHAR(255)}\n)",
+      "detail": "Explain analyze",
+      "documentation": {
+        "value": "Show execution plan with actual timings.\n\n```sql\nEXPLAIN ANALYZE SELECT * FROM users WHERE email = 'a@b.com';\n```"
+      },
+      "insertText": "EXPLAIN ANALYZE ${1:SELECT * FROM ${2:table} WHERE ${3:condition}};",
       "insertTextRules": 4,
-      "sortText": "02_CREATE_TABLE_IF"
+      "sortText": "00_explain_analyze"
     },
     {
-      "label": "CREATE INDEX",
-      "kind": 15,
-      "detail": "Create an index on a table",
-      "documentation": { "value": "Creates an index on one or more columns to improve query performance." },
-      "insertText": "CREATE INDEX ${1:idx_name} ON ${2:table} (${3:column})",
+      "label": "VACUUM",
+      "kind": 14,
+      "detail": "Vacuum (PostgreSQL)",
+      "documentation": {
+        "value": "Reclaim storage and update statistics.\n\n```sql\nVACUUM ANALYZE users;\n```"
+      },
+      "insertText": "VACUUM ${1|ANALYZE,FULL,VERBOSE|} ${2:table};",
       "insertTextRules": 4,
-      "sortText": "02_CREATE_INDEX"
+      "sortText": "00_vacuum"
     },
     {
-      "label": "CREATE UNIQUE INDEX",
-      "kind": 15,
-      "detail": "Create a unique index",
-      "documentation": { "value": "Creates a unique index ensuring no duplicate values in the indexed columns." },
-      "insertText": "CREATE UNIQUE INDEX ${1:idx_name} ON ${2:table} (${3:column})",
+      "label": "CLUSTER",
+      "kind": 14,
+      "detail": "Cluster (PostgreSQL)",
+      "documentation": {
+        "value": "Reorder table rows according to an index.\n\n```sql\nCLUSTER users USING idx_users_email;\n```"
+      },
+      "insertText": "CLUSTER ${1:table} USING ${2:index};",
       "insertTextRules": 4,
-      "sortText": "02_CREATE_UNIQUE_INDEX"
+      "sortText": "00_cluster"
     },
     {
-      "label": "CREATE VIEW",
-      "kind": 15,
-      "detail": "Create a view",
-      "documentation": { "value": "Creates a virtual table based on a SELECT query. Views simplify complex queries and provide abstraction." },
-      "insertText": "CREATE VIEW ${1:view_name} AS\nSELECT ${2:columns}\nFROM ${3:table}\nWHERE ${4:condition}",
+      "label": "REINDEX",
+      "kind": 14,
+      "detail": "Reindex",
+      "documentation": {
+        "value": "Rebuild indexes.\n\n```sql\nREINDEX TABLE users;\n```"
+      },
+      "insertText": "REINDEX ${1|TABLE,INDEX,DATABASE|} ${2:name};",
       "insertTextRules": 4,
-      "sortText": "02_CREATE_VIEW"
+      "sortText": "00_reindex"
     },
     {
-      "label": "CREATE DATABASE",
+      "label": "CREATE FUNCTION",
       "kind": 15,
-      "detail": "Create a new database",
-      "documentation": { "value": "Creates a new database with the specified name." },
-      "insertText": "CREATE DATABASE ${1:database_name}",
+      "detail": "Create function (PostgreSQL)",
+      "documentation": {
+        "value": "Create a PL/pgSQL function.\n\n```sql\nCREATE OR REPLACE FUNCTION get_user(p_id INT)\nRETURNS TABLE(name TEXT, email TEXT) AS $$\nBEGIN\n  RETURN QUERY SELECT u.name, u.email FROM users u WHERE u.id = p_id;\nEND;\n$$ LANGUAGE plpgsql;\n```"
+      },
+      "insertText": "CREATE OR REPLACE FUNCTION ${1:function_name}(${2:params})\nRETURNS ${3:return_type} AS $$\nBEGIN\n  ${4:-- body}\n  RETURN ${5:result};\nEND;\n$$ LANGUAGE plpgsql;",
       "insertTextRules": 4,
-      "sortText": "02_CREATE_DATABASE"
+      "sortText": "00_create_function"
     },
     {
-      "label": "ALTER TABLE ADD COLUMN",
+      "label": "CREATE PROCEDURE",
       "kind": 15,
-      "detail": "Add a column to a table",
-      "documentation": { "value": "Adds a new column to an existing table with the specified data type and constraints." },
-      "insertText": "ALTER TABLE ${1:table} ADD COLUMN ${2:column_name} ${3:data_type}",
+      "detail": "Create procedure (PostgreSQL 11+ / MySQL)",
+      "documentation": {
+        "value": "Create a stored procedure.\n\n```sql\nCREATE OR REPLACE PROCEDURE transfer(sender INT, receiver INT, amount NUMERIC)\nLANGUAGE plpgsql AS $$\nBEGIN\n  UPDATE accounts SET balance = balance - amount WHERE id = sender;\n  UPDATE accounts SET balance = balance + amount WHERE id = receiver;\nEND;\n$$;\n```"
+      },
+      "insertText": "CREATE OR REPLACE PROCEDURE ${1:proc_name}(${2:params})\nLANGUAGE plpgsql AS $$\nBEGIN\n  ${3:-- body}\nEND;\n$$;",
       "insertTextRules": 4,
-      "sortText": "03_ALTER_ADD"
+      "sortText": "00_create_procedure"
     },
     {
-      "label": "ALTER TABLE DROP COLUMN",
+      "label": "CREATE TRIGGER",
       "kind": 15,
-      "detail": "Remove a column from a table",
-      "documentation": { "value": "Removes an existing column from a table. This is a destructive operation." },
-      "insertText": "ALTER TABLE ${1:table} DROP COLUMN ${2:column_name}",
+      "detail": "Create trigger",
+      "documentation": {
+        "value": "Create a trigger.\n\n```sql\nCREATE TRIGGER audit_update\nAFTER UPDATE ON users\nFOR EACH ROW\nEXECUTE FUNCTION log_change();\n```"
+      },
+      "insertText": "CREATE TRIGGER ${1:trigger_name}\n${2|BEFORE,AFTER,INSTEAD OF|} ${3|INSERT,UPDATE,DELETE|} ON ${4:table}\nFOR EACH ROW\nEXECUTE FUNCTION ${5:function_name}();",
       "insertTextRules": 4,
-      "sortText": "03_ALTER_DROP"
+      "sortText": "00_create_trigger"
     },
     {
-      "label": "ALTER TABLE MODIFY COLUMN",
+      "label": "CREATE TYPE",
       "kind": 15,
-      "detail": "Modify a column definition",
-      "documentation": { "value": "Changes the data type or constraints of an existing column." },
-      "insertText": "ALTER TABLE ${1:table} MODIFY COLUMN ${2:column_name} ${3:new_data_type}",
+      "detail": "Create type (PostgreSQL)",
+      "documentation": {
+        "value": "Create a custom composite type.\n\n```sql\nCREATE TYPE address AS (\n  street TEXT,\n  city TEXT,\n  zip VARCHAR(10)\n);\n```"
+      },
+      "insertText": "CREATE TYPE ${1:type_name} AS (\n  ${2:field1} ${3:TEXT},\n  ${4:field2} ${5:TEXT}\n);",
       "insertTextRules": 4,
-      "sortText": "03_ALTER_MODIFY"
+      "sortText": "00_create_type"
     },
     {
-      "label": "ALTER TABLE RENAME",
+      "label": "CREATE ENUM",
       "kind": 15,
-      "detail": "Rename a table",
-      "documentation": { "value": "Renames an existing table to a new name." },
-      "insertText": "ALTER TABLE ${1:old_name} RENAME TO ${2:new_name}",
-      "insertTextRules": 4,
-      "sortText": "03_ALTER_RENAME"
-    },
-    {
-      "label": "DROP TABLE",
-      "kind": 14,
-      "detail": "Drop a table",
-      "documentation": { "value": "Permanently removes a table and all its data from the database." },
-      "insertText": "DROP TABLE IF EXISTS ${1:table_name}",
+      "detail": "Create enum type (PostgreSQL)",
+      "documentation": {
+        "value": "Create an enumerated type.\n\n```sql\nCREATE TYPE status AS ENUM ('active', 'inactive', 'pending');\n```"
+      },
+      "insertText": "CREATE TYPE ${1:type_name} AS ENUM (${2:'value1', 'value2', 'value3'});",
       "insertTextRules": 4,
-      "sortText": "03_DROP_TABLE"
+      "sortText": "00_create_enum"
     },
     {
-      "label": "DROP INDEX",
-      "kind": 14,
-      "detail": "Drop an index",
-      "documentation": { "value": "Removes an index from the database." },
-      "insertText": "DROP INDEX ${1:index_name} ON ${2:table}",
+      "label": "DO block",
+      "kind": 15,
+      "detail": "Anonymous code block (PostgreSQL)",
+      "documentation": {
+        "value": "Execute anonymous PL/pgSQL.\n\n```sql\nDO $$\nBEGIN\n  RAISE NOTICE 'Hello, %', 'world';\nEND;\n$$;\n```"
+      },
+      "insertText": "DO $$\nBEGIN\n  ${1:-- body}\nEND;\n$$;",
       "insertTextRules": 4,
-      "sortText": "03_DROP_INDEX"
+      "sortText": "00_do_block"
     },
     {
-      "label": "DROP DATABASE",
-      "kind": 14,
-      "detail": "Drop a database",
-      "documentation": { "value": "Permanently removes a database and all its tables." },
-      "insertText": "DROP DATABASE IF EXISTS ${1:database_name}",
+      "label": "COPY",
+      "kind": 15,
+      "detail": "Copy (PostgreSQL)",
+      "documentation": {
+        "value": "Bulk load data from/to a file.\n\n```sql\nCOPY users (name, email) FROM '/tmp/users.csv' WITH (FORMAT csv, HEADER true);\n```"
+      },
+      "insertText": "COPY ${1:table} (${2:columns})\n${3|FROM,TO|} '${4:/path/to/file.csv}'\nWITH (FORMAT csv, HEADER true);",
       "insertTextRules": 4,
-      "sortText": "03_DROP_DATABASE"
+      "sortText": "00_copy"
     },
     {
-      "label": "WHERE",
-      "kind": 14,
-      "detail": "Filter rows by condition",
-      "documentation": { "value": "Filters rows based on a specified condition. Used with SELECT, UPDATE, and DELETE statements." },
-      "insertText": "WHERE ${1:condition}",
+      "label": "PREPARE",
+      "kind": 15,
+      "detail": "Prepared statement",
+      "documentation": {
+        "value": "Prepare a parameterized statement.\n\n```sql\nPREPARE get_user (INT) AS SELECT * FROM users WHERE id = $1;\nEXECUTE get_user(42);\n```"
+      },
+      "insertText": "PREPARE ${1:stmt_name} (${2:param_types}) AS\n${3:SELECT * FROM table WHERE id = \\$1};\nEXECUTE ${1:stmt_name}(${4:values});",
       "insertTextRules": 4,
-      "sortText": "04_WHERE"
+      "sortText": "00_prepare"
     },
     {
-      "label": "INNER JOIN",
+      "label": "DEALLOCATE",
       "kind": 14,
-      "detail": "Inner join two tables",
-      "documentation": { "value": "Returns rows that have matching values in both tables." },
-      "insertText": "INNER JOIN ${1:table} ON ${2:condition}",
+      "detail": "Deallocate prepared statement",
+      "documentation": {
+        "value": "Remove a prepared statement.\n\n```sql\nDEALLOCATE get_user;\n```"
+      },
+      "insertText": "DEALLOCATE ${1:stmt_name};",
       "insertTextRules": 4,
-      "sortText": "05_INNER_JOIN"
+      "sortText": "00_deallocate"
     },
     {
-      "label": "LEFT JOIN",
+      "label": "LOCK TABLE",
       "kind": 14,
-      "detail": "Left outer join",
-      "documentation": { "value": "Returns all rows from the left table and matched rows from the right table. Non-matching right rows are NULL." },
-      "insertText": "LEFT JOIN ${1:table} ON ${2:condition}",
+      "detail": "Lock table",
+      "documentation": {
+        "value": "Acquire a table lock.\n\n```sql\nLOCK TABLE accounts IN ACCESS EXCLUSIVE MODE;\n```"
+      },
+      "insertText": "LOCK TABLE ${1:table} IN ${2|ACCESS SHARE,ROW SHARE,ROW EXCLUSIVE,SHARE UPDATE EXCLUSIVE,SHARE,SHARE ROW EXCLUSIVE,EXCLUSIVE,ACCESS EXCLUSIVE|} MODE;",
       "insertTextRules": 4,
-      "sortText": "05_LEFT_JOIN"
+      "sortText": "00_lock table"
     },
     {
-      "label": "RIGHT JOIN",
-      "kind": 14,
-      "detail": "Right outer join",
-      "documentation": { "value": "Returns all rows from the right table and matched rows from the left table. Non-matching left rows are NULL." },
-      "insertText": "RIGHT JOIN ${1:table} ON ${2:condition}",
+      "label": "Pagination query",
+      "kind": 15,
+      "detail": "Paginated query template",
+      "documentation": {
+        "value": "Offset-based pagination.\n\n```sql\nSELECT * FROM products\nORDER BY id\nLIMIT 20 OFFSET 40;\n```"
+      },
+      "insertText": "SELECT ${1:*}\nFROM ${2:table}\nORDER BY ${3:id}\nLIMIT ${4:20} OFFSET ${5:0};",
       "insertTextRules": 4,
-      "sortText": "05_RIGHT_JOIN"
+      "sortText": "00_pagination_query"
     },
     {
-      "label": "FULL OUTER JOIN",
-      "kind": 14,
-      "detail": "Full outer join",
-      "documentation": { "value": "Returns all rows from both tables with NULLs where there is no match." },
-      "insertText": "FULL OUTER JOIN ${1:table} ON ${2:condition}",
+      "label": "Keyset pagination",
+      "kind": 15,
+      "detail": "Keyset (cursor) pagination",
+      "documentation": {
+        "value": "Efficient cursor-based pagination.\n\n```sql\nSELECT * FROM products\nWHERE id > :last_id\nORDER BY id\nLIMIT 20;\n```"
+      },
+      "insertText": "SELECT ${1:*}\nFROM ${2:table}\nWHERE ${3:id} > ${4:last_seen_value}\nORDER BY ${3:id}\nLIMIT ${5:20};",
       "insertTextRules": 4,
-      "sortText": "05_FULL_JOIN"
+      "sortText": "00_keyset_pagination"
     },
     {
-      "label": "CROSS JOIN",
-      "kind": 14,
-      "detail": "Cross join (Cartesian product)",
-      "documentation": { "value": "Returns the Cartesian product of both tables — every combination of rows." },
-      "insertText": "CROSS JOIN ${1:table}",
+      "label": "Running total",
+      "kind": 15,
+      "detail": "Running total window query",
+      "documentation": {
+        "value": "Cumulative sum using window function.\n\n```sql\nSELECT date, amount,\n  SUM(amount) OVER (ORDER BY date) AS running_total\nFROM transactions;\n```"
+      },
+      "insertText": "SELECT ${1:date}, ${2:amount},\n  SUM(${2:amount}) OVER (ORDER BY ${1:date}) AS running_total\nFROM ${3:table};",
       "insertTextRules": 4,
-      "sortText": "05_CROSS_JOIN"
+      "sortText": "00_running_total"
     },
     {
-      "label": "SELF JOIN",
+      "label": "Top-N per group",
       "kind": 15,
-      "detail": "Join a table with itself",
-      "documentation": { "value": "Joins a table to itself using aliases, useful for hierarchical or comparative queries." },
-      "insertText": "SELECT a.${1:column}, b.${2:column}\nFROM ${3:table} a\nINNER JOIN ${3:table} b ON a.${4:key} = b.${5:key}",
+      "detail": "Top-N per group query",
+      "documentation": {
+        "value": "Get top N rows per category.\n\n```sql\nSELECT * FROM (\n  SELECT *, ROW_NUMBER() OVER (PARTITION BY dept ORDER BY salary DESC) AS rn\n  FROM employees\n) ranked\nWHERE rn <= 3;\n```"
+      },
+      "insertText": "SELECT * FROM (\n  SELECT *, ROW_NUMBER() OVER (PARTITION BY ${1:group_col} ORDER BY ${2:order_col} DESC) AS rn\n  FROM ${3:table}\n) ranked\nWHERE rn <= ${4:3};",
       "insertTextRules": 4,
-      "sortText": "05_SELF_JOIN"
+      "sortText": "00_top-n_per_group"
     },
     {
-      "label": "GROUP BY",
-      "kind": 14,
-      "detail": "Group rows by column(s)",
-      "documentation": { "value": "Groups rows sharing a value in specified columns into summary rows. Commonly used with aggregate functions." },
-      "insertText": "GROUP BY ${1:column}",
+      "label": "Duplicate finder",
+      "kind": 15,
+      "detail": "Find duplicate rows",
+      "documentation": {
+        "value": "Detect duplicates.\n\n```sql\nSELECT email, COUNT(*) AS cnt\nFROM users\nGROUP BY email\nHAVING COUNT(*) > 1;\n```"
+      },
+      "insertText": "SELECT ${1:column}, COUNT(*) AS cnt\nFROM ${2:table}\nGROUP BY ${1:column}\nHAVING COUNT(*) > 1;",
       "insertTextRules": 4,
-      "sortText": "06_GROUP_BY"
+      "sortText": "00_duplicate_finder"
     },
     {
-      "label": "HAVING",
-      "kind": 14,
-      "detail": "Filter grouped rows",
-      "documentation": { "value": "Filters groups created by GROUP BY based on aggregate conditions. Similar to WHERE but for groups." },
-      "insertText": "HAVING ${1:condition}",
+      "label": "Gap analysis",
+      "kind": 15,
+      "detail": "Find gaps in sequence",
+      "documentation": {
+        "value": "Detect gaps in an ID sequence.\n\n```sql\nSELECT id + 1 AS gap_start,\n  LEAD(id) OVER (ORDER BY id) - 1 AS gap_end\nFROM orders\nWHERE LEAD(id) OVER (ORDER BY id) - id > 1;\n```"
+      },
+      "insertText": "SELECT ${1:id} + 1 AS gap_start,\n  LEAD(${1:id}) OVER (ORDER BY ${1:id}) - 1 AS gap_end\nFROM ${2:table}\nWHERE LEAD(${1:id}) OVER (ORDER BY ${1:id}) - ${1:id} > 1;",
       "insertTextRules": 4,
-      "sortText": "06_HAVING"
+      "sortText": "00_gap_analysis"
     },
     {
-      "label": "ORDER BY",
-      "kind": 14,
-      "detail": "Sort result set",
-      "documentation": { "value": "Sorts the result set by one or more columns in ascending (ASC) or descending (DESC) order." },
-      "insertText": "ORDER BY ${1:column} ${2|ASC,DESC|}",
+      "label": "Date series",
+      "kind": 15,
+      "detail": "Generate date series (PostgreSQL)",
+      "documentation": {
+        "value": "Generate a series of dates.\n\n```sql\nSELECT d::DATE\nFROM generate_series('2024-01-01'::DATE, '2024-12-31'::DATE, '1 day'::INTERVAL) d;\n```"
+      },
+      "insertText": "SELECT ${1:d}::DATE\nFROM generate_series(\n  '${2:2024-01-01}'::DATE,\n  '${3:2024-12-31}'::DATE,\n  '${4:1 day}'::INTERVAL\n) ${1:d};",
       "insertTextRules": 4,
-      "sortText": "06_ORDER_BY"
+      "sortText": "00_date_series"
     },
     {
-      "label": "LIMIT",
-      "kind": 14,
-      "detail": "Limit number of rows returned",
-      "documentation": { "value": "Restricts the number of rows returned by a query." },
-      "insertText": "LIMIT ${1:count}",
+      "label": "Recursive tree",
+      "kind": 15,
+      "detail": "Recursive tree / hierarchy",
+      "documentation": {
+        "value": "Traverse a parent-child tree.\n\n```sql\nWITH RECURSIVE tree AS (\n  SELECT id, name, parent_id, 0 AS depth, name::TEXT AS path\n  FROM categories WHERE parent_id IS NULL\n  UNION ALL\n  SELECT c.id, c.name, c.parent_id, t.depth + 1,\n    t.path || ' > ' || c.name\n  FROM categories c JOIN tree t ON c.parent_id = t.id\n)\nSELECT * FROM tree ORDER BY path;\n```"
+      },
+      "insertText": "WITH RECURSIVE tree AS (\n  SELECT ${1:id}, ${2:name}, ${3:parent_id}, 0 AS depth, ${2:name}::TEXT AS path\n  FROM ${4:table}\n  WHERE ${3:parent_id} IS NULL\n  UNION ALL\n  SELECT c.${1:id}, c.${2:name}, c.${3:parent_id}, t.depth + 1,\n    t.path || ' > ' || c.${2:name}\n  FROM ${4:table} c\n  JOIN tree t ON c.${3:parent_id} = t.${1:id}\n)\nSELECT * FROM tree ORDER BY path;",
       "insertTextRules": 4,
-      "sortText": "06_LIMIT"
+      "sortText": "00_recursive_tree"
     },
     {
-      "label": "OFFSET",
-      "kind": 14,
-      "detail": "Skip rows before returning",
-      "documentation": { "value": "Skips the specified number of rows before returning results. Used with LIMIT for pagination." },
-      "insertText": "OFFSET ${1:count}",
+      "label": "Audit trigger",
+      "kind": 15,
+      "detail": "Audit trigger function (PostgreSQL)",
+      "documentation": {
+        "value": "Trigger to log changes.\n\n```sql\nCREATE OR REPLACE FUNCTION audit_trigger()\nRETURNS TRIGGER AS $$\nBEGIN\n  INSERT INTO audit_log (table_name, action, old_data, new_data, changed_at)\n  VALUES (TG_TABLE_NAME, TG_OP, row_to_json(OLD), row_to_json(NEW), NOW());\n  RETURN NEW;\nEND;\n$$ LANGUAGE plpgsql;\n```"
+      },
+      "insertText": "CREATE OR REPLACE FUNCTION ${1:audit_trigger}()\nRETURNS TRIGGER AS $$\nBEGIN\n  INSERT INTO ${2:audit_log} (table_name, action, old_data, new_data, changed_at)\n  VALUES (TG_TABLE_NAME, TG_OP, row_to_json(OLD), row_to_json(NEW), NOW());\n  RETURN NEW;\nEND;\n$$ LANGUAGE plpgsql;\n\nCREATE TRIGGER ${3:trg_audit}\nAFTER ${4|INSERT,UPDATE,DELETE|} ON ${5:table}\nFOR EACH ROW\nEXECUTE FUNCTION ${1:audit_trigger}();",
       "insertTextRules": 4,
-      "sortText": "06_OFFSET"
+      "sortText": "00_audit_trigger"
     },
     {
-      "label": "LIMIT OFFSET",
+      "label": "Pivot / Crosstab",
       "kind": 15,
-      "detail": "Paginate results",
-      "documentation": { "value": "Combines LIMIT and OFFSET for pagination. LIMIT controls page size, OFFSET controls starting position." },
-      "insertText": "LIMIT ${1:page_size} OFFSET ${2:start}",
+      "detail": "Pivot query",
+      "documentation": {
+        "value": "Pivot rows to columns using CASE.\n\n```sql\nSELECT product,\n  SUM(CASE WHEN month = 'Jan' THEN revenue END) AS jan,\n  SUM(CASE WHEN month = 'Feb' THEN revenue END) AS feb\nFROM sales\nGROUP BY product;\n```"
+      },
+      "insertText": "SELECT ${1:group_col},\n  SUM(CASE WHEN ${2:pivot_col} = '${3:val1}' THEN ${4:measure} END) AS ${5:alias1},\n  SUM(CASE WHEN ${2:pivot_col} = '${6:val2}' THEN ${4:measure} END) AS ${7:alias2}\nFROM ${8:table}\nGROUP BY ${1:group_col};",
       "insertTextRules": 4,
-      "sortText": "06_LIMIT_OFFSET"
+      "sortText": "00_pivot_/_crosstab"
     },
     {
-      "label": "UNION",
+      "label": "LIKE",
       "kind": 14,
-      "detail": "Combine result sets (deduplicated)",
-      "documentation": { "value": "Combines the result sets of two or more SELECT statements, removing duplicates." },
-      "insertText": "UNION\nSELECT ${1:columns} FROM ${2:table}",
+      "detail": "Pattern matching",
+      "documentation": {
+        "value": "Pattern matching with wildcards.\n\n```sql\nSELECT * FROM users WHERE name LIKE '%john%';\n-- % = any chars, _ = single char\n```"
+      },
+      "insertText": "LIKE '${1:%pattern%}'",
       "insertTextRules": 4,
-      "sortText": "07_UNION"
+      "sortText": "02_like"
     },
     {
-      "label": "UNION ALL",
+      "label": "ILIKE",
       "kind": 14,
-      "detail": "Combine result sets (with duplicates)",
-      "documentation": { "value": "Combines the result sets of two or more SELECT statements, including duplicates. Faster than UNION." },
-      "insertText": "UNION ALL\nSELECT ${1:columns} FROM ${2:table}",
+      "detail": "Case-insensitive LIKE (PostgreSQL)",
+      "documentation": {
+        "value": "Case-insensitive pattern matching (PostgreSQL).\n\n```sql\nSELECT * FROM users WHERE name ILIKE '%john%';\n```"
+      },
+      "insertText": "ILIKE '${1:%pattern%}'",
       "insertTextRules": 4,
-      "sortText": "07_UNION_ALL"
+      "sortText": "02_ilike"
     },
     {
-      "label": "EXISTS",
+      "label": "BETWEEN",
       "kind": 14,
-      "detail": "Check for subquery results",
-      "documentation": { "value": "Returns TRUE if the subquery returns one or more rows. Often used in WHERE clauses." },
-      "insertText": "EXISTS (SELECT 1 FROM ${1:table} WHERE ${2:condition})",
+      "detail": "Range predicate",
+      "documentation": {
+        "value": "Test if value is within a range (inclusive).\n\n```sql\nSELECT * FROM orders WHERE created_at BETWEEN '2024-01-01' AND '2024-12-31';\n```"
+      },
+      "insertText": "BETWEEN ${1:start} AND ${2:end}",
       "insertTextRules": 4,
-      "sortText": "07_EXISTS"
+      "sortText": "02_between"
     },
     {
       "label": "IN",
       "kind": 14,
-      "detail": "Match against a list of values",
-      "documentation": { "value": "Tests whether a value matches any value in a list or subquery." },
+      "detail": "Set membership",
+      "documentation": {
+        "value": "Test if value matches any in a list.\n\n```sql\nSELECT * FROM users WHERE role IN ('admin', 'editor', 'moderator');\n```"
+      },
       "insertText": "IN (${1:values})",
       "insertTextRules": 4,
-      "sortText": "07_IN"
+      "sortText": "02_in"
     },
     {
       "label": "NOT IN",
       "kind": 14,
-      "detail": "Exclude a list of values",
-      "documentation": { "value": "Tests whether a value does not match any value in a list or subquery." },
+      "detail": "Exclude set members",
+      "documentation": {
+        "value": "Test if value is not in a list.\n\n```sql\nSELECT * FROM users WHERE status NOT IN ('banned', 'deleted');\n```"
+      },
       "insertText": "NOT IN (${1:values})",
       "insertTextRules": 4,
-      "sortText": "07_NOT_IN"
+      "sortText": "02_not_in"
     },
     {
-      "label": "BETWEEN",
+      "label": "EXISTS",
       "kind": 14,
-      "detail": "Range filter",
-      "documentation": { "value": "Filters values within a specified inclusive range. Works with numbers, dates, and strings." },
-      "insertText": "BETWEEN ${1:start} AND ${2:end}",
+      "detail": "Existence subquery",
+      "documentation": {
+        "value": "Test if subquery returns any rows.\n\n```sql\nSELECT * FROM users u WHERE EXISTS (\n  SELECT 1 FROM orders o WHERE o.user_id = u.id\n);\n```"
+      },
+      "insertText": "EXISTS (\n\tSELECT 1 FROM ${1:table} WHERE ${2:condition}\n)",
       "insertTextRules": 4,
-      "sortText": "07_BETWEEN"
+      "sortText": "02_exists"
     },
     {
-      "label": "LIKE",
+      "label": "ANY",
       "kind": 14,
-      "detail": "Pattern matching",
-      "documentation": { "value": "Filters rows by pattern matching. Use '%' for any sequence of characters and '_' for a single character." },
-      "insertText": "LIKE '${1:pattern}'",
+      "detail": "Compare to any subquery result",
+      "documentation": {
+        "value": "Compare to any value returned by subquery.\n\n```sql\nSELECT * FROM products WHERE price > ANY (SELECT price FROM discounted);\n```"
+      },
+      "insertText": "ANY (${1:subquery})",
       "insertTextRules": 4,
-      "sortText": "07_LIKE"
+      "sortText": "02_any"
     },
     {
-      "label": "CASE WHEN",
-      "kind": 15,
-      "detail": "Conditional expression",
-      "documentation": { "value": "Evaluates conditions and returns a value when the first condition is met, similar to IF-THEN-ELSE." },
-      "insertText": "CASE\n\tWHEN ${1:condition} THEN ${2:result}\n\tWHEN ${3:condition} THEN ${4:result}\n\tELSE ${5:default}\nEND",
+      "label": "ALL",
+      "kind": 14,
+      "detail": "Compare to all subquery results",
+      "documentation": {
+        "value": "Compare to all values returned by subquery.\n\n```sql\nSELECT * FROM products WHERE price > ALL (SELECT price FROM competitor_prices);\n```"
+      },
+      "insertText": "ALL (${1:subquery})",
       "insertTextRules": 4,
-      "sortText": "07_CASE"
+      "sortText": "02_all"
     },
     {
-      "label": "AS",
+      "label": "IS NULL",
       "kind": 14,
-      "detail": "Alias for column or table",
-      "documentation": { "value": "Creates an alias for a column or table, making the output more readable." },
-      "insertText": "AS ${1:alias}",
+      "detail": "NULL check",
+      "documentation": {
+        "value": "Test for NULL values.\n\n```sql\nSELECT * FROM users WHERE deleted_at IS NULL;\n```"
+      },
+      "insertText": "IS NULL",
       "insertTextRules": 4,
-      "sortText": "08_AS"
+      "sortText": "02_is_null"
     },
     {
-      "label": "WITH (CTE)",
-      "kind": 15,
-      "detail": "Common Table Expression",
-      "documentation": { "value": "Defines a temporary named result set (CTE) that can be referenced within the main query. Improves readability for complex queries." },
-      "insertText": "WITH ${1:cte_name} AS (\n\tSELECT ${2:columns}\n\tFROM ${3:table}\n\tWHERE ${4:condition}\n)\nSELECT * FROM ${1:cte_name}",
+      "label": "IS NOT NULL",
+      "kind": 14,
+      "detail": "NOT NULL check",
+      "documentation": {
+        "value": "Test for non-NULL values.\n\n```sql\nSELECT * FROM users WHERE email IS NOT NULL;\n```"
+      },
+      "insertText": "IS NOT NULL",
       "insertTextRules": 4,
-      "sortText": "00_WITH_CTE"
+      "sortText": "02_is_not_null"
     },
     {
-      "label": "WITH RECURSIVE (CTE)",
-      "kind": 15,
-      "detail": "Recursive Common Table Expression",
-      "documentation": { "value": "Defines a recursive CTE for querying hierarchical or tree-structured data." },
-      "insertText": "WITH RECURSIVE ${1:cte_name} AS (\n\tSELECT ${2:columns}\n\tFROM ${3:table}\n\tWHERE ${4:base_condition}\n\tUNION ALL\n\tSELECT ${5:columns}\n\tFROM ${3:table}\n\tINNER JOIN ${1:cte_name} ON ${6:join_condition}\n)\nSELECT * FROM ${1:cte_name}",
+      "label": "HAVING",
+      "kind": 14,
+      "detail": "Filter grouped results",
+      "documentation": {
+        "value": "Filter groups after GROUP BY.\n\n```sql\nSELECT department, COUNT(*) as cnt\nFROM employees\nGROUP BY department\nHAVING COUNT(*) > 5;\n```"
+      },
+      "insertText": "HAVING ${1:condition}",
       "insertTextRules": 4,
-      "sortText": "00_WITH_RECURSIVE"
+      "sortText": "02_having"
     },
     {
-      "label": "DISTINCT",
+      "label": "CREATE ROLE",
       "kind": 14,
-      "detail": "Remove duplicate rows",
-      "documentation": { "value": "Eliminates duplicate rows from the result set." },
-      "insertText": "DISTINCT",
-      "insertTextRules": 0,
-      "sortText": "08_DISTINCT"
+      "detail": "Create role/user",
+      "documentation": {
+        "value": "Create a database role.\n\n```sql\nCREATE ROLE app_user WITH LOGIN PASSWORD 'secret' VALID UNTIL '2025-12-31';\n```"
+      },
+      "insertText": "CREATE ROLE ${1:name} WITH ${2|LOGIN,NOLOGIN|} PASSWORD '${3:password}';",
+      "insertTextRules": 4,
+      "sortText": "03_create_role"
     },
     {
-      "label": "IS NULL",
+      "label": "ALTER ROLE",
       "kind": 14,
-      "detail": "Check for NULL values",
-      "documentation": { "value": "Tests whether a value is NULL." },
-      "insertText": "IS NULL",
-      "insertTextRules": 0,
-      "sortText": "08_IS_NULL"
+      "detail": "Modify role",
+      "documentation": {
+        "value": "Modify role properties.\n\n```sql\nALTER ROLE app_user SET search_path TO myschema, public;\n```"
+      },
+      "insertText": "ALTER ROLE ${1:name} ${2|SET,SUPERUSER,CREATEDB,CREATEROLE,NOLOGIN|};",
+      "insertTextRules": 4,
+      "sortText": "03_alter_role"
     },
     {
-      "label": "IS NOT NULL",
+      "label": "DROP ROLE",
       "kind": 14,
-      "detail": "Check for non-NULL values",
-      "documentation": { "value": "Tests whether a value is not NULL." },
-      "insertText": "IS NOT NULL",
-      "insertTextRules": 0,
-      "sortText": "08_IS_NOT_NULL"
-    },
-    {
-      "label": "COUNT",
-      "kind": 1,
-      "detail": "Count rows",
-      "documentation": { "value": "Returns the number of rows matching the query. COUNT(*) counts all rows; COUNT(column) counts non-NULL values." },
-      "insertText": "COUNT(${1:*})",
+      "detail": "Drop role",
+      "documentation": {
+        "value": "Remove a database role.\n\n```sql\nDROP ROLE IF EXISTS old_user;\n```"
+      },
+      "insertText": "DROP ROLE IF EXISTS ${1:name};",
       "insertTextRules": 4,
-      "sortText": "10_COUNT"
+      "sortText": "03_drop_role"
     },
     {
-      "label": "SUM",
-      "kind": 1,
-      "detail": "Sum of values",
-      "documentation": { "value": "Returns the total sum of a numeric column." },
-      "insertText": "SUM(${1:column})",
+      "label": "CREATE DATABASE",
+      "kind": 14,
+      "detail": "Create database",
+      "documentation": {
+        "value": "Create new database.\n\n```sql\nCREATE DATABASE mydb\n  OWNER = app_user\n  ENCODING = 'UTF8'\n  LC_COLLATE = 'en_US.UTF-8';\n```"
+      },
+      "insertText": "CREATE DATABASE ${1:name}\n\tOWNER = ${2:owner}\n\tENCODING = '${3:UTF8}';",
       "insertTextRules": 4,
-      "sortText": "10_SUM"
+      "sortText": "03_create_db"
     },
     {
-      "label": "AVG",
-      "kind": 1,
-      "detail": "Average of values",
-      "documentation": { "value": "Returns the average value of a numeric column, ignoring NULLs." },
-      "insertText": "AVG(${1:column})",
+      "label": "DROP DATABASE",
+      "kind": 14,
+      "detail": "Drop database",
+      "documentation": {
+        "value": "Delete a database.\n\n```sql\nDROP DATABASE IF EXISTS old_db;\n```"
+      },
+      "insertText": "DROP DATABASE IF EXISTS ${1:name};",
       "insertTextRules": 4,
-      "sortText": "10_AVG"
+      "sortText": "03_drop_db"
     },
     {
-      "label": "MIN",
-      "kind": 1,
-      "detail": "Minimum value",
-      "documentation": { "value": "Returns the smallest value in a column." },
-      "insertText": "MIN(${1:column})",
+      "label": "SERIAL",
+      "kind": 14,
+      "detail": "Auto-increment integer",
+      "documentation": {
+        "value": "Auto-incrementing integer (PostgreSQL).\n\n```sql\nCREATE TABLE items (\n  id SERIAL PRIMARY KEY\n);\n```"
+      },
+      "insertText": "SERIAL",
       "insertTextRules": 4,
-      "sortText": "10_MIN"
+      "sortText": "04_serial"
     },
     {
-      "label": "MAX",
-      "kind": 1,
-      "detail": "Maximum value",
-      "documentation": { "value": "Returns the largest value in a column." },
-      "insertText": "MAX(${1:column})",
+      "label": "UUID",
+      "kind": 14,
+      "detail": "UUID data type",
+      "documentation": {
+        "value": "UUID column type.\n\n```sql\nCREATE TABLE items (\n  id UUID DEFAULT gen_random_uuid() PRIMARY KEY\n);\n```"
+      },
+      "insertText": "UUID DEFAULT gen_random_uuid()",
       "insertTextRules": 4,
-      "sortText": "10_MAX"
+      "sortText": "04_uuid"
     },
     {
-      "label": "GROUP_CONCAT",
-      "kind": 1,
-      "detail": "Concatenate grouped values",
-      "documentation": { "value": "Concatenates values from multiple rows into a single string, with an optional separator. MySQL-specific; use STRING_AGG in PostgreSQL." },
-      "insertText": "GROUP_CONCAT(${1:column} SEPARATOR '${2:,}')",
+      "label": "JSONB",
+      "kind": 14,
+      "detail": "JSONB data type (PostgreSQL)",
+      "documentation": {
+        "value": "Binary JSON type with indexing support.\n\n```sql\nCREATE TABLE events (\n  id SERIAL PRIMARY KEY,\n  data JSONB NOT NULL DEFAULT '{}'\n);\n```"
+      },
+      "insertText": "JSONB${1: NOT NULL DEFAULT '\\{\\}'}",
       "insertTextRules": 4,
-      "sortText": "10_GROUP_CONCAT"
+      "sortText": "04_jsonb"
     },
     {
-      "label": "CONCAT",
-      "kind": 1,
-      "detail": "Concatenate strings",
-      "documentation": { "value": "Concatenates two or more strings into one." },
-      "insertText": "CONCAT(${1:string1}, ${2:string2})",
+      "label": "TIMESTAMP WITH TIME ZONE",
+      "kind": 14,
+      "detail": "Timestamptz type",
+      "documentation": {
+        "value": "Timestamp with timezone.\n\n```sql\ncreated_at TIMESTAMP WITH TIME ZONE DEFAULT NOW()\n```"
+      },
+      "insertText": "TIMESTAMP WITH TIME ZONE DEFAULT ${1:NOW()}",
       "insertTextRules": 4,
-      "sortText": "11_CONCAT"
+      "sortText": "04_timestamptz"
     },
     {
-      "label": "SUBSTRING",
-      "kind": 1,
-      "detail": "Extract part of a string",
-      "documentation": { "value": "Returns a portion of a string starting at a specified position for a given length." },
-      "insertText": "SUBSTRING(${1:string}, ${2:start}, ${3:length})",
+      "label": "TEXT",
+      "kind": 14,
+      "detail": "Text data type",
+      "documentation": {
+        "value": "Variable-length text.\n\n```sql\nname TEXT NOT NULL\n```"
+      },
+      "insertText": "TEXT",
       "insertTextRules": 4,
-      "sortText": "11_SUBSTRING"
+      "sortText": "04_text"
     },
     {
-      "label": "TRIM",
-      "kind": 1,
-      "detail": "Remove leading/trailing spaces",
-      "documentation": { "value": "Removes leading and trailing whitespace (or specified characters) from a string." },
-      "insertText": "TRIM(${1:string})",
+      "label": "NUMERIC",
+      "kind": 14,
+      "detail": "Exact numeric type",
+      "documentation": {
+        "value": "Exact numeric with precision and scale.\n\n```sql\nprice NUMERIC(10, 2)\n```"
+      },
+      "insertText": "NUMERIC(${1:10}, ${2:2})",
       "insertTextRules": 4,
-      "sortText": "11_TRIM"
+      "sortText": "04_numeric"
     },
     {
-      "label": "UPPER",
-      "kind": 1,
-      "detail": "Convert to uppercase",
-      "documentation": { "value": "Converts all characters in a string to uppercase." },
-      "insertText": "UPPER(${1:string})",
+      "label": "VARCHAR",
+      "kind": 14,
+      "detail": "Variable-length character",
+      "documentation": {
+        "value": "Variable-length string with limit.\n\n```sql\nemail VARCHAR(255) NOT NULL UNIQUE\n```"
+      },
+      "insertText": "VARCHAR(${1:255})",
       "insertTextRules": 4,
-      "sortText": "11_UPPER"
+      "sortText": "04_varchar"
     },
     {
-      "label": "LOWER",
-      "kind": 1,
-      "detail": "Convert to lowercase",
-      "documentation": { "value": "Converts all characters in a string to lowercase." },
-      "insertText": "LOWER(${1:string})",
+      "label": "INTEGER",
+      "kind": 14,
+      "detail": "Integer type",
+      "documentation": {
+        "value": "32-bit integer.\n\n```sql\nage INTEGER CHECK (age >= 0)\n```"
+      },
+      "insertText": "INTEGER",
       "insertTextRules": 4,
-      "sortText": "11_LOWER"
+      "sortText": "04_integer"
     },
     {
-      "label": "LENGTH",
-      "kind": 1,
-      "detail": "String length",
-      "documentation": { "value": "Returns the number of characters in a string." },
-      "insertText": "LENGTH(${1:string})",
+      "label": "DECIMAL",
+      "kind": 14,
+      "detail": "Decimal type",
+      "documentation": {
+        "value": "Exact decimal number.\n\n```sql\namount DECIMAL(12, 4)\n```"
+      },
+      "insertText": "DECIMAL(${1:12}, ${2:2})",
       "insertTextRules": 4,
-      "sortText": "11_LENGTH"
+      "sortText": "04_decimal"
     },
     {
-      "label": "REPLACE",
-      "kind": 1,
-      "detail": "Replace occurrences in a string",
-      "documentation": { "value": "Replaces all occurrences of a substring within a string with a new substring." },
-      "insertText": "REPLACE(${1:string}, ${2:old}, ${3:new})",
+      "label": "PRIMARY KEY",
+      "kind": 14,
+      "detail": "Primary key constraint",
+      "documentation": {
+        "value": "Define primary key.\n\n```sql\nid INTEGER PRIMARY KEY\n-- or table-level:\nPRIMARY KEY (col1, col2)\n```"
+      },
+      "insertText": "PRIMARY KEY${1: (${2:column})}",
       "insertTextRules": 4,
-      "sortText": "11_REPLACE"
+      "sortText": "04_pk"
     },
     {
-      "label": "COALESCE",
-      "kind": 1,
-      "detail": "Return first non-NULL value",
-      "documentation": { "value": "Returns the first non-NULL value from the argument list. Useful for providing default values." },
-      "insertText": "COALESCE(${1:value1}, ${2:value2})",
+      "label": "FOREIGN KEY",
+      "kind": 14,
+      "detail": "Foreign key constraint",
+      "documentation": {
+        "value": "Define foreign key relationship.\n\n```sql\nFOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE\n```"
+      },
+      "insertText": "FOREIGN KEY (${1:column}) REFERENCES ${2:table}(${3:id}) ON DELETE ${4|CASCADE,SET NULL,RESTRICT,NO ACTION|}",
       "insertTextRules": 4,
-      "sortText": "11_COALESCE"
+      "sortText": "04_fk"
     },
     {
-      "label": "IFNULL",
-      "kind": 1,
-      "detail": "Replace NULL with a value",
-      "documentation": { "value": "Returns the first argument if it is not NULL; otherwise returns the second argument. MySQL-specific." },
-      "insertText": "IFNULL(${1:expression}, ${2:default_value})",
+      "label": "UNIQUE",
+      "kind": 14,
+      "detail": "Unique constraint",
+      "documentation": {
+        "value": "Ensure column uniqueness.\n\n```sql\nemail VARCHAR(255) UNIQUE\n-- or table-level:\nUNIQUE (email, tenant_id)\n```"
+      },
+      "insertText": "UNIQUE${1: (${2:columns})}",
       "insertTextRules": 4,
-      "sortText": "11_IFNULL"
+      "sortText": "04_unique"
     },
     {
-      "label": "CAST",
-      "kind": 1,
-      "detail": "Convert data type",
-      "documentation": { "value": "Converts a value from one data type to another." },
-      "insertText": "CAST(${1:expression} AS ${2:data_type})",
+      "label": "CHECK",
+      "kind": 14,
+      "detail": "Check constraint",
+      "documentation": {
+        "value": "Add check constraint.\n\n```sql\nCHECK (price >= 0)\nCHECK (status IN ('active', 'inactive', 'pending'))\n```"
+      },
+      "insertText": "CHECK (${1:condition})",
       "insertTextRules": 4,
-      "sortText": "11_CAST"
-    },
-    {
-      "label": "NOW",
-      "kind": 1,
-      "detail": "Current date and time",
-      "documentation": { "value": "Returns the current date and time as a DATETIME value." },
-      "insertText": "NOW()",
-      "insertTextRules": 0,
-      "sortText": "12_NOW"
+      "sortText": "04_check"
     },
     {
-      "label": "CURRENT_TIMESTAMP",
+      "label": "DEFAULT",
       "kind": 14,
-      "detail": "Current timestamp",
-      "documentation": { "value": "Returns the current date and time. Equivalent to NOW() in most databases." },
-      "insertText": "CURRENT_TIMESTAMP",
-      "insertTextRules": 0,
-      "sortText": "12_CURRENT_TIMESTAMP"
+      "detail": "Default value",
+      "documentation": {
+        "value": "Set column default.\n\n```sql\ncreated_at TIMESTAMP DEFAULT NOW()\nstatus VARCHAR(20) DEFAULT 'pending'\n```"
+      },
+      "insertText": "DEFAULT ${1:value}",
+      "insertTextRules": 4,
+      "sortText": "04_default"
     },
     {
-      "label": "DATE_ADD",
-      "kind": 1,
-      "detail": "Add interval to a date",
-      "documentation": { "value": "Adds a specified time interval to a date." },
-      "insertText": "DATE_ADD(${1:date}, INTERVAL ${2:value} ${3|DAY,MONTH,YEAR,HOUR,MINUTE,SECOND|})",
+      "label": "NOT NULL",
+      "kind": 14,
+      "detail": "Not null constraint",
+      "documentation": {
+        "value": "Prevent NULL values.\n\n```sql\nname VARCHAR(100) NOT NULL\n```"
+      },
+      "insertText": "NOT NULL",
       "insertTextRules": 4,
-      "sortText": "12_DATE_ADD"
+      "sortText": "04_not_null"
     },
     {
-      "label": "DATEDIFF",
-      "kind": 1,
-      "detail": "Difference between dates",
-      "documentation": { "value": "Returns the number of days between two dates." },
-      "insertText": "DATEDIFF(${1:date1}, ${2:date2})",
+      "label": "EXCEPT ALL",
+      "kind": 14,
+      "detail": "Except all (with duplicates)",
+      "documentation": {
+        "value": "Return rows from first query not in second, keeping duplicates.\n\n```sql\nSELECT * FROM table1 EXCEPT ALL SELECT * FROM table2;\n```"
+      },
+      "insertText": "EXCEPT ALL\n${1:SELECT}",
       "insertTextRules": 4,
-      "sortText": "12_DATEDIFF"
+      "sortText": "02_except_all"
     },
     {
-      "label": "EXTRACT",
-      "kind": 1,
-      "detail": "Extract part of a date",
-      "documentation": { "value": "Extracts a specific part (YEAR, MONTH, DAY, HOUR, etc.) from a date or timestamp." },
-      "insertText": "EXTRACT(${1|YEAR,MONTH,DAY,HOUR,MINUTE,SECOND|} FROM ${2:date})",
+      "label": "INTERSECT ALL",
+      "kind": 14,
+      "detail": "Intersect all (with duplicates)",
+      "documentation": {
+        "value": "Return common rows keeping duplicates.\n\n```sql\nSELECT * FROM table1 INTERSECT ALL SELECT * FROM table2;\n```"
+      },
+      "insertText": "INTERSECT ALL\n${1:SELECT}",
       "insertTextRules": 4,
-      "sortText": "12_EXTRACT"
+      "sortText": "02_intersect_all"
     },
     {
-      "label": "DATE_FORMAT",
+      "label": "GENERATE_SERIES",
       "kind": 1,
-      "detail": "Format a date value",
-      "documentation": { "value": "Formats a date value according to the specified format string. MySQL-specific." },
-      "insertText": "DATE_FORMAT(${1:date}, '${2:%Y-%m-%d}')",
+      "detail": "Generate series of values",
+      "documentation": {
+        "value": "Generate a series of values.\n\n```sql\nSELECT generate_series(1, 10);\nSELECT generate_series('2024-01-01'::date, '2024-12-31'::date, '1 month');\n```"
+      },
+      "insertText": "generate_series(${1:start}, ${2:stop}${3:, '${4:1 day}'})",
       "insertTextRules": 4,
-      "sortText": "12_DATE_FORMAT"
+      "sortText": "01_generate_series"
     },
     {
-      "label": "ROW_NUMBER",
+      "label": "UNNEST",
       "kind": 1,
-      "detail": "Assign sequential row numbers",
-      "documentation": { "value": "Assigns a unique sequential integer to each row within a partition, starting at 1." },
-      "insertText": "ROW_NUMBER() OVER (${1:PARTITION BY ${2:column}} ORDER BY ${3:column})",
+      "detail": "Expand array to rows",
+      "documentation": {
+        "value": "Expand an array to a set of rows.\n\n```sql\nSELECT unnest(ARRAY[1,2,3]);\nSELECT unnest('{a,b,c}'::text[]);\n```"
+      },
+      "insertText": "unnest(${1:array})",
       "insertTextRules": 4,
-      "sortText": "13_ROW_NUMBER"
+      "sortText": "01_unnest"
     },
     {
-      "label": "RANK",
+      "label": "ARRAY_LENGTH",
       "kind": 1,
-      "detail": "Assign rank with gaps",
-      "documentation": { "value": "Assigns a rank to each row within a partition. Rows with equal values receive the same rank, leaving gaps." },
-      "insertText": "RANK() OVER (${1:PARTITION BY ${2:column}} ORDER BY ${3:column})",
+      "detail": "Array length",
+      "documentation": {
+        "value": "Get array length.\n\n```sql\nSELECT array_length(ARRAY[1,2,3], 1); -- 3\n```"
+      },
+      "insertText": "array_length(${1:array}, ${2:1})",
       "insertTextRules": 4,
-      "sortText": "13_RANK"
+      "sortText": "01_array_length"
     },
     {
-      "label": "DENSE_RANK",
+      "label": "PERCENTILE_CONT",
       "kind": 1,
-      "detail": "Assign rank without gaps",
-      "documentation": { "value": "Assigns a rank to each row within a partition. Equal values receive the same rank with no gaps in ranking." },
-      "insertText": "DENSE_RANK() OVER (${1:PARTITION BY ${2:column}} ORDER BY ${3:column})",
+      "detail": "Continuous percentile",
+      "documentation": {
+        "value": "Calculate continuous percentile.\n\n```sql\nSELECT percentile_cont(0.5) WITHIN GROUP (ORDER BY salary) AS median\nFROM employees;\n```"
+      },
+      "insertText": "percentile_cont(${1:0.5}) WITHIN GROUP (ORDER BY ${2:column})",
       "insertTextRules": 4,
-      "sortText": "13_DENSE_RANK"
+      "sortText": "01_percentile"
     },
     {
-      "label": "LEAD",
+      "label": "PERCENTILE_DISC",
       "kind": 1,
-      "detail": "Access next row's value",
-      "documentation": { "value": "Returns the value of a column from the next row (or N rows ahead) within a partition." },
-      "insertText": "LEAD(${1:column}, ${2:offset}, ${3:default}) OVER (${4:PARTITION BY ${5:column}} ORDER BY ${6:column})",
+      "detail": "Discrete percentile",
+      "documentation": {
+        "value": "Calculate discrete percentile.\n\n```sql\nSELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY salary) FROM employees;\n```"
+      },
+      "insertText": "percentile_disc(${1:0.5}) WITHIN GROUP (ORDER BY ${2:column})",
       "insertTextRules": 4,
-      "sortText": "13_LEAD"
+      "sortText": "01_percentile_d"
     },
     {
-      "label": "LAG",
+      "label": "STRING_TO_ARRAY",
       "kind": 1,
-      "detail": "Access previous row's value",
-      "documentation": { "value": "Returns the value of a column from the previous row (or N rows behind) within a partition." },
-      "insertText": "LAG(${1:column}, ${2:offset}, ${3:default}) OVER (${4:PARTITION BY ${5:column}} ORDER BY ${6:column})",
+      "detail": "Split string to array",
+      "documentation": {
+        "value": "Split string into array.\n\n```sql\nSELECT string_to_array('a,b,c', ','); -- {a,b,c}\n```"
+      },
+      "insertText": "string_to_array(${1:string}, '${2:,}')",
       "insertTextRules": 4,
-      "sortText": "13_LAG"
+      "sortText": "01_str_to_arr"
     },
     {
-      "label": "NTILE",
+      "label": "ARRAY_TO_STRING",
       "kind": 1,
-      "detail": "Divide rows into buckets",
-      "documentation": { "value": "Distributes rows into a specified number of approximately equal groups." },
-      "insertText": "NTILE(${1:num_buckets}) OVER (ORDER BY ${2:column})",
+      "detail": "Join array to string",
+      "documentation": {
+        "value": "Join array elements into string.\n\n```sql\nSELECT array_to_string(ARRAY[1,2,3], ', '); -- '1, 2, 3'\n```"
+      },
+      "insertText": "array_to_string(${1:array}, '${2:, }')",
       "insertTextRules": 4,
-      "sortText": "13_NTILE"
+      "sortText": "01_arr_to_str"
     },
     {
-      "label": "OVER",
-      "kind": 14,
-      "detail": "Window function clause",
-      "documentation": { "value": "Defines the window (set of rows) for a window function. Can include PARTITION BY and ORDER BY." },
-      "insertText": "OVER (${1:PARTITION BY ${2:column}} ORDER BY ${3:column})",
+      "label": "ENCODE",
+      "kind": 1,
+      "detail": "Encode binary data",
+      "documentation": {
+        "value": "Encode binary data to text.\n\n```sql\nSELECT encode(digest('hello', 'sha256'), 'hex');\n```"
+      },
+      "insertText": "encode(${1:data}, '${2|hex,base64,escape|}')",
       "insertTextRules": 4,
-      "sortText": "13_OVER"
+      "sortText": "01_encode"
     },
     {
-      "label": "PARTITION BY",
-      "kind": 14,
-      "detail": "Partition window rows",
-      "documentation": { "value": "Divides the result set into partitions for window function calculations." },
-      "insertText": "PARTITION BY ${1:column}",
+      "label": "DECODE",
+      "kind": 1,
+      "detail": "Decode text to binary",
+      "documentation": {
+        "value": "Decode text to binary data.\n\n```sql\nSELECT decode('48656C6C6F', 'hex');\n```"
+      },
+      "insertText": "decode(${1:text}, '${2|hex,base64,escape|}')",
       "insertTextRules": 4,
-      "sortText": "13_PARTITION_BY"
+      "sortText": "01_decode"
     },
     {
-      "label": "PRIMARY KEY",
-      "kind": 15,
-      "detail": "Primary key constraint",
-      "documentation": { "value": "Defines a column as the primary key, ensuring uniqueness and creating a clustered index." },
-      "insertText": "PRIMARY KEY (${1:column})",
+      "label": "MD5",
+      "kind": 1,
+      "detail": "MD5 hash",
+      "documentation": {
+        "value": "Calculate MD5 hash.\n\n```sql\nSELECT md5('hello'); -- '5d41402abc4b2a76b9719d911017c592'\n```"
+      },
+      "insertText": "md5(${1:string})",
       "insertTextRules": 4,
-      "sortText": "14_PRIMARY_KEY"
+      "sortText": "01_md5"
     },
     {
-      "label": "FOREIGN KEY",
-      "kind": 15,
-      "detail": "Foreign key constraint",
-      "documentation": { "value": "Defines a foreign key relationship between two tables, enforcing referential integrity." },
-      "insertText": "FOREIGN KEY (${1:column}) REFERENCES ${2:parent_table}(${3:parent_column})",
+      "label": "GEN_RANDOM_UUID",
+      "kind": 1,
+      "detail": "Generate UUID (PostgreSQL)",
+      "documentation": {
+        "value": "Generate random UUID.\n\n```sql\nSELECT gen_random_uuid();\n```"
+      },
+      "insertText": "gen_random_uuid()",
       "insertTextRules": 4,
-      "sortText": "14_FOREIGN_KEY"
+      "sortText": "01_uuid"
     },
     {
-      "label": "CONSTRAINT FOREIGN KEY",
-      "kind": 15,
-      "detail": "Named foreign key constraint",
-      "documentation": { "value": "Defines a named foreign key constraint with optional ON DELETE and ON UPDATE actions." },
-      "insertText": "CONSTRAINT ${1:fk_name} FOREIGN KEY (${2:column})\n\tREFERENCES ${3:parent_table}(${4:parent_column})\n\tON DELETE ${5|CASCADE,SET NULL,RESTRICT,NO ACTION|}\n\tON UPDATE ${6|CASCADE,SET NULL,RESTRICT,NO ACTION|}",
+      "label": "TO_NUMBER",
+      "kind": 1,
+      "detail": "Convert string to number",
+      "documentation": {
+        "value": "Convert text to numeric.\n\n```sql\nSELECT to_number('1,234.56', '9G999D99');\n```"
+      },
+      "insertText": "to_number(${1:text}, '${2:format}')",
       "insertTextRules": 4,
-      "sortText": "14_CONSTRAINT_FK"
+      "sortText": "01_to_number"
     },
     {
-      "label": "UNIQUE",
+      "label": "BIGINT",
       "kind": 14,
-      "detail": "Unique constraint",
-      "documentation": { "value": "Ensures all values in a column or set of columns are unique." },
-      "insertText": "UNIQUE (${1:column})",
+      "detail": "64-bit integer type",
+      "documentation": {
+        "value": "BIGINT: 64-bit signed integer."
+      },
+      "insertText": "BIGINT",
       "insertTextRules": 4,
-      "sortText": "14_UNIQUE"
-    },
-    {
-      "label": "NOT NULL",
-      "kind": 14,
-      "detail": "Not null constraint",
-      "documentation": { "value": "Ensures a column cannot contain NULL values." },
-      "insertText": "NOT NULL",
-      "insertTextRules": 0,
-      "sortText": "14_NOT_NULL"
+      "sortText": "04"
     },
     {
-      "label": "DEFAULT",
+      "label": "BIGSERIAL",
       "kind": 14,
-      "detail": "Default value",
-      "documentation": { "value": "Sets a default value for a column when no value is specified during INSERT." },
-      "insertText": "DEFAULT ${1:value}",
+      "detail": "Auto-increment bigint",
+      "documentation": {
+        "value": "BIGSERIAL: auto-incrementing 64-bit integer."
+      },
+      "insertText": "BIGSERIAL",
       "insertTextRules": 4,
-      "sortText": "14_DEFAULT"
+      "sortText": "04"
     },
     {
-      "label": "CHECK",
+      "label": "SMALLINT",
       "kind": 14,
-      "detail": "Check constraint",
-      "documentation": { "value": "Defines a condition that each row must satisfy." },
-      "insertText": "CHECK (${1:condition})",
+      "detail": "16-bit integer type",
+      "documentation": {
+        "value": "SMALLINT: 16-bit signed integer."
+      },
+      "insertText": "SMALLINT",
       "insertTextRules": 4,
-      "sortText": "14_CHECK"
+      "sortText": "04"
     },
     {
-      "label": "BEGIN TRANSACTION",
-      "kind": 15,
-      "detail": "Start a transaction",
-      "documentation": { "value": "Starts a new database transaction. Changes are not committed until COMMIT is called." },
-      "insertText": "BEGIN TRANSACTION;\n${1:-- statements}\nCOMMIT;",
+      "label": "BOOLEAN",
+      "kind": 14,
+      "detail": "Boolean type",
+      "documentation": {
+        "value": "Boolean: true/false."
+      },
+      "insertText": "BOOLEAN",
       "insertTextRules": 4,
-      "sortText": "15_BEGIN"
+      "sortText": "04"
     },
     {
-      "label": "COMMIT",
+      "label": "REAL",
       "kind": 14,
-      "detail": "Commit a transaction",
-      "documentation": { "value": "Saves all changes made during the current transaction to the database." },
-      "insertText": "COMMIT",
-      "insertTextRules": 0,
-      "sortText": "15_COMMIT"
+      "detail": "Float type",
+      "documentation": {
+        "value": "REAL: 32-bit floating point."
+      },
+      "insertText": "REAL",
+      "insertTextRules": 4,
+      "sortText": "04"
     },
     {
-      "label": "ROLLBACK",
+      "label": "FLOAT",
       "kind": 14,
-      "detail": "Rollback a transaction",
-      "documentation": { "value": "Undoes all changes made during the current transaction." },
-      "insertText": "ROLLBACK",
-      "insertTextRules": 0,
-      "sortText": "15_ROLLBACK"
+      "detail": "Floating point type",
+      "documentation": {
+        "value": "FLOAT: floating point number."
+      },
+      "insertText": "FLOAT",
+      "insertTextRules": 4,
+      "sortText": "04"
     },
     {
-      "label": "SAVEPOINT",
+      "label": "DATE",
       "kind": 14,
-      "detail": "Create a savepoint",
-      "documentation": { "value": "Creates a point within a transaction to which you can later roll back." },
-      "insertText": "SAVEPOINT ${1:savepoint_name}",
+      "detail": "Date type",
+      "documentation": {
+        "value": "DATE: calendar date (year, month, day)."
+      },
+      "insertText": "DATE",
       "insertTextRules": 4,
-      "sortText": "15_SAVEPOINT"
+      "sortText": "04"
     },
     {
-      "label": "TRUNCATE TABLE",
+      "label": "TIMESTAMP",
       "kind": 14,
-      "detail": "Remove all rows from a table",
-      "documentation": { "value": "Removes all rows from a table quickly without logging individual row deletions. Cannot be rolled back in some databases." },
-      "insertText": "TRUNCATE TABLE ${1:table_name}",
+      "detail": "Timestamp type",
+      "documentation": {
+        "value": "TIMESTAMP: date and time without timezone."
+      },
+      "insertText": "TIMESTAMP",
       "insertTextRules": 4,
-      "sortText": "03_TRUNCATE"
+      "sortText": "04"
     },
     {
-      "label": "EXPLAIN",
+      "label": "TIMESTAMPTZ",
       "kind": 14,
-      "detail": "Show query execution plan",
-      "documentation": { "value": "Displays the execution plan for a query, useful for performance optimization." },
-      "insertText": "EXPLAIN ${1:query}",
+      "detail": "Timestamp with timezone",
+      "documentation": {
+        "value": "TIMESTAMPTZ: timestamp with timezone."
+      },
+      "insertText": "TIMESTAMPTZ",
       "insertTextRules": 4,
-      "sortText": "16_EXPLAIN"
+      "sortText": "04"
     },
     {
-      "label": "GRANT",
+      "label": "CHAR",
       "kind": 14,
-      "detail": "Grant privileges",
-      "documentation": { "value": "Grants specific privileges on database objects to users or roles." },
-      "insertText": "GRANT ${1|SELECT,INSERT,UPDATE,DELETE,ALL PRIVILEGES|} ON ${2:table} TO '${3:user}'@'${4:host}'",
+      "detail": "Fixed-length char",
+      "documentation": {
+        "value": "CHAR(n): fixed-length character string."
+      },
+      "insertText": "CHAR()",
       "insertTextRules": 4,
-      "sortText": "16_GRANT"
+      "sortText": "04"
     },
     {
-      "label": "REVOKE",
+      "label": "BYTEA",
       "kind": 14,
-      "detail": "Revoke privileges",
-      "documentation": { "value": "Removes previously granted privileges from a user or role." },
-      "insertText": "REVOKE ${1|SELECT,INSERT,UPDATE,DELETE,ALL PRIVILEGES|} ON ${2:table} FROM '${3:user}'@'${4:host}'",
+      "detail": "Binary data type",
+      "documentation": {
+        "value": "BYTEA: binary data (byte array)."
+      },
+      "insertText": "BYTEA",
       "insertTextRules": 4,
-      "sortText": "16_REVOKE"
+      "sortText": "04"
     },
     {
-      "label": "SUBQUERY",
-      "kind": 27,
-      "detail": "Inline subquery",
-      "documentation": { "value": "A SELECT statement nested inside another statement. Can be used in WHERE, FROM, or SELECT clauses." },
-      "insertText": "(SELECT ${1:column} FROM ${2:table} WHERE ${3:condition})",
+      "label": "JSON",
+      "kind": 14,
+      "detail": "JSON type",
+      "documentation": {
+        "value": "JSON: text-based JSON storage."
+      },
+      "insertText": "JSON",
       "insertTextRules": 4,
-      "sortText": "17_SUBQUERY"
+      "sortText": "04"
     },
     {
-      "label": "CORRELATED SUBQUERY",
-      "kind": 27,
-      "detail": "Correlated subquery",
-      "documentation": { "value": "A subquery that references columns from the outer query. Evaluated once per row of the outer query." },
-      "insertText": "SELECT ${1:columns}\nFROM ${2:table} t1\nWHERE ${3:column} ${4:operator} (\n\tSELECT ${5:aggregate}(${6:column})\n\tFROM ${2:table} t2\n\tWHERE t2.${7:key} = t1.${7:key}\n)",
+      "label": "ARRAY",
+      "kind": 14,
+      "detail": "Array type",
+      "documentation": {
+        "value": "ARRAY: array of any base type.\n\n```sql\ntags TEXT[] DEFAULT '{}'\n```"
+      },
+      "insertText": "ARRAY[]",
       "insertTextRules": 4,
-      "sortText": "17_CORRELATED_SUBQUERY"
+      "sortText": "04"
     },
     {
-      "label": "INDEX",
+      "label": "INET",
       "kind": 14,
-      "detail": "Index keyword",
-      "documentation": { "value": "Used with CREATE or DROP to manage indexes which speed up data retrieval." },
-      "insertText": "INDEX ${1:index_name} (${2:column})",
+      "detail": "IP address type",
+      "documentation": {
+        "value": "INET: IPv4 or IPv6 host address."
+      },
+      "insertText": "INET",
       "insertTextRules": 4,
-      "sortText": "14_INDEX"
+      "sortText": "04"
     },
     {
-      "label": "CREATE PROCEDURE",
-      "kind": 15,
-      "detail": "Create a stored procedure",
-      "documentation": { "value": "Creates a stored procedure that can be called to execute a predefined set of SQL statements." },
-      "insertText": "CREATE PROCEDURE ${1:procedure_name}(${2:parameters})\nBEGIN\n\t${3:-- SQL statements}\nEND",
+      "label": "CIDR",
+      "kind": 14,
+      "detail": "Network address type",
+      "documentation": {
+        "value": "CIDR: IPv4 or IPv6 network address."
+      },
+      "insertText": "CIDR",
       "insertTextRules": 4,
-      "sortText": "02_CREATE_PROCEDURE"
+      "sortText": "04"
     },
     {
-      "label": "CREATE TRIGGER",
-      "kind": 15,
-      "detail": "Create a trigger",
-      "documentation": { "value": "Creates a trigger that automatically executes a set of SQL statements when a specified event occurs on a table." },
-      "insertText": "CREATE TRIGGER ${1:trigger_name}\n${2|BEFORE,AFTER|} ${3|INSERT,UPDATE,DELETE|} ON ${4:table}\nFOR EACH ROW\nBEGIN\n\t${5:-- SQL statements}\nEND",
+      "label": "ENUM",
+      "kind": 14,
+      "detail": "Enum shorthand",
+      "documentation": {
+        "value": "Enum type reference."
+      },
+      "insertText": "ENUM",
       "insertTextRules": 4,
-      "sortText": "02_CREATE_TRIGGER"
+      "sortText": "04"
     },
     {
-      "label": "WINDOW FUNCTION",
-      "kind": 27,
-      "detail": "Window function with OVER clause",
-      "documentation": { "value": "Template for using aggregate or ranking functions as window functions with PARTITION BY and ORDER BY." },
-      "insertText": "${1|ROW_NUMBER,RANK,DENSE_RANK,SUM,AVG,COUNT,MIN,MAX|}() OVER (\n\tPARTITION BY ${2:partition_column}\n\tORDER BY ${3:order_column}\n)",
+      "label": "EXECUTE",
+      "kind": 14,
+      "detail": "Execute prepared statement",
+      "documentation": {
+        "value": "Execute a prepared statement.\n\n```sql\nEXECUTE stmt_name(param1, param2);\n```"
+      },
+      "insertText": "EXECUTE ();",
       "insertTextRules": 4,
-      "sortText": "13_WINDOW_FUNCTION"
+      "sortText": "02"
     }
   ]
 }