so far…

Author: juleswritescode

Cargo.lock

@@ -22,6 +22,7 @@ pgt_treesitter_queries.workspace = true
 schemars                         = { workspace = true, optional = true }
 serde                            = { workspace = true, features = ["derive"] }
 serde_json                       = { workspace = true }
+tracing                          = { workspace = true }
 tree-sitter.workspace            = true
 tree_sitter_sql.workspace        = true
 

crates/pgt_completions/Cargo.toml

@@ -17,6 +17,7 @@ pub struct CompletionParams<'a> {
     pub tree: Option<&'a tree_sitter::Tree>,
 }
 
+#[tracing::instrument(level = "debug")]
 pub fn complete(params: CompletionParams) -> Vec<CompletionItem> {
     let ctx = CompletionContext::new(&params);
 

crates/pgt_completions/src/complete.rs

@@ -81,6 +81,8 @@ impl<'a> CompletionContext<'a> {
         ctx.gather_tree_context();
         ctx.gather_info_from_ts_queries();
 
+        println!("Here's my node: {:?}", ctx.ts_node.unwrap());
+
         ctx
     }
 

crates/pgt_completions/src/context.rs

@@ -143,12 +143,86 @@ mod tests {
         let params = get_test_params(&tree, &cache, case.get_input_query());
         let mut items = complete(params);
 
-        let _ = items.split_off(3);
+        let _ = items.split_off(6);
 
-        items.sort_by(|a, b| a.label.cmp(&b.label));
+        #[derive(Eq, PartialEq, Debug)]
+        struct LabelAndDesc {
+            label: String,
+            desc: String,
+        }
+
+        let labels: Vec<LabelAndDesc> = items
+            .into_iter()
+            .map(|c| LabelAndDesc {
+                label: c.label,
+                desc: c.description,
+            })
+            .collect();
+
+        let expected = vec![
+            ("name", "Table: public.users"),
+            ("narrator", "Table: public.audio_books"),
+            ("narrator_id", "Table: private.audio_books"),
+            ("name", "Schema: pg_catalog"),
+            ("nameconcatoid", "Schema: pg_catalog"),
+            ("nameeq", "Schema: pg_catalog"),
+        ]
+        .into_iter()
+        .map(|(label, schema)| LabelAndDesc {
+            label: label.into(),
+            desc: schema.into(),
+        })
+        .collect::<Vec<LabelAndDesc>>();
+
+        assert_eq!(labels, expected);
+    }
+
+    #[tokio::test]
+    async fn suggests_relevant_columns_without_letters() {
+        let setup = r#"
+            create table users (
+                id serial primary key,
+                name text,
+                address text,
+                email text
+            );
+        "#;
+
+        let test_case = TestCase {
+            message: "suggests user created tables first",
+            query: format!(r#"select {} from users"#, CURSOR_POS),
+            label: "",
+            description: "",
+        };
+
+        let (tree, cache) = get_test_deps(setup, test_case.get_input_query()).await;
+        let params = get_test_params(&tree, &cache, test_case.get_input_query());
+        let results = complete(params);
 
-        let labels: Vec<String> = items.into_iter().map(|c| c.label).collect();
+        let (first_four, _rest) = results.split_at(4);
+
+        let has_column_in_first_four = |col: &'static str| {
+            first_four
+                .iter()
+                .find(|compl_item| compl_item.label.as_str() == col)
+                .is_some()
+        };
 
-        assert_eq!(labels, vec!["name", "narrator", "narrator_id"]);
+        assert!(
+            has_column_in_first_four("id"),
+            "`id` not present in first four completion items."
+        );
+        assert!(
+            has_column_in_first_four("name"),
+            "`name` not present in first four completion items."
+        );
+        assert!(
+            has_column_in_first_four("address"),
+            "`address` not present in first four completion items."
+        );
+        assert!(
+            has_column_in_first_four("email"),
+            "`email` not present in first four completion items."
+        );
     }
 }

crates/pgt_completions/src/providers/columns.rs

@@ -73,8 +73,8 @@ mod tests {
         "#;
 
         let test_cases = vec![
-            (format!("select * from us{}", CURSOR_POS), "users"),
-            (format!("select * from em{}", CURSOR_POS), "emails"),
+            // (format!("select * from us{}", CURSOR_POS), "users"),
+            // (format!("select * from em{}", CURSOR_POS), "emails"),
             (format!("select * from {}", CURSOR_POS), "addresses"),
         ];
 

crates/pgt_completions/src/providers/tables.rs

@@ -33,7 +33,6 @@ impl CompletionRelevance<'_> {
         self.check_is_user_defined();
         self.check_matches_schema(ctx);
         self.check_matches_query_input(ctx);
-        self.check_if_catalog(ctx);
         self.check_is_invocation(ctx);
         self.check_matching_clause_type(ctx);
         self.check_relations_in_stmt(ctx);
@@ -52,7 +51,10 @@ impl CompletionRelevance<'_> {
         let name = match self.data {
             CompletionRelevanceData::Function(f) => f.name.as_str(),
             CompletionRelevanceData::Table(t) => t.name.as_str(),
-            CompletionRelevanceData::Column(c) => c.name.as_str(),
+            CompletionRelevanceData::Column(c) => {
+                //
+                c.name.as_str()
+            }
         };
 
         if name.starts_with(content) {
@@ -61,7 +63,7 @@ impl CompletionRelevance<'_> {
                 .try_into()
                 .expect("The length of the input exceeds i32 capacity");
 
-            self.score += len * 5;
+            self.score += len * 10;
         };
     }
 
@@ -135,14 +137,6 @@ impl CompletionRelevance<'_> {
         }
     }
 
-    fn check_if_catalog(&mut self, ctx: &CompletionContext) {
-        if ctx.schema_name.as_ref().is_some_and(|n| n == "pg_catalog") {
-            return;
-        }
-
-        self.score -= 5; // unlikely that the user wants schema data
-    }
-
     fn check_relations_in_stmt(&mut self, ctx: &CompletionContext) {
         match self.data {
             CompletionRelevanceData::Table(_) | CompletionRelevanceData::Function(_) => return,
@@ -182,5 +176,11 @@ impl CompletionRelevance<'_> {
         if system_schemas.contains(&schema.as_str()) {
             self.score -= 10;
         }
+
+        // "public" is the default postgres schema where users
+        // create objects. Prefer it by a slight bit.
+        if schema.as_str() == "public" {
+            self.score += 2;
+        }
     }
 }

crates/pgt_completions/src/relevance.rs

@@ -17,7 +17,7 @@
   // YOU CAN COMMENT ME OUT :)
   "db": {
     "host": "127.0.0.1",
-    "port": 5432,
+    "port": 54322,
     "username": "postgres",
     "password": "postgres",
     "database": "postgres",