extern/nushell
1
0
Fork 1
mirror of https://github.com/nushell/nushell.git synced 2025-08-09 12:15:42 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove Record::from_raw_cols_vals_unchecked (#11810)

Browse Source 
# Description
Follows from #11718 and replaces all usages of
`Record::from_raw_cols_vals_unchecked` with iterator or `record!`
equivalents.
This commit is contained in:
Ian Manske
2024-02-18 12:20:22 +00:00
committed by GitHub
parent 28f0f32ae7
commit fb4251aba7
18 changed files with 267 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
crates/nu-command/src/charting/histogram.rs
View File

@ -4,7 +4,7 @@ use nu_engine::CallExt;
use nu_protocol::ast::Call;
use nu_protocol::engine::{Command, EngineState, Stack};
use nu_protocol::{
record, Category, Example, IntoPipelineData, PipelineData, Record, ShellError, Signature, Span,
record, Category, Example, IntoPipelineData, PipelineData, ShellError, Signature, Span,
Spanned, SyntaxShape, Type, Value,
};
use std::collections::HashMap;
@ -239,13 +239,6 @@ fn histogram_impl(
}
let mut result = vec![];
let result_cols = vec![
value_column_name.to_string(),
"count".to_string(),
"quantile".to_string(),
"percentage".to_string(),
freq_column.to_string(),
];
const MAX_FREQ_COUNT: f64 = 100.0;
for (val, count) in counter.into_iter().sorted() {
let quantile = match calc_method {
@ -259,16 +252,13 @@ fn histogram_impl(
result.push((
count, // attach count first for easily sorting.
Value::record(
Record::from_raw_cols_vals_unchecked(
result_cols.clone(),
vec![
val.into_value(),
Value::int(count, span),
Value::float(quantile, span),
Value::string(percentage, span),
Value::string(freq, span),
],
),
record! {
value_column_name => val.into_value(),
"count" => Value::int(count, span),
"quantile" => Value::float(quantile, span),
"percentage" => Value::string(percentage, span),
freq_column => Value::string(freq, span),
},
span,
),
));

29
crates/nu-command/src/database/values/sqlite.rs
View File

@ -441,15 +441,15 @@ fn prepared_statement_to_nu_list(
) -> Result<Value, SqliteError> {
let column_names = stmt
.column_names()
.iter()
.map(|c| c.to_string())
.into_iter()
.map(String::from)
.collect::<Vec<String>>();
let row_results = stmt.query_map([], |row| {
Ok(convert_sqlite_row_to_nu_value(
row,
call_span,
column_names.clone(),
&column_names,
))
})?;
@ -491,18 +491,19 @@ fn read_entire_sqlite_db(
Ok(Value::record(tables, call_span))
}
pub fn convert_sqlite_row_to_nu_value(row: &Row, span: Span, column_names: Vec<String>) -> Value {
let mut vals = Vec::with_capacity(column_names.len());
pub fn convert_sqlite_row_to_nu_value(row: &Row, span: Span, column_names: &[String]) -> Value {
let record = column_names
.iter()
.enumerate()
.map(|(i, col)| {
(
col.clone(),
convert_sqlite_value_to_nu_value(row.get_ref_unwrap(i), span),
)
})
.collect();
for i in 0..column_names.len() {
let val = convert_sqlite_value_to_nu_value(row.get_ref_unwrap(i), span);
vals.push(val);
}
Value::record(
Record::from_raw_cols_vals_unchecked(column_names, vals),
span,
)
Value::record(record, span)
}
pub fn convert_sqlite_value_to_nu_value(value: ValueRef, span: Span) -> Value {

42
crates/nu-command/src/formats/from/delimited.rs
View File

@ -1,5 +1,5 @@
use csv::{ReaderBuilder, Trim};
use nu_protocol::{IntoPipelineData, PipelineData, Record, ShellError, Span, Value};
use nu_protocol::{IntoPipelineData, PipelineData, ShellError, Span, Value};
fn from_delimited_string_to_value(
DelimitedReaderConfig {
@ -36,28 +36,28 @@ fn from_delimited_string_to_value(
let mut rows = vec![];
for row in reader.records() {
let row = row?;
let output_row = (0..headers.len())
.map(|i| {
row.get(i)
.map(|value| {
if no_infer {
Value::string(value.to_string(), span)
} else if let Ok(i) = value.parse::<i64>() {
Value::int(i, span)
} else if let Ok(f) = value.parse::<f64>() {
Value::float(f, span)
} else {
Value::string(value.to_string(), span)
}
})
.unwrap_or(Value::nothing(span))
let columns = headers.iter().cloned();
let values = row
.into_iter()
.map(|s| {
if no_infer {
Value::string(s, span)
} else if let Ok(i) = s.parse() {
Value::int(i, span)
} else if let Ok(f) = s.parse() {
Value::float(f, span)
} else {
Value::string(s, span)
}
})
.collect::<Vec<Value>>();
.chain(std::iter::repeat(Value::nothing(span)));
rows.push(Value::record(
Record::from_raw_cols_vals_unchecked(headers.clone(), output_row),
span,
));
// If there are more values than the number of headers,
// then the remaining values are ignored.
//
// Otherwise, if there are less values than headers,
// then `Value::nothing(span)` is used to fill the remaining columns.
rows.push(Value::record(columns.zip(values).collect(), span));
}
Ok(Value::list(rows, span))

15
crates/nu-command/src/formats/from/nuon.rs
View File

@ -421,15 +421,16 @@ fn convert_to_value(
span: expr.span,
});
}
let vals: Vec<Value> = row
.into_iter()
.map(|cell| convert_to_value(cell, span, original_text))
let record = cols
.iter()
.zip(row)
.map(|(col, cell)| {
convert_to_value(cell, span, original_text).map(|val| (col.clone(), val))
})
.collect::<Result<_, _>>()?;
output.push(Value::record(
Record::from_raw_cols_vals_unchecked(cols.clone(), vals),
span,
));
output.push(Value::record(record, span));
}
Ok(Value::list(output, span))

36
crates/nu-command/src/strings/detect_columns.rs
View File

@ -136,13 +136,11 @@ fn detect_columns(
.map(move |x| {
let row = find_columns(&x);
let mut cols = vec![];
let mut vals = vec![];
let mut record = Record::new();
if headers.len() == row.len() {
for (header, val) in headers.iter().zip(row.iter()) {
cols.push(header.item.clone());
vals.push(Value::string(val.item.clone(), name_span));
record.push(&header.item, Value::string(&val.item, name_span));
}
} else {
let mut pre_output = vec![];
@ -176,8 +174,7 @@ fn detect_columns(
for header in &headers {
for pre_o in &pre_output {
if pre_o.0 == header.item {
cols.push(header.item.clone());
vals.push(pre_o.1.clone())
record.push(&header.item, pre_o.1.clone());
}
}
}
@ -187,25 +184,25 @@ fn detect_columns(
match nu_cmd_base::util::process_range(range) {
Ok((l_idx, r_idx)) => {
let l_idx = if l_idx < 0 {
cols.len() as isize + l_idx
record.len() as isize + l_idx
} else {
l_idx
};
let r_idx = if r_idx < 0 {
cols.len() as isize + r_idx
record.len() as isize + r_idx
} else {
r_idx
};
if !(l_idx <= r_idx && (r_idx >= 0 || l_idx < (cols.len() as isize))) {
return Value::record(
Record::from_raw_cols_vals_unchecked(cols, vals),
name_span,
);
if !(l_idx <= r_idx && (r_idx >= 0 || l_idx < (record.len() as isize))) {
return Value::record(record, name_span);
}
(l_idx.max(0) as usize, (r_idx as usize + 1).min(cols.len()))
(
l_idx.max(0) as usize,
(r_idx as usize + 1).min(record.len()),
)
}
Err(processing_error) => {
let err = processing_error("could not find range index", name_span);
@ -213,9 +210,11 @@ fn detect_columns(
}
}
} else {
return Value::record(Record::from_raw_cols_vals_unchecked(cols, vals), name_span);
return Value::record(record, name_span);
};
let (mut cols, mut vals): (Vec<_>, Vec<_>) = record.into_iter().unzip();
// Merge Columns
((start_index + 1)..(cols.len() - end_index + start_index + 1)).for_each(|idx| {
cols.swap(idx, end_index - start_index - 1 + idx);
@ -233,9 +232,12 @@ fn detect_columns(
let last_seg = vals.split_off(end_index);
vals.truncate(start_index);
vals.push(binding);
last_seg.into_iter().for_each(|v| vals.push(v));
vals.extend(last_seg);
Value::record(Record::from_raw_cols_vals_unchecked(cols, vals), name_span)
match Record::from_raw_cols_vals(cols, vals, Span::unknown(), name_span) {
Ok(record) => Value::record(record, name_span),
Err(err) => Value::error(err, name_span),
}
})
.into_pipeline_data(ctrlc))
} else {