How do I select multiple keys for output?

[ronniegane]

This seems like a basic question but I can't find examples anywhere in the documentation.
If I have input like

- alpha: 1
  beta: foo
  gamma: 0.3
  delta: bar
- alpha: 2
  beta: baz
  gamma: 1.23
  delta: buzz

And I want to select only the beta and delta keys, so that I get the following output:

- beta: foo
  delta: bar
- beta: baz
  delta: buzz

How do I do it? Every example in the documentation is only selecting a single key.

The equivalent in jq would be something like:

jq '.[] | .beta, .delta'

or

jq '.[] | {beta, delta}'

[mikefarah]

This can't be done yet - would be neat though :)

[macropin]

Would be great to document that this feature is missing. I wasted a lot of time trying to figure it out.

[aditya999123]

hey, is this available now? i have a use case for exactly this, and wasted a lot of time to figure out how to do this

[mikefarah]

Yeah cool - sorry for your time wasted - I'd love to add this at some stage but for now I'll add it to the readme as a known missing feature

[aditya999123]

Super, i would like to take a stab at it

[mikefarah]

Cool - I've been thinking about it, there are other related issues about being able to:

• use AND, OR operators
• nest expressions (e.g. find by child).

And I think they all can be solved by refactoring the code that handles path expressions as an array into a proper path expression tree. This will allow multiple keys for output by an expression like a.(b.thing or c.other.thing or d.whatever) as well as a whole bunch of other combos.

Other commands (like write) use the same code, so they too will benefit by being able to give complex expressions to update..

I don't think it will be easy though...

[mikefarah]

https://www.geeksforgeeks.org/expression-tree/ for reference.

yq would need to parse the path string into a path expression tree, then data-navigator will need to be updated to recursively navigate via the expression tree (rather than the expression array it uses atm)

[mikefarah]

Might take it on myself actually - it's so fundamental to the whole codebase.

Sorry - normally I definitely welcome help, but this is a significant bit if work that affects the core

[aditya999123]

cool, no worries. Will wait for you to add these functionalities

[SteveH-US]

How does one search for multiple keys? The docs and help doesn't offer a clue.

[otosky]

Adding this in posterity for those who also couldn't seem to locate this in the docs.

Surrounding the desired keys in parens () should do the trick.

for example, with foobar.yaml:

---
top:
  k1: v1
  k2: v2
bottom:
  k3: v3
  k4: v4

yq e '.top | (.k1, .k2)' foobar.yaml
will yield

v1
v2

[tony-sol]

Is there a way to save objects structure and sequence?
For example, file is:

- name: foo
  status: waiting
  a-lot-of-other: fields
- name: bar
  status: waiting
  a-lot-of-other: fields

And i want to get just

- name: foo
  status: waiting
- name: bar
  status: waiting

I've tried cat file.yaml | yq '.[] | (.name,.status)' to do so, but got just:

foo
bar
waiting
waiting

UPD: for anyone else, who will searching for this - looks like using [{ with key mapping instead of ( is a solution:
cat file.yaml | yq '.[] |[{"name": .name, "status": .status}]' gives required results :)

[Skaronator]

I got it working without using a map. Just use +

$ yq e '.tools[] | (.name + " " + .version)' tools.yaml 
k9s v0.29.1
kubectl v1.28.4

[mikefarah]

Sorry didn't see all the attention here, @tony-sol you can do it like this:

yq '.[] |= pick(["name", "status"])' data1.yaml

Explanation:

• You want to pick particular fields from each map in the array
• .[] |= <exp> will match each element in the array, and update that element w.r.t itself
• pick([]) will take a given map and pick fields (omitting the rest)

See https://mikefarah.gitbook.io/yq/operators/pick for details.

The different with doing .[] | (.name, .status) is that will match all elements and just pulling out just those values.

[mikefarah]

Moved to discussion - so github tells me when there's activity here :)