forked from extern/nushell
21b84a6d65
This is a follow up from https://github.com/nushell/nushell/pull/7540. Please provide feedback if you have the time! ## Summary This PR lets you use `?` to indicate that a member in a cell path is optional and Nushell should return `null` if that member cannot be accessed. Unlike the previous PR, `?` is now a _postfix_ modifier for cell path members. A cell path of `.foo?.bar` means that `foo` is optional and `bar` is not. `?` does _not_ suppress all errors; it is intended to help in situations where data has "holes", i.e. the data types are correct but something is missing. Type mismatches (like trying to do a string path access on a date) will still fail. ### Record Examples ```bash { foo: 123 }.foo # returns 123 { foo: 123 }.bar # errors { foo: 123 }.bar? # returns null { foo: 123 } | get bar # errors { foo: 123 } | get bar? # returns null { foo: 123 }.bar.baz # errors { foo: 123 }.bar?.baz # errors because `baz` is not present on the result from `bar?` { foo: 123 }.bar.baz? # errors { foo: 123 }.bar?.baz? # returns null ``` ### List Examples ``` 〉[{foo: 1} {foo: 2} {}].foo Error: nu:🐚:column_not_found × Cannot find column ╭─[entry #30:1:1] 1 │ [{foo: 1} {foo: 2} {}].foo · ─┬ ─┬─ · │ ╰── cannot find column 'foo' · ╰── value originates here ╰──── 〉[{foo: 1} {foo: 2} {}].foo? ╭───┬───╮ │ 0 │ 1 │ │ 1 │ 2 │ │ 2 │ │ ╰───┴───╯ 〉[{foo: 1} {foo: 2} {}].foo?.2 | describe nothing 〉[a b c].4? | describe nothing 〉[{foo: 1} {foo: 2} {}] | where foo? == 1 ╭───┬─────╮ │ # │ foo │ ├───┼─────┤ │ 0 │ 1 │ ╰───┴─────╯ ``` # Breaking changes 1. Column names with `?` in them now need to be quoted. 2. The `-i`/`--ignore-errors` flag has been removed from `get` and `select` 1. After this PR, most `get` error handling can be done with `?` and/or `try`/`catch`. 4. Cell path accesses like this no longer work without a `?`: ```bash 〉[{a:1 b:2} {a:3}].b.0 2 ``` We had some clever code that was able to recognize that since we only want row `0`, it's OK if other rows are missing column `b`. I removed that because it's tricky to maintain, and now that query needs to be written like: ```bash 〉[{a:1 b:2} {a:3}].b?.0 2 ``` I think the regression is acceptable for now. I plan to do more work in the future to enable streaming of cell path accesses, and when that happens I'll be able to make `.b.0` work again.
95 lines
2.3 KiB
Rust
95 lines
2.3 KiB
Rust
use super::Expression;
|
|
use crate::Span;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::fmt::Write;
|
|
|
|
#[derive(Debug, Clone, PartialOrd, Serialize, Deserialize)]
|
|
pub enum PathMember {
|
|
String {
|
|
val: String,
|
|
span: Span,
|
|
optional: bool,
|
|
},
|
|
Int {
|
|
val: usize,
|
|
span: Span,
|
|
optional: bool,
|
|
},
|
|
}
|
|
|
|
impl PartialEq for PathMember {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
match (self, other) {
|
|
(
|
|
Self::String {
|
|
val: l_val,
|
|
optional: l_opt,
|
|
..
|
|
},
|
|
Self::String {
|
|
val: r_val,
|
|
optional: r_opt,
|
|
..
|
|
},
|
|
) => l_val == r_val && l_opt == r_opt,
|
|
(
|
|
Self::Int {
|
|
val: l_val,
|
|
optional: l_opt,
|
|
..
|
|
},
|
|
Self::Int {
|
|
val: r_val,
|
|
optional: r_opt,
|
|
..
|
|
},
|
|
) => l_val == r_val && l_opt == r_opt,
|
|
_ => false,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, PartialOrd, Serialize, Deserialize)]
|
|
pub struct CellPath {
|
|
pub members: Vec<PathMember>,
|
|
}
|
|
|
|
impl CellPath {
|
|
pub fn into_string(&self) -> String {
|
|
let mut output = String::new();
|
|
|
|
for (idx, elem) in self.members.iter().enumerate() {
|
|
if idx > 0 {
|
|
output.push('.');
|
|
}
|
|
match elem {
|
|
PathMember::Int { val, .. } => {
|
|
let _ = write!(output, "{val}");
|
|
}
|
|
PathMember::String { val, .. } => output.push_str(val),
|
|
}
|
|
}
|
|
|
|
output
|
|
}
|
|
|
|
pub fn make_optional(&mut self) {
|
|
for member in &mut self.members {
|
|
match member {
|
|
PathMember::String {
|
|
ref mut optional, ..
|
|
} => *optional = true,
|
|
PathMember::Int {
|
|
ref mut optional, ..
|
|
} => *optional = true,
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct FullCellPath {
|
|
pub head: Expression,
|
|
pub tail: Vec<PathMember>,
|
|
}
|