Minor: Simplify IdentTaker

datafusion/sql/src/planner.rs

@@ -622,21 +622,37 @@ pub fn object_name_to_table_reference(
     idents_to_table_reference(idents, enable_normalization)
 }
 
-struct IdentTaker(Vec<Ident>);
+struct IdentTaker {
+    normalizer: IdentNormalizer,
+    idents: Vec<Ident>,
+}
+
 /// Take the next identifier from the back of idents, panic'ing if
 /// there are none left
 impl IdentTaker {
-    fn take(&mut self, enable_normalization: bool) -> String {
-        let ident = self.0.pop().expect("no more identifiers");
-        IdentNormalizer::new(enable_normalization).normalize(ident)
+    fn new(idents: Vec<Ident>, enable_normalization: bool) -> Self {
+        Self {
+            normalizer: IdentNormalizer::new(enable_normalization),
+            idents,
+        }
+    }
+
+    fn take(&mut self) -> String {
+        let ident = self.idents.pop().expect("no more identifiers");
+        self.normalizer.normalize(ident)
+    }
+
+    /// Returns the number of remaining identifiers
+    fn len(&self) -> usize {
+        self.idents.len()
     }
 }
 
 // impl Display for a nicer error message
 impl std::fmt::Display for IdentTaker {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut first = true;
-        for ident in self.0.iter() {
+        for ident in self.idents.iter() {
             if !first {
                 write!(f, ".")?;
             }
@@ -653,29 +669,28 @@ pub(crate) fn idents_to_table_reference(
     idents: Vec<Ident>,
     enable_normalization: bool,
 ) -> Result<TableReference> {
-    let mut taker = IdentTaker(idents);
-    let num_idents = taker.0.len();
+    let mut taker = IdentTaker::new(idents, enable_normalization);
 
-    match num_idents {
+    match taker.len() {
         1 => {
-            let table = taker.take(enable_normalization);
+            let table = taker.take();
             Ok(TableReference::bare(table))
         }
         2 => {
-            let table = taker.take(enable_normalization);
-            let schema = taker.take(enable_normalization);
+            let table = taker.take();
+            let schema = taker.take();
             Ok(TableReference::partial(schema, table))
         }
         3 => {
-            let table = taker.take(enable_normalization);
-            let schema = taker.take(enable_normalization);
-            let catalog = taker.take(enable_normalization);
+            let table = taker.take();
+            let schema = taker.take();
+            let catalog = taker.take();
             Ok(TableReference::full(catalog, schema, table))
         }
         _ => plan_err!(
             "Unsupported compound identifier '{}'. Expected 1, 2 or 3 parts, got {}",
             taker,
-            num_idents
+            taker.len()
         ),
     }
 }

datafusion/sql/src/utils.rs

@@ -259,7 +259,7 @@ pub(crate) fn make_decimal_type(
     }
 }
 
-// Normalize an owned identifier to a lowercase string unless the identifier is quoted.
+/// Normalize an owned identifier to a lowercase string, unless the identifier is quoted.
 pub(crate) fn normalize_ident(id: Ident) -> String {
     match id.quote_style {
         Some(_) => id.value,