From b6285c5922277dad92f57ba690d73260627efbfd Mon Sep 17 00:00:00 2001 From: Tony <1094086026@qq.com> Date: Wed, 27 May 2026 16:33:32 +0800 Subject: [PATCH] feat: add `in` operator (inverse of `has`) Add the `in` operator to check if a value is present in a mapping (as a key) or sequence (as an element). This mirrors jq's `in` operator which is defined as the inverse of `has`. Usage: . as $m | "key" | in($m) -- check map key existence . as $m | "value" | in($m) -- check array value membership .[] | select(.type | in(["a","b"])) -- filter by membership Fixes #2322 --- pkg/yqlib/doc/operators/in.md | 121 ++++++++++++++++++++++++++++++++++ pkg/yqlib/lexer_participle.go | 1 + pkg/yqlib/operation.go | 1 + pkg/yqlib/operator_in.go | 59 +++++++++++++++++ pkg/yqlib/operator_in_test.go | 105 +++++++++++++++++++++++++++++ 5 files changed, 287 insertions(+) create mode 100644 pkg/yqlib/doc/operators/in.md create mode 100644 pkg/yqlib/operator_in.go create mode 100644 pkg/yqlib/operator_in_test.go diff --git a/pkg/yqlib/doc/operators/in.md b/pkg/yqlib/doc/operators/in.md new file mode 100644 index 0000000000..ac1836ab17 --- /dev/null +++ b/pkg/yqlib/doc/operators/in.md @@ -0,0 +1,121 @@ + +## Check key exists in map using variable binding +Given a sample.yml file of: +```yaml +a: 1 +b: 2 +c: 3 +``` +then +```bash +yq '. as $m | "a" | in($m)' sample.yml +``` +will output +```yaml +true +``` + +## Check key does not exist in map +Given a sample.yml file of: +```yaml +a: 1 +b: 2 +c: 3 +``` +then +```bash +yq '. as $m | "d" | in($m)' sample.yml +``` +will output +```yaml +false +``` + +## Check value exists in array +Given a sample.yml file of: +```yaml +- Tool +- Food +- Flower +``` +then +```bash +yq '. as $m | "Food" | in($m)' sample.yml +``` +will output +```yaml +true +``` + +## Check value does not exist in array +Given a sample.yml file of: +```yaml +- Tool +- Food +- Flower +``` +then +```bash +yq '. as $m | "Animal" | in($m)' sample.yml +``` +will output +```yaml +false +``` + +## Check in with select on array elements +Filter items whose type is in the given list + +Given a sample.yml file of: +```yaml +- item: Pizza + type: Food +- item: Rose + type: Flower +- item: Hammer + type: Tool +``` +then +```bash +yq '.[] | select(.type | in(["Tool", "Food"]))' sample.yml +``` +will output +```yaml +item: Pizza +type: Food +item: Hammer +type: Tool +``` + +## In with variable binding - found +Given a sample.yml file of: +```yaml +a: 1 +b: 2 +c: 3 +``` +then +```bash +yq '. as $m | "b" | in($m)' sample.yml +``` +will output +```yaml +true +``` + +## In with variable binding - not found +Given a sample.yml file of: +```yaml +a: 1 +b: 2 +c: 3 +``` +then +```bash +yq '. as $m | "z" | in($m)' sample.yml +``` +will output +```yaml +false +``` + diff --git a/pkg/yqlib/lexer_participle.go b/pkg/yqlib/lexer_participle.go index 938b8a717a..11d60febfc 100644 --- a/pkg/yqlib/lexer_participle.go +++ b/pkg/yqlib/lexer_participle.go @@ -102,6 +102,7 @@ var participleYqRules = []*participleYqRule{ simpleOp("select", selectOpType), simpleOp("has", hasOpType), + simpleOp("in", inOpType), simpleOp("unique_?by", uniqueByOpType), simpleOp("unique", uniqueOpType), diff --git a/pkg/yqlib/operation.go b/pkg/yqlib/operation.go index cbea1d7b9c..7fac760051 100644 --- a/pkg/yqlib/operation.go +++ b/pkg/yqlib/operation.go @@ -191,6 +191,7 @@ var recursiveDescentOpType = &operationType{Type: "RECURSIVE_DESCENT", NumArgs: var selectOpType = &operationType{Type: "SELECT", NumArgs: 1, Precedence: 52, Handler: selectOperator, CheckForPostTraverse: true} var hasOpType = &operationType{Type: "HAS", NumArgs: 1, Precedence: 50, Handler: hasOperator} +var inOpType = &operationType{Type: "IN", NumArgs: 1, Precedence: 50, Handler: inOperator} var uniqueOpType = &operationType{Type: "UNIQUE", NumArgs: 0, Precedence: 52, Handler: unique, CheckForPostTraverse: true} var uniqueByOpType = &operationType{Type: "UNIQUE_BY", NumArgs: 1, Precedence: 52, Handler: uniqueBy, CheckForPostTraverse: true} var groupByOpType = &operationType{Type: "GROUP_BY", NumArgs: 1, Precedence: 52, Handler: groupBy, CheckForPostTraverse: true} diff --git a/pkg/yqlib/operator_in.go b/pkg/yqlib/operator_in.go new file mode 100644 index 0000000000..037e06cd80 --- /dev/null +++ b/pkg/yqlib/operator_in.go @@ -0,0 +1,59 @@ +package yqlib + +import ( + "container/list" +) + +func inOperator(d *dataTreeNavigator, context Context, expressionNode *ExpressionNode) (Context, error) { + + log.Debugf("inOperation") + var results = list.New() + + rhs, err := d.GetMatchingNodes(context.ReadOnlyClone(), expressionNode.RHS) + + if err != nil { + return Context{}, err + } + + var collection *CandidateNode + if rhs.MatchingNodes.Len() != 0 { + collection = rhs.MatchingNodes.Front().Value.(*CandidateNode) + } else { + // no collection provided, return false for all + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { + candidate := el.Value.(*CandidateNode) + results.PushBack(createBooleanCandidate(candidate, false)) + } + return context.ChildContext(results), nil + } + + for el := context.MatchingNodes.Front(); el != nil; el = el.Next() { + candidate := el.Value.(*CandidateNode) + isIn := false + + switch collection.Kind { + case MappingNode: + // Check if candidate value exists as a key in the mapping + for index := 0; index < len(collection.Content); index = index + 2 { + key := collection.Content[index] + if key.Value == candidate.Value { + isIn = true + break + } + } + case SequenceNode: + // Check if candidate value is present in the sequence (value membership) + for _, element := range collection.Content { + if element.Value == candidate.Value { + isIn = true + break + } + } + default: + isIn = false + } + + results.PushBack(createBooleanCandidate(candidate, isIn)) + } + return context.ChildContext(results), nil +} diff --git a/pkg/yqlib/operator_in_test.go b/pkg/yqlib/operator_in_test.go new file mode 100644 index 0000000000..3e8a0ab672 --- /dev/null +++ b/pkg/yqlib/operator_in_test.go @@ -0,0 +1,105 @@ +package yqlib + +import ( + "testing" +) + +var inOperatorScenarios = []expressionScenario{ + { + description: "Check key exists in map using variable binding", + document: "a: 1\nb: 2\nc: 3\n", + expression: `. as $m | "a" | in($m)`, + expected: []string{ + "D0, P[], (!!bool)::true\n", + }, + }, + { + description: "Check key does not exist in map", + document: "a: 1\nb: 2\nc: 3\n", + expression: `. as $m | "d" | in($m)`, + expected: []string{ + "D0, P[], (!!bool)::false\n", + }, + }, + { + description: "Check value exists in array", + document: "- Tool\n- Food\n- Flower\n", + expression: `. as $m | "Food" | in($m)`, + expected: []string{ + "D0, P[], (!!bool)::true\n", + }, + }, + { + description: "Check value does not exist in array", + document: "- Tool\n- Food\n- Flower\n", + expression: `. as $m | "Animal" | in($m)`, + expected: []string{ + "D0, P[], (!!bool)::false\n", + }, + }, + { + description: "Check in with select on array elements", + subdescription: "Filter items whose type is in the given list", + document: "- {item: Pizza, type: Food}\n- {item: Rose, type: Flower}\n- {item: Hammer, type: Tool}\n", + expression: `.[] | select(.type | in(["Tool", "Food"]))`, + expected: []string{ + "D0, P[0], (!!map)::{item: Pizza, type: Food}\n", + "D0, P[2], (!!map)::{item: Hammer, type: Tool}\n", + }, + }, + { + description: "In with variable binding - found", + document: "a: 1\nb: 2\nc: 3\n", + expression: `. as $m | "b" | in($m)`, + expected: []string{ + "D0, P[], (!!bool)::true\n", + }, + }, + { + description: "In with variable binding - not found", + document: "a: 1\nb: 2\nc: 3\n", + expression: `. as $m | "z" | in($m)`, + expected: []string{ + "D0, P[], (!!bool)::false\n", + }, + }, + { + skipDoc: true, + document: "- one\n- two\n- three\n", + expression: `. as $m | "one" | in($m)`, + expected: []string{ + "D0, P[], (!!bool)::true\n", + }, + }, + { + skipDoc: true, + document: "- one\n- two\n- three\n", + expression: `. as $m | "five" | in($m)`, + expected: []string{ + "D0, P[], (!!bool)::false\n", + }, + }, + { + skipDoc: true, + document: "key: value\nother: stuff\n", + expression: `. as $m | "key" | in($m)`, + expected: []string{ + "D0, P[], (!!bool)::true\n", + }, + }, + { + skipDoc: true, + document: "key: value\nother: stuff\n", + expression: `. as $m | "missing" | in($m)`, + expected: []string{ + "D0, P[], (!!bool)::false\n", + }, + }, +} + +func TestInOperatorScenarios(t *testing.T) { + for _, tt := range inOperatorScenarios { + testScenario(t, &tt) + } + documentOperatorScenarios(t, "in", inOperatorScenarios) +}