just tests missing now

Author: psteinroe

crates/pgt_completions/src/context.rs

@@ -100,25 +100,23 @@ impl<'a> CompletionContext<'a> {
         executor.add_query_results::<queries::RelationMatch>();
 
         for relation_match in executor.get_iter(stmt_range) {
-            match relation_match {
-                QueryResult::Relation(r) => {
-                    let schema_name = r.get_schema(sql);
-                    let table_name = r.get_table(sql);
+            if let QueryResult::Relation(r) = relation_match {
+                let schema_name = r.get_schema(sql);
+                let table_name = r.get_table(sql);
 
-                    let current = self.mentioned_relations.get_mut(&schema_name);
+                let current = self.mentioned_relations.get_mut(&schema_name);
 
-                    match current {
-                        Some(c) => {
-                            c.insert(table_name);
-                        }
-                        None => {
-                            let mut new = HashSet::new();
-                            new.insert(table_name);
-                            self.mentioned_relations.insert(schema_name, new);
-                        }
-                    };
-                }
-            };
+                match current {
+                    Some(c) => {
+                        c.insert(table_name);
+                    }
+                    None => {
+                        let mut new = HashSet::new();
+                        new.insert(table_name);
+                        self.mentioned_relations.insert(schema_name, new);
+                    }
+                };
+            }
         }
     }
 

crates/pgt_schema_cache/src/lib.rs

@@ -15,3 +15,4 @@ pub use functions::{Behavior, Function, FunctionArg, FunctionArgs};
 pub use schema_cache::SchemaCache;
 pub use schemas::Schema;
 pub use tables::{ReplicaIdentity, Table};
+pub use types::{PostgresType, PostgresTypeAttribute};

crates/pgt_schema_cache/src/types.rs

@@ -56,58 +56,3 @@ impl SchemaCacheItem for PostgresType {
             .await
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use pgt_test_utils::test_database::get_new_test_db;
-    use sqlx::Executor;
-
-    use crate::{schema_cache::SchemaCacheItem, types::PostgresType};
-
-    #[tokio::test]
-    async fn test_types() {
-        let setup = r#"
-            CREATE TYPE "public"."priority" AS ENUM (
-                'critical',
-                'high',
-                'default',
-                'low',
-                'very_low'
-            );
-
-            CREATE TYPE complex AS (
-                r       double precision,
-                i       double precision
-            );
-        "#;
-
-        let test_db = get_new_test_db().await;
-
-        test_db
-            .execute(setup)
-            .await
-            .expect("Failed to setup test database");
-
-        let types = PostgresType::load(&test_db).await.unwrap();
-
-        let enum_type = types.iter().find(|t| t.name == "priority");
-        let comp_type = types.iter().find(|t| t.name == "complex");
-
-        println!("{:?}", enum_type);
-        // search for type id
-        println!("{:?}", comp_type);
-
-        comp_type.and_then(|t| {
-            t.attributes.attrs.iter().for_each(|a| {
-                let typ = types.iter().find(|t| t.id == a.type_id);
-                println!(
-                    "{}: {} - {:?}",
-                    a.name,
-                    a.type_id,
-                    typ.as_ref().map(|t| t.name.clone())
-                );
-            });
-            Some(())
-        });
-    }
-}

crates/pgt_typecheck/src/diagnostics.rs

@@ -97,21 +97,26 @@ impl Advices for TypecheckAdvices {
 pub(crate) fn create_type_error(
     pg_err: &PgDatabaseError,
     ts: &tree_sitter::Tree,
+    positions_valid: bool,
 ) -> TypecheckDiagnostic {
     let position = pg_err.position().and_then(|pos| match pos {
         sqlx::postgres::PgErrorPosition::Original(pos) => Some(pos - 1),
         _ => None,
     });
 
     let range = position.and_then(|pos| {
-        ts.root_node()
-            .named_descendant_for_byte_range(pos, pos)
-            .map(|node| {
-                TextRange::new(
-                    node.start_byte().try_into().unwrap(),
-                    node.end_byte().try_into().unwrap(),
-                )
-            })
+        if positions_valid {
+            ts.root_node()
+                .named_descendant_for_byte_range(pos, pos)
+                .map(|node| {
+                    TextRange::new(
+                        node.start_byte().try_into().unwrap(),
+                        node.end_byte().try_into().unwrap(),
+                    )
+                })
+        } else {
+            None
+        }
     });
 
     let severity = match pg_err.severity() {

crates/pgt_typecheck/src/lib.rs

@@ -7,8 +7,8 @@ use pgt_text_size::TextRange;
 use sqlx::postgres::PgDatabaseError;
 pub use sqlx::postgres::PgSeverity;
 use sqlx::{Executor, PgPool};
-pub use typed_identifier::TypedIdentifier;
 use typed_identifier::apply_identifiers;
+pub use typed_identifier::{IdentifierType, TypedIdentifier};
 
 #[derive(Debug)]
 pub struct TypecheckParams<'a> {
@@ -56,20 +56,24 @@ pub async fn check_sql(
     // each typecheck operation.
     conn.close_on_drop();
 
-    let prepared = apply_identifiers(
+    let (prepared, positions_valid) = apply_identifiers(
         params.identifiers,
         params.schema_cache,
         params.tree,
         params.sql,
     );
 
-    let res = conn.prepare(prepared).await;
+    let res = conn.prepare(&prepared).await;
 
     match res {
         Ok(_) => Ok(None),
         Err(sqlx::Error::Database(err)) => {
             let pg_err = err.downcast_ref::<PgDatabaseError>();
-            Ok(Some(create_type_error(pg_err, params.tree)))
+            Ok(Some(create_type_error(
+                pg_err,
+                params.tree,
+                positions_valid,
+            )))
         }
         Err(err) => Err(err),
     }