diff --git a/crates/squawk_ide/src/classify.rs b/crates/squawk_ide/src/classify.rs
index b5d61d99..56a55439 100644
--- a/crates/squawk_ide/src/classify.rs
+++ b/crates/squawk_ide/src/classify.rs
@@ -6,112 +6,56 @@ use squawk_syntax::{
 
 #[derive(Debug)]
 pub(crate) enum NameRefClass {
-    DropTable,
-    DropForeignTable,
-    Table,
-    DropIndex,
-    DropType,
-    DropDomain,
-    DropView,
-    DropMaterializedView,
-    DropSequence,
-    DropTrigger,
-    DropPolicy,
-    AlterPolicy,
-    DropEventTrigger,
-    SequenceOwnedByColumn,
-    Tablespace,
-    DropDatabase,
-    DropServer,
-    AlterServer,
-    CreateServer,
-    DropExtension,
-    AlterExtension,
-    ForeignTableServerName,
-    AlterRole,
-    DropRole,
-    SetRole,
-    Role,
-    ForeignKeyTable,
-    ForeignKeyColumn,
-    ForeignKeyLocalColumn,
-    CheckConstraintColumn,
-    PolicyColumn,
-    PolicyQualifiedColumnTable,
-    GeneratedColumn,
-    UniqueConstraintColumn,
-    PrimaryKeyConstraintColumn,
-    NotNullConstraintColumn,
-    ExcludeConstraintColumn,
-    PartitionByColumn,
-    PartitionOfTable,
-    LikeTable,
-    InheritsTable,
-    DropFunction,
-    DropAggregate,
-    DropProcedure,
-    DropRoutine,
+    Aggregate,
+    AlterColumn,
     CallProcedure,
-    DropSchema,
-    CreateIndex,
-    CreateIndexColumn,
-    DefaultConstraintFunctionCall,
-    SelectFunctionCall,
-    SelectFromTable,
-    SelectColumn,
-    SelectQualifiedColumnTable,
-    SelectQualifiedColumn,
+    Channel,
     CompositeTypeField,
-    InsertTable,
+    ConstraintColumn,
+    CreateIndexColumn,
+    Cursor,
+    Database,
+    DeleteColumn,
+    DeleteQualifiedColumnTable,
+    EventTrigger,
+    Extension,
+    ForeignKeyColumn,
+    ForeignKeyTable,
+    FromTable,
+    Function,
+    FunctionCall,
+    FunctionName,
+    Index,
     InsertColumn,
     InsertQualifiedColumnTable,
-    DeleteTable,
-    DeleteWhereColumn,
-    DeleteQualifiedColumnTable,
-    DeleteUsingTable,
-    UpdateTable,
-    UpdateWhereColumn,
-    UpdateSetColumn,
-    UpdateFromTable,
-    UpdateSetQualifiedColumnTable,
-    UpdateReturningColumn,
-    InsertReturningColumn,
-    DeleteReturningColumn,
-    MergeReturningColumn,
-    MergeWhenColumn,
-    MergeOnColumn,
-    MergeQualifiedColumnTable,
-    MergeUsingTable,
-    MergeTable,
-    UpdateReturningQualifiedColumnTable,
-    InsertReturningQualifiedColumnTable,
-    DeleteReturningQualifiedColumnTable,
-    MergeReturningQualifiedColumnTable,
     JoinUsingColumn,
-    SchemaQualifier,
-    TypeReference,
-    TruncateTable,
-    LockTable,
-    VacuumTable,
-    AlterTable,
-    AlterTableColumn,
-    AlterTableDropColumn,
-    RefreshMaterializedView,
-    ReindexTable,
-    ReindexIndex,
-    ReindexSchema,
-    ReindexDatabase,
-    ReindexSystem,
-    AttachPartition,
+    LikeTable,
+    MergeColumn,
+    MergeQualifiedColumnTable,
     NamedArgParameter,
-    Cursor,
+    Policy,
+    PolicyColumn,
+    PolicyQualifiedColumnTable,
     PreparedStatement,
-    NotifyChannel,
-    UnlistenChannel,
-    TriggerFunctionCall,
-    TriggerProcedureCall,
-    AlterEventTrigger,
-    OperatorFunctionRef,
+    Procedure,
+    ProcedureCall,
+    QualifiedColumn,
+    Role,
+    Routine,
+    Schema,
+    SelectColumn,
+    SelectFunctionCall,
+    SelectQualifiedColumn,
+    SelectQualifiedColumnTable,
+    Sequence,
+    Server,
+    Table,
+    Tablespace,
+    Trigger,
+    Type,
+    UpdateColumn,
+    UpdateQualifiedColumnTable,
+    View,
 }
 
 fn is_special_fn(kind: SyntaxKind) -> bool {
@@ -210,60 +154,36 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
                 in_when_clause = true;
             }
             if ast::Update::can_cast(ancestor.kind()) {
-                if in_returning_clause {
-                    if is_function_call || is_schema_table_col {
-                        return Some(NameRefClass::SchemaQualifier);
-                    } else {
-                        return Some(NameRefClass::UpdateReturningQualifiedColumnTable);
-                    }
-                } else if in_set_clause || in_where_clause || in_from_clause {
+                if in_returning_clause || in_set_clause || in_where_clause || in_from_clause {
                     if is_function_call || is_schema_table_col {
-                        return Some(NameRefClass::SchemaQualifier);
+                        return Some(NameRefClass::Schema);
                     } else {
-                        return Some(NameRefClass::UpdateSetQualifiedColumnTable);
+                        return Some(NameRefClass::UpdateQualifiedColumnTable);
                     }
                 }
             }
             if ast::Insert::can_cast(ancestor.kind()) {
-                if in_returning_clause {
-                    if is_function_call || is_schema_table_col {
-                        return Some(NameRefClass::SchemaQualifier);
-                    } else {
-                        return Some(NameRefClass::InsertReturningQualifiedColumnTable);
-                    }
-                } else if !in_from_clause && !in_on_clause {
+                if in_returning_clause || (!in_from_clause && !in_on_clause) {
                     if is_function_call || is_schema_table_col {
-                        return Some(NameRefClass::SchemaQualifier);
+                        return Some(NameRefClass::Schema);
                     } else {
                         return Some(NameRefClass::InsertQualifiedColumnTable);
                     }
                 }
             }
             if ast::Delete::can_cast(ancestor.kind()) {
-                if in_returning_clause {
-                    if is_function_call || is_schema_table_col {
-                        return Some(NameRefClass::SchemaQualifier);
-                    } else {
-                        return Some(NameRefClass::DeleteReturningQualifiedColumnTable);
-                    }
-                } else if in_where_clause || in_using_clause {
+                if in_returning_clause || in_where_clause || in_using_clause {
                     if is_function_call || is_schema_table_col {
-                        return Some(NameRefClass::SchemaQualifier);
+                        return Some(NameRefClass::Schema);
                     } else {
                         return Some(NameRefClass::DeleteQualifiedColumnTable);
                     }
                 }
             }
             if ast::Merge::can_cast(ancestor.kind()) {
-                if in_returning_clause {
-                    if is_function_call || is_schema_table_col {
-                        return Some(NameRefClass::SchemaQualifier);
-                    } else {
-                        return Some(NameRefClass::MergeReturningQualifiedColumnTable);
-                    }
-                } else if in_on_clause || in_when_clause {
+                if in_returning_clause || in_on_clause || in_when_clause {
                     if is_function_call || is_schema_table_col {
-                        return Some(NameRefClass::SchemaQualifier);
+                        return Some(NameRefClass::Schema);
                     } else {
                         return Some(NameRefClass::MergeQualifiedColumnTable);
                     }
@@ -271,7 +191,7 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
             }
             if ast::Select::can_cast(ancestor.kind()) && (!in_from_clause || in_on_clause) {
                 if is_function_call || is_schema_table_col {
-                    return Some(NameRefClass::SchemaQualifier);
+                    return Some(NameRefClass::Schema);
                 } else {
                     return Some(NameRefClass::SelectQualifiedColumnTable);
                 }
@@ -280,13 +200,13 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
                 || ast::AlterPolicy::can_cast(ancestor.kind())
             {
                 if is_function_call || is_schema_table_col {
-                    return Some(NameRefClass::SchemaQualifier);
+                    return Some(NameRefClass::Schema);
                 } else {
                     return Some(NameRefClass::PolicyQualifiedColumnTable);
                 }
             }
         }
-        return Some(NameRefClass::SchemaQualifier);
+        return Some(NameRefClass::Schema);
     }
 
     if let Some(parent) = name_ref.syntax().parent()
@@ -342,7 +262,7 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
             }
             if ast::Select::can_cast(ancestor.kind()) && (!in_from_clause || in_on_clause) {
                 if in_cast_expr {
-                    return Some(NameRefClass::TypeReference);
+                    return Some(NameRefClass::Type);
                 }
                 if is_base_of_outer_field_expr {
                     return Some(NameRefClass::SelectQualifiedColumnTable);
@@ -377,7 +297,7 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
             .and_then(|p| ast::Path::cast(p).and_then(|p| p.qualifier()))
         && outer_path.syntax() == inner_path.syntax()
     {
-        return Some(NameRefClass::SchemaQualifier);
+        return Some(NameRefClass::Schema);
     }
 
     // Check for function/procedure reference in CREATE OPERATOR before the type check
@@ -391,7 +311,7 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
             {
                 for outer in attr_option.syntax().ancestors() {
                     if ast::CreateOperator::can_cast(outer.kind()) {
-                        return Some(NameRefClass::OperatorFunctionRef);
+                        return Some(NameRefClass::FunctionName);
                     }
                 }
             }
@@ -404,7 +324,7 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
             in_type = true;
         }
         if in_type {
-            return Some(NameRefClass::TypeReference);
+            return Some(NameRefClass::Type);
         }
         if ast::Fetch::can_cast(ancestor.kind())
             || ast::Move::can_cast(ancestor.kind())
@@ -416,136 +336,103 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
         if ast::Execute::can_cast(ancestor.kind()) || ast::Deallocate::can_cast(ancestor.kind()) {
             return Some(NameRefClass::PreparedStatement);
         }
-        if ast::Notify::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::NotifyChannel);
-        }
-        if ast::Unlisten::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::UnlistenChannel);
-        }
-        if ast::DropTable::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropTable);
-        }
-        if ast::DropForeignTable::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropForeignTable);
-        }
-        if ast::Truncate::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::TruncateTable);
-        }
-        if ast::Lock::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::LockTable);
-        }
-        if ast::Vacuum::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::VacuumTable);
-        }
-        if ast::AlterColumn::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::AlterTableColumn);
-        }
-        if ast::DropColumn::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::AlterTableDropColumn);
-        }
-        if ast::AlterTable::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::AlterTable);
-        }
-        if ast::OnTable::can_cast(ancestor.kind()) {
+        if ast::Notify::can_cast(ancestor.kind()) || ast::Unlisten::can_cast(ancestor.kind()) {
+            return Some(NameRefClass::Channel);
+        }
+        if ast::DropTable::can_cast(ancestor.kind())
+            || ast::DropForeignTable::can_cast(ancestor.kind())
+            || ast::Truncate::can_cast(ancestor.kind())
+            || ast::Lock::can_cast(ancestor.kind())
+            || ast::Vacuum::can_cast(ancestor.kind())
+            || ast::AlterTable::can_cast(ancestor.kind())
+            || ast::OnTable::can_cast(ancestor.kind())
+            || ast::AttachPartition::can_cast(ancestor.kind())
+            || ast::Table::can_cast(ancestor.kind())
+            || ast::Inherits::can_cast(ancestor.kind())
+            || ast::PartitionOf::can_cast(ancestor.kind())
+        {
             return Some(NameRefClass::Table);
         }
-        if ast::AttachPartition::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::AttachPartition);
+        if ast::AlterColumn::can_cast(ancestor.kind()) || ast::DropColumn::can_cast(ancestor.kind())
+        {
+            return Some(NameRefClass::AlterColumn);
         }
-        if ast::Refresh::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::RefreshMaterializedView);
+        if let Some(comment_on) = ast::CommentOn::cast(ancestor.clone()) {
+            if comment_on.table_token().is_some() {
+                return Some(NameRefClass::Table);
+            }
+            if comment_on.column_token().is_some() {
+                return Some(NameRefClass::QualifiedColumn);
+            }
         }
         if let Some(reindex) = ast::Reindex::cast(ancestor.clone()) {
             if reindex.table_token().is_some() {
-                return Some(NameRefClass::ReindexTable);
+                return Some(NameRefClass::Table);
             }
             if reindex.index_token().is_some() {
-                return Some(NameRefClass::ReindexIndex);
+                return Some(NameRefClass::Index);
             }
             if reindex.schema_token().is_some() {
-                return Some(NameRefClass::ReindexSchema);
+                return Some(NameRefClass::Schema);
             }
-            if reindex.database_token().is_some() {
-                return Some(NameRefClass::ReindexDatabase);
+            if reindex.database_token().is_some() || reindex.system_token().is_some() {
+                return Some(NameRefClass::Database);
             }
-            if reindex.system_token().is_some() {
-                return Some(NameRefClass::ReindexSystem);
-            }
-        }
-        if ast::Table::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::Table);
         }
         if ast::DropIndex::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropIndex);
+            return Some(NameRefClass::Index);
         }
-        if ast::DropType::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropType);
+        if ast::DropType::can_cast(ancestor.kind()) || ast::DropDomain::can_cast(ancestor.kind()) {
+            return Some(NameRefClass::Type);
         }
-        if ast::DropDomain::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropDomain);
-        }
-        if ast::DropView::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropView);
-        }
-        if ast::DropMaterializedView::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropMaterializedView);
+        if ast::DropView::can_cast(ancestor.kind())
+            || ast::DropMaterializedView::can_cast(ancestor.kind())
+            || ast::Refresh::can_cast(ancestor.kind())
+        {
+            return Some(NameRefClass::View);
         }
         if ast::DropSequence::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropSequence);
+            return Some(NameRefClass::Sequence);
         }
         if ast::DropTrigger::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropTrigger);
+            return Some(NameRefClass::Trigger);
         }
-        if ast::DropPolicy::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropPolicy);
-        }
-        if ast::AlterPolicy::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::AlterPolicy);
+        if ast::DropPolicy::can_cast(ancestor.kind()) || ast::AlterPolicy::can_cast(ancestor.kind())
+        {
+            return Some(NameRefClass::Policy);
         }
-        if ast::DropEventTrigger::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropEventTrigger);
+        if ast::DropEventTrigger::can_cast(ancestor.kind())
+            || ast::AlterEventTrigger::can_cast(ancestor.kind())
+        {
+            return Some(NameRefClass::EventTrigger);
         }
         if ast::DropDatabase::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropDatabase);
-        }
-        if ast::DropServer::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropServer);
-        }
-        if ast::AlterServer::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::AlterServer);
-        }
-        if ast::AlterEventTrigger::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::AlterEventTrigger);
-        }
-        if ast::CreateServer::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::CreateServer);
-        }
-        if ast::DropExtension::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropExtension);
-        }
-        if ast::AlterExtension::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::AlterExtension);
+            return Some(NameRefClass::Database);
         }
-        if ast::AlterRole::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::AlterRole);
-        }
-        if ast::DropRole::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropRole);
+        if ast::DropServer::can_cast(ancestor.kind())
+            || ast::AlterServer::can_cast(ancestor.kind())
+            || ast::CreateServer::can_cast(ancestor.kind())
+            || ast::ServerName::can_cast(ancestor.kind())
+        {
+            return Some(NameRefClass::Server);
         }
-        if ast::SetRole::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::SetRole);
+        if ast::DropExtension::can_cast(ancestor.kind())
+            || ast::AlterExtension::can_cast(ancestor.kind())
+        {
+            return Some(NameRefClass::Extension);
         }
-        if ast::RoleRef::can_cast(ancestor.kind()) {
+        if ast::AlterRole::can_cast(ancestor.kind())
+            || ast::DropRole::can_cast(ancestor.kind())
+            || ast::SetRole::can_cast(ancestor.kind())
+            || ast::RoleRef::can_cast(ancestor.kind())
+        {
             return Some(NameRefClass::Role);
         }
-        if ast::ServerName::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::ForeignTableServerName);
-        }
         if let Some(sequence_option) = ast::SequenceOption::cast(ancestor.clone())
             && sequence_option.owned_token().is_some()
             && sequence_option.by_token().is_some()
         {
-            return Some(NameRefClass::SequenceOwnedByColumn);
+            return Some(NameRefClass::QualifiedColumn);
         }
         if ast::DropTablespace::can_cast(ancestor.kind())
             || ast::Tablespace::can_cast(ancestor.kind())
@@ -576,10 +463,10 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
                         .text_range()
                         .contains_range(name_ref.syntax().text_range())
                 {
-                    return Some(NameRefClass::ForeignKeyLocalColumn);
+                    return Some(NameRefClass::ConstraintColumn);
                 }
                 if in_set_null_columns {
-                    return Some(NameRefClass::ForeignKeyLocalColumn);
+                    return Some(NameRefClass::ConstraintColumn);
                 }
             } else {
                 return Some(NameRefClass::ForeignKeyTable);
@@ -604,89 +491,80 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
                 return Some(NameRefClass::ForeignKeyTable);
             }
         }
-        if ast::CheckConstraint::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::CheckConstraintColumn);
-        }
         if ast::CreatePolicy::can_cast(ancestor.kind())
             || ast::AlterPolicy::can_cast(ancestor.kind())
         {
             return Some(NameRefClass::PolicyColumn);
         }
-        if ast::GeneratedConstraint::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::GeneratedColumn);
-        }
-        if in_column_list && ast::UniqueConstraint::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::UniqueConstraintColumn);
-        }
-        if in_column_list && ast::PrimaryKeyConstraint::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::PrimaryKeyConstraintColumn);
+        if ast::CheckConstraint::can_cast(ancestor.kind())
+            || ast::GeneratedConstraint::can_cast(ancestor.kind())
+            || ast::NotNullConstraint::can_cast(ancestor.kind())
+        {
+            return Some(NameRefClass::ConstraintColumn);
         }
-        if ast::NotNullConstraint::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::NotNullConstraintColumn);
+        if in_column_list
+            && (ast::UniqueConstraint::can_cast(ancestor.kind())
+                || ast::PrimaryKeyConstraint::can_cast(ancestor.kind()))
+        {
+            return Some(NameRefClass::ConstraintColumn);
         }
         if (in_constraint_exclusion_list
             || in_constraint_include_clause
             || in_constraint_where_clause)
             && ast::ExcludeConstraint::can_cast(ancestor.kind())
         {
-            return Some(NameRefClass::ExcludeConstraintColumn);
+            return Some(NameRefClass::ConstraintColumn);
         }
         if ast::LikeClause::can_cast(ancestor.kind()) {
             return Some(NameRefClass::LikeTable);
         }
-        if ast::Inherits::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::InheritsTable);
-        }
         if ast::CastExpr::can_cast(ancestor.kind()) && in_type {
-            return Some(NameRefClass::TypeReference);
+            return Some(NameRefClass::Type);
         }
         if ast::DropFunction::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropFunction);
+            return Some(NameRefClass::Function);
         }
         if ast::DropAggregate::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropAggregate);
+            return Some(NameRefClass::Aggregate);
         }
         if ast::DropProcedure::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropProcedure);
+            return Some(NameRefClass::Procedure);
         }
         if ast::DropRoutine::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropRoutine);
+            return Some(NameRefClass::Routine);
         }
         if ast::Call::can_cast(ancestor.kind()) {
             return Some(NameRefClass::CallProcedure);
         }
         if ast::DropSchema::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::DropSchema);
+            return Some(NameRefClass::Schema);
         }
         if ast::CreateIndex::can_cast(ancestor.kind()) {
             if in_partition_item {
                 return Some(NameRefClass::CreateIndexColumn);
             }
-            return Some(NameRefClass::CreateIndex);
+            return Some(NameRefClass::Table);
         }
         if let Some(create_trigger) = ast::CreateTrigger::cast(ancestor.clone())
             && in_call_expr
             && !in_arg_list
         {
             if create_trigger.procedure_token().is_some() {
-                return Some(NameRefClass::TriggerProcedureCall);
+                return Some(NameRefClass::ProcedureCall);
             }
-            return Some(NameRefClass::TriggerFunctionCall);
+            return Some(NameRefClass::FunctionCall);
         }
         if let Some(create_event_trigger) = ast::CreateEventTrigger::cast(ancestor.clone())
             && in_call_expr
             && !in_arg_list
         {
             if create_event_trigger.procedure_token().is_some() {
-                return Some(NameRefClass::TriggerProcedureCall);
+                return Some(NameRefClass::ProcedureCall);
             }
-            return Some(NameRefClass::TriggerFunctionCall);
+            return Some(NameRefClass::FunctionCall);
         }
         if in_partition_item && ast::CreateTableLike::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::PartitionByColumn);
-        }
-        if ast::PartitionOf::can_cast(ancestor.kind()) {
-            return Some(NameRefClass::PartitionOfTable);
+            return Some(NameRefClass::ConstraintColumn);
         }
         if is_special_fn(ancestor.kind()) {
             in_special_sql_fn = true;
@@ -701,7 +579,7 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
             in_call_expr = true;
         }
         if ast::DefaultConstraint::can_cast(ancestor.kind()) && in_call_expr && !in_arg_list {
-            return Some(NameRefClass::DefaultConstraintFunctionCall);
+            return Some(NameRefClass::FunctionCall);
         }
         if ast::OnClause::can_cast(ancestor.kind()) {
             in_on_clause = true;
@@ -714,7 +592,7 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
                 return Some(NameRefClass::SelectFunctionCall);
             }
             if in_from_clause && !in_on_clause {
-                return Some(NameRefClass::SelectFromTable);
+                return Some(NameRefClass::FromTable);
             }
             // Classify as SelectColumn for target list, WHERE, ORDER BY, GROUP BY, etc.
             // (anything in SELECT except FROM clause)
@@ -736,13 +614,10 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
             in_partition_item = true;
         }
         if ast::Insert::can_cast(ancestor.kind()) {
-            if in_returning_clause {
-                return Some(NameRefClass::InsertReturningColumn);
-            }
-            if in_column_list {
+            if in_returning_clause || in_column_list {
                 return Some(NameRefClass::InsertColumn);
             }
-            return Some(NameRefClass::InsertTable);
+            return Some(NameRefClass::Table);
         }
         if ast::JoinUsingClause::can_cast(ancestor.kind()) && in_column_list {
             return Some(NameRefClass::JoinUsingColumn);
@@ -763,49 +638,34 @@ pub(crate) fn classify_name_ref(name_ref: &ast::NameRef) -> Option<NameRefClass>
             in_returning_clause = true;
         }
         if ast::Delete::can_cast(ancestor.kind()) {
-            if in_returning_clause {
-                return Some(NameRefClass::DeleteReturningColumn);
-            }
-            if in_where_clause {
-                return Some(NameRefClass::DeleteWhereColumn);
+            if in_returning_clause || in_where_clause {
+                return Some(NameRefClass::DeleteColumn);
             }
             if in_using_clause {
-                return Some(NameRefClass::DeleteUsingTable);
+                return Some(NameRefClass::FromTable);
             }
-            return Some(NameRefClass::DeleteTable);
+            return Some(NameRefClass::Table);
         }
         if ast::Update::can_cast(ancestor.kind()) {
-            if in_returning_clause {
-                return Some(NameRefClass::UpdateReturningColumn);
-            }
-            if in_where_clause {
-                return Some(NameRefClass::UpdateWhereColumn);
-            }
-            if in_set_clause {
-                return Some(NameRefClass::UpdateSetColumn);
+            if in_returning_clause || in_where_clause || in_set_clause {
+                return Some(NameRefClass::UpdateColumn);
             }
             if in_from_clause {
-                return Some(NameRefClass::UpdateFromTable);
+                return Some(NameRefClass::FromTable);
             }
-            return Some(NameRefClass::UpdateTable);
+            return Some(NameRefClass::Table);
         }
         if ast::MergeWhenClause::can_cast(ancestor.kind()) {
             in_when_clause = true;
         }
         if ast::Merge::can_cast(ancestor.kind()) {
-            if in_returning_clause {
-                return Some(NameRefClass::MergeReturningColumn);
-            }
-            if in_when_clause {
-                return Some(NameRefClass::MergeWhenColumn);
-            }
-            if in_on_clause {
-                return Some(NameRefClass::MergeOnColumn);
+            if in_when_clause || in_returning_clause || in_on_clause {
+                return Some(NameRefClass::MergeColumn);
             }
             if in_using_clause {
-                return Some(NameRefClass::MergeUsingTable);
+                return Some(NameRefClass::FromTable);
             }
-            return Some(NameRefClass::MergeTable);
+            return Some(NameRefClass::Table);
         }
     }
 
diff --git a/crates/squawk_ide/src/goto_definition.rs b/crates/squawk_ide/src/goto_definition.rs
index 4d4b2fc8..297f138e 100644
--- a/crates/squawk_ide/src/goto_definition.rs
+++ b/crates/squawk_ide/src/goto_definition.rs
@@ -6562,6 +6562,34 @@ alter table users$0 drop column email;
         ");
     }
 
+    #[test]
+    fn goto_comment_on_table() {
+        assert_snapshot!(goto("
+create table t(id int);
+comment on table t$0 is '';
+"), @r"
+          ╭▸ 
+        2 │ create table t(id int);
+          │              ─ 2. destination
+        3 │ comment on table t is '';
+          ╰╴                 ─ 1. source
+        ");
+    }
+
+    #[test]
+    fn goto_comment_on_column() {
+        assert_snapshot!(goto("
+create table t(id int);
+comment on column t.id$0 is '';
+"), @r"
+          ╭▸ 
+        2 │ create table t(id int);
+          │                ── 2. destination
+        3 │ comment on column t.id is '';
+          ╰╴                     ─ 1. source
+        ");
+    }
+
     #[test]
     fn goto_refresh_materialized_view() {
         assert_snapshot!(goto("
diff --git a/crates/squawk_ide/src/hover.rs b/crates/squawk_ide/src/hover.rs
index 0d3fc7c3..29af7d27 100644
--- a/crates/squawk_ide/src/hover.rs
+++ b/crates/squawk_ide/src/hover.rs
@@ -47,31 +47,17 @@ pub fn hover(file: &ast::SourceFile, offset: TextSize) -> Option<String> {
         match context {
             NameRefClass::CreateIndexColumn
             | NameRefClass::InsertColumn
-            | NameRefClass::DeleteWhereColumn
-            | NameRefClass::UpdateWhereColumn
-            | NameRefClass::UpdateSetColumn
-            | NameRefClass::UpdateReturningColumn
-            | NameRefClass::InsertReturningColumn
-            | NameRefClass::DeleteReturningColumn
-            | NameRefClass::MergeReturningColumn
-            | NameRefClass::MergeWhenColumn
-            | NameRefClass::MergeOnColumn
-            | NameRefClass::CheckConstraintColumn
-            | NameRefClass::GeneratedColumn
-            | NameRefClass::UniqueConstraintColumn
-            | NameRefClass::PrimaryKeyConstraintColumn
-            | NameRefClass::NotNullConstraintColumn
-            | NameRefClass::ExcludeConstraintColumn
-            | NameRefClass::PartitionByColumn
+            | NameRefClass::DeleteColumn
+            | NameRefClass::UpdateColumn
+            | NameRefClass::MergeColumn
+            | NameRefClass::ConstraintColumn
             | NameRefClass::JoinUsingColumn
             | NameRefClass::ForeignKeyColumn
-            | NameRefClass::ForeignKeyLocalColumn
-            | NameRefClass::SequenceOwnedByColumn
-            | NameRefClass::AlterTableColumn
-            | NameRefClass::AlterTableDropColumn => {
+            | NameRefClass::AlterColumn
+            | NameRefClass::QualifiedColumn => {
                 return hover_column(root, &name_ref, &binder);
             }
-            NameRefClass::TypeReference | NameRefClass::DropType | NameRefClass::DropDomain => {
+            NameRefClass::Type => {
                 return hover_type(root, &name_ref, &binder);
             }
             NameRefClass::CompositeTypeField => {
@@ -91,86 +77,51 @@ pub fn hover(file: &ast::SourceFile, offset: TextSize) -> Option<String> {
                 // Finally try as table (handles case like `select t from t;` where t is the table)
                 return hover_table(root, &name_ref, &binder);
             }
-            NameRefClass::Table
-            | NameRefClass::DropTable
-            | NameRefClass::DropForeignTable
-            | NameRefClass::DropView
-            | NameRefClass::DropMaterializedView
-            | NameRefClass::CreateIndex
-            | NameRefClass::InsertTable
+            NameRefClass::DeleteQualifiedColumnTable
+            | NameRefClass::ForeignKeyTable
+            | NameRefClass::FromTable
             | NameRefClass::InsertQualifiedColumnTable
-            | NameRefClass::DeleteTable
-            | NameRefClass::DeleteQualifiedColumnTable
-            | NameRefClass::DeleteUsingTable
-            | NameRefClass::MergeUsingTable
-            | NameRefClass::UpdateTable
-            | NameRefClass::SelectFromTable
-            | NameRefClass::UpdateFromTable
-            | NameRefClass::SelectQualifiedColumnTable
-            | NameRefClass::UpdateSetQualifiedColumnTable
+            | NameRefClass::LikeTable
             | NameRefClass::MergeQualifiedColumnTable
-            | NameRefClass::UpdateReturningQualifiedColumnTable
-            | NameRefClass::InsertReturningQualifiedColumnTable
-            | NameRefClass::DeleteReturningQualifiedColumnTable
-            | NameRefClass::MergeReturningQualifiedColumnTable
-            | NameRefClass::MergeTable
             | NameRefClass::PolicyQualifiedColumnTable
-            | NameRefClass::ForeignKeyTable
-            | NameRefClass::LikeTable
-            | NameRefClass::InheritsTable
-            | NameRefClass::PartitionOfTable
-            | NameRefClass::TruncateTable
-            | NameRefClass::LockTable
-            | NameRefClass::VacuumTable
-            | NameRefClass::AlterTable
-            | NameRefClass::ReindexTable
-            | NameRefClass::RefreshMaterializedView
-            | NameRefClass::AttachPartition => {
+            | NameRefClass::SelectQualifiedColumnTable
+            | NameRefClass::Table
+            | NameRefClass::UpdateQualifiedColumnTable
+            | NameRefClass::View => {
                 return hover_table(root, &name_ref, &binder);
             }
-            NameRefClass::DropSequence => return hover_sequence(root, &name_ref, &binder),
-            NameRefClass::DropTrigger => return hover_trigger(root, &name_ref, &binder),
-            NameRefClass::DropPolicy | NameRefClass::AlterPolicy => {
+            NameRefClass::Sequence => return hover_sequence(root, &name_ref, &binder),
+            NameRefClass::Trigger => return hover_trigger(root, &name_ref, &binder),
+            NameRefClass::Policy => {
                 return hover_policy(root, &name_ref, &binder);
             }
-            NameRefClass::DropEventTrigger | NameRefClass::AlterEventTrigger => {
+            NameRefClass::EventTrigger => {
                 return hover_event_trigger(root, &name_ref, &binder);
             }
-            NameRefClass::DropDatabase
-            | NameRefClass::ReindexDatabase
-            | NameRefClass::ReindexSystem => return hover_database(root, &name_ref, &binder),
-            NameRefClass::DropServer
-            | NameRefClass::AlterServer
-            | NameRefClass::CreateServer
-            | NameRefClass::ForeignTableServerName => {
+            NameRefClass::Database => {
+                return hover_database(root, &name_ref, &binder);
+            }
+            NameRefClass::Server => {
                 return hover_server(root, &name_ref, &binder);
             }
-            NameRefClass::DropExtension | NameRefClass::AlterExtension => {
+            NameRefClass::Extension => {
                 return hover_extension(root, &name_ref, &binder);
             }
-            NameRefClass::AlterRole
-            | NameRefClass::DropRole
-            | NameRefClass::SetRole
-            | NameRefClass::Role => {
+            NameRefClass::Role => {
                 return hover_role(root, &name_ref, &binder);
             }
             NameRefClass::Tablespace => return hover_tablespace(root, &name_ref, &binder),
-            NameRefClass::DropIndex | NameRefClass::ReindexIndex => {
+            NameRefClass::Index => {
                 return hover_index(root, &name_ref, &binder);
             }
-            NameRefClass::DropFunction
-            | NameRefClass::DefaultConstraintFunctionCall
-            | NameRefClass::TriggerFunctionCall
-            | NameRefClass::OperatorFunctionRef => {
+            NameRefClass::Function | NameRefClass::FunctionCall | NameRefClass::FunctionName => {
                 return hover_function(root, &name_ref, &binder);
             }
-            NameRefClass::DropAggregate => return hover_aggregate(root, &name_ref, &binder),
-            NameRefClass::DropProcedure
-            | NameRefClass::CallProcedure
-            | NameRefClass::TriggerProcedureCall => {
+            NameRefClass::Aggregate => return hover_aggregate(root, &name_ref, &binder),
+            NameRefClass::Procedure | NameRefClass::CallProcedure | NameRefClass::ProcedureCall => {
                 return hover_procedure(root, &name_ref, &binder);
             }
-            NameRefClass::DropRoutine => return hover_routine(root, &name_ref, &binder),
+            NameRefClass::Routine => return hover_routine(root, &name_ref, &binder),
             NameRefClass::SelectFunctionCall => {
                 // Try function first, but fall back to column if no function found
                 // (handles function-call-style column access like `select a(t)`)
@@ -179,9 +130,7 @@ pub fn hover(file: &ast::SourceFile, offset: TextSize) -> Option<String> {
                 }
                 return hover_column(root, &name_ref, &binder);
             }
-            NameRefClass::SchemaQualifier
-            | NameRefClass::DropSchema
-            | NameRefClass::ReindexSchema => {
+            NameRefClass::Schema => {
                 return hover_schema(root, &name_ref, &binder);
             }
             NameRefClass::NamedArgParameter => {
@@ -193,7 +142,7 @@ pub fn hover(file: &ast::SourceFile, offset: TextSize) -> Option<String> {
             NameRefClass::PreparedStatement => {
                 return hover_prepared_statement(root, &name_ref, &binder);
             }
-            NameRefClass::NotifyChannel | NameRefClass::UnlistenChannel => {
+            NameRefClass::Channel => {
                 return hover_channel(root, &name_ref, &binder);
             }
         }
diff --git a/crates/squawk_ide/src/resolve.rs b/crates/squawk_ide/src/resolve.rs
index 274b9611..a8474317 100644
--- a/crates/squawk_ide/src/resolve.rs
+++ b/crates/squawk_ide/src/resolve.rs
@@ -20,22 +20,7 @@ pub(crate) fn resolve_name_ref_ptrs(
     let context = classify_name_ref(name_ref)?;
 
     match context {
-        NameRefClass::DropTable
-        | NameRefClass::DropForeignTable
-        | NameRefClass::Table
-        | NameRefClass::CreateIndex
-        | NameRefClass::InsertTable
-        | NameRefClass::DeleteTable
-        | NameRefClass::UpdateTable
-        | NameRefClass::PartitionOfTable
-        | NameRefClass::InheritsTable
-        | NameRefClass::TruncateTable
-        | NameRefClass::LockTable
-        | NameRefClass::VacuumTable
-        | NameRefClass::AlterTable
-        | NameRefClass::ReindexTable
-        | NameRefClass::MergeTable
-        | NameRefClass::AttachPartition => {
+        NameRefClass::Table => {
             let path = find_containing_path(name_ref)?;
             let (table_name, schema) = extract_table_schema_from_path(&path)?;
             let position = name_ref.syntax().text_range().start();
@@ -69,14 +54,11 @@ pub(crate) fn resolve_name_ref_ptrs(
             let statement_name = Name::from_node(name_ref);
             resolve_prepared_statement_name_ptr(binder, &statement_name).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::NotifyChannel | NameRefClass::UnlistenChannel => {
+        NameRefClass::Channel => {
             let channel_name = Name::from_node(name_ref);
             resolve_channel_name_ptr(binder, &channel_name).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::SelectFromTable
-        | NameRefClass::UpdateFromTable
-        | NameRefClass::MergeUsingTable
-        | NameRefClass::DeleteUsingTable => {
+        NameRefClass::FromTable => {
             let table_name = Name::from_node(name_ref);
             let schema = if let Some(parent) = name_ref.syntax().parent()
                 && let Some(field_expr) = ast::FieldExpr::cast(parent)
@@ -104,13 +86,13 @@ pub(crate) fn resolve_name_ref_ptrs(
 
             resolve_view_name_ptr(binder, &table_name, &schema, position).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropIndex | NameRefClass::ReindexIndex => {
+        NameRefClass::Index => {
             let path = find_containing_path(name_ref)?;
             let (index_name, schema) = extract_table_schema_from_path(&path)?;
             let position = name_ref.syntax().text_range().start();
             resolve_index_name_ptr(binder, &index_name, &schema, position).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropType | NameRefClass::DropDomain | NameRefClass::TypeReference => {
+        NameRefClass::Type => {
             let (type_name, schema) = if let Some(parent) = name_ref.syntax().parent()
                 && let Some(field_expr) = ast::FieldExpr::cast(parent)
                 && field_expr
@@ -134,22 +116,20 @@ pub(crate) fn resolve_name_ref_ptrs(
             let position = name_ref.syntax().text_range().start();
             resolve_type_name_ptr(binder, &type_name, &schema, position).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropView
-        | NameRefClass::DropMaterializedView
-        | NameRefClass::RefreshMaterializedView => {
+        NameRefClass::View => {
             let path = find_containing_path(name_ref)?;
             let (view_name, schema) = extract_table_schema_from_path(&path)?;
             let position = name_ref.syntax().text_range().start();
             resolve_view_name_ptr(binder, &view_name, &schema, position).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropSequence => {
+        NameRefClass::Sequence => {
             let path = find_containing_path(name_ref)?;
             let (sequence_name, schema) = extract_table_schema_from_path(&path)?;
             let position = name_ref.syntax().text_range().start();
             resolve_sequence_name_ptr(binder, &sequence_name, &schema, position)
                 .map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropTrigger => {
+        NameRefClass::Trigger => {
             let drop_trigger = name_ref
                 .syntax()
                 .ancestors()
@@ -167,7 +147,7 @@ pub(crate) fn resolve_name_ref_ptrs(
             resolve_trigger_name_ptr(binder, &trigger_name, &schema, position, Some(table_name))
                 .map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropPolicy | NameRefClass::AlterPolicy => {
+        NameRefClass::Policy => {
             let (policy_name, on_table) = name_ref.syntax().ancestors().find_map(|a| {
                 if let Some(policy) = ast::DropPolicy::cast(a.clone()) {
                     Some((policy.name_ref(), policy.on_table()))
@@ -182,40 +162,28 @@ pub(crate) fn resolve_name_ref_ptrs(
             resolve_policy_name_ptr(binder, &policy_name, &schema, position, table_name)
                 .map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropEventTrigger | NameRefClass::AlterEventTrigger => {
+        NameRefClass::EventTrigger => {
             let event_trigger_name = Name::from_node(name_ref);
             resolve_event_trigger_name_ptr(binder, &event_trigger_name).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::ReindexDatabase
-        | NameRefClass::ReindexSystem
-        | NameRefClass::DropDatabase => {
+        NameRefClass::Database => {
             let database_name = Name::from_node(name_ref);
             resolve_database_name_ptr(binder, &database_name).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropServer
-        | NameRefClass::AlterServer
-        | NameRefClass::CreateServer
-        | NameRefClass::ForeignTableServerName => {
+        NameRefClass::Server => {
             let server_name = Name::from_node(name_ref);
             resolve_server_name_ptr(binder, &server_name).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropExtension | NameRefClass::AlterExtension => {
+        NameRefClass::Extension => {
             let extension_name = Name::from_node(name_ref);
             resolve_extension_name_ptr(binder, &extension_name).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::AlterRole
-        | NameRefClass::DropRole
-        | NameRefClass::SetRole
-        | NameRefClass::Role => {
+        NameRefClass::Role => {
             let role_name = Name::from_node(name_ref);
             resolve_role_name_ptr(binder, &role_name).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::SequenceOwnedByColumn => {
-            let sequence_option = name_ref
-                .syntax()
-                .ancestors()
-                .find_map(ast::SequenceOption::cast)?;
-            let path = sequence_option.path()?;
+        NameRefClass::QualifiedColumn => {
+            let path = name_ref.syntax().ancestors().find_map(ast::Path::cast)?;
             let column_name = Name::from_node(name_ref);
             let table_path = path.qualifier()?;
             resolve_column_for_path(binder, root, &table_path, column_name)
@@ -251,14 +219,7 @@ pub(crate) fn resolve_name_ref_ptrs(
             let column_name = Name::from_node(name_ref);
             resolve_column_for_path(binder, root, &path, column_name).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::GeneratedColumn
-        | NameRefClass::CheckConstraintColumn
-        | NameRefClass::UniqueConstraintColumn
-        | NameRefClass::PrimaryKeyConstraintColumn
-        | NameRefClass::NotNullConstraintColumn
-        | NameRefClass::ExcludeConstraintColumn
-        | NameRefClass::PartitionByColumn
-        | NameRefClass::ForeignKeyLocalColumn => {
+        NameRefClass::ConstraintColumn => {
             let create_table = name_ref
                 .syntax()
                 .ancestors()
@@ -305,7 +266,7 @@ pub(crate) fn resolve_name_ref_ptrs(
             let position = name_ref.syntax().text_range().start();
             resolve_table_name_ptr(binder, &table_name, &schema, position).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropFunction => {
+        NameRefClass::Function => {
             let function_sig = name_ref
                 .syntax()
                 .ancestors()
@@ -317,7 +278,7 @@ pub(crate) fn resolve_name_ref_ptrs(
             resolve_function(binder, &function_name, &schema, params.as_deref(), position)
                 .map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropAggregate => {
+        NameRefClass::Aggregate => {
             let aggregate = name_ref
                 .syntax()
                 .ancestors()
@@ -335,7 +296,7 @@ pub(crate) fn resolve_name_ref_ptrs(
             )
             .map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropProcedure => {
+        NameRefClass::Procedure => {
             let function_sig = name_ref
                 .syntax()
                 .ancestors()
@@ -353,7 +314,7 @@ pub(crate) fn resolve_name_ref_ptrs(
             )
             .map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropRoutine => {
+        NameRefClass::Routine => {
             let function_sig = name_ref
                 .syntax()
                 .ancestors()
@@ -386,11 +347,11 @@ pub(crate) fn resolve_name_ref_ptrs(
             resolve_procedure(binder, &procedure_name, &schema, None, position)
                 .map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DropSchema | NameRefClass::SchemaQualifier => {
+        NameRefClass::Schema => {
             let schema_name = Name::from_node(name_ref);
             resolve_schema(binder, &schema_name).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DefaultConstraintFunctionCall | NameRefClass::TriggerFunctionCall => {
+        NameRefClass::FunctionCall => {
             let schema = if let Some(parent_node) = name_ref.syntax().parent()
                 && let Some(field_expr) = ast::FieldExpr::cast(parent_node)
             {
@@ -405,7 +366,7 @@ pub(crate) fn resolve_name_ref_ptrs(
             resolve_function(binder, &function_name, &schema, None, position)
                 .map(|ptr| smallvec![ptr])
         }
-        NameRefClass::TriggerProcedureCall => {
+        NameRefClass::ProcedureCall => {
             let schema = if let Some(parent_node) = name_ref.syntax().parent()
                 && let Some(field_expr) = ast::FieldExpr::cast(parent_node)
             {
@@ -421,7 +382,7 @@ pub(crate) fn resolve_name_ref_ptrs(
             resolve_procedure(binder, &procedure_name, &schema, None, position)
                 .map(|ptr| smallvec![ptr])
         }
-        NameRefClass::OperatorFunctionRef => {
+        NameRefClass::FunctionName => {
             let path_type = name_ref
                 .syntax()
                 .ancestors()
@@ -490,52 +451,34 @@ pub(crate) fn resolve_name_ref_ptrs(
         NameRefClass::InsertQualifiedColumnTable => {
             resolve_insert_table_name_ptr(binder, name_ref).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DeleteWhereColumn | NameRefClass::DeleteReturningColumn => {
+        NameRefClass::DeleteColumn => {
             resolve_delete_column_ptr(binder, root, name_ref).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::DeleteQualifiedColumnTable
-        | NameRefClass::DeleteReturningQualifiedColumnTable => {
+        NameRefClass::DeleteQualifiedColumnTable => {
             resolve_delete_table_name_ptr(binder, name_ref).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::UpdateWhereColumn | NameRefClass::UpdateSetColumn => {
+        NameRefClass::UpdateColumn => {
             resolve_update_column_ptr(binder, root, name_ref).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::UpdateReturningQualifiedColumnTable
-        | NameRefClass::UpdateSetQualifiedColumnTable => {
+        NameRefClass::UpdateQualifiedColumnTable => {
             resolve_update_table_name_ptr(binder, name_ref).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::UpdateReturningColumn => {
-            resolve_update_column_ptr(binder, root, name_ref).map(|ptr| smallvec![ptr])
-        }
-        NameRefClass::InsertReturningColumn => {
-            resolve_insert_column_ptr(binder, root, name_ref).map(|ptr| smallvec![ptr])
-        }
-        NameRefClass::MergeWhenColumn
-        | NameRefClass::MergeReturningColumn
-        | NameRefClass::MergeOnColumn => {
+        NameRefClass::MergeColumn => {
             resolve_merge_column_ptr(binder, root, name_ref).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::MergeQualifiedColumnTable
-        | NameRefClass::MergeReturningQualifiedColumnTable => {
+        NameRefClass::MergeQualifiedColumnTable => {
             resolve_merge_table_name_ptr(binder, name_ref).map(|ptr| smallvec![ptr])
         }
-        NameRefClass::InsertReturningQualifiedColumnTable => {
-            resolve_insert_table_name_ptr(binder, name_ref).map(|ptr| smallvec![ptr])
-        }
         NameRefClass::JoinUsingColumn => resolve_join_using_columns(binder, root, name_ref),
-        NameRefClass::AlterTableColumn | NameRefClass::AlterTableDropColumn => {
+        NameRefClass::AlterColumn => {
             let column_name = Name::from_node(name_ref);
             let alter_table = name_ref
                 .syntax()
                 .ancestors()
                 .find_map(ast::AlterTable::cast)?;
-            let path = alter_table.relation_name()?.path()?;
-            resolve_column_for_path(binder, root, &path, column_name).map(|ptr| smallvec![ptr])
-        }
-        NameRefClass::ReindexSchema => {
-            let path = find_containing_path(name_ref)?;
-            let schema_name = extract_table_name(&path)?;
-            resolve_schema(binder, &schema_name).map(|ptr| smallvec![ptr])
+            let table_path = alter_table.relation_name()?.path()?;
+            resolve_column_for_path(binder, root, &table_path, column_name)
+                .map(|ptr| smallvec![ptr])
         }
     }
 }
diff --git a/crates/squawk_syntax/src/ast/generated/nodes.rs b/crates/squawk_syntax/src/ast/generated/nodes.rs
index bd6a0f32..f4b522dd 100644
--- a/crates/squawk_syntax/src/ast/generated/nodes.rs
+++ b/crates/squawk_syntax/src/ast/generated/nodes.rs
@@ -2669,6 +2669,18 @@ pub struct CommentOn {
     pub(crate) syntax: SyntaxNode,
 }
 impl CommentOn {
+    #[inline]
+    pub fn aggregate(&self) -> Option<Aggregate> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn cast_sig(&self) -> Option<CastSig> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn function_sig(&self) -> Option<FunctionSig> {
+        support::child(&self.syntax)
+    }
     #[inline]
     pub fn literal(&self) -> Option<Literal> {
         support::child(&self.syntax)
@@ -2678,37 +2690,245 @@ impl CommentOn {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn op(&self) -> Option<Op> {
+        support::child(&self.syntax)
+    }
+    #[inline]
     pub fn path(&self) -> Option<Path> {
         support::child(&self.syntax)
     }
     #[inline]
+    pub fn ty(&self) -> Option<Type> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn using_method(&self) -> Option<UsingMethod> {
+        support::child(&self.syntax)
+    }
+    #[inline]
+    pub fn l_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::L_PAREN)
+    }
+    #[inline]
+    pub fn r_paren_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::R_PAREN)
+    }
+    #[inline]
+    pub fn comma_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COMMA)
+    }
+    #[inline]
+    pub fn access_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ACCESS_KW)
+    }
+    #[inline]
+    pub fn aggregate_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::AGGREGATE_KW)
+    }
+    #[inline]
+    pub fn cast_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CAST_KW)
+    }
+    #[inline]
+    pub fn class_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CLASS_KW)
+    }
+    #[inline]
+    pub fn collation_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COLLATION_KW)
+    }
+    #[inline]
+    pub fn column_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::COLUMN_KW)
+    }
+    #[inline]
     pub fn comment_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::COMMENT_KW)
     }
     #[inline]
+    pub fn configuration_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONFIGURATION_KW)
+    }
+    #[inline]
     pub fn constraint_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::CONSTRAINT_KW)
     }
     #[inline]
+    pub fn conversion_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::CONVERSION_KW)
+    }
+    #[inline]
+    pub fn data_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DATA_KW)
+    }
+    #[inline]
+    pub fn database_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DATABASE_KW)
+    }
+    #[inline]
+    pub fn dictionary_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::DICTIONARY_KW)
+    }
+    #[inline]
     pub fn domain_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::DOMAIN_KW)
     }
     #[inline]
+    pub fn event_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EVENT_KW)
+    }
+    #[inline]
+    pub fn extension_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::EXTENSION_KW)
+    }
+    #[inline]
+    pub fn family_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FAMILY_KW)
+    }
+    #[inline]
+    pub fn for_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOR_KW)
+    }
+    #[inline]
+    pub fn foreign_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FOREIGN_KW)
+    }
+    #[inline]
+    pub fn function_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::FUNCTION_KW)
+    }
+    #[inline]
+    pub fn index_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::INDEX_KW)
+    }
+    #[inline]
     pub fn is_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::IS_KW)
     }
     #[inline]
+    pub fn language_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LANGUAGE_KW)
+    }
+    #[inline]
+    pub fn large_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::LARGE_KW)
+    }
+    #[inline]
+    pub fn materialized_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::MATERIALIZED_KW)
+    }
+    #[inline]
+    pub fn method_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::METHOD_KW)
+    }
+    #[inline]
     pub fn null_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::NULL_KW)
     }
     #[inline]
+    pub fn object_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OBJECT_KW)
+    }
+    #[inline]
     pub fn on_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::ON_KW)
     }
     #[inline]
+    pub fn operator_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::OPERATOR_KW)
+    }
+    #[inline]
+    pub fn parser_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PARSER_KW)
+    }
+    #[inline]
+    pub fn policy_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::POLICY_KW)
+    }
+    #[inline]
+    pub fn procedural_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PROCEDURAL_KW)
+    }
+    #[inline]
+    pub fn procedure_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PROCEDURE_KW)
+    }
+    #[inline]
+    pub fn publication_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::PUBLICATION_KW)
+    }
+    #[inline]
+    pub fn role_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROLE_KW)
+    }
+    #[inline]
+    pub fn routine_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::ROUTINE_KW)
+    }
+    #[inline]
+    pub fn rule_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::RULE_KW)
+    }
+    #[inline]
+    pub fn schema_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SCHEMA_KW)
+    }
+    #[inline]
+    pub fn search_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SEARCH_KW)
+    }
+    #[inline]
+    pub fn sequence_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SEQUENCE_KW)
+    }
+    #[inline]
+    pub fn server_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SERVER_KW)
+    }
+    #[inline]
+    pub fn statistics_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::STATISTICS_KW)
+    }
+    #[inline]
+    pub fn subscription_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::SUBSCRIPTION_KW)
+    }
+    #[inline]
     pub fn table_token(&self) -> Option<SyntaxToken> {
         support::token(&self.syntax, SyntaxKind::TABLE_KW)
     }
+    #[inline]
+    pub fn tablespace_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TABLESPACE_KW)
+    }
+    #[inline]
+    pub fn template_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TEMPLATE_KW)
+    }
+    #[inline]
+    pub fn text_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TEXT_KW)
+    }
+    #[inline]
+    pub fn transform_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRANSFORM_KW)
+    }
+    #[inline]
+    pub fn trigger_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TRIGGER_KW)
+    }
+    #[inline]
+    pub fn type_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::TYPE_KW)
+    }
+    #[inline]
+    pub fn view_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::VIEW_KW)
+    }
+    #[inline]
+    pub fn wrapper_token(&self) -> Option<SyntaxToken> {
+        support::token(&self.syntax, SyntaxKind::WRAPPER_KW)
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/squawk_syntax/src/postgresql.ungram b/crates/squawk_syntax/src/postgresql.ungram
index a3c75728..93b57edc 100644
--- a/crates/squawk_syntax/src/postgresql.ungram
+++ b/crates/squawk_syntax/src/postgresql.ungram
@@ -2121,9 +2121,48 @@ Analyze =
 CommentOn =
   'comment' 'on'
   (
-    // TODO: I think we'll need proper nodes for each variant of comment on
-    'table' Path
+    'access' 'method' Path
+  | 'aggregate' Aggregate
+  | 'cast' CastSig
+  | 'collation' Path
+  | 'column' Path
   | 'constraint' NameRef 'on' 'domain'? Path
+  | 'conversion' Path
+  | 'database' Path
+  | 'domain' Path
+  | 'event' 'trigger' Path
+  | 'extension' Path
+  | 'foreign' 'data' 'wrapper' Path
+  | 'foreign' 'table' Path
+  | 'function' FunctionSig
+  | 'index' Path
+  | 'large' 'object' Literal
+  | 'materialized' 'view' Path
+  | 'operator' Op '(' Type ',' Type ')'
+  | 'operator' 'class' Path UsingMethod
+  | 'operator' 'family' Path UsingMethod
+  | 'policy' NameRef 'on' Path
+  | 'procedural'? 'language' Path
+  | 'procedure' FunctionSig
+  | 'publication' Path
+  | 'role' Path
+  | 'routine' FunctionSig
+  | 'rule' NameRef 'on' Path
+  | 'schema' Path
+  | 'sequence' Path
+  | 'server' Path
+  | 'statistics' Path
+  | 'subscription' Path
+  | 'table' Path
+  | 'tablespace' Path
+  | 'text' 'search' 'configuration' Path
+  | 'text' 'search' 'dictionary' Path
+  | 'text' 'search' 'parser' Path
+  | 'text' 'search' 'template' Path
+  | 'transform' 'for' Type 'language' NameRef
+  | 'trigger' NameRef 'on' Path
+  | 'type' Path
+  | 'view' Path
   )
   'is'
   ('null' | Literal)