@questdb/sql-parser 0.1.0 → 0.1.2

package/dist/index.js

@@ -1418,7 +1418,7 @@ var QuestDBParser = class extends CstParser {
           ALT: () => this.CONSUME(VariableReference)
         },
         { ALT: () => this.CONSUME(StringLiteral) },
-        { ALT: () => this.SUBRULE(this.qualifiedName) }
+        { ALT: () => this.SUBRULE(this.tableName) }
       ]);
       this.OPTION2(() => {
         this.CONSUME(Timestamp);
@@ -1466,47 +1466,95 @@ var QuestDBParser = class extends CstParser {
     this.tableFunctionName = this.RULE("tableFunctionName", () => {
       this.SUBRULE(this.identifier);
     });
+    // ---- Join clause: dispatches to type-specific sub-rules so that each
+    //      join type only offers its own valid postamble tokens.
     this.joinClause = this.RULE("joinClause", () => {
-      this.OPTION(() => {
-        this.OR([
-          { ALT: () => this.CONSUME(Inner) },
-          { ALT: () => this.CONSUME(Left) },
-          { ALT: () => this.CONSUME(Right) },
-          { ALT: () => this.CONSUME(Full) },
-          { ALT: () => this.CONSUME(Cross) },
-          { ALT: () => this.CONSUME(Asof) },
-          { ALT: () => this.CONSUME(Lt) },
-          { ALT: () => this.CONSUME(Splice) },
-          { ALT: () => this.CONSUME(Window) },
-          { ALT: () => this.CONSUME(Prevailing) }
-        ]);
-        this.OPTION1(() => this.CONSUME(Outer));
-      });
+      this.OR([
+        { ALT: () => this.SUBRULE(this.asofLtJoin) },
+        { ALT: () => this.SUBRULE(this.spliceJoin) },
+        { ALT: () => this.SUBRULE(this.windowJoin) },
+        { ALT: () => this.SUBRULE(this.standardJoin) }
+      ]);
+    });
+    // ASOF/LT JOIN: ON + TOLERANCE
+    this.asofLtJoin = this.RULE("asofLtJoin", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(Asof) },
+        { ALT: () => this.CONSUME(Lt) }
+      ]);
       this.CONSUME(Join);
       this.SUBRULE(this.tableRef);
-      this.OPTION2(() => {
+      this.OPTION(() => {
         this.CONSUME(On);
         this.SUBRULE(this.expression);
       });
-      this.OPTION3(() => {
+      this.OPTION1(() => {
         this.CONSUME(Tolerance);
         this.CONSUME(DurationLiteral);
       });
-      this.OPTION4(() => {
+    });
+    // SPLICE JOIN: ON only
+    this.spliceJoin = this.RULE("spliceJoin", () => {
+      this.CONSUME(Splice);
+      this.CONSUME(Join);
+      this.SUBRULE(this.tableRef);
+      this.OPTION(() => {
+        this.CONSUME(On);
+        this.SUBRULE(this.expression);
+      });
+    });
+    // WINDOW/PREVAILING JOIN: ON + RANGE BETWEEN + INCLUDE/EXCLUDE PREVAILING
+    this.windowJoin = this.RULE("windowJoin", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(Window) },
+        { ALT: () => this.CONSUME(Prevailing) }
+      ]);
+      this.CONSUME(Join);
+      this.SUBRULE(this.tableRef);
+      this.OPTION(() => {
+        this.CONSUME(On);
+        this.SUBRULE(this.expression);
+      });
+      this.OPTION1(() => {
         this.CONSUME(Range);
         this.CONSUME(Between);
         this.SUBRULE(this.windowJoinBound);
         this.CONSUME(And);
         this.SUBRULE1(this.windowJoinBound);
       });
-      this.OPTION5(() => {
-        this.OR3([
+      this.OPTION2(() => {
+        this.OR1([
           { ALT: () => this.CONSUME(Include) },
           { ALT: () => this.CONSUME(Exclude) }
         ]);
         this.CONSUME1(Prevailing);
       });
     });
+    // Standard joins: (INNER | LEFT [OUTER] | RIGHT [OUTER] | FULL [OUTER] | CROSS)? JOIN + ON
+    this.standardJoin = this.RULE("standardJoin", () => {
+      this.OPTION(() => {
+        this.OR([
+          {
+            ALT: () => {
+              this.OR1([
+                { ALT: () => this.CONSUME(Left) },
+                { ALT: () => this.CONSUME(Right) },
+                { ALT: () => this.CONSUME(Full) }
+              ]);
+              this.OPTION1(() => this.CONSUME(Outer));
+            }
+          },
+          { ALT: () => this.CONSUME(Inner) },
+          { ALT: () => this.CONSUME(Cross) }
+        ]);
+      });
+      this.CONSUME(Join);
+      this.SUBRULE(this.tableRef);
+      this.OPTION2(() => {
+        this.CONSUME(On);
+        this.SUBRULE(this.expression);
+      });
+    });
     // Window join bound: <number> <timeUnit> PRECEDING/FOLLOWING | CURRENT ROW [PRECEDING/FOLLOWING] | DurationLiteral PRECEDING/FOLLOWING
     this.windowJoinBound = this.RULE("windowJoinBound", () => {
       this.OR([
@@ -1720,7 +1768,7 @@ var QuestDBParser = class extends CstParser {
         ]);
       });
       this.CONSUME(Into);
-      this.SUBRULE(this.stringOrQualifiedName);
+      this.SUBRULE(this.tableNameOrString);
       this.OPTION2(() => this.SUBRULE1(this.batchClause));
       this.OPTION3(() => {
         this.CONSUME(LParen);
@@ -1758,7 +1806,7 @@ var QuestDBParser = class extends CstParser {
     // ==========================================================================
     this.updateStatement = this.RULE("updateStatement", () => {
       this.CONSUME(Update);
-      this.SUBRULE(this.qualifiedName);
+      this.SUBRULE(this.tableName);
       this.OPTION2(() => this.SUBRULE(this.identifier));
       this.CONSUME(Set2);
       this.SUBRULE(this.setClause);
@@ -1909,7 +1957,7 @@ var QuestDBParser = class extends CstParser {
           ALT: () => {
             this.CONSUME2(LParen);
             this.CONSUME(Like);
-            this.SUBRULE2(this.qualifiedName);
+            this.SUBRULE(this.tableName);
             this.CONSUME2(RParen);
           }
         }
@@ -2477,10 +2525,7 @@ var QuestDBParser = class extends CstParser {
     });
     this.alterTableStatement = this.RULE("alterTableStatement", () => {
       this.CONSUME(Table);
-      this.OR([
-        { ALT: () => this.SUBRULE(this.qualifiedName) },
-        { ALT: () => this.CONSUME(StringLiteral) }
-      ]);
+      this.SUBRULE(this.tableNameOrString);
       this.SUBRULE(this.alterTableAction);
     });
     this.alterTableAction = this.RULE("alterTableAction", () => {
@@ -2511,10 +2556,10 @@ var QuestDBParser = class extends CstParser {
               {
                 ALT: () => {
                   this.CONSUME1(Column);
-                  this.SUBRULE(this.identifier);
+                  this.SUBRULE(this.columnRef);
                   this.MANY1(() => {
                     this.CONSUME1(Comma);
-                    this.SUBRULE1(this.identifier);
+                    this.SUBRULE1(this.columnRef);
                   });
                 }
               },
@@ -2550,7 +2595,7 @@ var QuestDBParser = class extends CstParser {
           ALT: () => {
             this.CONSUME(Rename);
             this.CONSUME2(Column);
-            this.SUBRULE2(this.identifier);
+            this.SUBRULE2(this.columnRef);
             this.CONSUME(To);
             this.SUBRULE3(this.identifier);
           }
@@ -2560,7 +2605,7 @@ var QuestDBParser = class extends CstParser {
           ALT: () => {
             this.CONSUME1(Alter);
             this.CONSUME3(Column);
-            this.SUBRULE4(this.identifier);
+            this.SUBRULE3(this.columnRef);
             this.OR9([
               {
                 ALT: () => {
@@ -2779,7 +2824,7 @@ var QuestDBParser = class extends CstParser {
       () => {
         this.CONSUME(Materialized);
         this.CONSUME(View);
-        this.SUBRULE(this.qualifiedName);
+        this.SUBRULE(this.tableName);
         this.SUBRULE(this.alterMaterializedViewAction);
       }
     );
@@ -2791,7 +2836,7 @@ var QuestDBParser = class extends CstParser {
             ALT: () => {
               this.CONSUME(Alter);
               this.CONSUME(Column);
-              this.SUBRULE(this.identifier);
+              this.SUBRULE(this.columnRef);
               this.OR1([
                 {
                   ALT: () => {
@@ -2938,7 +2983,7 @@ var QuestDBParser = class extends CstParser {
               this.CONSUME(If);
               this.CONSUME(Exists);
             });
-            this.SUBRULE(this.qualifiedName);
+            this.SUBRULE(this.tableName);
           }
         }
       ]);
@@ -2994,10 +3039,10 @@ var QuestDBParser = class extends CstParser {
         this.CONSUME(Exists);
       });
       this.OPTION1(() => this.CONSUME(Only));
-      this.SUBRULE(this.qualifiedName);
+      this.SUBRULE(this.tableName);
       this.MANY(() => {
         this.CONSUME(Comma);
-        this.SUBRULE1(this.qualifiedName);
+        this.SUBRULE1(this.tableName);
       });
       this.OPTION2(() => {
         this.CONSUME(Keep);
@@ -3011,9 +3056,9 @@ var QuestDBParser = class extends CstParser {
     this.renameTableStatement = this.RULE("renameTableStatement", () => {
       this.CONSUME(Rename);
       this.CONSUME(Table);
-      this.SUBRULE(this.stringOrQualifiedName);
+      this.SUBRULE(this.tableNameOrString);
       this.CONSUME(To);
-      this.SUBRULE1(this.stringOrQualifiedName);
+      this.SUBRULE1(this.tableNameOrString);
     });
     this.addUserStatement = this.RULE("addUserStatement", () => {
       this.CONSUME(Add);
@@ -3224,7 +3269,7 @@ var QuestDBParser = class extends CstParser {
       this.CONSUME(Cancel);
     });
     this.copyFrom = this.RULE("copyFrom", () => {
-      this.SUBRULE(this.qualifiedName);
+      this.SUBRULE(this.tableName);
       this.CONSUME(From);
       this.SUBRULE(this.stringOrIdentifier);
       this.OPTION(() => this.SUBRULE(this.copyOptions));
@@ -3238,7 +3283,7 @@ var QuestDBParser = class extends CstParser {
             this.CONSUME(RParen);
           }
         },
-        { ALT: () => this.SUBRULE(this.qualifiedName) }
+        { ALT: () => this.SUBRULE(this.tableName) }
       ]);
       this.CONSUME(To);
       this.SUBRULE1(this.stringOrIdentifier);
@@ -3389,7 +3434,7 @@ var QuestDBParser = class extends CstParser {
         {
           ALT: () => {
             this.CONSUME(Table);
-            this.SUBRULE(this.qualifiedName);
+            this.SUBRULE(this.tableName);
           }
         },
         { ALT: () => this.CONSUME(Abort) }
@@ -3401,7 +3446,7 @@ var QuestDBParser = class extends CstParser {
     this.compileViewStatement = this.RULE("compileViewStatement", () => {
       this.CONSUME(Compile);
       this.CONSUME(View);
-      this.SUBRULE(this.qualifiedName);
+      this.SUBRULE(this.tableName);
     });
     // ==========================================================================
     // GRANT / REVOKE Statements
@@ -3517,7 +3562,7 @@ var QuestDBParser = class extends CstParser {
       });
     });
     this.grantTableTarget = this.RULE("grantTableTarget", () => {
-      this.SUBRULE(this.qualifiedName);
+      this.SUBRULE(this.tableName);
       this.OPTION(() => {
         this.CONSUME(LParen);
         this.SUBRULE(this.identifier);
@@ -3563,7 +3608,7 @@ var QuestDBParser = class extends CstParser {
     this.vacuumTableStatement = this.RULE("vacuumTableStatement", () => {
       this.CONSUME(Vacuum);
       this.CONSUME(Table);
-      this.SUBRULE(this.qualifiedName);
+      this.SUBRULE(this.tableName);
     });
     this.resumeWalStatement = this.RULE("resumeWalStatement", () => {
       this.CONSUME(Resume);
@@ -3589,7 +3634,7 @@ var QuestDBParser = class extends CstParser {
     this.reindexTableStatement = this.RULE("reindexTableStatement", () => {
       this.CONSUME(Reindex);
       this.CONSUME(Table);
-      this.SUBRULE(this.qualifiedName);
+      this.SUBRULE(this.tableName);
       this.OPTION(() => {
         this.CONSUME(Column);
         this.SUBRULE(this.identifier);
@@ -3620,7 +3665,7 @@ var QuestDBParser = class extends CstParser {
         this.CONSUME(Refresh);
         this.CONSUME(Materialized);
         this.CONSUME(View);
-        this.SUBRULE(this.qualifiedName);
+        this.SUBRULE(this.tableName);
         this.OPTION(() => {
           this.OR([
             { ALT: () => this.CONSUME(Full) },
@@ -3650,7 +3695,7 @@ var QuestDBParser = class extends CstParser {
             this.CONSUME1(RParen);
           }
         },
-        { ALT: () => this.SUBRULE(this.qualifiedName) }
+        { ALT: () => this.SUBRULE(this.tableName) }
       ]);
       this.OPTION(() => this.SUBRULE(this.whereClause));
       this.CONSUME(Pivot);
@@ -4403,6 +4448,20 @@ var QuestDBParser = class extends CstParser {
     this.columnRef = this.RULE("columnRef", () => {
       this.SUBRULE(this.qualifiedName);
     });
+    // Wrapper for qualifiedName in table/view name positions.
+    // Mirrors columnRef but for table references, so computeContentAssist
+    // ruleStack includes "tableName" → autocomplete suggests existing tables.
+    this.tableName = this.RULE("tableName", () => {
+      this.SUBRULE(this.qualifiedName);
+    });
+    // Accepts StringLiteral or tableName. Used for table references that
+    // can be quoted (INSERT INTO, RENAME TABLE, ALTER TABLE).
+    this.tableNameOrString = this.RULE("tableNameOrString", () => {
+      this.OR([
+        { ALT: () => this.CONSUME(StringLiteral) },
+        { ALT: () => this.SUBRULE(this.tableName) }
+      ]);
+    });
     this.qualifiedName = this.RULE("qualifiedName", () => {
       this.SUBRULE(this.identifier);
       this.MANY(() => {
@@ -4830,7 +4889,7 @@ var QuestDBVisitor = class extends BaseVisitor {
         parts: [ctx.StringLiteral[0].image.slice(1, -1)]
       };
     } else {
-      table = this.visit(ctx.qualifiedName);
+      table = this.visit(ctx.tableName);
     }
     const result = {
       type: "tableRef",
@@ -4874,39 +4933,73 @@ var QuestDBVisitor = class extends BaseVisitor {
     return void 0;
   }
   joinClause(ctx) {
+    if (ctx.asofLtJoin) return this.visit(ctx.asofLtJoin);
+    if (ctx.spliceJoin) return this.visit(ctx.spliceJoin);
+    if (ctx.windowJoin) return this.visit(ctx.windowJoin);
+    return this.visit(ctx.standardJoin);
+  }
+  asofLtJoin(ctx) {
     const result = {
       type: "join",
       table: this.visit(ctx.tableRef)
     };
-    if (ctx.Inner) result.joinType = "inner";
-    else if (ctx.Left) result.joinType = "left";
-    else if (ctx.Right) result.joinType = "right";
-    else if (ctx.Full) result.joinType = "full";
-    else if (ctx.Cross) result.joinType = "cross";
-    else if (ctx.Asof) result.joinType = "asof";
+    if (ctx.Asof) result.joinType = "asof";
     else if (ctx.Lt) result.joinType = "lt";
-    else if (ctx.Splice) result.joinType = "splice";
-    else if (ctx.Window) result.joinType = "window";
-    if (ctx.Outer) {
-      result.outer = true;
-    }
     if (ctx.expression) {
       result.on = this.visit(ctx.expression);
     }
     if (ctx.DurationLiteral) {
       result.tolerance = ctx.DurationLiteral[0].image;
     }
+    return result;
+  }
+  spliceJoin(ctx) {
+    const result = {
+      type: "join",
+      joinType: "splice",
+      table: this.visit(ctx.tableRef)
+    };
+    if (ctx.expression) {
+      result.on = this.visit(ctx.expression);
+    }
+    return result;
+  }
+  windowJoin(ctx) {
+    const result = {
+      type: "join",
+      table: this.visit(ctx.tableRef)
+    };
+    if (ctx.Window) result.joinType = "window";
+    if (ctx.expression) {
+      result.on = this.visit(ctx.expression);
+    }
     if (ctx.windowJoinBound && ctx.windowJoinBound.length >= 2) {
       result.range = {
         start: this.visit(ctx.windowJoinBound[0]),
         end: this.visit(ctx.windowJoinBound[1])
       };
     }
-    if (ctx.Prevailing) {
+    if (ctx.Include || ctx.Exclude) {
       result.prevailing = ctx.Include ? "include" : "exclude";
     }
     return result;
   }
+  standardJoin(ctx) {
+    const result = {
+      type: "join",
+      table: this.visit(ctx.tableRef)
+    };
+    if (ctx.Inner) result.joinType = "inner";
+    else if (ctx.Left) result.joinType = "left";
+    else if (ctx.Right) result.joinType = "right";
+    else if (ctx.Full) result.joinType = "full";
+    else if (ctx.Cross) result.joinType = "cross";
+    if (ctx.Outer) result.outer = true;
+    if (ctx.expression) {
+      result.on = this.visit(ctx.expression);
+    }
+    return result;
+  }
   windowJoinBound(ctx) {
     const result = {
       type: "windowJoinBound",
@@ -5044,7 +5137,7 @@ var QuestDBVisitor = class extends BaseVisitor {
   insertStatement(ctx) {
     const result = {
       type: "insert",
-      table: this.visit(ctx.stringOrQualifiedName)
+      table: this.visit(ctx.tableNameOrString)
     };
     if (ctx.Atomic) {
       result.atomic = true;
@@ -5085,7 +5178,7 @@ var QuestDBVisitor = class extends BaseVisitor {
   updateStatement(ctx) {
     const result = {
       type: "update",
-      table: this.visit(ctx.qualifiedName),
+      table: this.visit(ctx.tableName),
       set: ctx.setClause.map((s) => this.visit(s))
     };
     if (ctx.identifier) {
@@ -5186,8 +5279,8 @@ var QuestDBVisitor = class extends BaseVisitor {
         (c) => this.visit(c)
       );
     }
-    if (ctx.Like && ctx.qualifiedName) {
-      result.like = this.visit(ctx.qualifiedName[0]);
+    if (ctx.Like && ctx.tableName) {
+      result.like = this.visit(ctx.tableName[0]);
     }
     if (ctx.selectStatement) {
       result.asSelect = this.visit(
@@ -5570,10 +5663,7 @@ var QuestDBVisitor = class extends BaseVisitor {
     };
   }
   alterTableStatement(ctx) {
-    const table = ctx.qualifiedName ? this.visit(ctx.qualifiedName) : {
-      type: "qualifiedName",
-      parts: [ctx.StringLiteral[0].image.slice(1, -1)]
-    };
+    const table = this.visit(ctx.tableNameOrString);
     return {
       type: "alterTable",
       table,
@@ -5583,7 +5673,7 @@ var QuestDBVisitor = class extends BaseVisitor {
   alterMaterializedViewStatement(ctx) {
     return {
       type: "alterMaterializedView",
-      view: this.visit(ctx.qualifiedName),
+      view: this.visit(ctx.tableName),
       action: this.visit(
         ctx.alterMaterializedViewAction
       )
@@ -5591,9 +5681,10 @@ var QuestDBVisitor = class extends BaseVisitor {
   }
   alterMaterializedViewAction(ctx) {
     if (ctx.Add && ctx.Index) {
+      const colRef = this.visit(ctx.columnRef[0]);
       const result = {
         actionType: "addIndex",
-        column: this.extractIdentifierName(ctx.identifier[0].children)
+        column: colRef.name.parts[colRef.name.parts.length - 1]
       };
       if (ctx.Capacity && ctx.NumberLiteral) {
         result.capacity = parseInt(ctx.NumberLiteral[0].image, 10);
@@ -5601,9 +5692,10 @@ var QuestDBVisitor = class extends BaseVisitor {
       return result;
     }
     if (ctx.Symbol && ctx.Capacity) {
+      const colRef = this.visit(ctx.columnRef[0]);
       return {
         actionType: "symbolCapacity",
-        column: this.extractIdentifierName(ctx.identifier[0].children),
+        column: colRef.name.parts[colRef.name.parts.length - 1],
         capacity: parseInt(ctx.NumberLiteral[0].image, 10)
       };
     }
@@ -5620,9 +5712,10 @@ var QuestDBVisitor = class extends BaseVisitor {
       };
     }
     if (ctx.Alter && ctx.Drop && ctx.Index) {
+      const colRef = this.visit(ctx.columnRef[0]);
       return {
         actionType: "dropIndex",
-        column: this.extractIdentifierName(ctx.identifier[0].children)
+        column: colRef.name.parts[colRef.name.parts.length - 1]
       };
     }
     if (ctx.Resume) {
@@ -5712,26 +5805,28 @@ var QuestDBVisitor = class extends BaseVisitor {
       }
       return result;
     }
-    if (ctx.Drop && ctx.identifier && !ctx.Partition && !ctx.Alter) {
+    if (ctx.Drop && ctx.columnRef && !ctx.Partition && !ctx.Alter) {
       return {
         actionType: "dropColumn",
-        columns: ctx.identifier.map(
-          (id) => this.extractIdentifierName(id.children)
-        )
+        columns: ctx.columnRef.map((c) => {
+          const ref = this.visit(c);
+          return ref.name.parts[ref.name.parts.length - 1];
+        })
       };
     }
     if (ctx.Rename) {
-      const identifiers = ctx.identifier.map(
-        (id) => this.extractIdentifierName(id.children)
-      );
+      const oldRef = this.visit(ctx.columnRef[0]);
+      const oldName = oldRef.name.parts[oldRef.name.parts.length - 1];
+      const newName = this.extractIdentifierName(ctx.identifier[0].children);
       return {
         actionType: "renameColumn",
-        oldName: identifiers[0],
-        newName: identifiers[1]
+        oldName,
+        newName
       };
     }
-    if (ctx.Alter && ctx.identifier) {
-      const column = this.extractIdentifierName(ctx.identifier[0].children);
+    if (ctx.Alter && ctx.columnRef) {
+      const colRef = this.visit(ctx.columnRef[0]);
+      const column = colRef.name.parts[colRef.name.parts.length - 1];
       let alterType = "type";
       let newType;
       let capacity;
@@ -5915,7 +6010,7 @@ var QuestDBVisitor = class extends BaseVisitor {
     if (ctx.All) {
       result.allTables = true;
     } else {
-      result.table = this.visit(ctx.qualifiedName);
+      result.table = this.visit(ctx.tableName);
       if (ctx.If) {
         result.ifExists = true;
       }
@@ -5961,7 +6056,7 @@ var QuestDBVisitor = class extends BaseVisitor {
   // TRUNCATE TABLE Statement
   // ==========================================================================
   truncateTableStatement(ctx) {
-    const tables = ctx.qualifiedName.map(
+    const tables = ctx.tableName.map(
       (qn) => this.visit(qn)
     );
     const result = {
@@ -5985,8 +6080,8 @@ var QuestDBVisitor = class extends BaseVisitor {
   renameTableStatement(ctx) {
     return {
       type: "renameTable",
-      from: this.visit(ctx.stringOrQualifiedName[0]),
-      to: this.visit(ctx.stringOrQualifiedName[1])
+      from: this.visit(ctx.tableNameOrString[0]),
+      to: this.visit(ctx.tableNameOrString[1])
     };
   }
   addUserStatement(ctx) {
@@ -6194,7 +6289,7 @@ var QuestDBVisitor = class extends BaseVisitor {
   copyFrom(ctx) {
     const result = {
       type: "copyFrom",
-      table: this.visit(ctx.qualifiedName),
+      table: this.visit(ctx.tableName),
       file: this.extractMaybeString(ctx.stringOrIdentifier[0])
     };
     if (ctx.copyOptions) {
@@ -6203,7 +6298,7 @@ var QuestDBVisitor = class extends BaseVisitor {
     return result;
   }
   copyTo(ctx) {
-    const source = ctx.selectStatement ? this.visit(ctx.selectStatement[0]) : this.visit(ctx.qualifiedName);
+    const source = ctx.selectStatement ? this.visit(ctx.selectStatement[0]) : this.visit(ctx.tableName);
     const result = {
       type: "copyTo",
       source,
@@ -6285,13 +6380,13 @@ var QuestDBVisitor = class extends BaseVisitor {
     return {
       type: "backup",
       action: "table",
-      table: this.visit(ctx.qualifiedName)
+      table: this.visit(ctx.tableName)
     };
   }
   compileViewStatement(ctx) {
     return {
       type: "compileView",
-      view: this.visit(ctx.qualifiedName)
+      view: this.visit(ctx.tableName)
     };
   }
   convertPartitionTarget(ctx) {
@@ -6390,7 +6485,7 @@ var QuestDBVisitor = class extends BaseVisitor {
   grantTableTarget(ctx) {
     const result = {
       type: "grantTableTarget",
-      table: this.visit(ctx.qualifiedName)
+      table: this.visit(ctx.tableName)
     };
     if (ctx.identifier && ctx.identifier.length > 0) {
       result.columns = ctx.identifier.map(
@@ -6420,7 +6515,7 @@ var QuestDBVisitor = class extends BaseVisitor {
   vacuumTableStatement(ctx) {
     return {
       type: "vacuumTable",
-      table: this.visit(ctx.qualifiedName)
+      table: this.visit(ctx.tableName)
     };
   }
   resumeWalStatement(ctx) {
@@ -6445,7 +6540,7 @@ var QuestDBVisitor = class extends BaseVisitor {
   reindexTableStatement(ctx) {
     const result = {
       type: "reindexTable",
-      table: this.visit(ctx.qualifiedName)
+      table: this.visit(ctx.tableName)
     };
     if (ctx.Column && ctx.identifier) {
       result.columns = ctx.identifier.map(
@@ -6465,7 +6560,7 @@ var QuestDBVisitor = class extends BaseVisitor {
   refreshMaterializedViewStatement(ctx) {
     const result = {
       type: "refreshMaterializedView",
-      view: this.visit(ctx.qualifiedName)
+      view: this.visit(ctx.tableName)
     };
     if (ctx.Full) result.mode = "full";
     if (ctx.Incremental) result.mode = "incremental";
@@ -6482,7 +6577,7 @@ var QuestDBVisitor = class extends BaseVisitor {
   // PIVOT Statement
   // ==========================================================================
   pivotStatement(ctx) {
-    const source = ctx.selectStatement ? this.visit(ctx.selectStatement[0]) : this.visit(ctx.qualifiedName);
+    const source = ctx.selectStatement ? this.visit(ctx.selectStatement[0]) : this.visit(ctx.tableName);
     const body = ctx.pivotBody ? this.visit(ctx.pivotBody) : {};
     const result = {
       type: "pivot",
@@ -7337,6 +7432,19 @@ var QuestDBVisitor = class extends BaseVisitor {
       name: this.visit(ctx.qualifiedName)
     };
   }
+  tableName(ctx) {
+    return this.visit(ctx.qualifiedName);
+  }
+  tableNameOrString(ctx) {
+    if (ctx.StringLiteral) {
+      return {
+        type: "qualifiedName",
+        parts: [ctx.StringLiteral[0].image.slice(1, -1)]
+      };
+    }
+    if (ctx.tableName) return this.visit(ctx.tableName);
+    return { type: "qualifiedName", parts: [] };
+  }
   qualifiedName(ctx) {
     const parts = ctx.identifier.map((id) => {
       return this.extractIdentifierName(id.children);
@@ -9162,6 +9270,18 @@ function extractTablesFromAst(ast) {
         tables.push({ table: tableName });
       }
     }
+    if ((n.type === "alterTable" || n.type === "alterMaterializedView") && n.table) {
+      const tableName = normalizeTableName(n.table);
+      if (tableName) {
+        tables.push({ table: tableName });
+      }
+    }
+    if (n.type === "alterMaterializedView" && n.view) {
+      const viewName = normalizeTableName(n.view);
+      if (viewName) {
+        tables.push({ table: viewName });
+      }
+    }
     for (const key of Object.keys(n)) {
       const child = n[key];
       if (Array.isArray(child)) {
@@ -9313,23 +9433,34 @@ function extractTables(fullSql, tokens) {
     fullSql,
     tokens
   );
+  const DDL_TABLE_PREFIXES = /* @__PURE__ */ new Set(["Alter", "Truncate", "Drop"]);
   for (let i = outerQueryStart; i < tokens.length; i++) {
-    if (!TABLE_PREFIX_TOKENS.has(tokens[i].tokenType.name)) continue;
-    const tableNameResult = readQualifiedName(i + 1);
-    if (!tableNameResult) continue;
-    let alias;
-    let aliasStart = tableNameResult.nextIndex;
-    if (tokens[aliasStart]?.tokenType.name === "As") {
-      aliasStart++;
+    const tokenName = tokens[i].tokenType.name;
+    if (TABLE_PREFIX_TOKENS.has(tokenName)) {
+      const tableNameResult = readQualifiedName(i + 1);
+      if (!tableNameResult) continue;
+      let alias;
+      let aliasStart = tableNameResult.nextIndex;
+      if (tokens[aliasStart]?.tokenType.name === "As") {
+        aliasStart++;
+      }
+      if (isIdentifierLike(tokens[aliasStart])) {
+        alias = tokenToNamePart(tokens[aliasStart]);
+      }
+      tables.push({
+        table: tableNameResult.name,
+        alias
+      });
+      i = alias ? aliasStart : tableNameResult.nextIndex - 1;
+      continue;
     }
-    if (isIdentifierLike(tokens[aliasStart])) {
-      alias = tokenToNamePart(tokens[aliasStart]);
+    if (DDL_TABLE_PREFIXES.has(tokenName) && tokens[i + 1]?.tokenType.name === "Table") {
+      const tableNameResult = readQualifiedName(i + 2);
+      if (tableNameResult) {
+        tables.push({ table: tableNameResult.name });
+        i = tableNameResult.nextIndex - 1;
+      }
     }
-    tables.push({
-      table: tableNameResult.name,
-      alias
-    });
-    i = alias ? aliasStart : tableNameResult.nextIndex - 1;
   }
   for (const name of cteNames) {
     tables.push({ table: name });
@@ -9365,6 +9496,13 @@ function collapseTrailingQualifiedRef(tokens) {
   if (start >= i) return null;
   return [...tokens.slice(0, start), lastToken];
 }
+function classifyIdentifierPath(ruleStack) {
+  if (ruleStack.includes("valuesClause")) return "newName";
+  if (ruleStack.includes("identifierExpression") || ruleStack.includes("columnRef") || ruleStack.includes("qualifiedStar"))
+    return "column";
+  if (ruleStack.includes("tableName")) return "table";
+  return "newName";
+}
 function computeSuggestions(tokens) {
   const ruleName = tokens.some((t) => t.tokenType.name === "Semicolon") ? "statements" : "statement";
   const suggestions = parser.computeContentAssist(ruleName, tokens);
@@ -9376,10 +9514,21 @@ function computeSuggestions(tokens) {
   const specific = suggestions.filter(
     (s) => !isImplicitStatementPath(s.ruleStack, IMPLICIT_RULES)
   );
-  const result = (specific.length > 0 ? specific : suggestions).map(
-    (s) => s.nextTokenType
-  );
   const effectiveSuggestions = specific.length > 0 ? specific : suggestions;
+  const result = effectiveSuggestions.map((s) => s.nextTokenType);
+  let suggestColumns = false;
+  let suggestTables = false;
+  for (const s of effectiveSuggestions) {
+    if (s.nextTokenType.name === "IdentifierKeyword") {
+      const cls = classifyIdentifierPath(s.ruleStack);
+      if (cls === "column") {
+        suggestColumns = true;
+        suggestTables = true;
+      } else if (cls === "table") {
+        suggestTables = true;
+      }
+    }
+  }
   if (effectiveSuggestions.length > 0 && effectiveSuggestions.every((s) => s.ruleStack.includes("qualifiedStar"))) {
     const collapsed = collapseTrailingQualifiedRef(tokens);
     if (collapsed) {
@@ -9388,19 +9537,28 @@ function computeSuggestions(tokens) {
         const filteredExtra = extra.filter(
           (s) => !isImplicitStatementPath(s.ruleStack, IMPLICIT_RULES)
         );
-        const extraResult = (filteredExtra.length > 0 ? filteredExtra : extra).map((s) => s.nextTokenType);
+        const extraEffective = filteredExtra.length > 0 ? filteredExtra : extra;
         const seen = new Set(result.map((t) => t.name));
-        for (const t of extraResult) {
-          if (!seen.has(t.name)) {
-            seen.add(t.name);
-            result.push(t);
+        for (const s of extraEffective) {
+          if (!seen.has(s.nextTokenType.name)) {
+            seen.add(s.nextTokenType.name);
+            result.push(s.nextTokenType);
+          }
+          if (s.nextTokenType.name === "IdentifierKeyword") {
+            const cls = classifyIdentifierPath(s.ruleStack);
+            if (cls === "column") {
+              suggestColumns = true;
+              suggestTables = true;
+            } else if (cls === "table") {
+              suggestTables = true;
+            }
           }
         }
       } catch (e) {
       }
     }
   }
-  return result;
+  return { nextTokenTypes: result, suggestColumns, suggestTables };
 }
 function inferTableFromQualifiedRef(tokensBefore, isMidWord) {
   const effective = isMidWord ? tokensBefore.slice(0, -1) : tokensBefore;
@@ -9412,6 +9570,32 @@ function inferTableFromQualifiedRef(tokensBefore, isMidWord) {
   const table = tableToken.tokenType.name === "QuotedIdentifier" ? tableToken.image.slice(1, -1) : tableToken.image;
   return { table };
 }
+function extractReferencedColumns(tokens, tableAndAliasSet) {
+  const result = /* @__PURE__ */ new Set();
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    const name = token.tokenType.name;
+    if (name !== "Identifier" && name !== "QuotedIdentifier" && !IDENTIFIER_KEYWORD_TOKENS.has(name)) {
+      continue;
+    }
+    if (i + 1 < tokens.length && tokens[i + 1].tokenType.name === "Dot") {
+      continue;
+    }
+    if (i > 0 && tokens[i - 1].tokenType.name === "Dot" && i + 1 < tokens.length && tokens[i + 1].tokenType.name === "Dot") {
+      continue;
+    }
+    if (i + 1 < tokens.length && tokens[i + 1].tokenType.name === "LParen") {
+      continue;
+    }
+    const image = name === "QuotedIdentifier" ? token.image.slice(1, -1) : token.image;
+    const lower = image.toLowerCase();
+    if (tableAndAliasSet.has(lower)) {
+      continue;
+    }
+    result.add(lower);
+  }
+  return result;
+}
 function getContentAssist(fullSql, cursorOffset) {
   const fullTokens = QuestDBLexer.tokenize(fullSql).tokens;
   for (const token of fullTokens) {
@@ -9426,7 +9610,10 @@ function getContentAssist(fullSql, cursorOffset) {
         cteColumns: {},
         tokensBefore: [],
         isMidWord: true,
-        lexErrors: []
+        lexErrors: [],
+        suggestColumns: false,
+        suggestTables: false,
+        referencedColumns: /* @__PURE__ */ new Set()
       };
     }
   }
@@ -9437,8 +9624,13 @@ function getContentAssist(fullSql, cursorOffset) {
   const isMidWord = !WORD_BOUNDARY_CHARS.has(lastChar);
   const tokensForAssist = isMidWord && tokens.length > 0 ? tokens.slice(0, -1) : tokens;
   let nextTokenTypes = [];
+  let suggestColumns = false;
+  let suggestTables = false;
   try {
-    nextTokenTypes = computeSuggestions(tokensForAssist);
+    const computed = computeSuggestions(tokensForAssist);
+    nextTokenTypes = computed.nextTokenTypes;
+    suggestColumns = computed.suggestColumns;
+    suggestTables = computed.suggestTables;
   } catch (e) {
   }
   const { tables: tablesInScope, cteColumns } = extractTables(
@@ -9473,6 +9665,15 @@ function getContentAssist(fullSql, cursorOffset) {
   if (tablesInScope.length === 0 && qualifiedRef) {
     tablesInScope.push(qualifiedRef);
   }
+  const tableAndAliasSet = /* @__PURE__ */ new Set();
+  for (const t of tablesInScope) {
+    tableAndAliasSet.add(t.table.toLowerCase());
+    if (t.alias) tableAndAliasSet.add(t.alias.toLowerCase());
+  }
+  const referencedColumns = extractReferencedColumns(
+    tokensForAssist,
+    tableAndAliasSet
+  );
   return {
     nextTokenTypes,
     tablesInScope,
@@ -9480,13 +9681,18 @@ function getContentAssist(fullSql, cursorOffset) {
     tokensBefore: tokens,
     isMidWord,
     lexErrors: lexResult.errors,
-    qualifiedTableRef: qualifiedRef?.table
+    qualifiedTableRef: qualifiedRef?.table,
+    suggestColumns,
+    suggestTables,
+    referencedColumns
   };
 }
 function getNextValidTokens(sql) {
   const lexResult = QuestDBLexer.tokenize(sql);
   try {
-    return computeSuggestions(lexResult.tokens).map((t) => t.name);
+    return computeSuggestions(lexResult.tokens).nextTokenTypes.map(
+      (t) => t.name
+    );
   } catch (e) {
     return [];
   }
@@ -10058,6 +10264,35 @@ var TABLE_NAME_TOKENS = /* @__PURE__ */ new Set([
   "Table",
   "View"
 ]);
+function buildColumnIndex(schema) {
+  const index = /* @__PURE__ */ new Map();
+  for (const table of schema.tables) {
+    const key = table.name.toLowerCase();
+    const cols = schema.columns[key];
+    if (cols) {
+      index.set(key, new Set(cols.map((c) => c.name.toLowerCase())));
+    }
+  }
+  return index;
+}
+function rankTableSuggestions(suggestions, referencedColumns, columnIndex) {
+  if (referencedColumns.size === 0) return;
+  const scores = /* @__PURE__ */ new Map();
+  for (const [tableName, colNames] of columnIndex) {
+    let count = 0;
+    for (const ref of referencedColumns) {
+      if (colNames.has(ref)) count++;
+    }
+    if (count > 0) scores.set(tableName, count);
+  }
+  if (scores.size === 0) return;
+  for (const s of suggestions) {
+    if (s.kind !== "table" /* Table */) continue;
+    const score = scores.get(s.label.toLowerCase());
+    if (score === void 0) continue;
+    s.priority = score === referencedColumns.size ? 1 /* High */ : 2 /* Medium */;
+  }
+}
 function getLastSignificantTokens(tokens) {
   const result = [];
   for (let i = tokens.length - 1; i >= 0; i--) {
@@ -10071,45 +10306,6 @@ function getLastSignificantTokens(tokens) {
   }
   return result;
 }
-var EXPRESSION_END_TOKENS = /* @__PURE__ */ new Set([
-  "Identifier",
-  "QuotedIdentifier",
-  "RParen",
-  "NumberLiteral",
-  "LongLiteral",
-  "DecimalLiteral",
-  "StringLiteral"
-]);
-function isExpressionEnd(tokenName) {
-  return EXPRESSION_END_TOKENS.has(tokenName) || IDENTIFIER_KEYWORD_TOKENS.has(tokenName);
-}
-function getIdentifierSuggestionScope(lastTokenName, prevTokenName, rawLastTokenName, rawPrevTokenName) {
-  if (rawLastTokenName && isExpressionEnd(rawLastTokenName)) {
-    return { includeColumns: false, includeTables: false };
-  }
-  if (rawLastTokenName === "Star") {
-    if (rawPrevTokenName && isExpressionEnd(rawPrevTokenName)) {
-      return { includeColumns: true, includeTables: true };
-    }
-    return { includeColumns: false, includeTables: false };
-  }
-  if (lastTokenName === "As") {
-    if (rawLastTokenName === "LParen") {
-      return { includeColumns: false, includeTables: true };
-    }
-    return { includeColumns: false, includeTables: false };
-  }
-  if (prevTokenName && TABLE_NAME_TOKENS.has(prevTokenName)) {
-    return { includeColumns: false, includeTables: true };
-  }
-  if (lastTokenName && TABLE_NAME_TOKENS.has(lastTokenName)) {
-    return { includeColumns: false, includeTables: true };
-  }
-  if (!lastTokenName) {
-    return { includeColumns: false, includeTables: true };
-  }
-  return { includeColumns: true, includeTables: true };
-}
 function createAutocompleteProvider(schema) {
   const normalizedSchema = {
     tables: schema.tables,
@@ -10120,6 +10316,7 @@ function createAutocompleteProvider(schema) {
       ])
     )
   };
+  const columnIndex = buildColumnIndex(normalizedSchema);
   return {
     getSuggestions(query, cursorOffset) {
       const {
@@ -10128,7 +10325,10 @@ function createAutocompleteProvider(schema) {
         cteColumns,
         tokensBefore,
         isMidWord,
-        qualifiedTableRef
+        qualifiedTableRef,
+        suggestColumns,
+        suggestTables,
+        referencedColumns
       } = getContentAssist(query, cursorOffset);
       const effectiveSchema = Object.keys(cteColumns).length > 0 ? {
         ...normalizedSchema,
@@ -10156,22 +10356,20 @@ function createAutocompleteProvider(schema) {
         }
       }
       if (nextTokenTypes.length > 0) {
-        const tokensForScope = isMidWord && tokensBefore.length > 0 ? tokensBefore.slice(0, -1) : tokensBefore;
-        const [lastTokenName, prevTokenName] = getLastSignificantTokens(tokensForScope);
-        const rawLastTokenName = tokensForScope.length > 0 ? tokensForScope[tokensForScope.length - 1]?.tokenType?.name : void 0;
-        const rawPrevTokenName = tokensForScope.length > 1 ? tokensForScope[tokensForScope.length - 2]?.tokenType?.name : void 0;
-        const scope = getIdentifierSuggestionScope(
-          lastTokenName,
-          prevTokenName,
-          rawLastTokenName,
-          rawPrevTokenName
-        );
-        return buildSuggestions(
+        const suggestions = buildSuggestions(
           nextTokenTypes,
           effectiveSchema,
           effectiveTablesInScope,
-          { ...scope, isMidWord }
+          {
+            includeColumns: suggestColumns,
+            includeTables: suggestTables,
+            isMidWord
+          }
         );
+        if (suggestTables) {
+          rankTableSuggestions(suggestions, referencedColumns, columnIndex);
+        }
+        return suggestions;
       }
       const fallbackTokens = isMidWord && tokensBefore.length > 0 ? tokensBefore.slice(0, -1) : tokensBefore;
       const [lastFallback] = getLastSignificantTokens(fallbackTokens);
@@ -10200,6 +10398,7 @@ function createAutocompleteProvider(schema) {
             });
           }
         }
+        rankTableSuggestions(suggestions, referencedColumns, columnIndex);
         return suggestions;
       }
       return [];