✨ add string.notIn([..]) (#5538)

Add the counterpart to the `in` call:

```coffee
> term.notIn([a,b,c])
true

> term.notIn([term])
false
```

Signed-off-by: Dominik Richter <dominik.richter@gmail.com>

Author: arlimus

llx/builtin.go

@@ -330,6 +330,7 @@ func init() {
 			string("contains" + types.Regex):               {f: stringContainsRegex, Label: "contains"},
 			string("contains" + types.Array(types.Regex)):  {f: stringContainsArrayRegex, Label: "contains"},
 			string("in"):        {f: stringInArray, Label: "in"},
+			string("notIn"):     {f: stringNotInArray, Label: "in"},
 			string("find"):      {f: stringFindV2, Label: "find"},
 			string("camelcase"): {f: stringCamelcaseV2, Label: "camelcase"},
 			string("downcase"):  {f: stringDowncaseV2, Label: "downcase"},
@@ -564,6 +565,7 @@ func init() {
 			string("contains" + types.Regex):               {f: dictContainsRegex, Label: "contains"},
 			string("contains" + types.Array(types.Regex)):  {f: dictContainsArrayRegex, Label: "contains"},
 			"in":           {f: dictIn, Label: "in"},
+			"notIn":        {f: dictNotIn, Label: "notIn"},
 			string("find"): {f: dictFindV2, Label: "find"},
 			// NOTE: the following functions are internal ONLY!
 			// We have not yet decided if and how these may be exposed to users
@@ -627,6 +629,7 @@ func init() {
 			"unique":                   {f: arrayUniqueV2},
 			"difference":               {f: arrayDifferenceV2},
 			"in":                       {f: anyArrayInStringArray},
+			"notIn":                    {f: anyArrayNotInStringArray},
 			"containsAll":              {f: arrayContainsAll},
 			"containsNone":             {f: arrayContainsNone},
 			"==":                       {Compiler: compileArrayOpArray("=="), f: tarrayCmpTarrayV2, Label: "=="},

llx/builtin_array.go

@@ -820,6 +820,18 @@ func anyArrayInStringArray(e *blockExecutor, bind *RawData, chunk *Chunk, ref ui
 	return BoolTrue, 0, nil
 }
 
+func anyArrayNotInStringArray(e *blockExecutor, bind *RawData, chunk *Chunk, ref uint64) (*RawData, uint64, error) {
+	// mildly inefficient, but reduces complexity
+	res, ref, err := anyArrayInStringArray(e, bind, chunk, ref)
+	if res == BoolTrue {
+		return BoolFalse, ref, err
+	}
+	if res == BoolFalse {
+		return BoolTrue, ref, err
+	}
+	return res, ref, err
+}
+
 func arrayContainsAll(e *blockExecutor, bind *RawData, chunk *Chunk, ref uint64) (*RawData, uint64, error) {
 	if bind.Value == nil {
 		return &RawData{Type: bind.Type, Error: bind.Error}, 0, nil

llx/builtin_map.go

@@ -1535,6 +1535,17 @@ func dictIn(e *blockExecutor, bind *RawData, chunk *Chunk, ref uint64) (*RawData
 	}
 }
 
+func dictNotIn(e *blockExecutor, bind *RawData, chunk *Chunk, ref uint64) (*RawData, uint64, error) {
+	switch bind.Value.(type) {
+	case string:
+		return stringNotInArray(e, bind, chunk, ref)
+	case []any:
+		return anyArrayNotInStringArray(e, bind, chunk, ref)
+	default:
+		return nil, 0, errors.New("dict value does not support field `in`")
+	}
+}
+
 func dictFindV2(e *blockExecutor, bind *RawData, chunk *Chunk, ref uint64) (*RawData, uint64, error) {
 	switch bind.Value.(type) {
 	case string:

llx/builtin_simple.go

@@ -2262,6 +2262,35 @@ func stringInArray(e *blockExecutor, bind *RawData, chunk *Chunk, ref uint64) (*
 	return BoolFalse, 0, nil
 }
 
+func stringNotInArray(e *blockExecutor, bind *RawData, chunk *Chunk, ref uint64) (*RawData, uint64, error) {
+	if bind.Value == nil {
+		return BoolTrue, 0, nil
+	}
+
+	argRef := chunk.Function.Args[0]
+	arg, rref, err := e.resolveValue(argRef, ref)
+	if err != nil || rref > 0 {
+		return nil, rref, err
+	}
+
+	if arg.Value == nil {
+		return BoolTrue, 0, nil
+	}
+
+	arr := arg.Value.([]interface{})
+	for i := range arr {
+		v, ok := arr[i].(string)
+		if !ok {
+			return nil, 0, errors.New("invalid type in array")
+		}
+
+		if v == bind.Value.(string) {
+			return BoolFalse, 0, nil
+		}
+	}
+	return BoolTrue, 0, nil
+}
+
 func stringFindV2(e *blockExecutor, bind *RawData, chunk *Chunk, ref uint64) (*RawData, uint64, error) {
 	if bind.Value == nil {
 		return ArrayData([]interface{}{}, types.String), 0, nil

mql/mql_test.go

@@ -327,7 +327,7 @@ func TestNullString(t *testing.T) {
 	})
 }
 
-func TestDictMethods(t *testing.T) {
+func TestDictContains(t *testing.T) {
 	x := testutils.InitTester(testutils.LinuxMock())
 	x.TestSimple(t, []testutils.SimpleTest{
 		{

mqlc/builtin.go

@@ -68,9 +68,13 @@ func init() {
 				desc: "Checks if this string contains another string",
 			},
 			"in": {
-				typ: boolType, compile: compileStringIn,
+				typ: boolType, compile: compileStringInOrNotIn,
 				desc: "Checks if this string is contained in an array of strings",
 			},
+			"notIn": {
+				typ: boolType, compile: compileStringInOrNotIn,
+				desc: "Checks if this string is not contained in an array of strings",
+			},
 			"find": {
 				typ: stringArrayType, signature: FunctionSignature{Required: 1, Args: []types.Type{types.Regex}},
 				desc: "Find a regular expression in a string and return all matches as an array",
@@ -126,6 +130,9 @@ func init() {
 			"lines":     {typ: stringArrayType, signature: FunctionSignature{}},
 			"split":     {typ: stringArrayType, signature: FunctionSignature{Required: 1, Args: []types.Type{types.String}}},
 			"trim":      {typ: stringType, signature: FunctionSignature{Required: 0, Args: []types.Type{types.String}}},
+			// string / array
+			"in":    {typ: boolType, signature: FunctionSignature{Required: 1, Args: []types.Type{types.Array(types.String), types.Array(types.Dict)}}},
+			"notIn": {typ: boolType, signature: FunctionSignature{Required: 1, Args: []types.Type{types.Array(types.String), types.Array(types.Dict)}}},
 			// array- or map-ish
 			"first":   {typ: dictType, signature: FunctionSignature{}},
 			"last":    {typ: dictType, signature: FunctionSignature{}},
@@ -136,7 +143,6 @@ func init() {
 				compile: compileDictContains, typ: boolType, signature: FunctionSignature{Required: 1, Args: []types.Type{types.FunctionLike}},
 				desc: "When dealing with strings, check if it contains another string. When dealing with maps or arrays, check if any entry matches the given condition.",
 			},
-			"in":           {typ: boolType, signature: FunctionSignature{Required: 1, Args: []types.Type{types.Array(types.String)}}},
 			"containsOnly": {compile: compileDictContainsOnly, signature: FunctionSignature{Required: 1, Args: []types.Type{types.FunctionLike}}},
 			"containsAll":  {compile: compileDictContainsAll, signature: FunctionSignature{Required: 1, Args: []types.Type{types.FunctionLike}}},
 			"containsNone": {compile: compileDictContainsNone, signature: FunctionSignature{Required: 1, Args: []types.Type{types.FunctionLike}}},
@@ -187,7 +193,8 @@ func init() {
 			"sample":       {typHandler: &sameType, signature: FunctionSignature{Required: 1, Args: []types.Type{types.Int}}},
 			"duplicates":   {compile: compileArrayDuplicates, signature: FunctionSignature{Required: 0, Args: []types.Type{types.String}}},
 			"unique":       {compile: compileArrayUnique, signature: FunctionSignature{Required: 0}},
-			"in":           {typ: boolType, compile: compileStringIn, signature: FunctionSignature{Required: 1, Args: []types.Type{types.Array(types.String)}}},
+			"in":           {typ: boolType, compile: compileStringInOrNotIn, signature: FunctionSignature{Required: 1, Args: []types.Type{types.Array(types.String)}}},
+			"notIn":        {typ: boolType, compile: compileStringInOrNotIn, signature: FunctionSignature{Required: 1, Args: []types.Type{types.Array(types.String)}}},
 			"contains":     {compile: compileArrayContains, signature: FunctionSignature{Required: 1, Args: []types.Type{types.FunctionLike}}},
 			"containsOnly": {compile: compileArrayContainsOnly, signature: FunctionSignature{Required: 1, Args: []types.Type{types.FunctionLike}}},
 			"containsAll":  {compile: compileArrayContainsAll, signature: FunctionSignature{Required: 1, Args: []types.Type{types.FunctionLike}}},

mqlc/builtin_simple.go

@@ -166,7 +166,7 @@ func compileStringContains(c *compiler, typ types.Type, ref uint64, id string, c
 	}
 }
 
-func compileStringIn(c *compiler, typ types.Type, ref uint64, id string, call *parser.Call) (types.Type, error) {
+func compileStringInOrNotIn(c *compiler, typ types.Type, ref uint64, id string, call *parser.Call) (types.Type, error) {
 	if call == nil || len(call.Function) != 1 {
 		return types.Nil, errors.New("function " + id + " needs one argument")
 	}
@@ -178,7 +178,7 @@ func compileStringIn(c *compiler, typ types.Type, ref uint64, id string, call *p
 
 	c.addChunk(&llx.Chunk{
 		Call: llx.Chunk_FUNCTION,
-		Id:   "in",
+		Id:   id,
 		Function: &llx.Function{
 			Type:    string(types.Bool),
 			Binding: ref,

providers/core/resources/mql_test.go

@@ -436,6 +436,14 @@ func TestString_Methods(t *testing.T) {
 			Code:        "'hiya'.in([])",
 			Expectation: false,
 		},
+		{
+			Code:        "'hiya'.notIn(['one', 'hiya'])",
+			Expectation: false,
+		},
+		{
+			Code:        "'hiya'.notIn(['one', 'two'])",
+			Expectation: true,
+		},
 		{
 			Code:        "'oh-hello-world!'.camelcase",
 			Expectation: "ohHelloWorld!",

providers/os/resources/mql_test.go

@@ -262,6 +262,42 @@ func TestResource_duplicateFields(t *testing.T) {
 	})
 }
 
+func TestDict_Methods_In(t *testing.T) {
+	p := "parse.json('/dummy.json')."
+
+	x := testutils.InitTester(testutils.LinuxMock())
+	x.TestSimple(t, []testutils.SimpleTest{
+		{
+			Code:        p + "params['hello'].in(['1','2','hello'])",
+			ResultIndex: 1,
+			Expectation: true,
+		},
+		{
+			Code:        p + "params['hello'].in(['1','2'])",
+			ResultIndex: 1,
+			Expectation: false,
+		},
+	})
+}
+
+func TestDict_Methods_NotIn(t *testing.T) {
+	p := "parse.json('/dummy.json')."
+
+	x := testutils.InitTester(testutils.LinuxMock())
+	x.TestSimple(t, []testutils.SimpleTest{
+		{
+			Code:        p + "params['hello'].notIn(['1','2','hello'])",
+			ResultIndex: 1,
+			Expectation: false,
+		},
+		{
+			Code:        p + "params['hello'].notIn(['1','2'])",
+			ResultIndex: 1,
+			Expectation: true,
+		},
+	})
+}
+
 func TestDict_Methods_InRange(t *testing.T) {
 	p := "parse.json('/dummy.json')."