1006 lines
36 KiB
TypeScript
1006 lines
36 KiB
TypeScript
import fs from 'fs';
|
|
import path from 'path';
|
|
import { CaretPosition, EntityContextType } from 'src/parser/common/types';
|
|
import { PostgreSQL } from 'src/parser/postgresql';
|
|
import { commentOtherLine } from 'test/helper';
|
|
|
|
const syntaxSql = fs.readFileSync(
|
|
path.join(__dirname, 'fixtures', 'syntaxSuggestion.sql'),
|
|
'utf-8'
|
|
);
|
|
|
|
describe('Postgre SQL Syntax Suggestion', () => {
|
|
const postgresql = new PostgreSQL();
|
|
|
|
test('Validate Syntax SQL', () => {
|
|
expect(postgresql.validate(syntaxSql).length).not.toBe(0);
|
|
expect(postgresql.validate(syntaxSql).length).not.toBe(0);
|
|
expect(postgresql.validate(syntaxSql).length).not.toBe(0);
|
|
});
|
|
|
|
test('Insert table ', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 3,
|
|
column: 18,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.TABLE
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.', 'tb']);
|
|
});
|
|
|
|
test('Alter table ', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 7,
|
|
column: 15,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.TABLE
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db']);
|
|
});
|
|
|
|
test('Select table', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 5,
|
|
column: 18,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.TABLE
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.']);
|
|
});
|
|
|
|
test('Create table ', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 1,
|
|
column: 18,
|
|
};
|
|
const pos1: CaretPosition = {
|
|
lineNumber: 1,
|
|
column: 31,
|
|
};
|
|
const pos2: CaretPosition = {
|
|
lineNumber: 1,
|
|
column: 67,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const syntaxes1 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos1.lineNumber),
|
|
pos1
|
|
)?.syntax;
|
|
const syntaxes2 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos2.lineNumber),
|
|
pos2
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.TABLE_CREATE
|
|
);
|
|
const suggestion1 = syntaxes1?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN_CREATE
|
|
);
|
|
const suggestion2 = syntaxes2?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
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 ', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 9,
|
|
column: 28,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.VIEW_CREATE
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.', 'v']);
|
|
});
|
|
|
|
test('Drop view ', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 13,
|
|
column: 14,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.VIEW
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.']);
|
|
});
|
|
|
|
test('Alter view ', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 11,
|
|
column: 16,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.VIEW
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db', '.', 'v']);
|
|
});
|
|
|
|
test('Create function ', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 15,
|
|
column: 20,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.FUNCTION_CREATE
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['fn1']);
|
|
});
|
|
|
|
test('Drop function', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 17,
|
|
column: 18,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.FUNCTION
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['fn1']);
|
|
});
|
|
|
|
test('Create database', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 19,
|
|
column: 19,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.DATABASE_CREATE
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db']);
|
|
});
|
|
|
|
test('Drop database', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 21,
|
|
column: 17,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.DATABASE
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db']);
|
|
});
|
|
|
|
test('Alter database', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 23,
|
|
column: 18,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.DATABASE
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['db']);
|
|
});
|
|
|
|
test('Create schema', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 25,
|
|
column: 40,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.DATABASE_CREATE
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['schema_name']);
|
|
});
|
|
|
|
test('Drop schema', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 27,
|
|
column: 26,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.DATABASE
|
|
);
|
|
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual(['sch']);
|
|
});
|
|
|
|
test('Alter schema', () => {
|
|
const pos: CaretPosition = {
|
|
lineNumber: 29,
|
|
column: 18,
|
|
};
|
|
const syntaxes = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.DATABASE
|
|
);
|
|
|
|
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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const syntaxesCreate = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, posCreate.lineNumber),
|
|
posCreate
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestionCreate = syntaxesCreate?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const syntaxesCreate = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, posCreate.lineNumber),
|
|
posCreate
|
|
)?.syntax;
|
|
const syntaxesAction = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, posAction.lineNumber),
|
|
posAction
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestionCreate = syntaxesCreate?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN_CREATE
|
|
);
|
|
const suggestionAction = syntaxesAction?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([
|
|
'table_name',
|
|
'.',
|
|
'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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const syntaxesCreate = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, posCreate.lineNumber),
|
|
posCreate
|
|
)?.syntax;
|
|
const syntaxesAction = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, posAction.lineNumber),
|
|
posAction
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestionCreate = syntaxesCreate?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestionAction = syntaxesAction?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const syntaxes1 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos1.lineNumber),
|
|
pos1
|
|
)?.syntax;
|
|
const syntaxes2 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos2.lineNumber),
|
|
pos2
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion1 = syntaxes1?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion2 = syntaxes2?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN_CREATE
|
|
);
|
|
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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const syntaxes1 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos1.lineNumber),
|
|
pos1
|
|
)?.syntax;
|
|
const syntaxes2 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos2.lineNumber),
|
|
pos2
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion1 = syntaxes1?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion2 = syntaxes2?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN_CREATE
|
|
);
|
|
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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const syntaxes1 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos1.lineNumber),
|
|
pos1
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion1 = syntaxes1?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const syntaxes1 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos1.lineNumber),
|
|
pos1
|
|
)?.syntax;
|
|
const syntaxes2 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos2.lineNumber),
|
|
pos2
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion1 = syntaxes1?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion2 = syntaxes2?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
expect(suggestion).not.toBeUndefined();
|
|
expect(suggestion?.wordRanges.map((token) => token.text)).toEqual([
|
|
'tablename',
|
|
'.',
|
|
'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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const syntaxes1 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos1.lineNumber),
|
|
pos1
|
|
)?.syntax;
|
|
const syntaxes2 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos2.lineNumber),
|
|
pos2
|
|
)?.syntax;
|
|
const syntaxes3 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos3.lineNumber),
|
|
pos3
|
|
)?.syntax;
|
|
const syntaxes4 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos4.lineNumber),
|
|
pos4
|
|
)?.syntax;
|
|
const syntaxes5 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos5.lineNumber),
|
|
pos5
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion1 = syntaxes1?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion2 = syntaxes2?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion3 = syntaxes3?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion4 = syntaxes4?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
|
|
const suggestion5 = syntaxes5?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const syntaxes1 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos1.lineNumber),
|
|
pos1
|
|
)?.syntax;
|
|
const syntaxes2 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos2.lineNumber),
|
|
pos2
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion1 = syntaxes1?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion2 = syntaxes2?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos.lineNumber),
|
|
pos
|
|
)?.syntax;
|
|
const syntaxes1 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos1.lineNumber),
|
|
pos1
|
|
)?.syntax;
|
|
const suggestion = syntaxes?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion1 = syntaxes1?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos1.lineNumber),
|
|
pos1
|
|
)?.syntax;
|
|
const syntaxes2 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos2.lineNumber),
|
|
pos2
|
|
)?.syntax;
|
|
const syntaxes3 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos3.lineNumber),
|
|
pos3
|
|
)?.syntax;
|
|
const suggestion1 = syntaxes1?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion2 = syntaxes2?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.COLUMN
|
|
);
|
|
const suggestion3 = syntaxes3?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.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('TRUNCATE TABLE', () => {
|
|
const pos1: CaretPosition = {
|
|
lineNumber: 79,
|
|
column: 16,
|
|
};
|
|
const pos2: CaretPosition = {
|
|
lineNumber: 81,
|
|
column: 18,
|
|
};
|
|
|
|
const syntaxes1 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos1.lineNumber),
|
|
pos1
|
|
)?.syntax;
|
|
const syntaxes2 = postgresql.getSuggestionAtCaretPosition(
|
|
commentOtherLine(syntaxSql, pos2.lineNumber),
|
|
pos2
|
|
)?.syntax;
|
|
|
|
const suggestion1 = syntaxes1?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.TABLE
|
|
);
|
|
const suggestion2 = syntaxes2?.find(
|
|
(syn) => syn.syntaxContextType === EntityContextType.TABLE
|
|
);
|
|
|
|
expect(suggestion1).not.toBeUndefined();
|
|
expect(suggestion1?.wordRanges.map((token) => token.text)).toEqual([]);
|
|
expect(suggestion2).not.toBeUndefined();
|
|
expect(suggestion2?.wordRanges.map((token) => token.text)).toEqual(['t1']);
|
|
});
|
|
});
|