Type specifier o, does not support negative numbers. If the given field is a negative integer, the output in undefined.

Type specifiers x and X expect the corresponding field to be that of a 64-bit signed integer and produce the same integer in the Hexadecimal numeral system stripped of any leading zeros. For instance, if a field num contains the value 42, running:

format("%X", field=[num])

The format() function creates the field _format = 2A. Notice that format() does not add the common denomination of 0x (from the C programming language) to the produced output unless given the # flag. Likewise, 0x can be added explicitly to the format string as:

format("0x%X", field=[num])

This would produce the field _format = 0x2A.

Hexadecimal formatting is closely related to the binary representation of the integer, which is in Two's complement representation. This has the adverse effect that the hexadecimals produced for negative integers can have a large amount of leading F characters. If your input is a signed 32-bit integer, you can shorten the output of format() down to only display output corresponding to 32-bits, using the length specifiers.

Type specifiers f and F format the given field as a real number with the specified precision. They only work on floating point values up to 1e9 (one billion). See Supported Precision for more information.

Type specifiers e and E formats the given field as a real number in scientific notation, lowercase and uppercase respectively. For instance, 176.54 formatted using %e becomes 1.765400e+02.

For type specifiers g and G the specified precision represents the amount of significant figures, instead of the number of digits after the decimal point. If the integer part of the number is larger than the specified amount of significant digits, g and G behave like e and E respectively, otherwise they behave like f and F. Notice that the minimum precision is 6 and the maximum precision is 9.

CPU time is the exact amount of time that the CPU has spent processing data for a specific program or process. In this example the avg() function is used to calculate the sum of all numbers; the mean of the CPU Time.

The query is used to averaging the field containing the CPU value. This value is then piped to the format() function, which provides a formatting code — how the field value should be formatted. In this example, it formats the value to two decimal. Calculation of CPU times is useful to determine processing power - for example if troubleshooting a system with high CPU usage.

Sample output from the incoming example data:

In this example, the format() function is used to combine values from two fields a and b into a single field combined using a comma as a separator.

Example incoming data might look like this:

The query is used to merge values from multiple fields into a single field using a specified format pattern.

This query is useful, for example, to create concatenated values for reporting, to prepare data for export, or to simplify complex multi-field data structures into a single field.

Sample output from the incoming example data:

The concat() is not able to concatenate fields and strings together. For example to create a pathname based on the directory and filename it is not possible to do:

concat([dirname,"/",filename],as=pathname)

This will raise an error. Instead, we can use format().

The format() function provides a flexible method of formatting data, including encapsulating or combining strings and fields together.

In this example, the format() is used to convert decimal numbers to uppercase hexadecimal format. The %X format specifier converts integers to hexadecimal with uppercase letters A-F.

Example incoming data might look like this:

The query is used to convert decimal numbers to their hexadecimal representation, which is particularly useful when working with binary data, memory addresses, or color codes.

This query is useful, for example, to analyze network packets, debug memory dumps, or work with data that is commonly represented in hexadecimal format.

Sample output from the incoming example data:

Note that the hexadecimal values are displayed in uppercase letters, and leading zeros are not included in the output. The original decimal values are preserved in the num field while the hexadecimal representations are stored in the _format field.

In this example, the format() is used to convert decimal numbers to uppercase hexadecimal format with the 0x prefix. The %X format specifier converts integers to hexadecimal with uppercase letters A-F.

Example incoming data might look like this:

The query is used to convert decimal numbers to their hexadecimal representation with the standard 0x prefix, making the output immediately recognizable as hexadecimal values.

This query is useful, for example, to format numbers for programming contexts, debug memory addresses, or analyze system-level logs where hexadecimal values are commonly prefixed with 0x.

Sample output from the incoming example data:

Note that each hexadecimal value is prefixed with 0x, making it clear that these are hexadecimal representations. The original decimal values are preserved in the num field while the formatted hexadecimal representations are stored in the _format field.

In this example, the top() is used to count occurrences of repository names in the field repo, followed by the format() function to create clickable links for each repository.

Example incoming data might look like this:

The query is used to analyze the frequency of repository interactions and create clickable links for each repository.

This query is useful, for example, to create interactive reports showing which repositories are most actively used, or to build dashboards where users can quickly access frequently accessed repositories.

Sample output from the incoming example data:

Note that the results are automatically sorted by count in descending order, showing the most frequently accessed repositories first. The original field value is preserved in the repo field while the formatted link is available in the link field.

In this example, the objectArray:eval() function is used to format the array entries in[].key and in[].value separating the concatenated values with a : in the output field out[]. The output must be a single field in this example as format() is only capable of creating a single value.

Example incoming data might look like this:

in[0].key = x
in[0].value = y
in[1].key = a
in[1].value = b

The query is used to format arrays of objects.

Sample output from the incoming example data:

out[0] = x:y
out[1] = a:b

In this example, the array:eval() function is used to convert all values (for example [Thermostat, Smart Light]) in an array devices[] from lowercase to uppercase and show the results in a new array.

Example incoming data might look like this:

The query is used to turn values in an array into uppercase. The array:eval() function can also be used for squaring a list of numbers in an array.

Sample output from the incoming example data:

To round a number to a specific number of decimal points, use format() rather than round().

When using format(), rounding is performed using standard math rules. The format() rounds a number to a specific decimal accuracy.