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

Remove Span::unknown (#525)

Browse Source
This commit is contained in:
JT
2021-12-19 18:46:13 +11:00
committed by GitHub
parent b54e9b6bfd
commit 2883d6cd1e
183 changed files with 1291 additions and 1124 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
crates/nu-command/src/dataframe/append.rs
View File

@ -34,13 +34,25 @@ impl Command for AppendDF {
$a | dfr append $a"#,
result: Some(
NuDataFrame::try_from_columns(vec![
Column::new("a".to_string(), vec![1.into(), 3.into()]),
Column::new("b".to_string(), vec![2.into(), 4.into()]),
Column::new("a_x".to_string(), vec![1.into(), 3.into()]),
Column::new("b_x".to_string(), vec![2.into(), 4.into()]),
Column::new(
"a".to_string(),
vec![Value::test_int(1), Value::test_int(3)],
),
Column::new(
"b".to_string(),
vec![Value::test_int(2), Value::test_int(4)],
),
Column::new(
"a_x".to_string(),
vec![Value::test_int(1), Value::test_int(3)],
),
Column::new(
"b_x".to_string(),
vec![Value::test_int(2), Value::test_int(4)],
),
])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
Example {
@ -51,15 +63,25 @@ impl Command for AppendDF {
NuDataFrame::try_from_columns(vec![
Column::new(
"a".to_string(),
vec![1.into(), 3.into(), 1.into(), 3.into()],
vec![
Value::test_int(1),
Value::test_int(3),
Value::test_int(1),
Value::test_int(3),
],
),
Column::new(
"b".to_string(),
vec![2.into(), 4.into(), 2.into(), 4.into()],
vec![
Value::test_int(2),
Value::test_int(4),
Value::test_int(2),
Value::test_int(4),
],
),
])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
]

6
crates/nu-command/src/dataframe/column.rs
View File

@ -2,7 +2,7 @@ use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape,
Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
};
use super::values::{Column, NuDataFrame};
@ -32,10 +32,10 @@ impl Command for ColumnDF {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"a".to_string(),
vec![1.into(), 3.into()],
vec![Value::test_int(1), Value::test_int(3)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

64
crates/nu-command/src/dataframe/describe.rs
View File

@ -3,7 +3,7 @@ use super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::{
chunked_array::ChunkedArray,
@ -37,51 +37,51 @@ impl Command for DescribeDF {
Column::new(
"descriptor".to_string(),
vec![
"count".to_string().into(),
"sum".to_string().into(),
"mean".to_string().into(),
"median".to_string().into(),
"std".to_string().into(),
"min".to_string().into(),
"25%".to_string().into(),
"50%".to_string().into(),
"75%".to_string().into(),
"max".to_string().into(),
Value::test_string("count"),
Value::test_string("sum"),
Value::test_string("mean"),
Value::test_string("median"),
Value::test_string("std"),
Value::test_string("min"),
Value::test_string("25%"),
Value::test_string("50%"),
Value::test_string("75%"),
Value::test_string("max"),
],
),
Column::new(
"a (i64)".to_string(),
vec![
2.0.into(),
2.0.into(),
1.0.into(),
1.0.into(),
0.0.into(),
1.0.into(),
1.0.into(),
1.0.into(),
1.0.into(),
1.0.into(),
Value::test_float(2.0),
Value::test_float(2.0),
Value::test_float(1.0),
Value::test_float(1.0),
Value::test_float(0.0),
Value::test_float(1.0),
Value::test_float(1.0),
Value::test_float(1.0),
Value::test_float(1.0),
Value::test_float(1.0),
],
),
Column::new(
"b (i64)".to_string(),
vec![
2.0.into(),
2.0.into(),
1.0.into(),
1.0.into(),
0.0.into(),
1.0.into(),
1.0.into(),
1.0.into(),
1.0.into(),
1.0.into(),
Value::test_float(2.0),
Value::test_float(2.0),
Value::test_float(1.0),
Value::test_float(1.0),
Value::test_float(0.0),
Value::test_float(1.0),
Value::test_float(1.0),
Value::test_float(1.0),
Value::test_float(1.0),
Value::test_float(1.0),
],
),
])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

4
crates/nu-command/src/dataframe/drop.rs
View File

@ -33,10 +33,10 @@ impl Command for DropDF {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"b".to_string(),
vec![2.into(), 4.into()],
vec![Value::test_int(2), Value::test_int(4)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

28
crates/nu-command/src/dataframe/drop_nulls.rs
View File

@ -40,12 +40,21 @@ impl Command for DropNulls {
$a | dfr drop-nulls"#,
result: Some(
NuDataFrame::try_from_columns(vec![
Column::new("a".to_string(), vec![1.into(), 1.into()]),
Column::new("b".to_string(), vec![2.into(), 2.into()]),
Column::new("res".to_string(), vec![1.into(), 1.into()]),
Column::new(
"a".to_string(),
vec![Value::test_int(1), Value::test_int(1)],
),
Column::new(
"b".to_string(),
vec![Value::test_int(2), Value::test_int(2)],
),
Column::new(
"res".to_string(),
vec![Value::test_int(1), Value::test_int(1)],
),
])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
Example {
@ -55,10 +64,15 @@ impl Command for DropNulls {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"div_0_0".to_string(),
vec![1.into(), 1.into(), 1.into(), 1.into()],
vec![
Value::test_int(1),
Value::test_int(1),
Value::test_int(1),
Value::test_int(1),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
]
@ -94,7 +108,7 @@ fn command(
.collect::<Vec<String>>();
(Some(agg_string), col_span)
}
None => (None, Span::unknown()),
None => (None, call.head),
};
let subset_slice = subset.as_ref().map(|cols| &cols[..]);

6
crates/nu-command/src/dataframe/dtypes.rs
View File

@ -29,15 +29,15 @@ impl Command for DataTypes {
NuDataFrame::try_from_columns(vec![
Column::new(
"column".to_string(),
vec!["a".to_string().into(), "b".to_string().into()],
vec![Value::test_string("a"), Value::test_string("b")],
),
Column::new(
"dtype".to_string(),
vec!["i64".to_string().into(), "i64".to_string().into()],
vec![Value::test_string("i64"), Value::test_string("i64")],
),
])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

8
crates/nu-command/src/dataframe/series/all_false.rs
View File

@ -30,10 +30,10 @@ impl Command for AllFalse {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"all_false".to_string(),
vec![true.into()],
vec![Value::test_bool(true)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
Example {
@ -44,10 +44,10 @@ impl Command for AllFalse {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"all_false".to_string(),
vec![false.into()],
vec![Value::test_bool(false)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
]

8
crates/nu-command/src/dataframe/series/all_true.rs
View File

@ -30,10 +30,10 @@ impl Command for AllTrue {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"all_true".to_string(),
vec![true.into()],
vec![Value::test_bool(true)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
Example {
@ -44,10 +44,10 @@ impl Command for AllTrue {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"all_true".to_string(),
vec![false.into()],
vec![Value::test_bool(false)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
]

6
crates/nu-command/src/dataframe/series/arg_max.rs
View File

@ -3,7 +3,7 @@ use super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::{IntoSeries, NewChunkedArray, UInt32Chunked};
@ -30,10 +30,10 @@ impl Command for ArgMax {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"arg_max".to_string(),
vec![1.into()],
vec![Value::test_int(1)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/arg_min.rs
View File

@ -3,7 +3,7 @@ use super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::{IntoSeries, NewChunkedArray, UInt32Chunked};
@ -30,10 +30,10 @@ impl Command for ArgMin {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"arg_min".to_string(),
vec![0.into()],
vec![Value::test_int(0)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

12
crates/nu-command/src/dataframe/series/cumulative.rs
View File

@ -4,7 +4,7 @@ use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape,
Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
};
use polars::prelude::{DataType, IntoSeries};
@ -64,10 +64,16 @@ impl Command for Cumulative {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0_cum_sum".to_string(),
vec![1.into(), 3.into(), 6.into(), 10.into(), 15.into()],
vec![
Value::test_int(1),
Value::test_int(3),
Value::test_int(6),
Value::test_int(10),
Value::test_int(15),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/date/get_day.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,10 @@ impl Command for GetDay {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![4.into(), 4.into()],
vec![Value::test_int(4), Value::test_int(4)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/date/get_hour.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,10 @@ impl Command for GetHour {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![16.into(), 16.into()],
vec![Value::test_int(16), Value::test_int(16)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/date/get_minute.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,10 @@ impl Command for GetMinute {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![39.into(), 39.into()],
vec![Value::test_int(39), Value::test_int(39)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/date/get_month.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,10 @@ impl Command for GetMonth {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![8.into(), 8.into()],
vec![Value::test_int(8), Value::test_int(8)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/date/get_nanosecond.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,10 @@ impl Command for GetNanosecond {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![0.into(), 0.into()],
vec![Value::test_int(0), Value::test_int(0)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/date/get_ordinal.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,10 @@ impl Command for GetOrdinal {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![217.into(), 217.into()],
vec![Value::test_int(217), Value::test_int(217)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/date/get_second.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,10 @@ impl Command for GetSecond {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![18.into(), 18.into()],
vec![Value::test_int(18), Value::test_int(18)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/date/get_week.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,10 @@ impl Command for GetWeek {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![32.into(), 32.into()],
vec![Value::test_int(32), Value::test_int(32)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/date/get_weekday.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,10 @@ impl Command for GetWeekDay {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![1.into(), 1.into()],
vec![Value::test_int(1), Value::test_int(1)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/date/get_year.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,10 @@ impl Command for GetYear {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![2020.into(), 2020.into()],
vec![Value::test_int(2020), Value::test_int(2020)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

22
crates/nu-command/src/dataframe/series/indexes/arg_sort.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -33,10 +33,16 @@ impl Command for ArgSort {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"arg_sort".to_string(),
vec![0.into(), 1.into(), 2.into(), 3.into(), 4.into()],
vec![
Value::test_int(0),
Value::test_int(1),
Value::test_int(2),
Value::test_int(3),
Value::test_int(4),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
Example {
@ -45,10 +51,16 @@ impl Command for ArgSort {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"arg_sort".to_string(),
vec![3.into(), 4.into(), 1.into(), 2.into(), 0.into()],
vec![
Value::test_int(3),
Value::test_int(4),
Value::test_int(1),
Value::test_int(2),
Value::test_int(0),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
]

6
crates/nu-command/src/dataframe/series/indexes/arg_true.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -30,10 +30,10 @@ impl Command for ArgTrue {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"arg_true".to_string(),
vec![1.into()],
vec![Value::test_int(1)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/indexes/arg_unique.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -30,10 +30,10 @@ impl Command for ArgUnique {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"arg_unique".to_string(),
vec![0.into(), 1.into(), 3.into()],
vec![Value::test_int(0), Value::test_int(1), Value::test_int(3)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

11
crates/nu-command/src/dataframe/series/indexes/set_with_idx.rs
View File

@ -41,10 +41,17 @@ impl Command for SetWithIndex {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![6.into(), 1.into(), 6.into(), 2.into(), 4.into(), 3.into()],
vec![
Value::test_int(6),
Value::test_int(1),
Value::test_int(6),
Value::test_int(2),
Value::test_int(4),
Value::test_int(3),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

18
crates/nu-command/src/dataframe/series/masks/is_duplicated.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -31,17 +31,17 @@ impl Command for IsDuplicated {
NuDataFrame::try_from_columns(vec![Column::new(
"is_duplicated".to_string(),
vec![
false.into(),
true.into(),
true.into(),
true.into(),
true.into(),
true.into(),
true.into(),
Value::test_bool(false),
Value::test_bool(true),
Value::test_bool(true),
Value::test_bool(true),
Value::test_bool(true),
Value::test_bool(true),
Value::test_bool(true),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

16
crates/nu-command/src/dataframe/series/masks/is_in.rs
View File

@ -35,17 +35,17 @@ impl Command for IsIn {
NuDataFrame::try_from_columns(vec![Column::new(
"is_in".to_string(),
vec![
false.into(),
true.into(),
true.into(),
true.into(),
false.into(),
false.into(),
false.into(),
Value::test_bool(false),
Value::test_bool(true),
Value::test_bool(true),
Value::test_bool(true),
Value::test_bool(false),
Value::test_bool(false),
Value::test_bool(false),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

11
crates/nu-command/src/dataframe/series/masks/is_not_null.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,15 @@ impl Command for IsNotNull {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"is_not_null".to_string(),
vec![true.into(), true.into(), false.into(), true.into()],
vec![
Value::test_bool(true),
Value::test_bool(true),
Value::test_bool(false),
Value::test_bool(true),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

11
crates/nu-command/src/dataframe/series/masks/is_null.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,15 @@ impl Command for IsNull {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"is_null".to_string(),
vec![false.into(), false.into(), true.into(), false.into()],
vec![
Value::test_bool(false),
Value::test_bool(false),
Value::test_bool(true),
Value::test_bool(false),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

18
crates/nu-command/src/dataframe/series/masks/is_unique.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -31,17 +31,17 @@ impl Command for IsUnique {
NuDataFrame::try_from_columns(vec![Column::new(
"is_unique".to_string(),
vec![
true.into(),
false.into(),
false.into(),
false.into(),
false.into(),
false.into(),
false.into(),
Value::test_bool(true),
Value::test_bool(false),
Value::test_bool(false),
Value::test_bool(false),
Value::test_bool(false),
Value::test_bool(false),
Value::test_bool(false),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

10
crates/nu-command/src/dataframe/series/masks/not.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -32,10 +32,14 @@ impl Command for NotSeries {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![false.into(), true.into(), false.into()],
vec![
Value::test_bool(false),
Value::test_bool(true),
Value::test_bool(false),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

10
crates/nu-command/src/dataframe/series/masks/set.rs
View File

@ -41,10 +41,16 @@ impl Command for SetSeries {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![0.into(), 0.into(), 1.into(), 2.into(), 2.into()],
vec![
Value::test_int(0),
Value::test_int(0),
Value::test_int(1),
Value::test_int(2),
Value::test_int(2),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

4
crates/nu-command/src/dataframe/series/n_null.rs
View File

@ -30,10 +30,10 @@ impl Command for NNull {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"count_null".to_string(),
vec![2.into()],
vec![Value::test_int(2)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

4
crates/nu-command/src/dataframe/series/n_unique.rs
View File

@ -29,10 +29,10 @@ impl Command for NUnique {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"count_unique".to_string(),
vec![4.into()],
vec![Value::test_int(4)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

11
crates/nu-command/src/dataframe/series/rename.rs
View File

@ -4,7 +4,7 @@ use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape,
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
};
#[derive(Clone)]
@ -32,10 +32,15 @@ impl Command for Rename {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"new_name".to_string(),
vec![5.into(), 6.into(), 7.into(), 8.into()],
vec![
Value::test_int(5),
Value::test_int(6),
Value::test_int(7),
Value::test_int(8),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

20
crates/nu-command/src/dataframe/series/rolling.rs
View File

@ -4,7 +4,7 @@ use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape,
Category, Example, PipelineData, ShellError, Signature, Span, Spanned, SyntaxShape, Value,
};
use polars::prelude::{DataType, IntoSeries, RollingOptions};
@ -68,10 +68,15 @@ impl Command for Rolling {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0_rolling_sum".to_string(),
vec![3.into(), 5.into(), 7.into(), 9.into()],
vec![
Value::test_int(3),
Value::test_int(5),
Value::test_int(7),
Value::test_int(9),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
Example {
@ -80,10 +85,15 @@ impl Command for Rolling {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0_rolling_max".to_string(),
vec![2.into(), 3.into(), 4.into(), 5.into()],
vec![
Value::test_int(2),
Value::test_int(3),
Value::test_int(4),
Value::test_int(5),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
]

6
crates/nu-command/src/dataframe/series/shift.rs
View File

@ -4,7 +4,7 @@ use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape,
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
};
#[derive(Clone)]
@ -32,10 +32,10 @@ impl Command for Shift {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![1.into(), 2.into(), 2.into()],
vec![Value::test_int(1), Value::test_int(2), Value::test_int(2)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

8
crates/nu-command/src/dataframe/series/string/concatenate.rs
View File

@ -39,13 +39,13 @@ impl Command for Concatenate {
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![
"abcza".to_string().into(),
"abcxs".to_string().into(),
"abccd".to_string().into(),
Value::test_string("abcza"),
Value::test_string("abcxs"),
Value::test_string("abccd"),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

10
crates/nu-command/src/dataframe/series/string/contains.rs
View File

@ -4,7 +4,7 @@ use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape,
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
};
use polars::prelude::IntoSeries;
@ -37,10 +37,14 @@ impl Command for Contains {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![true.into(), false.into(), false.into()],
vec![
Value::test_bool(true),
Value::test_bool(false),
Value::test_bool(false),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

10
crates/nu-command/src/dataframe/series/string/replace.rs
View File

@ -4,7 +4,7 @@ use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape,
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
};
use polars::prelude::IntoSeries;
@ -45,13 +45,13 @@ impl Command for Replace {
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![
"ABc".to_string().into(),
"ABc".to_string().into(),
"ABc".to_string().into(),
Value::test_string("ABc"),
Value::test_string("ABc"),
Value::test_string("ABc"),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

10
crates/nu-command/src/dataframe/series/string/replace_all.rs
View File

@ -4,7 +4,7 @@ use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape,
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
};
use polars::prelude::IntoSeries;
@ -45,13 +45,13 @@ impl Command for ReplaceAll {
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![
"AbAc".to_string().into(),
"AbAc".to_string().into(),
"AbAc".to_string().into(),
Value::test_string("AbAc"),
Value::test_string("AbAc"),
Value::test_string("AbAc"),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/series/string/str_lengths.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -30,10 +30,10 @@ impl Command for StrLengths {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![1.into(), 2.into(), 3.into()],
vec![Value::test_int(1), Value::test_int(2), Value::test_int(3)],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

10
crates/nu-command/src/dataframe/series/string/str_slice.rs
View File

@ -4,7 +4,7 @@ use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape,
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
};
use polars::prelude::IntoSeries;
@ -35,13 +35,13 @@ impl Command for StrSlice {
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![
"bc".to_string().into(),
"bc".to_string().into(),
"bc".to_string().into(),
Value::test_string("bc"),
Value::test_string("bc"),
Value::test_string("bc"),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

8
crates/nu-command/src/dataframe/series/string/strftime.rs
View File

@ -4,7 +4,7 @@ use nu_engine::CallExt;
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape,
Category, Example, PipelineData, ShellError, Signature, Span, SyntaxShape, Value,
};
use polars::prelude::IntoSeries;
@ -36,12 +36,12 @@ impl Command for StrFTime {
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![
"2020/08/04".to_string().into(),
"2020/08/04".to_string().into(),
Value::test_string("2020/08/04"),
Value::test_string("2020/08/04"),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

10
crates/nu-command/src/dataframe/series/string/to_lowercase.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -31,13 +31,13 @@ impl Command for ToLowerCase {
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![
"abc".to_string().into(),
"abc".to_string().into(),
"abc".to_string().into(),
Value::test_string("abc"),
Value::test_string("abc"),
Value::test_string("abc"),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

10
crates/nu-command/src/dataframe/series/string/to_uppercase.rs
View File

@ -3,7 +3,7 @@ use super::super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -31,13 +31,13 @@ impl Command for ToUpperCase {
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![
"ABC".to_string().into(),
"ABC".to_string().into(),
"ABC".to_string().into(),
Value::test_string("ABC"),
Value::test_string("ABC"),
Value::test_string("ABC"),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

11
crates/nu-command/src/dataframe/series/unique.rs
View File

@ -3,7 +3,7 @@ use super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
use polars::prelude::IntoSeries;
@ -28,9 +28,12 @@ impl Command for Unique {
description: "Returns unique values from a series",
example: "[2 2 2 2 2] | dfr to-df | dfr unique",
result: Some(
NuDataFrame::try_from_columns(vec![Column::new("0".to_string(), vec![2.into()])])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![Value::test_int(2)],
)])
.expect("simple df for test should not fail")
.into_value(Span::test_data()),
),
}]
}

14
crates/nu-command/src/dataframe/series/value_counts.rs
View File

@ -3,7 +3,7 @@ use super::super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
#[derive(Clone)]
@ -28,11 +28,17 @@ impl Command for ValueCount {
example: "[5 5 5 5 6 6] | dfr to-df | dfr value-counts",
result: Some(
NuDataFrame::try_from_columns(vec![
Column::new("0".to_string(), vec![5.into(), 6.into()]),
Column::new("counts".to_string(), vec![4.into(), 2.into()]),
Column::new(
"0".to_string(),
vec![Value::test_int(5), Value::test_int(6)],
),
Column::new(
"counts".to_string(),
vec![Value::test_int(4), Value::test_int(2)],
),
])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}

6
crates/nu-command/src/dataframe/test_dataframe.rs
View File

@ -62,7 +62,7 @@ pub fn test_dataframe(cmds: Vec<Box<dyn Command + 'static>>) {
Value::Record {
cols: vec![],
vals: vec![],
span: Span::unknown(),
span: Span::test_data(),
},
);
@ -70,11 +70,11 @@ pub fn test_dataframe(cmds: Vec<Box<dyn Command + 'static>>) {
&engine_state,
&mut stack,
&block,
PipelineData::new(Span::unknown()),
PipelineData::new(Span::test_data()),
) {
Err(err) => panic!("test eval error in `{}`: {:?}", example.example, err),
Ok(result) => {
let result = result.into_value(Span::unknown());
let result = result.into_value(Span::test_data());
println!("input: {}", example.example);
println!("result: {:?}", result);
println!("done: {:?}", start.elapsed());

48
crates/nu-command/src/dataframe/to_df.rs
View File

@ -3,7 +3,7 @@ use super::values::{Column, NuDataFrame};
use nu_protocol::{
ast::Call,
engine::{Command, EngineState, Stack},
Category, Example, PipelineData, ShellError, Signature, Span,
Category, Example, PipelineData, ShellError, Signature, Span, Value,
};
#[derive(Clone)]
@ -29,11 +29,17 @@ impl Command for ToDataFrame {
example: "[[a b];[1 2] [3 4]] | dfr to-df",
result: Some(
NuDataFrame::try_from_columns(vec![
Column::new("a".to_string(), vec![1.into(), 3.into()]),
Column::new("b".to_string(), vec![2.into(), 4.into()]),
Column::new(
"a".to_string(),
vec![Value::test_int(1), Value::test_int(3)],
),
Column::new(
"b".to_string(),
vec![Value::test_int(2), Value::test_int(4)],
),
])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
Example {
@ -41,19 +47,25 @@ impl Command for ToDataFrame {
example: "[[1 2 a] [3 4 b] [5 6 c]] | dfr to-df",
result: Some(
NuDataFrame::try_from_columns(vec![
Column::new("0".to_string(), vec![1.into(), 3.into(), 5.into()]),
Column::new("1".to_string(), vec![2.into(), 4.into(), 6.into()]),
Column::new(
"0".to_string(),
vec![Value::test_int(1), Value::test_int(3), Value::test_int(5)],
),
Column::new(
"1".to_string(),
vec![Value::test_int(2), Value::test_int(4), Value::test_int(6)],
),
Column::new(
"2".to_string(),
vec![
"a".to_string().into(),
"b".to_string().into(),
"c".to_string().into(),
Value::test_string("a"),
Value::test_string("b"),
Value::test_string("c"),
],
),
])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
Example {
@ -63,13 +75,13 @@ impl Command for ToDataFrame {
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![
"a".to_string().into(),
"b".to_string().into(),
"c".to_string().into(),
Value::test_string("a"),
Value::test_string("b"),
Value::test_string("c"),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
Example {
@ -78,10 +90,14 @@ impl Command for ToDataFrame {
result: Some(
NuDataFrame::try_from_columns(vec![Column::new(
"0".to_string(),
vec![true.into(), true.into(), false.into()],
vec![
Value::test_bool(true),
Value::test_bool(true),
Value::test_bool(false),
],
)])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
},
]

225
crates/nu-command/src/dataframe/values/nu_dataframe/conversion.rs
View File

@ -7,7 +7,7 @@ use polars::chunked_array::object::builder::ObjectChunkedBuilder;
use polars::chunked_array::ChunkedArray;
use polars::prelude::{
DataFrame, DataType, DatetimeChunked, Int64Type, IntoSeries, NamedFrom, NewChunkedArray,
ObjectType, PolarsNumericType, Series,
ObjectType, Series,
};
use std::ops::{Deref, DerefMut};
@ -109,15 +109,14 @@ pub fn create_column(
series: &Series,
from_row: usize,
to_row: usize,
span: Span,
) -> Result<Column, ShellError> {
let size = to_row - from_row;
match series.dtype() {
DataType::Null => {
let values = std::iter::repeat(Value::Nothing {
span: Span::unknown(),
})
.take(size)
.collect::<Vec<Value>>();
let values = std::iter::repeat(Value::Nothing { span })
.take(size)
.collect::<Vec<Value>>();
Ok(Column::new(series.name().into(), values))
}
@ -125,61 +124,188 @@ pub fn create_column(
let casted = series.u8().map_err(|e| {
ShellError::LabeledError("Error casting column to u8".into(), e.to_string())
})?;
Ok(column_from_casted(casted, from_row, size))
let values = casted
.into_iter()
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => Value::Int {
val: a as i64,
span,
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
Ok(Column::new(casted.name().into(), values))
}
DataType::UInt16 => {
let casted = series.u16().map_err(|e| {
ShellError::LabeledError("Error casting column to u16".into(), e.to_string())
})?;
Ok(column_from_casted(casted, from_row, size))
let values = casted
.into_iter()
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => Value::Int {
val: a as i64,
span,
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
Ok(Column::new(casted.name().into(), values))
}
DataType::UInt32 => {
let casted = series.u32().map_err(|e| {
ShellError::LabeledError("Error casting column to u32".into(), e.to_string())
})?;
Ok(column_from_casted(casted, from_row, size))
let values = casted
.into_iter()
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => Value::Int {
val: a as i64,
span,
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
Ok(Column::new(casted.name().into(), values))
}
DataType::UInt64 => {
let casted = series.u64().map_err(|e| {
ShellError::LabeledError("Error casting column to u64".into(), e.to_string())
})?;
Ok(column_from_casted(casted, from_row, size))
let values = casted
.into_iter()
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => Value::Int {
val: a as i64,
span,
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
Ok(Column::new(casted.name().into(), values))
}
DataType::Int8 => {
let casted = series.i8().map_err(|e| {
ShellError::LabeledError("Error casting column to i8".into(), e.to_string())
})?;
Ok(column_from_casted(casted, from_row, size))
let values = casted
.into_iter()
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => Value::Int {
val: a as i64,
span,
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
Ok(Column::new(casted.name().into(), values))
}
DataType::Int16 => {
let casted = series.i16().map_err(|e| {
ShellError::LabeledError("Error casting column to i16".into(), e.to_string())
})?;
Ok(column_from_casted(casted, from_row, size))
let values = casted
.into_iter()
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => Value::Int {
val: a as i64,
span,
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
Ok(Column::new(casted.name().into(), values))
}
DataType::Int32 => {
let casted = series.i32().map_err(|e| {
ShellError::LabeledError("Error casting column to i32".into(), e.to_string())
})?;
Ok(column_from_casted(casted, from_row, size))
let values = casted
.into_iter()
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => Value::Int {
val: a as i64,
span,
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
Ok(Column::new(casted.name().into(), values))
}
DataType::Int64 => {
let casted = series.i64().map_err(|e| {
ShellError::LabeledError("Error casting column to i64".into(), e.to_string())
})?;
Ok(column_from_casted(casted, from_row, size))
let values = casted
.into_iter()
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => Value::Int {
val: a as i64,
span,
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
Ok(Column::new(casted.name().into(), values))
}
DataType::Float32 => {
let casted = series.f32().map_err(|e| {
ShellError::LabeledError("Error casting column to f32".into(), e.to_string())
})?;
Ok(column_from_casted(casted, from_row, size))
let values = casted
.into_iter()
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => Value::Float {
val: a as f64,
span,
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
Ok(Column::new(casted.name().into(), values))
}
DataType::Float64 => {
let casted = series.f64().map_err(|e| {
ShellError::LabeledError("Error casting column to f64".into(), e.to_string())
})?;
Ok(column_from_casted(casted, from_row, size))
let values = casted
.into_iter()
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => Value::Float { val: a, span },
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
Ok(Column::new(casted.name().into(), values))
}
DataType::Boolean => {
let casted = series.bool().map_err(|e| {
@ -191,13 +317,8 @@ pub fn create_column(
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => Value::Bool {
val: a,
span: Span::unknown(),
},
None => Value::Nothing {
span: Span::unknown(),
},
Some(a) => Value::Bool { val: a, span },
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
@ -215,11 +336,9 @@ pub fn create_column(
.map(|v| match v {
Some(a) => Value::String {
val: a.into(),
span: Span::unknown(),
},
None => Value::Nothing {
span: Span::unknown(),
span,
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
@ -242,9 +361,7 @@ pub fn create_column(
.take(size)
.map(|v| match v {
Some(a) => a.get_value(),
None => Value::Nothing {
span: Span::unknown(),
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
@ -273,12 +390,10 @@ pub fn create_column(
Value::Date {
val: datetime,
span: Span::unknown(),
span,
}
}
None => Value::Nothing {
span: Span::unknown(),
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
@ -305,12 +420,10 @@ pub fn create_column(
Value::Date {
val: datetime,
span: Span::unknown(),
span,
}
}
None => Value::Nothing {
span: Span::unknown(),
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
@ -328,11 +441,9 @@ pub fn create_column(
.map(|v| match v {
Some(nanoseconds) => Value::Duration {
val: nanoseconds,
span: Span::unknown(),
},
None => Value::Nothing {
span: Span::unknown(),
span,
},
None => Value::Nothing { span },
})
.collect::<Vec<Value>>();
@ -345,29 +456,9 @@ pub fn create_column(
}
}
fn column_from_casted<T>(casted: &ChunkedArray<T>, from_row: usize, size: usize) -> Column
where
T: PolarsNumericType,
T::Native: Into<Value>,
{
let values = casted
.into_iter()
.skip(from_row)
.take(size)
.map(|v| match v {
Some(a) => a.into(),
None => Value::Nothing {
span: Span::unknown(),
},
})
.collect::<Vec<Value>>();
Column::new(casted.name().into(), values)
}
// Adds a separator to the vector of values using the column names from the
// dataframe to create the Values Row
pub fn add_separator(values: &mut Vec<Value>, df: &DataFrame) {
pub fn add_separator(values: &mut Vec<Value>, df: &DataFrame, span: Span) {
let mut cols = vec![];
let mut vals = vec![];
@ -375,15 +466,11 @@ pub fn add_separator(values: &mut Vec<Value>, df: &DataFrame) {
cols.push(name.to_string());
vals.push(Value::String {
val: "...".into(),
span: Span::unknown(),
span,
})
}
let extra_record = Value::Record {
cols,
vals,
span: Span::unknown(),
};
let extra_record = Value::Record { cols, vals, span };
values.push(extra_record);
}

2
crates/nu-command/src/dataframe/values/nu_dataframe/custom_value.rs
View File

@ -29,7 +29,7 @@ impl CustomValue for NuDataFrame {
}
fn to_base_value(&self, span: Span) -> Result<Value, ShellError> {
let vals = self.print()?;
let vals = self.print(span)?;
Ok(Value::List { vals, span })
}

55
crates/nu-command/src/dataframe/values/nu_dataframe/mod.rs
View File

@ -37,7 +37,7 @@ impl Display for DataFrameValue {
impl Default for DataFrameValue {
fn default() -> Self {
Self(Value::Nothing {
span: Span::unknown(),
span: Span { start: 0, end: 0 },
})
}
}
@ -178,15 +178,15 @@ impl NuDataFrame {
Value::CustomValue { val, span } => match val.as_any().downcast_ref::<NuDataFrame>() {
Some(df) => Ok(NuDataFrame(df.0.clone())),
None => Err(ShellError::CantConvert(
"Dataframe not found".into(),
"value is not a dataframe".into(),
"dataframe".into(),
"non-dataframe".into(),
span,
)),
},
_ => Err(ShellError::CantConvert(
"Dataframe not found".into(),
"value is not a dataframe".into(),
value.span()?,
x => Err(ShellError::CantConvert(
"dataframe".into(),
x.get_type().to_string(),
x.span()?,
)),
}
}
@ -239,8 +239,8 @@ impl NuDataFrame {
}
pub fn get_value(&self, row: usize, span: Span) -> Result<Value, ShellError> {
let series = self.as_series(Span::unknown())?;
let column = conversion::create_column(&series, row, row + 1)?;
let series = self.as_series(span)?;
let column = conversion::create_column(&series, row, row + 1, span)?;
if column.len() == 0 {
Err(ShellError::AccessBeyondEnd(series.len(), span))
@ -254,44 +254,49 @@ impl NuDataFrame {
}
// Print is made out a head and if the dataframe is too large, then a tail
pub fn print(&self) -> Result<Vec<Value>, ShellError> {
pub fn print(&self, span: Span) -> Result<Vec<Value>, ShellError> {
let df = &self.0;
let size: usize = 20;
if df.height() > size {
let sample_size = size / 2;
let mut values = self.head(Some(sample_size))?;
conversion::add_separator(&mut values, df);
let mut values = self.head(Some(sample_size), span)?;
conversion::add_separator(&mut values, df, span);
let remaining = df.height() - sample_size;
let tail_size = remaining.min(sample_size);
let mut tail_values = self.tail(Some(tail_size))?;
let mut tail_values = self.tail(Some(tail_size), span)?;
values.append(&mut tail_values);
Ok(values)
} else {
Ok(self.head(Some(size))?)
Ok(self.head(Some(size), span)?)
}
}
pub fn head(&self, rows: Option<usize>) -> Result<Vec<Value>, ShellError> {
pub fn head(&self, rows: Option<usize>, span: Span) -> Result<Vec<Value>, ShellError> {
let to_row = rows.unwrap_or(5);
let values = self.to_rows(0, to_row)?;
let values = self.to_rows(0, to_row, span)?;
Ok(values)
}
pub fn tail(&self, rows: Option<usize>) -> Result<Vec<Value>, ShellError> {
pub fn tail(&self, rows: Option<usize>, span: Span) -> Result<Vec<Value>, ShellError> {
let df = &self.0;
let to_row = df.height();
let size = rows.unwrap_or(5);
let from_row = to_row.saturating_sub(size);
let values = self.to_rows(from_row, to_row)?;
let values = self.to_rows(from_row, to_row, span)?;
Ok(values)
}
pub fn to_rows(&self, from_row: usize, to_row: usize) -> Result<Vec<Value>, ShellError> {
pub fn to_rows(
&self,
from_row: usize,
to_row: usize,
span: Span,
) -> Result<Vec<Value>, ShellError> {
let df = &self.0;
let upper_row = to_row.min(df.height());
@ -301,7 +306,7 @@ impl NuDataFrame {
.get_columns()
.iter()
.map(
|col| match conversion::create_column(col, from_row, upper_row) {
|col| match conversion::create_column(col, from_row, upper_row, span) {
Ok(col) => {
size = col.len();
Ok(col)
@ -327,17 +332,11 @@ impl NuDataFrame {
match col.next() {
Some(v) => vals.push(v),
None => vals.push(Value::Nothing {
span: Span::unknown(),
}),
None => vals.push(Value::Nothing { span }),
};
}
Value::Record {
cols,
vals,
span: Span::unknown(),
}
Value::Record { cols, vals, span }
})
.collect::<Vec<Value>>();

17
crates/nu-command/src/dataframe/with_column.rs
View File

@ -33,12 +33,21 @@ impl Command for WithColumn {
"[[a b]; [1 2] [3 4]] | dfr to-df | dfr with-column ([5 6] | dfr to-df) --name c",
result: Some(
NuDataFrame::try_from_columns(vec![
Column::new("a".to_string(), vec![1.into(), 3.into()]),
Column::new("b".to_string(), vec![2.into(), 4.into()]),
Column::new("c".to_string(), vec![5.into(), 6.into()]),
Column::new(
"a".to_string(),
vec![Value::test_int(1), Value::test_int(3)],
),
Column::new(
"b".to_string(),
vec![Value::test_int(2), Value::test_int(4)],
),
Column::new(
"c".to_string(),
vec![Value::test_int(5), Value::test_int(6)],
),
])
.expect("simple df for test should not fail")
.into_value(Span::unknown()),
.into_value(Span::test_data()),
),
}]
}