add comment, rename

Author: juleswritescode

crates/pgt_completions/src/context.rs

@@ -106,7 +106,25 @@ pub(crate) struct CompletionContext<'a> {
     pub schema_cache: &'a SchemaCache,
     pub position: usize,
 
-    pub schema_name: Option<String>,
+    /// If the cursor is on a node that uses dot notation
+    /// to specify an alias or schema, this will hold the schema's or
+    /// alias's name.
+    ///
+    /// Here, `auth` is a schema name:
+    /// ```sql
+    /// select * from auth.users;
+    /// ```
+    ///
+    /// Here, `u` is an alias name:
+    /// ```sql
+    /// select
+    ///     *
+    /// from
+    ///     auth.users u
+    ///     left join identities i
+    ///     on u.id = i.user_id;
+    /// ```
+    pub schema_or_alias_name: Option<String>,
     pub wrapping_clause_type: Option<ClauseType>,
 
     pub wrapping_node_kind: Option<WrappingNode>,
@@ -127,7 +145,7 @@ impl<'a> CompletionContext<'a> {
             schema_cache: params.schema,
             position: usize::from(params.position),
             node_under_cursor: None,
-            schema_name: None,
+            schema_or_alias_name: None,
             wrapping_clause_type: None,
             wrapping_node_kind: None,
             wrapping_statement_range: None,
@@ -258,7 +276,7 @@ impl<'a> CompletionContext<'a> {
                         NodeText::Original(txt) => {
                             let parts: Vec<&str> = txt.split('.').collect();
                             if parts.len() == 2 {
-                                self.schema_name = Some(parts[0].to_string());
+                                self.schema_or_alias_name = Some(parts[0].to_string());
                             }
                         }
                         NodeText::Replaced => {}
@@ -380,7 +398,10 @@ mod tests {
 
             let ctx = CompletionContext::new(&params);
 
-            assert_eq!(ctx.schema_name, expected_schema.map(|f| f.to_string()));
+            assert_eq!(
+                ctx.schema_or_alias_name,
+                expected_schema.map(|f| f.to_string())
+            );
         }
     }
 

crates/pgt_completions/src/providers/helper.rs

@@ -7,7 +7,7 @@ pub(crate) fn get_completion_text_with_schema(
     item_name: &str,
     item_schema_name: &str,
 ) -> Option<CompletionText> {
-    if item_schema_name == "public" || ctx.schema_name.is_some() {
+    if item_schema_name == "public" || ctx.schema_or_alias_name.is_some() {
         None
     } else {
         let node = ctx.node_under_cursor.unwrap();

crates/pgt_completions/src/relevance/filtering.rs

@@ -87,11 +87,38 @@ impl CompletionFilter<'_> {
     }
 
     fn check_mentioned_schema(&self, ctx: &CompletionContext) -> Option<()> {
-        if ctx.schema_name.is_none() {
+        if ctx.schema_or_alias_name.is_none() {
             return Some(());
         }
 
-        let name = ctx.schema_name.as_ref().unwrap();
+        let name = ctx.schema_or_alias_name.as_ref().unwrap();
+
+        let does_not_match = match self.data {
+            CompletionRelevanceData::Table(table) => &table.schema != name,
+            CompletionRelevanceData::Function(f) => &f.schema != name,
+            CompletionRelevanceData::Column(_) => {
+                // columns belong to tables, not schemas
+                true
+            }
+            CompletionRelevanceData::Schema(_) => {
+                // we should never allow schema suggestions if there already was one.
+                true
+            }
+        };
+
+        if does_not_match {
+            return None;
+        }
+
+        Some(())
+    }
+
+    fn check_mentioned_alias(&self, ctx: &CompletionContext) -> Option<()> {
+        if ctx.schema_or_alias_name.is_none() {
+            return Some(());
+        }
+
+        let name = ctx.schema_or_alias_name.as_ref().unwrap();
 
         let does_not_match = match self.data {
             CompletionRelevanceData::Table(table) => &table.schema != name,

crates/pgt_completions/src/relevance/scoring.rs

@@ -62,7 +62,7 @@ impl CompletionScore<'_> {
         };
 
         let has_mentioned_tables = !ctx.mentioned_relations.is_empty();
-        let has_mentioned_schema = ctx.schema_name.is_some();
+        let has_mentioned_schema = ctx.schema_or_alias_name.is_some();
 
         self.score += match self.data {
             CompletionRelevanceData::Table(_) => match clause_type {
@@ -98,7 +98,7 @@ impl CompletionScore<'_> {
             Some(wn) => wn,
         };
 
-        let has_mentioned_schema = ctx.schema_name.is_some();
+        let has_mentioned_schema = ctx.schema_or_alias_name.is_some();
         let has_node_text = ctx.get_node_under_cursor_content().is_some();
 
         self.score += match self.data {
@@ -135,7 +135,7 @@ impl CompletionScore<'_> {
     }
 
     fn check_matches_schema(&mut self, ctx: &CompletionContext) {
-        let schema_name = match ctx.schema_name.as_ref() {
+        let schema_name = match ctx.schema_or_alias_name.as_ref() {
             None => return,
             Some(n) => n,
         };