Swap out Option<String> for Cow<str> when checking for unmappable chars

Author: abreis

diesel_cli/src/infer_schema_internals/data_structures.rs

@@ -53,9 +53,9 @@ impl fmt::Display for ColumnType {
 #[derive(Debug)]
 pub struct ColumnDefinition {
     pub sql_name: String,
+    pub rust_name: String,
     pub ty: ColumnType,
     pub docs: String,
-    pub rust_name: Option<String>,
 }
 
 impl ColumnInformation {

diesel_cli/src/infer_schema_internals/inference.rs

@@ -5,6 +5,7 @@ use diesel::result::Error::NotFound;
 use super::data_structures::*;
 use super::table_data::*;
 use crate::database::InferConnection;
+use std::borrow::Cow;
 
 static RESERVED_NAMES: &[&str] = &[
     "abstract", "alignof", "as", "become", "box", "break", "const", "continue", "crate", "do",
@@ -28,9 +29,9 @@ fn contains_unmappable_chars(name: &str) -> bool {
     !name.chars().all(|c| c.is_ascii_alphanumeric() || c == '_')
 }
 
-pub fn rust_name_for_sql_name(sql_name: &str) -> Option<String> {
+pub fn rust_name_for_sql_name(sql_name: &str) -> Cow<str> {
     if is_reserved_name(sql_name) {
-        Some(format!("{}_", sql_name))
+        Cow::Owned(format!("{}_", sql_name))
     } else if contains_unmappable_chars(sql_name) {
         // Map each non-alphanumeric character ([^a-zA-Z0-9]) to an underscore.
         let mut rust_name: String = sql_name
@@ -49,9 +50,9 @@ pub fn rust_name_for_sql_name(sql_name: &str) -> Option<String> {
             last_len = rust_name.len();
         }
 
-        Some(rust_name)
+        Cow::Owned(rust_name)
     } else {
-        None
+        Cow::Borrowed(sql_name)
     }
 }
 
@@ -181,14 +182,14 @@ pub fn load_table_data(database_url: &str, name: TableName) -> Result<TableData,
     let primary_key = get_primary_keys(&connection, &name)?;
     let primary_key = primary_key
         .iter()
-        .map(|k| rust_name_for_sql_name(&k).unwrap_or_else(|| k.clone()))
+        .map(|k| rust_name_for_sql_name(&k).into())
         .collect();
 
     let column_data = get_column_information(&connection, &name)?
         .into_iter()
         .map(|c| {
             let ty = determine_column_type(&c, &connection)?;
-            let rust_name = rust_name_for_sql_name(&c.column_name);
+            let rust_name = rust_name_for_sql_name(&c.column_name).to_string();
 
             Ok(ColumnDefinition {
                 docs: doc_comment!(

diesel_cli/src/infer_schema_internals/information_schema.rs

@@ -192,7 +192,7 @@ where
     Ok(table_names
         .into_iter()
         .map(|name| TableName {
-            rust_name: inference::rust_name_for_sql_name(&name),
+            rust_name: inference::rust_name_for_sql_name(&name).to_string(),
             sql_name: name,
             schema: schema_name
                 .filter(|&schema| schema != default_schema)

diesel_cli/src/infer_schema_internals/table_data.rs

@@ -9,16 +9,16 @@ use super::inference;
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct TableName {
     pub sql_name: String,
+    pub rust_name: String,
     pub schema: Option<String>,
-    pub rust_name: Option<String>,
 }
 
 impl TableName {
     pub fn from_name<T: Into<String>>(name: T) -> Self {
         let name = name.into();
 
         TableName {
-            rust_name: inference::rust_name_for_sql_name(&name),
+            rust_name: inference::rust_name_for_sql_name(&name).to_string(),
             sql_name: name,
             schema: None,
         }
@@ -32,7 +32,7 @@ impl TableName {
         let name = name.into();
 
         TableName {
-            rust_name: inference::rust_name_for_sql_name(&name),
+            rust_name: inference::rust_name_for_sql_name(&name).to_string(),
             sql_name: name,
             schema: Some(schema.into()),
         }
@@ -67,7 +67,7 @@ where
 
 impl fmt::Display for TableName {
     fn fmt(&self, out: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        let name = self.rust_name.as_ref().unwrap_or(&self.sql_name);
+        let name = &self.rust_name;
 
         match self.schema {
             Some(ref schema_name) => write!(out, "{}.{}", schema_name, name),

diesel_cli/src/print_schema.rs

@@ -163,10 +163,10 @@ impl<'a> Display for TableDefinitions<'a> {
                 let mut out = PadAdapter::new(f);
                 writeln!(out)?;
                 for table in &self.tables {
-                    if let Some(ref rust_name) = &table.name.rust_name {
-                        writeln!(out, "{},", rust_name)?;
-                    } else {
+                    if table.name.rust_name == table.name.sql_name {
                         writeln!(out, "{},", table.name.sql_name)?;
+                    } else {
+                        writeln!(out, "{},", table.name.rust_name)?;
                     }
                 }
             }
@@ -203,7 +203,7 @@ impl<'a> Display for TableDefinition<'a> {
                 }
             }
 
-            if self.table.name.rust_name.is_some() {
+            if self.table.name.rust_name != self.table.name.sql_name {
                 writeln!(
                     out,
                     r#"#[sql_name = "{}"]"#,
@@ -250,11 +250,11 @@ impl<'a> Display for ColumnDefinitions<'a> {
                         writeln!(out, "///{}{}", if d.is_empty() { "" } else { " " }, d)?;
                     }
                 }
-                if let Some(ref rust_name) = column.rust_name {
-                    writeln!(out, r#"#[sql_name = "{}"]"#, column.sql_name)?;
-                    writeln!(out, "{} -> {},", rust_name, column.ty)?;
-                } else {
+                if column.rust_name == column.sql_name {
                     writeln!(out, "{} -> {},", column.sql_name, column.ty)?;
+                } else {
+                    writeln!(out, r#"#[sql_name = "{}"]"#, column.sql_name)?;
+                    writeln!(out, "{} -> {},", column.rust_name, column.ty)?;
                 }
             }
         }
@@ -267,19 +267,9 @@ struct Joinable<'a>(&'a ForeignKeyConstraint);
 
 impl<'a> Display for Joinable<'a> {
     fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        let child_table_name = self
-            .0
-            .child_table
-            .rust_name
-            .as_ref()
-            .unwrap_or(&self.0.child_table.sql_name);
-
-        let parent_table_name = self
-            .0
-            .parent_table
-            .rust_name
-            .as_ref()
-            .unwrap_or(&self.0.parent_table.sql_name);
+        let child_table_name = &self.0.child_table.rust_name;
+
+        let parent_table_name = &self.0.parent_table.rust_name;
 
         write!(
             f,