# Work with unsigned integers

An unsigned integer (uinteger) type represents a unsigned 64-bit integer.

Type name: `uint`
Min value: `0`
Max value: `18446744073709551615`

## UInteger syntax

Flux does not provide a uinteger literal syntax. However, you can use `uint()` to convert basic data types into a uinteger.

``````uint(v: 123)
// Returns 123 (uint)
``````

## Convert data types to uintegers

Use the `uint()` function to convert the following basic types to uintegers:

• string: returns the uinteger equivalent of the numeric string (`[0-9]`)
• bool: returns `1` for `true` or `0` for `false`
• duration: returns the number of nanoseconds in the duration
• time: returns the equivalent nanosecond epoch timestamp
• float: truncates the float value at the decimal and returns the uinteger equivalent
• int: returns the uinteger equivalent of the integer
``````uint(v: "123")
// 123

uint(v: true)
// Returns 1

uint(v: 1d3h24m)
// Returns 98640000000000

uint(v: 2021-01-01T00:00:00Z)
// Returns 1609459200000000000

uint(v: 12.54)
// Returns 12

uint(v: -54321)
// Returns 18446744073709497295
``````

#### Round float values before converting to uintegers

When converting floats to integers, `uint()` truncates the float value at the decimal (for example `12.54` to `12`). You may want to round float values to the nearest whole number (`12.54` to `13`) before converting. To do this:

1. Import the `math` package.
2. Use `math.round()` to round the float value before converting it to a uinteger.
``````import "math"

uint(v: math.round(x: 12.54))
// Returns 13
``````

### Convert a hexadecimal string to a uinteger

To convert a hexadecimal string representation of a number to a uinteger:

1. Import the `contrib/bonitoo-io/hex` package.
2. Use `hex.uint()` to convert the hexadecimal string to a uinteger.
``````import "contrib/bonitoo-io/hex"

hex.uint(v: "-1e240")
// Returns 123456
``````

### Convert columns to uintegers

Flux lets you iterate over rows in a stream of tables and convert columns to uintegers.

To convert the `_value` column to uintegers, use the `toUInt()` function.

`toUInt()` only operates on the `_value` column.

``````data
|> toUInt()
``````
##### Given the following input data:
_time_value (float)
2021-01-01T00:00:00Z1.23
2021-01-01T02:00:00Z4.56
2021-01-01T03:00:00Z-7.89
2021-01-01T04:00:00Z10.11
##### The example above returns:
_time_value (uint)
2021-01-01T00:00:00Z1
2021-01-01T02:00:00Z4
2021-01-01T03:00:00Z18446744073709551609
2021-01-01T04:00:00Z10

To convert any column to uintegers:

1. Use `map()` to iterate over and rewrite rows.
2. Use `uint()` to convert columns values to uintegers.
``````data
|> map(fn: (r) => ({ r with uid: uint(v: r.uid) }))
``````
##### Given the following input data:
_timeindex (string)
2021-01-01T00:00:00Z100010024
2021-01-01T02:00:00Z100050213
2021-01-01T03:00:00Z200130763
2021-01-01T04:00:00Z101420099
##### The example above returns:
_timeindex (uint)
2021-01-01T00:00:00Z100010024
2021-01-01T02:00:00Z100050213
2021-01-01T03:00:00Z200130763
2021-01-01T04:00:00Z101420099

## Operate on uintegers

### Perform arithmetic operations on uintegers

To perform operations like adding, subtracting, multiplying, or dividing uintegers, use Flux arithmetic operators. Operands must be the same type. The operation returns an uinteger.

When operating with uinteger operands, fractional results are truncated at the decimal.

``````uint(v: 1) + uint(v: 45)
// Returns 46

uint(v: 1) - uint(v: 45)
// Returns 18446744073709551572

uint(v: 12) * uint(v: 100)
// Returns 1200

uint(v: 100) / uint(v: 200)
// Returns 0

uint(v: 10) ^ uint(v: 2)
// Returns 100
``````

### Perform bitwise operations on uintegers

Use the `experimental/bitwise` package to perform bitwise operations on uintegers.

``````import "experimental/bitwise"

bitwise.uand(a: uint(v: 12), b: uint(v: 21))
// Returns 4

bitwise.uor(a: uint(v: 12), b: uint(v: 21))
// Returns 29

bitwise.uxor(a: uint(v: 12), b: uint(v: 21))
// Returns 25

bitwise.uclear(a: uint(v: 12), b: uint(v: 21))
// Returns 8

bitwise.unot(a: uint(v: 12))
// Returns 18446744073709551603

bitwise.ulshift(a: uint(v: 12), b: uint(v: 21))
// Returns 25165824

bitwise.urshift(a: uint(v: 21), b: uint(v: 4))
// Returns 1
``````

### Compare uintegers

Use Flux comparison operators to compare uintegers. Operands must be the same type. The operation returns a boolean.

``````uint(v: 12345600) == uint(v: 12345601)
// Returns false

uint(v: 2) > uint(v: -2)
// Returns false
``````

### The future of Flux

Flux is going into maintenance mode. You can continue using it as you currently are without any changes to your code.

### InfluxDB v3 enhancements and InfluxDB Clustered is now generally available

New capabilities, including faster query performance and management tooling advance the InfluxDB v3 product line. InfluxDB Clustered is now generally available.

### InfluxDB v3 performance and features

The InfluxDB v3 product line has seen significant enhancements in query performance and has made new management tooling available. These enhancements include an operational dashboard to monitor the health of your InfluxDB cluster, single sign-on (SSO) support in InfluxDB Cloud Dedicated, and new management APIs for tokens and databases.

Learn about the new v3 enhancements

### InfluxDB Clustered general availability

InfluxDB Clustered is now generally available and gives you the power of InfluxDB v3 in your self-managed stack.

Talk to us about InfluxDB Clustered