---
title: Work with dynamic types
description: A dynamic type is a wrapper for data whose type is not known until runtime. Dynamic types help when working with data from external sources (like JSON) that support types that do not have an equivalent Flux type.
url: https://docs.influxdata.com/flux/v0/data-types/dynamic/
estimated_tokens: 5304
product: Flux
version: v0
publisher: InfluxData
canonical: https://docs.influxdata.com/flux/v0/data-types/dynamic/
date: '2023-11-06T17:08:22-07:00'
lastmod: '2023-11-06T17:08:22-07:00'
---

A **dynamic** type is a wrapper for data whose type is not known until runtime.
Dynamic types help when working with data from external sources (like JSON)
that support types that do not have an equivalent Flux type.

* [Parse JSON into Flux types](#parse-json-into-flux-types)
* [Dynamic type syntax](#dynamic-type-syntax)
* [Reference values in a dynamic type](#reference-values-in-a-dynamic-type)
* [Operate on dynamic types](#operate-on-dynamic-types)

#### Dynamic types are not supported in tables

**Dynamic types are not supported in Flux tables.**To include a dynamic value in a Flux table, you must[cast the dynamic type to a Flux basic type](#basic-types).
For a full example of casting dynamic types to basic types and including them
in a table, see [Include dynamic types in a table](#include-dynamic-types-in-a-table).

## Parse JSON into Flux types

The primary (but not exclusive) use case for dynamic types is converting JSON
data into native Flux types; specifically Flux [arrays](/flux/v0/data-types/composite/array/)and [records](/flux/v0/data-types/composite/record/).

Because of strict typing rules in Flux, JSON data doesn’t always gracefully parse
into native Flux types.
The most common reason is that Flux arrays require all children to be the same type.
JSON arrays allow elements to be different types.

With Flux records (the corollary of a JSON object), the properties in the record
are part of the record’s type.
If you have a JSON array of objects where the objects’ schemas are different,
the array cannot be parsed as a Flux array because the types of the records in
the array do not match.

[](#view-examples-of-json-arrays-that-cannot-be-directly-parsed-into-flux-arrays)

View examples of JSON arrays that cannot be directly parsed into Flux arrays

#### Array of scalar values

The following array is a valid JSON array, but an invalid Flux array because
each element in the array is a different type.

```json
["three", 2, true]
```

#### Array of objects

The following array is a valid JSON array, but an invalid Flux array.
The schemas of the objects in the array do not match, so when converted to Flux
records, their types do not match and the array is invalid.

```json
[
    {"first-name": "John", "last-name": "Doe", "age": 42},
    {"first-name": "Jane", "last-name": "Doe"},
    {"first-name": "James", "last-name": "Doe", "age": 15}
]
```

The dynamic type provides a way to resolve the differences between JSON and Flux types.

## Dynamic type syntax

Flux does not provide a literal syntax for dynamic types.
To cast a value to a dynamic type:

1. Import the [`experimental/dynamic` package](/flux/v0/stdlib/experimental/dynamic/).
2. Use [`dynamic.dynamic()`](/flux/v0/stdlib/experimental/dynamic/dynamic/) to
   convert a value to a dynamic type.

```
import "experimental/dynamic"

dynamic.dynamic(v: "Example string")

// Returns dynamic(Example string)

```

## Reference values in a dynamic type

Use bracket and dot notation to reference values in dynamic records and arrays.
Use the `exists` operator to check if a dynamic type contains a non-null value.

* [Reference values in a dynamic record](#reference-values-in-a-dynamic-record)
* [Reference values in a dynamic array](#reference-values-in-a-dynamic-array)
* [Ensure a dynamic type contains a non-null value](#ensure-a-dynamic-type-contains-a-non-null-value)

### Reference values in a dynamic record

```
import "experimental/dynamic"

record = {one: 1, two: 2, three: 3}
dynamicRecord = dynamic.dynamic(v: record)

dynamicRecord.one
// Returns dynamic(1)

dynamicRecord["two"]
// Returns dynamic(2)

```

### Reference values in a dynamic array

```
import "experimental/dynamic"

arr = ["a", "b", "c"]
dynamicArr = dynamic.asArray(v: dynamic.dynamic(v: arr))

dynamicArr[0]
// Returns dynamic(a)

```

### Ensure a dynamic type contains a non-null value

Use the `exists` operator to check if a dynamic type contains a non-null value.
If you attempt to access members of a null dynamic value, Flux returns an error.`exists` lets you guard against errors caused by attempting to access members in
null dynamic values.

[](#view-examples-of-using-exists-to-check-for-non-null-dynamic-types)

View examples of using `exists` to check for non-null dynamic types

```
import "experimental/dynamic"
import "internal/debug"

dynamicRecord = dynamic.dynamic(v: {one: 1, two: 2, three: 3})
dynamicNull = dynamic.dynamic(v: debug.null())

exists dynamicRecord
// Returns true

exists dynamicNull
// Returns false

```

##### Accessing members of dynamic types

```
dynamicRecord.one
// Returns dynamic(1)

dynamicRecord.four
// Returns dynamic(<null>)

dynamicNull.one
// Error: cannot access property "one" on value of type invalid

```

## Operate on dynamic types

* [Convert dynamic types to Flux types](#convert-dynamic-types-to-flux-types)

  * [Basic types](#basic-types)
  * [Composite types](#composite-types)

* [Include dynamic types in a table](#include-dynamic-types-in-a-table)

* [Convert a JSON array to a Flux table](#convert-a-json-array-to-a-flux-table)

* [Encode a dynamic type as JSON](#encode-a-dynamic-type-as-json)

  * [Encode a dynamic record as JSON](#encode-a-dynamic-record-as-json)
  * [Encode a dynamic array of different basic types as JSON](#encode-a-dynamic-array-of-different-basic-types-as-json)

### Convert dynamic types to Flux types

#### Basic types

#### String ####

Use [`string()`](/flux/v0/stdlib/universe/string/) to convert a dynamic type to a string.`string()` returns the string representation of the dynamic value.

```
import "experimental/dynamic"

dynamicValue = dynamic.dynamic(v: "string")

string(v: dynamicValue)
// Returns "string"

```

Use [`int()`](/flux/v0/stdlib/universe/int/) to convert a dynamic type to an integer.`int()` returns the [integer equivalent](/flux/v0/data-types/basic/int/#convert-data-types-to-integers)of the dynamic value.

```
import "experimental/dynamic"

dynamicValue = dynamic.dynamic(v: "12")

int(v: dynamicValue)
// Returns 12

```

Use [`uint()`](/flux/v0/stdlib/universe/uint/) to convert a dynamic type to an unsigned integer (UInteger).`uint()` returns the [UInteger equivalent](/flux/v0/data-types/basic/uint/#convert-data-types-to-uintegers)of the dynamic value.

```
import "experimental/dynamic"

dynamicValue = dynamic.dynamic(v: "12")

uint(v: dynamicValue)
// Returns 12

```

Use [`float()`](/flux/v0/stdlib/universe/float/) to convert a dynamic type to a floating point value.`float()` returns the [float equivalent](/flux/v0/data-types/basic/float/#convert-data-types-to-floats)of the dynamic value.

```
import "experimental/dynamic"

dynamicValue = dynamic.dynamic(v: "12.1")

float(v: dynamicValue)
// Returns 12.1

```

Use [`bool()`](/flux/v0/stdlib/universe/bool/) to convert a dynamic type to a boolean value.`bool()` returns the [boolean equivalent](/flux/v0/data-types/basic/bool/#convert-data-types-to-booleans)of the dynamic value.

```
import "experimental/dynamic"

dynamicValue = dynamic.dynamic(v: "true")

bool(v: dynamicValue)
// Returns true

```

Use [`duration()`](/flux/v0/stdlib/universe/duration/) to convert a dynamic type to a duration value.`duration()` returns the [duration equivalent](/flux/v0/data-types/basic/duration/#convert-data-types-to-durations)of the dynamic value.

```
import "experimental/dynamic"

dynamicValue = dynamic.dynamic(v: 3000000000)

duration(v: dynamicValue)
// Returns 3s

```

Use [`time()`](/flux/v0/stdlib/universe/time/) to convert a dynamic type to a time value.`time()` returns the [time equivalent](/flux/v0/data-types/basic/time/#convert-data-types-to-time)of the dynamic value.

```
import "experimental/dynamic"

dynamicValue = dynamic.dynamic(v: 1640995200000000000)

time(v: dynamicValue)
// Returns 2022-01-01T00:00:00.000000000Z

```

Use [`bytes()`](/flux/v0/stdlib/universe/bytes/) to convert a dynamic type to a byte-encoded string.`bytes()` returns the [bytes equivalent](/flux/v0/data-types/basic/bytes/#convert-data-types-to-bytes)of the dynamic value.

```
import "experimental/dynamic"

dynamicValue = dynamic.dynamic(v: "Hello world!")

bytes(v: dynamicValue)
// Returns 0x48656c6c6f20776f726c6421

```

1. Use [`string()`](/flux/v0/stdlib/universe/string/) to convert a dynamic type to a string.
2. Import the [`regexp` package](/flux/v0/stdlib/regexp/) and use[`regexp.compile()`](/flux/v0/stdlib/regexp/compile/) to convert the string
   value to a regular expression type.

```
import "experimental/dynamic"
import "regexp"

dynamicValue = dynamic.dynamic(v: "^[abc][123]{1,}")
stringValue = string(v: dynamicValue)

regexp.compile(v: stringValue)
// Returns /^[abc][123]{1,}/

```

#### Composite types

Dynamic composite types will almost always come from working with a byte-encoded
JSON string. All the examples below assume this.

#### Array ####

**To convert a JSON array to a Flux array:**

1. Import the following packages:

   * [array](/flux/v0/stdlib/array/)
   * [experimental/dynamic](/flux/v0/stdlib/experimental/dynamic/)

2. Use [`dynamic.jsonParse()`](/flux/v0/stdlib/experimental/dynamic/jsonparse/)to parse a byte-encoded JSON string into a dynamic type.

3. Use [`dynamic.asArray()`](/flux/v0/stdlib/experimental/dynamic/asarray/)to convert the dynamic-typed array into an array of dynamic types.

4. Use [`array.map()`](/flux/v0/stdlib/array/map/) to iterate over each element
   in the array and explicitly [cast dynamic types to basic types](#basic-types).

[](#view-example-with-an-array-of-scalar-values)

View example with an array of scalar values

##### JSON array of scalar values

```json
["3", 2, true]
```

##### Convert a JSON array of scalar values to a Flux array

```
import "array"
import "experimental/dynamic"

json = jsonBytes // Byte-encoded JSON above
parsed = dynamic.jsonParse(data: json)

parsed
    |> dynamic.asArray()
    |> array.map(fn: (x) => int(v: x))

// Returns [3, 2, 1]

```

[](#view-example-with-an-array-of-json-objects)

View example with an array of JSON objects

##### JSON array of objects

```json
[
    {"first-name": "John", "last-name": "Doe", "age": 42},
    {"first-name": "Jane", "last-name": "Doe"},
    {"first-name": "James", "last-name": "Doe", "age": 15}
]
```

##### Convert a JSON array of objects to a Flux array

```
import "array"
import "experimental/dynamic"

json = jsonBytes // Byte-encoded JSON above
parsed = dynamic.jsonParse(data: json)

parsed
    |> dynamic.asArray()
    |> array.map(
        fn: (x) => ({
            fname: string(v: x["first-name"]),
            lname: string(v: x["last-name"]),
            age: int(v: x.age)
        }),
    )

// Returns [
//     {age: 42, fname: John, lname: Doe},
//     {age: <null>, fname: Jane, lname: Doe},
//     {age: 15, fname: James, lname: Doe}
// ]

```

**To convert a JSON object to a Flux record:**

1. Import the [`experimental/dynamic` package](/flux/v0/stdlib/experimental/dynamic/)
2. Use [`dynamic.jsonParse()`](/flux/v0/stdlib/experimental/dynamic/jsonparse/)to parse a byte-encoded JSON string into a dynamic type.
3. Define a new record and [cast each property of the dynamic type to a basic type](#basic-types).

##### JSON object

```json
{"first-name": "John", "last-name": "Doe", "age": 42}
```

##### Convert a JSON object to a Flux record

```
import "experimental/dynamic"

json = jsonBytes // Byte-encoded JSON above
parsed = dynamic.jsonParse(data: json)

newRecord = {
    fname: string(v: parsed["first-name"]),
    lname: string(v: parsed["last-name"]),
    age: int(v: parsed.age)
}

// newRecord returns {age: 42, fname: John, lname: Doe}

```

### Check the type of a value inside of a dynamic type

Use [`dynamic.isType()`](/flux/v0/stdlib/experimental/dynamic/istype/) to check
the type of a value inside of a dynamic type.

The following example uses the [`http/requests` package](/flux/v0/stdlib/http/requests/)and the [Fruityvice API](https://www.fruityvice.com/) to return information about
apples as a JSON object.

[](#view-the-returned-json-object)

View the returned JSON object

```json
{
    "genus": "Malus",
    "name": "Apple",
    "id": 6,
    "family": "Rosaceae",
    "order": "Rosales",
    "nutritions": {
        "carbohydrates": 11.4,
        "protein": 0.3,
        "fat": 0.4,
        "calories": 52,
        "sugar": 10.3
    }
}
```

```
import "experimental/dynamic"

response = requests.get(url: "https://www.fruityvice.com/api/fruit/apple")
parsed = dynamic.jsonParse(data: response.body)

dynamic.isType(v: parsed.genus, type: "string")
// Returns true

dynamic.isType(v: parsed.nutritions, type: "array")
// Returns false

dynamic.isType(v: parsed.nutritions, type: "object")
// Returns true

```

### Include dynamic types in a table

**Dynamic types are not supported in Flux tables.**To include a dynamic value in a Flux table,[cast the dynamic type to a Flux basic type](#basic-types).

The following example uses [`array.from()`](/flux/v0/stdlib/array/from/) to
build and ad hoc table using dynamic types.
Each dynamic type must be cast to a Flux basic type when defining the row record.

```js
import "array"
import "experimental/dynamic"

dynamicString = dynamic.dynamic(v: "one")
dynamicInt = dynamic.dynamic(v: 1)
dynamicFloat = dynamic.dynamic(v: 1.0)
dynamicBool = dynamic.dynamic(v: true)

array.from(
    rows: [
        {
            string: string(v: dynamicString),
            int: int(v: dynamicInt),
            float: float(v: dynamicFloat),
            bool: bool(v: dynamicBool),
        },
    ],
)
```

[](#view-output-table)

View output table

|string|int|float|bool|
|------|---|-----|----|
| one  | 1 | 1.0 |true|

### Convert a JSON array to a Flux table

1. Import the following packages:

   * [array](/flux/v0/stdlib/array/)
   * [experimental/dynamic](/flux/v0/stdlib/experimental/dynamic/)

2. Use [`dynamic.jsonParse()`](/flux/v0/stdlib/experimental/dynamic/jsonparse/)to parse the the JSON response body returned from `requests.get()` into a
   Flux dynamic type.
   Define a variable to capture the parsed JSON.
   The example below uses the `parsed` variable.

3. Use [`dynamic.asArray()`](/flux/v0/stdlib/experimental/dynamic/asarray/)to convert the dynamic type returned by `dynamic.jsonParse()` to a dynamic
   array. Define a variable to capture the dynamic array.
   The example below uses the `fruit` variable.

4. Use [`array.map()`](/flux/v0/stdlib/array/map/) to do the following:

   * Iterate over each dynamic record in the dynamic array and flatten nested records.
     Flux tables do not support nested [records](/flux/v0/data-types/composite/record/)(the corollary of a JSON object).
   * Explicitly [cast dynamic values in each dynamic record to a Flux basic type](#basic-types).

The following example uses the [`http/requests` package](/flux/v0/stdlib/http/requests/)and the [Fruityvice API](https://www.fruityvice.com/) to return information about
various fruit as JSON and then structure the returned data as a Flux table.

```js
import "array"
import "experimental/dynamic"
import "http/requests"

response = requests.get(url: "https://www.fruityvice.com/api/fruit/all")
parsed = dynamic.jsonParse(data: response.body)
fruit = dynamic.asArray(v: parsed)

fruit_flat =
    fruit
        |> array.map(
            fn: (x) =>
                ({
                    name: string(v: x.name),
                    cals: int(v: x.nutritions.calories),
                    carbs: float(v: x.nutritions.carbohydrates),
                    fat: float(v: x.nutritions.fat),
                    protein: float(v: x.nutritions.protein),
                    sugar: float(v: x.nutritions.sugar),
                }),
        )

array.from(rows: fruit_flat)
```

[](#view-output-table)

View output table

|    name    |cals|carbs| fat |protein|sugar|
|------------|----|-----|-----|-------|-----|
|   Apple    | 52 |11.4 | 0.4 |  0.3  |10.3 |
|  Apricot   | 15 | 3.9 | 0.1 |  0.5  | 3.2 |
|  Avocado   |160 |8.53 |14.66|   2   |0.66 |
|   Banana   | 96 | 22  | 0.2 |   1   |17.2 |
| Blackberry | 40 |  9  | 0.4 |  1.3  | 4.5 |
| Blueberry  | 29 | 5.5 | 0.4 |   0   | 5.4 |
|   Cherry   | 50 | 12  | 0.3 |   1   |  8  |
|Dragonfruit | 60 |  9  | 1.5 |   9   |  8  |
|   Durian   |147 |27.1 | 5.3 |  1.5  |6.75 |
|   Feijoa   | 44 |  8  | 0.4 |  0.6  |  3  |
|    Fig     | 74 | 19  | 0.3 |  0.8  | 16  |
| Gooseberry | 44 | 10  | 0.6 |  0.9  |  0  |
|   Grape    | 69 |18.1 |0.16 | 0.72  | 16  |
|   Grapes   | 69 |18.1 |0.16 | 0.72  |15.48|
| GreenApple | 21 | 3.1 | 0.1 |  0.4  | 6.4 |
|   Guava    | 68 | 14  |  1  |  2.6  |  9  |
|    Kiwi    | 61 | 15  | 0.5 |  1.1  |  9  |
| Kiwifruit  | 61 |14.6 | 0.5 | 1.14  | 8.9 |
|   Lemon    | 29 |  9  | 0.3 |  1.1  | 2.5 |
|    Lime    | 25 | 8.4 | 0.1 |  0.3  | 1.7 |
|Lingonberry | 50 |11.3 |0.34 | 0.75  |5.74 |
|   Lychee   | 66 | 17  |0.44 |  0.8  | 15  |
|   Mango    | 60 | 15  |0.38 | 0.82  |13.7 |
|   Melon    | 34 |  8  |  0  |   0   |  8  |
|   Morus    | 43 | 9.8 |0.39 | 1.44  | 8.1 |
|   Orange   | 43 | 8.3 | 0.2 |   1   | 8.2 |
|   Papaya   | 43 | 11  | 0.4 |   0   |  1  |
|Passionfruit| 97 |22.4 | 0.7 |  2.2  |11.2 |
|    Pear    | 57 | 15  | 0.1 |  0.4  | 10  |
| Persimmon  | 81 | 18  |  0  |   0   | 18  |
| Pineapple  | 50 |13.12|0.12 | 0.54  |9.85 |
|  Pitahaya  | 36 |  7  | 0.4 |   1   |  3  |
|    Plum    | 46 |11.4 |0.28 |  0.7  |9.92 |
|Pomegranate | 83 |18.7 | 1.2 |  1.7  |13.7 |
| Raspberry  | 53 | 12  | 0.7 |  1.2  | 4.4 |
| Strawberry | 29 | 5.5 | 0.4 |  0.8  | 5.4 |
| Tangerine  | 45 | 8.3 | 0.4 |   0   | 9.1 |
|   Tomato   | 74 | 3.9 | 0.2 |  0.9  | 2.6 |
| Watermelon | 30 |  8  | 0.2 |  0.6  |  6  |

### Encode a dynamic type as JSON

#### Encode a dynamic record as JSON

1. Import the `experimental/dynamic` package.
2. Use [`dynamic.dynamic()`](/flux/v0/stdlib/experimental/dynamic/dynamic/)to convert the record to a dynamic type.
3. Use [`dynamic.jsonEncode()`](/flux/v0/stdlib/experimental/dynamic/jsonencode/)to convert the dynamic record into a byte-encoded JSON string.

```
import "experimental/dynamic"

dynamicRecord = dynamic.dynamic(v: {one: 1, two: 2, three: 3})

dynamic.jsonEncode(v: dynamicRecord)

// Returns the following byte-encoded JSON string:
// {"one":1,"three":3,"two":2}

```

#### Encode a dynamic array of different basic types as JSON

Build a dynamic array where each element is a different basic type.
This might be necessary if you’re send JSON data to an API that expects an array
of values where each value is a different type.
Values in a Flux array must be the same type, so you must build a dynamic array
of dynamic types:

1. Import the `experimental/dynamic` package.
2. Use [`dynamic.dynamic()`](/flux/v0/stdlib/experimental/dynamic/dynamic/)  
   to convert the array to a dynamic type.
3. Use `dynamic.dynamic()` to convert all values in the array to dynamic types.
4. Use [`dynamic.jsonEncode()`](/flux/v0/stdlib/experimental/dynamic/jsonencode/)to convert the dynamic array into a byte-encoded JSON string.

```
import "experimental/dynamic"

arr =
    dynamic.dynamic(
        v: [
            dynamic.dynamic(v: "three"),
            dynamic.dynamic(v: 2),
            dynamic.dynamic(v: true)
        ],
    )

dynamic.jsonEncode(v: arr)

// Returns the following byte-encoded JSON string:
// ["three", 2, true]

```

[dynamic types](/flux/v0/tags/dynamic-types/)[data types](/flux/v0/tags/data-types/)
| string | int | float | bool |
| --- | --- | --- | --- |
| string | int | float | bool |
| one | 1 | 1.0 | true |

| name | cals | carbs | fat | protein | sugar |
| --- | --- | --- | --- | --- | --- |
| name | cals | carbs | fat | protein | sugar |
| Apple | 52 | 11.4 | 0.4 | 0.3 | 10.3 |
| Apricot | 15 | 3.9 | 0.1 | 0.5 | 3.2 |
| Avocado | 160 | 8.53 | 14.66 | 2 | 0.66 |
| Banana | 96 | 22 | 0.2 | 1 | 17.2 |
| Blackberry | 40 | 9 | 0.4 | 1.3 | 4.5 |
| Blueberry | 29 | 5.5 | 0.4 | 0 | 5.4 |
| Cherry | 50 | 12 | 0.3 | 1 | 8 |
| Dragonfruit | 60 | 9 | 1.5 | 9 | 8 |
| Durian | 147 | 27.1 | 5.3 | 1.5 | 6.75 |
| Feijoa | 44 | 8 | 0.4 | 0.6 | 3 |
| Fig | 74 | 19 | 0.3 | 0.8 | 16 |
| Gooseberry | 44 | 10 | 0.6 | 0.9 | 0 |
| Grape | 69 | 18.1 | 0.16 | 0.72 | 16 |
| Grapes | 69 | 18.1 | 0.16 | 0.72 | 15.48 |
| GreenApple | 21 | 3.1 | 0.1 | 0.4 | 6.4 |
| Guava | 68 | 14 | 1 | 2.6 | 9 |
| Kiwi | 61 | 15 | 0.5 | 1.1 | 9 |
| Kiwifruit | 61 | 14.6 | 0.5 | 1.14 | 8.9 |
| Lemon | 29 | 9 | 0.3 | 1.1 | 2.5 |
| Lime | 25 | 8.4 | 0.1 | 0.3 | 1.7 |
| Lingonberry | 50 | 11.3 | 0.34 | 0.75 | 5.74 |
| Lychee | 66 | 17 | 0.44 | 0.8 | 15 |
| Mango | 60 | 15 | 0.38 | 0.82 | 13.7 |
| Melon | 34 | 8 | 0 | 0 | 8 |
| Morus | 43 | 9.8 | 0.39 | 1.44 | 8.1 |
| Orange | 43 | 8.3 | 0.2 | 1 | 8.2 |
| Papaya | 43 | 11 | 0.4 | 0 | 1 |
| Passionfruit | 97 | 22.4 | 0.7 | 2.2 | 11.2 |
| Pear | 57 | 15 | 0.1 | 0.4 | 10 |
| Persimmon | 81 | 18 | 0 | 0 | 18 |
| Pineapple | 50 | 13.12 | 0.12 | 0.54 | 9.85 |
| Pitahaya | 36 | 7 | 0.4 | 1 | 3 |
| Plum | 46 | 11.4 | 0.28 | 0.7 | 9.92 |
| Pomegranate | 83 | 18.7 | 1.2 | 1.7 | 13.7 |
| Raspberry | 53 | 12 | 0.7 | 1.2 | 4.4 |
| Strawberry | 29 | 5.5 | 0.4 | 0.8 | 5.4 |
| Tangerine | 45 | 8.3 | 0.4 | 0 | 9.1 |
| Tomato | 74 | 3.9 | 0.2 | 0.9 | 2.6 |
| Watermelon | 30 | 8 | 0.2 | 0.6 | 6 |