ClickHouse/clickhouse-docs-embeddings huggingface dataset:
YTsaurus dictionary source

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/create/dictionary/sources/ytsaurus.md)

Experimental feature. [Learn more.](/docs/beta-and-experimental-features#experimental-features)

Not supported in ClickHouse Cloud

References

This is an experimental feature that may change in backwards-incompatible ways in future releases.
Enable usage of the YTsaurus dictionary source
using setting [`allow_experimental_ytsaurus_dictionary_source`](/docs/operations/settings/settings#allow_experimental_ytsaurus_dictionary_source).

Example of settings:

- DDL- Configuration file

```
SOURCE(YTSAURUS(
    http_proxy_urls 'http://localhost:8000'
    cypress_path '//tmp/test'
    oauth_token 'password'
))
```

```
<source>
    <ytsaurus>
        <http_proxy_urls>http://localhost:8000</http_proxy_urls>
        <cypress_path>//tmp/test</cypress_path>
        <oauth_token>password</oauth_token>
        <check_table_schema>1</check_table_schema>
    </ytsaurus>
</source>
```

  

Setting fields:

|  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- |
| Setting Description|  |  |  |  |  |  | | --- | --- | --- | --- | --- | --- | | `http_proxy_urls` URL to the YTsaurus http proxy.|  |  |  |  | | --- | --- | --- | --- | | `cypress_path` Cypress path to the table source.|  |  | | --- | --- | | `oauth_token` OAuth token. | | | | | | | |

Was this page helpful?
title_wip

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/create/function.md)

Creates a user defined function (UDF) from a lambda expression. The expression must consist of function parameters, constants, operators, or other function calls.

**Syntax**

```
CREATE [OR REPLACE] FUNCTION name [ON CLUSTER cluster] AS (parameter0, ...) -> expression
```

A function can have an arbitrary number of parameters.

There are a few restrictions:

- The name of a function must be unique among user defined and system functions.
- Recursive functions are not allowed.
- All variables used by a function must be specified in its parameter list.

If any restriction is violated then an exception is raised.

**Example**

Query:

```
CREATE FUNCTION linear_equation AS (x, k, b) -> k*x + b;
SELECT number, linear_equation(number, 2, 1) FROM numbers(3);
```

Result:

```
┌─number─┬─plus(multiply(2, number), 1)─┐
│      0 │                            1 │
│      1 │                            3 │
│      2 │                            5 │
└────────┴──────────────────────────────┘
```

A [conditional function](/docs/sql-reference/functions/conditional-functions) is called in a user defined function in the following query:

```
CREATE FUNCTION parity_str AS (n) -> if(n % 2, 'odd', 'even');
SELECT number, parity_str(number) FROM numbers(3);
```

Result:

```
┌─number─┬─if(modulo(number, 2), 'odd', 'even')─┐
│      0 │ even                                 │
│      1 │ odd                                  │
│      2 │ even                                 │
└────────┴──────────────────────────────────────┘
```

Replace an existing UDF:

```
CREATE FUNCTION exampleReplaceFunction AS frame -> frame;
SELECT create_query FROM system.functions WHERE name = 'exampleReplaceFunction';
CREATE OR REPLACE FUNCTION exampleReplaceFunction AS frame -> frame + 1;
SELECT create_query FROM system.functions WHERE name = 'exampleReplaceFunction';
```

Result:

```
┌─create_query─────────────────────────────────────────────┐
│ CREATE FUNCTION exampleReplaceFunction AS frame -> frame │
└──────────────────────────────────────────────────────────┘

┌─create_query───────────────────────────────────────────────────┐
│ CREATE FUNCTION exampleReplaceFunction AS frame -> (frame + 1) │
└────────────────────────────────────────────────────────────────┘
```

## Related Content[​](#related-content "Direct link to Related Content")

### [Executable UDFs](/docs/sql-reference/functions/udf).[​](#executable-udfs "Direct link to executable-udfs")

### [User-defined functions in ClickHouse Cloud](https://clickhouse.com/blog/user-defined-functions-clickhouse-udfs)[​](#user-defined-functions-in-clickhouse-cloud "Direct link to user-defined-functions-in-clickhouse-cloud")

- [Related Content](#related-content)
  - [Executable UDFs.](#executable-udfs)- [User-defined functions in ClickHouse Cloud](#user-defined-functions-in-clickhouse-cloud)

Was this page helpful?
title_wip

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/create/masking-policy.md)

ClickHouse Cloud only

Creates a masking policy, which allows dynamically transforming or masking column values for specific users or roles when they query a table.

Tip

Masking policies provide column-level data security by transforming sensitive data at query time without modifying the stored data.

Syntax:

```
CREATE MASKING POLICY [IF NOT EXISTS | OR REPLACE] policy_name ON [database.]table
    UPDATE column1 = expression1 [, column2 = expression2 ...]
    [WHERE condition]
    TO {role1 [, role2 ...] | ALL | ALL EXCEPT role1 [, role2 ...]}
    [PRIORITY priority_number]
```

## UPDATE Clause[​](#update-clause "Direct link to UPDATE Clause")

The `UPDATE` clause specifies which columns to mask and how to transform them. You can mask multiple columns in a single policy.

Examples:

- Simple masking: `UPDATE email = '***masked***'`
- Partial masking: `UPDATE email = concat(substring(email, 1, 3), '***@***.***')`
- Hash-based masking: `UPDATE email = concat('masked_', substring(hex(cityHash64(email)), 1, 8))`
- Multiple columns: `UPDATE email = '***@***.***', phone = '***-***-****'`

## WHERE Clause[​](#where-clause "Direct link to WHERE Clause")

The optional `WHERE` clause allows conditional masking based on row values. Only rows matching the condition will have the masking applied.

Example:

```
CREATE MASKING POLICY mask_high_salaries ON employees
UPDATE salary = 0
WHERE salary > 100000
TO analyst;
```

## TO Clause[​](#to-clause "Direct link to TO Clause")

In the `TO` section, specify which users and roles the policy should apply to.

- `TO user1, user2`: Apply to specific users/roles
- `TO ALL`: Apply to all users
- `TO ALL EXCEPT user1, user2`: Apply to all users except specified ones

Note

Unlike row policies, masking policies do not affect users who don't have the policy applied. If no masking policy applies to a user, they see the original data.

## PRIORITY Clause[​](#priority-clause "Direct link to PRIORITY Clause")

When multiple masking policies target the same column for a user, the `PRIORITY` clause determines the application order. Policies are applied in order from highest to lowest priority.

Default priority is 0. Policies with the same priority are applied in an undefined order.

Example:

```
-- Applied second (lower priority)
CREATE MASKING POLICY mask1 ON users
UPDATE email = '[email protected]'
TO analyst
PRIORITY 1;

-- Applied first (higher priority)
CREATE MASKING POLICY mask2 ON users
UPDATE email = '[email protected]'
TO analyst
PRIORITY 10;

-- analyst sees '[email protected]' because it's applied last
```

Performance Considerations

- Masking policies may impact query performance depending on expression complexity
- Some optimizations may be disabled for tables with active masking policies

- [UPDATE Clause](#update-clause)- [WHERE Clause](#where-clause)- [TO Clause](#to-clause)- [PRIORITY Clause](#priority-clause)

Was this page helpful?
title_wip

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/create/named-collection.md)

Not supported in ClickHouse Cloud

Creates a new named collection.

**Syntax**

```
CREATE NAMED COLLECTION [IF NOT EXISTS] name [ON CLUSTER cluster] AS
key_name1 = 'some value' [[NOT] OVERRIDABLE],
key_name2 = 'some value' [[NOT] OVERRIDABLE],
key_name3 = 'some value' [[NOT] OVERRIDABLE],
...
```

**Example**

```
CREATE NAMED COLLECTION foobar AS a = '1', b = '2' OVERRIDABLE;
```

**Related statements**

- [CREATE NAMED COLLECTION](/docs/sql-reference/statements/alter/named-collection)
- [DROP NAMED COLLECTION](/docs/sql-reference/statements/drop#drop-function)

**See Also**

- [Named collections guide](/docs/operations/named-collections)

Was this page helpful?
title_wip

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/create/role.md)

Creates new [roles](/docs/operations/access-rights#role-management). Role is a set of [privileges](/docs/sql-reference/statements/grant#granting-privilege-syntax). A [user](/docs/sql-reference/statements/create/user) assigned a role gets all the privileges of this role.

Syntax:

```
CREATE ROLE [IF NOT EXISTS | OR REPLACE] name1 [, name2 [,...]] [ON CLUSTER cluster_name]
    [IN access_storage_type]
    [SETTINGS variable [= value] [MIN [=] min_value] [MAX [=] max_value] [CONST|READONLY|WRITABLE|CHANGEABLE_IN_READONLY] | PROFILE 'profile_name'] [,...]
```

## Managing Roles[​](#managing-roles "Direct link to Managing Roles")

A user can be assigned multiple roles. Users can apply their assigned roles in arbitrary combinations by the [SET ROLE](/docs/sql-reference/statements/set-role) statement. The final scope of privileges is a combined set of all the privileges of all the applied roles. If a user has privileges granted directly to it's user account, they are also combined with the privileges granted by roles.

User can have default roles which apply at user login. To set default roles, use the [SET DEFAULT ROLE](/docs/sql-reference/statements/set-role#set-default-role) statement or the [ALTER USER](/docs/sql-reference/statements/alter/user) statement.

To revoke a role, use the [REVOKE](/docs/sql-reference/statements/revoke) statement.

To delete role, use the [DROP ROLE](/docs/sql-reference/statements/drop#drop-role) statement. The deleted role is being automatically revoked from all the users and roles to which it was assigned.

## Examples[​](#examples "Direct link to Examples")

```
CREATE ROLE accountant;
GRANT SELECT ON db.* TO accountant;
```

This sequence of queries creates the role `accountant` that has the privilege of reading data from the `db` database.

Assigning the role to the user `mira`:

```
GRANT accountant TO mira;
```

After the role is assigned, the user can apply it and execute the allowed queries. For example:

```
SET ROLE accountant;
SELECT * FROM db.*;
```

- [Managing Roles](#managing-roles)- [Examples](#examples)

Was this page helpful?
title_wip

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/create/settings-profile.md)

Creates [settings profiles](/docs/operations/access-rights#settings-profiles-management) that can be assigned to a user or a role.

Syntax:

```
CREATE SETTINGS PROFILE [IF NOT EXISTS | OR REPLACE] name1 [, name2 [,...]] 
    [ON CLUSTER cluster_name]
    [IN access_storage_type]
    [SETTINGS variable [= value] [MIN [=] min_value] [MAX [=] max_value] [CONST|READONLY|WRITABLE|CHANGEABLE_IN_READONLY] | INHERIT 'profile_name'] [,...]
    [TO {{role1 | user1 [, role2 | user2 ...]} | NONE | ALL | ALL EXCEPT {role1 | user1 [, role2 | user2 ...]}}]
```

`ON CLUSTER` clause allows creating settings profiles on a cluster, see [Distributed DDL](/docs/sql-reference/distributed-ddl).

## Example[​](#example "Direct link to Example")

Create a user:

```
CREATE USER robin IDENTIFIED BY 'password';
```

Create the `max_memory_usage_profile` settings profile with value and constraints for the `max_memory_usage` setting and assign it to user `robin`:

```
CREATE
SETTINGS PROFILE max_memory_usage_profile SETTINGS max_memory_usage = 100000001 MIN 90000000 MAX 110000000
TO robin
```

- [Example](#example)

Was this page helpful?
CREATE TABLE

```
REPLACE TABLE base.t1 (n UInt64) 
ENGINE = MergeTree 
ORDER BY n;

INSERT INTO base.t1 VALUES (3);

SELECT * FROM base.t1;

3
```

## COMMENT Clause[​](#comment-clause "Direct link to COMMENT Clause")

You can add a comment to the table when creating it.

**Syntax**

```
CREATE TABLE [db.]table_name
(
    name1 type1, name2 type2, ...
)
ENGINE = engine
COMMENT 'Comment'
```

Note

The `COMMENT` clause must be specified **after** any storage-specific clauses such as `PARTITION BY`, `ORDER BY`, and storage-specific `SETTINGS`.

After the `COMMENT` clause, only query-specific `SETTINGS` (like `max_threads`, etc.) will be parsed, not storage-related settings.

This means the correct clause order is:

- `ENGINE`
- storage clauses
- `COMMENT`
- query settings (if any)

**Example**

Query:

```
CREATE TABLE t1 (x String) ENGINE = Memory COMMENT 'The temporary table';
SELECT name, comment FROM system.tables WHERE name = 't1';
```

Result:

```
┌─name─┬─comment─────────────┐
│ t1   │ The temporary table │
└──────┴─────────────────────┘
```

## Related content[​](#related-content "Direct link to Related content")

- Blog: [Optimizing ClickHouse with Schemas and Codecs](https://clickhouse.com/blog/optimize-clickhouse-codecs-compression-schema)
- Blog: [Working with time series data in ClickHouse](https://clickhouse.com/blog/working-with-time-series-data-and-functions-ClickHouse)

- [Syntax Forms](#syntax-forms)
  - [With Explicit Schema](#with-explicit-schema)- [With Schema of Existing Table](#with-a-schema-similar-to-other-table)- [With Schema and Data of Existing Table](#with-a-schema-and-data-cloned-from-another-table)- [From a Table Function](#from-a-table-function)- [From SELECT query](#from-select-query)- [NULL Or NOT NULL Modifiers](#null-or-not-null-modifiers)- [Default Values](#default_values)
      - [DEFAULT](#default)- [MATERIALIZED](#materialized)- [EPHEMERAL](#ephemeral)- [ALIAS](#alias)- [Primary Key](#primary-key)- [Constraints](#constraints)
          - [CONSTRAINT](#constraint)- [ASSUME](#assume)- [TTL Expression](#ttl-expression)- [Column Compression Codecs](#column_compression_codec)
              - [General Purpose Codecs](#general-purpose-codecs)- [Specialized Codecs](#specialized-codecs)- [Encryption Codecs](#encryption-codecs)- [Temporary Tables](#temporary-tables)- [REPLACE TABLE](#replace-table)
                  - [Syntax](#syntax)- [Examples:](#examples)- [COMMENT Clause](#comment-clause)- [Related content](#related-content)

Was this page helpful?
EXCHANGE Statement

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/exchange.md)

Exchanges the names of two tables or dictionaries atomically.
This task can also be accomplished with a [`RENAME`](/docs/sql-reference/statements/rename) query using a temporary name, but the operation is not atomic in that case.

Note

The `EXCHANGE` query is supported by the [`Atomic`](/docs/engines/database-engines/atomic) and [`Shared`](/docs/cloud/reference/shared-catalog#shared-database-engine) database engines only.

**Syntax**

```
EXCHANGE TABLES|DICTIONARIES [db0.]name_A AND [db1.]name_B [ON CLUSTER cluster]
```

## EXCHANGE TABLES[​](#exchange-tables "Direct link to EXCHANGE TABLES")

Exchanges the names of two tables.

**Syntax**

```
EXCHANGE TABLES [db0.]table_A AND [db1.]table_B [ON CLUSTER cluster]
```

### EXCHANGE MULTIPLE TABLES[​](#exchange-multiple-tables "Direct link to EXCHANGE MULTIPLE TABLES")

You can exchange multiple table pairs in a single query by separating them with commas.

Note

When exchanging multiple table pairs, the exchanges are performed **sequentially, not atomically**. If an error occurs during the operation, some table pairs may have been exchanged while others have not.

**Example**

```
-- Create tables
CREATE TABLE a (a UInt8) ENGINE=Memory;
CREATE TABLE b (b UInt8) ENGINE=Memory;
CREATE TABLE c (c UInt8) ENGINE=Memory;
CREATE TABLE d (d UInt8) ENGINE=Memory;

-- Exchange two pairs of tables in one query
EXCHANGE TABLES a AND b, c AND d;

SHOW TABLE a;
SHOW TABLE b;
SHOW TABLE c;
SHOW TABLE d;
```

```
-- Now table 'a' has the structure of 'b', and table 'b' has the structure of 'a'
┌─statement──────────────┐
│ CREATE TABLE default.a↴│
│↳(                     ↴│
│↳    `b` UInt8         ↴│
│↳)                     ↴│
│↳ENGINE = Memory        │
└────────────────────────┘
┌─statement──────────────┐
│ CREATE TABLE default.b↴│
│↳(                     ↴│
│↳    `a` UInt8         ↴│
│↳)                     ↴│
│↳ENGINE = Memory        │
└────────────────────────┘

-- Now table 'c' has the structure of 'd', and table 'd' has the structure of 'c'
┌─statement──────────────┐
│ CREATE TABLE default.c↴│
│↳(                     ↴│
│↳    `d` UInt8         ↴│
│↳)                     ↴│
│↳ENGINE = Memory        │
└────────────────────────┘
┌─statement──────────────┐
│ CREATE TABLE default.d↴│
│↳(                     ↴│
│↳    `c` UInt8         ↴│
│↳)                     ↴│
│↳ENGINE = Memory        │
└────────────────────────┘
```

## EXCHANGE DICTIONARIES[​](#exchange-dictionaries "Direct link to EXCHANGE DICTIONARIES")

Exchanges the names of two dictionaries.

**Syntax**

```
EXCHANGE DICTIONARIES [db0.]dict_A AND [db1.]dict_B [ON CLUSTER cluster]
```

**See Also**

- [Dictionaries](/docs/sql-reference/statements/create/dictionary)

- [EXCHANGE TABLES](#exchange-tables)
  - [EXCHANGE MULTIPLE TABLES](#exchange-multiple-tables)- [EXCHANGE DICTIONARIES](#exchange-dictionaries)

Was this page helpful?
title_wip

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/execute_as.md)

Allows to execute queries on behalf of a different user.

## Syntax[​](#syntax "Direct link to Syntax")

```
EXECUTE AS target_user;
EXECUTE AS target_user subquery;
```

The first form (without `subquery`) sets that all the following queries in the current session will be executed on behalf of the specified `target_user`.

The second form (with `subquery`) executes only the specified `subquery` on behalf of the specified `target_user`.

In order to work both forms require config setting `access_control_improvements.allow_impersonate_user`
to be set to `1` and the `IMPERSONATE` privilege to be granted. For example, the following commands

```
GRANT IMPERSONATE ON user1 TO user2;
GRANT IMPERSONATE ON * TO user3;
```

allow user `user2` to execute commands `EXECUTE AS user1 ...` and also allow user `user3` to execute commands as any user.

While impersonating another user function [currentUser()](/docs/sql-reference/functions/other-functions#currentUser) returns the name of that other user,
and function [authenticatedUser()](/docs/sql-reference/functions/other-functions#authenticatedUser) returns the name of the user who has been actually authenticated.

## Examples[​](#examples "Direct link to Examples")

```
SELECT currentUser(), authenticatedUser(); -- outputs "default    default"
CREATE USER james;
EXECUTE AS james SELECT currentUser(), authenticatedUser(); -- outputs "james    default"
```

- [Syntax](#syntax)- [Examples](#examples)

Was this page helpful?
title_wip

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/exists.md)

```
EXISTS [TEMPORARY] [TABLE|DICTIONARY|DATABASE] [db.]name [INTO OUTFILE filename] [FORMAT format]
```

Returns a single `UInt8`-type column, which contains the single value `0` if the table or database does not exist, or `1` if the table exists in the specified database.

Was this page helpful?
title_wip

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/move.md)

This statement allows to move an access entity from one access storage to another.

Syntax:

```
MOVE {USER, ROLE, QUOTA, SETTINGS PROFILE, ROW POLICY} name1 [, name2, ...] TO access_storage_type
```

Currently, there are five access storages in ClickHouse:

- `local_directory`
- `memory`
- `replicated`
- `users_xml` (ro)
- `ldap` (ro)

Examples:

```
MOVE USER test TO local_directory
```

```
MOVE ROLE test TO memory
```

Was this page helpful?
title_wip

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/parallel_with.md)

Allows to execute multiple statements in parallel.

## Syntax[​](#syntax "Direct link to Syntax")

```
statement1 PARALLEL WITH statement2 [PARALLEL WITH statement3 ...]
```

Executes statements `statement1`, `statement2`, `statement3`, ... in parallel with each other. The output of those statements is discarded.

Executing statements in parallel may be faster than just a sequence of the same statements in many cases. For example, `statement1 PARALLEL WITH statement2 PARALLEL WITH statement3` is likely to be faster than `statement1; statement2; statement3`.

## Examples[​](#examples "Direct link to Examples")

Creates two tables in parallel:

```
CREATE TABLE table1(x Int32) ENGINE = MergeTree ORDER BY tuple()
PARALLEL WITH
CREATE TABLE table2(y String) ENGINE = MergeTree ORDER BY tuple();
```

Drops two tables in parallel:

```
DROP TABLE table1
PARALLEL WITH
DROP TABLE table2;
```

## Settings[​](#settings "Direct link to Settings")

Setting [max\_threads](/docs/operations/settings/settings#max_threads) controls how many threads are spawned.

## Comparison with UNION[​](#comparison-with-union "Direct link to Comparison with UNION")

The `PARALLEL WITH` clause is a bit similar to [UNION](/docs/sql-reference/statements/select/union), which also executes its operands in parallel. However there are some differences:

- `PARALLEL WITH` doesn't return any results from executing its operands, it can only rethrow an exception from them if any;
- `PARALLEL WITH` doesn't require its operands to have the same set of result columns;
- `PARALLEL WITH` can execute any statements (not just `SELECT`).

- [Syntax](#syntax)- [Examples](#examples)- [Settings](#settings)- [Comparison with UNION](#comparison-with-union)

Was this page helpful?
RENAME Statement

[Edit this page](https://github.com/ClickHouse/ClickHouse/tree/master/docs/en/sql-reference/statements/rename.md)

Renames databases, tables, or dictionaries. Several entities can be renamed in a single query.
Note that the `RENAME` query with several entities is non-atomic operation. To swap entities names atomically, use the [EXCHANGE](/docs/sql-reference/statements/exchange) statement.

**Syntax**

```
RENAME [DATABASE|TABLE|DICTIONARY] name TO new_name [,...] [ON CLUSTER cluster]
```

## RENAME DATABASE[​](#rename-database "Direct link to RENAME DATABASE")

Renames databases.

**Syntax**

```
RENAME DATABASE atomic_database1 TO atomic_database2 [,...] [ON CLUSTER cluster]
```

## RENAME TABLE[​](#rename-table "Direct link to RENAME TABLE")

Renames one or more tables.

Renaming tables is a light operation. If you pass a different database after `TO`, the table will be moved to this database. However, the directories with databases must reside in the same file system. Otherwise, an error is returned.
If you rename multiple tables in one query, the operation is not atomic. It may be partially executed, and queries in other sessions may get `Table ... does not exist ...` error.

**Syntax**

```
RENAME TABLE [db1.]name1 TO [db2.]name2 [,...] [ON CLUSTER cluster]
```

**Example**

```
RENAME TABLE table_A TO table_A_bak, table_B TO table_B_bak;
```

And you can use a simpler sql:

```
RENAME table_A TO table_A_bak, table_B TO table_B_bak;
```

## RENAME DICTIONARY[​](#rename-dictionary "Direct link to RENAME DICTIONARY")

Renames one or several dictionaries. This query can be used to move dictionaries between databases.

**Syntax**

```
RENAME DICTIONARY [db0.]dict_A TO [db1.]dict_B [,...] [ON CLUSTER cluster]
```

**See Also**

- [Dictionaries](/docs/sql-reference/statements/create/dictionary)

- [RENAME DATABASE](#rename-database)- [RENAME TABLE](#rename-table)- [RENAME DICTIONARY](#rename-dictionary)

Was this page helpful?