feat: hover crate

Author: psteinroe

Cargo.lock

@@ -8,6 +8,7 @@ text-size = "1.1.1"
 sql_parser.workspace = true
 schema_cache.workspace = true
 tree-sitter.workspace = true
+tree_sitter_sql.workspace = true
 
 [dev-dependencies]
 

crates/hover/Cargo.toml

@@ -1,44 +1,47 @@
+mod resolve;
+
+use resolve::Hoverable;
 use schema_cache::SchemaCache;
 use text_size::{TextRange, TextSize};
 
 pub struct HoverParams {
     pub position: text_size::TextSize,
+    pub source: String,
     pub ast: Option<sql_parser::EnrichedAst>,
     pub tree: tree_sitter::Tree,
     pub schema_cache: SchemaCache,
 }
 
+#[derive(Debug)]
 pub struct HoverResult {
     range: Option<TextRange>,
     content: String,
 }
 
 pub fn hover(params: HoverParams) -> Option<HoverResult> {
-    // if ast, find deepest node at position
-    if params.ast.is_some() {
-        let ast = params.ast.unwrap();
-        let node = ast.covering_node(TextRange::empty(params.position));
-        if node.is_some() {
-            let node = node.unwrap();
-            return Some(HoverResult {
-                range: Some(node.range()),
-                content: "Hover".to_string(),
-            });
-        }
-    }
-    // else, try to find ts node at position in tree
-    // using: https://docs.rs/tree-sitter/0.22.6/tree_sitter/struct.TreeCursor.html#method.goto_first_child_for_byte
-    // get byte offset from position
-    let r = params.tree.root_node().named_descendant_for_byte_range(
-        usize::from(params.position),
-        usize::from(params.position),
-    );
-    if r.is_some() {
-        let r = r.unwrap();
-        match r.kind() {}
+    let elem = if params.ast.is_some() {
+        resolve::resolve_from_enriched_ast(params.position, params.ast.unwrap())
+    } else {
+        resolve::resolve_from_tree_sitter(params.position, params.tree, &params.source)
+    };
+
+    if elem.is_none() {
+        return None;
     }
 
-    // TODO: get table / column whatever COMMENT from schema cache
+    match elem.unwrap() {
+        Hoverable::Relation(r) => {
+            let table = params.schema_cache.find_table(&r.name, r.schema.as_deref());
 
-    None
+            table.map(|t| HoverResult {
+                range: Some(r.range),
+                content: if t.comment.is_some() {
+                    format!("{}\n{}", t.name, t.comment.as_ref().unwrap())
+                } else {
+                    t.name.clone()
+                },
+            })
+        }
+        _ => None,
+    }
 }

crates/hover/src/lib.rs

@@ -0,0 +1,132 @@
+use sql_parser::{AstNode, EnrichedAst};
+use text_size::{TextRange, TextSize};
+use tree_sitter::Tree;
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct HoverableRelation {
+    pub name: String,
+    pub schema: Option<String>,
+    pub range: TextRange,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct HoverableColumn {
+    pub name: String,
+    pub table: Option<String>,
+    pub schema: Option<String>,
+    pub range: TextRange,
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum Hoverable {
+    Relation(HoverableRelation),
+    Column(HoverableColumn),
+}
+
+pub fn resolve_from_enriched_ast(pos: TextSize, ast: EnrichedAst) -> Option<Hoverable> {
+    let node = ast.covering_node(TextRange::empty(pos));
+
+    if node.is_none() {
+        return None;
+    }
+
+    let node = node.unwrap();
+
+    match node.node {
+        AstNode::RangeVar(ref range_var) => Some(Hoverable::Relation(HoverableRelation {
+            range: node.range(),
+            name: range_var.relname.clone(),
+            schema: if range_var.schemaname.is_empty() {
+                None
+            } else {
+                Some(range_var.schemaname.clone())
+            },
+        })),
+        _ => None,
+    }
+}
+
+pub fn resolve_from_tree_sitter(pos: TextSize, tree: Tree, source: &str) -> Option<Hoverable> {
+    let r = tree
+        .root_node()
+        .named_descendant_for_byte_range(usize::from(pos), usize::from(pos));
+
+    if r.is_none() {
+        return None;
+    }
+
+    let mut node = r.unwrap();
+    let node_range = node.range();
+
+    while node.parent().is_some() && node.parent().unwrap().range() == node_range {
+        node = node.parent().unwrap();
+    }
+
+    match node.kind() {
+        "relation" => Some(Hoverable::Relation(HoverableRelation {
+            range: TextRange::new(
+                TextSize::try_from(node.range().start_byte).unwrap(),
+                TextSize::try_from(node.range().end_byte).unwrap(),
+            ),
+            name: node.utf8_text(source.as_bytes()).unwrap().to_string(),
+            schema: None,
+        })),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use sql_parser::parse_ast;
+    use text_size::{TextRange, TextSize};
+
+    use super::{Hoverable, HoverableRelation};
+
+    #[test]
+    fn test_resolve_from_enriched_ast() {
+        let input = "select id from contact;";
+        let position = TextSize::new(15);
+
+        let root = sql_parser::parse_sql_statement(input).unwrap();
+        let ast = parse_ast(input, &root).ast;
+
+        let hover = super::resolve_from_enriched_ast(position, ast);
+
+        assert!(hover.is_some());
+
+        assert_eq!(
+            hover.unwrap(),
+            Hoverable::Relation(HoverableRelation {
+                range: TextRange::new(TextSize::new(15), TextSize::new(22)),
+                name: "contact".to_string(),
+                schema: None,
+            })
+        );
+    }
+
+    #[test]
+    fn test_resolve_from_tree_sitter() {
+        let input = "select id from contact;";
+        let position = TextSize::new(15);
+
+        let mut parser = tree_sitter::Parser::new();
+        parser
+            .set_language(tree_sitter_sql::language())
+            .expect("Error loading sql language");
+
+        let tree = parser.parse(input, None).unwrap();
+
+        let hover = super::resolve_from_tree_sitter(position, tree, input);
+
+        assert!(hover.is_some());
+
+        assert_eq!(
+            hover.unwrap(),
+            Hoverable::Relation(HoverableRelation {
+                range: TextRange::new(TextSize::new(15), TextSize::new(22)),
+                name: "contact".to_string(),
+                schema: None,
+            })
+        );
+    }
+}

crates/hover/src/resolve.rs

@@ -29,6 +29,12 @@ impl SchemaCache {
     pub fn mutate(&mut self) {
         unimplemented!();
     }
+
+    pub fn find_table(&self, name: &str, schema: Option<&str>) -> Option<&Table> {
+        self.tables
+            .iter()
+            .find(|t| t.name == name && t.schema == schema.unwrap_or("public"))
+    }
 }
 
 pub trait SchemaCacheItem {

crates/schema_cache/src/schema_cache.rs

@@ -30,17 +30,17 @@ impl From<String> for ReplicaIdentity {
 
 #[derive(Debug, Clone, Default)]
 pub struct Table {
-    id: i64,
-    schema: String,
-    name: String,
-    rls_enabled: bool,
-    rls_forced: bool,
-    replica_identity: ReplicaIdentity,
-    bytes: i64,
-    size: String,
-    live_rows_estimate: i64,
-    dead_rows_estimate: i64,
-    comment: Option<String>,
+    pub id: i64,
+    pub schema: String,
+    pub name: String,
+    pub rls_enabled: bool,
+    pub rls_forced: bool,
+    pub replica_identity: ReplicaIdentity,
+    pub bytes: i64,
+    pub size: String,
+    pub live_rows_estimate: i64,
+    pub dead_rows_estimate: i64,
+    pub comment: Option<String>,
 }
 
 impl SchemaCacheItem for Table {