Turn type Ident into struct Ident

The Ident type was previously an alias for a String. Turn it into a full
fledged struct, so that the parser can preserve the distinction between
identifier value and quote style already made by the tokenizer's Word
structure.

Author: Robert Grimm

src/ast/mod.rs

@@ -90,8 +90,61 @@ where
     DisplaySeparated { slice, sep: ", " }
 }
 
-/// Identifier name, in the originally quoted form (e.g. `"id"`)
-pub type Ident = String;
+/// An identifier, decomposed into its value or character data and the quote style.
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Ident {
+    /// The value of the identifier without quotes.
+    pub value: String,
+    /// The starting quote if any. Valid quote characters are the single quote,
+    /// double quote, backtick, and opening square bracket.
+    pub quote_style: Option<char>,
+}
+
+impl Ident {
+    /// Create a new identifier with the given value and no quotes.
+    pub fn new<S>(value: S) -> Self
+    where
+        S: Into<String>,
+    {
+        Ident {
+            value: value.into(),
+            quote_style: None,
+        }
+    }
+
+    /// Create a new quoted identifier with the given quote and value. This function
+    /// panics if the given quote is not a valid quote character.
+    pub fn with_quote<S>(quote: char, value: S) -> Self
+    where
+        S: Into<String>,
+    {
+        assert!(quote == '\'' || quote == '"' || quote == '`' || quote == '[');
+        Ident {
+            value: value.into(),
+            quote_style: Some(quote),
+        }
+    }
+}
+
+impl From<&str> for Ident {
+    fn from(value: &str) -> Self {
+        Ident {
+            value: value.to_string(),
+            quote_style: None,
+        }
+    }
+}
+
+impl fmt::Display for Ident {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self.quote_style {
+            Some(q) if q == '"' || q == '\'' || q == '`' => write!(f, "{}{}{}", q, self.value, q),
+            Some(q) if q == '[' => write!(f, "[{}]", self.value),
+            None => f.write_str(&self.value),
+            _ => panic!("unexpected quote style"),
+        }
+    }
+}
 
 /// A name of a table, view, custom type, etc., possibly multi-part, i.e. db.schema.obj
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -210,7 +263,7 @@ pub enum Expr {
 impl fmt::Display for Expr {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Expr::Identifier(s) => f.write_str(s),
+            Expr::Identifier(s) => write!(f, "{}", s),
             Expr::Wildcard => f.write_str("*"),
             Expr::QualifiedWildcard(q) => write!(f, "{}.*", display_separated(q, ".")),
             Expr::CompoundIdentifier(s) => write!(f, "{}", display_separated(s, ".")),
@@ -1092,7 +1145,7 @@ impl fmt::Display for SetVariableValue {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use SetVariableValue::*;
         match self {
-            Ident(ident) => f.write_str(ident),
+            Ident(ident) => write!(f, "{}", ident),
             Literal(literal) => write!(f, "{}", literal),
         }
     }

src/parser.rs

@@ -216,11 +216,11 @@ impl Parser {
                 // identifier, a function call, or a simple identifier:
                 _ => match self.peek_token() {
                     Some(Token::LParen) | Some(Token::Period) => {
-                        let mut id_parts: Vec<Ident> = vec![w.as_ident()];
+                        let mut id_parts: Vec<Ident> = vec![w.to_ident()];
                         let mut ends_with_wildcard = false;
                         while self.consume_token(&Token::Period) {
                             match self.next_token() {
-                                Some(Token::Word(w)) => id_parts.push(w.as_ident()),
+                                Some(Token::Word(w)) => id_parts.push(w.to_ident()),
                                 Some(Token::Mult) => {
                                     ends_with_wildcard = true;
                                     break;
@@ -240,7 +240,7 @@ impl Parser {
                             Ok(Expr::CompoundIdentifier(id_parts))
                         }
                     }
-                    _ => Ok(Expr::Identifier(w.as_ident())),
+                    _ => Ok(Expr::Identifier(w.to_ident())),
                 },
             }, // End of Token::Word
             Token::Mult => Ok(Expr::Wildcard),
@@ -1129,7 +1129,7 @@ impl Parser {
         let table_name = self.parse_object_name()?;
         let (columns, constraints) = self.parse_columns()?;
         self.expect_keywords(&["STORED", "AS"])?;
-        let file_format = self.parse_identifier()?.parse::<FileFormat>()?;
+        let file_format = self.parse_identifier()?.value.parse::<FileFormat>()?;
 
         self.expect_keyword("LOCATION")?;
         let location = self.parse_literal_string()?;
@@ -1257,7 +1257,7 @@ impl Parser {
                 }
 
                 columns.push(ColumnDef {
-                    name: column_name.as_ident(),
+                    name: column_name.to_ident(),
                     data_type,
                     collation,
                     options,
@@ -1599,11 +1599,11 @@ impl Parser {
             Some(Token::Word(ref w))
                 if after_as || !reserved_kwds.contains(&w.keyword.as_str()) =>
             {
-                Ok(Some(w.as_ident()))
+                Ok(Some(w.to_ident()))
             }
             // MSSQL supports single-quoted strings as aliases for columns
             // We accept them as table aliases too, although MSSQL does not.
-            Some(Token::SingleQuotedString(ref s)) => Ok(Some(format!("'{}'", s))),
+            Some(Token::SingleQuotedString(ref s)) => Ok(Some(Ident::with_quote('\'', s.clone()))),
             not_an_ident => {
                 if after_as {
                     return self.expected("an identifier after AS", not_an_ident);
@@ -1647,7 +1647,7 @@ impl Parser {
     /// Parse a simple one-word identifier (possibly quoted, possibly a keyword)
     pub fn parse_identifier(&mut self) -> Result<Ident, ParserError> {
         match self.next_token() {
-            Some(Token::Word(w)) => Ok(w.as_ident()),
+            Some(Token::Word(w)) => Ok(w.to_ident()),
             unexpected => self.expected("identifier", unexpected),
         }
     }
@@ -1890,15 +1890,15 @@ impl Parser {
             let token = self.peek_token();
             let value = match (self.parse_value(), token) {
                 (Ok(value), _) => SetVariableValue::Literal(value),
-                (Err(_), Some(Token::Word(ident))) => SetVariableValue::Ident(ident.as_ident()),
+                (Err(_), Some(Token::Word(ident))) => SetVariableValue::Ident(ident.to_ident()),
                 (Err(_), other) => self.expected("variable value", other)?,
             };
             Ok(Statement::SetVariable {
                 local: modifier == Some("LOCAL"),
                 variable,
                 value,
             })
-        } else if variable == "TRANSACTION" && modifier.is_none() {
+        } else if variable.value == "TRANSACTION" && modifier.is_none() {
             Ok(Statement::SetTransaction {
                 modes: self.parse_transaction_modes()?,
             })
@@ -2386,8 +2386,11 @@ impl Parser {
 }
 
 impl Word {
-    pub fn as_ident(&self) -> Ident {
-        self.to_string()
+    pub fn to_ident(&self) -> Ident {
+        Ident {
+            value: self.value.clone(),
+            quote_style: self.quote_style,
+        }
     }
 }