---
title: UNKNOWN_TYPE ClickHouse® error
meta:
  description: Learn how to fix the UNKNOWN_TYPE error in ClickHouse and Tinybird. Understand what causes it and see examples of how to resolve it
---

# UNKNOWN_TYPE ClickHouse® error

{% callout %}
This error usually means you're trying to use a data type that doesn't exist in ClickHouse®. Check the type name spelling and verify it's available in your ClickHouse® version.
{% /callout %}

The `UNKNOWN_TYPE` error in ClickHouse® (and Tinybird) happens when you try to use a data type that doesn't exist in ClickHouse® or isn't available in your version. This commonly occurs when using types from other database systems or trying to use newer ClickHouse® types in older versions.

## What causes this error

You typically see it when:

* Using data types from other database systems (MySQL, PostgreSQL, etc.)
* Misspelling ClickHouse® type names
* Using types available in newer ClickHouse® versions
* Using custom types that haven't been defined
* Using deprecated or removed types

## Example errors

```sql {% title="Fails: MySQL type in ClickHouse" %}
CREATE TABLE events (id INT, name VARCHAR(255))
```

```sql {% title="Fails: misspelled type" %}
CREATE TABLE events (id UInt32, name Strng)
```

```sql {% title="Fails: non-existent type" %}
CREATE TABLE events (id UInt32, data JSONB)
```

```sql {% title="Fails: wrong case" %}
CREATE TABLE events (id uint32, name String)
```

{% callout type="caution" %}
ClickHouse® types are capitalized exactly: `UInt32`, `String`, `Float64`. There is no `BOOLEAN` type; use `UInt8` or `Bool` in newer versions.
{% /callout %}

## How to fix it

### Use ClickHouse® data types

Replace with equivalent ClickHouse® types:

```sql {% title="Fix: use ClickHouse types" %}
CREATE TABLE events (id UInt32, name String)
```

### Check type spelling

Verify the correct type name:

```sql {% title="Fix: correct spelling" %}
CREATE TABLE events (id UInt32, name String)
```

### Use proper case

ClickHouse® types are case-sensitive:

```sql {% title="Fix: correct case" %}
CREATE TABLE events (id UInt32, name String)
```

### Check type availability

Verify the type exists in your ClickHouse® version:

```sql {% title="Check ClickHouse version" %}
SELECT version()
```

## Common patterns and solutions

### Basic data types

Common ClickHouse® data types:

```sql {% title="Basic types" %}
CREATE TABLE events (
    id UInt32,
    name String,
    value Float64,
    active UInt8,
    timestamp DateTime
)
```

### Integer types

ClickHouse® integer types:

```sql {% title="Integer types" %}
CREATE TABLE events (
    tiny_id UInt8,
    small_id UInt16,
    normal_id UInt32,
    big_id UInt64,
    signed_id Int32
)
```

### String types

ClickHouse® string types:

```sql {% title="String types" %}
CREATE TABLE events (
    name String,
    fixed_name FixedString(10),
    uuid UUID
)
```

### Complex types

ClickHouse® complex types:

```sql {% title="Complex types" %}
CREATE TABLE events (
    id UInt32,
    tags Array(String),
    metadata Map(String, String),
    nullable_name Nullable(String),
    decimal_value Decimal(10, 2)
)
```

{% callout type="tip" %}
Use `Nullable(Type)` wrapper for nullability and `Array(Type)` for arrays. Decimal types require scale and precision.
{% /callout %}

### Date and time types

ClickHouse® date/time types:

```sql {% title="Date/time types" %}
CREATE TABLE events (
    date_col Date,
    datetime_col DateTime,
    timestamp_col DateTime64(3)
)
```

## Type mapping from other databases

### MySQL to ClickHouse®

| MySQL | ClickHouse® | Description |
|-------|------------|-------------|
| `INT` | `Int32` | 32-bit integer |
| `VARCHAR(255)` | `String` | Variable-length string |
| `TEXT` | `String` | Long text |
| `DATETIME` | `DateTime` | Date and time |
| `BOOLEAN` | `UInt8` | Boolean (0/1) |

### PostgreSQL to ClickHouse®

| PostgreSQL | ClickHouse® | Description |
|------------|------------|-------------|
| `INTEGER` | `Int32` | 32-bit integer |
| `VARCHAR` | `String` | Variable-length string |
| `TEXT` | `String` | Long text |
| `TIMESTAMP` | `DateTime` | Date and time |
| `JSONB` | `String` | JSON (as string) |

## Advanced solutions

### Using complex types

ClickHouse® complex types:

```sql {% title="Complex types" %}
CREATE TABLE events (
    id UInt32,
    tags Array(String),
    metadata Map(String, String),
    coordinates Tuple(Float64, Float64)
)
```

### Using Nullable types

For columns that can be NULL:

```sql {% title="Nullable types" %}
CREATE TABLE events (
    id UInt32,
    name Nullable(String),
    value Nullable(Float64)
)
```

### Using LowCardinality for optimization

For columns with repeated values:

```sql {% title="LowCardinality types" %}
CREATE TABLE events (
    id UInt32,
    event_type LowCardinality(String),
    user_id UInt32
)
```

## Tinybird-specific notes

In Tinybird, this error often occurs when:

* Using Data Sources with unsupported types
* Creating Pipes with incompatible type definitions
* Using Materialized Views with wrong types
* Working with imported schemas from other databases

To debug in Tinybird:

1. Check Tinybird's supported ClickHouse® types
2. Use the Data Source schema editor to verify types
3. Test type definitions in the Query Builder
4. Use Schema Hints to enforce proper types

## Best practices

### Type selection

* Use appropriate types for your data
* Consider storage and performance implications
* Use Nullable types when needed
* Use LowCardinality for repeated string values

### Type validation

* Test type definitions with sample data
* Verify type compatibility across operations
* Use type conversion functions when needed
* Document type choices and reasons

### Performance considerations

* Use smallest appropriate integer types
* Consider using LowCardinality for string columns
* Use appropriate precision for decimal types
* Index columns with appropriate types

## See also

* [ClickHouse® Data Types](/sql-reference/data-types)
* [Working with Data Sources](/forward/core-concepts/data-sources)
* [Common function errors](/sql-reference/clickhouse-errors/ILLEGAL_TYPE_OF_ARGUMENT)