feat: move AggregateFunctionsSuggestion to a separate interface, refactor general parser create tests

src/parsing/index.ts

@@ -18,9 +18,7 @@ export interface ParseResult {
         onlyTables?: boolean;
     };
     suggestColumns?: ColumnSuggestion;
-    suggestAggregateFunctions?: {
-        tables: Table[],
-    };
+    suggestAggregateFunctions?: AggregateFunctionsSuggestion;
     suggestAnalyticFunctions?: unknown;
     suggestColRefKeywords?: unknown;
     suggestColumnAliases?: ColumnAliasSuggestion[];
@@ -87,6 +85,10 @@ export type StatementPart =
         qualified: boolean,
     };
 
+export interface AggregateFunctionsSuggestion {
+    tables: Table[],
+}
+
 export interface ColumnSuggestion {
     source?: string;
     tables: Table[];

src/parsing/parsers/clickhouse/jison/structure.json

@@ -6,7 +6,7 @@
     "../../generic/jison/alter/alter_table.jison",
     "../../generic/jison/alter/alter_view.jison",
     "../../generic/jison/create/create_common.jison",
-    "../../generic/jison/create/create_database.jison",
+    "../../generic/jison/create/create_database_or_schema.jison",
     "../../generic/jison/create/create_role.jison",
     "create/create_table.jison",
     "../../generic/jison/create/create_view.jison",

src/parsing/parsers/generic/jison/create/create_common.test.ts

@@ -0,0 +1,14 @@
+import {
+    KeywordSuggestion,
+    parseGenericSql,
+} from '../../../../index';
+import {expect, test} from '@jest/globals';
+
+test('should suggest CREATE', () => {
+    const parseResult = parseGenericSql('', '');
+
+    expect(parseResult.errors).toBeUndefined();
+
+    const suggestion: KeywordSuggestion = { value: 'CREATE', weight: -1 };
+    expect(parseResult.suggestKeywords).toContainEqual(suggestion);
+})

src/parsing/parsers/generic/jison/create/create_database_or_schema.test.ts

@@ -0,0 +1,71 @@
+import {
+    KeywordSuggestion,
+    parseGenericSql, parseGenericSqlWithoutCursor, StatementPart,
+} from '../../../../index';
+import {expect, test} from '@jest/globals';
+
+// TODO: add separate DatabaseOrSchema tests:
+//  - 'something [IF NOT EXITS]'
+//  - 'something IF [NOT EXISTS]'
+//  - 'something IF NOT [exists]'
+//  - 'something [IF NOT EXISTS] something2'
+
+test('should suggest creating DATABASE and SCHEMA', () => {
+    const parseResult = parseGenericSql('CREATE ', '');
+
+    expect(parseResult.errors).toBeUndefined();
+
+    const suggestions: KeywordSuggestion[] = [
+        { value: 'DATABASE', weight: -1 },
+        { value: 'SCHEMA', weight: -1 },
+    ];
+    expect(parseResult.suggestKeywords).toEqual(expect.arrayContaining(suggestions))
+})
+
+// TODO: remove duplicates, because databaseOrSchema should be tested separately
+test('should suggest IF NOT EXISTS for database creation', () => {
+    const parseResult = parseGenericSql('CREATE DATABASE ', '');
+
+    expect(parseResult.errors).toBeUndefined();
+
+    const suggestions: KeywordSuggestion[] = [
+        { value: 'IF NOT EXISTS', weight: -1 },
+    ];
+    expect(parseResult.suggestKeywords).toEqual(expect.arrayContaining(suggestions))
+})
+
+test('should suggest IF NOT EXISTS for schema creation', () => {
+    const parseResult = parseGenericSql('CREATE SCHEMA ', '');
+
+    expect(parseResult.errors).toBeUndefined();
+
+    const suggestions: KeywordSuggestion[] = [
+        { value: 'IF NOT EXISTS', weight: -1 },
+    ];
+    expect(parseResult.suggestKeywords).toEqual(expect.arrayContaining(suggestions))
+})
+
+// TODO: remove duplicates, because databaseOrSchema should be tested separately
+test('should not report errors on full CREATE DATABASE statement', () => {
+    const parseResult = parseGenericSqlWithoutCursor('CREATE DATABASE test_database;');
+    expect(parseResult.errors).toBeUndefined();
+})
+
+test('should not report errors on full CREATE SCHEMA statement and fill locations', () => {
+    const parseResult = parseGenericSqlWithoutCursor('CREATE SCHEMA test_schema;');
+
+    expect(parseResult.errors).toBeUndefined();
+
+    const statementParts: StatementPart[] = [
+        {
+            type: 'statement',
+            location: {
+                first_column: 1,
+                first_line: 1,
+                last_column: 26,
+                last_line: 1
+            },
+        }
+    ];
+    expect(parseResult.locations).toEqual(statementParts);
+})

src/parsing/parsers/generic/jison/create/create_role.test.ts

@@ -0,0 +1,35 @@
+import {
+    KeywordSuggestion,
+    parseGenericSql, parseGenericSqlWithoutCursor, StatementPart,
+} from '../../../../index';
+import {expect, test} from '@jest/globals';
+
+test('should suggest creating ROLE', () => {
+    const parseResult = parseGenericSql('CREATE ', '');
+
+    expect(parseResult.errors).toBeUndefined();
+
+    const suggestions: KeywordSuggestion[] = [
+        { value: 'ROLE', weight: -1 },
+    ];
+    expect(parseResult.suggestKeywords).toEqual(expect.arrayContaining(suggestions))
+})
+
+test('should not report errors on full CREATE ROLE statement and fill locations', () => {
+    const parseResult = parseGenericSqlWithoutCursor('CREATE ROLE test_role;');
+
+    expect(parseResult.errors).toBeUndefined();
+
+    const statementParts: StatementPart[] = [
+        {
+            type: 'statement',
+            location: {
+                first_column: 1,
+                first_line: 1,
+                last_column: 22,
+                last_line: 1
+            },
+        }
+    ];
+    expect(parseResult.locations).toEqual(statementParts);
+})

src/parsing/parsers/generic/jison/create/create_table.test.ts

@@ -0,0 +1,82 @@
+import {
+    KeywordSuggestion,
+    parseGenericSql, parseGenericSqlWithoutCursor, StatementPart,
+} from '../../../../index';
+import {expect, test} from '@jest/globals';
+
+test('should suggest creating TABLE', () => {
+    const parseResult = parseGenericSql('CREATE ', '');
+
+    expect(parseResult.errors).toBeUndefined();
+
+    const suggestions: KeywordSuggestion[] = [
+        { value: 'TABLE', weight: -1 },
+    ];
+    expect(parseResult.suggestKeywords).toEqual(expect.arrayContaining(suggestions))
+})
+
+test('should suggest IF NOT EXISTS', () => {
+    const parseResult = parseGenericSql('CREATE TABLE ', '');
+
+    expect(parseResult.errors).toBeUndefined();
+
+    const suggestions: KeywordSuggestion[] = [
+        { value: 'IF NOT EXISTS', weight: -1 },
+    ];
+    expect(parseResult.suggestKeywords).toEqual(expect.arrayContaining(suggestions))
+})
+
+test('should suggest data types', () => {
+    const parseResult = parseGenericSql('CREATE TABLE food (id ', '');
+
+    // TODO: fix unhandled error
+    // expect(parseResult.errors).toBeUndefined();
+
+    const suggestions: KeywordSuggestion[] = [
+        { value: 'BIGINT', weight: -1 },
+        { value: 'BOOLEAN', weight: -1 },
+        { value: 'CHAR', weight: -1 },
+        { value: 'DECIMAL', weight: -1 },
+        { value: 'DOUBLE', weight: -1 },
+        { value: 'FLOAT', weight: -1 },
+        { value: 'INT', weight: -1 },
+    ];
+    expect(parseResult.suggestKeywords).toEqual(expect.arrayContaining(suggestions))
+})
+
+test('should suggest data types when some types are already written', () => {
+    const parseResult = parseGenericSql('CREATE TABLE food (id INT, age FLOAT, bar ', '');
+
+    // TODO: fix unhandled error
+    // expect(parseResult.errors).toBeUndefined();
+
+    const suggestions: KeywordSuggestion[] = [
+        { value: 'BIGINT', weight: -1 },
+        { value: 'BOOLEAN', weight: -1 },
+        { value: 'CHAR', weight: -1 },
+        { value: 'DECIMAL', weight: -1 },
+        { value: 'DOUBLE', weight: -1 },
+        { value: 'FLOAT', weight: -1 },
+        { value: 'INT', weight: -1 },
+    ];
+    expect(parseResult.suggestKeywords).toEqual(expect.arrayContaining(suggestions))
+})
+
+test('should not report errors on full CREATE TABLE statement', () => {
+    const parseResult = parseGenericSqlWithoutCursor('CREATE TABLE test_table (id INT, age FLOAT);');
+
+    expect(parseResult.errors).toBeUndefined();
+
+    const statementParts: StatementPart[] = [
+        {
+            type: 'statement',
+            location: {
+                first_column: 1,
+                first_line: 1,
+                last_column: 44,
+                last_line: 1
+            },
+        }
+    ];
+    expect(parseResult.locations).toEqual(statementParts);
+})