✨ array.reverse() and array.join() (#6058)

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

Author: arlimus

llx/builtin.go

@@ -633,6 +633,8 @@ func init() {
 			"$one":                     {f: arrayOneV2},
 			"map":                      {f: arrayMapV2},
 			"flat":                     {f: arrayFlat},
+			"reverse":                  {f: arrayReverse},
+			"join":                     {f: arrayJoin},
 			"duplicates":               {f: arrayDuplicatesV2},
 			"fieldDuplicates":          {f: arrayFieldDuplicatesV2},
 			"unique":                   {f: arrayUniqueV2},

llx/builtin_array.go

@@ -7,6 +7,7 @@ import (
 	"errors"
 	"math/rand"
 	"strconv"
+	"strings"
 
 	"go.mondoo.com/cnquery/v12/types"
 	"go.mondoo.com/cnquery/v12/utils/multierr"
@@ -506,6 +507,63 @@ func arrayFlat(e *blockExecutor, bind *RawData, chunk *Chunk, ref uint64) (*RawD
 	return &RawData{Type: types.Array(typ), Value: res}, 0, nil
 }
 
+func arrayReverse(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
+	}
+
+	list, ok := bind.Value.([]any)
+	// this should not happen at this point
+	if !ok {
+		return &RawData{Type: bind.Type, Error: errors.New("incorrect type, no array data found")}, 0, nil
+	}
+
+	res := make([]any, len(list))
+	for i := range list {
+		res[len(res)-1-i] = list[i]
+	}
+
+	return &RawData{Type: bind.Type, Value: res}, 0, nil
+}
+
+func arrayJoin(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
+	}
+
+	list, ok := bind.Value.([]any)
+	// this should not happen at this point
+	if !ok {
+		return &RawData{Type: bind.Type, Error: errors.New("incorrect type, no array data found")}, 0, nil
+	}
+
+	var sep string
+	if len(chunk.Function.Args) == 1 {
+		item, rref, err := e.resolveValue(chunk.Function.Args[0], ref)
+		if err != nil || rref > 0 {
+			return nil, rref, err
+		}
+		sep, ok = item.Value.(string)
+		if !ok {
+			return nil, rref, errors.New("separator provided to join() must be a string")
+		}
+	}
+
+	var res strings.Builder
+	for i := range list {
+		s, ok := list[i].(string)
+		if !ok {
+			return nil, 0, errors.New("failed to join() elements, must be strings")
+		}
+		if sep != "" && i > 0 {
+			res.WriteString(sep)
+		}
+		res.WriteString(s)
+	}
+
+	return &RawData{Type: types.String, Value: res.String()}, 0, nil
+}
+
 // Take an array and separate it into a list of unique entries and another
 // list of only duplicates. The latter list only has every entry appear only
 // once.

mqlc/builtin.go

@@ -209,6 +209,8 @@ func init() {
 			"none":         {compile: compileArrayNone, signature: FunctionSignature{Required: 1, Args: []types.Type{types.FunctionLike}}},
 			"map":          {compile: compileArrayMap, signature: FunctionSignature{Required: 1, Args: []types.Type{types.FunctionLike}}},
 			"flat":         {compile: compileArrayFlat, signature: FunctionSignature{}},
+			"reverse":      {typHandler: &sameType, signature: FunctionSignature{}},
+			"join":         {compile: compileArrayJoin, signature: FunctionSignature{Args: []types.Type{types.String}}},
 		},
 		types.MapLike: {
 			"[]":       {typHandler: &childType, signature: FunctionSignature{Required: 1, Args: []types.Type{types.String}}},

mqlc/builtin_array.go

@@ -526,3 +526,35 @@ func compileArrayFlat(c *compiler, typ types.Type, ref uint64, id string, call *
 	})
 	return typ, nil
 }
+
+func compileArrayJoin(c *compiler, typ types.Type, ref uint64, id string, call *parser.Call) (types.Type, error) {
+	switch typ.Child() {
+	case types.String, types.Dict:
+	default:
+		return types.Nil, errors.New("can only call join() on arrays that have strings in them")
+	}
+
+	var args []*llx.Primitive = nil
+	if call != nil {
+		if len(call.Function) > 1 {
+			return types.Nil, errors.New("called join() with too many arguments, at most one supported")
+		}
+		prim, err := callArgTypeIs(c, call, id, "separator", 0, types.String, types.Dict)
+		if err != nil {
+			return types.Nil, err
+		}
+		args = []*llx.Primitive{prim}
+	}
+
+	c.addChunk(&llx.Chunk{
+		Call: llx.Chunk_FUNCTION,
+		Id:   id,
+		Function: &llx.Function{
+			Type:    string(typ),
+			Binding: ref,
+			Args:    args,
+		},
+	})
+
+	return types.String, nil
+}

providers/core/resources/mql_test.go

@@ -471,6 +471,10 @@ func TestString_Methods(t *testing.T) {
 			Code:        "'hello world'.split(' ')",
 			Expectation: []any{"hello", "world"},
 		},
+		{
+			Code:        "'1.2.3.4'.split('.').reverse.join(':')",
+			Expectation: "4:3:2:1",
+		},
 		{
 			Code:        "'he\nll\no'.lines",
 			Expectation: []any{"he", "ll", "o"},
@@ -574,6 +578,14 @@ func TestArray(t *testing.T) {
 			Code:        "[1,2,3]",
 			Expectation: []any{int64(1), int64(2), int64(3)},
 		},
+		{
+			Code:        "[1,2,3].length",
+			Expectation: int64(3),
+		},
+		{
+			Code:        "[1,2,3].reverse",
+			Expectation: []any{int64(3), int64(2), int64(1)},
+		},
 		{
 			Code:        "return [1,2,3]",
 			Expectation: []any{int64(1), int64(2), int64(3)},