tojsonl: refactor boolcheck

use non-allocating to_lowercase_into() and make it more efficient/performant/readable

src/cmd/tojsonl.rs

@@ -165,6 +165,8 @@ pub fn run(argv: &[&str]) -> CliResult<()> {
  args.flag_no_boolean
  };
 
+ let mut lowecase_buffer = String::new();
+
  // create a vec lookup about inferred field data types
  let mut field_type_vec: Vec<JsonlType> = Vec::with_capacity(headers.len());
  for (_field_name, field_def) in &properties_map {
@@ -196,7 +198,7 @@ pub fn run(argv: &[&str]) -> CliResult<()> {
  }
  } else if let Some(str_val) = vals[0].as_str() {
  // else, if its a string, get the first character of val1 lowercase
- boolcheck(str_val)
+ boolcheck(str_val, &mut lowecase_buffer)
  } else {
  '*'
  }
@@ -211,7 +213,7 @@ pub fn run(argv: &[&str]) -> CliResult<()> {
  _ => '*',
  }
  } else if let Some(str_val) = vals[1].as_str() {
- boolcheck(str_val)
+ boolcheck(str_val, &mut lowecase_buffer)
  } else {
  '*'
  };
@@ -290,16 +292,16 @@ pub fn run(argv: &[&str]) -> CliResult<()> {
  .par_iter()
  .map(|record_item| {
  let mut record = record_item.clone();
- let mut temp_string = String::new();
- let mut temp_string2: String;
+ let mut json_string = String::new();
+ let mut temp_string2 = String::new();
 
  let mut header_key = Value::String(String::new());
  let mut temp_val = Value::String(String::new());
 
  if args.flag_trim {
  record.trim();
  }
- write!(temp_string, "{{").unwrap();
+ write!(json_string, "{{").unwrap();
  for (idx, field) in record.iter().enumerate() {
  let field_val = if let Some(field_type) = field_type_vec.get(idx) {
  match field_type {
@@ -317,7 +319,7 @@ pub fn run(argv: &[&str]) -> CliResult<()> {
  JsonlType::Null => "null",
  JsonlType::Integer | JsonlType::Number => field,
  JsonlType::Boolean => {
- if let 't' | 'y' | '1' = boolcheck(field) {
+ if let 't' | 'y' | '1' = boolcheck(field, &mut temp_string2) {
  "true"
  } else {
  "false"
@@ -329,15 +331,15 @@ pub fn run(argv: &[&str]) -> CliResult<()> {
  };
  header_key = headers[idx].into();
  if field_val.is_empty() {
- write!(temp_string, r#"{header_key}:null,"#).unwrap();
+ write!(json_string, r#"{header_key}:null,"#).unwrap();
  } else {
- write!(temp_string, r#"{header_key}:{field_val},"#).unwrap();
+ write!(json_string, r#"{header_key}:{field_val},"#).unwrap();
  }
  }
- temp_string.pop(); // remove last comma
- temp_string.push('}');
+ json_string.pop(); // remove last comma
+ json_string.push('}');
  record.clear();
- record.push_field(&temp_string);
+ record.push_field(&json_string);
  record
  })
  .collect_into_vec(&mut batch_results);
@@ -354,21 +356,23 @@ pub fn run(argv: &[&str]) -> CliResult<()> {
 }
 
 #[inline]
-fn boolcheck(field_str: &str) -> char {
+/// check if a field is a boolean
+/// by checking the first character of the field
+/// and the field's domain is true/false, yes/no
+fn boolcheck(field_str: &str, lowercase_buffer: &mut String) -> char {
  let mut chars = field_str.chars();
  let mut first_char = chars.next().unwrap_or('_');
  first_char.make_ascii_lowercase();
 
  if field_str.len() < 2 {
  return first_char;
  }
- if field_str.eq_ignore_ascii_case("true")
- || field_str.eq_ignore_ascii_case("false")
- || field_str.eq_ignore_ascii_case("yes")
- || field_str.eq_ignore_ascii_case("no")
- {
- first_char
- } else {
- '_'
+
+ // we use to_lowercase_into to avoid allocations for this function
+ // which is called in a hot loop
+ util::to_lowercase_into(field_str, lowercase_buffer);
+ match lowercase_buffer.as_str() {
+ "true" | "false" | "yes" | "no" => first_char,
+ _ => '_',
  }
 }