fixie fixie

Author: juleswritescode

crates/pgls_completions/src/providers/helper.rs

@@ -45,7 +45,7 @@ pub(crate) fn with_schema_or_alias(
     item_name: &str,
     schema_or_alias_name: Option<&str>,
 ) -> String {
-    let is_already_prefixed_with_schema_name = matches!(ctx.identifier_qualifiers, (_, Some(_)));
+    let is_already_prefixed_with_schema_name = ctx.has_any_qualifier();
 
     let with_quotes = node_text_surrounded_by_quotes(ctx);
     let single_leading_quote = only_leading_quote(ctx);

crates/pgls_completions/src/relevance/filtering.rs

@@ -225,7 +225,7 @@ impl CompletionFilter<'_> {
                             (ctx.matches_ancestor_history(&[
                                 "grantable_on_table",
                                 "object_reference",
-                            ]) && ctx.identifier_qualifiers.1.is_none())
+                            ]) && !ctx.has_any_qualifier())
                                 || ctx.matches_ancestor_history(&["grantable_on_all"])
                         }
 
@@ -308,16 +308,10 @@ impl CompletionFilter<'_> {
     }
 
     fn check_mentioned_schema_or_alias(&self, ctx: &TreesitterContext) -> Option<()> {
-        if ctx.identifier_qualifiers.1.is_none() {
-            return Some(());
-        }
-
-        let second_qualifier = ctx
-            .identifier_qualifiers
-            .1
-            .as_ref()
-            .unwrap()
-            .replace('"', "");
+        let second_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,

crates/pgls_completions/src/relevance/scoring.rs

@@ -79,7 +79,7 @@ impl CompletionScore<'_> {
         };
 
         let has_mentioned_tables = ctx.has_any_mentioned_relations();
-        let has_qualifier = ctx.identifier_qualifiers.1.is_some();
+        let has_qualifier = ctx.has_any_qualifier();
 
         self.score += match self.data {
             CompletionRelevanceData::Table(_) => match clause_type {
@@ -149,7 +149,7 @@ impl CompletionScore<'_> {
             Some(wn) => wn,
         };
 
-        let has_single_qualifier = matches!(ctx.identifier_qualifiers, (None, Some(_)));
+        let has_single_qualifier = ctx.has_single_qualifier();
         let has_node_text = ctx
             .get_node_under_cursor_content()
             .is_some_and(|txt| !sanitization::is_sanitized_token(txt.as_str()));
@@ -191,27 +191,20 @@ impl CompletionScore<'_> {
     }
 
     fn check_matches_schema(&mut self, ctx: &TreesitterContext) {
-        if matches!(ctx.identifier_qualifiers, (None, None)) {
-            return;
-        }
-
-        let schema_from_qualifier = ctx
-            .identifier_qualifiers
-            .1
-            .as_ref()
-            .map(|n| n.replace('"', ""));
+        let schema_from_qualifier = match ctx.tail_qualifier_sanitized() {
+            Some(s) => s,
+            None => return,
+        };
 
         let data_schema = match self.get_schema_name() {
             Some(s) => s,
             None => return,
         };
 
-        if let Some(schema_name) = schema_from_qualifier {
-            if schema_name == data_schema {
-                self.score += 25;
-            } else {
-                self.score -= 10;
-            }
+        if schema_from_qualifier == data_schema {
+            self.score += 25;
+        } else {
+            self.score -= 10;
         }
     }
 

crates/pgls_treesitter/src/context/mod.rs

@@ -101,16 +101,14 @@ pub struct TreesitterContext<'a> {
     pub text: &'a str,
     pub position: usize,
 
-    /// Tuple containing up to two qualifiers for identifier-node under the cursor.
+    /// Tuple containing up to two qualifiers for identifier-node under the cursor: (head, tail)
     ///
     /// The qualifiers represent different "parents" based on the context, for example:
+    /// - `column` -> (None, None)
     /// - `table.column` -> (None, Some("table"))
     /// - `alias.column` -> (None, Some("alias"))
     /// - `schema.table` -> (None, Some("schema"))
     /// - `schema.table.column` -> (Some("schema"), Some("table"))
-    ///
-    /// Without any qualifiers:
-    /// - `column` -> (None, None)
     /// - `table` -> (None, None)
     pub identifier_qualifiers: (Option<String>, Option<String>),
 
@@ -781,6 +779,36 @@ impl<'a> TreesitterContext<'a> {
     pub fn has_mentioned_columns(&self) -> bool {
         !self.mentioned_columns.is_empty()
     }
+
+    /// Returns the head qualifier (leftmost), sanitized (quotes removed)
+    /// For `schema.table.column`: returns `Some("schema")`
+    /// For `table.column`: returns `None`
+    pub fn head_qualifier_sanitized(&self) -> Option<String> {
+        self.identifier_qualifiers
+            .0
+            .as_ref()
+            .map(|s| s.replace('"', ""))
+    }
+
+    /// Returns the tail qualifier (rightmost), sanitized (quotes removed)
+    /// 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
+            .as_ref()
+            .map(|s| s.replace('"', ""))
+    }
+
+    /// Returns true if there is at least one qualifier present
+    pub fn has_any_qualifier(&self) -> bool {
+        self.identifier_qualifiers.1.is_some()
+    }
+
+    /// 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(_)))
+    }
 }
 
 #[cfg(test)]