Update polars to 0.28 (#9136)

# Description
Update polars to 0.28.
Luckily, it didn't require major changes.

# User-Facing Changes
None.
(Apart from the fact that certain error messages will stop breaking
table formatting)

crates/nu-command/src/dataframe/eager/drop_duplicates.rs

@@ -97,7 +97,7 @@ fn command(
     };
 
     df.as_ref()
-        .unique(subset_slice, keep_strategy)
+        .unique(subset_slice, keep_strategy, None)
         .map_err(|e| {
             ShellError::GenericError(
                 "Error dropping duplicates".into(),

crates/nu-command/src/dataframe/eager/open.rs

@@ -9,8 +9,8 @@ use nu_protocol::{
 use std::{fs::File, io::BufReader, path::PathBuf};
 
 use polars::prelude::{
-    CsvEncoding, CsvReader, IpcReader, JsonReader, LazyCsvReader, LazyFrame, ParallelStrategy,
-    ParquetReader, ScanArgsIpc, ScanArgsParquet, SerReader,
+    CsvEncoding, CsvReader, IpcReader, JsonReader, LazyCsvReader, LazyFileListReader, LazyFrame,
+    ParallelStrategy, ParquetReader, ScanArgsIpc, ScanArgsParquet, SerReader,
 };
 
 #[derive(Clone)]
@@ -146,6 +146,7 @@ fn from_parquet(
             row_count: None,
             low_memory: false,
             cloud_options: None,
+            use_statistics: false,
         };
 
         let df: NuLazyFrame = LazyFrame::scan_parquet(file, args)

crates/nu-command/src/dataframe/eager/sql_context.rs

@@ -164,7 +164,7 @@ impl SQLContext {
                         .unwrap_or_default()
                         .schema()
                         .get_index(shm_p)
-                        .unwrap_or((&"".to_string(), &DataType::Null))
+                        .unwrap_or((&"".into(), &DataType::Null))
                         .0)
                 })
                 .collect::<Vec<_>>();

crates/nu-command/src/dataframe/expressions/lit.rs

@@ -36,7 +36,7 @@ impl Command for ExprLit {
             example: "dfr lit 2 | dfr into-nu",
             result: Some(Value::Record {
                 cols: vec!["expr".into(), "value".into()],
-                vals: vec![Value::test_string("literal"), Value::test_string("2i64")],
+                vals: vec![Value::test_string("literal"), Value::test_string("2")],
                 span: Span::test_data(),
             }),
         }]

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

@@ -98,7 +98,10 @@ fn command(
         multithreaded: true,
     };
 
-    let mut res = df.as_series(call.head)?.argsort(sort_options).into_series();
+    let mut res = df
+        .as_series(call.head)?
+        .arg_sort(sort_options)
+        .into_series();
     res.rename("arg_sort");
 
     NuDataFrame::try_from_series(vec![res], call.head)

crates/nu-command/src/dataframe/series/rolling.rs

@@ -146,6 +146,7 @@ fn command(
         by: None,
         closed_window: None,
         tu: None,
+        tz: None,
     };
     let res = match roll_type {
         RollType::Max => series.rolling_max(rolling_opts),

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

@@ -82,7 +82,7 @@ fn command(
         )
     })?;
 
-    let res = chunked.contains(&pattern).map_err(|e| {
+    let res = chunked.contains(&pattern, false).map_err(|e| {
         ShellError::GenericError(
             "Error searching in series".into(),
             e.to_string(),

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

@@ -80,7 +80,18 @@ fn command(
         )
     })?;
 
-    let res = casted.strftime(&fmt).into_series();
+    let res = casted
+        .strftime(&fmt)
+        .map_err(|e| {
+            ShellError::GenericError(
+                "Error formatting datetime".into(),
+                e.to_string(),
+                Some(call.head),
+                None,
+                Vec::new(),
+            )
+        })?
+        .into_series();
 
     NuDataFrame::try_from_series(vec![res.into_series()], call.head)
         .map(|df| PipelineData::Value(NuDataFrame::into_value(df, call.head), None))

crates/nu-command/src/dataframe/values/nu_dataframe/between_values.rs

@@ -736,7 +736,7 @@ fn contains_series_pat(series: &Series, pat: &str, span: Span) -> Result<Value,
     let casted = series.utf8();
     match casted {
         Ok(casted) => {
-            let res = casted.contains(pat);
+            let res = casted.contains(pat, false);
 
             match res {
                 Ok(res) => {

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

@@ -426,25 +426,29 @@ pub fn expr_to_value(expr: &Expr, span: Span) -> Value {
                 span,
             }
         }
-        Expr::SortBy { expr, by, reverse } => {
+        Expr::SortBy {
+            expr,
+            by,
+            descending,
+        } => {
             let expr = expr_to_value(expr.as_ref(), span);
             let by: Vec<Value> = by.iter().map(|b| expr_to_value(b, span)).collect();
             let by = Value::List { vals: by, span };
 
-            let reverse: Vec<Value> = reverse
+            let descending: Vec<Value> = descending
                 .iter()
                 .map(|r| Value::Bool { val: *r, span })
                 .collect();
-            let reverse = Value::List {
-                vals: reverse,
+            let descending = Value::List {
+                vals: descending,
                 span,
             };
 
-            let cols = vec!["expr".into(), "by".into(), "reverse".into()];
+            let cols = vec!["expr".into(), "by".into(), "descending".into()];
 
             Value::Record {
                 cols,
-                vals: vec![expr, by, reverse],
+                vals: vec![expr, by, descending],
                 span,
             }
         }