finish dataTypes zh translate (#3417)

* add dataTypes zh translate --> init docs

* add dataTypes zh translate

* finish dataTypes zh translate

* fix punctuation in dataTypes zh translate

docs/zh/data_types/array.md

@@ -1,8 +1,84 @@
 <a name="data_type-array"></a>
 
-# Array（T）
+# Array(T)
 
-一个包含类型 T 的 数组（Array）。T 类型可以是任意类型，包括数组类型。
-我们不推荐使用多维数组，因为多维数组并没有得到很好支持（比如，不能在 MergeTree 引擎的表中存储多维数组）。
+由 `T` 类型元素组成的数组。
 
-[来源文章](https://clickhouse.yandex/docs/en/data_types/array/) <!--hide-->
+`T` 可以是任意类型，包含数组类型。不推荐使用多维数组，ClickHouse 对多维数组的支持有限。例如，不能存储在 `MergeTree` 表中存储多维数组。
+
+## 创建数组
+
+您可以使用一个函数创建数组：
+
+```
+array(T)
+```
+
+您也可以使用方括号：
+
+```
+[]
+```
+
+创建数组示例：
+
+```
+:) SELECT array(1, 2) AS x, toTypeName(x)
+
+SELECT
+    [1, 2] AS x,
+    toTypeName(x)
+
+┌─x─────┬─toTypeName(array(1, 2))─┐
+│ [1,2] │ Array(UInt8)            │
+└───────┴─────────────────────────┘
+
+1 rows in set. Elapsed: 0.002 sec.
+
+:) SELECT [1, 2] AS x, toTypeName(x)
+
+SELECT
+    [1, 2] AS x,
+    toTypeName(x)
+
+┌─x─────┬─toTypeName([1, 2])─┐
+│ [1,2] │ Array(UInt8)       │
+└───────┴────────────────────┘
+
+1 rows in set. Elapsed: 0.002 sec.
+```
+
+## 使用数据类型
+
+当动态创建数组时，ClickHouse 自动将参数类型定义为可以存储所有列出的参数的最窄的数据类型。如果存在任何 [NULL](../query_language/syntax.md#null-literal) 或者 [Nullable](nullable.md#data_type-nullable) 类型参数，那么数组元素的类型是 [Nullable](nullable.md#data_type-nullable)。
+
+如果 ClickHouse 无法确定数据类型，它将产生异常。当尝试同时创建一个包含字符串和数字的数组时会发生这种情况 (`SELECT array(1, 'a')`)。
+
+自动数据类型检测示例：
+
+```
+:) SELECT array(1, 2, NULL) AS x, toTypeName(x)
+
+SELECT
+    [1, 2, NULL] AS x,
+    toTypeName(x)
+
+┌─x──────────┬─toTypeName(array(1, 2, NULL))─┐
+│ [1,2,NULL] │ Array(Nullable(UInt8))        │
+└────────────┴───────────────────────────────┘
+
+1 rows in set. Elapsed: 0.002 sec.
+```
+
+如果您尝试创建不兼容的数据类型数组，ClickHouse 将引发异常：
+
+```
+:) SELECT array(1, 'a')
+
+SELECT [1, 'a']
+
+Received exception from server (version 1.1.54388):
+Code: 386. DB::Exception: Received from localhost:9000, 127.0.0.1. DB::Exception: There is no supertype for types UInt8, String because some of them are String/FixedString and some of them are not.
+
+0 rows in set. Elapsed: 0.246 sec.
+```

docs/zh/data_types/boolean.md

@@ -1,5 +1,3 @@
-# Boolean values
+# Boolean Values
 
-没有单独的类型来存储 boolean 值。可以使用 UInt8 类型，取值限制为 0 或 1。
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/boolean/) <!--hide-->
+没有单独的类型来存储布尔值。可以使用 UInt8 类型，取值限制为 0 或 1。

docs/zh/data_types/date.md

@@ -1,8 +1,5 @@
 # Date
 
-Date 用两个字节来存储从 1970-01-01 到现在的日期值（无符号的值）。Date 允许存储的值 UNIX 纪元开始后的时间值，这个值上限会在编译阶段作为一个常量存储（当前只能到 2038 年，但可以拓展到 2106 年）。
-Date 最小的值为 0000-00-00 00:00:00。
+日期类型，用两个字节存储，表示从 1970-01-01 (无符号) 到当前的日期值。允许存储从 Unix 纪元开始到编译阶段定义的上限阈值常量（目前上限是2106年，但最终完全支持的年份为2105）。最小值输出为0000-00-00。
 
-Date 中没有存储时区信息。
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/date/) <!--hide-->
+日期中没有存储时区信息。

docs/zh/data_types/datetime.md

@@ -1,16 +1,13 @@
+<a name="data_type-datetime"></a>
+
 # DateTime
 
-包含时间和日期。用4个字节来存储 Unix 时间戳（无符号的值）。允许存储的时间范围同 Date 类型。最小的值为 0000-00-00 00:00:00。
-DateTime 类型值精确到秒（不考虑闰秒）
+时间戳类型。用四个字节存储 Unix 时间戳（无符号的）。允许存储与日期类型相同的范围内的值。最小值为 0000-00-00 00:00:00。时间戳类型值精确到秒（没有闰秒）。
 
-## Time zones
+## 时区
 
-在客户端或服务器启动时，会使用系统的时区来将时间日期从文本（划分成多个部分）到二进制之间相互转化。在文本格式中，有关夏令时信息不作存储。
+使用启动客户端或服务器时的系统时区，时间戳是从文本（分解为组件）转换为二进制并返回。在文本格式中，有关夏令时的信息会丢失。
 
-默认情况下，客户端连接到服务的时候会使用服务端时区。可以通过客户端命令行参数 `--use_client_time_zone` 来设置使用客户端时区。
+默认情况下，客户端连接到服务的时候会使用服务端时区。您可以通过启用客户端命令行选项 `--use_client_time_zone` 来设置使用客户端时间。
 
-在所有的时区内，只支持部分与UTC相差整数小时（不考虑闰秒）的时区。
-
-因此，在处理文本日期时（例如，在保存文本转储时），请记住在夏时制期间可能会出现歧义，如果时区发生变化，可能会出现与数据匹配的问题。
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/datetime/) <!--hide-->
+因此，在处理文本日期时（例如，在保存文本转储时），请记住在夏令时更改期间可能存在歧义，如果时区发生更改，则可能存在匹配数据的问题。

docs/zh/data_types/decimal.md

@@ -2,17 +2,17 @@
 
 # Decimal(P, S), Decimal32(S), Decimal64(S), Decimal128(S)
 
-有符号的定点数，在进行加减乘操作的过程中都会保留精度。对于除法，最低有效数字被丢弃（不舍入）。
+有符号的定点数，可在加、减和乘法运算过程中保持精度。对于除法，最低有效数字会被丢弃（不舍入）。
 
 ## 参数
 
-- P - 精度。范围值: [ 1 : 38 ]，决定可以有多少个十进制数字（包括分数）。
-- S - 范围。范围值: [ 0 : P ]，决定小数的位数。
+- P - 精度。有效范围：[1:38]，决定可以有多少个十进制数字（包括分数）。
+- S - 规模。有效范围：[0：P]，决定数字的小数部分中包含的小数位数。
 
 对于不同的 P 参数值 Decimal 表示，以下例子都是同义的：
-- [ 1 : 9 ] 的 P - for Decimal32(S)
-- [ 10 : 18 ] 的 P - for Decimal64(S)
-- [ 19 : 38 ] 的 P - for Decimal128(S)
+- P from [ 1 : 9 ] - for Decimal32(S)
+- P from [ 10 : 18 ] - for Decimal64(S)
+- P from [ 19 : 38 ] - for Decimal128(S)
 
 ## 十进制值范围
 
@@ -20,38 +20,37 @@
 - Decimal64(S) - ( -1 * 10^(18 - S), 1 * 10^(18 - S) )
 - Decimal128(S) - ( -1 * 10^(38 - S), 1 * 10^(38 - S) )
 
-例如, Decimal32(4) 可以表示 -99999.9999 到 99999.9999 范围内步数为 0.0001 的值。
+例如，Decimal32(4) 可以表示 -99999.9999 至 99999.9999 的数值，步长为0.0001。
 
 ## 内部表示方式
 
 数据采用与自身位宽相同的有符号整数存储。这个数在内存中实际范围会高于上述范围，从 String 转换到十进制数的时候会做对应的检查。
 
-Decimal32/Decimal64 通常处理速度要高于Decimal128，这是因为当前通用CPU不支持128位的操作导致的。
+由于现代CPU不支持128位数字，因此 Decimal128 上的操作由软件模拟。所以 Decimal128 的运算速度明显慢于 Decimal32/Decimal64。
 
-## 运算以及结果的类型
+## 运算和结果类型
 
-对Decimal的二进制运算导致更宽的结果类型（具有任何参数顺序）。
+对Decimal的二进制运算导致更宽的结果类型（无论参数的顺序如何）。
 
 - Decimal64(S1) <op> Decimal32(S2) -> Decimal64(S)
 - Decimal128(S1) <op> Decimal32(S2) -> Decimal128(S)
 - Decimal128(S1) <op> Decimal64(S2) -> Decimal128(S)
 
-精度变化的规则:
+精度变化的规则：
 
-- 加，减： S = max(S1, S2).
-- 相乘： S = S1 + S2.
-- 相除：S = S1.
+- 加法，减法：S = max(S1, S2)。
+- 乘法：S = S1 + S2。
+- 除法：S = S1。
 
-对于 Decimal 和整数之间的类似操作，结果为一样参数值的 Decimal。
+对于 Decimal 和整数之间的类似操作，结果是与参数大小相同的十进制。
 
-没有定义 Decimal 和 Float32/Float64 的操作。如果你真的需要他们，你可以某一个参数明确地转换为 toDecimal32，toDecimal64， toDecimal128 或 toFloat32， toFloat64。注意这个操作会丢失精度，并且类型转换是一个代价昂贵的操作。
-
-有一些函数对 Decimal 进行操作后是返回 Float64 的（例如，var 或 stddev）。计算的结果可能仍在 Decimal 中执行，这可能导致 Float64 和具有相同值的 Decimal 输入计算后的结果不同。
+未定义Decimal和Float32/Float64之间的函数。要执行此类操作，您可以使用：toDecimal32、toDecimal64、toDecimal128 或 toFloat32，toFloat64，需要显式地转换其中一个参数。注意，结果将失去精度，类型转换是昂贵的操作。
 
+Decimal上的一些函数返回结果为Float64（例如，var或stddev）。对于其中一些，中间计算发生在Decimal中。对于此类函数，尽管结果类型相同，但Float64和Decimal中相同数据的结果可能不同。
 
 ## 溢出检查
 
-在对 Decimal 计算的过程中，数值会有可能溢出。分数中的过多数字被丢弃（不是舍入的）。 整数中的过多数字将导致异常。
+在对 Decimal 类型执行操作时，数值可能会发生溢出。分数中的过多数字被丢弃（不是舍入的）。整数中的过多数字将导致异常。
 
 ```
 SELECT toDecimal32(2, 4) AS x, x / 3
@@ -76,7 +75,7 @@ SELECT toDecimal32(4.2, 8) AS x, 6 * x
 DB::Exception: Decimal math overflow.
 ```
 
-溢出检查会导致操作减慢。 如果已知溢出不可能，则使用`decimal_check_overflow`设置禁用检查是有意义的。 禁用检查并发生溢出时，结果将不正确：
+检查溢出会导致计算变慢。如果已知溢出不可能，则可以通过设置`decimal_check_overflow`来禁用溢出检查，在这种情况下，溢出将导致结果不正确：
 
 ```
 SET decimal_check_overflow = 0;
@@ -88,7 +87,7 @@ SELECT toDecimal32(4.2, 8) AS x, 6 * x
 └────────────┴──────────────────────────────────┘
 ```
 
-溢出检查不仅会在数学运算中进行，还会在值比较中进行：
+溢出检查不仅发生在算术运算上，还发生在比较运算上：
 
 ```
 SELECT toDecimal32(1, 8) < 100
@@ -96,5 +95,3 @@ SELECT toDecimal32(1, 8) < 100
 ```
 DB::Exception: Can't compare.
 ```
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/decimal/) <!--hide-->

docs/zh/data_types/enum.md

@@ -1,34 +1,116 @@
-# Enum
+<a name="data_type-enum"></a>
 
-`Enum8` 或者 `Enum16`。 一组有限的字符串值，比 `String` 类型的存储更加有效。
+# Enum8, Enum16
 
-示例:
+包括 `Enum8` 和 `Enum16` 类型。`Enum` 保存 `'string'= integer` 的对应关系。在 ClickHouse 中，尽管用户使用的是字符串常量，但所有含有 `Enum` 数据类型的操作都是按照包含整数的值来执行。这在性能方面比使用 `String` 数据类型更有效。
 
-```text
-Enum8('hello' = 1, 'world' = 2)
+- `Enum8` 用 `'String'= Int8` 对描述。
+- `Enum16` 用 `'String'= Int16` 对描述。
+
+## 用法示例
+
+创建一个带有一个枚举 `Enum8('hello' = 1, 'world' = 2)` 类型的列：
+
+```
+CREATE TABLE t_enum
+(
+    x Enum8('hello' = 1, 'world' = 2)
+)
+ENGINE = TinyLog
 ```
 
-- 一个类型可以表示两个值: 'hello' and 'world'。
+这个 `x` 列只能存储类型定义中列出的值：`'hello'`或`'world'`。如果您尝试保存任何其他值，ClickHouse 抛出异常。
+
+```
+:) INSERT INTO t_enum VALUES ('hello'), ('world'), ('hello')
+
+INSERT INTO t_enum VALUES
+
+Ok.
+
+3 rows in set. Elapsed: 0.002 sec.
+
+:) insert into t_enum values('a')
+
+INSERT INTO t_enum VALUES
+
+
+Exception on client:
+Code: 49. DB::Exception: Unknown element 'a' for type Enum8('hello' = 1, 'world' = 2)
+```
+
+当您从表中查询数据时，ClickHouse 从 `Enum` 中输出字符串值。
+
+```
+SELECT * FROM t_enum
+
+┌─x─────┐
+│ hello │
+│ world │
+│ hello │
+└───────┘
+```
+
+如果需要看到对应行的数值，则必须将 `Enum` 值转换为整数类型。
+
+```
+SELECT CAST(x, 'Int8') FROM t_enum
+
+┌─CAST(x, 'Int8')─┐
+│               1 │
+│               2 │
+│               1 │
+└─────────────────┘
+```
+
+在查询中创建枚举值，您还需要使用 `CAST`。
+
+```
+SELECT toTypeName(CAST('a', 'Enum8(\'a\' = 1, \'b\' = 2)'))
+
+┌─toTypeName(CAST('a', 'Enum8(\'a\' = 1, \'b\' = 2)'))─┐
+│ Enum8('a' = 1, 'b' = 2)                              │
+└──────────────────────────────────────────────────────┘
+```
+
+## 规则及用法
 
 `Enum8` 类型的每个值范围是 `-128 ... 127`，`Enum16` 类型的每个值范围是 `-32768 ... 32767`。所有的字符串或者数字都必须是不一样的。允许存在空字符串。如果某个 Enum 类型被指定了（在表定义的时候），数字可以是任意顺序。然而，顺序并不重要。
-（译者注：如 `Enum8('he o' = 3, 'wld' = 1)` 也是合法的）
 
-在内存中，Enum 类型当做 `Int8` or `Int16` 对应的数值来存储。
-当以文本方式读取的时候，ClickHouse 将值解析成字符串然后去 Enum 值的集合中搜索对应字符串。如果没有找到，会抛出异常。当读取文本格式的时候，会根据读取到的字符串去找对应的数值。如果没有找到，会抛出异常。
+`Enum` 中的字符串和数值都不能是 [NULL](../query_language/syntax.md#null-literal)。
 
-当以文本方式写入的时候，ClickHouse 将值解析成字符串写入。如果  column 数据包含垃圾（不是从有用集合含有的数值），会抛弃异常。Enum 类型以二进制读取和写入的方式与 Int8 和 Int16 类型一样的。
-隐式默认值是对应类型的最小值。
+`Enum` 包含在 [Nullable](nullable.md#data_type-nullable) 类型中。因此，如果您使用此查询创建一个表
 
-在 `ORDER BY`, `GROUP BY`, `IN`, `DISTINCT` 中，Enums 和对应数值是一样的工作方式。比如， ORDER BY 会将它们按数值排序。对 Enums 类型使用相同和比较操作符都与操作它们隐含的数值是一样的。
+```
+CREATE TABLE t_enum_nullable
+(
+    x Nullable( Enum8('hello' = 1, 'world' = 2) )
+)
+ENGINE = TinyLog
+```
 
-Enum 值不能和数值比较大小。Enums 可以和一个常量字符串比较大小。如果字符串不是一个可用的 Enum 值，会抛出异常。可以使用 IN 运算符来判断一个 Enum 是否存在于某个 Enum 集合中，其中集合中的 Enum 需要用字符串表示。
+不仅可以存储 `'hello'` 和 `'world'` ，还可以存储 `NULL`。
 
-大部分数字运算和字符串运算都没有给 Enum 类型定义，比如，Enum 类型不能和一个数相加，或进行字符串连接的操作，但是可以通过 toString 方法返回它对应的字符串。
+```
+INSERT INTO t_enum_null Values('hello'),('world'),(NULL)
+```
+
+在内存中，`Enum` 列的存储方式与相应数值的 `Int8` 或 `Int16` 相同。
+
+当以文本方式读取的时候，ClickHouse 将值解析成字符串然后去枚举值的集合中搜索对应字符串。如果没有找到，会抛出异常。当读取文本格式的时候，会根据读取到的字符串去找对应的数值。如果没有找到，会抛出异常。
+
+当以文本形式写入时，ClickHouse 将值解析成字符串写入。如果列数据包含垃圾数据（不是来自有效集合的数字），则抛出异常。Enum 类型以二进制读取和写入的方式与 `Int8` 和 `Int16` 类型一样的。
+
+隐式默认值是数值最小的值。
+
+在 `ORDER BY`，`GROUP BY`，`IN`，`DISTINCT` 等等中，Enum 的行为与相应的数字相同。例如，按数字排序。对于等式运算符和比较运算符，Enum 的工作机制与它们在底层数值上的工作机制相同。
+
+枚举值不能与数字进行比较。枚举可以与常量字符串进行比较。如果与之比较的字符串不是有效Enum值，则将引发异常。可以使用 IN 运算符来判断一个 Enum 是否存在于某个 Enum 集合中，其中集合中的 Enum 需要用字符串表示。
+
+大多数具有数字和字符串的运算并不适用于Enums；例如，Enum 类型不能和一个数值相加。但是，Enum有一个原生的 `toString` 函数，它返回它的字符串值。
 
 Enum 值使用 `toT` 函数可以转换成数值类型，其中 T 是一个数值类型。若 `T` 恰好对应 Enum 的底层数值类型，这个转换是零消耗的。
 
 Enum 类型可以被 `ALTER` 无成本地修改对应集合的值。可以通过 `ALTER` 操作来增加或删除 Enum 的成员（只要表没有用到该值，删除都是安全的）。作为安全保障，改变之前使用过的 Enum 成员将抛出异常。
 
 通过 `ALTER` 操作，可以将 `Enum8` 转成 `Enum16`，反之亦然，就像 `Int8` 转 `Int16`一样。
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/enum/) <!--hide-->

docs/zh/data_types/fixedstring.md

@@ -1,9 +1,9 @@
 # FixedString(N)
 
 固定长度 N 的字符串。N 必须是严格的正自然数。
-当服务端读取长度小于 N 的字符串时候（譬如解析插入的数据），字符串通过在末尾添加空字节来达到 N 字节长度。
-当服务端读取长度大于 N 的字符串时候，会返回一个错误。
-当服务端写入一个字符串的时候（譬如写入数据到 SELECT 查询结果中），末尾的空字节会被修剪掉。
+当服务端读取长度小于 N 的字符串时候（例如解析 INSERT 数据时），通过在字符串末尾添加空字节来达到 N 字节长度。
+当服务端读取长度大于 N 的字符串时候，将返回错误消息。
+当服务器写入一个字符串（例如，当输出 SELECT 查询的结果）时，NULL字节不会从字符串的末尾被移除，而是被输出。
 注意这种方式与 MYSQL 的 CHAR 类型是不一样的（MYSQL 的字符串会以空格填充，然后输出的时候空格会被修剪）。
 
-很少函数会使用 `FixedString(N)` 来代替 `String`，因此它并不是很方便。
+与 `String` 类型相比，极少的函数会使用 `FixedString(N)`，因此使用起来不太方便。

docs/zh/data_types/float.md

@@ -2,12 +2,12 @@
 
 [浮点数](https://en.wikipedia.org/wiki/IEEE_754)。
 
-类型与以下 C 类型是相同的：
+类型与以下 C 语言中类型是相同的：
 
 - `Float32` - `float`
 - `Float64`  - `double`
 
-我们建议，如果可能的话尽量用整形来存储数据。比如，将一定精度的浮点数转换成整形，譬如货币金额或者毫秒单位的加载时间。
+我们建议您尽可能以整数形式存储数据。例如，将固定精度的数字转换为整数值，例如货币数量或页面加载时间用毫秒为单位表示
 
 ## 使用浮点数
 
@@ -23,17 +23,17 @@
 └─────────────────────┘
 ```
 
-- 计算的结果取决于计算方式（处理器类型和计算机系统架构）
+- 计算的结果取决于计算方法（计算机系统的处理器类型和体系结构）
 
-- 浮点数计算可能出现这样的结果，比如 "infinity" （`Inf`） 和 "not-a-number" （`NaN`）。对浮点数计算的时候应该考虑到这点。
+- 浮点计算结果可能是诸如无穷大（`INF`）和"非数字"（`NaN`）。对浮点数计算的时候应该考虑到这点。
 
 - 当一行行阅读浮点数的时候，浮点数的结果可能不是机器最近显示的数值。
 
-## NaN 和 Inf
+## NaN and Inf
 
-相比于 SQL，ClickHouse 支持以下几种浮点数分类：
+与标准SQL相比，ClickHouse 支持以下类别的浮点数：
 
-- `Inf` – 正无穷。
+- `Inf` – 正无穷
 
 ```sql
 SELECT 0.5 / 0
@@ -44,7 +44,8 @@
 │            inf │
 └────────────────┘
 ```
-- `-Inf` – 负无穷。
+
+- `-Inf` – 负无穷
 
 ```sql
 SELECT -0.5 / 0
@@ -55,7 +56,8 @@
 │            -inf │
 └─────────────────┘
 ```
-- `NaN` – 非数字。
+
+- `NaN` – 非数字
 
 ```
 SELECT 0 / 0
@@ -68,5 +70,3 @@
 ```
 
 可以在[ORDER BY 子句](../query_language/select.md#query_language-queries-order_by) 查看更多关于 ` NaN` 排序的规则。
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/float/) <!--hide-->

docs/zh/data_types/index.md

@@ -4,6 +4,4 @@
 
 ClickHouse 可以在数据表中存储多种数据类型。
 
-本节将描述 ClickHouse 支持的数据类型以及在使用 与/或 运算实现他们时候的特殊考虑（如果有）。
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/) <!--hide-->
+本节描述 ClickHouse 支持的数据类型，以及使用或者实现它们时（如果有的话）的注意事项。

docs/zh/data_types/int_uint.md

@@ -17,6 +17,3 @@
 - UInt16 - [0 : 65535]
 - UInt32 - [0 : 4294967295]
 - UInt64 - [0 : 18446744073709551615]
-
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/int_uint/) <!--hide-->

docs/zh/data_types/nested_data_structures/aggregatefunction.md

@@ -1,5 +1,3 @@
 # AggregateFunction(name, types_of_arguments...)
 
 表示聚合函数中的中间状态。可以在聚合函数中通过 '-State' 后缀来访问它。更多信息，参考 "AggregatingMergeTree"。
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/nested_data_structures/aggregatefunction/) <!--hide-->

docs/zh/data_types/nested_data_structures/index.md

@@ -1,4 +1 @@
-# 嵌套数据类型
-
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/nested_data_structures/) <!--hide-->
+# 嵌套数据结构

docs/zh/data_types/nested_data_structures/nested.md

@@ -1,6 +1,6 @@
 # Nested(Name1 Type1, Name2 Type2, ...)
 
-类似嵌套表的嵌套数据结构。嵌套数据结构的参数（列名和列类型）与 CREATE 查询类似。每个表可以对应任意多行嵌套数据结构。
+嵌套数据结构类似于嵌套表。嵌套数据结构的参数（列名和类型）与 CREATE 查询类似。每个表可以包含任意多行嵌套数据结构。
 
 示例:
 
@@ -88,12 +88,10 @@ LIMIT 10
 └─────────┴─────────────────────┘
 ```
 
-不能对整个嵌套数据结构进行 SELECT 。只能显式地列出它的一部分列。
+不能对整个嵌套数据结构执行 SELECT。只能明确列出属于它一部分列。
 
 对于 INSERT 查询，可以单独地传入所有嵌套数据结构中的列数组（假如它们是单独的列数组）。在插入过程中，系统会检查它们是否有相同的长度。
 
 对于 DESCRIBE 查询，嵌套数据结构中的列会以相同的方式分别列出来。
 
-ALTER 查询对嵌套数据结构的操作非常局限。
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/nested_data_structures/nested/) <!--hide-->
+ALTER 查询对嵌套数据结构的操作非常有限。

docs/zh/data_types/nullable.md

@@ -2,10 +2,9 @@
 
 # Nullable(TypeName)
 
-允许加上一个符号 ([NULL](../query_language/syntax.md#null-literal)) 表示“缺失值”和 `TypeName` 允许的正常值。 例如，`Nullable（Int8）` 类型列可以存储 `Int8` 类型值，而没有值的行将存储 `NULL` 。
-
-对于`TypeName`，您不能使用复合数据类型 [Array](array.md#data_type is array) 和 [Tuple](tuple.md#data_type-tuple)。 复合数据类型可以包含 `Nullable` 类型值，例如 `Array (Nullable(Int8))`。
+允许用特殊标记 ([NULL](../query_language/syntax.md#null-literal)) 表示"缺失值"，可以与 `TypeName` 的正常值存放一起。例如，`Nullable(Int8)` 类型的列可以存储 `Int8` 类型值，而没有值的行将存储 `NULL`。
 
+对于 `TypeName`，不能使用复合数据类型 [Array](array.md#data_type is array) 和 [Tuple](tuple.md#data_type-tuple)。复合数据类型可以包含 `Nullable` 类型值，例如`Array(Nullable(Int8))`。
 
 `Nullable` 类型字段不能包含在表索引中。
 
@@ -15,11 +14,12 @@
 
 要在表的列中存储 `Nullable` 类型值，ClickHouse 除了使用带有值的普通文件外，还使用带有 `NULL` 掩码的单独文件。 掩码文件中的条目允许 ClickHouse 区分每个表行的 `NULL` 和相应数据类型的默认值。 由于附加了新文件，`Nullable` 列与类似的普通文件相比消耗额外的存储空间。
 
-!!! info "Note"
-    使用 `Nullable` 几乎总是会对性能产生负面影响，在设计数据库时请记住这一点。
+!!! 注意点
+    使用 `Nullable` 几乎总是对性能产生负面影响，在设计数据库时请记住这一点
 
+掩码文件中的条目允许ClickHouse区分每个表行的对应数据类型的"NULL"和默认值由于有额外的文件，"Nullable"列比普通列消耗更多的存储空间
 
-## 使用案例
+## 用法示例
 
 ```
 :) CREATE TABLE t_null(x Int8, y Nullable(Int8)) ENGINE TinyLog
@@ -55,5 +55,3 @@ FROM t_null
 
 2 rows in set. Elapsed: 0.144 sec.
 ```
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/nullable/) <!--hide-->

docs/zh/data_types/special_data_types/expression.md

@@ -1,5 +1,3 @@
 # Expression
 
-用在高阶函数中的 lambda 表达式中。
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/special_data_types/expression/) <!--hide-->
+用于表示高阶函数中的Lambd表达式。

docs/zh/data_types/special_data_types/index.md

@@ -1,5 +1,3 @@
 # Special Data Types
 
-特殊数据类型的值既不能存在表中也不能在结果中输出，但是可以被用于表示查询过程中的中间结果。
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/special_data_types/) <!--hide-->
+特殊数据类型的值既不能存在表中也不能在结果中输出，但可用于查询的中间结果。

docs/zh/data_types/special_data_types/nothing.md

@@ -2,11 +2,11 @@
 
 # Nothing
 
-此数据类型的唯一目的是表示不是期望值的情况。 所以你不能创建一个` Nothing` 类型的值。
+此数据类型的唯一目的是表示不是期望值的情况。 所以不能创建一个 `Nothing` 类型的值。
 
-例如， [NULL](../../query_language/syntax.md#null-literal) 有 `Nullable(Nothing)`。更多参见[Nullable](../../data_types/nullable.md#data_type-nullable).
+例如，文本 [NULL](../../query_language/syntax.md#null-literal) 的类型为 `Nullable(Nothing)`。详情请见 [Nullable](../../data_types/nullable.md#data_type-nullable)。
 
-`Nothing` 类型也可用于表示空数组：
+`Nothing` 类型也可以用来表示空数组：
 
 ```bash
 :) SELECT toTypeName(array())
@@ -19,6 +19,3 @@ SELECT toTypeName([])
 
 1 rows in set. Elapsed: 0.062 sec.
 ```
-
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/special_data_types/nothing/) <!--hide-->

docs/zh/data_types/special_data_types/set.md

@@ -1,5 +1,4 @@
 # Set
 
-可以用在 IN 表达式的右半边。
+可以用在 IN 表达式的右半部分。
 
-[来源文章](https://clickhouse.yandex/docs/en/data_types/special_data_types/set/) <!--hide-->

docs/zh/data_types/string.md

@@ -1,13 +1,13 @@
+<a name="data_types-string"></a>
+
 # String
 
-字符串可以任意长度的。它可以包含任意的字节组合，包括空字符。
-String 类型替代了其他 DBMSs 中的 VARCHAR， BLOB， CLOB 等类型。
+字符串可以任意长度的。它可以包含任意的字节集，包含空字节。因此，字符串类型可以代替其他 DBMSs 中的 VARCHAR、BLOB、CLOB 等类型。
 
 ## 编码
 
-ClickHouse 没有编码的概念。字符串可以是任意的字节组合，按它们原本的方式进行存储和输出。
+ClickHouse 没有编码的概念。字符串可以是任意的字节集，按它们原本的方式进行存储和输出。
 若需存储文本，我们建议使用 UTF-8 编码。至少，如果你的终端使用UTF-8（推荐），这样读写就不需要进行任何的转换了。
 同样，对不同的编码文本 ClickHouse 会有不同处理字符串的函数。
 比如，`length` 函数可以计算字符串包含的字节数组的长度，然而 `lengthUTF8` 函数是假设字符串以 UTF-8 编码，计算的是字符串包含的 Unicode 字符的长度。
 
-[来源文章](https://clickhouse.yandex/docs/en/data_types/string/) <!--hide-->

docs/zh/data_types/tuple.md

@@ -1,12 +1,16 @@
+<a name="data_type-tuple"></a>
+
 # Tuple(T1, T2, ...)
 
-元组，元组中的每个元素都有独立的[类型](index.md#data_types)。
+元组，其中每个元素都有单独的 [类型](index.md#data_types)。
 
-元组不能写入表中（除 Memory 表外）。它们会用于临时列分组。在某个查询中，IN 表达式和带特定参数的 lambda 函数可以来对临时列进行分组。更多信息，参见 [IN 操作符] (../query_language/select.md#in_operators)  和 [高阶函数](../query_language/functions/higher_order_functions.md#higher_order_functions)。
+不能在表中存储元组（除了内存表）。它们可以用于临时列分组。在查询中，IN 表达式和带特定参数的 lambda 函数可以来对临时列进行分组。更多信息，请参阅 [IN 操作符](../query_language/select.md#in_operators) and [Higher order functions](../query_language/functions/higher_order_functions.md#higher_order_functions)。
+
+元组可以是查询的结果。在这种情况下，对于JSON以外的文本格式，括号中的值是逗号分隔的。在JSON格式中，元组作为数组输出（在方括号中）。
 
 ## 创建元组
 
-可以用下面函数来创建元组：
+可以使用函数来创建元组：
 
 ```
 tuple(T1, T2, ...)
@@ -30,9 +34,9 @@ SELECT
 
 ## 元组中的数据类型
 
-当动态创建元组时，ClickHouse 会自动为元组的每一个参数赋予最小可表达的类型。如果该参数是 [NULL](../query_language/syntax.md#null-literal)，那么这个元组对应元素就是 [Nullable](nullable.md#data_type-nullable)。
+在动态创建元组时，ClickHouse 会自动为元组的每一个参数赋予最小可表达的类型。如果参数为 [NULL](../query_language/syntax.md#null-literal)，那这个元组对应元素是 [Nullable](nullable.md#data_type-nullable)。
 
-自动识别数据类型的示例：
+自动数据类型检测示例：
 
 ```
 SELECT tuple(1, NULL) AS x, toTypeName(x)
@@ -47,7 +51,3 @@ SELECT
 
 1 rows in set. Elapsed: 0.002 sec.
 ```
-
-
-[来源文章](https://clickhouse.yandex/docs/en/data_types/tuple/) <!--hide-->
-