feat: pgsql collect column name (#216)

* feat(pgsql: collect column name): pgsql: collect column name

* feat(pgsql): repair column name's unit test and sql

* feat(pgsql): pgsql: collect expression's column

* feat(update column's collect of some expression): pgsql: update column's collect of some expression

---------

Co-authored-by: zhaoge <>

test/parser/pgsql/suggestion/fixtures/syntaxSuggestion.sql

@@ -1,10 +1,10 @@
-CREATE TABLE db.  ();
+CREATE TABLE db.s (column_name int) PARTITION BY LIST (column_name);
 
 INSERT INTO db.tb ;
 
 SELECT * FROM db. ;
 
-ALTER TABLE db ;
+ALTER TABLE db ALTER column_name DROP NOT NULL;
 
 CREATE OR REPLACE VIEW db.v;
 
@@ -28,4 +28,50 @@ DROP SCHEMA IF EXISTS sch;
 
 ALTER SCHEMA name RENAME TO new_name;
 
+ALTER FOREIGN TABLE table_name RENAME column_name TO new_column_name;
 
+ALTER MATERIALIZED VIEW view_name RENAME COLUMN column_name TO new_column_name;
+
+ALTER MATERIALIZED VIEW view_name ALTER column_name SET STATISTICS 45;
+
+ALTER PUBLICATION name ADD TABLE table_name ( column_name);
+
+ALTER SEQUENCE name OWNED BY table_name.column_name;
+
+ALTER TABLE db RENAME column_name TO new_column_name;
+
+ANALYZE table_name (column_name);
+
+COMMENT ON COLUMN relation_name.column_name IS NULL;
+
+COPY table_name (col_name, col_name2) FROM 'filename' WITH (FORCE_QUOTE (clumn_name));
+
+CREATE FOREIGN TABLE table_name (column_name int) SERVER server_name;
+
+CREATE FUNCTION name (int) RETURNS TABLE (column_name column_type) LANGUAGE lang_name;
+
+CREATE INDEX ON table_name (column_name) INCLUDE (col_name1, col_name2);
+
+CREATE MATERIALIZED VIEW table_name (col_name);
+
+CREATE STATISTICS ON column_name FROM table_name;
+
+CREATE TRIGGER name AFTER UPDATE OF column_name ON table_name EXECUTE FUNCTION function_name;
+
+GRANT SELECT ( column_name) ON table_name TO role_specification;
+
+INSERT INTO table_name (column_name) DEFAULT VALUES ON CONFLICT (index_column_name) DO UPDATE SET column_name_exp = DEFAULT; 
+
+MERGE INTO wines w USING wine_stock_changes s ON s.winename = w.winename WHEN NOT MATCHED AND stock_delta > 0 THEN INSERT (col_name) VALUES(s.winename, s.stock_delta);
+
+REVOKE SELECT (co_name) ON table_name FROM PUBLIC;
+
+SECURITY LABEL ON COLUMN tablename.columnname IS string_literal;
+
+WITH with_query_name (col_name) AS (SELECT id FROM table_expression) SEARCH DEPTH FIRST BY column_name SET column_name CYCLE col_name SET col_name USING col_name SELECT;
+
+UPDATE tablename SET columnname = a + b, (col1, col2) = (a+3, b+4);
+
+VACUUM tablename (col1, col2);
+
+SELECT * FROM db.tbs GROUP BY (col1, col2) ORDER BY col3;

test/parser/pgsql/suggestion/syntaxSuggestion.test.ts

@@ -52,7 +52,7 @@ describe('Postgre SQL Syntax Suggestion', () => {
         expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db']);
     });
 
-    test('Select table ', () => {
+    test('Select table', () => {
         const pos: CaretPosition = {
             lineNumber: 5,
             column: 18,
@@ -72,18 +72,44 @@ describe('Postgre SQL Syntax Suggestion', () => {
     test('Create table ', () => {
         const pos: CaretPosition = {
             lineNumber: 1,
-            column: 17,
+            column: 18,
+        };
+        const pos1: CaretPosition = {
+            lineNumber: 1,
+            column: 31,
+        };
+        const pos2: CaretPosition = {
+            lineNumber: 1,
+            column: 67,
         };
         const syntaxes = parser.getSuggestionAtCaretPosition(
             commentOtherLine(syntaxSql, pos.lineNumber),
             pos
         )?.syntax;
+        const syntaxes1 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos1.lineNumber),
+            pos1
+        )?.syntax;
+        const syntaxes2 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos2.lineNumber),
+            pos2
+        )?.syntax;
         const suggestion = syntaxes?.find(
             (syn) => syn.syntaxContextType === SyntaxContextType.TABLE_CREATE
         );
+        const suggestion1 = syntaxes1?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion2 = syntaxes2?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
 
         expect(suggestion).not.toBeUndefined();
-        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.']);
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.', 's']);
+        expect(suggestion1).not.toBeUndefined();
+        expect(suggestion1?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+        expect(suggestion2).not.toBeUndefined();
+        expect(suggestion2?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
     });
 
     test('Create view ', () => {
@@ -272,4 +298,668 @@ describe('Postgre SQL Syntax Suggestion', () => {
         expect(suggestion).not.toBeUndefined();
         expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['name']);
     });
+
+    test('Alter Foreign Table With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 31,
+            column: 50,
+        };
+        const posCreate: CaretPosition = {
+            lineNumber: 31,
+            column: 69,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const syntaxesCreate = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, posCreate.lineNumber),
+            posCreate
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestionCreate = syntaxesCreate?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN_CREATE
+        );
+
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+        expect(suggestionCreate).not.toBeUndefined();
+        expect(suggestionCreate?.wordRanges.map((token) => token.text)).toEqual([
+            'new_column_name',
+        ]);
+    });
+
+    test('Alter MATERIALIZED VIEW With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 33,
+            column: 60,
+        };
+        const posCreate: CaretPosition = {
+            lineNumber: 33,
+            column: 79,
+        };
+        const posAction: CaretPosition = {
+            lineNumber: 35,
+            column: 52,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const syntaxesCreate = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, posCreate.lineNumber),
+            posCreate
+        )?.syntax;
+        const syntaxesAction = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, posAction.lineNumber),
+            posAction
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestionCreate = syntaxesCreate?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN_CREATE
+        );
+        const suggestionAction = syntaxesAction?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+        expect(suggestionCreate).not.toBeUndefined();
+        expect(suggestionCreate?.wordRanges.map((token) => token.text)).toEqual([
+            'new_column_name',
+        ]);
+        expect(suggestionAction).not.toBeUndefined();
+        expect(suggestionAction?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+    });
+
+    test('Alter PUBLICATION With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 37,
+            column: 58,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+    });
+
+    test('Alter SEQUENCE With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 39,
+            column: 52,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+    });
+
+    test('Alter Table With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 7,
+            column: 33,
+        };
+        const posCreate: CaretPosition = {
+            lineNumber: 41,
+            column: 34,
+        };
+        const posAction: CaretPosition = {
+            lineNumber: 41,
+            column: 53,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const syntaxesCreate = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, posCreate.lineNumber),
+            posCreate
+        )?.syntax;
+        const syntaxesAction = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, posAction.lineNumber),
+            posAction
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestionCreate = syntaxesCreate?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestionAction = syntaxesAction?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN_CREATE
+        );
+
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+        expect(suggestionCreate).not.toBeUndefined();
+        expect(suggestionCreate?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+        expect(suggestionAction).not.toBeUndefined();
+        expect(suggestionAction?.wordRanges.map((token) => token.text)).toEqual([
+            'new_column_name',
+        ]);
+    });
+
+    test('ANALYZE With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 43,
+            column: 32,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+    });
+
+    test('Comment On With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 45,
+            column: 44,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+    });
+
+    test('Copy With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 47,
+            column: 26,
+        };
+        const pos1: CaretPosition = {
+            lineNumber: 47,
+            column: 37,
+        };
+        const pos2: CaretPosition = {
+            lineNumber: 47,
+            column: 84,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const syntaxes1 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos1.lineNumber),
+            pos1
+        )?.syntax;
+        const syntaxes2 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos2.lineNumber),
+            pos2
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion1 = syntaxes1?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion2 = syntaxes2?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['col_name']);
+        expect(suggestion1).not.toBeUndefined();
+        expect(suggestion1?.wordRanges.map((token) => token.text)).toEqual(['col_name2']);
+        expect(suggestion2).not.toBeUndefined();
+        expect(suggestion2?.wordRanges.map((token) => token.text)).toEqual(['clumn_name']);
+    });
+
+    test('Create Foreign Table With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 49,
+            column: 45,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+    });
+
+    test('Create Function With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 51,
+            column: 54,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+    });
+
+    test('Create Index With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 53,
+            column: 40,
+        };
+        const pos1: CaretPosition = {
+            lineNumber: 53,
+            column: 60,
+        };
+        const pos2: CaretPosition = {
+            lineNumber: 53,
+            column: 71,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const syntaxes1 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos1.lineNumber),
+            pos1
+        )?.syntax;
+        const syntaxes2 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos2.lineNumber),
+            pos2
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion1 = syntaxes1?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion2 = syntaxes2?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+        expect(suggestion1).not.toBeUndefined();
+        expect(suggestion1?.wordRanges.map((token) => token.text)).toEqual(['col_name1']);
+        expect(suggestion2).not.toBeUndefined();
+        expect(suggestion2?.wordRanges.map((token) => token.text)).toEqual(['col_name2']);
+    });
+
+    test('Create MATERIALIZED VIEW With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 55,
+            column: 46,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['col_name']);
+    });
+
+    test('Create STATISTICS With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 57,
+            column: 33,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+    });
+
+    test('Create TRIGGER With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 59,
+            column: 48,
+        };
+        const pos1: CaretPosition = {
+            lineNumber: 59,
+            column: 93,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const syntaxes1 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos1.lineNumber),
+            pos1
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion1 = syntaxes1?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.FUNCTION
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+        expect(suggestion1).not.toBeUndefined();
+        expect(suggestion1?.wordRanges.map((token) => token.text)).toEqual(['function_name']);
+    });
+
+    test('GRANT With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 61,
+            column: 27,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+    });
+
+    test('Insert Into With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 63,
+            column: 36,
+        };
+        const pos1: CaretPosition = {
+            lineNumber: 63,
+            column: 83,
+        };
+        const pos2: CaretPosition = {
+            lineNumber: 63,
+            column: 114,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const syntaxes1 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos1.lineNumber),
+            pos1
+        )?.syntax;
+        const syntaxes2 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos2.lineNumber),
+            pos2
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion1 = syntaxes1?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion2 = syntaxes2?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+        expect(suggestion1).not.toBeUndefined();
+        expect(suggestion1?.wordRanges.map((token) => token.text)).toEqual(['index_column_name']);
+        expect(suggestion2).not.toBeUndefined();
+        expect(suggestion2?.wordRanges.map((token) => token.text)).toEqual(['column_name_exp']);
+    });
+
+    test('Merge With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 65,
+            column: 132,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['col_name']);
+    });
+    test('REVOKE With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 67,
+            column: 23,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['co_name']);
+    });
+
+    test('SECURITY With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 69,
+            column: 46,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['columnname']);
+    });
+
+    test('Select With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 71,
+            column: 31,
+        };
+        const pos1: CaretPosition = {
+            lineNumber: 71,
+            column: 103,
+        };
+        const pos2: CaretPosition = {
+            lineNumber: 71,
+            column: 119,
+        };
+        const pos3: CaretPosition = {
+            lineNumber: 71,
+            column: 134,
+        };
+        const pos4: CaretPosition = {
+            lineNumber: 71,
+            column: 147,
+        };
+        const pos5: CaretPosition = {
+            lineNumber: 71,
+            column: 162,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const syntaxes1 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos1.lineNumber),
+            pos1
+        )?.syntax;
+        const syntaxes2 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos2.lineNumber),
+            pos2
+        )?.syntax;
+        const syntaxes3 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos3.lineNumber),
+            pos3
+        )?.syntax;
+        const syntaxes4 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos4.lineNumber),
+            pos4
+        )?.syntax;
+        const syntaxes5 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos5.lineNumber),
+            pos5
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion1 = syntaxes1?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion2 = syntaxes2?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion3 = syntaxes3?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion4 = syntaxes4?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+
+        const suggestion5 = syntaxes5?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['col_name']);
+        expect(suggestion1).not.toBeUndefined();
+        expect(suggestion1?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+        expect(suggestion2).not.toBeUndefined();
+        expect(suggestion2?.wordRanges.map((token) => token.text)).toEqual(['column_name']);
+        expect(suggestion3).not.toBeUndefined();
+        expect(suggestion3?.wordRanges.map((token) => token.text)).toEqual(['col_name']);
+        expect(suggestion4).not.toBeUndefined();
+        expect(suggestion4?.wordRanges.map((token) => token.text)).toEqual(['col_name']);
+        expect(suggestion5).not.toBeUndefined();
+        expect(suggestion5?.wordRanges.map((token) => token.text)).toEqual(['col_name']);
+    });
+
+    test('Update With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 73,
+            column: 32,
+        };
+        const pos1: CaretPosition = {
+            lineNumber: 73,
+            column: 47,
+        };
+        const pos2: CaretPosition = {
+            lineNumber: 73,
+            column: 53,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const syntaxes1 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos1.lineNumber),
+            pos1
+        )?.syntax;
+        const syntaxes2 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos2.lineNumber),
+            pos2
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion1 = syntaxes1?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion2 = syntaxes2?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['columnname']);
+        expect(suggestion1).not.toBeUndefined();
+        expect(suggestion1?.wordRanges.map((token) => token.text)).toEqual(['col1']);
+        expect(suggestion2).not.toBeUndefined();
+        expect(suggestion2?.wordRanges.map((token) => token.text)).toEqual(['col2']);
+    });
+
+    test('Vacuum With Column', () => {
+        const pos: CaretPosition = {
+            lineNumber: 75,
+            column: 23,
+        };
+        const pos1: CaretPosition = {
+            lineNumber: 75,
+            column: 29,
+        };
+        const syntaxes = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos.lineNumber),
+            pos
+        )?.syntax;
+        const syntaxes1 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos1.lineNumber),
+            pos1
+        )?.syntax;
+        const suggestion = syntaxes?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion1 = syntaxes1?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        expect(suggestion).not.toBeUndefined();
+        expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['col1']);
+        expect(suggestion1).not.toBeUndefined();
+        expect(suggestion1?.wordRanges.map((token) => token.text)).toEqual(['col2']);
+    });
+    test('Select table with expression', () => {
+        const pos1: CaretPosition = {
+            lineNumber: 77,
+            column: 36,
+        };
+        const pos2: CaretPosition = {
+            lineNumber: 77,
+            column: 42,
+        };
+        const pos3: CaretPosition = {
+            lineNumber: 77,
+            column: 57,
+        };
+        const syntaxes1 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos1.lineNumber),
+            pos1
+        )?.syntax;
+        const syntaxes2 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos2.lineNumber),
+            pos2
+        )?.syntax;
+        const syntaxes3 = parser.getSuggestionAtCaretPosition(
+            commentOtherLine(syntaxSql, pos3.lineNumber),
+            pos3
+        )?.syntax;
+        const suggestion1 = syntaxes1?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion2 = syntaxes2?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+        const suggestion3 = syntaxes3?.find(
+            (syn) => syn.syntaxContextType === SyntaxContextType.COLUMN
+        );
+
+        expect(suggestion1).not.toBeUndefined();
+        expect(suggestion1?.wordRanges.map((token) => token.text)).toEqual(['col1']);
+        expect(suggestion2).not.toBeUndefined();
+        expect(suggestion2?.wordRanges.map((token) => token.text)).toEqual(['col2']);
+        expect(suggestion3).not.toBeUndefined();
+        expect(suggestion3?.wordRanges.map((token) => token.text)).toEqual(['col3']);
+    });
 });

test/parser/pgsql/syntax/fixtures/others.sql

@@ -181,7 +181,9 @@ MOVE NEXT FROM cursor_name;
 WITH query_name (id) AS (SELECT id FROM table_expression)
 MERGE INTO ONLY target_table_name * AS target_alias
 USING ONLY source_table_name * ON s.winename = w.winename
-WHEN MATCHED AND s.winename = w.winename THEN UPDATE SET column_name = DEFAULT;
+WHEN MATCHED AND s.winename = w.winename THEN UPDATE SET column_name = stock + 3
+WHEN NOT MATCHED AND stock_delta + stock > 0 THEN INSERT ( column_name) OVERRIDING SYSTEM VALUE VALUES (s.winename)
+WHEN MATCHED THEN DELETE;
 
 -- NOTIFY
 NOTIFY virtual, 'This is the payload';

test/parser/pgsql/syntax/fixtures/select.sql

@@ -13,6 +13,8 @@ WINDOW  w AS (PARTITION BY depname ORDER BY salary DESC)
   FOR UPDATE OF table_name, table_name2 NOWAIT;
 SELECT;
 
+SELECT * FROM db.tbs GROUP BY (col1 > 3, col2 < 8) ORDER BY col3 > 9;
+
 WITH query_name (id) AS (SELECT id FROM table_expression) SELECT DISTINCT random() AS name1 FROM table_expression WHERE name1=name1 GROUP BY id  HAVING sum(len) < interval '5 hours' WINDOW  w AS (PARTITION BY depname ORDER BY salary DESC) INTERSECT DISTINCT (SELECT * FROM others) ORDER BY salary ASC LIMIT ALL OFFSET start FETCH NEXT ROW ONLY FOR NO KEY UPDATE;
 
 WITH query_name (id) AS (SELECT id FROM table_expression) SELECT DISTINCT ON (col1) random() AS name1 FROM table_expression WHERE name1=name1 GROUP BY id  HAVING sum(len) < interval '5 hours' WINDOW  w AS (PARTITION BY depname ORDER BY salary DESC) EXCEPT (SELECT * FROM others) ORDER BY salary USING > NULL FIRST LIMIT 40 OFFSET start FETCH NEXT ROW ONLY FOR SHARE;