> ## 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.

> Documentation for Show

# SHOW Statements

<Note>
  `SHOW CREATE (TABLE|DATABASE|USER)` hides secrets unless the following settings are turned on:

  * [`display_secrets_in_show_and_select`](/reference/settings/server-settings/settings#display_secrets_in_show_and_select) (server setting)
  * [`format_display_secrets_in_show_and_select` ](/reference/settings/formats#format_display_secrets_in_show_and_select) (format setting)

  Additionally, the user should have the [`displaySecretsInShowAndSelect`](/reference/statements/grant#displaysecretsinshowandselect) privilege.
</Note>

<h2 id="show-create-table--dictionary--view--database">
  SHOW CREATE TABLE | DICTIONARY | VIEW | DATABASE
</h2>

These statements return a single column of type String,
containing the `CREATE` query used for creating the specified object.

<h3 id="syntax">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW [CREATE] TABLE | TEMPORARY TABLE | DICTIONARY | VIEW | DATABASE [db.]table|view [INTO OUTFILE filename] [FORMAT format]
```

<Note>
  If you use this statement to get the `CREATE` query of system tables,
  you will get a *fake* query, which only declares the table structure,
  but cannot be used to create a table.
</Note>

<h2 id="show-databases">
  SHOW DATABASES
</h2>

This statement prints a list of all databases.

<h3 id="syntax-1">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW DATABASES [[NOT] LIKE | ILIKE '<pattern>'] [LIMIT <N>] [INTO OUTFILE filename] [FORMAT format]
```

It is identical to the query:

```sql theme={null}
SELECT name FROM system.databases [WHERE name [NOT] LIKE | ILIKE '<pattern>'] [LIMIT <N>] [INTO OUTFILE filename] [FORMAT format]
```

<h3 id="examples">
  Examples
</h3>

In this example we use `SHOW` to obtain database names containing the symbol sequence 'de' in their names:

```sql title="Query" theme={null}
SHOW DATABASES LIKE '%de%'
```

```text title="Response" theme={null}
┌─name────┐
│ default │
└─────────┘
```

We can also do so in a case-insensitive manner:

```sql title="Query" theme={null}
SHOW DATABASES ILIKE '%DE%'
```

```text title="Response" theme={null}
┌─name────┐
│ default │
└─────────┘
```

Or get database names which do not contain 'de' in their names:

```sql title="Query" theme={null}
SHOW DATABASES NOT LIKE '%de%'
```

```text title="Response" theme={null}
┌─name───────────────────────────┐
│ _temporary_and_external_tables │
│ system                         │
│ test                           │
│ tutorial                       │
└────────────────────────────────┘
```

Finally, we can get the names of only the first two databases:

```sql title="Query" theme={null}
SHOW DATABASES LIMIT 2
```

```text title="Response" theme={null}
┌─name───────────────────────────┐
│ _temporary_and_external_tables │
│ default                        │
└────────────────────────────────┘
```

<h3 id="see-also">
  See also
</h3>

* [`CREATE DATABASE`](/reference/statements/create/database)

<h2 id="show-tables">
  SHOW TABLES
</h2>

The `SHOW TABLES` statement displays a list of tables.

<h3 id="syntax-2">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW [FULL] [TEMPORARY] TABLES [{FROM | IN} <db>] [[NOT] LIKE | ILIKE '<pattern>'] [LIMIT <N>] [INTO OUTFILE <filename>] [FORMAT <format>]
```

If the `FROM` clause is not specified, the query returns a list of tables from the current database.

This statement is identical to the query:

```sql theme={null}
SELECT name FROM system.tables [WHERE name [NOT] LIKE | ILIKE '<pattern>'] [LIMIT <N>] [INTO OUTFILE <filename>] [FORMAT <format>]
```

<h3 id="examples-1">
  Examples
</h3>

In this example we use the `SHOW TABLES` statement to find all tables containing 'user' in their names:

```sql title="Query" theme={null}
SHOW TABLES FROM system LIKE '%user%'
```

```text title="Response" theme={null}
┌─name─────────────┐
│ user_directories │
│ users            │
└──────────────────┘
```

We can also do so in a case-insensitive manner:

```sql title="Query" theme={null}
SHOW TABLES FROM system ILIKE '%USER%'
```

```text title="Response" theme={null}
┌─name─────────────┐
│ user_directories │
│ users            │
└──────────────────┘
```

Or to find tables which don't contain the letter 's' in their names:

```sql title="Query" theme={null}
SHOW TABLES FROM system NOT LIKE '%s%'
```

```text title="Response" theme={null}
┌─name─────────┐
│ metric_log   │
│ metric_log_0 │
│ metric_log_1 │
└──────────────┘
```

Finally, we can get the names of only the first two tables:

```sql title="Query" theme={null}
SHOW TABLES FROM system LIMIT 2
```

```text title="Response" theme={null}
┌─name───────────────────────────┐
│ aggregate_function_combinators │
│ asynchronous_metric_log        │
└────────────────────────────────┘
```

<h3 id="see-also-1">
  See also
</h3>

* [`Create Tables`](/reference/statements/create/table)
* [`SHOW CREATE TABLE`](#show-create-table--dictionary--view--database)

<h2 id="show_columns">
  SHOW COLUMNS
</h2>

The `SHOW COLUMNS` statement displays a list of columns.

<h3 id="syntax-3">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW [EXTENDED] [FULL] COLUMNS {FROM | IN} <table> [{FROM | IN} <db>] [{[NOT] {LIKE | ILIKE} '<pattern>' | WHERE <expr>}] [LIMIT <N>] [INTO
OUTFILE <filename>] [FORMAT <format>]
```

The database and table name can be specified in abbreviated form as `<db>.<table>`,
meaning that `FROM tab FROM db` and `FROM db.tab` are equivalent.
If no database is specified, the query returns the list of columns from the current database.

There are also two optional keywords: `EXTENDED` and `FULL`. The `EXTENDED` keyword currently has no effect,
and exists for MySQL compatibility. The `FULL` keyword causes the output to include the collation, comment and privilege columns.

The `SHOW COLUMNS` statement produces a result table with the following structure:

| Column      | Description                                                                                                                   | Type               |
| ----------- | ----------------------------------------------------------------------------------------------------------------------------- | ------------------ |
| `field`     | The name of the column                                                                                                        | `String`           |
| `type`      | The column data type. If the query was made through the MySQL wire protocol, then the equivalent type name in MySQL is shown. | `String`           |
| `null`      | `YES` if the column data type is Nullable, `NO` otherwise                                                                     | `String`           |
| `key`       | `PRI` if the column is part of the primary key, `SOR` if the column is part of the sorting key, empty otherwise               | `String`           |
| `default`   | Default expression of the column if it is of type `ALIAS`, `DEFAULT`, or `MATERIALIZED`, otherwise `NULL`.                    | `Nullable(String)` |
| `extra`     | Additional information, currently unused                                                                                      | `String`           |
| `collation` | (only if `FULL` keyword was specified) Collation of the column, always `NULL` because ClickHouse has no per-column collations | `Nullable(String)` |
| `comment`   | (only if `FULL` keyword was specified) Comment on the column                                                                  | `String`           |
| `privilege` | (only if `FULL` keyword was specified) The privilege you have on this column, currently not available                         | `String`           |

<h3 id="examples-2">
  Examples
</h3>

In this example we'll use the `SHOW COLUMNS` statement to get information about all columns in table 'orders',
starting from 'delivery\_':

```sql title="Query" theme={null}
SHOW COLUMNS FROM 'orders' LIKE 'delivery_%'
```

```text title="Response" theme={null}
┌─field───────────┬─type─────┬─null─┬─key─────┬─default─┬─extra─┐
│ delivery_date   │ DateTime │    0 │ PRI SOR │ ᴺᵁᴸᴸ    │       │
│ delivery_status │ Bool     │    0 │         │ ᴺᵁᴸᴸ    │       │
└─────────────────┴──────────┴──────┴─────────┴─────────┴───────┘
```

<h3 id="see-also-2">
  See also
</h3>

* [`system.columns`](/reference/system-tables/columns)

<h2 id="show-dictionaries">
  SHOW DICTIONARIES
</h2>

The `SHOW DICTIONARIES` statement displays a list of [Dictionaries](/reference/statements/create/dictionary).

<h3 id="syntax-4">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW DICTIONARIES [FROM <db>] [LIKE '<pattern>'] [LIMIT <N>] [INTO OUTFILE <filename>] [FORMAT <format>]
```

If the `FROM` clause is not specified, the query returns the list of dictionaries from the current database.

You can get the same results as the `SHOW DICTIONARIES` query in the following way:

```sql theme={null}
SELECT name FROM system.dictionaries WHERE database = <db> [AND name LIKE <pattern>] [LIMIT <N>] [INTO OUTFILE <filename>] [FORMAT <format>]
```

<h3 id="examples-3">
  Examples
</h3>

The following query selects the first two rows from the list of tables in the `system` database, whose names contain `reg`.

```sql title="Query" theme={null}
SHOW DICTIONARIES FROM db LIKE '%reg%' LIMIT 2
```

```text title="Response" theme={null}
┌─name─────────┐
│ regions      │
│ region_names │
└──────────────┘
```

<h2 id="show-index">
  SHOW INDEX
</h2>

Displays a list of primary and data skipping indexes of a table.

This statement mostly exists for compatibility with MySQL. System tables [`system.tables`](/reference/system-tables/tables) (for
primary keys) and [`system.data_skipping_indices`](/reference/system-tables/data_skipping_indices) (for data skipping indices)
provide equivalent information but in a fashion more native to ClickHouse.

<h3 id="syntax-5">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW [EXTENDED] {INDEX | INDEXES | INDICES | KEYS } {FROM | IN} <table> [{FROM | IN} <db>] [WHERE <expr>] [INTO OUTFILE <filename>] [FORMAT <format>]
```

The database and table name can be specified in abbreviated form as `<db>.<table>`, i.e. `FROM tab FROM db` and `FROM db.tab` are
equivalent. If no database is specified, the query assumes the current database as database.

The optional keyword `EXTENDED` currently has no effect, and exists for MySQL compatibility.

The statement produces a result table with the following structure:

| Column          | Description                                                                                                              | Type               |
| --------------- | ------------------------------------------------------------------------------------------------------------------------ | ------------------ |
| `table`         | The name of the table.                                                                                                   | `String`           |
| `non_unique`    | Always `1` as ClickHouse does not support uniqueness constraints.                                                        | `UInt8`            |
| `key_name`      | The name of the index, `PRIMARY` if the index is a primary key index.                                                    | `String`           |
| `seq_in_index`  | For a primary key index, the position of the column starting from `1`. For a data skipping index: always `1`.            | `UInt8`            |
| `column_name`   | For a primary key index, the name of the column. For a data skipping index: `''` (empty string), see field "expression". | `String`           |
| `collation`     | The sorting of the column in the index: `A` if ascending, `D` if descending, `NULL` if unsorted.                         | `Nullable(String)` |
| `cardinality`   | An estimation of the index cardinality (number of unique values in the index). Currently always 0.                       | `UInt64`           |
| `sub_part`      | Always `NULL` because ClickHouse does not support index prefixes like MySQL.                                             | `Nullable(String)` |
| `packed`        | Always `NULL` because ClickHouse does not support packed indexes (like MySQL).                                           | `Nullable(String)` |
| `null`          | Currently unused                                                                                                         |                    |
| `index_type`    | The index type, e.g. `PRIMARY`, `MINMAX`, `BLOOM_FILTER` etc.                                                            | `String`           |
| `comment`       | Additional information about the index, currently always `''` (empty string).                                            | `String`           |
| `index_comment` | `''` (empty string) because indexes in ClickHouse cannot have a `COMMENT` field (like in MySQL).                         | `String`           |
| `visible`       | If the index is visible to the optimizer, always `YES`.                                                                  | `String`           |
| `expression`    | For a data skipping index, the index expression. For a primary key index: `''` (empty string).                           | `String`           |

<h3 id="examples-4">
  Examples
</h3>

In this example we use the `SHOW INDEX` statement to get information about all indexes in table 'tbl'

```sql title="Query" theme={null}
SHOW INDEX FROM 'tbl'
```

```text title="Response" theme={null}
┌─table─┬─non_unique─┬─key_name─┬─seq_in_index─┬─column_name─┬─collation─┬─cardinality─┬─sub_part─┬─packed─┬─null─┬─index_type───┬─comment─┬─index_comment─┬─visible─┬─expression─┐
│ tbl   │          1 │ blf_idx  │ 1            │ 1           │ ᴺᵁᴸᴸ      │ 0           │ ᴺᵁᴸᴸ     │ ᴺᵁᴸᴸ   │ ᴺᵁᴸᴸ │ BLOOM_FILTER │         │               │ YES     │ d, b       │
│ tbl   │          1 │ mm1_idx  │ 1            │ 1           │ ᴺᵁᴸᴸ      │ 0           │ ᴺᵁᴸᴸ     │ ᴺᵁᴸᴸ   │ ᴺᵁᴸᴸ │ MINMAX       │         │               │ YES     │ a, c, d    │
│ tbl   │          1 │ mm2_idx  │ 1            │ 1           │ ᴺᵁᴸᴸ      │ 0           │ ᴺᵁᴸᴸ     │ ᴺᵁᴸᴸ   │ ᴺᵁᴸᴸ │ MINMAX       │         │               │ YES     │ c, d, e    │
│ tbl   │          1 │ PRIMARY  │ 1            │ c           │ A         │ 0           │ ᴺᵁᴸᴸ     │ ᴺᵁᴸᴸ   │ ᴺᵁᴸᴸ │ PRIMARY      │         │               │ YES     │            │
│ tbl   │          1 │ PRIMARY  │ 2            │ a           │ A         │ 0           │ ᴺᵁᴸᴸ     │ ᴺᵁᴸᴸ   │ ᴺᵁᴸᴸ │ PRIMARY      │         │               │ YES     │            │
│ tbl   │          1 │ set_idx  │ 1            │ 1           │ ᴺᵁᴸᴸ      │ 0           │ ᴺᵁᴸᴸ     │ ᴺᵁᴸᴸ   │ ᴺᵁᴸᴸ │ SET          │         │               │ YES     │ e          │
└───────┴────────────┴──────────┴──────────────┴─────────────┴───────────┴─────────────┴──────────┴────────┴──────┴──────────────┴─────────┴───────────────┴─────────┴────────────┘
```

<h3 id="see-also-3">
  See also
</h3>

* [`system.tables`](/reference/system-tables/tables)
* [`system.data_skipping_indices`](/reference/system-tables/data_skipping_indices)

<h2 id="show-processlist">
  SHOW PROCESSLIST
</h2>

Outputs the content of the [`system.processes`](/reference/system-tables/processes) table, that contains a list of queries that are being processed at the moment, excluding `SHOW PROCESSLIST` queries.

<h3 id="syntax-6">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW PROCESSLIST [INTO OUTFILE filename] [FORMAT format]
```

The `SELECT * FROM system.processes` query returns data about all the current queries.

<Tip>
  Execute in the console:

  ```bash theme={null}
  $ watch -n1 "clickhouse-client --query='SHOW PROCESSLIST'"
  ```
</Tip>

<h2 id="show-grants">
  SHOW GRANTS
</h2>

The `SHOW GRANTS` statement shows privileges for a user.

<h3 id="syntax-7">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW GRANTS [FOR user1 [, user2 ...]] [WITH IMPLICIT] [FINAL]
```

If the user is not specified, the query returns privileges for the current user.

The `WITH IMPLICIT` modifier allows showing the implicit grants (e.g., `GRANT SELECT ON system.one`)

The `FINAL` modifier merges all grants from the user and its granted roles (with inheritance)

<h2 id="show-create-user">
  SHOW CREATE USER
</h2>

The `SHOW CREATE USER` statement shows parameters which were used at [user creation](/reference/statements/create/user).

<h3 id="syntax-8">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW CREATE USER [name1 [, name2 ...] | CURRENT_USER]
```

<h2 id="show-create-role">
  SHOW CREATE ROLE
</h2>

The `SHOW CREATE ROLE` statement shows parameters which were used at [role creation](/reference/statements/create/role).

<h3 id="syntax-9">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW CREATE ROLE name1 [, name2 ...]
```

<h2 id="show-create-row-policy">
  SHOW CREATE ROW POLICY
</h2>

The `SHOW CREATE ROW POLICY` statement shows parameters which were used at [row policy creation](/reference/statements/create/row-policy).

<h3 id="syntax-10">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW CREATE [ROW] POLICY name ON [database1.]table1 [, [database2.]table2 ...]
```

<h2 id="show-create-quota">
  SHOW CREATE QUOTA
</h2>

The `SHOW CREATE QUOTA` statement shows parameters which were used at [quota creation](/reference/statements/create/quota).

<h3 id="syntax-11">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW CREATE QUOTA [name1 [, name2 ...] | CURRENT]
```

<h2 id="show-create-settings-profile">
  SHOW CREATE SETTINGS PROFILE
</h2>

The `SHOW CREATE SETTINGS PROFILE` statement shows parameters which were used at [settings profile creation](/reference/statements/create/settings-profile).

<h3 id="syntax-12">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW CREATE [SETTINGS] PROFILE name1 [, name2 ...]
```

<h2 id="show-users">
  SHOW USERS
</h2>

The `SHOW USERS` statement returns a list of [user account](/concepts/features/security/access-rights#user-account-management) names.
To view user accounts parameters, see the system table [`system.users`](/reference/system-tables/users).

<h3 id="syntax-13">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW USERS
```

<h2 id="show-roles">
  SHOW ROLES
</h2>

The `SHOW ROLES` statement returns a list of [roles](/concepts/features/security/access-rights#role-management).
To view other parameters,
see system tables [`system.roles`](/reference/system-tables/roles) and [`system.role_grants`](/reference/system-tables/role_grants).

<h3 id="syntax-14">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW [CURRENT|ENABLED] ROLES
```

<h2 id="show-profiles">
  SHOW PROFILES
</h2>

The `SHOW PROFILES` statement returns a list of [setting profiles](/concepts/features/security/access-rights#settings-profiles-management).
To view user accounts parameters, see system table [`settings_profiles`](/reference/system-tables/settings_profiles).

<h3 id="syntax-15">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW [SETTINGS] PROFILES
```

<h2 id="show-policies">
  SHOW POLICIES
</h2>

The `SHOW POLICIES` statement returns a list of [row policies](/concepts/features/security/access-rights#row-policy-management) for the specified table.
To view user accounts parameters, see system table [`system.row_policies`](/reference/system-tables/row_policies).

<h3 id="syntax-16">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW [ROW] POLICIES [ON [db.]table]
```

<h2 id="show-quotas">
  SHOW QUOTAS
</h2>

The `SHOW QUOTAS` statement returns a list of [quotas](/concepts/features/security/access-rights#quotas-management).
To view quotas parameters, see the system table [`system.quotas`](/reference/system-tables/quotas).

<h3 id="syntax-17">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW QUOTAS
```

<h2 id="show-quota">
  SHOW QUOTA
</h2>

The `SHOW QUOTA` statement returns a [quota](/concepts/features/configuration/server-config/quotas) consumption for all users or for current user.
To view other parameters, see system tables [`system.quotas_usage`](/reference/system-tables/quotas_usage) and [`system.quota_usage`](/reference/system-tables/quota_usage).

<h3 id="syntax-18">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW [CURRENT] QUOTA
```

<h2 id="show-access">
  SHOW ACCESS
</h2>

The `SHOW ACCESS` statement shows all [users](/concepts/features/security/access-rights#user-account-management), [roles](/concepts/features/security/access-rights#role-management), [profiles](/concepts/features/security/access-rights#settings-profiles-management), etc. and all their [grants](/reference/statements/grant#privileges).

<h3 id="syntax-19">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW ACCESS
```

<h2 id="show-clusters">
  SHOW CLUSTER(S)
</h2>

The `SHOW CLUSTER(S)` statement returns a list of clusters.
All available clusters are listed in the [`system.clusters`](/reference/system-tables/clusters) table.

<Note>
  The `SHOW CLUSTER name` query displays `cluster`, `shard_num`, `replica_num`, `host_name`, `host_address`, and `port` of the `system.clusters` table for the specified cluster name.
</Note>

<h3 id="syntax-20">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW CLUSTER '<name>'
SHOW CLUSTERS [[NOT] LIKE|ILIKE '<pattern>'] [LIMIT <N>]
```

<h3 id="examples-5">
  Examples
</h3>

```sql title="Query" theme={null}
SHOW CLUSTERS;
```

```text title="Response" theme={null}
┌─cluster──────────────────────────────────────┐
│ test_cluster_two_shards                      │
│ test_cluster_two_shards_internal_replication │
│ test_cluster_two_shards_localhost            │
│ test_shard_localhost                         │
│ test_shard_localhost_secure                  │
│ test_unavailable_shard                       │
└──────────────────────────────────────────────┘
```

```sql title="Query" theme={null}
SHOW CLUSTERS LIKE 'test%' LIMIT 1;
```

```text title="Response" theme={null}
┌─cluster─────────────────┐
│ test_cluster_two_shards │
└─────────────────────────┘
```

```sql title="Query" theme={null}
SHOW CLUSTER 'test_shard_localhost' FORMAT Vertical;
```

```text title="Response" theme={null}
Row 1:
──────
cluster:                 test_shard_localhost
shard_num:               1
replica_num:             1
host_name:               localhost
host_address:            127.0.0.1
port:                    9000
```

<h2 id="show-settings">
  SHOW SETTINGS
</h2>

The `SHOW SETTINGS` statement returns a list of system settings and their values.
It selects data from the [`system.settings`](/reference/system-tables/settings) table.

<h3 id="syntax-21">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW [CHANGED] SETTINGS LIKE|ILIKE <name>
```

<h3 id="clauses">
  Clauses
</h3>

`LIKE|ILIKE` allow to specify a matching pattern for the setting name. It can contain globs such as `%` or `_`. `LIKE` clause is case-sensitive, `ILIKE` — case insensitive.

When the `CHANGED` clause is used, the query returns only settings changed from their default values.

<h3 id="examples-6">
  Examples
</h3>

Query with the `LIKE` clause:

```sql title="Query" theme={null}
SHOW SETTINGS LIKE 'send_timeout';
```

```text title="Response" theme={null}
┌─name─────────┬─type────┬─value─┐
│ send_timeout │ Seconds │ 300   │
└──────────────┴─────────┴───────┘
```

Query with the `ILIKE` clause:

```sql title="Query" theme={null}
SHOW SETTINGS ILIKE '%CONNECT_timeout%'
```

```text title="Response" theme={null}
┌─name────────────────────────────────────┬─type─────────┬─value─┐
│ connect_timeout                         │ Seconds      │ 10    │
│ connect_timeout_with_failover_ms        │ Milliseconds │ 50    │
│ connect_timeout_with_failover_secure_ms │ Milliseconds │ 100   │
└─────────────────────────────────────────┴──────────────┴───────┘
```

Query with the `CHANGED` clause:

```sql title="Query" theme={null}
SHOW CHANGED SETTINGS ILIKE '%MEMORY%'
```

```text title="Response" theme={null}
┌─name─────────────┬─type───┬─value───────┐
│ max_memory_usage │ UInt64 │ 10000000000 │
└──────────────────┴────────┴─────────────┘
```

<h2 id="show-setting">
  SHOW SETTING
</h2>

The `SHOW SETTING` statement outputs setting value for specified setting name.

<h3 id="syntax-22">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW SETTING <name>
```

<h3 id="see-also-4">
  See also
</h3>

* [`system.settings`](/reference/system-tables/settings) table

<h2 id="show-filesystem-caches">
  SHOW FILESYSTEM CACHES
</h2>

<h3 id="examples-7">
  Examples
</h3>

```sql title="Query" theme={null}
SHOW FILESYSTEM CACHES
```

```text title="Response" theme={null}
┌─Caches────┐
│ s3_cache  │
└───────────┘
```

<h3 id="see-also-5">
  See also
</h3>

* [`system.settings`](/reference/system-tables/settings) table

<h2 id="show-engines">
  SHOW ENGINES
</h2>

The `SHOW ENGINES` statement outputs the content of the [`system.table_engines`](/reference/system-tables/table_engines) table,
that contains description of table engines supported by server and their feature support information.

<h3 id="syntax-23">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW ENGINES [INTO OUTFILE filename] [FORMAT format]
```

<h3 id="see-also-6">
  See also
</h3>

* [system.table\_engines](/reference/system-tables/table_engines) table

<h2 id="show-functions">
  SHOW FUNCTIONS
</h2>

The `SHOW FUNCTIONS` statement outputs the content of the [`system.functions`](/reference/system-tables/functions) table.

<h3 id="syntax-24">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW FUNCTIONS [LIKE | ILIKE '<pattern>']
```

If either `LIKE` or `ILIKE` clause is specified, the query returns a list of system functions whose names match the provided `<pattern>`.

<h3 id="see-also-7">
  See Also
</h3>

* [`system.functions`](/reference/system-tables/functions) table

<h2 id="show-merges">
  SHOW MERGES
</h2>

The `SHOW MERGES` statement returns a list of merges.
All merges are listed in the [`system.merges`](/reference/system-tables/merges) table:

| Column              | Description                                                |
| ------------------- | ---------------------------------------------------------- |
| `table`             | Table name.                                                |
| `database`          | The name of the database the table is in.                  |
| `estimate_complete` | The estimated time to complete (in seconds).               |
| `elapsed`           | The time elapsed (in seconds) since the merge started.     |
| `progress`          | The percentage of completed work (0-100 percent).          |
| `is_mutation`       | 1 if this process is a part mutation.                      |
| `size_compressed`   | The total size of the compressed data of the merged parts. |
| `memory_usage`      | Memory consumption of the merge process.                   |

<h3 id="syntax-25">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW MERGES [[NOT] LIKE|ILIKE '<table_name_pattern>'] [LIMIT <N>]
```

<h3 id="examples-8">
  Examples
</h3>

```sql title="Query" theme={null}
SHOW MERGES;
```

```text title="Response" theme={null}
┌─table──────┬─database─┬─estimate_complete─┬─elapsed─┬─progress─┬─is_mutation─┬─size_compressed─┬─memory_usage─┐
│ your_table │ default  │              0.14 │    0.36 │    73.01 │           0 │        5.40 MiB │    10.25 MiB │
└────────────┴──────────┴───────────────────┴─────────┴──────────┴─────────────┴─────────────────┴──────────────┘
```

```sql title="Query" theme={null}
SHOW MERGES LIKE 'your_t%' LIMIT 1;
```

```text title="Response" theme={null}
┌─table──────┬─database─┬─estimate_complete─┬─elapsed─┬─progress─┬─is_mutation─┬─size_compressed─┬─memory_usage─┐
│ your_table │ default  │              0.14 │    0.36 │    73.01 │           0 │        5.40 MiB │    10.25 MiB │
└────────────┴──────────┴───────────────────┴─────────┴──────────┴─────────────┴─────────────────┴──────────────┘
```

<h2 id="show-create-masking-policy">
  SHOW CREATE MASKING POLICY
</h2>

The `SHOW CREATE MASKING POLICY` statement shows parameters which were used at [masking policy creation](/reference/statements/create/masking-policy).

<h3 id="syntax-26">
  Syntax
</h3>

```sql title="Syntax" theme={null}
SHOW CREATE MASKING POLICY name ON [database.]table
```