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

update polar to 0.25 (#6988)

Browse Source
This commit is contained in:
WindSoilder
2022-11-10 06:07:38 +08:00
committed by GitHub
parent 2c238aea6a
commit c259ef41bd
12 changed files with 327 additions and 228 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
crates/nu-command/Cargo.toml
View File

@ -104,7 +104,7 @@ version = "2.1.3"
optional = true
[dependencies.polars]
version = "0.23.2"
version = "0.25.0"
optional = true
features = [
"arg_where",

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

@ -199,7 +199,7 @@ fn command(
_ => None,
};
let std = match col.std_as_series().get(0) {
let std = match col.std_as_series(0).get(0) {
AnyValue::Float64(v) => Some(v),
_ => None,
};

1
crates/nu-command/src/dataframe/eager/open.rs
View File

@ -213,6 +213,7 @@ fn from_ipc(
cache: true,
rechunk: false,
row_count: None,
memmap: true,
};
let df: NuLazyFrame = LazyFrame::scan_ipc(file, args)

8
crates/nu-command/src/dataframe/eager/sql_context.rs
View File

@ -1,5 +1,5 @@
use crate::dataframe::eager::sql_expr::parse_sql_expr;
use polars::error::PolarsError;
use polars::error::{ErrString, PolarsError};
use polars::prelude::{col, DataFrame, DataType, IntoLazy, LazyFrame};
use sqlparser::ast::{
Expr as SqlExpr, Select, SelectItem, SetExpr, Statement, TableFactor, Value as SQLValue,
@ -30,7 +30,7 @@ impl SQLContext {
// Determine involved dataframe
// Implicit join require some more work in query parsers, Explicit join are preferred for now.
let tbl = select_stmt.from.get(0).ok_or_else(|| {
PolarsError::NotFound("No table found in select statement".to_string())
PolarsError::NotFound(ErrString::from("No table found in select statement"))
})?;
let mut alias_map = HashMap::new();
let tbl_name = match &tbl.relation {
@ -39,7 +39,7 @@ impl SQLContext {
.0
.get(0)
.ok_or_else(|| {
PolarsError::NotFound("No table found in select statement".to_string())
PolarsError::NotFound(ErrString::from("No table found in select statement"))
})?
.value
.to_string();
@ -181,7 +181,7 @@ impl SQLContext {
} else {
let ast = ast
.get(0)
.ok_or_else(|| PolarsError::NotFound("No statement found".to_string()))?;
.ok_or_else(|| PolarsError::NotFound(ErrString::from("No statement found")))?;
Ok(match ast {
Statement::Query(query) => {
let rs = match &*query.body {

2
crates/nu-command/src/dataframe/eager/sql_expr.rs
View File

@ -1,5 +1,5 @@
use polars::error::PolarsError;
use polars::prelude::{col, lit, DataType, Expr, LiteralValue, Result, TimeUnit};
use polars::prelude::{col, lit, DataType, Expr, LiteralValue, PolarsResult as Result, TimeUnit};
use sqlparser::ast::{
BinaryOperator as SQLBinaryOperator, DataType as SQLDataType, Expr as SqlExpr,

65
crates/nu-command/src/dataframe/expressions/expressions_macro.rs
View File

@ -69,6 +69,65 @@ macro_rules! expr_command {
}
}
};
($command: ident, $name: expr, $desc: expr, $examples: expr, $func: ident, $test: ident, $ddof: expr) => {
#[derive(Clone)]
pub struct $command;
impl Command for $command {
fn name(&self) -> &str {
$name
}
fn usage(&self) -> &str {
$desc
}
fn signature(&self) -> Signature {
Signature::build(self.name())
.input_type(Type::Custom("expression".into()))
.output_type(Type::Custom("expression".into()))
.category(Category::Custom("expression".into()))
}
fn examples(&self) -> Vec<Example> {
$examples
}
fn run(
&self,
_engine_state: &EngineState,
_stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<PipelineData, ShellError> {
let expr = NuExpression::try_from_pipeline(input, call.head)?;
let expr: NuExpression = expr.into_polars().$func($ddof).into();
Ok(PipelineData::Value(
NuExpression::into_value(expr, call.head),
None,
))
}
}
#[cfg(test)]
mod $test {
use super::super::super::test_dataframe::test_dataframe;
use super::*;
use crate::dataframe::lazy::aggregate::LazyAggregate;
use crate::dataframe::lazy::groupby::ToLazyGroupBy;
#[test]
fn test_examples() {
test_dataframe(vec![
Box::new($command {}),
Box::new(LazyAggregate {}),
Box::new(ToLazyGroupBy {}),
])
}
}
};
}
// ExprList command
@ -419,7 +478,8 @@ expr_command!(
),
},],
std,
test_std
test_std,
0
);
// ExprVar command
@ -450,5 +510,6 @@ expr_command!(
),
},],
var,
test_var
test_var,
0
);

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

@ -153,8 +153,8 @@ fn get_col_name(expr: &Expr) -> Option<String> {
match expr {
Expr::Column(column) => Some(column.to_string()),
Expr::Agg(agg) => match agg {
polars::prelude::AggExpr::Min(e)
| polars::prelude::AggExpr::Max(e)
polars::prelude::AggExpr::Min { input: e, .. }
| polars::prelude::AggExpr::Max { input: e, .. }
| polars::prelude::AggExpr::Median(e)
| polars::prelude::AggExpr::NUnique(e)
| polars::prelude::AggExpr::First(e)
@ -164,13 +164,11 @@ fn get_col_name(expr: &Expr) -> Option<String> {
| polars::prelude::AggExpr::Count(e)
| polars::prelude::AggExpr::Sum(e)
| polars::prelude::AggExpr::AggGroups(e)
| polars::prelude::AggExpr::Std(e)
| polars::prelude::AggExpr::Var(e) => get_col_name(e.as_ref()),
| polars::prelude::AggExpr::Std(e, _)
| polars::prelude::AggExpr::Var(e, _) => get_col_name(e.as_ref()),
polars::prelude::AggExpr::Quantile { expr, .. } => get_col_name(expr.as_ref()),
},
Expr::Reverse(expr)
| Expr::Shift { input: expr, .. }
| Expr::Filter { input: expr, .. }
Expr::Filter { input: expr, .. }
| Expr::Slice { input: expr, .. }
| Expr::Cast { expr, .. }
| Expr::Sort { expr, .. }
@ -179,11 +177,6 @@ fn get_col_name(expr: &Expr) -> Option<String> {
| Expr::Exclude(expr, _)
| Expr::Alias(expr, _)
| Expr::KeepName(expr)
| Expr::Not(expr)
| Expr::IsNotNull(expr)
| Expr::IsNull(expr)
| Expr::Duplicated(expr)
| Expr::IsUnique(expr)
| Expr::Explode(expr) => get_col_name(expr.as_ref()),
Expr::Ternary { .. }
| Expr::AnonymousFunction { .. }

56
crates/nu-command/src/dataframe/lazy/macro_commands.rs
View File

@ -58,6 +58,56 @@ macro_rules! lazy_command {
}
}
};
($command: ident, $name: expr, $desc: expr, $examples: expr, $func: ident, $test: ident, $ddot: expr) => {
#[derive(Clone)]
pub struct $command;
impl Command for $command {
fn name(&self) -> &str {
$name
}
fn usage(&self) -> &str {
$desc
}
fn signature(&self) -> Signature {
Signature::build(self.name())
.input_type(Type::Custom("dataframe".into()))
.output_type(Type::Custom("dataframe".into()))
.category(Category::Custom("lazyframe".into()))
}
fn examples(&self) -> Vec<Example> {
$examples
}
fn run(
&self,
_engine_state: &EngineState,
_stack: &mut Stack,
call: &Call,
input: PipelineData,
) -> Result<PipelineData, ShellError> {
let lazy = NuLazyFrame::try_from_pipeline(input, call.head)?;
let lazy = NuLazyFrame::new(lazy.from_eager, lazy.into_polars().$func($ddot));
Ok(PipelineData::Value(lazy.into_value(call.head)?, None))
}
}
#[cfg(test)]
mod $test {
use super::super::super::test_dataframe::test_dataframe;
use super::*;
#[test]
fn test_examples() {
test_dataframe(vec![Box::new($command {})])
}
}
};
}
// LazyReverse command
@ -232,7 +282,8 @@ lazy_command!(
),
},],
std,
test_std
test_std,
1
);
// LazyVar command
@ -254,5 +305,6 @@ lazy_command!(
),
},],
var,
test_var
test_var,
1
);

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

@ -116,7 +116,7 @@ fn command(
)
})?
.into_iter()
.filter_map(|val| val.map(|v| v as usize));
.flatten();
let df = NuDataFrame::try_from_pipeline(input, call.head)?;
let series = df.as_series(call.head)?;

83
crates/nu-command/src/dataframe/values/nu_expression/mod.rs
View File

@ -174,16 +174,6 @@ pub fn expr_to_value(expr: &Expr, span: Span) -> Value {
let cols = vec!["expr".to_string(), "value".to_string()];
match expr {
Expr::Not(expr) => {
let expr = expr_to_value(expr.as_ref(), span);
let cols = vec!["expr".into()];
Value::Record {
cols,
vals: vec![expr],
span,
}
}
Expr::Alias(expr, alias) => {
let expr = expr_to_value(expr.as_ref(), span);
let alias = Value::String {
@ -280,8 +270,8 @@ pub fn expr_to_value(expr: &Expr, span: Span) -> Value {
}
Expr::Agg(agg_expr) => {
let value = match agg_expr {
AggExpr::Min(expr)
| AggExpr::Max(expr)
AggExpr::Min { input: expr, .. }
| AggExpr::Max { input: expr, .. }
| AggExpr::Median(expr)
| AggExpr::NUnique(expr)
| AggExpr::First(expr)
@ -291,8 +281,8 @@ pub fn expr_to_value(expr: &Expr, span: Span) -> Value {
| AggExpr::Count(expr)
| AggExpr::Sum(expr)
| AggExpr::AggGroups(expr)
| AggExpr::Std(expr)
| AggExpr::Var(expr) => expr_to_value(expr.as_ref(), span),
| AggExpr::Std(expr, _)
| AggExpr::Var(expr, _) => expr_to_value(expr.as_ref(), span),
AggExpr::Quantile {
expr,
quantile,
@ -326,26 +316,6 @@ pub fn expr_to_value(expr: &Expr, span: Span) -> Value {
let vals = vec![expr_type, value];
Value::Record { cols, vals, span }
}
Expr::IsNotNull(expr) => {
let expr = expr_to_value(expr.as_ref(), span);
let cols = vec!["expr".into()];
Value::Record {
cols,
vals: vec![expr],
span,
}
}
Expr::IsNull(expr) => {
let expr = expr_to_value(expr.as_ref(), span);
let cols = vec!["expr".into()];
Value::Record {
cols,
vals: vec![expr],
span,
}
}
Expr::Count => {
let expr = Value::String {
val: "count".into(),
@ -372,36 +342,6 @@ pub fn expr_to_value(expr: &Expr, span: Span) -> Value {
span,
}
}
Expr::Reverse(expr) => {
let expr = expr_to_value(expr.as_ref(), span);
let cols = vec!["expr".into()];
Value::Record {
cols,
vals: vec![expr],
span,
}
}
Expr::Duplicated(expr) => {
let expr = expr_to_value(expr.as_ref(), span);
let cols = vec!["expr".into()];
Value::Record {
cols,
vals: vec![expr],
span,
}
}
Expr::IsUnique(expr) => {
let expr = expr_to_value(expr.as_ref(), span);
let cols = vec!["expr".into()];
Value::Record {
cols,
vals: vec![expr],
span,
}
}
Expr::Explode(expr) => {
let expr = expr_to_value(expr.as_ref(), span);
let cols = vec!["expr".into()];
@ -511,21 +451,6 @@ pub fn expr_to_value(expr: &Expr, span: Span) -> Value {
span,
}
}
Expr::Shift { input, periods } => {
let expr = expr_to_value(input.as_ref(), span);
let periods = Value::Int {
val: *periods,
span,
};
let cols = vec!["expr".into(), "periods".into()];
Value::Record {
cols,
vals: vec![expr, periods],
span,
}
}
Expr::Filter { input, by } => {
let input = expr_to_value(input.as_ref(), span);
let by = expr_to_value(by.as_ref(), span);

6
crates/nu-command/src/dataframe/values/nu_when/mod.rs
View File

@ -7,7 +7,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
#[derive(Clone)]
pub enum NuWhen {
WhenThen(WhenThen),
WhenThen(Box<WhenThen>),
WhenThenThen(WhenThenThen),
}
@ -27,7 +27,7 @@ impl<'de> Deserialize<'de> for NuWhen {
where
D: Deserializer<'de>,
{
Ok(NuWhen::WhenThen(when(col("a")).then(col("b"))))
Ok(NuWhen::WhenThen(Box::new(when(col("a")).then(col("b")))))
}
}
@ -39,7 +39,7 @@ impl fmt::Debug for NuWhen {
impl From<WhenThen> for NuWhen {
fn from(when_then: WhenThen) -> Self {
NuWhen::WhenThen(when_then)
NuWhen::WhenThen(Box::new(when_then))
}
}