progress

Author: psteinroe

Cargo.lock

@@ -69,8 +69,7 @@ impl<'a> Iterator for QueryResultIter<'a> {
 mod tests {
 
     use crate::{
-        TreeSitterQueriesExecutor,
-        queries::{ParameterMatch, RelationMatch},
+        queries::{Field, ParameterMatch, RelationMatch}, TreeSitterQueriesExecutor
     };
 
     #[test]
@@ -211,18 +210,18 @@ on sq1.id = pt.id;
 
         assert_eq!(results[0].get_root(sql), None);
         assert_eq!(results[0].get_path(sql), None);
-        assert_eq!(results[0].get_field(sql), "v_test");
+        assert_eq!(results[0].get_field(sql), Field::Text("v_test".to_string()));
 
         assert_eq!(results[1].get_root(sql), Some("fn_name".into()));
         assert_eq!(results[1].get_path(sql), Some("custom_type".into()));
-        assert_eq!(results[1].get_field(sql), "v_test2");
+        assert_eq!(results[1].get_field(sql), Field::Text("v_test2".to_string()));
 
         assert_eq!(results[2].get_root(sql), None);
         assert_eq!(results[2].get_path(sql), None);
-        assert_eq!(results[2].get_field(sql), "$3");
+        assert_eq!(results[2].get_field(sql), Field::Parameter(3));
 
         assert_eq!(results[3].get_root(sql), None);
         assert_eq!(results[3].get_path(sql), Some("custom_type".into()));
-        assert_eq!(results[3].get_field(sql), "v_test3");
+        assert_eq!(results[3].get_field(sql), Field::Text("v_test3".to_string()));
     }
 }

crates/pgt_treesitter_queries/src/lib.rs

@@ -26,6 +26,12 @@ pub struct ParameterMatch<'a> {
     pub(crate) field: tree_sitter::Node<'a>,
 }
 
+#[derive(Debug, PartialEq)]
+pub enum Field {
+    Text(String),
+    Parameter(usize),
+}
+
 impl ParameterMatch<'_> {
     pub fn get_root(&self, sql: &str) -> Option<String> {
         let str = self
@@ -47,11 +53,30 @@ impl ParameterMatch<'_> {
         Some(str.to_string())
     }
 
-    pub fn get_field(&self, sql: &str) -> String {
-        self.field
+    pub fn get_field(&self, sql: &str) -> Field {
+        let text = self
+            .field
             .utf8_text(sql.as_bytes())
-            .expect("Failed to get table from RelationMatch")
-            .to_string()
+            .expect("Failed to get field from RelationMatch");
+
+        if let Some(stripped) = text.strip_prefix('$') {
+            return Field::Parameter(
+                stripped
+                    .parse::<usize>()
+                    .expect("Failed to parse parameter"),
+            );
+        }
+
+        Field::Text(text.to_string())
+    }
+
+    pub fn get_range(&self) -> tree_sitter::Range {
+        self.field.range()
+    }
+
+    pub fn get_byte_range(&self) -> std::ops::Range<usize> {
+        let range = self.field.range();
+        range.start_byte..range.end_byte
     }
 }
 

crates/pgt_treesitter_queries/src/queries/parameters.rs

@@ -17,6 +17,7 @@ pgt_diagnostics.workspace  = true
 pgt_query_ext.workspace    = true
 pgt_schema_cache.workspace = true
 pgt_text_size.workspace    = true
+pgt_treesitter_queries.workspace = true
 sqlx.workspace             = true
 tokio.workspace            = true
 tree-sitter.workspace      = true

crates/pgt_typecheck/Cargo.toml

@@ -1,30 +1,17 @@
+use pgt_treesitter_queries::{
+    queries::{Field, ParameterMatch},
+    TreeSitterQueriesExecutor,
+};
+
 #[derive(Debug)]
 pub struct TypedIdentifier {
-    pub schema: Option<String>,
-    pub relation: Option<String>,
+    pub root: Option<String>,
+    pub field: Option<String>,
     pub name: String,
-    pub type_: (Option<String>, String),
+    pub type_: Identifier,
 }
 
-impl TypedIdentifier {
-    pub fn new(
-        schema: Option<String>,
-        relation: Option<String>,
-        name: String,
-        type_: (Option<String>, String),
-    ) -> Self {
-        TypedIdentifier {
-            schema,
-            relation,
-            name,
-            type_,
-        }
-    }
-
-    pub fn default_value(&self, schema_cache: &pgt_schema_cache::SchemaCache) -> String {
-        "NULL".to_string()
-    }
-}
+type Identifier = (Option<String>, String);
 
 /// Applies the identifiers to the SQL string by replacing them with their default values.
 pub fn apply_identifiers<'a>(
@@ -38,6 +25,35 @@ pub fn apply_identifiers<'a>(
     println!("Identifiers: {:?}", identifiers);
     println!("CST: {:#?}", cst);
 
+    let mut executor = TreeSitterQueriesExecutor::new(cst.root_node(), sql);
+
+    executor.add_query_results::<ParameterMatch>();
+
+    // we need the range and type of each field
+
+    let results: Vec<(std::ops::Range<usize>, &Identifier)> = executor
+        .get_iter(None)
+        .filter_map(|q| {
+            let m: &ParameterMatch = q.try_into().ok()?;
+
+            let ident = match m.get_field(sql) {
+                Field::Parameter(idx) => identifiers.get(idx)?,
+                Field::Text(field) => {
+                    let r = m.get_root(sql);
+                    let p = m.get_path(sql);
+
+                    identifiers.iter().find(|i| {
+                        // TODO: this is not correct, we need to check if the identifier is a prefix of the field
+
+                    })?
+                }
+            };
+
+            Some((m.get_byte_range(), &ident.type_))
+        })
+        // TODO resolve composite types or table types to plain types
+        .collect();
+
     sql
 }