('-- Please enter your SQL here --');
+
+ return (
+ <>
+ @monaco-editor/react Demo
+
+
+
+
+ setValue(newValue || '')}
+ options={{
+ minimap: { enabled: false },
+ fontSize: 14
+ }}
+ />
+
+
+ );
+};
+
+export default App;
diff --git a/samples/esm-vite-monaco-editor-react/src/languageSetup.ts b/samples/esm-vite-monaco-editor-react/src/languageSetup.ts
new file mode 100644
index 00000000..bb599c0b
--- /dev/null
+++ b/samples/esm-vite-monaco-editor-react/src/languageSetup.ts
@@ -0,0 +1,49 @@
+import { LanguageIdEnum } from 'monaco-sql-languages';
+/** import contribution file */
+import 'monaco-sql-languages/esm/languages/mysql/mysql.contribution';
+import 'monaco-sql-languages/esm/languages/flink/flink.contribution';
+import 'monaco-sql-languages/esm/languages/spark/spark.contribution';
+import 'monaco-sql-languages/esm/languages/hive/hive.contribution';
+import 'monaco-sql-languages/esm/languages/trino/trino.contribution';
+import 'monaco-sql-languages/esm/languages/pgsql/pgsql.contribution';
+import 'monaco-sql-languages/esm/languages/impala/impala.contribution';
+
+// import 'monaco-sql-languages/esm/all.contributions';
+
+/** import worker files */
+import EditorWorker from 'monaco-editor/esm/vs/editor/editor.worker?worker';
+import FlinkSQLWorker from 'monaco-sql-languages/esm/languages/flink/flink.worker?worker';
+import SparkSQLWorker from 'monaco-sql-languages/esm/languages/spark/spark.worker?worker';
+import HiveSQLWorker from 'monaco-sql-languages/esm/languages/hive/hive.worker?worker';
+import PGSQLWorker from 'monaco-sql-languages/esm/languages/pgsql/pgsql.worker?worker';
+import MySQLWorker from 'monaco-sql-languages/esm/languages/mysql/mysql.worker?worker';
+import TrinoSQLWorker from 'monaco-sql-languages/esm/languages/trino/trino.worker?worker';
+import ImpalaSQLWorker from 'monaco-sql-languages/esm/languages/impala/impala.worker?worker';
+
+/** define MonacoEnvironment.getWorker */
+(globalThis as any).MonacoEnvironment = {
+ getWorker(_: any, label: string) {
+ if (label === LanguageIdEnum.FLINK) {
+ return new FlinkSQLWorker();
+ }
+ if (label === LanguageIdEnum.HIVE) {
+ return new HiveSQLWorker();
+ }
+ if (label === LanguageIdEnum.SPARK) {
+ return new SparkSQLWorker();
+ }
+ if (label === LanguageIdEnum.PG) {
+ return new PGSQLWorker();
+ }
+ if (label === LanguageIdEnum.MYSQL) {
+ return new MySQLWorker();
+ }
+ if (label === LanguageIdEnum.TRINO) {
+ return new TrinoSQLWorker();
+ }
+ if (label === LanguageIdEnum.IMPALA) {
+ return new ImpalaSQLWorker();
+ }
+ return new EditorWorker();
+ }
+};
diff --git a/samples/esm-vite-monaco-editor-react/src/main.tsx b/samples/esm-vite-monaco-editor-react/src/main.tsx
new file mode 100644
index 00000000..482551b4
--- /dev/null
+++ b/samples/esm-vite-monaco-editor-react/src/main.tsx
@@ -0,0 +1,10 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import './languageSetup';
+import App from './App.tsx';
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+
+
+
+);
diff --git a/samples/esm-vite-monaco-editor-react/src/vite-env.d.ts b/samples/esm-vite-monaco-editor-react/src/vite-env.d.ts
new file mode 100644
index 00000000..11f02fe2
--- /dev/null
+++ b/samples/esm-vite-monaco-editor-react/src/vite-env.d.ts
@@ -0,0 +1 @@
+///
diff --git a/samples/esm-vite-monaco-editor-react/tsconfig.json b/samples/esm-vite-monaco-editor-react/tsconfig.json
new file mode 100644
index 00000000..aca48955
--- /dev/null
+++ b/samples/esm-vite-monaco-editor-react/tsconfig.json
@@ -0,0 +1,25 @@
+{
+ "compilerOptions": {
+ "target": "ES2020",
+ "useDefineForClassFields": true,
+ "lib": ["ES2020", "DOM", "DOM.Iterable"],
+ "module": "ESNext",
+ "skipLibCheck": true,
+
+ /* Bundler mode */
+ "moduleResolution": "bundler",
+ "allowImportingTsExtensions": true,
+ "resolveJsonModule": true,
+ "isolatedModules": true,
+ "noEmit": true,
+ "jsx": "react-jsx",
+
+ /* Linting */
+ "strict": true,
+ "noUnusedLocals": true,
+ "noUnusedParameters": true,
+ "noFallthroughCasesInSwitch": true
+ },
+ "include": ["src"],
+ "references": [{ "path": "./tsconfig.node.json" }]
+}
diff --git a/samples/esm-vite-monaco-editor-react/tsconfig.node.json b/samples/esm-vite-monaco-editor-react/tsconfig.node.json
new file mode 100644
index 00000000..eca66688
--- /dev/null
+++ b/samples/esm-vite-monaco-editor-react/tsconfig.node.json
@@ -0,0 +1,10 @@
+{
+ "compilerOptions": {
+ "composite": true,
+ "skipLibCheck": true,
+ "module": "ESNext",
+ "moduleResolution": "bundler",
+ "allowSyntheticDefaultImports": true
+ },
+ "include": ["vite.config.ts"]
+}
diff --git a/samples/esm-vite-monaco-editor-react/vite.config.ts b/samples/esm-vite-monaco-editor-react/vite.config.ts
new file mode 100644
index 00000000..94b332fd
--- /dev/null
+++ b/samples/esm-vite-monaco-editor-react/vite.config.ts
@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite';
+import react from '@vitejs/plugin-react';
+
+// https://vitejs.dev/config/
+export default defineConfig({
+ plugins: [react()]
+});
diff --git a/src/languageFeatures.ts b/src/languageFeatures.ts
index d19a1960..d3877b37 100644
--- a/src/languageFeatures.ts
+++ b/src/languageFeatures.ts
@@ -255,7 +255,9 @@ export class DefinitionAdapter implements languages.Def
startIndex: -1,
endIndex: -1,
startColumn: -1,
- endColumn: -1
+ endColumn: -1,
+ startTokenIndex: -1,
+ endTokenIndex: -1
};
const curEntity = entities?.find((entity: EntityContext) => {
const entityPosition = entity.position;
diff --git a/website/src/extensions/main/index.tsx b/website/src/extensions/main/index.tsx
index 9dbea27d..83682bf3 100644
--- a/website/src/extensions/main/index.tsx
+++ b/website/src/extensions/main/index.tsx
@@ -3,10 +3,8 @@ import {
IEditorTab,
IExtension,
IMoleculeContext,
- TabGroup,
- UniqueId
+ TabGroup
} from '@dtinsight/molecule';
-import lips from '@jcubic/lips';
import * as monaco from 'monaco-editor';
import { vsPlusTheme } from 'monaco-sql-languages/esm/main';
@@ -37,6 +35,8 @@ import TreeVisualizerPanel from '@/components/treeVisualizerPanel';
const problemsService = new ProblemsService();
+// eslint-disable-next-line @typescript-eslint/ban-types
+const disposed: { dispose: Function; [key: string]: any }[] = [];
export const mainExt: IExtension = {
id: 'mainExt',
name: 'mainExt',
@@ -267,6 +267,7 @@ export const mainExt: IExtension = {
)
}
]);
+ molecule.panel.remove('panel.item.output');
molecule.panel.add({
id: 'problem',
@@ -379,7 +380,7 @@ export const mainExt: IExtension = {
);
});
- molecule.editor.onContextMenuClick((item, tabId, groupId) => {
+ molecule.editor.onContextMenuClick((item) => {
switch (item.id) {
case 'parse': {
updateParseTree(molecule, languageService);
@@ -391,8 +392,7 @@ export const mainExt: IExtension = {
}
});
- molecule.editor.onFocus((item) => {
- const groupId = (molecule.editor.getCurrentGroup() || -1) as UniqueId;
+ molecule.editor.onModelMount((_, groupId) => {
const tab = molecule.editor.getCurrentTab();
if (tab?.id && tab.language) {
molecule.editor.setCurrent(tab?.id, groupId);
@@ -406,6 +406,9 @@ export const mainExt: IExtension = {
analyzeProblems({ fileData, molecule, tab, languageService });
debounceUpdateParseTree(molecule, languageService);
});
+ },
+ dispose() {
+ disposed.forEach((d) => d.dispose());
}
};
@@ -413,8 +416,7 @@ const analyzeProblems = debounce((info: any) => {
const { fileData, molecule, tab, languageService } = info || {};
const { value: sql, language } = fileData || {};
- // todo： 一定要 active Tab 才能获取到 language
- if (!language) return;
+ if (!language || !sql) return;
languageService.valid(language.toLocaleLowerCase(), sql).then((res: ParseError[]) => {
const problems = convertMsgToProblemItem(tab, sql, res);
@@ -489,7 +491,13 @@ const updateParseTree = (molecule: IMoleculeContext, languageService: LanguageSe
const language = activeTab?.language?.toLocaleLowerCase();
if (!parseTreePanel || !language || !activeTab) return;
- const sql = activeTab.model?.getValue() || '';
+ // 为了解决 activeTab?.model 可能是 undefined 进行getValue 会出现报错问题
+ let sql = '';
+ try {
+ sql = activeTab?.model?.getValue() || '';
+ } catch (e) {
+ sql = '';
+ }
languageService.getSerializedParseTree(language, sql).then((tree) => {
molecule.panel.update({
diff --git a/website/src/languages/helpers/completionService.ts b/website/src/languages/helpers/completionService.ts
index c060536c..35da2e43 100644
--- a/website/src/languages/helpers/completionService.ts
+++ b/website/src/languages/helpers/completionService.ts
@@ -1,8 +1,33 @@
import { languages } from 'monaco-editor/esm/vs/editor/editor.api';
-import { CompletionService, ICompletionItem } from 'monaco-sql-languages/esm/languageService';
-import { EntityContextType } from 'monaco-sql-languages/esm/main';
+import {
+ CommonEntityContext,
+ CompletionService,
+ ICompletionItem,
+ Suggestions,
+ WordRange
+} from 'monaco-sql-languages/esm/languageService';
+import { EntityContextType, StmtContextType } from 'monaco-sql-languages/esm/main';
-import { getCatalogs, getDataBases, getSchemas, getTables, getViews } from './dbMetaProvider';
+import {
+ getCatalogs,
+ getDataBases,
+ getSchemas,
+ getTables,
+ getViews,
+ getColumns
+} from './dbMetaProvider';
+import {
+ AttrName,
+ ColumnDeclareType,
+ EntityContext,
+ TableDeclareType
+} from 'dt-sql-parser/dist/parser/common/entityCollector';
+
+// Custom completion item interface, extending ICompletionItem to support additional properties
+interface EnhancedCompletionItem extends ICompletionItem {
+ _tableName?: string;
+ _columnText?: string;
+}
const haveCatalogSQLType = (languageId: string) => {
return ['flinksql', 'trinosql'].includes(languageId.toLowerCase());
@@ -12,179 +37,701 @@ const namedSchemaSQLType = (languageId: string) => {
return ['trinosql', 'hivesql', 'sparksql'].includes(languageId);
};
-export const completionService: CompletionService = async function (
- model,
- _position,
- _completionContext,
- suggestions,
- _entities,
- snippets
-) {
- if (!suggestions) {
- return Promise.resolve([]);
+const isWordRangesEndWithWhiteSpace = (wordRanges: WordRange[]) => {
+ return wordRanges.length > 1 && wordRanges.at(-1)?.text === ' ';
+};
+
+// Completion tracker class, used to track already added completion types
+class CompletionTracker {
+ private completionTypes = new Set();
+
+ hasCompletionType(type: string): boolean {
+ return this.completionTypes.has(type);
}
- const languageId = model.getLanguageId();
+
+ markAsCompleted(type: string): void {
+ this.completionTypes.add(type);
+ }
+}
+
+/**
+ * Get database object completion items (catalog, database, table, etc.)
+ */
+const getDatabaseObjectCompletions = async (
+ tracker: CompletionTracker,
+ languageId: string,
+ contextType: EntityContextType | StmtContextType,
+ words: string[]
+): Promise => {
const haveCatalog = haveCatalogSQLType(languageId);
const getDBOrSchema = namedSchemaSQLType(languageId) ? getSchemas : getDataBases;
+ const wordCount = words.length;
+ const result: ICompletionItem[] = [];
- const { keywords, syntax } = suggestions;
+ // Complete Catalog
+ if (wordCount <= 1 && haveCatalog && !tracker.hasCompletionType('catalog')) {
+ if (
+ [EntityContextType.CATALOG, EntityContextType.DATABASE_CREATE].includes(
+ contextType as EntityContextType
+ )
+ ) {
+ result.push(...(await getCatalogs(languageId)));
+ tracker.markAsCompleted('catalog');
+ }
+ }
- const keywordsCompletionItems: ICompletionItem[] = keywords.map((kw) => ({
- label: kw,
- kind: languages.CompletionItemKind.Keyword,
- detail: '关键字',
- sortText: '2' + kw
- }));
+ // Complete Database
+ if (wordCount <= 1 && !tracker.hasCompletionType('database')) {
+ if (
+ [
+ EntityContextType.DATABASE,
+ EntityContextType.TABLE,
+ EntityContextType.TABLE_CREATE,
+ EntityContextType.VIEW,
+ EntityContextType.VIEW_CREATE
+ ].includes(contextType as EntityContextType)
+ ) {
+ result.push(...(await getDBOrSchema(languageId)));
+ tracker.markAsCompleted('database');
+ }
+ }
- let syntaxCompletionItems: ICompletionItem[] = [];
+ // Complete Database under Catalog
+ if (
+ wordCount >= 2 &&
+ wordCount <= 3 &&
+ haveCatalog &&
+ !tracker.hasCompletionType('database_in_catalog')
+ ) {
+ if (
+ [
+ EntityContextType.DATABASE,
+ EntityContextType.TABLE,
+ EntityContextType.TABLE_CREATE,
+ EntityContextType.VIEW,
+ EntityContextType.VIEW_CREATE
+ ].includes(contextType as EntityContextType)
+ ) {
+ result.push(...(await getDBOrSchema(languageId, words[0])));
+ tracker.markAsCompleted('database_in_catalog');
+ }
+ }
- /** 是否已经存在 catalog 补全项 */
- let existCatalogCompletions = false;
- /** 是否已经存在 database 补全项 tmpDatabase */
- let existDatabaseCompletions = false;
- /** 是否已经存在 database 补全项 */
- let existDatabaseInCatCompletions = false;
- /** 是否已经存在 table 补全项 tmpTable */
- let existTableCompletions = false;
- /** 是否已经存在 tableInDb 补全项 （cat.db.table） */
- let existTableInDbCompletions = false;
- /** 是否已经存在 view 补全项 tmpDb */
- let existViewCompletions = false;
- /** 是否已经存在 viewInDb 补全项 */
- let existViewInDbCompletions = false;
+ // Complete Table
+ if (
+ contextType === EntityContextType.TABLE &&
+ wordCount <= 1 &&
+ !tracker.hasCompletionType('table')
+ ) {
+ result.push(...(await getTables(languageId)));
+ tracker.markAsCompleted('table');
+ }
- for (let i = 0; i < syntax.length; i++) {
- const { syntaxContextType, wordRanges } = syntax[i];
+ // Complete Tables under Database
+ if (
+ contextType === EntityContextType.TABLE &&
+ wordCount >= 2 &&
+ wordCount <= 3 &&
+ !tracker.hasCompletionType('table_in_database')
+ ) {
+ result.push(...(await getTables(languageId, undefined, words[0])));
+ tracker.markAsCompleted('table_in_database');
+ }
- // e.g. words -> ['cat', '.', 'database', '.', 'table']
- const words = wordRanges.map((wr) => wr.text);
- const wordCount = words.length;
+ // Complete Tables under Catalog.Database
+ if (
+ contextType === EntityContextType.TABLE &&
+ wordCount >= 4 &&
+ wordCount <= 5 &&
+ haveCatalog &&
+ !tracker.hasCompletionType('table_in_catalog_database')
+ ) {
+ result.push(...(await getTables(languageId, words[0], words[2])));
+ tracker.markAsCompleted('table_in_catalog_database');
+ }
- if (
- syntaxContextType === EntityContextType.CATALOG ||
- syntaxContextType === EntityContextType.DATABASE_CREATE
- ) {
- if (!existCatalogCompletions && wordCount <= 1) {
- syntaxCompletionItems = syntaxCompletionItems.concat(await getCatalogs(languageId));
- existCatalogCompletions = true;
+ // Complete View
+ if (
+ contextType === EntityContextType.VIEW &&
+ wordCount <= 1 &&
+ !tracker.hasCompletionType('view')
+ ) {
+ result.push(...(await getViews(languageId)));
+ tracker.markAsCompleted('view');
+ }
+
+ // Complete Views under Database
+ if (
+ contextType === EntityContextType.VIEW &&
+ wordCount >= 2 &&
+ wordCount <= 3 &&
+ !tracker.hasCompletionType('view_in_database')
+ ) {
+ result.push(...(await getViews(languageId, undefined, words[0])));
+ tracker.markAsCompleted('view_in_database');
+ }
+
+ // Complete Views under Catalog.Database
+ if (
+ contextType === EntityContextType.VIEW &&
+ wordCount >= 4 &&
+ wordCount <= 5 &&
+ !tracker.hasCompletionType('view_in_catalog_database')
+ ) {
+ result.push(...(await getViews(languageId, words[0], words[2])));
+ tracker.markAsCompleted('view_in_catalog_database');
+ }
+
+ return result;
+};
+
+/**
+ * Parse entity text and extract different parts
+ * @param originEntityText - The origin entity text
+ * @returns Parsed entity information
+ * @example
+ * parseEntityText('catalog.database.table') => { catalog: 'catalog', schema: 'database', table: 'table', fullPath: 'catalog.database.table' }
+ * parseEntityText('schema.table') => { catalog: null, schema: 'schema', table: 'table', fullPath: 'schema.table' }
+ * parseEntityText('table') => { catalog: null, schema: null, table: 'table', fullPath: 'table' }
+ */
+const parseEntityText = (originEntityText: string) => {
+ // Use regex to split correctly, keeping backtick-wrapped parts as a whole.
+ // Match: backtick-wrapped content (including internal dots) or regular non-dot characters.
+ // '`xx.xx`' should be treated as a whole word `xx.xx`.
+ const regex = /`[^`]+`|[^.]+/g;
+ const matches = originEntityText.match(regex) || [];
+
+ const words = matches.map((word) => {
+ if (word.startsWith('`') && word.endsWith('`') && word.length >= 3) {
+ const content = word.slice(1, -1);
+ // Only remove backticks when content contains only letters, numbers, and underscores
+ if (/^[a-zA-Z0-9_]+$/.test(content)) {
+ return content;
}
}
+ return word;
+ });
- if (
- syntaxContextType === EntityContextType.DATABASE ||
- syntaxContextType === EntityContextType.TABLE_CREATE ||
- syntaxContextType === EntityContextType.VIEW_CREATE
- ) {
- if (!existCatalogCompletions && haveCatalog && wordCount <= 1) {
- syntaxCompletionItems = syntaxCompletionItems.concat(await getCatalogs(languageId));
- existCatalogCompletions = true;
+ const length = words.length;
+ if (length >= 3) {
+ // catalog.schema.table format
+ return {
+ catalog: words[0],
+ schema: words[1],
+ table: words[2],
+ fullPath: words.join('.'),
+ pureEntityText: words[2]
+ };
+ } else if (length === 2) {
+ // schema.table format
+ return {
+ catalog: null,
+ schema: words[0],
+ table: words[1],
+ fullPath: words.join('.'),
+ pureEntityText: words[1]
+ };
+ } else {
+ // table format
+ return {
+ catalog: null,
+ schema: null,
+ table: words[0],
+ fullPath: words[0],
+ pureEntityText: words[0]
+ };
+ }
+};
+
+/**
+ * Get the pure entity text from the origin entity text
+ * @param originEntityText - The origin entity text
+ * @returns The pure entity text
+ * @example
+ * getPureEntityText('catalog.database.table') => 'table'
+ * getPureEntityText('tb.id') => 'id'
+ * getPureEntityText('`a1`') => 'a1'
+ */
+const getPureEntityText = (originEntityText: string) => {
+ return parseEntityText(originEntityText).pureEntityText;
+};
+
+/**
+ * Remove backticks from text for filter matching
+ * @param text - The text that may contain backticks
+ * @returns The text without backticks
+ */
+const removeBackticks = (text: string): string => {
+ return text.replace(/`/g, '');
+};
+
+/**
+ * Check if two entity paths match, considering schema information
+ * @param createTablePath - The path from CREATE TABLE statement
+ * @param referenceTablePath - The path from table reference
+ * @returns Whether the paths match
+ */
+const isEntityPathMatch = (createTablePath: string, referenceTablePath: string): boolean => {
+ const createInfo = parseEntityText(createTablePath);
+ const refInfo = parseEntityText(referenceTablePath);
+
+ // Exact match
+ if (createInfo.fullPath === refInfo.fullPath) {
+ return true;
+ }
+
+ // If reference has no schema but table name matches
+ if (!refInfo.schema && createInfo.table === refInfo.table) {
+ return true;
+ }
+
+ // If both have schema and table, they must match exactly
+ if (createInfo.schema && refInfo.schema) {
+ return createInfo.schema === refInfo.schema && createInfo.table === refInfo.table;
+ }
+
+ return false;
+};
+
+/**
+ * Process column completions, including regular columns and table.column format
+ */
+const getColumnCompletions = async (
+ languageId: string,
+ wordRanges: WordRange[],
+ entities: EntityContext[] | null
+): Promise => {
+ if (!entities) return [];
+
+ const words = wordRanges.map((wr) => wr.text);
+ const result: ICompletionItem[] = [];
+
+ // All tables defined in the context
+ const allTableDefinitionEntities =
+ (entities?.filter(
+ (entity) => entity.entityContextType === EntityContextType.TABLE_CREATE
+ ) as CommonEntityContext[]) || [];
+
+ // Source tables in the SELECT statement
+ const sourceTables =
+ (entities?.filter(
+ (entity) => entity.entityContextType === EntityContextType.TABLE && entity.isAccessible
+ ) as CommonEntityContext[]) || [];
+
+ // Find table definitions from source tables (regular CREATE TABLE with explicit columns)
+ const sourceTableDefinitionEntities = allTableDefinitionEntities.filter((createTable) =>
+ sourceTables?.some(
+ (sourceTable) =>
+ sourceTable.declareType === TableDeclareType.LITERAL &&
+ isEntityPathMatch(createTable.text, sourceTable.text)
+ )
+ );
+
+ // Find CTAS table definitions from source tables (CREATE TABLE AS SELECT)
+ const ctasTableDefinitionEntities = allTableDefinitionEntities.filter((createTable) =>
+ sourceTables?.some(
+ (sourceTable) =>
+ sourceTable.declareType === TableDeclareType.LITERAL &&
+ // Check if the CREATE TABLE has relatedEntities with QUERY_RESULT (indicates CTAS)
+ createTable.relatedEntities?.some(
+ (relatedEntity) =>
+ relatedEntity.entityContextType === EntityContextType.QUERY_RESULT
+ ) &&
+ isEntityPathMatch(createTable.text, sourceTable.text)
+ )
+ );
+
+ const derivedTableEntities =
+ sourceTables?.filter((entity) => entity.declareType === TableDeclareType.EXPRESSION) || [];
+
+ const tableNameAliasMap: Record = sourceTables.reduce(
+ (acc: Record, tb) => {
+ const alias = tb[AttrName.alias]?.text;
+ if (alias) {
+ acc[tb.text] = alias;
}
+ return acc;
+ },
+ {}
+ );
- if (!existDatabaseCompletions && wordCount <= 1) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getDBOrSchema(languageId)
- );
- existDatabaseCompletions = true;
+ // alias to full table path
+ const aliasToTableMap: Record = Object.fromEntries(
+ Object.entries(tableNameAliasMap).map(([tablePath, alias]) => [alias, tablePath])
+ );
+
+ // When not typing a dot, suggest all source tables and columns (if source tables are directly created in local context)
+ if (wordRanges.length <= 1) {
+ const columnRepeatCountMap = new Map();
+
+ // Get columns from local tables
+ let sourceTableColumns: EnhancedCompletionItem[] = [];
+
+ sourceTables.forEach((sourceTable) => {
+ const realTablePath = sourceTable.text;
+ const displayAlias = tableNameAliasMap[sourceTable.text];
+
+ const tableColumns = [
+ ...getSpecificTableColumns(
+ sourceTableDefinitionEntities,
+ realTablePath,
+ displayAlias
+ ),
+ ...getSpecificDerivedTableColumns(derivedTableEntities, displayAlias),
+ ...getSpecificCTASTableColumns(
+ ctasTableDefinitionEntities,
+ realTablePath,
+ displayAlias
+ )
+ ];
+
+ sourceTableColumns.push(...tableColumns);
+ });
+
+ // Count duplicate column names
+ sourceTableColumns.forEach((col) => {
+ if (col._columnText) {
+ const repeatCount = columnRepeatCountMap.get(col._columnText) || 0;
+ columnRepeatCountMap.set(col._columnText, repeatCount + 1);
+ }
+ });
+
+ // If there are columns with the same name, automatically include table name in inserted text
+ sourceTableColumns = sourceTableColumns.map((column) => {
+ const columnRepeatCount = columnRepeatCountMap.get(column._columnText as string) || 0;
+ const isIncludeInMultipleTables = sourceTables.length > 1;
+ if (columnRepeatCount > 1 && isIncludeInMultipleTables) {
+ const newLabel = `${column._tableName}.${column.label}`;
+ return {
+ ...column,
+ label: newLabel,
+ filterText: removeBackticks(newLabel),
+ insertText: `${column._tableName}.${column._columnText}`
+ };
}
- if (!existDatabaseInCatCompletions && haveCatalog && wordCount >= 2 && wordCount <= 3) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getDBOrSchema(languageId, words[0])
+ return column;
+ });
+
+ result.push(...sourceTableColumns);
+
+ // Also suggest tables when inputting column
+ const tableCompletionItems =
+ sourceTables.length > 1
+ ? sourceTables.map((tb) => {
+ const tableName = tb[AttrName.alias]?.text ?? getPureEntityText(tb.text);
+ return {
+ label: tableName,
+ filterText: removeBackticks(tableName),
+ kind: languages.CompletionItemKind.Field,
+ detail:
+ tb.declareType === TableDeclareType.LITERAL
+ ? 'table'
+ : 'derived table',
+ sortText: '1' + tableName
+ };
+ })
+ : [];
+
+ result.push(...tableCompletionItems);
+ } else if (wordRanges.length === 2 && words[1] === '.') {
+ // Table.column format completion
+ const tbNameOrAlias = words[0];
+
+ let realTablePath = tbNameOrAlias;
+
+ // Check if the input is an alias and resolve to full table path
+ if (aliasToTableMap[tbNameOrAlias]) {
+ realTablePath = aliasToTableMap[tbNameOrAlias];
+ } else {
+ // Try to find matching table in source tables (handles partial schema references)
+ const matchingTable = sourceTables.find((tb) => {
+ const parsedTable = parseEntityText(tb.text);
+ // Check if input matches table name or schema.table pattern
+ return (
+ parsedTable.table === tbNameOrAlias ||
+ parsedTable.fullPath === tbNameOrAlias ||
+ tb.text === tbNameOrAlias
);
- existDatabaseInCatCompletions = true;
+ });
+
+ if (matchingTable) {
+ realTablePath = matchingTable.text;
}
}
- if (syntaxContextType === EntityContextType.TABLE) {
- if (wordCount <= 1) {
- if (!existCatalogCompletions && haveCatalog) {
- const ctas = await getCatalogs(languageId);
- syntaxCompletionItems = syntaxCompletionItems.concat(ctas);
- existCatalogCompletions = true;
- }
-
- if (!existDatabaseCompletions) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getDBOrSchema(languageId)
- );
- existDatabaseCompletions = true;
- }
-
- if (!existTableCompletions) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getTables(languageId)
- );
- existTableCompletions = true;
- }
- } else if (wordCount >= 2 && wordCount <= 3) {
- if (!existDatabaseInCatCompletions && haveCatalog) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getDBOrSchema(languageId, words[0])
- );
- existDatabaseInCatCompletions = true;
- }
-
- if (!existTableInDbCompletions) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getTables(languageId, undefined, words[0])
- );
- existTableInDbCompletions = true;
- }
- } else if (wordCount >= 4 && wordCount <= 5) {
- if (!existTableInDbCompletions) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getTables(languageId, words[0], words[2])
- );
- existTableInDbCompletions = true;
- }
+ // Find columns in local table definitions
+ const displayAlias = aliasToTableMap[tbNameOrAlias] ? tbNameOrAlias : undefined;
+
+ const localTableColumns = [
+ ...getSpecificTableColumns(sourceTableDefinitionEntities, realTablePath, displayAlias),
+ ...getSpecificDerivedTableColumns(derivedTableEntities, displayAlias),
+ ...getSpecificCTASTableColumns(ctasTableDefinitionEntities, realTablePath, displayAlias)
+ ];
+
+ result.push(...localTableColumns);
+
+ // If no local table columns found, try to fetch from cloud
+ if (localTableColumns.length === 0) {
+ // Check if this table is locally created
+ const isLocallyCreatedTable = allTableDefinitionEntities.some((createTable) => {
+ return isEntityPathMatch(createTable.text, realTablePath);
+ });
+
+ const isLiteralTable = sourceTables.some(
+ (tb) =>
+ tb.declareType === TableDeclareType.LITERAL &&
+ (tb.text === realTablePath || isEntityPathMatch(tb.text, realTablePath))
+ );
+
+ // Only fetch from remote if table is not locally created
+ if (!isLocallyCreatedTable && isLiteralTable) {
+ const remoteColumns = await getColumns(languageId, realTablePath);
+ result.push(...remoteColumns);
}
}
+ }
- if (syntaxContextType === EntityContextType.VIEW) {
- if (wordCount <= 1) {
- if (!existCatalogCompletions && haveCatalog) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getCatalogs(languageId)
- );
- existCatalogCompletions = true;
- }
-
- if (!existDatabaseCompletions) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getDBOrSchema(languageId)
- );
- existDatabaseCompletions = true;
- }
-
- if (!existViewCompletions) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getViews(languageId)
- );
- existViewCompletions = true;
- }
- } else if (wordCount >= 2 && wordCount <= 3) {
- if (!existDatabaseInCatCompletions && haveCatalog) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getDBOrSchema(languageId, words[0])
- );
- existDatabaseInCatCompletions = true;
- }
-
- if (!existViewInDbCompletions) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getViews(languageId, undefined, words[0])
- );
- existViewInDbCompletions = true;
- }
- } else if (wordCount >= 4 && wordCount <= 5) {
- if (!existViewInDbCompletions) {
- syntaxCompletionItems = syntaxCompletionItems.concat(
- await getViews(languageId, words[0], words[2])
- );
- existViewInDbCompletions = true;
- }
- }
+ return result;
+};
+
+/**
+ * Get columns from a specific table
+ */
+const getSpecificTableColumns = (
+ sourceTableDefinitionEntities: CommonEntityContext[],
+ realTablePath: string,
+ displayAlias?: string
+): ICompletionItem[] => {
+ return sourceTableDefinitionEntities
+ .filter((tb) => {
+ return (
+ tb.text === realTablePath ||
+ isEntityPathMatch(tb.text, realTablePath) ||
+ getPureEntityText(tb.text) === getPureEntityText(realTablePath)
+ );
+ })
+ .map((tb) => {
+ const tableName = displayAlias || getPureEntityText(tb.text);
+ return (
+ tb.columns?.map((column) => {
+ const columnName =
+ column[AttrName.alias]?.text || getPureEntityText(column.text);
+ const label =
+ columnName +
+ (column[AttrName.colType]?.text
+ ? `(${column[AttrName.colType].text})`
+ : '');
+ return {
+ label,
+ filterText: removeBackticks(label),
+ insertText: columnName,
+ kind: languages.CompletionItemKind.EnumMember,
+ detail: `\`${tableName}\`'s column`,
+ sortText: '0' + tableName + columnName,
+ _columnText: columnName,
+ _tableName: tableName
+ };
+ }) || []
+ );
+ })
+ .flat();
+};
+
+/**
+ * Get columns from a specific derived table (subquery)
+ */
+const getSpecificDerivedTableColumns = (
+ derivedTableEntities: CommonEntityContext[],
+ displayAlias?: string
+): ICompletionItem[] => {
+ return derivedTableEntities
+ .filter((tb) => {
+ return displayAlias ? tb[AttrName.alias]?.text === displayAlias : false;
+ })
+ .map((tb) => {
+ const derivedTableQueryResult = tb.relatedEntities?.find(
+ (entity) => entity.entityContextType === EntityContextType.QUERY_RESULT
+ ) as CommonEntityContext | undefined;
+
+ const tableName =
+ displayAlias || tb[AttrName.alias]?.text || getPureEntityText(tb.text);
+
+ return (
+ derivedTableQueryResult?.columns
+ ?.filter((column) => column.declareType !== ColumnDeclareType.ALL)
+ .map((column) => {
+ const columnName =
+ column[AttrName.alias]?.text || getPureEntityText(column.text);
+ return {
+ label: columnName,
+ filterText: removeBackticks(columnName),
+ insertText: columnName,
+ kind: languages.CompletionItemKind.EnumMember,
+ detail: `\`${tableName}\`'s column`,
+ sortText: '0' + tableName + columnName,
+ _columnText: columnName,
+ _tableName: tableName
+ };
+ }) || []
+ );
+ })
+ .flat();
+};
+
+/**
+ * Get columns from a specific CTAS table
+ */
+const getSpecificCTASTableColumns = (
+ ctasTableEntities: CommonEntityContext[],
+ realTablePath: string,
+ displayAlias?: string
+): ICompletionItem[] => {
+ return ctasTableEntities
+ .filter((tb) => {
+ return (
+ tb.text === realTablePath ||
+ isEntityPathMatch(tb.text, realTablePath) ||
+ getPureEntityText(tb.text) === getPureEntityText(realTablePath)
+ );
+ })
+ .map((tb) => {
+ const ctasQueryResult = tb.relatedEntities?.find(
+ (entity) => entity.entityContextType === EntityContextType.QUERY_RESULT
+ ) as CommonEntityContext | undefined;
+
+ const tableName = displayAlias || getPureEntityText(tb.text);
+
+ return (
+ ctasQueryResult?.columns
+ ?.filter((column) => column.declareType !== ColumnDeclareType.ALL)
+ .map((column) => {
+ const columnName =
+ column[AttrName.alias]?.text || getPureEntityText(column.text);
+ const label =
+ columnName +
+ (column[AttrName.colType]?.text
+ ? `(${column[AttrName.colType].text})`
+ : '');
+ return {
+ label,
+ filterText: removeBackticks(label),
+ insertText: columnName,
+ kind: languages.CompletionItemKind.EnumMember,
+ detail: `\`${tableName}\`'s column`,
+ sortText: '0' + tableName + columnName,
+ _columnText: columnName,
+ _tableName: tableName
+ };
+ }) || []
+ );
+ })
+ .flat();
+};
+
+const getSyntaxCompletionItems = async (
+ languageId: string,
+ syntax: Suggestions['syntax'],
+ entities: EntityContext[] | null
+): Promise => {
+ const tracker = new CompletionTracker();
+ let syntaxCompletionItems: ICompletionItem[] = [];
+
+ for (let i = 0; i < syntax.length; i++) {
+ const { syntaxContextType, wordRanges } = syntax[i];
+ const words = wordRanges.map((wr) => wr.text);
+
+ // If already typed a space, we've left that context
+ if (isWordRangesEndWithWhiteSpace(wordRanges)) continue;
+
+ if (
+ [
+ EntityContextType.CATALOG,
+ EntityContextType.DATABASE,
+ EntityContextType.DATABASE_CREATE,
+ EntityContextType.TABLE,
+ EntityContextType.TABLE_CREATE,
+ EntityContextType.VIEW,
+ EntityContextType.VIEW_CREATE
+ ].includes(syntaxContextType as EntityContextType) &&
+ !tracker.hasCompletionType('db_objects')
+ ) {
+ // Get database object completions (catalog, database, table, etc.)
+ const dbObjectCompletions = await getDatabaseObjectCompletions(
+ tracker,
+ languageId,
+ syntaxContextType,
+ words
+ );
+
+ syntaxCompletionItems = syntaxCompletionItems.concat(dbObjectCompletions);
+ tracker.markAsCompleted('db_objects');
}
+
+ // Add table completions from table entities created in context
+ if (
+ syntaxContextType === EntityContextType.TABLE &&
+ words.length <= 1 &&
+ !tracker.hasCompletionType('created_tables')
+ ) {
+ const createTables =
+ entities
+ ?.filter(
+ (entity) => entity.entityContextType === EntityContextType.TABLE_CREATE
+ )
+ .map((tb) => {
+ const tableName = getPureEntityText(tb.text);
+ return {
+ label: tableName,
+ filterText: removeBackticks(tableName),
+ kind: languages.CompletionItemKind.Field,
+ detail: 'table',
+ sortText: '1' + tableName
+ };
+ }) || [];
+
+ syntaxCompletionItems = syntaxCompletionItems.concat(createTables);
+ tracker.markAsCompleted('created_tables');
+ }
+
+ // Process column completions
+ if (
+ syntaxContextType === EntityContextType.COLUMN &&
+ !tracker.hasCompletionType('columns')
+ ) {
+ const columnCompletions = await getColumnCompletions(languageId, wordRanges, entities);
+ syntaxCompletionItems = syntaxCompletionItems.concat(columnCompletions);
+ tracker.markAsCompleted('columns');
+ }
+ }
+
+ return syntaxCompletionItems;
+};
+
+export const completionService: CompletionService = async function (
+ model,
+ _position,
+ _completionContext,
+ suggestions,
+ entities,
+ snippets
+) {
+ if (!suggestions) {
+ return Promise.resolve([]);
}
+ const languageId = model.getLanguageId();
+
+ const { keywords, syntax } = suggestions;
+ console.log('syntax', syntax);
+ console.log('entities', entities);
+
+ const keywordsCompletionItems: ICompletionItem[] = keywords.map((kw) => ({
+ label: kw,
+ kind: languages.CompletionItemKind.Keyword,
+ detail: 'keyword',
+ sortText: '2' + kw
+ }));
+
+ const syntaxCompletionItems = await getSyntaxCompletionItems(languageId, syntax, entities);
const snippetCompletionItems: ICompletionItem[] =
snippets?.map((item) => ({
diff --git a/website/src/languages/helpers/dbMetaProvider.ts b/website/src/languages/helpers/dbMetaProvider.ts
index 881dfd23..9fd8b599 100644
--- a/website/src/languages/helpers/dbMetaProvider.ts
+++ b/website/src/languages/helpers/dbMetaProvider.ts
@@ -1,4 +1,5 @@
import { languages } from 'monaco-editor/esm/vs/editor/editor.api';
+import { ICompletionItem } from 'monaco-sql-languages/esm/languageService';
const catalogList = ['mock_catalog_1', 'mock_catalog_2', 'mock_catalog_3'];
const schemaList = ['mock_schema_1', 'mock_schema_2', 'mock_schema_3'];
@@ -21,78 +22,136 @@ const prefixLabel = (languageId: string, text: string) => {
};
/**
- * 获取所有的 catalog
+ * Remove backticks from text for filter matching
+ */
+const removeBackticks = (text: string): string => {
+ return text.replace(/`/g, '');
+};
+
+/**
+ * Get all catalogs
*/
export function getCatalogs(languageId: string) {
- const catCompletions = catalogList.map((cat) => ({
- label: prefixLabel(languageId, cat),
- kind: languages.CompletionItemKind.Field,
- detail: 'catalog',
- sortText: '1' + prefixLabel(languageId, cat)
- }));
+ const catCompletions = catalogList.map((cat) => {
+ const label = prefixLabel(languageId, cat);
+ return {
+ label,
+ filterText: removeBackticks(label),
+ kind: languages.CompletionItemKind.Field,
+ detail: 'Remote: catalog',
+ sortText: '1' + label
+ };
+ });
return Promise.resolve(catCompletions);
}
/**
- * 根据catalog 获取 database
+ * Get databases based on catalog
*/
export function getDataBases(languageId: string, catalog?: string) {
const databases = catalog ? databaseList : tmpDatabaseList;
- const databaseCompletions = databases.map((db) => ({
- label: prefixLabel(languageId, db),
- kind: languages.CompletionItemKind.Field,
- detail: 'database',
- sortText: '1' + prefixLabel(languageId, db)
- }));
+ const databaseCompletions = databases.map((db) => {
+ const label = prefixLabel(languageId, db);
+ return {
+ label,
+ filterText: removeBackticks(label),
+ kind: languages.CompletionItemKind.Field,
+ detail: 'Remote: database',
+ sortText: '1' + label
+ };
+ });
return Promise.resolve(databaseCompletions);
}
/**
- * 根据catalog 获取 schema
+ * Get schemas based on catalog
*/
export function getSchemas(languageId: string, catalog?: string) {
const schemas = catalog ? schemaList : tmpSchemaList;
- const schemaCompletions = schemas.map((sc) => ({
- label: prefixLabel(languageId, sc),
- kind: languages.CompletionItemKind.Field,
- detail: 'schema',
- sortText: '1' + prefixLabel(languageId, sc)
- }));
+ const schemaCompletions = schemas.map((sc) => {
+ const label = prefixLabel(languageId, sc);
+ return {
+ label,
+ filterText: removeBackticks(label),
+ kind: languages.CompletionItemKind.Field,
+ detail: 'Remote: schema',
+ sortText: '1' + label
+ };
+ });
return Promise.resolve(schemaCompletions);
}
/**
- * 根据 catalog 和 database 获取 table
+ * Get tables based on catalog and database
*/
export function getTables(languageId: string, catalog?: string, database?: string) {
const tables = catalog && database ? tableList : tmpTableList;
- const tableCompletions = tables.map((tb) => ({
- label: prefixLabel(languageId, tb),
- kind: languages.CompletionItemKind.Field,
- detail: 'table',
- sortText: '1' + prefixLabel(languageId, tb)
- }));
+ const tableCompletions = tables.map((tb) => {
+ const label = prefixLabel(languageId, tb);
+ return {
+ label,
+ filterText: removeBackticks(label),
+ kind: languages.CompletionItemKind.Field,
+ detail: 'Remote: table',
+ sortText: '1' + label
+ };
+ });
return Promise.resolve(tableCompletions);
}
/**
- * 根据 catalog 和 database 获取 view
+ * Get views based on catalog and database
*/
export function getViews(languageId: string, catalog?: string, database?: string) {
const views = catalog && database ? viewList : tmpViewList;
- const viewCompletions = views.map((v) => ({
- label: prefixLabel(languageId, v),
- kind: languages.CompletionItemKind.Field,
- detail: 'view',
- sortText: '1' + prefixLabel(languageId, v)
- }));
+ const viewCompletions = views.map((v) => {
+ const label = prefixLabel(languageId, v);
+ return {
+ label,
+ filterText: removeBackticks(label),
+ kind: languages.CompletionItemKind.Field,
+ detail: 'Remote: view',
+ sortText: '1' + label
+ };
+ });
return Promise.resolve(viewCompletions);
}
+
+/**
+ * Get column information for a specific table
+ * @param languageId Language ID
+ * @param tableName Table name
+ * @returns Column completion items
+ */
+export function getColumns(languageId: string, tableName: string): Promise {
+ // Mock column data, should fetch from cloud in real environment
+ const mockColumns = [
+ { name: 'id', type: 'INT' },
+ { name: 'name', type: 'VARCHAR' },
+ { name: 'age', type: 'INT' },
+ { name: 'created_at', type: 'TIMESTAMP' },
+ { name: 'updated_at', type: 'TIMESTAMP' }
+ ];
+
+ const columnCompletions = mockColumns.map((col) => {
+ const label = `${col.name}(${col.type})`;
+ return {
+ label,
+ filterText: removeBackticks(label),
+ insertText: col.name,
+ kind: languages.CompletionItemKind.EnumMember,
+ detail: `Remote: \`${tableName}\`'s column`,
+ sortText: '0' + tableName + col.name
+ };
+ });
+
+ return Promise.resolve(columnCompletions);
+}
diff --git a/website/src/workbench/problems/clients/paneView/index.tsx b/website/src/workbench/problems/clients/paneView/index.tsx
index be3c7241..77abde64 100644
--- a/website/src/workbench/problems/clients/paneView/index.tsx
+++ b/website/src/workbench/problems/clients/paneView/index.tsx
@@ -16,7 +16,7 @@ const treeLeafSubInfoClassName = getBEMElement(treeLeafClassName, 'subInfo');
function ProblemsPaneView({ problemsService }: { problemsService: any }) {
const localize = useLocale();
- const [data, setData] = useState(() => problemsService.get());
+ const [data, setData] = useState(() => problemsService.get()?.filter(Boolean));
useEffect(() => {
const unsubscribe = problemsService.subscribeData(setData);