awesome stuffings!

Author: juleswritescode

crates/pgls_completions/src/relevance/filtering.rs

@@ -308,17 +308,25 @@ impl CompletionFilter<'_> {
     }
 
     fn check_mentioned_schema_or_alias(&self, ctx: &TreesitterContext) -> Option<()> {
-        let second_qualifier = match ctx.tail_qualifier_sanitized() {
+        let tail_qualifier = match ctx.tail_qualifier_sanitized() {
             Some(q) => q,
             None => return Some(()), // no qualifier = this check passes
         };
 
         let matches = match self.data {
-            CompletionRelevanceData::Table(table) => table.schema == second_qualifier,
-            CompletionRelevanceData::Function(f) => f.schema == second_qualifier,
-            CompletionRelevanceData::Column(col) => ctx
-                .get_mentioned_table_for_alias(&second_qualifier)
-                .is_some_and(|t| t == &col.table_name),
+            CompletionRelevanceData::Table(table) => table.schema == tail_qualifier,
+            CompletionRelevanceData::Function(f) => f.schema == tail_qualifier,
+            CompletionRelevanceData::Column(col) => {
+                let table = ctx
+                    .get_mentioned_table_for_alias(&tail_qualifier)
+                    .unwrap_or(&tail_qualifier);
+
+                if let Some(schema) = ctx.head_qualifier_sanitized() {
+                    col.schema_name == schema.as_str() && col.table_name == table.as_str()
+                } else {
+                    col.table_name == table.as_str()
+                }
+            }
 
             // we should never allow schema suggestions if there already was one.
             CompletionRelevanceData::Schema(_) => false,

crates/pgls_completions/src/relevance/scoring.rs

@@ -149,15 +149,15 @@ impl CompletionScore<'_> {
             Some(wn) => wn,
         };
 
-        let has_single_qualifier = ctx.has_single_qualifier();
+        let has_qualifier = ctx.has_any_qualifier();
         let has_node_text = ctx
             .get_node_under_cursor_content()
             .is_some_and(|txt| !sanitization::is_sanitized_token(txt.as_str()));
 
         self.score += match self.data {
             CompletionRelevanceData::Table(_) => match wrapping_node {
-                WrappingNode::Relation if has_single_qualifier => 15,
-                WrappingNode::Relation if !has_single_qualifier => 10,
+                WrappingNode::Relation if has_qualifier => 15,
+                WrappingNode::Relation if !has_qualifier => 10,
                 WrappingNode::BinaryExpression => 5,
                 _ => -50,
             },
@@ -172,8 +172,8 @@ impl CompletionScore<'_> {
                 _ => -15,
             },
             CompletionRelevanceData::Schema(_) => match wrapping_node {
-                WrappingNode::Relation if !has_single_qualifier && !has_node_text => 15,
-                WrappingNode::Relation if !has_single_qualifier && has_node_text => 0,
+                WrappingNode::Relation if !has_qualifier && !has_node_text => 15,
+                WrappingNode::Relation if !has_qualifier && has_node_text => 0,
                 _ => -50,
             },
             CompletionRelevanceData::Policy(_) => 0,
@@ -191,11 +191,24 @@ impl CompletionScore<'_> {
     }
 
     fn check_matches_schema(&mut self, ctx: &TreesitterContext) {
-        let schema_from_qualifier = match ctx.tail_qualifier_sanitized() {
-            Some(s) => s,
-            None => return,
+        let schema_from_qualifier = match self.data {
+            CompletionRelevanceData::Table(_) | CompletionRelevanceData::Function(_) => {
+                ctx.tail_qualifier_sanitized()
+            }
+
+            CompletionRelevanceData::Column(_) | CompletionRelevanceData::Policy(_) => {
+                ctx.head_qualifier_sanitized()
+            }
+
+            CompletionRelevanceData::Schema(_) | CompletionRelevanceData::Role(_) => None,
         };
 
+        if schema_from_qualifier.is_none() {
+            return;
+        }
+
+        let schema_from_qualifier = schema_from_qualifier.unwrap();
+
         let data_schema = match self.get_schema_name() {
             Some(s) => s,
             None => return,

crates/pgls_hover/src/hoverables/column.rs

@@ -1,4 +1,4 @@
-use std::fmt::Write;
+u>se std::fmt::Write;
 
 use pgls_schema_cache::{Column, SchemaCache};
 use pgls_treesitter::TreesitterContext;
@@ -74,12 +74,18 @@ impl ContextualPriority for Column {
         let mut score = 0.0;
 
         // high score if we match the specific alias or table being referenced in the cursor context
-        if let Some(table_or_alias) = ctx.identifier_qualifiers.1.as_ref() {
-            if table_or_alias.replace('"', "") == self.table_name.as_str() {
+ 
+
+        if let Some(table_or_alias) = ctx.tail_qualifier_sanitized() {
+            let table = ctx.get_mentioned_table_for_alias(&table_or_alias).unwrap_or(&table_or_alias);
+
+            if table == self.table_name.as_str() {
                 score += 250.0;
-            } else if let Some(table_name) = ctx.get_mentioned_table_for_alias(table_or_alias) {
-                if table_name == self.table_name.as_str() {
-                    score += 250.0;
+            }  
+
+            if let Some(schema) = ctx.head_qualifier_sanitized() {
+                if schema == self.schema_name.as_str() {
+                    score += 50.0;
                 }
             }
         }

crates/pgls_treesitter/src/context/mod.rs

@@ -781,8 +781,8 @@ impl<'a> TreesitterContext<'a> {
     }
 
     /// Returns the head qualifier (leftmost), sanitized (quotes removed)
-    /// For `schema.table.column`: returns `Some("schema")`
-    /// For `table.column`: returns `None`
+    /// For `schema.table.<column>`: returns `Some("schema")`
+    /// For `table.<column>`: returns `None`
     pub fn head_qualifier_sanitized(&self) -> Option<String> {
         self.identifier_qualifiers
             .0
@@ -791,8 +791,8 @@ impl<'a> TreesitterContext<'a> {
     }
 
     /// Returns the tail qualifier (rightmost), sanitized (quotes removed)
-    /// For `schema.table.column`: returns `Some("table")`
-    /// For `table.column`: returns `Some("table")`
+    /// For `schema.table.<column>`: returns `Some("table")`
+    /// For `table.<column>`: returns `Some("table")`
     pub fn tail_qualifier_sanitized(&self) -> Option<String> {
         self.identifier_qualifiers
             .1
@@ -802,12 +802,13 @@ impl<'a> TreesitterContext<'a> {
 
     /// Returns true if there is at least one qualifier present
     pub fn has_any_qualifier(&self) -> bool {
-        self.identifier_qualifiers.1.is_some()
-    }
+        match self.identifier_qualifiers {
+            (Some(_), Some(_)) => true,
+            (None, Some(_)) => true,
+            (None, None) => false,
 
-    /// Returns true if there is exactly one qualifier (tail only, no head)
-    pub fn has_single_qualifier(&self) -> bool {
-        matches!(self.identifier_qualifiers, (None, Some(_)))
+            (Some(_), None) => unreachable!(),
+        }
     }
 }