Functions
atan2
atan2(x, y)
Returns the inverse tangent of x
/y
in radians between -pi and pi.
Code example
atan2(3, 2) -> 0.982793723247329
case
case(x, c1, r1, c2, r2, ..., (default))
Compare x
to each of c1
, c2
, etc. and return the matching r1
, r2
of the first match. If no entry matches, a final optional expression can be returned as default.
Code examples
case("b", "a", 1, "b", 2, "c", 3, 0) -> 2
case("d", "a", 1, "b", 2, "c", 3, 0) -> 0
ceil
ceil(x)
Returns x
rounded up to the nearest integer.
Code example
ceil(16.2) -> 17
chars
chars(x)
Creates an array of characters from a string.
Code example
"test".chars() -> ["t", "e", "s", "t"]
chunk
chunk(x, s)
Converts the list x
into several lists of length at most s
Code example
chunk([1, 2, 3, 4, 5, 6, 7], 3) -> [[1, 2, 3], [4, 5, 6], [7]]
concat
concat(x, y, ...)
Concatenate any number of strings.
Code examples
concat("Hello, ", "world!") -> "Hello, world!"
{
"externalId": concat("some-prefix:", input.tag)
}
distinct_by
distinct_by(x, (a(, b)) => ...)
Returns a list or object where the elements are distinct by the returned value of the given lambda function. The lambda function either takes list values, or object (value, key) pairs.
Code example
[1, 2, 3, 4, 5].distinct_by(x => x % 2) -> [1, 2]
except
except(x, (v(, k)) => ...)
or except(x, l)
Returns a list or object where keys or entries maching the predicate have been removed.
If the second argument is a lambda, it will be given the entry and if it returns true
, the entry is removed.
If the second argument is a list, any entry also found in this list will be removed.
Code examples
{
"x-axis": 13.6,
"y-axis": 63.1,
"z-axis": 1.4,
"offset": 4.3,
"power": "on"
}.except(["offset", "power"])
->
{
"x-axis": 13.6,
"y-axis": 63.1,
"z-axis": 1.4
}
{
"a": 1,
"b": 2,
"c": 3,
"d": 4
}.except((v, k) => v > 2)
->
{
"a": 1,
"b": 2
}
filter
filter(x, it => ...)
Removes any item from the list x
where the lambda function returns false
or null
.
Code examples
[1, 2, 3, 4].filter(item => item > 2) -> [3, 4]
input.data.map(row => {
"timestamp": to_unix_timestamp(row.StartTime, "%Y-%m-%dT%H:%M:%S"),
"value": try_float(row.Value, null),
"externalId": concat("prefix/", column.Name),
"type": "datapoint",
}).filter(dp => dp.value is "number")
flatmap
flatmap(x, it => ...)
Applies the lambda function to every item in the list x
and flattens the result.
For example, if the lambda function returns a list, the result of the flatmap
will just be a list instead of a list of lists.
Code examples
[[1, 2, 3], [2, 3, 4], [3, 4, 5]].flatmap(list => list.map(item => item + 1))
->
[2, 3, 4, 3, 4, 5, 4, 5, 6]
input.sensorData.flatmap(timeseries =>
timeseries.values.map(datapoint => {
"value": datapoint.value,
"timestamp": to_unix_timestamp(datapoint.datetime, "%Y-%m-%dT%H:%M:%S"),
"externalId": concat(timeseries.location, "/", timeseries.sensor),
"type": "datapoint"
})
)
float
float(x)
Converts x
into a floating point number if possible. If the conversion fails, the whole mapping will fail.
Consider using try_float instead if you need error handling.
Code example
float("6.1") -> 6.1
floor
floor(x)
Returns x
rounded down to the nearest integer.
Code example
floor(16.2) -> 16
format_timestamp
format_timestamp(x, f)
Converts the Unix timestamp x
into a string representation based on the format f
.
The format is given using the table found here.
Code examples
format_timestamp(1694159249120, "%Y-%m-%d %H:%M:%S") -> "2023-09-08 07:47:29"
format_timestamp(now(), "%d/%m - %Y") -> "08/09 - 2023"
if
if(x, y, (z))
Returns y
if x
evaluates to true
, otherwise return z
, or null
if z
is omitted.
Code examples
if(condition, "yes", "no")
if(true, "on", "off") -> "on"
int
int(x)
Converts x
into an integer if possible. If the conversion fails, the whole mapping will fail.
Consider using try_int instead if you need error handling.
Code example
int("6") -> 6
join
join(a, b, ...)
Returns the union of the given objects or arrays. If a key is present in multiple objects, it is overwritten by the rightmost object. Arrays are simply merged.
Code examples
join({"key1": "value1"}, {"key2": "value2"})
->
{
"key1": "value1",
"key2": "value2"
}
join([1, 2, 3], [4, 5], [6, 7, 8])
->
[1, 2, 3, 4, 5, 6, 7, 8]