update docs (#297)

* update docs

* update file directories

* modify docs directory structure
Co-authored-by: NHe Wang <wanghechn@qq.com>

.gitignore

@@ -87,7 +87,7 @@ test/var
 *.ccls-cache/
 
 ###### Docs website files
-site
+docs/site
 
 ###### Intellij files
 .idea

README.md

@@ -21,7 +21,7 @@ OceanBase Database supports the entire core business of Alipay and the core syst
 
 ## Quick start
 
-Refer to the [Get Started guide](docs/en/quick-start-en.md) to try out OceanBase Database.
+Refer to the [Get Started guide](docs/docs/docs-en/quick-start-en.md) to try out OceanBase Database.
 
 ## Documentation
 

mkdocs.md → docs/README.md

@@ -6,9 +6,9 @@ OceanBase documentation is built with [MkDocs](https://www.mkdocs.org/). You can
 
 Before installing dependencies, please make sure you have installed a recent version of Python 3 and pip.
 
-Then you can run the following command in your terminal:
+Then you can run the following command in your terminal at current directory:
 
-    $ pip install -r docs/requirements.txt
+    $ pip install -r requirements.txt
 
 ## Build the documentation
 
@@ -42,4 +42,4 @@ For configuration details, see [MkDocs User Guide](https://www.mkdocs.org/user-g
 
 ## Contribute
 
-See [How to contribute](CONTRIBUTING.md).
\ No newline at end of file
+See [How to contribute](../CONTRIBUTING.md).

docs/docs/docs-cn/1.about-oceanbase-database/1.what-is-oceanbase.md

+什么是 OceanBase 数据库 
+======================================
+
+
+
+OceanBase 数据库是一个金融级分布式关系数据库，提供社区版和企业版：
+
+* OceanBase 数据库社区版包含 OceanBase 的所有核心功能，源代码完全公开，且使用免费。
+
+  
+
+* OceanBase 数据库企业版在 OceanBase 社区版的基础上，提供更多高级功能，如商业特性兼容、图形化管理工具、操作审计、安全加密、高可用扩展等。如果您想了解 OceanBase 企业版的相关功能，请参考 [OceanBase 企业版文档](https://www.oceanbase.com/docs)。
+
+  
+
+
+
+
+本手册仅适用于 OceanBase 数据库社区版。
+
+特性 
+-----------------------
+
+OceanBase 数据库具有如下特性：
+
+* 高可用
+
+  OceanBase 数据库将数据以多副本的方式存储在集群的各个节点，可以轻松实现高可用，保证 RPO=0，甚至异地多活。即使单个节点出现故障也不影响业务。多副本能够满足从节点、机架、机房到城市级别的高可用、容灾要求，并且克服传统数据库的主备模式在主节点出现异常时 RPO\>0 的问题。
+  
+
+* 可扩展
+
+  OceanBase 数据库具有极强的可扩展性，可以在线进行平滑扩容或缩容，在扩容后自动实现系统负载均衡。并且扩容或缩容过程对应用透明。
+  
+
+* 低成本
+
+  OceanBase 数据库可以在通用服务器上运行，不依赖于特定的高端硬件，能够有效降低用户的硬件成本。OceanBase 数据库使用基于 LSM-Tree 的存储引擎，能够有效地对数据进行压缩，并且不影响性能，可以降低用户的存储成本。
+  
+
+* HTAP
+
+  OceanBase 数据库的分布式并行计算引擎对 OLTP 应用和 OLAP 应用都进行了很好的优化，并且支持跨数据库节点的 DQL 和 DML 并发执行，真正实现了一套计算引擎同时支持混合负载。
+  
+
+* 兼容性
+
+  OceanBase 数据库高度兼容 MySQL 数据库生态。OceanBase 数据库支持 MySQL 5.6 版本全部语法，可以与 MySQL 业务无缝切换。
+  
+
+* 多租户
+
+  OceanBase 数据库通过租户实现资源隔离，每个数据库服务的实例不感知其他实例的存在，并通过权限控制确保不同租户数据的安全性。多租户与 OceanBase 数据库强大的可扩展性相结合，能够提供安全、灵活的 DBaaS 服务。
+  
+
+
+
+
+许可证 
+------------------------
+
+OceanBase 数据库社区版完全开源，使用 [MulanPubL - 2.0](https://license.coscl.org.cn/MulanPubL-2.0/index.html) 许可证，您可以免费复制和使用源代码。当您修改或分发源代码时，请遵守木兰协议。
+

docs/docs/docs-cn/1.about-oceanbase-database/2.noun-interpretation.md

+名词解释 
+=========================
+
+本文介绍您在使用 OceanBase 数据库时可能需要了解的名词解释。
+
+* OceanBase 数据库
+
+  蚂蚁集团完全自主研发的金融级分布式关系数据库。OceanBase 数据库具有高可用、可拓展、高兼容、低成本、强一致及高性能等特点。详细信息参考 [什么是 OceanBase 数据库](/zh-CN/1.about-oceanbase-database/1.what-is-oceanbase.md)。
+  
+
+* OceanBase Database Proxy
+
+  OceanBase 数据库代理，简称为 ODP。ODP 是 OceanBase 数据库专用的连接代理软件。ODP 的核心功能包括：保证最佳路由，避免分布式事务；保护 OceanBase 数据库的高可用能力，单台服务器故障不影响应用。详细信息，参考 ODP 文档。
+  
+
+* OceanBase Deployer
+
+  OceanBase 开源软件的安装部署工具，简称为 OBD。OBD 同时也是包管理器，可以用来管理 OceanBase 所有的开源软件 **。**
+  
+
+
+

docs/docs/docs-cn/10.sql-reference/1.basic-elements/1.data-type.md

+数据类型 
+=========================
+
+
+
+OceanBase支持如下数据类型：
+
+* 数值类型
+
+* 日期时间类型
+
+* 字符类型
+
+* 大对象类型
+
+  
+
+
+
+
+
+
+数值类型 
+-------------
+
+数值类型可以划分为三类：
+
+* 整数类型：`BOOL`/`BOOLEAN`、`TINYINT`、`SMALLINT`、`MEDIUMINT`、`INT`/`INTEGER`、`BIGINT`。
+
+
+
+
+<!-- -->
+
+* 定点类型：`DECIMAL`/`NUMERIC`。
+
+
+
+
+<!-- -->
+
+* 浮点类型：`FLOAT`、`DOUBLE`。
+
+* Bit-Value类型：`BIT`
+
+
+
+
+所有数据类型都可以同时使用`UNSIGNED`关键字声明为无符号类型，这会导致值域发生变化。
+
+数值类型在定义时可以指定precision和scale，不同类型中precision和scale的含义可能有所不同，详情请见各类型详细说明。
+
+整数类型 
+-------------
+
+整数类型为定长、精确数值类型，值域取决于类型长度，以及是否为无符号，precision只表示最小显示宽度，详见"ZEROFILL属性"节。以下为相关信息：
+
+
+|                     类型                      | 长度(字节) |          值域(有符号)          |      值域(无符号)       |
+|---------------------------------------------|--------|---------------------------|--------------------|
+| `BOOL`/`BOOLEAN`/ `TINYINT` | 1      | \[-2 \^ 7 , 2 \^ 7 - 1\]  | \[0, 2 \^ 8 - 1\]  |
+| `SMALLINT`                                  | 2      | \[-2 \^ 15, 2 \^ 15 - 1\] | \[0, 2 \^ 16 - 1\] |
+| `MEDIUMINT`                                 | 3      | \[-2 \^ 23, 2 \^ 23 - 1\] | \[0, 2 \^ 24 - 1\] |
+| `INT`/`INTEGER`                             | 4      | \[-2 \^ 31, 2 \^ 31 - 1\] | \[0, 2 \^ 32 - 1\] |
+| `BIGINT`                                    | 8      | \[-2 \^ 63, 2 \^ 63 - 1\] | \[0, 2 \^ 64 - 1\] |
+
+
+
+
+
+`BOOL`等价于`BOOLEAN`，这两个类型又等价于`TINYINT(1)`。
+
+`INT`等价于`INTEGER`。
+
+定点类型 
+-------------
+
+定点类型为变长、精确数值类型，值域和精度取决于precision和scale，以及是否为无符号。precision和scale分别表示十进制下的总最大有效位数、小数部分最大有效位数，整数部分最大有效位数等于precision - scale，其中precision和scale的最大值分别为65、30，默认值分别为10、0。例如：
+
+* `DECIMAL(5, 2)`，整数部分和小数部分最大有效位数分别为3、2，所以值域为\[-999.99, 999.99\]。
+
+* 如果同时定义为`UNSIGNED`，则值域为\[0, 999.99\]。
+
+
+
+
+`DECIMAL`等价于`NUMERIC`。
+
+#### 浮点类型 
+
+浮点类型为定长、非精确数值类型，值域和精度取决于类型长度、precision和scale，以及是否为无符号。precision和scale分别表示十进制下的总最大有效位数、小数部分最大有效位数，整数部分最大有效位数等于precision - scale，其中precision和scale的最大值分别为53、30。
+
+浮点类型的精度只是IEEE标准中规定的理论值，实际情况可能因硬件或操作系统限制略有不同。
+
+以下为不指定precision和scale时的默认信息：
+
+
+|    类型    | 长度(字节) |          值域(有符号)          |     值域(无符号)      | 精度  |
+|----------|--------|---------------------------|------------------|-----|
+| `FLOAT`  | 4      | \[-2 \^ 128, 2 \^ 128\]   | \[0, 2 \^ 128\]  | 7位  |
+| `DOUBLE` | 8      | \[-2 \^ 1024, 2 \^ 1024\] | \[0, 2 \^ 1024\] | 15位 |
+
+
+
+
+
+如果指定precision和scale，则值域确定方法与定点类型相同。
+
+#### ZEROFILL属性 
+
+数值类型在定义时可以通过ZEROFILL关键字指定最小显示宽度，同时将该类型隐式定义为UNSIGNED。在数据实际显示宽度不足最小显示宽度时，通过先在小数部分补零到scale上限、再在整数部分补零到precision上限的方式，将显示宽度补足到最小显示宽度。例如：
+
+* `INT(5) ZEROFILL`：当数据值为`123`时，将显示为`00123`。
+
+* `DECIMAL(10, 5) ZEROFILL`：当数据值为`123.456`时，将显示为`00123.45600`。
+
+  
+
+
+
+
+
+
+#### BIT-Value类型 
+
+BIT数据类型用于存储bit values。一个BIT(M)能够存储M-bit的值，M的范围是1\~64。
+
+bit value通过b'value'的形式指定， **value** 是用0和1来指定的，例如,b'111'表示7，b'10000000'表示128。
+
+当向BIT(M)列插入值时，如果插入值的长度小于 **M** ，则会在左侧填充0。例如：将b'101'插入到BIT(6)时，相当于插入了b'000101'。
+
+日期时间类型 
+---------------
+
+以下为相关信息：
+
+
+|     类型      |                格式                |             下界             |             上界             |     含义      |
+|-------------|----------------------------------|----------------------------|----------------------------|-------------|
+| `DATETIME`  | YYYY-MM-DD HH:MM:SS\[.fraction\] | 0000-01-01 00:00:00.000000 | 9999-12-31 23:59:59.999999 | 日期时间(不考虑时区) |
+| `TIMESTAMP` | YYYY-MM-DD HH:MM:SS\[.fraction\] | 0000-01-01 00:00:00.000000 | 9999-12-31 23:59:59.999999 | 日期时间(考虑时区)  |
+| `DATE`      | YYYY-MM-DD                       | 0000-01-01                 | 9999-12-31                 | 日期          |
+| `TIME`      | HH:MM:SS\[.fraction\]            | -838:59:59.000000          | 838:59:59.000000           | 时间          |
+| `YEAR`      | YYYY                             | 1901                       | 2155                       | 年份          |
+
+
+
+
+
+`DATETIME`、`TIMESTAMP`、`TIME`的值域和精度取决于scale。该属性表示小数部分最大有效位数，最大值为6，默认值为0。
+
+字符类型 
+-------------
+
+以下为普通字符类型相关信息：
+
+
+|     类型      | 长度 |         定义长度上限(字符)          |    字符集    |
+|-------------|----|-----------------------------|-----------|
+| `VARCHAR`   | 变长 | 262144 / 256K               | `UTF8MB4` |
+| `VARBINARY` | 变长 | 1048576 / 1M                | `BINARY`  |
+| `CHAR`      | 定长 | 256                         | `UTF8MB4` |
+| `BINARY`    | 定长 | 256                         | `BINARY`  |
+| `enum`      | 变长 | 最多定义65535个元素，每个元素长度最多255个字符 | `UTF8MB4` |
+| `set`       | 变长 | 最多定义64个元素，每个元素长度最多255个字符    | `UTF8MB4` |
+
+
+
+大对象类型 
+--------------
+
+以下为大对象类型相关信息：
+
+
+|      类型      | 长度 |   存储长度上限(字节)   |    字符集    |
+|--------------|----|----------------|-----------|
+| `TINYTEXT`   | 变长 | 256            | `UTF8MB4` |
+| `TINYBLOB`   | 变长 | 256            | `BINARY`  |
+| `TEXT`       | 变长 | 65536 / 64K    | `UTF8MB4` |
+| `BLOB`       | 变长 | 65536 / 64K    | `BINARY`  |
+| `MEDIUMTEXT` | 变长 | 16777216 / 16M | `UTF8MB4` |
+| `MEDIUMBLOB` | 变长 | 16777216 / 16M | `BINARY`  |
+| `LONGTEXT`   | 变长 | 50331648 / 48M | `UTF8MB4` |
+| `LONGBLOB`   | 变长 | 50331648 / 48M | `BINARY`  |
+
+
+

docs/docs/docs-cn/10.sql-reference/1.basic-elements/2.expression.md

+表达式 
+========================
+
+
+
+表达式是广义概念，通常有若干个输入参数，并且返回一个输出结果。其中输入参数可能来自于常量或单行数据，也可能来自于多行数据。表达式可以组合，一个表达式的输入可以为另一个表达式的输出。
+
+根据表达式的来源和形式，可分为如下几类：
+
+* 列引用
+
+  
+
+
+
+
+<!-- -->
+
+* 常量
+
+  
+
+
+
+
+<!-- -->
+
+* 运算符
+
+  
+
+
+
+
+<!-- -->
+
+* 函数
+
+  
+
+
+
+
+例如：
+
+```javascript
+SELECT ABS(a + 1) 
+  FROM t1 
+ WHERE a > 0;
+```
+
+
+
+
+
+* a为列引用。
+
+
+
+
+<!-- -->
+
+* 0、1为常量。
+
+
+
+
+<!-- -->
+
+* `&gt;`、`+`为运算符，以0、1、a表达式为输入。
+
+
+
+
+<!-- -->
+
+* `ABS`为函数，以`+`表达式为输入。
+
+
+

docs/docs/docs-cn/10.sql-reference/1.basic-elements/3.type-conversion.md

+类型转换 
+=========================
+
+
+
+OceanBase支持显式类型转换和隐式类型转换。
+
+显示类型转换通过`CAST`函数实现。
+
+隐式类型转换发生在这样的场景中：一个操作需要一个指定类型的参数，但语句的实际参数值并不是指定类型，这时OceanBase会将实际参数值转为指定类型后，再进行后续操作。

docs/docs/docs-cn/10.sql-reference/1.basic-elements/4.character-set.md

+字符集 
+========================
+
+
+
+目前只支持如下字符集：
+
+* `UTF8MB4`：变长编码，字符最大长度4字节。
+
+
+
+
+<!-- -->
+
+* `BINARY`：定长编码，字符固定长度1字节。
+
+
+
+
+`UT8`/`UTF8MB3`是`UTF8MB4`的子集，变长编码，字符最大长度3字节。为支持无缝迁移，OceanBase在语法上将`UTF8`视为`UTF8MB4`的同义词。

docs/docs/docs-cn/10.sql-reference/1.basic-elements/5.collation.md

+排序规则 
+=========================
+
+
+
+目前只支持如下排序规则：
+
+* `UTF8MB4`的`UTF8MB4_GENERAL_CI`。
+
+
+
+
+<!-- -->
+
+* `UTF8MB4`的`UTF8MB4_BIN`。
+
+
+
+
+<!-- -->
+
+* `BINARY`的`BINARY`。
+
+
+

docs/docs/docs-cn/10.sql-reference/1.basic-elements/6.data-comparison-rules.md

+数据比较规则 
+===========================
+
+
+
+OceanBase允许任意两或多个任意类型的数据进行比较，比较结果可能为：
+
+* 非0 / TRUE
+
+
+
+
+<!-- -->
+
+* 0 / FALSE。
+
+
+
+
+<!-- -->
+
+* NULL。
+
+
+
+
+如果参与比较的数据类型不一致，OceanBase会根据相关规则确定一个用于比较的数据类型，逻辑上所有参与比较的数据都需要先转换为该数据类型才能参与比较操作。
+
+如果比较类型为文本类型，则还需要确定一个用于比较的排序规则。

docs/docs/docs-cn/10.sql-reference/1.basic-elements/7.literal.md

+字面量 
+========================
+
+
+
+文本 
+-----------
+
+文本是使用单引号`'`或双引号`"`引起来的字符序列，如果打开`ANSI_QUOTES`模式，那只有单引号`'`可以用于引用字符串。
+
+数值 
+-----------
+
+十进制数值可以分为精确数值（整数和定点数值）和浮点数值。数值可以使用小数点`.`作为十进制分隔符，也可以在前面加一个负号`-`来表示负值。
+
+十六进制数值只支持整数数值，以前缀`0X`开始，允许出现字母`A`到`F`，所有字母不区分大小写。
+
+日期时间 
+-------------
+
+日期时间字面量有文本或数值两种形式。
+
+* 文本格式可使用全量分隔符：`'2015-07-21 12:34:56.789'`，或完全不使用分隔符：`'20150721'`。
+
+
+
+
+<!-- -->
+
+* 数值格式只允许使用小数点`.`作为秒和微秒部分的分隔符：`20150721123456.789`。
+
+* 在需要使用分隔符时，除了秒和微秒部分之间只能使用小数点`.`外，其它分隔符建议只使用`-`、`/`、`:`等常用分隔符。
+
+  
+
+
+
+
+
+
+转义字符 
+-------------
+
+转义字符是在字符串中，某些序列前添加反斜线`\`，用于表示特殊含义。转义字符对大小写敏感。例如`\b`表示退格，但`\B`表示`B`。
+
+以下为所有转义符列表：
+
+
+| 转义符  |         含义          |
+|------|---------------------|
+| `\b` | 退格符。                |
+| `\f` | 换页符。                |
+| `\n` | 换行符。                |
+| `\r` | 回车符。                |
+| `\t` | tab字符。              |
+| `\\` | 反斜线字符。              |
+| `\'` | 单引号。                |
+| `\"` | 双引号。                |
+| `\_` | 下划线。                |
+| `\%` | 百分号。                |
+| `\0` | NULL。               |
+| `\Z` | ASCII 26，控制符Ctrl+Z。 |
+
+

docs/docs/docs-cn/10.sql-reference/1.basic-elements/8.annotation.md

+注释 
+=======================
+
+
+
+SQL 语句 
+---------------
+
+在普通 SQL 语句中，OceanBase 数据库支持如下 3 种注释方法：
+
+* 从 `#` 到行尾
+
+  
+
+
+
+
+<!-- -->
+
+* 从 `--` 到行尾
+
+  
+
+* 从 `/*` 到 `*/`
+
+  
+
+
+
+
+
+
+数据库对象 
+--------------
+
+在 DDL 语句中通过 `COMMENT` 子句可以为数据库对象指定注释。例如：
+
+```unknow
+create table t(pk INT PRIMARY KEY COMMENT '主键');
+```
+
+

docs/docs/docs-cn/10.sql-reference/2.operator/1.arithmetic-operators.md

+算术运算符 
+==========================
+
+
+
+以下为所有算术运算符列表：
+
+
+|    运算符    |  操作数  |       含义       |
+|-----------|-------|----------------|
+| `+`       | 一元/二元 | 一元表示正数，二元表示加法。 |
+| `-`       | 一元/二元 | 一元表示负数，二元表示减法。 |
+| `*`       | 二元    | 乘法。            |
+| `/`       | 二元    | 普通除法。          |
+| `DIV`     | 二元    | 整数除法，返回商数。     |
+| `MOD`或`%` | 二元    | 整数除法，返回余数。     |
+
+
+
+整数除法遵循如下原则：
+
+* 商数不论正负，统一向0取整。
+
+
+
+
+<!-- -->
+
+* 余数正负与被除数相同。
+
+
+
+
+例如：
+
+```javascript
+OceanBase (root@oceanbase)> SELECT (-7) DIV (3.6), (-7) MOD (3.6);
++----------------+----------------+
+| (-7) DIV (3.6) | (-7) MOD (3.6) |
++----------------+----------------+
+|             -1 |           -3.4 |
++----------------+----------------+
+1 row in set (0.01 sec)
+
+OceanBase (root@oceanbase)> SELECT (-7) DIV (-3.4), (-7) % (-3.4);
++-----------------+---------------+
+| (-7) DIV (-3.4) | (-7) % (-3.4) |
++-----------------+---------------+
+|               2 |          -0.2 |
++-----------------+---------------+
+1 row in set (0.02 sec)
+```
+
+

docs/docs/docs-cn/10.sql-reference/2.operator/2.bitwise-operators.md

+位运算符 
+=========================
+
+
+
+位运算使用`BIGINT UNSIGNED`计算，不需考虑符号位。
+
+以下为所有位运算符列表：
+
+
+|    运算符     | 操作数 |  含义   |
+|------------|-----|-------|
+| `&`    | 二元  | 按位与。  |
+| `|`        | 二元  | 按位或。  |
+| `~`        | 一元  | 按位取反。 |
+| `^`        | 二元  | 按位异或。 |
+| `<<` | 二元  | 逻辑左移。 |
+| `>>` | 二元  | 逻辑右移。 |
+
+

docs/docs/docs-cn/10.sql-reference/2.operator/3.comparison-operators.md

+比较运算符 
+==========================
+
+
+
+以下为所有比较运算符列表：
+
+
+|         运算符         | 操作数 |     含义     |    NULL参与运算    |
+|---------------------|-----|------------|----------------|
+| `=`                 | 二元  | 等于。        | 结果为NULL。       |
+| `<>`/`!=`     | 二元  | 不等于。       | 结果为NULL。       |
+| `>`              | 二元  | 大于。        | 结果为NULL。       |
+| `>=`             | 二元  | 大于等于。      | 结果为NULL。       |
+| `<`              | 二元  | 小于。        | 结果为NULL。       |
+| `<=`             | 二元  | 小于等于。      | 结果为NULL。       |
+| `[NOT] IN`          | 二元  | 是否在集合中。    | 详见说明。          |
+| `[NOT] BETWEEN AND` | 三元  | 是否在区间内。    | 详见说明。          |
+| `IS [NOT] TRUE`     | 一元  | 是否等于TRUE。  | 结果为TRUE或FALSE。 |
+| `IS [NOT] FALSE`    | 一元  | 是否等于FALSE。 | 结果为TRUE或FALSE。 |
+| `IS [NOT] NULL`     | 一元  | 是否等于NULL。  | 结果为TRUE或FALSE。 |
+| `<=>`         | 二元  | 安全等于。      | 结果为TRUE或FALSE。 |
+
+
+
+
+
+以下为部分运算符对NULL的特殊处理：
+
+* `value [NOT] IN ()`：
+
+
+
+
+<!-- -->
+
+
+
+<!-- -->
+
+
+
+<!-- -->
+
+* `value [NOT] BETWEEN lower AND upper`：
+
+
+
+
+<!-- -->
+
+
+
+<!-- -->
+
+
+
+例如：
+
+```javascript
+OceanBase (root@oceanbase)> SELECT 1 IN (1, NULL), 1 IN (2, NULL);
++----------------+----------------+
+| 1 IN (1, NULL) | 1 IN (2, NULL) |
++----------------+----------------+
+|              1 |           NULL |
++----------------+----------------+
+1 row in set (0.01 sec)
+
+OceanBase (root@oceanbase)> SELECT 1 BETWEEN 0 AND NULL, 1 BETWEEN 2 AND NULL;
++----------------------+----------------------+
+| 1 BETWEEN 0 AND NULL | 1 BETWEEN 2 AND NULL |
++----------------------+----------------------+
+|                 NULL |                    0 |
++----------------------+----------------------+
+1 row in set (0.01 sec)
+```
+
+

docs/docs/docs-cn/10.sql-reference/2.operator/4.logical-operators.md

+逻辑运算符 
+==========================
+
+
+
+以下为所有逻辑运算符列表：
+
+
+|        运算符         | 操作数 | 含义  |
+|--------------------|-----|-----|
+| `AND`/`&&` | 二元  | 逻辑与 |
+| `OR`/`||`          | 二元  | 逻辑或 |
+| `NOT`/`!`          | 一元  | 逻辑非 |
+
+

docs/docs/docs-cn/10.sql-reference/2.operator/5.date-and-time-operators.md

+日期时间运算符 
+============================
+
+
+
+以下为所有日期时间运算符列表：
+
+
+| 运算符 | 操作数 |      含义       |
+|-----|-----|---------------|
+| `+` | 二元  | 同`DATE_ADD`函数 |
+| `-` | 二元  | 同`DATE_SUB`函数 |
+
+
+
+例如：
+
+```javascript
+OceanBase (root@oceanbase)> SELECT '2008-12-31 23:59:59' + INTERVAL 1 SECOND;
++-------------------------------------------+
+| '2008-12-31 23:59:59' + INTERVAL 1 SECOND |
++-------------------------------------------+
+| 2009-01-01 00:00:00                       |
++-------------------------------------------+
+1 row in set (0.01 sec)
+```
+
+

docs/docs/docs-cn/10.sql-reference/2.operator/6.character-concatenation-operators.md

+字符连接运算符 
+============================
+
+
+
+以下为所有字符连接运算符列表：
+
+
+| 运算符  | 操作数 |  含义   |
+|------|-----|-------|
+| `||` | 二元  | 字符串连接 |
+
+
+
+如前节所述，`||`也可作为逻辑或运算符，两个不同含义是通过SQL MODE控制的：
+
+* SQL MODE包含`PIPES_AS_CONCAT`时，`||`为字符连接运算符。
+
+
+
+
+<!-- -->
+
+* SQL MODE不包含`PIPES_AS_CONCAT`时，`||`为逻辑与运算符。
+
+
+

docs/docs/docs-cn/10.sql-reference/2.operator/7.hierarchical-query-operators.md

+层次查询运算符 
+============================
+
+
+
+以下为所有层次查询运算符列表：
+
+
+|        运算符        | 操作数 |           含义           |
+|-------------------|-----|------------------------|
+| `PRIOR`           | 一元  | 用于指明column来自parent row |
+| `CONNECT_BY_ROOT` | 一元  | 用于指明顶层祖先               |
+
+

docs/docs/docs-cn/10.sql-reference/2.operator/8.collation-operators.md

+排序规则运算符 
+============================
+
+
+
+以下为所有排序规则运算符列表：
+
+
+|    运算符    |  操作数   |  含义  |
+|-----------|--------|------|
+| `COLLATE` | 一元（后缀） | 排序规则 |
+
+
+
+例如：
+
+```javascript
+SELECT last_name
+  FROM employees
+ ORDER BY last_name COLLATE UTF8MB4_GENERAL_CI;
+```
+
+

docs/docs/docs-cn/10.sql-reference/3.functions/2.aggregate-functions.md

+聚集函数 
+=========================
+
+
+
+聚合函数对一组值执行计算并返回单一的值。聚合函数忽略空值。聚合函数经常与SELECT语句的GROUP BY子句一同使用。
+
+所有聚合函数都具有确定性。任何时候用一组给定的输入值调用它们时，都返回相同的值。
+
+在OceanBase的聚合函数中，Value表达式只能出现一个。例如：不支持COUNT(c1, c2)，仅支持COUNT(c1）。
+
+AVG 
+------------
+
+**声明** 
+
+`AVG(([DISTINCT] expr)`
+
+**说明** 
+
+返回指定组中的平均值，空值被忽略。DISTINCT选项可用于返回expr的不同值的平均值。若找不到匹配的行，则AVG()返回NULL。
+
+**例子** 
+
+```javascript
+Oceanbase>select * from oceanbasetest;
++----+------+------+
+| id | ip   | ip2  |
++----+------+------+
+|  1 |    4 | NULL |
+|  3 |    3 | NULL |
+|  4 |    3 | NULL |
++----+------+------+
+3 rows in set (0.01 sec)
+
+Oceanbase>select avg(ip2), avg(ip), avg(distinct(ip)) from oceanbasetest;
++----------+---------+-------------------+
+| avg(ip2) | avg(ip) | avg(distinct(ip)) |
++----------+---------+-------------------+
+|     NULL |  3.3333 |            3.5000 |
++----------+---------+-------------------+
+1 row in set (0.00 sec)
+
+Oceanbase>select avg(distinct(ip)),avg(ip),avg(ip2) from oceanbasetest;
++-------------------+---------+----------+
+| avg(distinct(ip)) | avg(ip) | avg(ip2) |
++-------------------+---------+----------+
+|            3.5000 |  3.3333 |     NULL |
++-------------------+---------+----------+
+1 row in set (0.00 sec)
+```
+
+
+
+
+
+COUNT 
+--------------
+
+**声明** 
+
+`COUNT([DISTINCT] expr)`
+
+**说明** 
+
+COUNT(\[DISTINCT\] expr )返回SELECT语句检索到的行中非NULL值的数目。若找不到匹配的行，则COUNT()返回0。DISTINCT选项可用于返回 expr 的不同值的数目。
+
+COUNT(\*)的稍微不同之处在于，它返回检索行的数目，不论其是否包含NULL值。
+
+**例子** 
+
+```javascript
+Oceanbase>select * from oceanbasetest;
++----+------+------+
+| id | ip   | ip2  |
++----+------+------+
+|  1 |    4 | NULL |
+|  3 |    3 | NULL |
+|  4 |    3 | NULL |
++----+------+------+
+3 rows in set (0.00 sec)
+
+Oceanbase>select count(ip2), count(ip), count(distinct(ip)), count(*) from oceanbasetest;
++------------+-----------+---------------------+----------+
+| count(ip2) | count(ip) | count(distinct(ip)) | count(*) |
++------------+-----------+---------------------+----------+
+|          0 |         3 |                   2 |        3 |
++------------+-----------+---------------------+----------+
+1 row in set (0.00 sec)
+```
+
+
+
+
+
+MAX 
+------------
+
+**声明** 
+
+`MAX([DISTINCT] expr)`
+
+**说明** 
+
+返回指定数据中的最大值。
+
+MAX()的取值可以是一个字符串参数；在这些情况下，它们返回最大字符串值。DISTINCT关键字可以被用来查找 expr的不同值的最大值，这产生的结果与省略DISTINCT 的结果相同。
+
+假设表a有三行数据：id=1，num=10；id=2，num=20；id=3，num=30。
+
+**例子** 
+
+```javascript
+Oceanbase>SELECT MAX(num) FROM a;
++-----------------+
+| MAX(num)        |
++-----------------+
+|              30 |
++-----------------+
+1 row in set (0.00 sec)
+```
+
+
+
+
+
+MIN 
+------------
+
+**声明** 
+
+`MIN([DISTINCT] expr)`
+
+**说明** 
+
+返回指定数据中的最小值。
+
+MIN()的取值可以是一个字符串参数；在这些情况下，它们返回最小字符串值。DISTINCT关键字可以被用来查找expr 的不同值的最小值，然而，这产生的结果与省略DISTINCT 的结果相同。
+
+假设表a有三行数据：id=1，num=10；id=2，num=20；id=3，num=30。
+
+**例子** 
+
+```javascript
+Oceanbase>SELECT MIN(num) FROM a;
++----------------+
+| MIN(num)       |
++----------------+
+|             10 |
++----------------+
+1 row in set (0.00 sec)
+```
+
+
+
+
+
+SUM 
+------------
+
+**声明** 
+
+`SUM([DISTINCT] expr)`
+
+**说明** 
+
+返回 expr 的总数。若返回集合中无任何行，则 SUM() 返回NULL。DISTINCT关键字可用于求得 expr 不同值的总和。
+
+若找不到匹配的行，则SUM()返回NULL。
+
+**例子** 
+
+```javascript
+Oceanbase>select * from oceanbasetest;
++------+------+------+
+| id   | ip   | ip2  |
++------+------+------+
+|    1 |    4 | NULL |
+|    3 |    3 | NULL |
+|    4 |    3 | NULL |
++------+------+------+
+3 rows in set (0.00 sec)
+
+Oceanbase>select sum(ip2),sum(ip),sum(distinct(ip)) from oceanbasetest;
++----------+---------+-------------------+
+| sum(ip2) | sum(ip) | sum(distinct(ip)) |
++----------+---------+-------------------+
+|     NULL |      10 |                 7 |
++----------+---------+-------------------+
+1 row in set (0.00 sec)
+```
+
+
+
+
+
+GROUP_CONCAT 
+---------------------
+
+**声明** 
+
+`GROUP_CONCAT([DISTINCT] expr)`
+
+**说明** 
+
+该函数返回带有来自一个组的连接的非NULL值的字符串结果。
+
+```javascript
+GROUP_CONCAT([DISTINCT] expr [,expr ...]
+    [ORDER BY {unsigned_integer | col_name | expr}
+     ASC | DESC]
+    [SEPARATOR str_val])
+```
+
+
+
+**例子** 
+
+```javascript
+Oceanbase>select * from book;     //表book（书编号，书名，出版社）
++--------+--------------------------------+-----------------------------+
+| bookid | bookname                       | publishname                 |
++--------+--------------------------------+-----------------------------+
+|      1 | git help                       | alibaba group publisher     |
+|      2 | MySQL性能优化                  | 浙江大学图文出版社          |
+|      3 | JAVA编程指南                   | 机械工业出版社              |
+|      3 | JAVA编程指南                   | 机械工业出版社              |
+|      4 | 大规模分布式存储系统           | 机械工业出版社              |
++--------+--------------------------------+-----------------------------+
+5 rows in set (0.00 sec)    
+
+//查找书名信息
+Oceanbase>select group_concat(bookname) from book group by bookname;
++-----------------------------------+
+| group_concat(bookname)            |
++-----------------------------------+
+| git help                          |
+| JAVA编程指南,JAVA编程指南         |
+| MySQL性能优化                     |
+| 大规模分布式存储系统              |
++-----------------------------------+
+4 rows in set (0.00 sec)
+
+//查找书名信息，书名唯一
+Oceanbase>select group_concat(distinct(bookname)) from book group by bookname;
++----------------------------------+
+| group_concat(distinct(bookname)) |
++----------------------------------+
+| git help                         |
+| JAVA编程指南                     |
+| MySQL性能优化                    |
+| 大规模分布式存储系统             |
++----------------------------------+
+4 rows in set (0.01 sec)    
+
+//查找书名和出版社信息，以书名分组，出版社信息降序排序显示
+Oceanbase>select bookname, group_concat(publishname order by publishname desc separator  ';' ) from book group by bookname;
++--------------------------------+---------------------------------------------------------------------+
+| bookname                       | group_concat(publishname order by publishname desc separator  ';' ) |
++--------------------------------+---------------------------------------------------------------------+
+| git help                       | alibaba group publisher                                             |
+| JAVA编程指南                   | 机械工业出版社;机械工业出版社                                       |
+| MySQL性能优化                  | 浙江大学图文出版社                                                  |
+| 大规模分布式存储系统           | 机械工业出版社                                                      |
++--------------------------------+---------------------------------------------------------------------+
+4 rows in set (0.00 sec)
+```
+
+

docs/docs/docs-cn/10.sql-reference/3.functions/3.analysis-functions.md

+分析函数 
+=========================
+
+
+
+简介 
+-----------
+
+**分析函数** （某些数据库下也叫做 **窗口函数** ）与聚合函数类似，计算总是基于一组行的集合，不同的是，聚合函数一组只能返回一行，而分析函数每组可以返回多行，组内每一行都是基于窗口的逻辑计算的结果。分析函数可以显著优化需要 self-join 的查询。
+
+### 分析函数语法 
+
+"窗口"也称为 FRAME，OceanBase 数据库同时支持 ROWS 与 RANGE 两种 FRAME 语义，前者是基于物理行偏移的窗口，后者则是基于逻辑值偏移的窗口。
+
+分析函数语法如下：
+
+```unknow
+analytic_function:
+  analytic_function([ arguments ]) OVER (analytic_clause)
+
+analytic_clause:
+  [ query_partition_clause ] [ order_by_clause [ windowing_clause ] ]
+
+query_partition_clause:
+  PARTITION BY { expr[, expr ]... | ( expr[, expr ]... ) }
+
+order_by_clause:
+  ORDER [ SIBLINGS ] BY{ expr | position | c_alias } [ ASC | DESC ] [ NULLS FIRST | NULLS LAST ] [, { expr | position | c_alias } [ ASC | DESC ][ NULLS FIRST | NULLS LAST ]]...
+
+windowing_clause:
+  { ROWS | RANGE } { BETWEEN { UNBOUNDED PRECEDING | CURRENT ROW | value_expr {
+  PRECEDING | FOLLOWING } } AND{ UNBOUNDED FOLLOWING | CURRENT ROW | value_expr { 
+  PRECEDING | FOLLOWING } } | { UNBOUNDED PRECEDING | CURRENT ROW| value_expr 
+  PRECEDING}}
+```
+
+
+
+SUM/MIN/MAX/COUNT/AVG 
+------------------------------------------
+
+**声明** 
+
+SUM 的语法为：`SUM([ DISTINCT | ALL ] expr) [ OVER (analytic_clause) ]`
+
+MIN 的语法为：`MIN([ DISTINCT | ALL ] expr) [ OVER (analytic_clause) ]`
+
+MAX 的语法为：`MAX([ DISTINCT | ALL ] expr) [ OVER (analytic_clause) ]`
+
+COUNT 的语法为：`COUNT({ * | [ DISTINCT | ALL ] expr }) [ OVER (analytic_clause) ]`
+
+AVG 的语法为：`AVG([ DISTINCT | ALL ] expr) [ OVER(analytic_clause) ]`
+
+**说明** 
+
+以上分析函数都有对应的聚合函数，其中，`SUM` 返回 `expr` 的和，`MIN`/`MAX` 返回 `expr` 的最小值/最大值，`COUNT` 返回窗口中查询的行数，`AVG` 返回 `expr` 的平均值。
+
+对于 `COUNT` 函数，如果指定了 `expr`，即返回 `expr` 不为 NULL 的统计个数，如果指定 `COUNT(*)` 返回所有行的统计数目。
+
+**例子** 
+
+```javascript
+obclient> create table exployees(last_name char(10), salary decimal, job_id char(32));
+Query OK, 0 rows affected (0.17 sec)
+
+obclient> insert into exployees values('jim', 2000, 'cleaner');
+Query OK, 1 row affected (0.03 sec)
+
+obclient> insert into exployees values('mike', 12000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> insert into exployees values('lily', 13000, 'engineering');
+Query OK, 1 row affected (0.01 sec)
+
+obclient> insert into exployees values('tom', 11000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient>select last_name, sum(salary) over(partition by job_id) totol_s, min(salary) over(partition by job_id) min_s, max(salary) over(partition by job_id) max_s, count(*) over(partition by job_id) count_s from exployees;
++-----------+---------+-------+-------+---------+
+| last_name | totol_s | min_s | max_s | count_s |
++-----------+---------+-------+-------+---------+
+| jim       |    2000 |  2000 |  2000 |       1 |
+| mike      |   36000 | 11000 | 13000 |       3 |
+| lily      |   36000 | 11000 | 13000 |       3 |
+| tom       |   36000 | 11000 | 13000 |       3 |
++-----------+---------+-------+-------+---------+
+4 rows in set (0.01 sec)
+```
+
+
+
+NTH_VALUE/FIRST_VALUE/LAST_VALUE 
+-----------------------------------------------------
+
+**声明** 
+
+NTH_VALUE 的语法为：`NTH_VALUE (measure_expr, n) [ FROM { FIRST | LAST } ] [ { RESPECT | IGNORE } NULLS ] OVER (analytic_clause)`
+
+FIRST_VALUE 的语法为：`FIRST_VALUE { (expr) [ {RESPECT | IGNORE} NULLS ] | (expr [ {RESPECT | IGNORE} NULLS ])} OVER (analytic_clause)`
+
+LAST_VALUE 的语法为：`LAST_VALUE { (expr) [ {RESPECT | IGNORE} NULLS ] | (expr [ {RESPECT | IGNORE} NULLS ])} OVER (analytic_clause)`
+
+**说明** 
+
+NTH_VALUE 函数表示第几个值，方向由 `[ FROM { FIRST | LAST } ]` 确定，默认为 `FROM FIRST`，含有是否忽略 NULL 值的标志。其窗口为统一的 `analytic_clause`。这里 `n` 应该是正数，如果 `n` 是 NULL，函数将返回错误；如果 `n` 大于窗口内所有的行数，此函数将返回 NULL。
+
+FIRST_VALUE 和 LAST_VALUE 表示从第一个开始计数或者是从最后一个开始计数。
+
+**例子** 
+
+```javascript
+obclient> create table exployees(last_name char(10), salary decimal, job_id char(32));
+Query OK, 0 rows affected (0.08 sec)
+
+obclient> insert into exployees values('jim', 2000, 'cleaner');
+Query OK, 1 row affected (0.11 sec)
+
+obclient> insert into exployees values('mike', 12000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> insert into exployees values('lily', 13000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> insert into exployees values('tom', 11000, 'engineering');
+Query OK, 1 row affected (0.01 sec)
+
+obclient> select last_name, first_value(salary) over(partition by job_id) totol_s, last_value(salary) over(partition by job_id) min_s, max(salary) over(partition by job_id) max_s from exployees;
++-----------+---------+-------+-------+
+| last_name | totol_s | min_s | max_s |
++-----------+---------+-------+-------+
+| jim       |    2000 |  2000 |  2000 |
+| mike      |   12000 | 11000 | 13000 |
+| lily      |   12000 | 11000 | 13000 |
+| tom       |   12000 | 11000 | 13000 |
++-----------+---------+-------+-------+
+4 rows in set (0.01 sec)
+```
+
+
+
+LEAD/LAG 
+-----------------------------
+
+**声明** 
+
+LEAD 的语法为：`LEAD { ( value_expr [, offset [, default]]) [ { RESPECT | IGNORE } NULLS ] | ( value_expr [ { RESPECT | IGNORE } NULLS ] [, offset [, default]] )} OVER ([ query_partition_clause ] order_by_clause)`
+
+LAG 的语法为：`LAG { ( value_expr [, offset [, default]]) [ { RESPECT | IGNORE } NULLS ] | ( value_expr [ { RESPECT | IGNORE } NULLS ] [, offset [, default]] )} OVER ([ query_partition_clause ] order_by_clause)`
+
+**说明** 
+
+LEAD 和 LAG 含义为可以在一次查询中取出当前行的同一个字段的前面或后面第 N 行的数据，这种操作可以使用相同表的自连接来实现，但 LEAD/LAG 窗口函数有更高的效率。
+
+其中，`value_expr` 是要做比对的字段，`offset` 是 `value_expr` 的偏移量，`default` 参数的默认值为 NULL，即如果在 LEAD/LAG 没有显示的设置 `default` 值的情况下，返回值为 NULL。例如：对 LAG 来说，当前行为 4，`offset` 值为 6，这时候所要找的数据就是第 -2 行，不存在此行即返回 `default` 的值。
+
+`[ { RESPECT | IGNORE } NULLS ]` 的语法为是否考虑 NULL 值，默认为 `RESPECT`，考虑 NULL 值。
+
+注意 LEAD/LAG 两个函数后必须有 `order_by_clause`，数据应该在一个列上排序之后才能有前多少行后多少行的概念。`query_partition_clause` 是可选的，如果没有 `query_partition_clause`，就是全局的数据。
+
+**例子** 
+
+```unknow
+obclient> create table exployees(last_name char(10), salary decimal, job_id char(32));
+Query OK, 0 rows affected (0.08 sec)
+
+obclient> insert into exployees values('jim', 2000, 'cleaner');
+Query OK, 1 row affected (0.11 sec)
+
+obclient> insert into exployees values('mike', 12000, 'engineering');
+Query OK, 1 row affected (0.01 sec)
+
+obclient> insert into exployees values('lily', 13000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> insert into exployees values('tom', 11000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> select last_name, lead(salary) over(order by salary) lead, lag(salary) over(order by salary) lag from exployees;
++-----------+-------+-------+
+| last_name | lead  | lag   |
++-----------+-------+-------+
+| jim       | 11000 |  NULL |
+| tom       | 12000 |  2000 |
+| mike      | 13000 | 11000 |
+| lily      |  NULL | 12000 |
++-----------+-------+-------+
+4 rows in set (0.01 sec)
+```
+
+
+
+STDDEV/VARIANCE/STDDEV_SAMP/STDDEV_POP 
+-----------------------------------------------------------
+
+**声明** 
+
+VARIANCE 的语法为：`VARIANCE([ DISTINCT | ALL ] expr) [ OVER (analytic_clause) ]` 
+
+STDDEV 的语法为：`STDDEV([ DISTINCT | ALL ] expr) [ OVER (analytic_clause) ]` 
+
+STDDEV_SAMP 的语法为：`STDDEV_SAMP(expr) [ OVER (analytic_clause) ]`
+
+STDDEV_POP 的语法为：`STDDEV_POP(expr) [ OVER (analytic_clause) ]`
+
+**说明** 
+
+VARIANCE 返回的是 `expr` 的方差，`expr` 可能是数值类型或者可以转换成数值类型的类型，方差的类型和输入的值的类型相同。
+
+STDDEV 返回的是 `expr` 的标准差，参数类型方面和 VARIANCE 的相同。
+
+STDDEV_SAMP 返回的是样本标准差。
+
+STDDEV_POP 返回的是总体标准差。
+
+**例子** 
+
+```javascript
+obclient> create table exployees(last_name char(10), salary decimal, job_id char(32));
+Query OK, 0 rows affected (0.08 sec)
+
+obclient> insert into exployees values('jim', 2000, 'cleaner');
+Query OK, 1 row affected (0.11 sec)
+
+obclient> insert into exployees values('mike', 12000, 'engineering');
+Query OK, 1 row affected (0.01 sec)
+
+obclient> insert into exployees values('lily', 13000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> insert into exployees values('tom', 11000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> select last_name, stddev(salary) over(order by salary) std, variance(salary) over(order by salary) var, stddev_pop(salary) over() std_pop, stddev_samp(salary) over() from exployees;
++-----------+-------------------+--------------------+-------------------+----------------------------+
+| last_name | std               | var                | std_pop           | stddev_samp(salary) over() |
++-----------+-------------------+--------------------+-------------------+----------------------------+
+| jim       |                 0 |                  0 | 4387.482193696061 |          5066.228051190222 |
+| tom       |              4500 |           20250000 | 4387.482193696061 |          5066.228051190222 |
+| mike      | 4496.912521077347 | 20222222.222222224 | 4387.482193696061 |          5066.228051190222 |
+| lily      | 4387.482193696061 |           19250000 | 4387.482193696061 |          5066.228051190222 |
++-----------+-------------------+--------------------+-------------------+----------------------------+
+4 rows in set (0.00 sec)
+```
+
+
+
+NTILE 
+--------------------------
+
+**声明** 
+
+`NTILE(expr) OVER ([ query_partition_clause ] order_by_clause)`
+
+**说明** 
+
+NTILE 函数将分区中已经排序的行划分为大小尽可能相同的指定数量的分组，并返回给每行组号。`expr` 如果是 NULL，则返回 NULL。
+
+例子
+
+```javascript
+obclient> create table exployees(last_name char(10), salary decimal, job_id char(32));
+Query OK, 0 rows affected (0.08 sec)
+
+obclient> insert into exployees values('jim', 2000, 'cleaner');
+Query OK, 1 row affected (0.11 sec)
+
+obclient> insert into exployees values('mike', 12000, 'engineering');
+Query OK, 1 row affected (0.01 sec)
+
+obclient> insert into exployees values('lily', 13000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> insert into exployees values('tom', 11000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> select last_name, ntile(10) over(partition by job_id order by salary) ntl from exployees;
++-----------+------+
+| last_name | ntl  |
++-----------+------+
+| jim       |    1 |
+| tom       |    1 |
+| mike      |    2 |
+| lily      |    3 |
++-----------+------+
+4 rows in set (0.01 sec)
+```
+
+
+
+ROW_NUMBER 
+-------------------------------
+
+声明
+
+`ROW_NUMBER( ) OVER ([ query_partition_clause ] order_by_clause)`
+
+说明
+
+ROW_NUMBER 函数按照 `order_by_clause` 子句中指定的行的顺序，为每一行分配一个编号。
+
+例子
+
+```javascript
+obclient> create table exployees(last_name char(10), salary decimal, job_id char(32));
+Query OK, 0 rows affected (0.08 sec)
+
+obclient> insert into exployees values('jim', 2000, 'cleaner');
+Query OK, 1 row affected (0.11 sec)
+
+obclient> insert into exployees values('mike', 12000, 'engineering');
+Query OK, 1 row affected (0.01 sec)
+
+obclient> insert into exployees values('lily', 13000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> insert into exployees values('tom', 11000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> select last_name, row_number() over(partition by job_id order by salary) ntl from exployees;
++-----------+------+
+| last_name | ntl  |
++-----------+------+
+| jim       |    1 |
+| tom       |    1 |
+| mike      |    2 |
+| lily      |    3 |
++-----------+------+
+4 rows in set (0.00 sec)
+```
+
+
+
+RANK/DENSE_RANK/PERCENT_RANK 
+-------------------------------------------------
+
+**声** **明** 
+
+RANK 的语法为：`RANK( ) OVER ([ query_partition_clause ] order_by_clause)`
+
+DENSE_RANK 的语法为：`DENSE_RANK( ) OVER([ query_partition_clause ] order_by_clause)`
+
+PERCENT_RANK 的语法为：`PERCENT_RANK( ) OVER ([ query_partition_clause ] order_by_clause)`
+
+**说明** 
+
+RANK 计算每一行数据在某列上的排序，该列由 `order_by_clause` 中的列决定。例如，按照 salary 排序可以看出员工的收入排名。
+
+DENSE_RANK 的语义基本和 RANK 函数相同，但是 RANK 的排序中间会有'跳过'，但是 DENSE_RANK 中不会有。
+
+PERCENT_RANK 的语义基本和 RANK 函数相同，但是 PERCENT_RANK 排序的结果是百分比，计算的是给定行的百分比。
+
+**例子** 
+
+```unknow
+obclient> create table exployees(last_name char(10), salary decimal, job_id char(32));
+Query OK, 0 rows affected (0.10 sec)
+
+obclient> insert into exployees values('jim', 2000, 'cleaner');
+Query OK, 1 row affected (0.11 sec)
+
+obclient> insert into exployees values('mike', 12000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> insert into exployees values('lily', 13000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> insert into exployees values('tom', 11000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> select last_name, rank() over(partition by job_id order by salary) rank, dense_rank() over(partition by job_id order by salary) dense_rank, percent_rank() over(partition by job_id order by salary) percent_rank from exployees;
++-----------+------+------------+----------------------------------+
+| last_name | rank | dense_rank | percent_rank                     |
++-----------+------+------------+----------------------------------+
+| jim       |    1 |          1 | 0.000000000000000000000000000000 |
+| tom       |    1 |          1 | 0.000000000000000000000000000000 |
+| mike      |    2 |          2 | 0.500000000000000000000000000000 |
+| lily      |    3 |          3 | 1.000000000000000000000000000000 |
++-----------+------+------------+----------------------------------+
+4 rows in set (0.01 sec)
+```
+
+
+
+CUME_DIST 
+------------------------------
+
+**声明** 
+
+`CUME_DIST() OVER ([ query_partition_clause ] order_by_clause)`
+
+**说明** 
+
+该函数计算一个值的分布，返回值为大于 0 小于等于 1 的值。作为一个分析函数，CUME_DIST 在升序情况下计算比当前行的特定列小的数据的占比。例如如下例子中，按 job_id 分组并在薪水排序的情况下，每行数据在窗口内的排序列上的占比。
+
+**例子** 
+
+```unknow
+obclient> create table exployees(last_name char(10), salary decimal, job_id char(32));
+Query OK, 0 rows affected (0.10 sec)
+
+obclient> insert into exployees values('jim', 2000, 'cleaner');
+Query OK, 1 row affected (0.11 sec)
+
+obclient> insert into exployees values('mike', 12000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> insert into exployees values('lily', 13000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> insert into exployees values('tom', 11000, 'engineering');
+Query OK, 1 row affected (0.00 sec)
+
+obclient> select last_name, cume_dist() over(partition by job_id order by salary) cume_dist from exployees;
++-----------+----------------------------------+
+| last_name | cume_dist                        |
++-----------+----------------------------------+
+| jim       | 1.000000000000000000000000000000 |
+| tom       | 0.333333333333333333333333333333 |
+| mike      | 0.666666666666666666666666666667 |
+| lily      | 1.000000000000000000000000000000 |
++-----------+----------------------------------+
+4 rows in set (0.01 sec)
+```
+
+

docs/docs/docs-cn/10.sql-reference/3.functions/4.information-functions.md

+信息函数 
+=========================
+
+
+
+FOUND_ROWS 
+-------------------
+
+
+
+**声明** 
+
+`found_rows()`
+
+**说明** 
+
+一个SELECT语句可能包含一个LIMIT子句，用来限制数据库服务器端返回客户端的行数。在某些情况下，我们需要不再次运行该语句而得知在没有LIMIT时到底该语句返回了多少行。我们可以在SELECT语句中选择使用SQL_CALC_FOUND_ROWS, 然后调用FOUND_ROW()函数，获取该语句在没有LIMIT时返回的行数。
+
+例如：
+
+```javascript
+mysql> SELECT SQL_CALC_FOUND_ROWS * FROM tbl_name
+    -> WHERE id > 100 LIMIT 10;
+mysql> SELECT FOUND_ROWS();
+```
+
+
+
+第二个SELECT语句返回一个数字，表示在没有LIMIT子句的情况下，第一个SELECT语句返回了多少行。（若上述的SELECT语句在不使用SQL_CALC_FOUND_ROWS选项时，使用LIMIT和不使用LIMIT时候， FOUND_ROWS()可能会返回不同的结果）。
+
+通过FOUND_ROWS()函数返回的有效行数是瞬时的，并且不能越过SELECT SQL_CALC_FOUND_ROWS语句后面的语句。如果你后续还需要用到这个值，就需要将其保存。
+
+例如:
+
+```javascript
+mysql> SELECT SQL_CALC_FOUND_ROWS * FROM ... ;
+mysql> SET @rows = FOUND_ROWS();
+```
+
+
+
+假如你正在使用SQL_CALC_FOUND_ROWS，系统必须计算出在全部结果集合中有多少行。尽管如此，这也还是比不用LIMIT而再次运行查询要快，原因是结果集合不需要被发送到客户端。
+
+SQL_CALC_FOUND_ROWS和FOUND_ROWS()在当你希望限制一个查询返回的行数时是很有用的，同时还能不需要再次运行查询就可以确定全部结果集合中的行数。一个 **例子** 就是提供页式显示的Web脚本，该显示包含显示搜索结果其他部分的页的链接。使用FOUND_ROWS()使你确定剩下的结果需要多少其他的页。
+
+SQL_CALC_FOUND_ROWS 和 FOUND_ROWS() 的应用对于UNION 查询比对于简单SELECT 语句更为复杂，原因是在UNION 中，LIMIT 可能会出现在多个位置。它可能适用于UNION中的独立的SELECT语句，或是整个的UNION 结果。
+
+SQL_CALC_FOUND_ROWS对于 UNION的期望结果是它返回在没有全局的LIMIT的条件下而应返回的行数。SQL_CALC_FOUND_ROWS 和UNION 一同使用的条件是：
+
+* SQL_CALC_FOUND_ROWS 关键词必须出现在UNION的第一个 SELECT中。
+
+
+
+
+<!-- -->
+
+* FOUND_ROWS()的值只有在使用 UNION ALL时才是精确的。若使用不带ALL的UNION，则会发生两次删除，而FOUND_ROWS() 的指只需近似的。
+
+
+
+
+<!-- -->
+
+* 假若UNION 中没有出现LIMIT ，则SQL_CALC_FOUND_ROWS 被忽略，返回临时表中的创建的用来处理UNION的行数。
+
+
+
+
+
+
+LAST_INSERT_ID() 
+-------------------------
+
+**声明** 
+
+`last_insert_id()`
+
+**说明** 
+
+返回本session最后一次插入的自增字段值，如最近一条insert插入多条记录，LAST_INSERT_ID()返回第一条记录的自增字段值。
+
+**例子** 
+
+```javascript
+mysql>select LAST_INSERT_ID();
++------------------+
+| LAST_INSERT_ID() |
++------------------+
+|                5 |
++------------------+
+1 row in set (0.00 sec)
+```
+
+

docs/docs/docs-cn/10.sql-reference/3.functions/5.other-functions.md

+其它函数 
+=========================
+
+
+
+COALESCE 
+-----------------
+
+**声明** 
+
+`COALESCE(expr, expr, expr,...)`
+
+**说明** 
+
+依次参考各参数表达式，遇到非NULL值即停止并返回该值。如果所有的表达式都是空值，最终将返回一个空值。
+
+所有表达式必须是相同类型，或者可以隐性转换为相同的类型。
+
+**例子** 
+
+```javascript
+Oceanbase>SELECT COALESCE(NULL,NULL,3,4,5), COALESCE(NULL,NULL,NULL);
++---------------------------+--------------------------+
+| COALESCE(NULL,NULL,3,4,5) | COALESCE(NULL,NULL,NULL) |
++---------------------------+--------------------------+
+|                         3 |                     NULL |
++---------------------------+--------------------------+
+1 row in set (0.00 sec)
+```
+
+
+
+
+
+NVL 
+------------
+
+**声明** 
+
+`NVL(str1,replace_with)`
+
+**说明** 
+
+如果 str1 为 NULL，则替换成 replace_with。
+
+任何时候给它一个空值，它都返回一个你所选择的值。这种能够自动替换空值的能力有助于提供看上去更为完善的输出。其中 str1 一般是一个列名。replace_with 可以是任何值：直接值（即硬编码）、对其他列的引用或者表达式。
+
+**例子** 
+
+```javascript
+Oceanbase>SELECT NVL(NULL, 0), NVL(NULL, 'a');
++--------------+----------------+
+| NVL(NULL, 0) | NVL(NULL, 'a') |
++--------------+----------------+
+|            0 | a              |
++--------------+----------------+
+1 row in set (0.00 sec)
+```
+
+
+
+
+
+SLEEP 
+--------------
+
+**声明** 
+
+`SLEEP(duration)`
+
+**说明** 
+
+SLEEP函数根据duration指定的数值暂停相应的时间（单位为秒），并在暂停结束后返回0。
+
+如果SLEEP单独执行且没有被中断，返回结果0；
+
+如果SLEEP单独执行期间被中断，返回结果1，但不会返回任何错误码；
+
+如果SLEEP是查询的一部分，且暂停期间被中断，将会返回错误码1317；
+
+**例子** 
+
+```javascript
+mysql> SELECT SLEEP(1000);
++------------------+
+| SLEEP(1000) |
++------------------+
+|          0 |
++------------------+
+
+mysql> SELECT SLEEP(1000);
++------------------+
+| SLEEP(1000) |
++------------------+
+|          1 |
++------------------+
+
+mysql> SELECT 1 FROM t1 WHERE SLEEP(1000);
+ERROR 1317 (70100): Query execution was interrupted
+```
+
+
+
+
+
+全文查找函数 
+---------------
+
+**声明** 
+
+```javascript
+MATCH (col1,col2,...) AGAINST (expr [search_modifier])
+search_modifier:
+{
+    IN NATURAL LANGUAGE MODE
+    | IN NATURAL LANGUAGE MODE WITH QUERY EXPANSION
+    | IN BOOLEAN MODE
+    | WITH QUERY EXPANSION
+}
+```
+
+
+
+**说明** 
+
+OceanBase1.0已经支持使用全文查找函数来对全文索引进行查找，并且使用全文查找函数有以下要求：
+
+* 全文查找函数MATCH(col1,col2,...)中指定的列上必须有全文索引(OB目前只支持FULLTEXT CTXCAT索引)
+
+  
+
+
+
+
+<!-- -->
+
+* 在FULLTEXT CTXCAT索引中，全文查找函数MATCH(col1,col2,...)中指定的列必须完整的覆盖索引中的全文列，例如FULLTEXT INDEX(c1, c2, c3), CTXCAT(c2, c3) 必须是 MATCH(c2,c3) 才能完全的匹配
+
+  
+
+
+
+
+<!-- -->
+
+* 全文查找函数可以通过上述的关键字来指定查找模式(OB目前只支持NATURAL LANGUAGE MODE和BOOLEAN MODE两种模式)，缺省是NATURAL LANGUAGE MODE
+
+  
+
+
+
+
+默认情况下或者指定IN NATURAL LANGUAGE MODE标示符，MATCH...AGAINST将使用NATURAL LANGUAGE模式来进行全文查找，在NATURAL LANGUAGE模式下，AGAINST接受一个查找字符串，并且按照字符集的比较方式在索引中进行查找，对于表中的每一行数据，MATCH的返回值代表了查找字符串和行中数据的相关度，也就是查找字符串中的文本和数据表中的文本相似度。在默认情况下，OB创建的字符串相关的列是大小写不敏感的，因此，全文查找的关键字是不区分大小写的。如果需要区分大小写，可以为创建全文索引的列指定大小写敏感的数据类型，例如UTF8MB4_BIN。如果MATCH...AGAINST函数被用在WHERE子句中，MATCH被用来过滤跟关键字相关度不匹配的数据，MATCH...AGAINST=0表示没有和关键字相似的数据，目前OB只支持MATCH...AGAINST=0和MATCH...AGAINST\>0两种形式，即完全不相关或者有任意一个关键字相关即可。AGAINST参数中可以接受多个关键字，关键字之间使用' '隔开，表示OR关系，只要有任意一个关键字匹配，即认为符合查找的要求。
+
+OB可以通过使用IN BOOLEAN MODE关键字来进行BOOLEAN模式的全文查找。在这种模式中，关键字前面一些特殊的操作符含有特殊的语义。例如：
+
+```javascript
+SELECT * FROM t1 WHERE MATCH (a, b) AGAINST ('菊花 茉莉花' IN BOOLEAN MODE);
++----+------------+------------+
+| id | a            | b            |
++----+------------+------------+
+|  1 | 支付宝        | 菊花茶        |
+|  2 | 淘宝          | 茉莉花        |
++----+------------+------------+
+
+SELECT * FROM t1 WHERE MATCH (a, b)
+    AGAINST ('+菊花 -茉莉花' IN BOOLEAN MODE);
++----+------------+------------+
+| id | a            | b            |
++----+------------+------------+
+|  1 | 支付宝        | 菊花茶        |
++----+------------+------------+
+```
+
+
+
+OB的BOOLEAN全文查找目前支持以下几种操作符：+ 代表AND关系，表示查找结果中同时要包含被+修饰的关键字- 代表NOT关系，表示查找结果中不能包含被-修饰的关键字。
+
+```javascript
+(no operator) 代表OR关系，表示查找结果中只要包含任意一个没有操作符修饰的关键字即可
+```
+
+
+
+在BOOLEAN全文查找模式中有以下几点需要注意：操作符必须位于关键字的前面，关键字后面的操作符没有修饰意义，例如+菊花是有意义的操作符修饰，而菊花+中的操作符没有修饰意义。操作符和关键字必须紧密相连，不能被其它符号分割开，否者没有修饰意义，例如：+ 菊花前面的操作符没有修饰意义。

docs/docs/docs-cn/10.sql-reference/4.queries-and-subqueries/1.overview-8.md

+概述 
+=======================
+
+
+
+查询(SQL)是指数据库中用来获取数据的方式，它可搭配条件限制的子句(如where)，排列顺序的子句（如order by）等语句来获取查询结果。子查询是指嵌套在一个上层查询中的查询。上层的查询一般被称为父查询或外层查询。子查询的结果作为输入传递回"父查询"或"外部查询"。父查询将这个值结合到计算中，以便确定最后的输出。SQL语言允许多层嵌套查询，即一个子查询中还可以嵌套其他子查询。同时，子查询可以出现在SQL语句中的各种子句中，比如select语句，from语句，where语句等。
+
+子查询 
+------------
+
+在数据库中，子查询可以分成有依赖关系的子查询和没有依赖关系的子查询。有依赖关系的子查询是指该子查询的执行依赖了外部查询的'变量'，所以这种子查询通常会被计算多次。没有依赖关系的子查询是指该子查询的执行不依赖外部查询的'变量', 这种子查询一般只需要计算一次。下图分别展示了一个没有依赖关系的子查询和一个有依赖关系的子查询。
+
+```javascript
+OceanBase (root@test)> create table t1(a int primary key, b int, c int);
+Query OK, 0 rows affected (0.70 sec)
+OceanBase (root@test)> create table t2(a int primary key, b int, c int);
+Query OK, 0 rows affected (0.92 sec)
+-- 没有依赖关系的子查询
+OceanBase (root@test)> select * from t1 where t1.a in (select t2.a from t2);
+Empty set (0.22 sec)
+-- 有依赖关系的子查询，子查询中用到了外层查询变量t1.b
+OceanBase (root@test)> select * from t1 where t1.a in (select t2.a from t2 where t2.b = t1.b);
+Empty set (0.05 sec)
+```
+
+
+
+
+
+子查询展开(subquery unnesting) 
+----------------------------------
+
+子查询展开是数据库的一种优化策略，它把一些子查询置于外层的父查询中，其实质是把某些子查询转化为等价的多表连接操作。这种策略带来的一个明显的好处就是，有写访问路径，连接方法和连接顺序可能被有效的利用，使得查询语句的层次尽可能的减少。下图展示了一个子查询展开的例子，既子查询被改写成了连接语句。
+
+```javascript
+OceanBase (root@test)> create table t1(a int primary key, b int, c int);
+Query OK, 0 rows affected (0.70 sec)
+OceanBase (root@test)> create table t2(a int primary key, b int, c int);
+Query OK, 0 rows affected (0.92 sec)
+--- 有依赖关系的子查询被展开改写成连接
+OceanBase (root@test)> explain select * from t1 where t1.a in (select t2.b from t2 where t2.c = t1.c);
+| =======================================
+|ID|OPERATOR      |NAME|EST. ROWS|COST|
+---------------------------------------
+|0 |HASH SEMI JOIN|    |1        |2924|
+|1 | TABLE SCAN   |t1  |1000     |455 |
+|2 | TABLE SCAN   |t2  |1000     |455 |
+=======================================
+
+Outputs & filters:
+-------------------------------------
+  0 - output([t1.a], [t1.b], [t1.c]), filter(nil),
+      equal_conds([t1.a = t2.b], [t2.c = t1.c]), other_conds(nil)
+  1 - output([t1.c], [t1.a], [t1.b]), filter(nil),
+      access([t1.c], [t1.a], [t1.b]), partitions(p0)
+  2 - output([t2.c], [t2.b]), filter(nil),
+      access([t2.c], [t2.b]), partitions(p0)
+```
+
+

docs/docs/docs-cn/10.sql-reference/5.sql-statement/11.create-database.md

+CREATE DATABASE 
+====================================
+
+
+
+描述 
+-----------
+
+该语句用于创建数据库，并可以指定数据库的默认属性（如数据库默认字符集，校验规则等）。
+
+格式 
+-----------
+
+```javascript
+create_database_stmt:
+    CREATE {DATABASE | SCHEMA} [IF NOT EXISTS] database_name [database_option_list]
+
+database_option_list:
+    database_option [database_option ...]
+
+database_option:
+    [DEFAULT] {CHARACTER SET | CHARSET} [=] charset_name
+  | [DEFAULT] COLLATE [=] collation_name
+  | REPLICA_NUM [=] int_num
+  | PRIMARY_ZONE [=] zone_name
+  | {READ ONLY | READ WRITE}
+  | DEFAULT TABLEGROUP [=] {NULL | table_group_name}
+```
+
+
+
+参数解释 
+-------------
+
+
+
+|               **参数**                |               **描述**               |
+|-------------------------------------|------------------------------------|
+| database_name                       | 指定要修改属性的数据库名称。如果不指定，会对当前默认数据库进行修改。 |
+| CHARSET charset_name                | 指定要修改的字符集。                         |
+| COLLATE collation_name              | 指定校对规则。                            |
+| REPLICA_NUM int_num                 | 指定副本数。                             |
+| PRIMARY_ZONE zone_name              | 指定主Zone。                           |
+| READ ONLY \| READ WRITE             | 设置数据库级只读或读写属性。                     |
+| DEFAULT TABLEGROUP table_group_name | 设置数据库默认表组信息，NULL表示取消数据库默认表组。       |
+
+
+
+示例 
+-----------
+
+* 创建数据库 test2，并指定字符集为UTF8。
+
+
+
+
+```javascript
+OceanBase(admin@test)>create database test2 default CHARACTER SET UTF8;
+Query OK, 1 row affected (0.00 sec)
+```
+
+
+
+* 创建读写属性的数据库test3。
+
+
+
+
+```javascript
+OceanBase(admin@test)>create database test3 READ WRITE;
+Query OK, 1 row affected (0.03 sec)
+```
+
+

docs/docs/docs-cn/10.sql-reference/5.sql-statement/53.SCHEMA.md

+SCHEMA 
+===========================
+
+
+
+`SCHEMA`同`DATABASE`，请参考 CREATE DATABASE、ALTER DATABASE、DROP DATABASE 的详细描述。

docs/docs/docs-cn/11.sql-reference-oracle-mode/3.basic-elements-1/1.built-in-data-types/3.numeric-data-type/1.overview-of-numeric-data-types.md

+数值数据类型概述 
+=============================
+
+
+
+OceanBase 为我们提供了四种存储数值的数据类型，它们分别是 `NUMBER`、`FLOAT`、`BINARY_FLOAT` 和 `BINARY_DOUBLE`。您可以通过这四种数值类型存储定点数、浮点数和零。在数值计算时，数值类型具有不同的优先级，具体信息请查阅 [数值类型的优先级](/zh-CN/11.sql-reference-oracle-mode/3.basic-elements-1/1.built-in-data-types/3.numeric-data-type/5.numeric-priority.md)。
+
+
+|    **数据类**    | **长度（字节）** |                             **说明**                              |
+|---------------|------------|-----------------------------------------------------------------|
+| NUMBER        | 4\~40      | `NUMBER(p,s)` 存储变长、十进制精度的定点数；也可以存储浮点数，此时 `NUMBER` 没有 `p` 和 `s`。 |
+| FLOAT         | 4\~40      | `FLOAT(p)` 是 `NUMBER` 数据类型的子类型。二进制精度范围为 1\~126。`FLOAT` 不是浮点数。   |
+| BINARY_FLOAT  | 4          | 二进制精度浮点数，是一种 32 位单精度浮点数数据类型。                                    |
+| BINARY_DOUBLE | 8          | 二进制精度浮点数，是一种 64 位双精度浮点数数据类型。                                    |
+
+