Create Record type (#10103)

# Description
This PR creates a new `Record` type to reduce duplicate code and
possibly bugs as well. (This is an edited version of #9648.)
- `Record` implements `FromIterator` and `IntoIterator` and so can be
iterated over or collected into. For example, this helps with
conversions to and from (hash)maps. (Also, no more
`cols.iter().zip(vals)`!)
- `Record` has a `push(col, val)` function to help insure that the
number of columns is equal to the number of values. I caught a few
potential bugs thanks to this (e.g. in the `ls` command).
- Finally, this PR also adds a `record!` macro that helps simplify
record creation. It is used like so:
   ```rust
   record! {
       "key1" => some_value,
       "key2" => Value::string("text", span),
       "key3" => Value::int(optional_int.unwrap_or(0), span),
       "key4" => Value::bool(config.setting, span),
   }
   ```
Since macros hinder formatting, etc., the right hand side values should
be relatively short and sweet like the examples above.

Where possible, prefer `record!` or `.collect()` on an iterator instead
of multiple `Record::push`s, since the first two automatically set the
record capacity and do less work overall.

# User-Facing Changes
Besides the changes in `nu-protocol` the only other breaking changes are
to `nu-table::{ExpandedTable::build_map, JustTable::kv_table}`.

crates/nu-command/src/database/commands/into_sqlite.rs

@@ -7,7 +7,6 @@ use nu_protocol::{
     Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span, Spanned,
     SyntaxShape, Type, Value,
 };
-use std::iter;
 use std::path::Path;
 
 #[derive(Clone)]
@@ -127,12 +126,9 @@ fn action(
                     format!(
                         "({})",
                         match list_value {
-                            Value::Record {
-                                cols: _,
-                                vals,
-                                span: _,
-                            } => {
-                                vals.iter()
+                            Value::Record { val, .. } => {
+                                val.vals
+                                    .iter()
                                     .map(|rec_val| {
                                         format!("'{}'", nu_value_to_string(rec_val.clone(), ""))
                                     })
@@ -249,14 +245,13 @@ fn nu_value_to_string(value: Value, separator: &str) -> String {
             nu_utils::strip_ansi_unlikely(&val).replace('\'', "''")
         }
         Value::List { vals: val, .. } => val
-            .iter()
-            .map(|x| nu_value_to_string(x.clone(), ", "))
+            .into_iter()
+            .map(|x| nu_value_to_string(x, ", "))
             .collect::<Vec<_>>()
             .join(separator),
-        Value::Record { cols, vals, .. } => cols
-            .iter()
-            .zip(vals.iter())
-            .map(|(x, y)| format!("{}: {}", x, nu_value_to_string(y.clone(), ", ")))
+        Value::Record { val, .. } => val
+            .into_iter()
+            .map(|(x, y)| format!("{}: {}", x, nu_value_to_string(y, ", ")))
             .collect::<Vec<_>>()
             .join(separator),
         Value::LazyRecord { val, .. } => match val.collect() {
@@ -305,8 +300,8 @@ fn get_columns_with_sqlite_types(input: &[Value]) -> Vec<(String, String)> {
         //     sqlite_type
         // );
 
-        if let Value::Record { cols, vals, .. } = item {
-            for (c, v) in iter::zip(cols, vals) {
+        if let Value::Record { val, .. } = item {
+            for (c, v) in val {
                 if !columns.iter().any(|(name, _)| name == c) {
                     columns.push((
                         c.to_string(),

crates/nu-command/src/database/commands/schema.rs

@@ -3,7 +3,7 @@ use crate::database::values::definitions::{db_row::DbRow, db_table::DbTable};
 use nu_protocol::{
     ast::Call,
     engine::{Command, EngineState, Stack},
-    Category, Example, PipelineData, ShellError, Signature, Span, Type, Value,
+    record, Category, Example, PipelineData, Record, ShellError, Signature, Span, Type, Value,
 };
 use rusqlite::Connection;
 #[derive(Clone)]
@@ -43,8 +43,6 @@ impl Command for SchemaDb {
         call: &Call,
         input: PipelineData,
     ) -> Result<PipelineData, ShellError> {
-        let mut cols = vec![];
-        let mut vals = vec![];
         let span = call.head;
 
         let sqlite_db = SQLiteDatabase::try_from_pipeline(input, span)?;
@@ -59,58 +57,32 @@ impl Command for SchemaDb {
             )
         })?;
 
-        let mut table_names = vec![];
-        let mut table_values = vec![];
+        let mut tables_record = Record::new();
         for table in tables {
             let column_info = get_table_columns(&sqlite_db, &conn, &table, span)?;
             let constraint_info = get_table_constraints(&sqlite_db, &conn, &table, span)?;
             let foreign_key_info = get_table_foreign_keys(&sqlite_db, &conn, &table, span)?;
             let index_info = get_table_indexes(&sqlite_db, &conn, &table, span)?;
 
-            let mut cols = vec![];
-            let mut vals = vec![];
-
-            cols.push("columns".into());
-            vals.push(Value::List {
-                vals: column_info,
-                span,
-            });
-
-            cols.push("constraints".into());
-            vals.push(Value::List {
-                vals: constraint_info,
-                span,
-            });
-
-            cols.push("foreign_keys".into());
-            vals.push(Value::List {
-                vals: foreign_key_info,
-                span,
-            });
-
-            cols.push("indexes".into());
-            vals.push(Value::List {
-                vals: index_info,
-                span,
-            });
-
-            table_names.push(table.name);
-            table_values.push(Value::Record { cols, vals, span });
+            tables_record.push(
+                table.name,
+                Value::record(
+                    record! {
+                        "columns" => Value::list(column_info, span),
+                        "constraints" => Value::list(constraint_info, span),
+                        "foreign_keys" => Value::list(foreign_key_info, span),
+                        "indexes" => Value::list(index_info, span),
+                    },
+                    span,
+                ),
+            );
         }
 
-        cols.push("tables".into());
-        vals.push(Value::Record {
-            cols: table_names,
-            vals: table_values,
-            span,
-        });
+        let record = record! { "tables" => Value::record(tables_record, span) };
 
         // TODO: add views and triggers
 
-        Ok(PipelineData::Value(
-            Value::Record { cols, vals, span },
-            None,
-        ))
+        Ok(PipelineData::Value(Value::record(record, span), None))
     }
 }
 
@@ -145,19 +117,14 @@ fn get_table_columns(
     // a record of column name = column value
     let mut column_info = vec![];
     for t in columns {
-        let mut col_names = vec![];
-        let mut col_values = vec![];
-        let fields = t.fields();
-        let columns = t.columns();
-        for (k, v) in fields.iter().zip(columns.iter()) {
-            col_names.push(k.clone());
-            col_values.push(Value::string(v.clone(), span));
-        }
-        column_info.push(Value::Record {
-            cols: col_names.clone(),
-            vals: col_values.clone(),
+        column_info.push(Value::record(
+            t.fields()
+                .into_iter()
+                .zip(t.columns())
+                .map(|(k, v)| (k, Value::string(v, span)))
+                .collect(),
             span,
-        });
+        ));
     }
 
     Ok(column_info)
@@ -180,19 +147,15 @@ fn get_table_constraints(
     })?;
     let mut constraint_info = vec![];
     for constraint in constraints {
-        let mut con_cols = vec![];
-        let mut con_vals = vec![];
-        let fields = constraint.fields();
-        let columns = constraint.columns();
-        for (k, v) in fields.iter().zip(columns.iter()) {
-            con_cols.push(k.clone());
-            con_vals.push(Value::string(v.clone(), span));
-        }
-        constraint_info.push(Value::Record {
-            cols: con_cols.clone(),
-            vals: con_vals.clone(),
+        constraint_info.push(Value::record(
+            constraint
+                .fields()
+                .into_iter()
+                .zip(constraint.columns())
+                .map(|(k, v)| (k, Value::string(v, span)))
+                .collect(),
             span,
-        });
+        ));
     }
 
     Ok(constraint_info)
@@ -215,19 +178,14 @@ fn get_table_foreign_keys(
     })?;
     let mut foreign_key_info = vec![];
     for fk in foreign_keys {
-        let mut fk_cols = vec![];
-        let mut fk_vals = vec![];
-        let fields = fk.fields();
-        let columns = fk.columns();
-        for (k, v) in fields.iter().zip(columns.iter()) {
-            fk_cols.push(k.clone());
-            fk_vals.push(Value::string(v.clone(), span));
-        }
-        foreign_key_info.push(Value::Record {
-            cols: fk_cols.clone(),
-            vals: fk_vals.clone(),
+        foreign_key_info.push(Value::record(
+            fk.fields()
+                .into_iter()
+                .zip(fk.columns())
+                .map(|(k, v)| (k, Value::string(v, span)))
+                .collect(),
             span,
-        });
+        ));
     }
 
     Ok(foreign_key_info)
@@ -250,19 +208,15 @@ fn get_table_indexes(
     })?;
     let mut index_info = vec![];
     for index in indexes {
-        let mut idx_cols = vec![];
-        let mut idx_vals = vec![];
-        let fields = index.fields();
-        let columns = index.columns();
-        for (k, v) in fields.iter().zip(columns.iter()) {
-            idx_cols.push(k.clone());
-            idx_vals.push(Value::string(v.clone(), span));
-        }
-        index_info.push(Value::Record {
-            cols: idx_cols.clone(),
-            vals: idx_vals.clone(),
+        index_info.push(Value::record(
+            index
+                .fields()
+                .into_iter()
+                .zip(index.columns())
+                .map(|(k, v)| (k, Value::string(v, span)))
+                .collect(),
             span,
-        });
+        ));
     }
 
     Ok(index_info)

crates/nu-command/src/database/values/sqlite.rs

@@ -3,7 +3,7 @@ use super::definitions::{
     db_index::DbIndex, db_table::DbTable,
 };
 
-use nu_protocol::{CustomValue, PipelineData, ShellError, Span, Spanned, Value};
+use nu_protocol::{CustomValue, PipelineData, Record, ShellError, Span, Spanned, Value};
 use rusqlite::{types::ValueRef, Connection, Row};
 use serde::{Deserialize, Serialize};
 use std::{
@@ -415,8 +415,7 @@ fn read_entire_sqlite_db(
     call_span: Span,
     ctrlc: Option<Arc<AtomicBool>>,
 ) -> Result<Value, rusqlite::Error> {
-    let mut table_names: Vec<String> = Vec::new();
-    let mut tables: Vec<Value> = Vec::new();
+    let mut tables = Record::new();
 
     let mut get_table_names =
         conn.prepare("SELECT name FROM sqlite_master WHERE type = 'table'")?;
@@ -424,18 +423,12 @@ fn read_entire_sqlite_db(
 
     for row in rows {
         let table_name: String = row?;
-        table_names.push(table_name.clone());
-
         let table_stmt = conn.prepare(&format!("select * from [{table_name}]"))?;
         let rows = prepared_statement_to_nu_list(table_stmt, call_span, ctrlc.clone())?;
-        tables.push(rows);
+        tables.push(table_name, rows);
     }
 
-    Ok(Value::Record {
-        cols: table_names,
-        vals: tables,
-        span: call_span,
-    })
+    Ok(Value::record(tables, call_span))
 }
 
 pub fn convert_sqlite_row_to_nu_value(row: &Row, span: Span, column_names: Vec<String>) -> Value {
@@ -446,11 +439,13 @@ pub fn convert_sqlite_row_to_nu_value(row: &Row, span: Span, column_names: Vec<S
         vals.push(val);
     }
 
-    Value::Record {
-        cols: column_names,
-        vals,
+    Value::record(
+        Record {
+            cols: column_names,
+            vals,
+        },
         span,
-    }
+    )
 }
 
 pub fn convert_sqlite_value_to_nu_value(value: ValueRef, span: Span) -> Value {
@@ -488,11 +483,7 @@ mod test {
         let db = open_connection_in_memory().unwrap();
         let converted_db = read_entire_sqlite_db(db, Span::test_data(), None).unwrap();
 
-        let expected = Value::Record {
-            cols: vec![],
-            vals: vec![],
-            span: Span::test_data(),
-        };
+        let expected = Value::test_record(Record::new());
 
         assert_eq!(converted_db, expected);
     }
@@ -512,14 +503,13 @@ mod test {
         .unwrap();
         let converted_db = read_entire_sqlite_db(db, Span::test_data(), None).unwrap();
 
-        let expected = Value::Record {
+        let expected = Value::test_record(Record {
             cols: vec!["person".to_string()],
             vals: vec![Value::List {
                 vals: vec![],
                 span: Span::test_data(),
             }],
-            span: Span::test_data(),
-        };
+        });
 
         assert_eq!(converted_db, expected);
     }
@@ -546,16 +536,15 @@ mod test {
 
         let converted_db = read_entire_sqlite_db(db, span, None).unwrap();
 
-        let expected = Value::Record {
+        let expected = Value::test_record(Record {
             cols: vec!["item".to_string()],
             vals: vec![Value::List {
                 vals: vec![
-                    Value::Record {
+                    Value::test_record(Record {
                         cols: vec!["id".to_string(), "name".to_string()],
                         vals: vec![Value::Int { val: 123, span }, Value::Nothing { span }],
-                        span,
-                    },
-                    Value::Record {
+                    }),
+                    Value::test_record(Record {
                         cols: vec!["id".to_string(), "name".to_string()],
                         vals: vec![
                             Value::Int { val: 456, span },
@@ -564,13 +553,11 @@ mod test {
                                 span,
                             },
                         ],
-                        span,
-                    },
+                    }),
                 ],
                 span,
             }],
-            span,
-        };
+        });
 
         assert_eq!(converted_db, expected);
     }