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.
136 lines
3.4 KiB
Rust
136 lines
3.4 KiB
Rust
use crate::tests::{fail_test, run_test, TestResult};
|
|
|
|
// Tests for $nothing / null / Value::Nothing
|
|
#[test]
|
|
fn nothing_fails_string() -> TestResult {
|
|
fail_test("$nothing.foo", "doesn't support cell paths")
|
|
}
|
|
|
|
#[test]
|
|
fn nothing_fails_int() -> TestResult {
|
|
fail_test("$nothing.3", "doesn't support cell paths")
|
|
}
|
|
|
|
// Tests for records
|
|
#[test]
|
|
fn record_single_field_success() -> TestResult {
|
|
run_test("{foo: 'bar'}.foo == 'bar'", "true")
|
|
}
|
|
|
|
#[test]
|
|
fn record_single_field_optional_success() -> TestResult {
|
|
run_test("{foo: 'bar'}.foo? == 'bar'", "true")
|
|
}
|
|
|
|
#[test]
|
|
fn get_works_with_cell_path_success() -> TestResult {
|
|
run_test("{foo: 'bar'} | get foo?", "bar")
|
|
}
|
|
|
|
#[test]
|
|
fn get_works_with_cell_path_missing_data() -> TestResult {
|
|
run_test("{foo: 'bar'} | get foobar? | to nuon", "null")
|
|
}
|
|
|
|
#[test]
|
|
fn record_single_field_failure() -> TestResult {
|
|
fail_test("{foo: 'bar'}.foobar", "")
|
|
}
|
|
|
|
#[test]
|
|
fn record_int_failure() -> TestResult {
|
|
fail_test("{foo: 'bar'}.3", "")
|
|
}
|
|
|
|
#[test]
|
|
fn record_single_field_optional() -> TestResult {
|
|
run_test("{foo: 'bar'}.foobar? | to nuon", "null")
|
|
}
|
|
|
|
#[test]
|
|
fn record_single_field_optional_does_not_short_circuit() -> TestResult {
|
|
fail_test("{foo: 'bar'}.foobar?.baz", "nothing")
|
|
}
|
|
|
|
#[test]
|
|
fn record_multiple_optional_fields() -> TestResult {
|
|
run_test("{foo: 'bar'}.foobar?.baz? | to nuon", "null")
|
|
}
|
|
|
|
#[test]
|
|
fn nested_record_field_success() -> TestResult {
|
|
run_test("{foo: {bar: 'baz'} }.foo.bar == 'baz'", "true")
|
|
}
|
|
|
|
#[test]
|
|
fn nested_record_field_failure() -> TestResult {
|
|
fail_test("{foo: {bar: 'baz'} }.foo.asdf", "")
|
|
}
|
|
|
|
#[test]
|
|
fn nested_record_field_optional() -> TestResult {
|
|
run_test("{foo: {bar: 'baz'} }.foo.asdf? | to nuon", "null")
|
|
}
|
|
|
|
#[test]
|
|
fn record_with_nested_list_success() -> TestResult {
|
|
run_test("{foo: [{bar: 'baz'}]}.foo.0.bar == 'baz'", "true")
|
|
}
|
|
|
|
#[test]
|
|
fn record_with_nested_list_int_failure() -> TestResult {
|
|
fail_test("{foo: [{bar: 'baz'}]}.foo.3.bar", "")
|
|
}
|
|
|
|
#[test]
|
|
fn record_with_nested_list_column_failure() -> TestResult {
|
|
fail_test("{foo: [{bar: 'baz'}]}.foo.0.asdf", "")
|
|
}
|
|
|
|
// Tests for lists
|
|
#[test]
|
|
fn list_single_field_success() -> TestResult {
|
|
run_test("[{foo: 'bar'}].foo.0 == 'bar'", "true")?;
|
|
// test field access both ways
|
|
run_test("[{foo: 'bar'}].0.foo == 'bar'", "true")
|
|
}
|
|
|
|
#[test]
|
|
fn list_single_field_failure() -> TestResult {
|
|
fail_test("[{foo: 'bar'}].asdf", "")
|
|
}
|
|
|
|
// Test the scenario where the requested column is not present in all rows
|
|
#[test]
|
|
fn jagged_list_access_fails() -> TestResult {
|
|
fail_test("[{foo: 'bar'}, {}].foo", "cannot find column")?;
|
|
fail_test("[{}, {foo: 'bar'}].foo", "cannot find column")
|
|
}
|
|
|
|
#[test]
|
|
fn jagged_list_optional_access_succeeds() -> TestResult {
|
|
run_test("[{foo: 'bar'}, {}].foo?.0", "bar")?;
|
|
run_test("[{foo: 'bar'}, {}].foo?.1 | to nuon", "null")?;
|
|
|
|
run_test("[{}, {foo: 'bar'}].foo?.0 | to nuon", "null")?;
|
|
run_test("[{}, {foo: 'bar'}].foo?.1", "bar")
|
|
}
|
|
|
|
// test that accessing a nonexistent row fails
|
|
#[test]
|
|
fn list_row_access_failure() -> TestResult {
|
|
fail_test("[{foo: 'bar'}, {foo: 'baz'}].2", "")
|
|
}
|
|
|
|
#[test]
|
|
fn list_row_optional_access_succeeds() -> TestResult {
|
|
run_test("[{foo: 'bar'}, {foo: 'baz'}].2? | to nuon", "null")?;
|
|
run_test("[{foo: 'bar'}, {foo: 'baz'}].3? | to nuon", "null")
|
|
}
|
|
|
|
// regression test for an old bug
|
|
#[test]
|
|
fn do_not_delve_too_deep_in_nested_lists() -> TestResult {
|
|
fail_test("[[{foo: bar}]].foo", "cannot find column")
|
|
}
|