dt-sql-parser 4.0.3-beta.0 → 4.0.3-beta.1

package/dist/parser/spark/sparkErrorListener.js

@@ -0,0 +1,63 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { ParseErrorListener } from '../common/parseErrorListener';
+import { SparkSqlParser } from '../../lib/spark/SparkSqlParser';
+export class SparkErrorListener extends ParseErrorListener {
+    constructor(errorListener, preferredRules, locale) {
+        super(errorListener, locale);
+        this.objectNames = new Map([
+            [SparkSqlParser.RULE_namespaceName, 'namespace'],
+            [SparkSqlParser.RULE_namespaceNameCreate, 'namespace'],
+            [SparkSqlParser.RULE_tableName, 'table'],
+            [SparkSqlParser.RULE_tableNameCreate, 'table'],
+            [SparkSqlParser.RULE_viewName, 'view'],
+            [SparkSqlParser.RULE_viewNameCreate, 'view'],
+            [SparkSqlParser.RULE_functionName, 'function'],
+            [SparkSqlParser.RULE_functionNameCreate, 'function'],
+            [SparkSqlParser.RULE_columnName, 'column'],
+            [SparkSqlParser.RULE_columnNameCreate, 'column'],
+        ]);
+        this.preferredRules = preferredRules;
+    }
+    getExpectedText(parser, token) {
+        var _a;
+        let expectedText = '';
+        let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
+        while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
+            currentContext = currentContext.parent;
+        }
+        const core = new CodeCompletionCore(parser);
+        core.preferredRules = this.preferredRules;
+        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        if (candidates.rules.size) {
+            const result = [];
+            // get expectedText as collect rules first
+            for (const candidate of candidates.rules) {
+                const [ruleType] = candidate;
+                const name = this.objectNames.get(ruleType);
+                switch (ruleType) {
+                    case SparkSqlParser.RULE_namespaceName:
+                    case SparkSqlParser.RULE_tableName:
+                    case SparkSqlParser.RULE_viewName:
+                    case SparkSqlParser.RULE_functionName:
+                    case SparkSqlParser.RULE_columnName: {
+                        result.push(`{existing}${name}`);
+                        break;
+                    }
+                    case SparkSqlParser.RULE_namespaceNameCreate:
+                    case SparkSqlParser.RULE_tableNameCreate:
+                    case SparkSqlParser.RULE_functionNameCreate:
+                    case SparkSqlParser.RULE_viewNameCreate:
+                    case SparkSqlParser.RULE_columnNameCreate: {
+                        result.push(`{new}${name}`);
+                        break;
+                    }
+                }
+            }
+            expectedText = result.join('{or}');
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? '{orKeyword}' : '{keyword}';
+        }
+        return expectedText;
+    }
+}

package/dist/parser/trino/index.d.ts

@@ -6,11 +6,14 @@ import { BasicSQL } from '../common/basicSQL';
 import { Suggestions } from '../common/types';
 import { TrinoSqlSplitListener } from './trinoSplitListener';
 import { TrinoEntityCollector } from './trinoEntityCollector';
+import { ErrorListener } from '../common/parseErrorListener';
+import { TrinoErrorListener } from './trinoErrorListener';
 export { TrinoSqlSplitListener, TrinoEntityCollector };
 export declare class TrinoSQL extends BasicSQL<TrinoSqlLexer, ProgramContext, TrinoSqlParser> {
     protected createLexerFromCharStream(charStreams: CharStream): TrinoSqlLexer;
     protected createParserFromTokenStream(tokenStream: CommonTokenStream): TrinoSqlParser;
     protected get splitListener(): TrinoSqlSplitListener;
+    protected createErrorListener(_errorListener: ErrorListener): TrinoErrorListener;
     protected createEntityCollector(input: string, caretTokenIndex?: number): TrinoEntityCollector;
     protected preferredRules: Set<number>;
     protected processCandidates(candidates: CandidatesCollection, allTokens: Token[], caretTokenIndex: number, tokenIndexOffset: number): Suggestions<Token>;

package/dist/parser/trino/index.js

@@ -4,6 +4,7 @@ import { BasicSQL } from '../common/basicSQL';
 import { EntityContextType } from '../common/types';
 import { TrinoSqlSplitListener } from './trinoSplitListener';
 import { TrinoEntityCollector } from './trinoEntityCollector';
+import { TrinoErrorListener } from './trinoErrorListener';
 export { TrinoSqlSplitListener, TrinoEntityCollector };
 export class TrinoSQL extends BasicSQL {
     constructor() {
@@ -32,6 +33,9 @@ export class TrinoSQL extends BasicSQL {
     get splitListener() {
         return new TrinoSqlSplitListener();
     }
+    createErrorListener(_errorListener) {
+        return new TrinoErrorListener(_errorListener, this.preferredRules, this.locale);
+    }
     createEntityCollector(input, caretTokenIndex) {
         return new TrinoEntityCollector(input, caretTokenIndex);
     }

package/dist/parser/trino/trinoEntityCollector.d.ts

@@ -1,5 +1,5 @@
-import type { CatalogNameCreateContext, CatalogRefContext, ColumnNameCreateContext, CreateMaterializedViewContext, CreateSchemaContext, CreateTableAsSelectContext, CreateTableContext, CreateViewContext, InsertIntoContext, SchemaNameCreateContext, SchemaRefContext, SingleStatementContext, TableNameCreateContext, TableRefContext, ViewNameCreateContext, ViewRefContext, QueryStatementContext } from '../../lib/trino/TrinoSqlParser';
 import type { TrinoSqlListener } from '../../lib/trino/TrinoSqlListener';
+import { CatalogNameCreateContext, CatalogRefContext, ColumnNameCreateContext, CreateMaterializedViewContext, CreateSchemaContext, CreateTableAsSelectContext, CreateTableContext, CreateViewContext, InsertIntoContext, QueryStatementContext, SchemaNameCreateContext, SchemaRefContext, SingleStatementContext, TableNameCreateContext, TableRefContext, ViewNameCreateContext, ViewRefContext } from '../../lib/trino/TrinoSqlParser';
 import { EntityCollector } from '../common/entityCollector';
 export declare class TrinoEntityCollector extends EntityCollector implements TrinoSqlListener {
     /** ====== Entity Begin */

package/dist/parser/trino/trinoEntityCollector.js

@@ -1,5 +1,6 @@
+import { AliasedRelationContext, ColumnDefinitionContext, CreateMaterializedViewContext, CreateTableAsSelectContext, CreateTableContext, CreateViewContext, } from '../../lib/trino/TrinoSqlParser';
+import { AttrName, EntityCollector, StmtContextType } from '../common/entityCollector';
 import { EntityContextType } from '../common/types';
-import { StmtContextType, EntityCollector } from '../common/entityCollector';
 export class TrinoEntityCollector extends EntityCollector {
     /** ====== Entity Begin */
     exitCatalogRef(ctx) {
@@ -15,19 +16,47 @@ export class TrinoEntityCollector extends EntityCollector {
         this.pushEntity(ctx, EntityContextType.DATABASE_CREATE);
     }
     exitTableRef(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE);
+        var _a;
+        const needCollectAttr = ((_a = this.getRootStmt()) === null || _a === void 0 ? void 0 : _a.stmtContextType) === StmtContextType.SELECT_STMT;
+        this.pushEntity(ctx, EntityContextType.TABLE, needCollectAttr
+            ? [
+                {
+                    attrName: AttrName.alias,
+                    endContextList: [AliasedRelationContext.name],
+                },
+            ]
+            : undefined);
     }
     exitTableNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.TABLE_CREATE);
+        this.pushEntity(ctx, EntityContextType.TABLE_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateTableContext.name, CreateTableAsSelectContext.name],
+            },
+        ]);
     }
     exitViewRef(ctx) {
         this.pushEntity(ctx, EntityContextType.VIEW);
     }
     exitViewNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.VIEW_CREATE);
+        this.pushEntity(ctx, EntityContextType.VIEW_CREATE, [
+            {
+                attrName: AttrName.comment,
+                endContextList: [CreateMaterializedViewContext.name, CreateViewContext.name],
+            },
+        ]);
     }
     exitColumnNameCreate(ctx) {
-        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE);
+        this.pushEntity(ctx, EntityContextType.COLUMN_CREATE, [
+            {
+                attrName: AttrName.colType,
+                endContextList: [ColumnDefinitionContext.name],
+            },
+            {
+                attrName: AttrName.comment,
+                endContextList: [ColumnDefinitionContext.name],
+            },
+        ]);
     }
     /** ===== Statement begin */
     enterSingleStatement(ctx) {

package/dist/parser/trino/trinoErrorListener.d.ts

@@ -0,0 +1,9 @@
+import { Parser, Token } from 'antlr4ng';
+import { ErrorListener, ParseErrorListener } from '../common/parseErrorListener';
+import { LOCALE_TYPE } from '../common/types';
+export declare class TrinoErrorListener extends ParseErrorListener {
+    private preferredRules;
+    private objectNames;
+    constructor(errorListener: ErrorListener, preferredRules: Set<number>, locale: LOCALE_TYPE);
+    getExpectedText(parser: Parser, token: Token): string;
+}

package/dist/parser/trino/trinoErrorListener.js

@@ -0,0 +1,65 @@
+import { CodeCompletionCore } from 'antlr4-c3';
+import { TrinoSqlParser } from '../../lib/trino/TrinoSqlParser';
+import { ParseErrorListener } from '../common/parseErrorListener';
+export class TrinoErrorListener extends ParseErrorListener {
+    constructor(errorListener, preferredRules, locale) {
+        super(errorListener, locale);
+        this.objectNames = new Map([
+            [TrinoSqlParser.RULE_catalogRef, 'catalog'],
+            [TrinoSqlParser.RULE_catalogNameCreate, 'catalog'],
+            [TrinoSqlParser.RULE_tableRef, 'table'],
+            [TrinoSqlParser.RULE_tableNameCreate, 'table'],
+            [TrinoSqlParser.RULE_viewRef, 'view'],
+            [TrinoSqlParser.RULE_viewNameCreate, 'view'],
+            [TrinoSqlParser.RULE_schemaRef, 'schema'],
+            [TrinoSqlParser.RULE_schemaNameCreate, 'schema'],
+            [TrinoSqlParser.RULE_functionName, 'function'],
+            [TrinoSqlParser.RULE_columnRef, 'column'],
+            [TrinoSqlParser.RULE_columnNameCreate, 'column'],
+        ]);
+        this.preferredRules = preferredRules;
+    }
+    getExpectedText(parser, token) {
+        var _a;
+        let expectedText = '';
+        let currentContext = (_a = parser.context) !== null && _a !== void 0 ? _a : undefined;
+        while (currentContext === null || currentContext === void 0 ? void 0 : currentContext.parent) {
+            currentContext = currentContext.parent;
+        }
+        const core = new CodeCompletionCore(parser);
+        core.preferredRules = this.preferredRules;
+        const candidates = core.collectCandidates(token.tokenIndex, currentContext);
+        if (candidates.rules.size) {
+            const result = [];
+            // get expectedText as collect rules first
+            for (const candidate of candidates.rules) {
+                const [ruleType] = candidate;
+                const name = this.objectNames.get(ruleType);
+                switch (ruleType) {
+                    case TrinoSqlParser.RULE_catalogRef:
+                    case TrinoSqlParser.RULE_schemaRef:
+                    case TrinoSqlParser.RULE_tableRef:
+                    case TrinoSqlParser.RULE_viewRef:
+                    case TrinoSqlParser.RULE_functionName:
+                    case TrinoSqlParser.RULE_columnRef: {
+                        result.push(`{existing}${name}`);
+                        break;
+                    }
+                    case TrinoSqlParser.RULE_catalogNameCreate:
+                    case TrinoSqlParser.RULE_tableNameCreate:
+                    case TrinoSqlParser.RULE_schemaNameCreate:
+                    case TrinoSqlParser.RULE_viewNameCreate:
+                    case TrinoSqlParser.RULE_tableNameCreate: {
+                        result.push(`{new}${name}`);
+                        break;
+                    }
+                }
+            }
+            expectedText = result.join('{or}');
+        }
+        if (candidates.tokens.size) {
+            expectedText += expectedText ? '{orKeyword}' : '{keyword}';
+        }
+        return expectedText;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dt-sql-parser",
-  "version": "4.0.3-beta.0",
+  "version": "4.0.3-beta.1",
   "authors": "DTStack Corporation",
   "description": "SQL Parsers for BigData, built with antlr4",
   "keywords": [
@@ -70,7 +70,7 @@
   },
   "repository": {
     "type": "git",
-		"url": "https://github.com/DTStack/dt-sql-parser.git"
+    "url": "https://github.com/DTStack/dt-sql-parser.git"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"
@@ -89,6 +89,8 @@
     "*": [
       "prettier --write --ignore-unknown"
     ],
-    "*.g4": ["antlr-format -c ./antlr.format.json -v"]
+    "*.g4": [
+      "antlr-format -c ./antlr.format.json -v"
+    ]
   }
 }