feat!: avoid string cloning

davidsmfreire · davidsmfreire · commit e4e711ce088e · 2026-04-24T21:53:32.000+01:00
diff --git a/sqlshield-gui/src/main.rs b/sqlshield-gui/src/main.rs
@@ -18,10 +18,9 @@ fn main() -> Result<(), slint::PlatformError> {
                 // println!("schema -> {}", ui.get_schema());
             }
 
-            let errors = match sqlshield::validate_query(
-                ui.get_queries().to_string(),
-                ui.get_schema().to_string(),
-            ) {
+            let queries = ui.get_queries();
+            let schema = ui.get_schema();
+            let errors = match sqlshield::validate_query(queries.as_str(), schema.as_str()) {
                 Ok(errors) => errors,
                 Err(err) => vec![err],
             };
diff --git a/sqlshield-py/src/lib.rs b/sqlshield-py/src/lib.rs
@@ -37,8 +37,8 @@ fn validate_files(dir: String, schema_file_path: String) -> PyResult<Vec<PySqlVa
 }
 
 #[pyfunction]
-fn validate_query(query: String, schema: String) -> PyResult<Vec<String>> {
-    sqlshield_rs::validate_query(query, schema).map_err(|err| PyValueError::new_err(err))
+fn validate_query(query: &str, schema: &str) -> PyResult<Vec<String>> {
+    sqlshield_rs::validate_query(query, schema).map_err(PyValueError::new_err)
 }
 
 /// A Python module implemented in Rust.
diff --git a/sqlshield/src/lib.rs b/sqlshield/src/lib.rs
@@ -9,15 +9,15 @@ use regex::Regex;
 use validation::{validate_queries_in_code, validate_statements_with_schema, SqlValidationError};
 use walkdir::WalkDir;
 
-pub fn validate_query(query: String, schema: String) -> Result<Vec<String>, String> {
+pub fn validate_query(query: &str, schema: &str) -> Result<Vec<String>, String> {
     let dialect = sqlparser::dialect::GenericDialect {};
 
-    let statements = match sqlparser::parser::Parser::parse_sql(&dialect, &query) {
+    let statements = match sqlparser::parser::Parser::parse_sql(&dialect, query) {
         Ok(statements) => statements,
         Err(err) => return Err(err.to_string()),
     };
 
-    let loaded_schema = match schema::load_schema(&schema.into_bytes(), "sql") {
+    let loaded_schema = match schema::load_schema(schema.as_bytes(), "sql") {
         Ok(loaded_schema) => loaded_schema,
         Err(err) => return Err(err),
     };
diff --git a/sqlshield/src/validation/asserts.rs b/sqlshield/src/validation/asserts.rs
@@ -1,27 +1,27 @@
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
+
+use crate::schema;
 
 pub fn is_relation_in_schema(
     relation: &sqlparser::ast::TableFactor,
-    tables: &HashSet<String>,
+    schema: &schema::TablesAndColumns,
+    extras: &HashMap<&str, HashSet<&str>>,
 ) -> Option<String> {
-    // returns table_name if not in schema
-    match &relation {
+    match relation {
         sqlparser::ast::TableFactor::Table { name, .. } => {
             // TODO support table name with schema prefixed instead of using last ident
-            let table_name = name.0.last().unwrap();
-            let table_name_str = table_name.value.as_str();
-            if tables.contains(table_name_str) {
+            let table_name = name.0.last().unwrap().value.as_str();
+            if schema.contains_key(table_name) || extras.contains_key(table_name) {
                 return None;
             }
-            let name_full: String = name
+            let name_full = name
                 .0
                 .iter()
                 .map(|e| e.value.as_str())
                 .collect::<Vec<&str>>()
                 .join(".");
-            return Some(name_full);
+            Some(name_full)
         }
-        _ => {}
+        _ => None,
     }
-    None
 }
diff --git a/sqlshield/src/validation/clauses/mod.rs b/sqlshield/src/validation/clauses/mod.rs
@@ -1,7 +1,13 @@
 mod select;
 
+use std::collections::{HashMap, HashSet};
+
 use crate::schema;
 
 pub trait ClauseValidation {
-    fn validate(&self, schema: &schema::TablesAndColumns) -> Vec<String>;
+    fn validate(
+        &self,
+        schema: &schema::TablesAndColumns,
+        extras: &HashMap<&str, HashSet<&str>>,
+    ) -> Vec<String>;
 }
diff --git a/sqlshield/src/validation/clauses/select.rs b/sqlshield/src/validation/clauses/select.rs
@@ -2,28 +2,30 @@ use crate::{schema, validation::asserts};
 
 use super::ClauseValidation;
 
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 
 impl ClauseValidation for sqlparser::ast::Select {
-    fn validate(&self, schema: &schema::TablesAndColumns) -> Vec<String> {
-        let tables_in_schema: HashSet<String> = HashSet::from_iter(schema.keys().cloned());
-
+    fn validate(
+        &self,
+        schema: &schema::TablesAndColumns,
+        extras: &HashMap<&str, HashSet<&str>>,
+    ) -> Vec<String> {
         let select = self;
         let mut errors = vec![];
 
         for item in &select.from {
-            let relation_name = asserts::is_relation_in_schema(&item.relation, &tables_in_schema);
-
-            if let Some(relation_name) = relation_name {
+            if let Some(relation_name) =
+                asserts::is_relation_in_schema(&item.relation, schema, extras)
+            {
                 errors.push(format!(
                     "Table `{relation_name}` not found in schema nor subqueries"
                 ))
             }
 
             for join in &item.joins {
-                let relation_name =
-                    asserts::is_relation_in_schema(&join.relation, &tables_in_schema);
-                if let Some(relation_name) = relation_name {
+                if let Some(relation_name) =
+                    asserts::is_relation_in_schema(&join.relation, schema, extras)
+                {
                     errors.push(format!(
                         "Table `{relation_name}` not found in schema nor subqueries"
                     ))
@@ -32,7 +34,7 @@ impl ClauseValidation for sqlparser::ast::Select {
         }
 
         for item in &select.projection {
-            let result = is_select_item_in_relations(item, &select.from, &schema);
+            let result = is_select_item_in_relations(item, &select.from, schema, extras);
 
             if let Some((item_name, relations_not_found_in)) = result {
                 if relations_not_found_in.len() == 1 {
@@ -50,25 +52,28 @@ impl ClauseValidation for sqlparser::ast::Select {
     }
 }
 
-fn is_select_item_in_relations(
-    item: &sqlparser::ast::SelectItem,
-    tables: &Vec<sqlparser::ast::TableWithJoins>,
-    schema: &schema::TablesAndColumns,
-) -> Option<(String, Vec<String>)> {
-    let mut tables_searched_where_not_found: Vec<String> = vec![];
-    let mut item_name: Option<String> = None;
+fn is_select_item_in_relations<'a>(
+    item: &'a sqlparser::ast::SelectItem,
+    tables: &'a [sqlparser::ast::TableWithJoins],
+    schema: &'a schema::TablesAndColumns,
+    extras: &HashMap<&'a str, HashSet<&'a str>>,
+) -> Option<(&'a str, Vec<&'a str>)> {
+    let mut tables_searched_where_not_found: Vec<&str> = vec![];
+    let mut item_name: Option<&str> = None;
 
     for relation in tables {
-        let result = could_select_item_be_in_relation(&item, &relation.relation, &schema);
-        if let Some((col_name, table_name)) = result {
+        if let Some((col_name, table_name)) =
+            could_select_item_be_in_relation(item, &relation.relation, schema, extras)
+        {
             tables_searched_where_not_found.push(table_name);
             if item_name.is_none() {
                 item_name = Some(col_name);
             }
         }
         for join in &relation.joins {
-            let result = could_select_item_be_in_relation(&item, &join.relation, &schema);
-            if let Some((col_name, table_name)) = result {
+            if let Some((col_name, table_name)) =
+                could_select_item_be_in_relation(item, &join.relation, schema, extras)
+            {
                 tables_searched_where_not_found.push(table_name);
                 if item_name.is_none() {
                     item_name = Some(col_name);
@@ -83,68 +88,59 @@ fn is_select_item_in_relations(
     Some((item_name?, tables_searched_where_not_found))
 }
 
-fn could_select_item_be_in_relation(
-    item: &sqlparser::ast::SelectItem,
-    table: &sqlparser::ast::TableFactor,
-    schema: &schema::TablesAndColumns,
-) -> Option<(String, String)> {
+fn could_select_item_be_in_relation<'a>(
+    item: &'a sqlparser::ast::SelectItem,
+    table: &'a sqlparser::ast::TableFactor,
+    schema: &'a schema::TablesAndColumns,
+    extras: &HashMap<&'a str, HashSet<&'a str>>,
+) -> Option<(&'a str, &'a str)> {
     // returns item_name, table_name if item could be in table but is not
 
-    let mut columns: Option<&HashSet<String>> = None;
-    let mut col_name: Option<String> = None;
-    let mut col_table_alias: Option<String> = None;
-    // let mut col_alias: Option<String> = None;
-
-    let mut table_name: Option<String> = None;
-
-    match &item {
-        sqlparser::ast::SelectItem::UnnamedExpr(expression) => {
-            match expression {
-                sqlparser::ast::Expr::Identifier(identifier) => {
-                    col_name = Some(identifier.value.clone());
-                }
-                sqlparser::ast::Expr::CompoundIdentifier(identifier) => {
-                    // for now only supports table alias
-                    if identifier.len() == 2 {
-                        col_table_alias = Some(identifier[0].value.clone());
-                        col_name = Some(identifier[1].value.clone());
-                    }
-                }
-                _ => {}
-            }
-        }
+    let (col_name, col_table_alias): (Option<&str>, Option<&str>) = match item {
+        sqlparser::ast::SelectItem::UnnamedExpr(expression) => match expression {
+            sqlparser::ast::Expr::Identifier(identifier) => (Some(identifier.value.as_str()), None),
+            sqlparser::ast::Expr::CompoundIdentifier(identifier) if identifier.len() == 2 => (
+                Some(identifier[1].value.as_str()),
+                Some(identifier[0].value.as_str()),
+            ),
+            _ => (None, None),
+        },
         // TODO: aliased columns
         // sqlparser::ast::SelectItem::ExprWithAlias { expr, alias } => {},
-        _ => {}
-    }
+        _ => (None, None),
+    };
 
-    match &table {
+    let (table_name, alias) = match table {
         sqlparser::ast::TableFactor::Table { name, alias, .. } => {
-            let name = &name.0.last().unwrap().value;
-
-            match (alias, col_table_alias) {
-                (None, None) => {
-                    columns = schema.get(name);
-                }
-                (None, Some(_)) => {}
-                (Some(_), None) => {}
-                (Some(alias), Some(col_table_alias)) => {
-                    if alias.name.value == col_table_alias {
-                        columns = schema.get(name);
-                    }
-                }
-            }
-            table_name = Some(name.clone());
+            (name.0.last().unwrap().value.as_str(), alias.as_ref())
         }
         // TODO Implement for others
-        _ => (),
-    }
+        _ => return None,
+    };
 
-    if let (Some(columns), Some(col_name)) = (columns, col_name) {
-        if !columns.contains(col_name.as_str()) {
-            return Some((col_name, table_name?));
-        }
+    let should_check = match (alias, col_table_alias) {
+        (None, None) => true,
+        (Some(table_alias), Some(col_alias)) => table_alias.name.value == col_alias,
+        _ => false,
+    };
+
+    if !should_check {
+        return None;
     }
 
-    None
+    let col_name = col_name?;
+
+    let column_present = if let Some(cols) = schema.get(table_name) {
+        cols.contains(col_name)
+    } else if let Some(cols) = extras.get(table_name) {
+        cols.contains(col_name)
+    } else {
+        return None;
+    };
+
+    if column_present {
+        None
+    } else {
+        Some((col_name, table_name))
+    }
 }
diff --git a/sqlshield/src/validation/mod.rs b/sqlshield/src/validation/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -37,8 +37,8 @@ fn validate_files(dir: String, schema_file_path: String) -> PyResult<Vec<PySqlVa`
`37`	`37`	`}`
`38`	`38`
`39`	`39`	`#[pyfunction]`
`40`		`-fn validate_query(query: String, schema: String) -> PyResult<Vec<String>> {`
`41`		`- sqlshield_rs::validate_query(query, schema).map_err(\|err\| PyValueError::new_err(err))`
	`40`	`+fn validate_query(query: &str, schema: &str) -> PyResult<Vec<String>> {`
	`41`	`+ sqlshield_rs::validate_query(query, schema).map_err(PyValueError::new_err)`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`/// A Python module implemented in Rust.`