> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-fix-nav-issues.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Optional prepared data structure for usage in JOIN operations.

# Join table engine

Optional prepared data structure for usage in [JOIN](/reference/statements/select/join) operations.

<Note>
  In ClickHouse Cloud, if your service was created with a version earlier than 25.4, you will need to set the compatibility to at least 25.4 using  `SET compatibility=25.4`.
</Note>

<h2 id="creating-a-table">
  Creating a table
</h2>

```sql theme={null}
CREATE TABLE [IF NOT EXISTS] [db.]table_name [ON CLUSTER cluster]
(
    name1 [type1] [DEFAULT|MATERIALIZED|ALIAS expr1],
    name2 [type2] [DEFAULT|MATERIALIZED|ALIAS expr2],
) ENGINE = Join(join_strictness, join_type, k1[, k2, ...])
```

See the detailed description of the [CREATE TABLE](/reference/statements/create/table) query.

<h2 id="engine-parameters">
  Engine parameters
</h2>

<h3 id="join_strictness">
  `join_strictness`
</h3>

`join_strictness` – [JOIN strictness](/reference/statements/select/join#supported-types-of-join).

<h3 id="join_type">
  `join_type`
</h3>

`join_type` – [JOIN type](/reference/statements/select/join#supported-types-of-join).

<h3 id="key-columns">
  Key columns
</h3>

`k1[, k2, ...]` – Key columns from the `USING` clause that the `JOIN` operation is made with.

Enter `join_strictness` and `join_type` parameters without quotes, for example, `Join(ANY, LEFT, col1)`. They must match the `JOIN` operation that the table will be used for. If the parameters do not match, ClickHouse does not throw an exception and may return incorrect data.

<h2 id="specifics-and-recommendations">
  Specifics and recommendations
</h2>

<h3 id="data-storage">
  Data storage
</h3>

`Join` table data is always located in the RAM. When inserting rows into a table, ClickHouse writes data blocks to the directory on the disk so that they can be restored when the server restarts.

If the server restarts incorrectly, the data block on the disk might get lost or damaged. In this case, you may need to manually delete the file with damaged data.

<h3 id="selecting-and-inserting-data">
  Selecting and Inserting Data
</h3>

You can use `INSERT` queries to add data to the `Join`-engine tables. If the table was created with the `ANY` strictness, data for duplicate keys are ignored. With the `ALL` strictness, all rows are added.

Main use-cases for `Join`-engine tables are following:

* Place the table to the right side in a `JOIN` clause.
* Call the [joinGet](/reference/functions/regular-functions/other-functions#joinGet) function, which lets you extract data from the table the same way as from a dictionary.

<h3 id="deleting-data">
  Deleting data
</h3>

`ALTER DELETE` queries for `Join`-engine tables are implemented as [mutations](/reference/statements/alter/index#mutations). `DELETE` mutation reads filtered data and overwrites data of memory and disk.

<h3 id="join-limitations-and-settings">
  Limitations and settings
</h3>

When creating a table, the following settings are applied:

<h4 id="join_use_nulls">
  `join_use_nulls`
</h4>

[join\_use\_nulls](/reference/settings/session-settings#join_use_nulls)

<h4 id="max_rows_in_join">
  `max_rows_in_join`
</h4>

[max\_rows\_in\_join](/reference/settings/session-settings#max_rows_in_join)

<h4 id="max_bytes_in_join">
  `max_bytes_in_join`
</h4>

[max\_bytes\_in\_join](/reference/settings/session-settings#max_bytes_in_join)

<h4 id="join_overflow_mode">
  `join_overflow_mode`
</h4>

[join\_overflow\_mode](/reference/settings/session-settings#join_overflow_mode)

<h4 id="join_any_take_last_row">
  `join_any_take_last_row`
</h4>

[join\_any\_take\_last\_row](/reference/settings/session-settings#join_any_take_last_row)

<h4 id="join_use_nulls-1">
  `join_use_nulls`
</h4>

<h4 id="persistent">
  Persistent
</h4>

Disables persistency for the Join and [Set](/reference/engines/table-engines/special/set) table engines.

Reduces the I/O overhead. Suitable for scenarios that pursue performance and do not require persistence.

Possible values:

* 1 — Enabled.
* 0 — Disabled.

Default value: `1`.

The `Join`-engine tables can't be used in `GLOBAL JOIN` operations.

The `Join`-engine allows to specify [join\_use\_nulls](/reference/settings/session-settings#join_use_nulls) setting in the `CREATE TABLE` statement. [SELECT](/reference/statements/select/index) query should have the same `join_use_nulls` value.

<h2 id="example">
  Usage examples
</h2>

Creating the left-side table:

```sql theme={null}
CREATE TABLE id_val(`id` UInt32, `val` UInt32) ENGINE = TinyLog;
```

```sql theme={null}
INSERT INTO id_val VALUES (1,11), (2,12), (3,13);
```

Creating the right-side `Join` table:

```sql theme={null}
CREATE TABLE id_val_join(`id` UInt32, `val` UInt8) ENGINE = Join(ANY, LEFT, id);
```

```sql theme={null}
INSERT INTO id_val_join VALUES (1,21), (1,22), (3,23);
```

Joining the tables:

```sql theme={null}
SELECT * FROM id_val ANY LEFT JOIN id_val_join USING (id);
```

```text theme={null}
┌─id─┬─val─┬─id_val_join.val─┐
│  1 │  11 │              21 │
│  2 │  12 │               0 │
│  3 │  13 │              23 │
└────┴─────┴─────────────────┘
```

As an alternative, you can retrieve data from the `Join` table, specifying the join key value:

```sql theme={null}
SELECT joinGet('id_val_join', 'val', toUInt32(1));
```

```text theme={null}
┌─joinGet('id_val_join', 'val', toUInt32(1))─┐
│                                         21 │
└────────────────────────────────────────────┘
```

Deleting a row from the `Join` table:

```sql theme={null}
ALTER TABLE id_val_join DELETE WHERE id = 3;
```

```text theme={null}
┌─id─┬─val─┐
│  1 │  21 │
└────┴─────┘
```