fix: Fix autocomplete table name issues.

Author: Artmann

packages/server/src/complete/candidates/createTableCandidates.ts

@@ -27,6 +27,23 @@ export function createCatalogDatabaseAndTableCandidates(
   const qualificationLevel = lastToken.split('.').length - 1
 
   const qualifiedEntities = tables.flatMap((table) => {
+    const results: Identifier[] = []
+
+    // When user types without dots (qualificationLevel === 0), always include
+    // a table name suggestion. This allows typing "act" to match "actor" even
+    // if the table has a database (e.g., "squeal.actor").
+    if (qualificationLevel === 0) {
+      const tableIdentifier = new Identifier(
+        lastToken,
+        table.tableName,
+        '',
+        ICONS.TABLE,
+        onFromClause ? 'FROM' : 'OTHERS'
+      )
+      results.push(tableIdentifier)
+    }
+
+    // Also add qualified suggestions (catalog/database) based on qualification level
     let qualificationNeeded = 0
     if (table.catalog) {
       qualificationNeeded++
@@ -37,14 +54,18 @@ export function createCatalogDatabaseAndTableCandidates(
     const qualificationLevelNeeded = qualificationNeeded - qualificationLevel
     switch (qualificationLevelNeeded) {
       case 0: {
-        const tableIdentifier = new Identifier(
-          lastToken,
-          getFullyQualifiedTableName(table),
-          '',
-          ICONS.TABLE,
-          onFromClause ? 'FROM' : 'OTHERS'
-        )
-        return [tableIdentifier]
+        // Only add fully qualified name if we haven't already added just the table name
+        if (qualificationLevel > 0) {
+          const tableIdentifier = new Identifier(
+            lastToken,
+            getFullyQualifiedTableName(table),
+            '',
+            ICONS.TABLE,
+            onFromClause ? 'FROM' : 'OTHERS'
+          )
+          results.push(tableIdentifier)
+        }
+        break
       }
       case 1: {
         const qualifiedDatabaseName =
@@ -60,7 +81,7 @@ export function createCatalogDatabaseAndTableCandidates(
             ICONS.DATABASE,
             onFromClause ? 'FROM' : 'OTHERS'
           )
-          return [databaseIdentifier]
+          results.push(databaseIdentifier)
         }
         break
       }
@@ -73,11 +94,11 @@ export function createCatalogDatabaseAndTableCandidates(
             ICONS.CATALOG,
             onFromClause ? 'FROM' : 'OTHERS'
           )
-          return [catalogIdentifier]
+          results.push(catalogIdentifier)
         }
         break
     }
-    return []
+    return results
   })
 
   return qualifiedEntities

packages/server/src/complete/complete.ts

@@ -350,14 +350,39 @@ class Completer {
     if (!ast.distinct) {
       this.addCandidate(toCompletionItemForKeyword('DISTINCT'))
     }
+
+    // Check if cursor is inside a FROM clause table reference
+    // This handles the case where "SELECT * FROM a" parses successfully
+    // but we still want to suggest tables starting with "a"
+    const parsedFromClause = getFromNodesFromClause(this.sql)
+    const fromNodes = parsedFromClause?.from?.tables || []
+    const subqueryTables = createTablesFromFromNodes(fromNodes)
+    const schemaAndSubqueries = this.schema.tables.concat(subqueryTables)
+
+    for (const tableNode of fromNodes) {
+      if (tableNode.type === 'table') {
+        // Check if the lastToken matches the table name (user is typing the table name)
+        // This means the cursor is ON the table name, not after it (like typing an alias)
+        const tableNameMatches =
+          this.lastToken.length > 0 &&
+          tableNode.table.toLowerCase().startsWith(this.lastToken.toLowerCase())
+
+        if (tableNameMatches && isPosInLocation(tableNode.location, this.pos)) {
+          // Cursor is typing a table name - suggest tables
+          this.addCandidatesForTables(schemaAndSubqueries, true)
+          if (logger.isDebugEnabled())
+            logger.debug(
+              `parse query returns: ${JSON.stringify(this.candidates)}`
+            )
+          return
+        }
+      }
+    }
+
     const columnRef = findColumnAtPosition(ast, this.pos)
     if (!columnRef) {
       this.addJoinCondidates(ast)
     } else {
-      const parsedFromClause = getFromNodesFromClause(this.sql)
-      const fromNodes = parsedFromClause?.from?.tables || []
-      const subqueryTables = createTablesFromFromNodes(fromNodes)
-      const schemaAndSubqueries = this.schema.tables.concat(subqueryTables)
       if (columnRef.table) {
         // We know what table/alias this column belongs to
         // Find the corresponding table and suggest it's columns

packages/server/test/complete.test.ts

@@ -553,13 +553,19 @@ describe('Fully qualified table names', () => {
     expect(result.candidates).toEqual(expect.arrayContaining(expected))
   })
 
-  test('not complete table name when not qualified', () => {
+  test('complete table name when not qualified', () => {
+    // After the fix for GitHub issue #24, typing a partial table name should
+    // match tables even if they require qualification (have database/catalog).
+    // This allows users to type "tabl" and get "table2" and "table3" suggestions.
     const result = complete(
       'SELECT * FROM tabl',
       { line: 0, column: 18 },
       SIMPLE_NESTED_SCHEMA
     )
-    expect(result.candidates.length).toEqual(0)
+    // Should match table2 and table3
+    const labels = result.candidates.map((c) => c.label)
+    expect(labels).toContain('table2')
+    expect(labels).toContain('table3')
   })
   test('complete alias when table', () => {
     const result = complete(

packages/server/test/complete/complete_table.test.ts

@@ -149,4 +149,112 @@ describe('TableName completion', () => {
     const TABLE_KIND = 21
     expect(result.candidates.every((c) => c.kind === TABLE_KIND)).toBe(true)
   })
+
+  test('complete table name with database-qualified tables', () => {
+    const schema = {
+      tables: [
+        {
+          catalog: null,
+          database: 'squeal',
+          tableName: 'actor',
+          columns: [{ columnName: 'actor_id', description: '' }],
+        },
+        {
+          catalog: null,
+          database: 'squeal',
+          tableName: 'actor_info',
+          columns: [{ columnName: 'actor_id', description: '' }],
+        },
+        {
+          catalog: null,
+          database: 'squeal',
+          tableName: 'film',
+          columns: [{ columnName: 'film_id', description: '' }],
+        },
+      ],
+      functions: [],
+    }
+
+    // Test: typing 'a' after FROM should match 'actor' and 'actor_info'
+    const result = complete('SELECT * FROM a', { line: 0, column: 15 }, schema)
+
+    const labels = result.candidates.map((c) => c.label)
+    expect(labels).toContain('actor')
+    expect(labels).toContain('actor_info')
+    expect(labels).not.toContain('film')
+  })
+
+  test('complete table name when SQL parses successfully', () => {
+    // This tests Issue 1 - when the parser treats partial table name as valid
+    const schema = {
+      tables: [
+        { catalog: null, database: null, tableName: 'actor', columns: [] },
+        { catalog: null, database: null, tableName: 'actor_info', columns: [] },
+        { catalog: null, database: null, tableName: 'film', columns: [] },
+      ],
+      functions: [],
+    }
+
+    const result = complete(
+      'SELECT * FROM act',
+      { line: 0, column: 17 },
+      schema
+    )
+
+    const labels = result.candidates.map((c) => c.label)
+    expect(labels).toContain('actor')
+    expect(labels).toContain('actor_info')
+    expect(labels).not.toContain('film')
+  })
+
+  test('complete table name with partial input after typing more characters', () => {
+    const schema = {
+      tables: [
+        {
+          catalog: null,
+          database: 'squeal',
+          tableName: 'actor',
+          columns: [],
+        },
+        {
+          catalog: null,
+          database: 'squeal',
+          tableName: 'actor_info',
+          columns: [],
+        },
+        {
+          catalog: null,
+          database: 'squeal',
+          tableName: 'film',
+          columns: [],
+        },
+        {
+          catalog: null,
+          database: 'squeal',
+          tableName: 'film_actor',
+          columns: [],
+        },
+        {
+          catalog: null,
+          database: 'squeal',
+          tableName: 'customer',
+          columns: [],
+        },
+      ],
+      functions: [],
+    }
+
+    // Test: typing 'fil' should match 'film' and 'film_actor'
+    const result = complete(
+      'SELECT * FROM fil',
+      { line: 0, column: 17 },
+      schema
+    )
+
+    const labels = result.candidates.map((c) => c.label)
+    expect(labels).toContain('film')
+    expect(labels).toContain('film_actor')
+    expect(labels).not.toContain('actor')
+    expect(labels).not.toContain('customer')
+  })
 })