This is an automated email from the ASF dual-hosted git repository.
morrysnow pushed a commit to branch polish_mysql_campati
in repository https://gitbox.apache.org/repos/asf/doris-website.git
commit 54d97281cd2670d1b965916099614cf03f0077ee
Author: morrySnow <zhangwen...@selectdb.com>
AuthorDate: Tue Dec 24 17:09:13 2024 +0800
[polish](MySQL-compatability) polish MySQL-compatability docs
---
docs/query-data/mysql-compatibility.md | 31 ++++++-----------
.../current/query-data/mysql-compatibility.md | 39 +++++++++-------------
.../version-2.1/query-data/mysql-compatibility.md | 37 ++++++++------------
.../version-3.0/query-data/mysql-compatibility.md | 39 +++++++++-------------
.../version-2.1/query-data/mysql-compatibility.md | 31 ++++++-----------
.../version-3.0/query-data/mysql-compatibility.md | 31 ++++++-----------
6 files changed, 77 insertions(+), 131 deletions(-)
diff --git a/docs/query-data/mysql-compatibility.md
b/docs/query-data/mysql-compatibility.md
index acd2386b70c..cc75d0eab49 100644
--- a/docs/query-data/mysql-compatibility.md
+++ b/docs/query-data/mysql-compatibility.md
@@ -79,44 +79,37 @@ Doris has several unique data types. Here are the details:
- **HyperLogLog**
- HLL (HyperLogLog) is a data type that cannot be used as a key column. It can
be used in aggregate, duplicate, and unique models. In an aggregate model
table, the corresponding aggregation type for HLL is HLL_UNION. The length and
default value do not need to be specified. The length is controlled internally
based on the data aggregation level. HLL columns can only be queried or used
with `HLL_UNION_AGG`, `HLL_RAW_AGG`, `HLL_CARDINALITY`, `HLL_HASH`, and other
related functions.
+ HLL (HyperLogLog) is a data type that cannot be used as a key column. In an
aggregate model table, the corresponding aggregation type for HLL is HLL_UNION.
The length and default value do not need to be specified. The length is
controlled internally based on the data aggregation level. HLL columns can only
be queried or used with `HLL_UNION_AGG`, `HLL_RAW_AGG`, `HLL_CARDINALITY`,
`HLL_HASH`, and other related functions.
HLL is used for approximate fuzzy deduplication and performs better than
count distinct when dealing with large amounts of data. The typical error rate
of HLL is around 1%, sometimes reaching up to 2%.
- **Bitmap**
- Bitmap is another data type in Doris. It can be used in aggregate, unique,
or duplicate models. In Unique or Duplicate models, it must be used as a
non-key column. In aggregate models, it must also be used as a non-key column,
and the corresponding aggregation type during table creation is BITMAP_UNION.
Similar to HLL, the length and default values do not need to be specified, and
the length is controlled internally based on the data aggregation level. Bitmap
columns can only be querie [...]
+ Bitmap is a data type that cannot be used as a key column. In aggregate
model table, the corresponding aggregation type for BITMAP is BITMAP_UNION.
Similar to HLL, the length and default values do not need to be specified, and
the length is controlled internally based on the data aggregation level. Bitmap
columns can only be queried or used with functions like `BITMAP_UNION_COUNT`,
`BITMAP_UNION`, `BITMAP_HASH`, `BITMAP_HASH64` and others.
Using BITMAP in traditional scenarios may impact loading speed, but it
generally performs better than Count Distinct when dealing with large amounts
of data. Please note that in real-time scenarios, using BITMAP without a global
dictionary and with bitmap_hash() function may introduce an error of around
0.1%. If this error is not acceptable, you can use bitmap_hash64 instead.
- **QUANTILE_PERCENT**
- QUANTILE_STATE is another data type in Doris, which cannot be used as a key
column. It can be used in aggregate, duplicate, and iuique models. In an
aggregate model table, the corresponding aggregation type for QUANTILE_STATE is
QUANTILE_UNION. The length and default value do not need to be specified, and
the length is controlled internally based on the data aggregation level.
QUANTILE_STATE columns can only be queried or used with functions like
`QUANTILE_PERCENT`, `QUANTILE_UNION`, ` [...]
+ QUANTILE_STATE is a data type that cannot be used as a key column. In an
aggregate model table, the corresponding aggregation type for QUANTILE_STATE is
QUANTILE_UNION. The length and default value do not need to be specified, and
the length is controlled internally based on the data aggregation level.
QUANTILE_STATE columns can only be queried or used with functions like
`QUANTILE_PERCENT`, `QUANTILE_UNION`, `TO_QUANTILE_STATE` and others.
QUANTILE_STATE is used for calculating approximate quantile values. During
import, it performs pre-aggregation on the same key with different values. When
the number of values does not exceed 2048, it stores all the data in detail.
When the number of values exceeds 2048, it uses the TDigest algorithm to
aggregate (cluster) the data and save the centroids of the clusters.
- **Array<T\>**
- Array is a data type in Doris that represents an array composed of elements
of type T. It cannot be used as a key column. Currently, it supports usage in
duplicate models and non-key column usage in unique models.
-
- The supported types for T are `BOOLEAN`, `TINYINT`, `SMALLINT`, `INT`,
`BIGINT`, `LARGEINT`, `FLOAT`, `DOUBLE`, `DECIMAL`, `DATE`, DATETIME, CHAR,
VARCHAR, and STRING.
+ Array is a data type in Doris that represents an array composed of elements
of type T. It cannot be used as a key column.
- **MAP<K, V\>**
- MAP is a data type in Doris that represents a map composed of elements of
types K and V. It cannot be used as a key column and can be used in both
duplicate and unique models.
-
- The supported types for K and V are `BOOLEAN`, `TINYINT`, `SMALLINT`, `INT`,
`BIGINT`, `LARGEINT`, `FLOAT`, `DOUBLE`, `DECIMAL`, `DATE`, `DATETIME`, `CHAR`,
`VARCHAR`, and `STRING`.
+ MAP is a data type in Doris that represents a map composed of elements of
types K and V.
- **STRUCT<field_name:field_type,...>**
- A structure (STRUCT) is composed of multiple fields. It can also be
identified as a collection of multiple columns. It cannot be used as a key and
is currently only supported in tables of the duplicate model.
+ A structure (STRUCT) is composed of multiple fields. It can also be
identified as a collection of multiple columns.
- field_name: The identifier of the field, which must be unique.
-
- field_type: The type of field.
- The supported types for fields are `BOOLEAN`, `TINYINT`, `SMALLINT`, `INT`,
`BIGINT`, `LARGEINT`, `FLOAT`, `DOUBLE`, `DECIMAL`, `DATE`, `DATETIME`, `CHAR`,
`VARCHAR`, and `STRING`.
-
- **Agg_State**
AGG_STATE is a data type in Doris that cannot be used as a key column. During
table creation, the signature of the aggregation function needs to be declared.
@@ -152,14 +145,14 @@ distribution_desc
| Parameter | Differences from MySQL
|
| ---------------------- |
------------------------------------------------------------ |
-| Column_definition_list | - Field list definition: The basic syntax is
similar to MySQL but includes an additional operation for aggregate types. <br
/>- The aggregate type operation primarily supports Aggregate and Duplicate
data models. <br />- When creating a table, MySQL allows adding constraints
like Index (e.g., Primary Key, Unique Key) after the field list definition,
while Doris supports these constraints and computations by defining data
models. |
+| Column_definition_list | - Field list definition: The basic syntax is
similar to MySQL but includes an additional operation for aggregate types. <br
/>- The aggregate type operation primarily supports Aggregate. <br />- When
creating a table, MySQL allows adding constraints like Index (e.g., Primary
Key, Unique Key) after the field list definition, while Doris supports these
constraints and computations by defining data models. |
| Index_definition_list | - Index list definition: The basic syntax is
similar to MySQL, supporting bitmap indexes, inverted indexes, and N-Gram
indexes, but Bloom filter indexes are set through properties. <br />- MySQL
supports B+Tree and Hash indexes. |
| Engine_type | - Table engine type: Optional. <br />- The
currently supported table engine is mainly the OLAP native engine. <br />-
MySQL supports storage engines such as Innodb, MyISAM, etc. |
| Keys_type | - Data model: Optional. <br />- Supported types
include: 1) DUPLICATE KEY (default): The specified columns are sort columns. 2)
AGGREGATE KEY: The specified columns are dimension columns. 3) UNIQUE KEY: The
specified columns are primary key columns. <br />- MySQL does not have the
concept of a data model. |
| Table_comment | Table comment
|
-| Partition_info | - Partitioning algorithm: Optional. Supported
partitioning algorithms include: <br /> LESS THAN: Only defines the upper bound
of partitions. The lower bound is determined by the upper bound of the previous
partition. FIXED RANGE: Defines left-closed and right-open intervals for
partitions. <br />- MULTI RANGE: Creates multiple RANGE partitions in bulk,
defining left-closed and right-open intervals, setting time units and steps.
Time units support years, months, [...]
+| Partition_info | - Partitioning algorithm: Optional. Doris supported
partitioning algorithms include: <br />- LESS THAN: Only defines the upper
bound of partitions. The lower bound is determined by the upper bound of the
previous partition.<br />- FIXED RANGE: Defines left-closed and right-open
intervals for partitions. <br />- MULTI RANGE: Creates multiple RANGE
partitions in bulk, defining left-closed and right-open intervals, setting time
units and steps. Time units support [...]
| Distribution_desc | - Bucketing algorithm: Required. Includes: 1) Hash
bucketing syntax: DISTRIBUTED BY HASH (k1[,k2 ...]) [BUCKETS num\|auto].
Description: Uses specified key columns for hash bucketing. 2) Random bucketing
syntax: DISTRIBUTED BY RANDOM [BUCKETS num\|auto]. Description: Uses random
numbers for bucketing. <br />- MySQL does not have a bucketing algorithm. |
-| Rollup_list | - Multiple materialized views can be created while
creating the table. <br />- Syntax: `rollup_name (col1[, col2, ...]) [DUPLICATE
KEY(col1[, col2, ...])][PROPERTIES("key" = "value")]` <br />- MySQL does not
support this. |
+| Rollup_list | - Multiple sync materialized views can be created
while creating the table. <br />- Syntax: `rollup_name (col1[, col2, ...])
[DUPLICATE KEY(col1[, col2, ...])][PROPERTIES("key" = "value")]` <br />- MySQL
does not support this. |
| Properties | Table properties: They differ from MySQL's table
properties, and the syntax for defining table properties also differs from
MySQL. |
@@ -193,10 +186,8 @@ CREATE MATERIALIZED VIEW (IF NOT EXISTS)?
mvName=multipartIdentifier
```
- The basic syntax is consistent with MySQL.
-
-- Doris supports two types of materialized views: synchronous materialized
views and asynchronous materialized views (supported for v2.1). The
asynchronous materialized views in Doris are more powerful.
-
-- MySQL only supports asynchronous materialized views.
+- Doris supports logical view and supports two types of materialized views:
synchronous materialized views and asynchronous materialized views
+- MySQL do not supports asynchronous materialized views.
#### 05 ALTER TABLE / ALTER INDEX
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/query-data/mysql-compatibility.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/query-data/mysql-compatibility.md
index 15685608ec6..9a620e0ab16 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/current/query-data/mysql-compatibility.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/current/query-data/mysql-compatibility.md
@@ -25,7 +25,7 @@ under the License.
-->
-Doris 是高度兼容 MySQL 语法，支持标准 SQL。但是 Doris 与 MySQL 还是有很多不同的地方，下面给出了他们的差异点介绍。
+Doris 高度兼容 MySQL 语法，支持标准 SQL。但是 Doris 与 MySQL 还是有很多不同的地方，下面给出了它们的差异点介绍。
## 数据类型
@@ -78,46 +78,39 @@ Doris 是高度兼容 MySQL 语法，支持标准 SQL。但是 Doris 与 MySQL
- **HyperLogLog**
- HLL 不能作为 Key 列使用，支持在 Aggregate 模型、Duplicate 模型和 Unique 模型的表中使用。在 Aggregate
模型表中使用时，建表时配合的聚合类型为 HLL_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且 HLL 列只能通过配套的
HLL_UNION_AGG、HLL_RAW_AGG、HLL_CARDINALITY、HLL_HASH 进行查询或使用。
+ HLL 类型不能作为 Key 列使用。在 Aggregate 模型表中使用时，建表时配合的聚合类型为
HLL_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且 HLL 列只能通过配套的
HLL_UNION_AGG、HLL_RAW_AGG、HLL_CARDINALITY、HLL_HASH 进行查询或使用。
HLL 是模糊去重，在处理大数据量时，其性能优于 Count Distinct。HLL 的误差率通常在 1% 左右，有时可能会达到 2%。
- **BITMAP**
- BITMAP 类型的列可以在 Aggregate 表、Unique 表或 Duplicate 表中使用，但必须作为非 Key 列。在 Unique 表或
Duplicate 表中使用时，同样需遵循此规则。在 Aggregate 表中使用时，还需配合 BITMAP_UNION
聚合类型。用户无需指定长度和默认值，长度会根据数据的聚合程度由系统内部控制。并且，BITMAP 列只能通过配套的
BITMAP_UNION_COUNT、BITMAP_UNION、BITMAP_HASH、BITMAP_HASH64 等函数进行查询或使用。
+ BITMAP 类型不能作为 Key 列使用。在 Aggregate 表中使用时，还需配合 BITMAP_UNION
聚合定义。用户无需指定长度和默认值，长度会根据数据的聚合程度由系统内部控制。并且，BITMAP 列只能通过配套的
BITMAP_UNION_COUNT、BITMAP_UNION、BITMAP_HASH、BITMAP_HASH64 等函数进行查询或使用。
离线场景下使用 BITMAP 可能会影响导入速度，在数据量大的情况下，其查询速度会慢于 HLL，但优于 Count
Distinct。注意：在实时场景下，如果 BITMAP 不使用全局字典，而使用了
BITMAP_HASH()，可能会导致约千分之一的误差。如果此误差不可接受，可以使用 BITMAP_HASH64。
- **QUANTILE_PERCENT（QUANTILE_STATE）**
- QUANTILE_STATE 不能作为 Key 列使用，支持在 Aggregate 模型、Duplicate 模型和 Unique 模型的表中使用。在
Aggregate 模型表中使用时，建表时配合的聚合类型为 QUANTILE_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且
QUANTILE_STATE 列只能通过配套的 QUANTILE_PERCENT、QUANTILE_UNION、TO_QUANTILE_STATE
等函数进行查询或使用。
+ QUANTILE_STATE 类型不能作为 Key 列使用。在 Aggregate 模型表中使用时，建表时配合的聚合类型为
QUANTILE_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且 QUANTILE_STATE 列只能通过配套的
QUANTILE_PERCENT、QUANTILE_UNION、TO_QUANTILE_STATE 等函数进行查询或使用。
QUANTILE_STATE 是一种计算分位数近似值的类型，在导入时会对相同的 Key，不同 Value 进行预聚合，当 Value 数量不超过
2048 时，会采用明细记录所有数据，当 Value 数量大于 2048 时采用
[TDigest](https://github.com/tdunning/t-digest/blob/main/docs/t-digest-paper/histo.pdf)
算法，对数据进行聚合（聚类），并保存聚类后的质心点。
- **Array<T\>**
- Array 由 T 类型元素组成的数组，不能作为 Key 列使用。目前支持在 Duplicate 模型的表中使用，也支持在 Unique 模型的表中非
Key 列使用。
-
- T 类型包括：BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE,
DECIMAL, DATE, DATETIME,CHAR, VARCHAR, STRING
+ Array 由 T 类型元素组成的数组，不能作为 Key 列使用。
- **MAP<K, V>**
- Map 是由 K, V 类型元素组成的映射表，不能作为 Key 列使用。目前支持在 Duplicate，Unique 模型的表中使用。
-
- K,V 支持的类型包括：BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT,
DOUBLE, DECIMAL, DATE, DATETIME, CHAR, VARCHAR, STRING
+ Map 是由 K, V 类型元素组成的映射表，不能作为 Key 列使用。
- **STRUCT<field_name:field_type, ... >**
- Struct 由多个 Field 组成的结构体，也可被理解为多个列的集合。不能作为 Key 使用，目前 Struct 仅支持在 Duplicate
模型的表中使用。
+ Struct 由多个 Field 组成的结构体，也可被理解为多个列的集合。不能作为 Key 使用。
一个 Struct 中的 Field 的名字和数量固定，且总是为 Nullable，一个 Field 通常由下面部分组成：
- field_name: Field 的标识符，不可重复
-
- field_type: Field 的类型
- 当前可支持的类型包括：BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE,
DECIMAL, DATE, DATETIME, CHAR, VARCHAR, STRING
-
- **Agg_State**
AGG_STATE 不能作为 Key 列使用，建表时需要同时声明聚合函数的签名。
@@ -154,14 +147,14 @@ distribution_desc
| 参数 | 与 MySQL 不同之处
|
| ---------------------- |
------------------------------------------------------------ |
-| column_definition_list | - 字段列表定义，其基本语法与 MySQL 类似，但会额外包含一个聚合类型的操作。<br />-
该聚合类型的操作，主要支持的数据模型为 Aggregate Key。<br />- 在创建表时，MySQL 允许在字段列表定义后添加 Index 等约束，如
Primary Key、Unique Key 等；而 Doris 则是通过定义数据模型来实现对这些约束和计算的支持。 |
-| index_definition_list | - 索引列表定义，基本语法与 MySQL 类似，支持位图索引、倒排索引和 N-Gram
索引，但是布隆过滤器索引是通过属性设置。<br />- 而 MySQL 支持的 index 有 B+Tree，Hash。 |
+| column_definition_list | - 字段列表定义，其基本语法与 MySQL 类似。<br />- Doris
额外包含一个聚合类型的操作，主要支持的数据模型为 Aggregate Key。<br />- MySQL 允许在字段列表定义后添加 Index 等约束，如
Primary Key、Unique Key 等；而 Doris 则是通过定义数据模型来实现对这些约束和计算的支持。 |
+| index_definition_list | - 索引列表定义，基本语法与 MySQL 类似 <br /> - MySQL 支持位图索引、倒排索引和
N-Gram 索引。另外可以通过属性设置布隆过滤器索引。<br />- MySQL 支持 B+Tree 索引和 Hash 索引。 |
| engine_type | - 表引擎类型，可选。<br />- 目前支持的表引擎主要是 OLAP 原生引擎。<br />-
MySQL 支持的存储引擎有：Innodb，MyISAM 等 |
| keys_type | - 数据模型，可选。<br />- 支持的类型包括：1）DUPLICATE
KEY（默认）：其后指定的列为排序列。2）AGGREGATE KEY：其后指定的列为维度列。3）UNIQUE KEY：其后指定的列为主键列。<br />-
MySQL 则没有数据模型的概念。 |
| table_comment | 表注释
|
-| partition_info | - 分区算法，可选。支持的分区算法，包括：<br /> LESS
THAN：仅定义分区上界。下界由上一个分区的上界决定。FIXED RANGE：定义分区的左闭右开区间。<br />- MULTI RANGE：批量创建
RANGE 分区，定义分区的左闭右开区间，设定时间单位和步长，时间单位支持年、月、日、周和小时。<br /> MULTI RANGE：批量创建数字类型的
RANGE 分区，定义分区的左闭右开区间，设定步长。<br />- MySQL
支持的算法：Hash，Range，List，并且还支持子分区，子分区支持的算法只有 Hash。 |
+| partition_info | 分区算法，可选。<br /> Doris 支持的分区算法，包括：<br />- LESS
THAN：仅定义分区上界。下界由上一个分区的上界决定。<br />- FIXED RANGE：定义分区的左闭右开区间。<br />- MULTI
RANGE：批量创建 RANGE 分区，定义分区的左闭右开区间，设定时间单位和步长，时间单位支持年、月、日、周和小时。<br /><br /> MySQL
支持的算法：Hash，Range，List Key，并且还支持子分区，子分区支持的算法有 Hash 和 Key。 |
| distribution_desc | - 分桶算法，必选，包括：1）Hash 分桶语法：DISTRIBUTED BY HASH
(k1[,k2 ...]) [BUCKETS num\|auto] 说明：使用指定的 key 列进行哈希分桶。2）Random
分桶语法：DISTRIBUTED BY RANDOM [BUCKETS num\|auto] 说明：使用随机数进行分桶。<br />- MySQL
没有分桶算法。 |
-| rollup_list | - 建表的同时可以创建多个物化视图。 <br />- 语法：`rollup_name (col1[,
col2, ...]) [DUPLICATE KEY(col1[, col2, ...])][PROPERTIES("key" = "value")]`
<br />- MySQL 不支持 |
+| rollup_list | - 建表的同时可以创建多个同步物化视图。 <br />- 语法：`rollup_name
(col1[, col2, ...]) [DUPLICATE KEY(col1[, col2, ...])][PROPERTIES("key" =
"value")]` <br />- MySQL 不支持 |
| properties | 表属性，与 MySQL 的表属性不一致，定义表属性的语法也与 MySQL 不一致 |
@@ -195,10 +188,8 @@ CREATE MATERIALIZED VIEW (IF NOT EXISTS)?
mvName=multipartIdentifier
```
- 基本语法与 MySQL 一致
-
-- Doris 支持两种物化视图，同步物化视图和异步物化视图（异步物化视图从 v2.1 开始支持）。Doris 的异步物化视图更加强大。
-
-- MySQL 仅支持异步物化视图
+- Doris 除了支持逻辑视图外，还支持两种物化视图，同步物化视图和异步物化视图
+- MySQL 不支持物化视图
**4 ALTER TABLE / ALTER INDEX**
@@ -259,7 +250,7 @@ DELETE FROM table_name [table_alias]
WHERE condition
```
-Doris 该语法只能在 UNique Key 模型表上使用。
+Doris 该语法只能在 Unique Key 模型表上使用。
Doris Delete 语法与 MySQL 基本一致。但是由于 Doris 是一个分析数据库，所以删除不能过于频繁。
@@ -288,4 +279,4 @@ Doris Select 语法与 MySQL 基本一致
## SQL Function
-Doris Function 基本覆盖绝大部分 MySQL Function。
\ No newline at end of file
+Doris Function 基本覆盖绝大部分 MySQL Function。
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/query-data/mysql-compatibility.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/query-data/mysql-compatibility.md
index 86eed3f819e..9a620e0ab16 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/query-data/mysql-compatibility.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-2.1/query-data/mysql-compatibility.md
@@ -25,7 +25,7 @@ under the License.
-->
-Doris 是高度兼容 MySQL 语法，支持标准 SQL。但是 Doris 与 MySQL 还是有很多不同的地方，下面给出了他们的差异点介绍。
+Doris 高度兼容 MySQL 语法，支持标准 SQL。但是 Doris 与 MySQL 还是有很多不同的地方，下面给出了它们的差异点介绍。
## 数据类型
@@ -78,46 +78,39 @@ Doris 是高度兼容 MySQL 语法，支持标准 SQL。但是 Doris 与 MySQL
- **HyperLogLog**
- HLL 不能作为 Key 列使用，支持在 Aggregate 模型、Duplicate 模型和 Unique 模型的表中使用。在 Aggregate
模型表中使用时，建表时配合的聚合类型为 HLL_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且 HLL 列只能通过配套的
HLL_UNION_AGG、HLL_RAW_AGG、HLL_CARDINALITY、HLL_HASH 进行查询或使用。
+ HLL 类型不能作为 Key 列使用。在 Aggregate 模型表中使用时，建表时配合的聚合类型为
HLL_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且 HLL 列只能通过配套的
HLL_UNION_AGG、HLL_RAW_AGG、HLL_CARDINALITY、HLL_HASH 进行查询或使用。
HLL 是模糊去重，在处理大数据量时，其性能优于 Count Distinct。HLL 的误差率通常在 1% 左右，有时可能会达到 2%。
- **BITMAP**
- BITMAP 类型的列可以在 Aggregate 表、Unique 表或 Duplicate 表中使用，但必须作为非 Key 列。在 Unique 表或
Duplicate 表中使用时，同样需遵循此规则。在 Aggregate 表中使用时，还需配合 BITMAP_UNION
聚合类型。用户无需指定长度和默认值，长度会根据数据的聚合程度由系统内部控制。并且，BITMAP 列只能通过配套的
BITMAP_UNION_COUNT、BITMAP_UNION、BITMAP_HASH、BITMAP_HASH64 等函数进行查询或使用。
+ BITMAP 类型不能作为 Key 列使用。在 Aggregate 表中使用时，还需配合 BITMAP_UNION
聚合定义。用户无需指定长度和默认值，长度会根据数据的聚合程度由系统内部控制。并且，BITMAP 列只能通过配套的
BITMAP_UNION_COUNT、BITMAP_UNION、BITMAP_HASH、BITMAP_HASH64 等函数进行查询或使用。
离线场景下使用 BITMAP 可能会影响导入速度，在数据量大的情况下，其查询速度会慢于 HLL，但优于 Count
Distinct。注意：在实时场景下，如果 BITMAP 不使用全局字典，而使用了
BITMAP_HASH()，可能会导致约千分之一的误差。如果此误差不可接受，可以使用 BITMAP_HASH64。
- **QUANTILE_PERCENT（QUANTILE_STATE）**
- QUANTILE_STATE 不能作为 Key 列使用，支持在 Aggregate 模型、Duplicate 模型和 Unique 模型的表中使用。在
Aggregate 模型表中使用时，建表时配合的聚合类型为 QUANTILE_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且
QUANTILE_STATE 列只能通过配套的 QUANTILE_PERCENT、QUANTILE_UNION、TO_QUANTILE_STATE
等函数进行查询或使用。
+ QUANTILE_STATE 类型不能作为 Key 列使用。在 Aggregate 模型表中使用时，建表时配合的聚合类型为
QUANTILE_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且 QUANTILE_STATE 列只能通过配套的
QUANTILE_PERCENT、QUANTILE_UNION、TO_QUANTILE_STATE 等函数进行查询或使用。
QUANTILE_STATE 是一种计算分位数近似值的类型，在导入时会对相同的 Key，不同 Value 进行预聚合，当 Value 数量不超过
2048 时，会采用明细记录所有数据，当 Value 数量大于 2048 时采用
[TDigest](https://github.com/tdunning/t-digest/blob/main/docs/t-digest-paper/histo.pdf)
算法，对数据进行聚合（聚类），并保存聚类后的质心点。
- **Array<T\>**
- Array 由 T 类型元素组成的数组，不能作为 Key 列使用。目前支持在 Duplicate 模型的表中使用，也支持在 Unique 模型的表中非
Key 列使用。
-
- T 类型包括：BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE,
DECIMAL, DATE, DATETIME,CHAR, VARCHAR, STRING
+ Array 由 T 类型元素组成的数组，不能作为 Key 列使用。
- **MAP<K, V>**
- Map 是由 K, V 类型元素组成的映射表，不能作为 Key 列使用。目前支持在 Duplicate，Unique 模型的表中使用。
-
- K,V 支持的类型包括：BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT,
DOUBLE, DECIMAL, DATE, DATETIME, CHAR, VARCHAR, STRING
+ Map 是由 K, V 类型元素组成的映射表，不能作为 Key 列使用。
- **STRUCT<field_name:field_type, ... >**
- Struct 由多个 Field 组成的结构体，也可被理解为多个列的集合。不能作为 Key 使用，目前 Struct 仅支持在 Duplicate
模型的表中使用。
+ Struct 由多个 Field 组成的结构体，也可被理解为多个列的集合。不能作为 Key 使用。
一个 Struct 中的 Field 的名字和数量固定，且总是为 Nullable，一个 Field 通常由下面部分组成：
- field_name: Field 的标识符，不可重复
-
- field_type: Field 的类型
- 当前可支持的类型包括：BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE,
DECIMAL, DATE, DATETIME, CHAR, VARCHAR, STRING
-
- **Agg_State**
AGG_STATE 不能作为 Key 列使用，建表时需要同时声明聚合函数的签名。
@@ -154,14 +147,14 @@ distribution_desc
| 参数 | 与 MySQL 不同之处
|
| ---------------------- |
------------------------------------------------------------ |
-| column_definition_list | - 字段列表定义，其基本语法与 MySQL 类似，但会额外包含一个聚合类型的操作。<br />-
该聚合类型的操作，主要支持的数据模型为 Aggregate Key。<br />- 在创建表时，MySQL 允许在字段列表定义后添加 Index 等约束，如
Primary Key、Unique Key 等；而 Doris 则是通过定义数据模型来实现对这些约束和计算的支持。 |
-| index_definition_list | - 索引列表定义，基本语法与 MySQL 类似，支持位图索引、倒排索引和 N-Gram
索引，但是布隆过滤器索引是通过属性设置。<br />- 而 MySQL 支持的 index 有 B+Tree，Hash。 |
+| column_definition_list | - 字段列表定义，其基本语法与 MySQL 类似。<br />- Doris
额外包含一个聚合类型的操作，主要支持的数据模型为 Aggregate Key。<br />- MySQL 允许在字段列表定义后添加 Index 等约束，如
Primary Key、Unique Key 等；而 Doris 则是通过定义数据模型来实现对这些约束和计算的支持。 |
+| index_definition_list | - 索引列表定义，基本语法与 MySQL 类似 <br /> - MySQL 支持位图索引、倒排索引和
N-Gram 索引。另外可以通过属性设置布隆过滤器索引。<br />- MySQL 支持 B+Tree 索引和 Hash 索引。 |
| engine_type | - 表引擎类型，可选。<br />- 目前支持的表引擎主要是 OLAP 原生引擎。<br />-
MySQL 支持的存储引擎有：Innodb，MyISAM 等 |
| keys_type | - 数据模型，可选。<br />- 支持的类型包括：1）DUPLICATE
KEY（默认）：其后指定的列为排序列。2）AGGREGATE KEY：其后指定的列为维度列。3）UNIQUE KEY：其后指定的列为主键列。<br />-
MySQL 则没有数据模型的概念。 |
| table_comment | 表注释
|
-| partition_info | - 分区算法，可选。支持的分区算法，包括：<br /> LESS
THAN：仅定义分区上界。下界由上一个分区的上界决定。FIXED RANGE：定义分区的左闭右开区间。<br />- MULTI RANGE：批量创建
RANGE 分区，定义分区的左闭右开区间，设定时间单位和步长，时间单位支持年、月、日、周和小时。<br /> MULTI RANGE：批量创建数字类型的
RANGE 分区，定义分区的左闭右开区间，设定步长。<br />- MySQL
支持的算法：Hash，Range，List，并且还支持子分区，子分区支持的算法只有 Hash。 |
+| partition_info | 分区算法，可选。<br /> Doris 支持的分区算法，包括：<br />- LESS
THAN：仅定义分区上界。下界由上一个分区的上界决定。<br />- FIXED RANGE：定义分区的左闭右开区间。<br />- MULTI
RANGE：批量创建 RANGE 分区，定义分区的左闭右开区间，设定时间单位和步长，时间单位支持年、月、日、周和小时。<br /><br /> MySQL
支持的算法：Hash，Range，List Key，并且还支持子分区，子分区支持的算法有 Hash 和 Key。 |
| distribution_desc | - 分桶算法，必选，包括：1）Hash 分桶语法：DISTRIBUTED BY HASH
(k1[,k2 ...]) [BUCKETS num\|auto] 说明：使用指定的 key 列进行哈希分桶。2）Random
分桶语法：DISTRIBUTED BY RANDOM [BUCKETS num\|auto] 说明：使用随机数进行分桶。<br />- MySQL
没有分桶算法。 |
-| rollup_list | - 建表的同时可以创建多个物化视图。 <br />- 语法：`rollup_name (col1[,
col2, ...]) [DUPLICATE KEY(col1[, col2, ...])][PROPERTIES("key" = "value")]`
<br />- MySQL 不支持 |
+| rollup_list | - 建表的同时可以创建多个同步物化视图。 <br />- 语法：`rollup_name
(col1[, col2, ...]) [DUPLICATE KEY(col1[, col2, ...])][PROPERTIES("key" =
"value")]` <br />- MySQL 不支持 |
| properties | 表属性，与 MySQL 的表属性不一致，定义表属性的语法也与 MySQL 不一致 |
@@ -195,10 +188,8 @@ CREATE MATERIALIZED VIEW (IF NOT EXISTS)?
mvName=multipartIdentifier
```
- 基本语法与 MySQL 一致
-
-- Doris 支持两种物化视图，同步物化视图和异步物化视图（异步物化视图从 v2.1 开始支持）。Doris 的异步物化视图更加强大。
-
-- MySQL 仅支持异步物化视图
+- Doris 除了支持逻辑视图外，还支持两种物化视图，同步物化视图和异步物化视图
+- MySQL 不支持物化视图
**4 ALTER TABLE / ALTER INDEX**
@@ -259,7 +250,7 @@ DELETE FROM table_name [table_alias]
WHERE condition
```
-Doris 该语法只能在 UNique Key 模型表上使用。
+Doris 该语法只能在 Unique Key 模型表上使用。
Doris Delete 语法与 MySQL 基本一致。但是由于 Doris 是一个分析数据库，所以删除不能过于频繁。
diff --git
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/query-data/mysql-compatibility.md
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/query-data/mysql-compatibility.md
index 15685608ec6..9a620e0ab16 100644
---
a/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/query-data/mysql-compatibility.md
+++
b/i18n/zh-CN/docusaurus-plugin-content-docs/version-3.0/query-data/mysql-compatibility.md
@@ -25,7 +25,7 @@ under the License.
-->
-Doris 是高度兼容 MySQL 语法，支持标准 SQL。但是 Doris 与 MySQL 还是有很多不同的地方，下面给出了他们的差异点介绍。
+Doris 高度兼容 MySQL 语法，支持标准 SQL。但是 Doris 与 MySQL 还是有很多不同的地方，下面给出了它们的差异点介绍。
## 数据类型
@@ -78,46 +78,39 @@ Doris 是高度兼容 MySQL 语法，支持标准 SQL。但是 Doris 与 MySQL
- **HyperLogLog**
- HLL 不能作为 Key 列使用，支持在 Aggregate 模型、Duplicate 模型和 Unique 模型的表中使用。在 Aggregate
模型表中使用时，建表时配合的聚合类型为 HLL_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且 HLL 列只能通过配套的
HLL_UNION_AGG、HLL_RAW_AGG、HLL_CARDINALITY、HLL_HASH 进行查询或使用。
+ HLL 类型不能作为 Key 列使用。在 Aggregate 模型表中使用时，建表时配合的聚合类型为
HLL_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且 HLL 列只能通过配套的
HLL_UNION_AGG、HLL_RAW_AGG、HLL_CARDINALITY、HLL_HASH 进行查询或使用。
HLL 是模糊去重，在处理大数据量时，其性能优于 Count Distinct。HLL 的误差率通常在 1% 左右，有时可能会达到 2%。
- **BITMAP**
- BITMAP 类型的列可以在 Aggregate 表、Unique 表或 Duplicate 表中使用，但必须作为非 Key 列。在 Unique 表或
Duplicate 表中使用时，同样需遵循此规则。在 Aggregate 表中使用时，还需配合 BITMAP_UNION
聚合类型。用户无需指定长度和默认值，长度会根据数据的聚合程度由系统内部控制。并且，BITMAP 列只能通过配套的
BITMAP_UNION_COUNT、BITMAP_UNION、BITMAP_HASH、BITMAP_HASH64 等函数进行查询或使用。
+ BITMAP 类型不能作为 Key 列使用。在 Aggregate 表中使用时，还需配合 BITMAP_UNION
聚合定义。用户无需指定长度和默认值，长度会根据数据的聚合程度由系统内部控制。并且，BITMAP 列只能通过配套的
BITMAP_UNION_COUNT、BITMAP_UNION、BITMAP_HASH、BITMAP_HASH64 等函数进行查询或使用。
离线场景下使用 BITMAP 可能会影响导入速度，在数据量大的情况下，其查询速度会慢于 HLL，但优于 Count
Distinct。注意：在实时场景下，如果 BITMAP 不使用全局字典，而使用了
BITMAP_HASH()，可能会导致约千分之一的误差。如果此误差不可接受，可以使用 BITMAP_HASH64。
- **QUANTILE_PERCENT（QUANTILE_STATE）**
- QUANTILE_STATE 不能作为 Key 列使用，支持在 Aggregate 模型、Duplicate 模型和 Unique 模型的表中使用。在
Aggregate 模型表中使用时，建表时配合的聚合类型为 QUANTILE_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且
QUANTILE_STATE 列只能通过配套的 QUANTILE_PERCENT、QUANTILE_UNION、TO_QUANTILE_STATE
等函数进行查询或使用。
+ QUANTILE_STATE 类型不能作为 Key 列使用。在 Aggregate 模型表中使用时，建表时配合的聚合类型为
QUANTILE_UNION。用户不需要指定长度和默认值。长度根据数据的聚合程度系统内控制。并且 QUANTILE_STATE 列只能通过配套的
QUANTILE_PERCENT、QUANTILE_UNION、TO_QUANTILE_STATE 等函数进行查询或使用。
QUANTILE_STATE 是一种计算分位数近似值的类型，在导入时会对相同的 Key，不同 Value 进行预聚合，当 Value 数量不超过
2048 时，会采用明细记录所有数据，当 Value 数量大于 2048 时采用
[TDigest](https://github.com/tdunning/t-digest/blob/main/docs/t-digest-paper/histo.pdf)
算法，对数据进行聚合（聚类），并保存聚类后的质心点。
- **Array<T\>**
- Array 由 T 类型元素组成的数组，不能作为 Key 列使用。目前支持在 Duplicate 模型的表中使用，也支持在 Unique 模型的表中非
Key 列使用。
-
- T 类型包括：BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE,
DECIMAL, DATE, DATETIME,CHAR, VARCHAR, STRING
+ Array 由 T 类型元素组成的数组，不能作为 Key 列使用。
- **MAP<K, V>**
- Map 是由 K, V 类型元素组成的映射表，不能作为 Key 列使用。目前支持在 Duplicate，Unique 模型的表中使用。
-
- K,V 支持的类型包括：BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT,
DOUBLE, DECIMAL, DATE, DATETIME, CHAR, VARCHAR, STRING
+ Map 是由 K, V 类型元素组成的映射表，不能作为 Key 列使用。
- **STRUCT<field_name:field_type, ... >**
- Struct 由多个 Field 组成的结构体，也可被理解为多个列的集合。不能作为 Key 使用，目前 Struct 仅支持在 Duplicate
模型的表中使用。
+ Struct 由多个 Field 组成的结构体，也可被理解为多个列的集合。不能作为 Key 使用。
一个 Struct 中的 Field 的名字和数量固定，且总是为 Nullable，一个 Field 通常由下面部分组成：
- field_name: Field 的标识符，不可重复
-
- field_type: Field 的类型
- 当前可支持的类型包括：BOOLEAN, TINYINT, SMALLINT, INT, BIGINT, LARGEINT, FLOAT, DOUBLE,
DECIMAL, DATE, DATETIME, CHAR, VARCHAR, STRING
-
- **Agg_State**
AGG_STATE 不能作为 Key 列使用，建表时需要同时声明聚合函数的签名。
@@ -154,14 +147,14 @@ distribution_desc
| 参数 | 与 MySQL 不同之处
|
| ---------------------- |
------------------------------------------------------------ |
-| column_definition_list | - 字段列表定义，其基本语法与 MySQL 类似，但会额外包含一个聚合类型的操作。<br />-
该聚合类型的操作，主要支持的数据模型为 Aggregate Key。<br />- 在创建表时，MySQL 允许在字段列表定义后添加 Index 等约束，如
Primary Key、Unique Key 等；而 Doris 则是通过定义数据模型来实现对这些约束和计算的支持。 |
-| index_definition_list | - 索引列表定义，基本语法与 MySQL 类似，支持位图索引、倒排索引和 N-Gram
索引，但是布隆过滤器索引是通过属性设置。<br />- 而 MySQL 支持的 index 有 B+Tree，Hash。 |
+| column_definition_list | - 字段列表定义，其基本语法与 MySQL 类似。<br />- Doris
额外包含一个聚合类型的操作，主要支持的数据模型为 Aggregate Key。<br />- MySQL 允许在字段列表定义后添加 Index 等约束，如
Primary Key、Unique Key 等；而 Doris 则是通过定义数据模型来实现对这些约束和计算的支持。 |
+| index_definition_list | - 索引列表定义，基本语法与 MySQL 类似 <br /> - MySQL 支持位图索引、倒排索引和
N-Gram 索引。另外可以通过属性设置布隆过滤器索引。<br />- MySQL 支持 B+Tree 索引和 Hash 索引。 |
| engine_type | - 表引擎类型，可选。<br />- 目前支持的表引擎主要是 OLAP 原生引擎。<br />-
MySQL 支持的存储引擎有：Innodb，MyISAM 等 |
| keys_type | - 数据模型，可选。<br />- 支持的类型包括：1）DUPLICATE
KEY（默认）：其后指定的列为排序列。2）AGGREGATE KEY：其后指定的列为维度列。3）UNIQUE KEY：其后指定的列为主键列。<br />-
MySQL 则没有数据模型的概念。 |
| table_comment | 表注释
|
-| partition_info | - 分区算法，可选。支持的分区算法，包括：<br /> LESS
THAN：仅定义分区上界。下界由上一个分区的上界决定。FIXED RANGE：定义分区的左闭右开区间。<br />- MULTI RANGE：批量创建
RANGE 分区，定义分区的左闭右开区间，设定时间单位和步长，时间单位支持年、月、日、周和小时。<br /> MULTI RANGE：批量创建数字类型的
RANGE 分区，定义分区的左闭右开区间，设定步长。<br />- MySQL
支持的算法：Hash，Range，List，并且还支持子分区，子分区支持的算法只有 Hash。 |
+| partition_info | 分区算法，可选。<br /> Doris 支持的分区算法，包括：<br />- LESS
THAN：仅定义分区上界。下界由上一个分区的上界决定。<br />- FIXED RANGE：定义分区的左闭右开区间。<br />- MULTI
RANGE：批量创建 RANGE 分区，定义分区的左闭右开区间，设定时间单位和步长，时间单位支持年、月、日、周和小时。<br /><br /> MySQL
支持的算法：Hash，Range，List Key，并且还支持子分区，子分区支持的算法有 Hash 和 Key。 |
| distribution_desc | - 分桶算法，必选，包括：1）Hash 分桶语法：DISTRIBUTED BY HASH
(k1[,k2 ...]) [BUCKETS num\|auto] 说明：使用指定的 key 列进行哈希分桶。2）Random
分桶语法：DISTRIBUTED BY RANDOM [BUCKETS num\|auto] 说明：使用随机数进行分桶。<br />- MySQL
没有分桶算法。 |
-| rollup_list | - 建表的同时可以创建多个物化视图。 <br />- 语法：`rollup_name (col1[,
col2, ...]) [DUPLICATE KEY(col1[, col2, ...])][PROPERTIES("key" = "value")]`
<br />- MySQL 不支持 |
+| rollup_list | - 建表的同时可以创建多个同步物化视图。 <br />- 语法：`rollup_name
(col1[, col2, ...]) [DUPLICATE KEY(col1[, col2, ...])][PROPERTIES("key" =
"value")]` <br />- MySQL 不支持 |
| properties | 表属性，与 MySQL 的表属性不一致，定义表属性的语法也与 MySQL 不一致 |
@@ -195,10 +188,8 @@ CREATE MATERIALIZED VIEW (IF NOT EXISTS)?
mvName=multipartIdentifier
```
- 基本语法与 MySQL 一致
-
-- Doris 支持两种物化视图，同步物化视图和异步物化视图（异步物化视图从 v2.1 开始支持）。Doris 的异步物化视图更加强大。
-
-- MySQL 仅支持异步物化视图
+- Doris 除了支持逻辑视图外，还支持两种物化视图，同步物化视图和异步物化视图
+- MySQL 不支持物化视图
**4 ALTER TABLE / ALTER INDEX**
@@ -259,7 +250,7 @@ DELETE FROM table_name [table_alias]
WHERE condition
```
-Doris 该语法只能在 UNique Key 模型表上使用。
+Doris 该语法只能在 Unique Key 模型表上使用。
Doris Delete 语法与 MySQL 基本一致。但是由于 Doris 是一个分析数据库，所以删除不能过于频繁。
@@ -288,4 +279,4 @@ Doris Select 语法与 MySQL 基本一致
## SQL Function
-Doris Function 基本覆盖绝大部分 MySQL Function。
\ No newline at end of file
+Doris Function 基本覆盖绝大部分 MySQL Function。
diff --git a/versioned_docs/version-2.1/query-data/mysql-compatibility.md
b/versioned_docs/version-2.1/query-data/mysql-compatibility.md
index 5dfffc284ee..6beea3254e8 100644
--- a/versioned_docs/version-2.1/query-data/mysql-compatibility.md
+++ b/versioned_docs/version-2.1/query-data/mysql-compatibility.md
@@ -79,44 +79,37 @@ Doris has several unique data types. Here are the details:
- **HyperLogLog**
- HLL (HyperLogLog) is a data type that cannot be used as a key column. It can
be used in aggregate, duplicate, and unique models. In an aggregate model
table, the corresponding aggregation type for HLL is HLL_UNION. The length and
default value do not need to be specified. The length is controlled internally
based on the data aggregation level. HLL columns can only be queried or used
with `HLL_UNION_AGG`, `HLL_RAW_AGG`, `HLL_CARDINALITY`, `HLL_HASH`, and other
related functions.
+ HLL (HyperLogLog) is a data type that cannot be used as a key column. In an
aggregate model table, the corresponding aggregation type for HLL is HLL_UNION.
The length and default value do not need to be specified. The length is
controlled internally based on the data aggregation level. HLL columns can only
be queried or used with `HLL_UNION_AGG`, `HLL_RAW_AGG`, `HLL_CARDINALITY`,
`HLL_HASH`, and other related functions.
HLL is used for approximate fuzzy deduplication and performs better than
count distinct when dealing with large amounts of data. The typical error rate
of HLL is around 1%, sometimes reaching up to 2%.
- **Bitmap**
- Bitmap is another data type in Doris. It can be used in aggregate, unique,
or duplicate models. In Unique or Duplicate models, it must be used as a
non-key column. In aggregate models, it must also be used as a non-key column,
and the corresponding aggregation type during table creation is BITMAP_UNION.
Similar to HLL, the length and default values do not need to be specified, and
the length is controlled internally based on the data aggregation level. Bitmap
columns can only be querie [...]
+ Bitmap is a data type that cannot be used as a key column. In aggregate
model table, the corresponding aggregation type for BITMAP is BITMAP_UNION.
Similar to HLL, the length and default values do not need to be specified, and
the length is controlled internally based on the data aggregation level. Bitmap
columns can only be queried or used with functions like `BITMAP_UNION_COUNT`,
`BITMAP_UNION`, `BITMAP_HASH`, `BITMAP_HASH64` and others.
Using BITMAP in traditional scenarios may impact loading speed, but it
generally performs better than Count Distinct when dealing with large amounts
of data. Please note that in real-time scenarios, using BITMAP without a global
dictionary and with bitmap_hash() function may introduce an error of around
0.1%. If this error is not acceptable, you can use bitmap_hash64 instead.
- **QUANTILE_PERCENT**
- QUANTILE_STATE is another data type in Doris, which cannot be used as a key
column. It can be used in aggregate, duplicate, and iuique models. In an
aggregate model table, the corresponding aggregation type for QUANTILE_STATE is
QUANTILE_UNION. The length and default value do not need to be specified, and
the length is controlled internally based on the data aggregation level.
QUANTILE_STATE columns can only be queried or used with functions like
`QUANTILE_PERCENT`, `QUANTILE_UNION`, ` [...]
+ QUANTILE_STATE is a data type that cannot be used as a key column. In an
aggregate model table, the corresponding aggregation type for QUANTILE_STATE is
QUANTILE_UNION. The length and default value do not need to be specified, and
the length is controlled internally based on the data aggregation level.
QUANTILE_STATE columns can only be queried or used with functions like
`QUANTILE_PERCENT`, `QUANTILE_UNION`, `TO_QUANTILE_STATE` and others.
QUANTILE_STATE is used for calculating approximate quantile values. During
import, it performs pre-aggregation on the same key with different values. When
the number of values does not exceed 2048, it stores all the data in detail.
When the number of values exceeds 2048, it uses the TDigest algorithm to
aggregate (cluster) the data and save the centroids of the clusters.
- **Array<T\>**
- Array is a data type in Doris that represents an array composed of elements
of type T. It cannot be used as a key column. Currently, it supports usage in
duplicate models and non-key column usage in unique models.
-
- The supported types for T are `BOOLEAN`, `TINYINT`, `SMALLINT`, `INT`,
`BIGINT`, `LARGEINT`, `FLOAT`, `DOUBLE`, `DECIMAL`, `DATE`, DATETIME, CHAR,
VARCHAR, and STRING.
+ Array is a data type in Doris that represents an array composed of elements
of type T. It cannot be used as a key column.
- **MAP<K, V\>**
- MAP is a data type in Doris that represents a map composed of elements of
types K and V. It cannot be used as a key column and can be used in both
duplicate and unique models.
-
- The supported types for K and V are `BOOLEAN`, `TINYINT`, `SMALLINT`, `INT`,
`BIGINT`, `LARGEINT`, `FLOAT`, `DOUBLE`, `DECIMAL`, `DATE`, `DATETIME`, `CHAR`,
`VARCHAR`, and `STRING`.
+ MAP is a data type in Doris that represents a map composed of elements of
types K and V.
- **STRUCT<field_name:field_type,...>**
- A structure (STRUCT) is composed of multiple fields. It can also be
identified as a collection of multiple columns. It cannot be used as a key and
is currently only supported in tables of the duplicate model.
+ A structure (STRUCT) is composed of multiple fields. It can also be
identified as a collection of multiple columns.
- field_name: The identifier of the field, which must be unique.
-
- field_type: The type of field.
- The supported types for fields are `BOOLEAN`, `TINYINT`, `SMALLINT`, `INT`,
`BIGINT`, `LARGEINT`, `FLOAT`, `DOUBLE`, `DECIMAL`, `DATE`, `DATETIME`, `CHAR`,
`VARCHAR`, and `STRING`.
-
- **Agg_State**
AGG_STATE is a data type in Doris that cannot be used as a key column. During
table creation, the signature of the aggregation function needs to be declared.
@@ -152,14 +145,14 @@ distribution_desc
| Parameter | Differences from MySQL
|
| ---------------------- |
------------------------------------------------------------ |
-| Column_definition_list | - Field list definition: The basic syntax is
similar to MySQL but includes an additional operation for aggregate types. <br
/>- The aggregate type operation primarily supports Aggregate Key. <br />- When
creating a table, MySQL allows adding constraints like Index (e.g., Primary
Key, Unique Key) after the field list definition, while Doris supports these
constraints and computations by defining data models. |
+| Column_definition_list | - Field list definition: The basic syntax is
similar to MySQL but includes an additional operation for aggregate types. <br
/>- The aggregate type operation primarily supports Aggregate. <br />- When
creating a table, MySQL allows adding constraints like Index (e.g., Primary
Key, Unique Key) after the field list definition, while Doris supports these
constraints and computations by defining data models. |
| Index_definition_list | - Index list definition: The basic syntax is
similar to MySQL, supporting bitmap indexes, inverted indexes, and N-Gram
indexes, but Bloom filter indexes are set through properties. <br />- MySQL
supports B+Tree and Hash indexes. |
| Engine_type | - Table engine type: Optional. <br />- The
currently supported table engine is mainly the OLAP native engine. <br />-
MySQL supports storage engines such as Innodb, MyISAM, etc. |
| Keys_type | - Data model: Optional. <br />- Supported types
include: 1) DUPLICATE KEY (default): The specified columns are sort columns. 2)
AGGREGATE KEY: The specified columns are dimension columns. 3) UNIQUE KEY: The
specified columns are primary key columns. <br />- MySQL does not have the
concept of a data model. |
| Table_comment | Table comment
|
-| Partition_info | - Partitioning algorithm: Optional. Supported
partitioning algorithms include: <br /> LESS THAN: Only defines the upper bound
of partitions. The lower bound is determined by the upper bound of the previous
partition. FIXED RANGE: Defines left-closed and right-open intervals for
partitions. <br />- MULTI RANGE: Creates multiple RANGE partitions in bulk,
defining left-closed and right-open intervals, setting time units and steps.
Time units support years, months, [...]
+| Partition_info | - Partitioning algorithm: Optional. Doris supported
partitioning algorithms include: <br />- LESS THAN: Only defines the upper
bound of partitions. The lower bound is determined by the upper bound of the
previous partition.<br />- FIXED RANGE: Defines left-closed and right-open
intervals for partitions. <br />- MULTI RANGE: Creates multiple RANGE
partitions in bulk, defining left-closed and right-open intervals, setting time
units and steps. Time units support [...]
| Distribution_desc | - Bucketing algorithm: Required. Includes: 1) Hash
bucketing syntax: DISTRIBUTED BY HASH (k1[,k2 ...]) [BUCKETS num\|auto].
Description: Uses specified key columns for hash bucketing. 2) Random bucketing
syntax: DISTRIBUTED BY RANDOM [BUCKETS num\|auto]. Description: Uses random
numbers for bucketing. <br />- MySQL does not have a bucketing algorithm. |
-| Rollup_list | - Multiple materialized views can be created while
creating the table. <br />- Syntax: `rollup_name (col1[, col2, ...]) [DUPLICATE
KEY(col1[, col2, ...])][PROPERTIES("key" = "value")]` <br />- MySQL does not
support this. |
+| Rollup_list | - Multiple sync materialized views can be created
while creating the table. <br />- Syntax: `rollup_name (col1[, col2, ...])
[DUPLICATE KEY(col1[, col2, ...])][PROPERTIES("key" = "value")]` <br />- MySQL
does not support this. |
| Properties | Table properties: They differ from MySQL's table
properties, and the syntax for defining table properties also differs from
MySQL. |
@@ -193,10 +186,8 @@ CREATE MATERIALIZED VIEW (IF NOT EXISTS)?
mvName=multipartIdentifier
```
- The basic syntax is consistent with MySQL.
-
-- Doris supports two types of materialized views: synchronous materialized
views and asynchronous materialized views (supported for v2.1). The
asynchronous materialized views in Doris are more powerful.
-
-- MySQL only supports asynchronous materialized views.
+- Doris supports logical view and supports two types of materialized views:
synchronous materialized views and asynchronous materialized views
+- MySQL do not supports asynchronous materialized views.
#### 05 ALTER TABLE / ALTER INDEX
diff --git a/versioned_docs/version-3.0/query-data/mysql-compatibility.md
b/versioned_docs/version-3.0/query-data/mysql-compatibility.md
index 5dfffc284ee..6beea3254e8 100644
--- a/versioned_docs/version-3.0/query-data/mysql-compatibility.md
+++ b/versioned_docs/version-3.0/query-data/mysql-compatibility.md
@@ -79,44 +79,37 @@ Doris has several unique data types. Here are the details:
- **HyperLogLog**
- HLL (HyperLogLog) is a data type that cannot be used as a key column. It can
be used in aggregate, duplicate, and unique models. In an aggregate model
table, the corresponding aggregation type for HLL is HLL_UNION. The length and
default value do not need to be specified. The length is controlled internally
based on the data aggregation level. HLL columns can only be queried or used
with `HLL_UNION_AGG`, `HLL_RAW_AGG`, `HLL_CARDINALITY`, `HLL_HASH`, and other
related functions.
+ HLL (HyperLogLog) is a data type that cannot be used as a key column. In an
aggregate model table, the corresponding aggregation type for HLL is HLL_UNION.
The length and default value do not need to be specified. The length is
controlled internally based on the data aggregation level. HLL columns can only
be queried or used with `HLL_UNION_AGG`, `HLL_RAW_AGG`, `HLL_CARDINALITY`,
`HLL_HASH`, and other related functions.
HLL is used for approximate fuzzy deduplication and performs better than
count distinct when dealing with large amounts of data. The typical error rate
of HLL is around 1%, sometimes reaching up to 2%.
- **Bitmap**
- Bitmap is another data type in Doris. It can be used in aggregate, unique,
or duplicate models. In Unique or Duplicate models, it must be used as a
non-key column. In aggregate models, it must also be used as a non-key column,
and the corresponding aggregation type during table creation is BITMAP_UNION.
Similar to HLL, the length and default values do not need to be specified, and
the length is controlled internally based on the data aggregation level. Bitmap
columns can only be querie [...]
+ Bitmap is a data type that cannot be used as a key column. In aggregate
model table, the corresponding aggregation type for BITMAP is BITMAP_UNION.
Similar to HLL, the length and default values do not need to be specified, and
the length is controlled internally based on the data aggregation level. Bitmap
columns can only be queried or used with functions like `BITMAP_UNION_COUNT`,
`BITMAP_UNION`, `BITMAP_HASH`, `BITMAP_HASH64` and others.
Using BITMAP in traditional scenarios may impact loading speed, but it
generally performs better than Count Distinct when dealing with large amounts
of data. Please note that in real-time scenarios, using BITMAP without a global
dictionary and with bitmap_hash() function may introduce an error of around
0.1%. If this error is not acceptable, you can use bitmap_hash64 instead.
- **QUANTILE_PERCENT**
- QUANTILE_STATE is another data type in Doris, which cannot be used as a key
column. It can be used in aggregate, duplicate, and iuique models. In an
aggregate model table, the corresponding aggregation type for QUANTILE_STATE is
QUANTILE_UNION. The length and default value do not need to be specified, and
the length is controlled internally based on the data aggregation level.
QUANTILE_STATE columns can only be queried or used with functions like
`QUANTILE_PERCENT`, `QUANTILE_UNION`, ` [...]
+ QUANTILE_STATE is a data type that cannot be used as a key column. In an
aggregate model table, the corresponding aggregation type for QUANTILE_STATE is
QUANTILE_UNION. The length and default value do not need to be specified, and
the length is controlled internally based on the data aggregation level.
QUANTILE_STATE columns can only be queried or used with functions like
`QUANTILE_PERCENT`, `QUANTILE_UNION`, `TO_QUANTILE_STATE` and others.
QUANTILE_STATE is used for calculating approximate quantile values. During
import, it performs pre-aggregation on the same key with different values. When
the number of values does not exceed 2048, it stores all the data in detail.
When the number of values exceeds 2048, it uses the TDigest algorithm to
aggregate (cluster) the data and save the centroids of the clusters.
- **Array<T\>**
- Array is a data type in Doris that represents an array composed of elements
of type T. It cannot be used as a key column. Currently, it supports usage in
duplicate models and non-key column usage in unique models.
-
- The supported types for T are `BOOLEAN`, `TINYINT`, `SMALLINT`, `INT`,
`BIGINT`, `LARGEINT`, `FLOAT`, `DOUBLE`, `DECIMAL`, `DATE`, DATETIME, CHAR,
VARCHAR, and STRING.
+ Array is a data type in Doris that represents an array composed of elements
of type T. It cannot be used as a key column.
- **MAP<K, V\>**
- MAP is a data type in Doris that represents a map composed of elements of
types K and V. It cannot be used as a key column and can be used in both
duplicate and unique models.
-
- The supported types for K and V are `BOOLEAN`, `TINYINT`, `SMALLINT`, `INT`,
`BIGINT`, `LARGEINT`, `FLOAT`, `DOUBLE`, `DECIMAL`, `DATE`, `DATETIME`, `CHAR`,
`VARCHAR`, and `STRING`.
+ MAP is a data type in Doris that represents a map composed of elements of
types K and V.
- **STRUCT<field_name:field_type,...>**
- A structure (STRUCT) is composed of multiple fields. It can also be
identified as a collection of multiple columns. It cannot be used as a key and
is currently only supported in tables of the duplicate model.
+ A structure (STRUCT) is composed of multiple fields. It can also be
identified as a collection of multiple columns.
- field_name: The identifier of the field, which must be unique.
-
- field_type: The type of field.
- The supported types for fields are `BOOLEAN`, `TINYINT`, `SMALLINT`, `INT`,
`BIGINT`, `LARGEINT`, `FLOAT`, `DOUBLE`, `DECIMAL`, `DATE`, `DATETIME`, `CHAR`,
`VARCHAR`, and `STRING`.
-
- **Agg_State**
AGG_STATE is a data type in Doris that cannot be used as a key column. During
table creation, the signature of the aggregation function needs to be declared.
@@ -152,14 +145,14 @@ distribution_desc
| Parameter | Differences from MySQL
|
| ---------------------- |
------------------------------------------------------------ |
-| Column_definition_list | - Field list definition: The basic syntax is
similar to MySQL but includes an additional operation for aggregate types. <br
/>- The aggregate type operation primarily supports Aggregate Key. <br />- When
creating a table, MySQL allows adding constraints like Index (e.g., Primary
Key, Unique Key) after the field list definition, while Doris supports these
constraints and computations by defining data models. |
+| Column_definition_list | - Field list definition: The basic syntax is
similar to MySQL but includes an additional operation for aggregate types. <br
/>- The aggregate type operation primarily supports Aggregate. <br />- When
creating a table, MySQL allows adding constraints like Index (e.g., Primary
Key, Unique Key) after the field list definition, while Doris supports these
constraints and computations by defining data models. |
| Index_definition_list | - Index list definition: The basic syntax is
similar to MySQL, supporting bitmap indexes, inverted indexes, and N-Gram
indexes, but Bloom filter indexes are set through properties. <br />- MySQL
supports B+Tree and Hash indexes. |
| Engine_type | - Table engine type: Optional. <br />- The
currently supported table engine is mainly the OLAP native engine. <br />-
MySQL supports storage engines such as Innodb, MyISAM, etc. |
| Keys_type | - Data model: Optional. <br />- Supported types
include: 1) DUPLICATE KEY (default): The specified columns are sort columns. 2)
AGGREGATE KEY: The specified columns are dimension columns. 3) UNIQUE KEY: The
specified columns are primary key columns. <br />- MySQL does not have the
concept of a data model. |
| Table_comment | Table comment
|
-| Partition_info | - Partitioning algorithm: Optional. Supported
partitioning algorithms include: <br /> LESS THAN: Only defines the upper bound
of partitions. The lower bound is determined by the upper bound of the previous
partition. FIXED RANGE: Defines left-closed and right-open intervals for
partitions. <br />- MULTI RANGE: Creates multiple RANGE partitions in bulk,
defining left-closed and right-open intervals, setting time units and steps.
Time units support years, months, [...]
+| Partition_info | - Partitioning algorithm: Optional. Doris supported
partitioning algorithms include: <br />- LESS THAN: Only defines the upper
bound of partitions. The lower bound is determined by the upper bound of the
previous partition.<br />- FIXED RANGE: Defines left-closed and right-open
intervals for partitions. <br />- MULTI RANGE: Creates multiple RANGE
partitions in bulk, defining left-closed and right-open intervals, setting time
units and steps. Time units support [...]
| Distribution_desc | - Bucketing algorithm: Required. Includes: 1) Hash
bucketing syntax: DISTRIBUTED BY HASH (k1[,k2 ...]) [BUCKETS num\|auto].
Description: Uses specified key columns for hash bucketing. 2) Random bucketing
syntax: DISTRIBUTED BY RANDOM [BUCKETS num\|auto]. Description: Uses random
numbers for bucketing. <br />- MySQL does not have a bucketing algorithm. |
-| Rollup_list | - Multiple materialized views can be created while
creating the table. <br />- Syntax: `rollup_name (col1[, col2, ...]) [DUPLICATE
KEY(col1[, col2, ...])][PROPERTIES("key" = "value")]` <br />- MySQL does not
support this. |
+| Rollup_list | - Multiple sync materialized views can be created
while creating the table. <br />- Syntax: `rollup_name (col1[, col2, ...])
[DUPLICATE KEY(col1[, col2, ...])][PROPERTIES("key" = "value")]` <br />- MySQL
does not support this. |
| Properties | Table properties: They differ from MySQL's table
properties, and the syntax for defining table properties also differs from
MySQL. |
@@ -193,10 +186,8 @@ CREATE MATERIALIZED VIEW (IF NOT EXISTS)?
mvName=multipartIdentifier
```
- The basic syntax is consistent with MySQL.
-
-- Doris supports two types of materialized views: synchronous materialized
views and asynchronous materialized views (supported for v2.1). The
asynchronous materialized views in Doris are more powerful.
-
-- MySQL only supports asynchronous materialized views.
+- Doris supports logical view and supports two types of materialized views:
synchronous materialized views and asynchronous materialized views
+- MySQL do not supports asynchronous materialized views.
#### 05 ALTER TABLE / ALTER INDEX
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscr...@doris.apache.org
For additional commands, e-mail: commits-h...@doris.apache.org
