@clickzetta/cz-cli-darwin-x64 0.3.1

package/bin/skills/lakehouse-doc/references/Zettapark_Data_Engineering_Demo.md

@@ -0,0 +1,348 @@
+# 基于 Lakehouse Zettapark 进行数据工程 Data Engineering
+
+这是一个非常基础的数据工程示例，演示了如何通过云器 Zettapark Python 代码进行读取、分组和写入数据等基本 DataFrame 操作。本示例使用云器Lakehouse内置的免费示例数据库（clickzetta\_sample\_data.tpch\_100g）作为数据源。
+
+步骤如下：
+
+```
+1，通过Zettapark连接到云器Lakehouse
+
+2，通过SupplierKey连接 2个大型表 (LINEITEMS 有 6亿行 & SUPPLIER 有 100 万行)
+
+3，通过将虚拟计算集群调整到不同规格来演示按需扩展
+
+4，对比不同规格的虚拟计算集群对同一个任务的执行时间的不同
+
+    汇总供应商和零件编号的数据以计算总和、最小值和最大值（3500万行）
+
+    将结果数据框写入云器Lakehouse物理表（8000万行）
+```
+
+也可以通过[下载Jupyter Notebook文件](https://github.com/yunqiqiliang/clickzetta_quickstart/blob/main/Zettapark/Zettapark_Data_Engineering_Demo.ipynb)直接运行本实例。
+
+**整个操作从调整计算资源、读取数据、连接、汇总大约需要 30 来秒，向您展示了云器 Lakehouse 强大的功能、即时可扩展性和性能。**
+
+## 安装云器 Zettapark
+
+```python
+# !pip install clickzetta-zettapark-python
+```
+
+## 通过 Zettapark 连接到云器 Lakehouse (Without PySpark)
+
+```python
+import time
+from clickzetta.zettapark.session import Session
+import clickzetta.zettapark.functions as f
+from clickzetta.zettapark import Session, DataFrame
+from clickzetta.zettapark.functions import udf, col
+from clickzetta.zettapark.types import IntegerType
+from clickzetta.zettapark.functions import call_udf
+```
+
+<----- Make these changes before running the notebook --------------------
+Change Connection params to match your environment
+<----------------------------------------------------------------------------
+
+VCLUSTER\_Name = 'default\_ap'
+VCLUSTER\_Size = "XSMALL"
+VCLUSTER\_ReSize = "MEDIUM"
+Workspace\_Name = 'gharchive'
+Schema\_Name = 'Public'
+
+```python
+import json
+from clickzetta.zettapark.session import Session
+# 1- 创建会话连接云器Lakehouse
+# 从配置文件中读取参数
+with open('config.json', 'r') as config_file:
+config = json.load(config_file)
+
+print("正在连接到云器Lakehouse.....n")
+
+
+# 创建会话
+session = Session.builder.configs(config).create()
+
+print("连接成功！...n")
+
+
+```
+
+正在连接到云器Lakehouse.....
+连接成功！...
+
+```python
+sql_cmd = f"CREATE VCLUSTER IF NOT EXISTS {VCLUSTER_Name} VCLUSTER_SIZE = {VCLUSTER_Size} AUTO_SUSPEND_IN_SECOND = 10 "
+print("XSMALL VCLUSTER 创建就绪 n")
+
+session.sql(sql_cmd).collect()
+
+session.use_schema(Schema_Name)
+```
+
+XSMALL VCLUSTER 创建就绪
+
+> 注：计算集群的vcluster\_size参数同时支持以T-shirt size（XSMALL、SMALL、Large等）和以数字（1,2,4,16等）表达的方式，以提供更丰富的计算集群规格，满足不同场景的需要。更多信息详见：[计算集群规格代码变更说明](vcluster_size_description.md)
+
+`config.json` 文件样本([参数说明](https://doc.clickzetta.com/JDBC-Driver))：
+
+```json
+{
+
+  "username": "请替换为您的用户名",
+
+  "password": "请替换为您的密码",
+
+  "service": "请替换为您的服务地址",
+
+  "instance": "请替换为您的实例ID",
+
+  "workspace": "请替换为您的工作空间",
+
+  "schema": "请替换为您的模式",
+
+  "vcluster": "请替换为您的虚拟集群",
+
+  "sdk_job_timeout": 60,
+
+  "hints": {
+
+    "sdk.job.timeout": 60,
+
+    "query_tag": "test_conn_hints_zettapark"
+
+  }
+
+}
+```
+
+## 开始数据工程 Data Engineering Process
+
+```python
+from clickzetta.zettapark.functions import col, sum, min, max
+
+print("Joining, Aggregating with 2 large tables(600M & 1M rows) & Writing results to new table(80M rows) ..n")
+
+# 2- define table
+dfLineItems = session.table("clickzetta_sample_data.tpch_100g.LINEITEM") # 600 Million Rows
+dfSuppliers = session.table("clickzetta_sample_data.tpch_100g.SUPPLIER") # 100K Rows
+
+print('Lineitems Table: %s 行' % dfLineItems.count())
+print('Suppliers Table: %s 行' % dfSuppliers.count())
+
+# 3 - JOIN TABLES
+dfJoinTables = dfLineItems.join(dfSuppliers, dfLineItems["L_SUPPKEY"] == dfSuppliers["S_SUPPKEY"])
+
+# 4 - SUMMARIZE THE DATA BY SUPPLIER, PART, SUM, MIN & MAX
+dfSummary = dfJoinTables.groupBy("S_NAME", "L_PARTKEY").agg(
+sum(col("L_QUANTITY")).alias("TOTAL_QTY"),
+min(col("L_QUANTITY")).alias("MIN_QTY"),
+max(col("L_QUANTITY")).alias("MAX_QTY")
+)
+
+dfSummary.show()
+
+```
+
+```
+Joining, Aggregating with 2 large tables(600M & 1M rows) & Writing results to new table(80M rows) ..
+Lineitems Table: 600037902 行
+Suppliers Table: 1000000 行
+------------------------------------------------------------------
+|         s_name         |   l_partkey    | total_qty | min_qty | max_qty |
+------------------------------------------------------------------
+| Supplier#000102785     |  18602748      |   156.00  |  12.00  |  49.00  |
+| Supplier#000268783     |   8268782      |   228.00  |   1.00  |  44.00  |
+| Supplier#000680518     |  12680517      |   107.00  |   8.00  |  47.00  |
+| Supplier#000981141     |   1731139      |   228.00  |   5.00  |  48.00  |
+| Supplier#000172390     |   1172389      |   192.00  |   1.00  |  38.00  |
+| Supplier#000763964     |   1763963      |   174.00  |   1.00  |  47.00  |
+| Supplier#000087125     |  16337076      |   168.00  |   4.00  |  50.00  |
+| Supplier#000092530     |   1842528      |   169.00  |   1.00  |  48.00  |
+| Supplier#000366762     |  18866725      |   156.00  |   3.00  |  41.00  |
+| Supplier#000785842     |   4285833      |   238.00  |   2.00  |  40.00  |
+------------------------------------------------------------------
+```
+
+```python
+# 2 - READ & JOIN 2 LARGE TABLES (600M & 1M rows)
+from clickzetta.zettapark.functions import col, sum, min, max
+
+print("正在合并和聚合两个大表（6亿行和100万行），并将结果写入新表（8000万行）..n")
+
+dfLineItems = session.table("clickzetta_sample_data.tpch_100g.LINEITEM") # 600 Million Rows
+dfSuppliers = session.table("clickzetta_sample_data.tpch_100g.SUPPLIER") # 1 Million Rows
+
+print('Lineitems Table: %s 行' % dfLineItems.count())
+print('Suppliers Table: %s 行' % dfSuppliers.count())
+
+# 3 - JOIN TABLES
+dfJoinTables = dfLineItems.join(dfSuppliers, dfLineItems["L_SUPPKEY"] == dfSuppliers["S_SUPPKEY"])
+
+# 4 - SUMMARIZE THE DATA BY SUPPLIER, PART, SUM, MIN & MAX
+dfSummary = dfJoinTables.groupBy("S_NAME", "L_PARTKEY").agg(
+sum("L_QUANTITY").alias("TOTAL_QTY"),
+min("L_QUANTITY").alias("MIN_QTY"),
+max("L_QUANTITY").alias("MAX_QTY")
+)
+
+dfSummary.show()
+```
+
+```
+正在合并和聚合两个大表（6亿行和100万行），并将结果写入新表（8000万行）..n
+Lineitems Table: 600037902 行
+Suppliers Table: 1000000 行
+------------------------------------------------------------------
+|         s_name         |  l_partkey   | total_qty | min_qty | max_qty |
+------------------------------------------------------------------
+| Supplier#000543332     |  14043303    |   164.00  |  17.00  |  50.00  |
+| Supplier#000162101     |   6412082    |   243.00  |   3.00  |  49.00  |
+| Supplier#000170221     |   9920211    |   204.00  |  10.00  |  48.00  |
+| Supplier#000652699     |   4402694    |   215.00  |   3.00  |  46.00  |
+| Supplier#000635296     |   1635295    |   153.00  |   3.00  |  29.00  |
+| Supplier#000915082     |   3665078    |   228.00  |   3.00  |  42.00  |
+| Supplier#000624767     |  15624766    |   149.00  |  11.00  |  37.00  |
+| Supplier#000899746     |   4399737    |   202.00  |   1.00  |  48.00  |
+| Supplier#000285255     |   6285254    |   274.00  |  10.00  |  48.00  |
+| Supplier#000052105     |  19552066    |   307.00  |   1.00  |  48.00  |
+------------------------------------------------------------------
+```
+
+## 3. 通过不同计算资源（虚拟集群）完成同样的计算任务需要不同的时间，查看弹性扩缩容的效果。
+
+```python
+start_time = time.time()
+
+# 4 - 将虚拟计算集群大小调整为 XSMALL
+print(f"正在调整到 {VCLUSTER_Size} ..")
+
+sql_cmd = f"ALTER VCLUSTER {VCLUSTER_Name} SET VCLUSTER_SIZE = '{VCLUSTER_Size}' "
+session.sql(sql_cmd).collect()
+
+print("完成！...nn")
+
+
+# 5 - 将结果写入新表（8000万行）
+# <-- 这是当所有之前的操作编译并作为单个作业执行时
+print("正在创建目标 SALES_SUMMARY 表...nn")
+dfSummary.write.mode("overwrite").saveAsTable("SALES_SUMMARY")
+print("目标表已创建！...")
+
+# 6 - 查询结果（8000万行）
+print("正在查询结果...n")
+dfSales = session.table("SALES_SUMMARY")
+dfSales.show()
+end_time = time.time()
+
+print("--- 连接、汇总和写入结果到新表用了 %s 秒 --- n" % int(end_time - start_time))
+print("--- 向 SALES_SUMMARY 表写入了 %s 行" % dfSales.count())
+
+# 7 - 将虚拟计算集群大小减少到 XSMALL
+print("将 VCLUSTER 缩小到 XS...n")
+sql_cmd = "ALTER VCLUSTER {} SET VCLUSTER_SIZE = 'XSMALL'".format(VCLUSTER_Name)
+session.sql(sql_cmd).collect()
+
+print("完成！...n")
+
+```
+
+```
+正在调整到 XSMALL ..
+完成！...
+正在创建目标 SALES_SUMMARY 表...
+目标表已创建！...
+正在查询结果...
+------------------------------------------------------------------
+|         s_name         |   l_partkey   | total_qty | min_qty | max_qty |
+------------------------------------------------------------------
+| Supplier#000966043     |   1216039     |   173.00  |  9.00   |  50.00  |
+| Supplier#000986803     |  17236751     |   164.00  |  5.00   |  41.00  |
+| Supplier#000081344     |    81343      |   112.00  |  7.00   |  50.00  |
+| Supplier#000905118     |  12405093     |   184.00  |  1.00   |  48.00  |
+| Supplier#000922670     |  14172627     |   179.00  |  6.00   |  46.00  |
+| Supplier#000873089     |  12373064     |   126.00  |  9.00   |  37.00  |
+| Supplier#000389530     |   9889511     |   253.00  |  1.00   |  48.00  |
+| Supplier#000668325     |  14668324     |   192.00  |  4.00   |  45.00  |
+| Supplier#000788387     |  11538375     |   222.00  |  7.00   |  49.00  |
+| Supplier#000196264     |  13946250     |   277.00  |  5.00   |  45.00  |
+------------------------------------------------------------------
+
+--- 连接、汇总和写入结果到新表用了 75 秒 ---
+--- 向 SALES_SUMMARY 表写入了 79975543 行
+将 VCLUSTER 缩小到 XS...
+完成！...
+```
+
+```python
+start_time = time.time()
+
+# 4 - 将虚拟计算集群大小增加到 MEDIUM
+print(f"正在将 {VCLUSTER_Size} 调整为 {VCLUSTER_ReSize} ..")
+
+sql_cmd = f"ALTER VCLUSTER {VCLUSTER_Name} SET VCLUSTER_SIZE = '{VCLUSTER_ReSize}'"
+session.sql(sql_cmd).collect()
+
+print("完成！...nn")
+
+
+# 5 - 将结果写入新表（8000万行）
+# <-- 这是当所有之前的操作编译并作为单个作业执行时
+print("正在创建目标 SALES_SUMMARY 表...nn")
+dfSummary.write.mode("overwrite").saveAsTable("SALES_SUMMARY")
+print("目标表已创建！...")
+
+# 6 - 查询结果（8000万行）
+print("正在查询结果...n")
+dfSales = session.table("SALES_SUMMARY")
+dfSales.show()
+end_time = time.time()
+print("--- 连接、汇总和写入结果到新表用了 %s 秒 --- n" % int(end_time - start_time))
+print("--- 向 SALES_SUMMARY 表写入了 %s 行" % dfSales.count())
+
+# 7 - 将虚拟计算集群大小少到 XSMALL
+print("将 VCLUSTER 缩小到 XSMALL...n")
+sql_cmd = f"ALTER VCLUSTER {VCLUSTER_Name} SET VCLUSTER_SIZE = {VCLUSTER_Size}"
+session.sql(sql_cmd).collect()
+
+print("完成！...n")
+
+```
+
+```
+正在将 XSMALL 调整为 MEDIUM ..
+完成！...
+正在创建目标 SALES_SUMMARY 表...
+目标表已创建！...
+正在查询结果...
+------------------------------------------------------------------
+|         s_name         | l_partkey  | total_qty | min_qty | max_qty |
+------------------------------------------------------------------
+| Supplier#000577084     |  3327080   |   220.00  |  15.00  |  49.00  |
+| Supplier#000971635     | 12721622   |   263.00  |   4.00  |  50.00  |
+| Supplier#000914390     |  5664384   |   113.00  |   5.00  |  38.00  |
+| Supplier#000158186     |  2908183   |   241.00  |   7.00  |  46.00  |
+| Supplier#000842304     | 13842303   |   180.00  |  12.00  |  40.00  |
+| Supplier#000024822     |  9524803   |   181.00  |   1.00  |  48.00  |
+| Supplier#000851711     |  7351696   |   346.00  |   3.00  |  50.00  |
+| Supplier#000512255     |  6512254   |   250.00  |   3.00  |  50.00  |
+| Supplier#000392018     | 18141999   |   164.00  |   1.00  |  48.00  |
+| Supplier#000020477     |  9770467   |    81.00  |   4.00  |  25.00  |
+------------------------------------------------------------------
+
+--- 连接、汇总和写入结果到新表用了 18 秒 ---
+--- 向 SALES_SUMMARY 表写入了 79975543 行
+将 VCLUSTER 缩小到 XSMALL...
+完成！...
+```
+
+# **Zettapark 相对于 Spark 和 PySpark 的优势**
+
+*   **迁移快捷**：代码与 Spark/PySpark 基本相同，无需重新学习新语言。
+*   **更便宜**：计算完全 Serverless 化，可以秒级扩缩容（向上/向下），并且仅在使用时运行（产生成本）。
+*   **秒级即时扩缩容**：同样的计算任务，XSMALL 规格的虚拟计算集群 (VCluster) 需要约 75 秒，而 MEDIUM 规格的仅需约 20 秒。
+*   **更快**：消除了所有不必要的数据移动，计算时间更短，成本更低。
+*   **更易使用**：意味着更少的人力投入，因为计算和存储几乎无需维护。
+
+^

package/bin/skills/lakehouse-doc/references/a_comprehensive_guide_to_ingesting_data_into_clickzetta_lakehouse.md

@@ -0,0 +1,66 @@
+# 将数据导入云器 Lakehouse 的完整指南
+
+## 概述
+
+将数据导入云器 Lakehouse 的方法有很多种。不同的场景、要求、团队技能和技术栈选择都可能影响数据采集的决策。本快速入门将指导您完成使用不同方法加载相同数据的示例。
+
+### 数据入仓
+
+* 通过云器 Lakehouse Studio 加载本地文件
+* 通过云器 Lakehouse Studio 批量加载（公网连接）
+* 通过云器 Lakehouse Studio 批量加载（私网连接）
+* 通过云器 Lakehouse Studio 实时多表加载（CDC）
+* 使用 ZettaPark SQL 导入数据
+* 使用 ZettaPark 从 DataFrame 导入数据
+* 来自 Kafka – 采用 ZettaPipe
+* 来自 Kafka – 外部表方式
+* 来自数据湖（对象存储）– SQL Volume 方式
+* 来自数据湖（对象存储）– SQL COPY INTO 方式
+* 来自 External Catalog (Hive) – SQL 方式
+* 从 Java SDK - 使用云器实时写入服务
+
+### 数据入湖
+
+* 通过数据库客户端 DBV/SQLWorkbench PUT 文件的方式
+* 通过 ZettaPark PUT 文件的方式
+
+在本指南结束时，您应该熟悉多种加载数据的方法，并能够根据您的目标和需求选择正确的模式。完成初始项目设置后，每种数据提取方法都可以单独进行，且彼此独立。
+
+### 先决条件
+
+* 云器 Lakehouse 账户需具备创建用户、角色、工作空间、Schema、动态表、虚拟计算集群、数据同步与调度任务等能力。
+* 熟悉 SQL/Python、Kafka 和/或 Java，具体要求因数据加载方式而异。
+* Docker 基础知识
+* 能够在本地运行 Docker 或访问可运行 Kafka 及 Kafka Connector 的环境。
+
+### 您将学到什么
+
+* 如何以及何时使用云器 Lakehouse Studio 进行离线数据同步
+* 如何以及何时使用云器 Lakehouse Studio 进行多表实时数据同步
+* 如何从数据湖导入数据
+* 如何以及何时从文件导入数据
+* 如何从 Kafka 加载数据
+* 如何从流中加载数据
+
+### 需要什么
+
+* [云器Lakehouse](https://www.yunqi.tech/)账户
+* 本指南的 [Github代码库](https://github.com/yunqiqiliang/clickzetta_quickstart/tree/main/a_comprehensive_guide_to_ingesting_data_into_clickzetta)
+
+### Mac 要求
+
+* [Docker](https://docs.docker.com/desktop/install/mac-install/)安装
+* [Conda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/macos.html)安装
+
+### Linux 要求
+
+* [Docker](https://docs.docker.com/engine/install/ubuntu/)安装
+* [Conda](https://docs.conda.io/projects/conda/en/stable/user-guide/install/linux.html)安装
+
+### Windows 要求
+
+* 适用于 Windows 的 [WSL with Ubuntu](https://learn.microsoft.com/en-us/windows/wsl/install)
+* 在 Ubuntu 中安装 [Docker](https://docs.docker.com/engine/install/ubuntu/)
+* 在 Ubuntu 中安装 [Conda](https://docs.conda.io/projects/conda/en/stable/user-guide/install/linux.html)
+
+^

package/bin/skills/lakehouse-doc/references/access-control-configration.md

@@ -0,0 +1,249 @@
+# 配置访问控制
+
+本文介绍如何在云器Lakehouse中为账户和元数据对象配置访问控制策略。通过合理配置访问控制，你可以确保数据与对象的访问仅限于授权用户与角色，符合最小权限原则，提升系统安全性。
+
+## 服务实例级管理
+
+### 为服务实例（instance）指定额外的管理员用户
+
+在云器Lakehouse中，创建服务实例的用户默认拥有“实例管理员”（instance\_admin）角色。为确保至少有一名用户可执行实例层面的管理任务（如创建工作空间、管理实例级角色），当你移除被授予“实例管理员”（instance\_admin）角色的用户时至少需要保留一名用户，否则会收到报错提示。建议至少再指定一名用户为实例管理员，以避免因用户不可用或其他特殊情况造成的影响。
+
+^
+
+### 授予实例级别角色
+
+服务实例级别的角色仅支持通过Web端方式授予。仅具备“服务实例管理员”（instance\_admin）角色的用户可进行此操作。
+
+在服务实例中，依次打开“管理”->“安全”菜单，点击进入，并切换到“角色”页面。
+
+:-: ![](.topwrite/assets/image_1734853864093.png =791)
+
+点击需要授予的服务实例角色，进入该角色的详情页面，点击“用户授予”：
+
+:-: ![](.topwrite/assets/image_1734853972562.png =793)
+
+在弹窗中勾选需要授予的用户，点击“授权”按钮，即可完成实例角色的授予。
+
+^
+
+## 工作空间级管理
+
+### 指定工作空间（workspace）管理员
+
+创建工作空间（workspace）的用户默认拥有该工作空间的"工作空间管理员（workspace\_admin）"角色，该角色具备管理工作空间内的所有权限。每个工作空间内至少需要有一名用户被授予工作空间管理员角色，可以有多个用户被同时授予。
+
+### 管理工作空间内角色和成员
+
+每个工作空间内的角色和成员是与其他工作空间独立的，需要单独授予。仅一个工作空间的工作空间管理员（workspace\_admin）角色，可以管理该工作空间内的角色授予、创建、删除，以及空间内成员的添加、移除。
+
+#### 管理空间成员
+
+一个用户若要在指定工作空间内使用计算集群（Vcluster）和执行SQL，其前提条件是加入该工作空间。工作空间管理员可以通过以下两种方式将指定用户加入工作空间中：
+
+**Web端操作**
+
+进入服务实例后，依次点击菜单中的“管理”-“工作空间”，进入工作空间列表。点击工作空间名称，进入需要添加成员的工作空间详情。
+
+:-: ![](.topwrite/assets/image_1734854163713.png =795)
+
+在工作空间详情页点击“+ 添加用户” 按钮，在弹窗中选择需要添加的用户。只有服务实例中已存在且当前未加入此工作空间的用户才会在列表中显示。勾选一到多名用户，随后点击“添加用户”或“添加用户并授予角色”按钮，将已选择用户添加进入工作空间。成功添加后，可在工作空间的“用户”列表中找到新添加的用户。
+
+在工作空间的“用户”列表中，点击某一用户右侧操作列的“...”，选择“移除用户”，将从工作空间中移除该用户。被移除的用户将立即失去被授予的空间角色，并失去使用工作空间内计算集群（Vcluster）和在该工作空间内执行SQL的权限。
+
+:-: ![](.topwrite/assets/image_1734876545148.png =788)
+
+请注意，从工作空间移除的用户，仍将具备被直接授予给用户的数据权限，即可以在其他工作空间行使被授予的数据权限，对数据进行查询或变更。因此，推荐通过授予角色的方式来管理权限，以降低此类场景带来的权限管理难度。
+
+**SQL操作**
+
+通过JDBC连接工作空间，为工作空间添加用户时执行以下语句：
+
+```SQL
+CREATE USER <user_name>;
+```
+
+\<user\_name>替换为需要加入工作空间的用户名。仅支持添加服务实例中已存在且当前没有加入此工作空间的用户。
+
+从工作空间移除用户执行以下语句：
+
+```SQL
+DROP USER <user_name>;
+```
+
+\<user\_name>替换为需要移除工作空间的用户名。该操作不会删除此用户身份，只会从当前工作空间中移除此用户。
+
+### 使用工作空间级别角色
+
+#### 在工作空间内进行开发
+
+在工作空间中进行开发需要：具备在工作空间中执行SQL的权限（成为工作空间成员后获得）；具备使用工作空间中计算资源的权限；具备需要操作的数据对象的权限。
+
+在每个工作空间中预置了以下角色默认具备以上的一种或多种权限，可将以下角色授予用户，以快速开始数据开发。
+
+**工作空间开发者（workspace\_dev）角色**
+
+workspace\_dev角色默认具备工作空间内所有数据对象（table、view、dynamic table等，详见'元数据对象'）的读写权限，默认具备工作空间内所有计算集群的使用权限。
+
+用户被授予workspace\_dev角色后，可直接在Web页面的"开发"功能内或使用JDBC协议进行数据开发。
+
+注意，workspace\_dev角色默认具备的数据对象读写权限并不支持其将权限二次授权。如需授予其他角色数据对象的读或写权限，请使用具备工作空间管理员（workspace\_admin）角色的用户进行操作。
+
+**数据分析师（workspace\_analyst）角色**
+
+workspace\_analyst角色默认具备工作空间内所有计算集群的使用权限，默认具备工作空间内所有数据对象（table、view、dynamic table等）的read metadata（元数据查看）权限，但是不具备数据对象的select权限，即不能对任何的表或视图执行select查询。使用workspace\_analyst角色进行数据查询分析时，需要授予workspace\_analyst角色要查询数据对象的select权限，以执行数据查询操作。
+
+对workspace\_analyst角色的数据授权操作，请参考“GRANT”语句操作文档。
+
+**使用自定义角色或用户**
+
+自定义角色和用户通过授权，也可在工作空间中执行SQL语句进行开发或数据查询分析，但无法使用Web端的“开发”功能。对自定义角色和用户的授权需要具备workspace\_admin角色的用户进行操作。授权可参考以下语句：
+
+```SQL
+--将工作空间内所有计算集群的使用和元数据查看权限授予自定义角色
+GRANT USE, READ METADATA ON ALL VCLUSTERS TO ROLE <CUSTOM_ROLE_NAME>;
+--[可选]将指定名称的计算集群的使用和元数据查看权限授予自定义角色
+GRANT USE, READ METADATA ON  VCLUSTER <VCLUSTER_NAME> TO ROLE <CUSTOM_ROLE_NAME>;
+
+--将指定名称的schema下所有对象的select和元数据查询权限授予自定义角色
+GRANT SELECT, READ METADATA ON ALL OBJECTS IN SCHEMA <SCHEMA_NAME> TO ROLE <CUSTOM_ROLE_NAME>;
+--将指定table的select和元数据查询权限授予自定义角色
+GRANT SELECT, READ METADATA ON TABLE <TABLE_NAME> TO ROLE <CUSTOM_ROLE_NAME>;
+```
+
+对用户授权时，将上述语句中的 TO ROLE <CUSTOM_ROLE_NAME> 替换为 TO USER <USER_NAME> 即可。
+
+#### 提交并运维工作空间调度任务
+
+在工作空间中提交调度任务只能在Web端的“开发”功能中完成。workspace\_admin(工作空间管理员)和workspace\_dev（工作空间开发者）角色具备“提交”作业脚本成为调度任务的权限。
+
+:-: ![](.topwrite/assets/image_1734876961826.png =802)
+
+^
+
+工作空间中运维调度任务的系统角色为：workspace\_sre（工作空间运维）。具备该角色的用户，可在“运维监控”菜单下的“**任务运维**”和”**监控报警**“功能以及”数据“菜单下的”**数据质量**“功能中，对其所在空间的调度任务进行管理操作。
+
+workspace\_sre（工作空间运维）角色具备该角色所在工作空间下所有调度任务的运维管理权限，不具备工作空间下的计算资源使用和数据对象查询权限。
+
+如需对服务实例内所有工作空间的调度任务进行统一管理，可对用户授予实例级别角色：instance\_sre（实例运维）角色。该角色的权限是服务实例内所有workspace\_sre角色默认权限的并集。
+
+#### 创建自定义角色
+
+为实践“最小权限原则”，建议根据你的组织业务职能划分创建自定义角色，并为其分配针对特定对象和操作的权限。这样，你可以精确控制用户对特定数据或对象的访问范围。
+
+创建自定义角色的一般流程：
+
+1. 创建自定义角色（CREATE ROLE语句）。
+2. 为该角色授予所需的权限点（GRANT语句）。
+3. 将该角色授予给需要相关权限的用户（GRANT ROLE语句或Web端操作）。
+
+**注意**：云器Lakehouse中，角色不能被授予给其他角色，即不支持角色层次结构（Role Hierarchy）。所有角色最终直接授予给用户，避免了因角色间的层级继承关系而带来的、判断具体用户权限范围的复杂度。
+
+#### 授予或移除用户的角色
+
+你可以使用Web或执行授权SQL的操作方式向用户授予或移除角色。仅具备服务实例管理员（instance\_admin）或工作空间管理员（workspace\_admin）角色的用户，可以为用户授予或移除角色。服务实例管理员（instance\_admin）具备向服务实例内所有用户授予实例级别角色的权限；工作空间管理员（workspace\_admin）具备向工作空间内成员授予空间内角色的权限。
+
+**Web端操作**
+
+在“安全”-“角色”页面，可以查看当前实例下的服务实例级别角色和工作空间级别角色。
+
+:-: ![](.topwrite/assets/image_1734878372389.png =784)
+
+服务实例管理员（instance\_admin）角色可查看所有的实例级别角色和所有工作空间级别角色，可管理所有实例级别角色的授权；
+
+工作空间管理员（workspace\_admin）角色可查看本工作空间内的所有工作空间角色，并管理这些角色的授权。如一个用户同时具备多个工作空间的工作空间管理员（workspace\_admin）角色，则可以同时管理多个工作空间内的角色授权。
+
+对任一角色授权时，点击该角色名称，进入角色详情页，此时可以查看该角色已被授予的所有用户。点击“+ 用户授予”，在弹窗中勾选需要添加的用户，点击“授权”，即可将角色授予用户。
+:-: ![](.topwrite/assets/image_1734878510613.png =798)
+
+移除角色被授予的用户时，点击用户名右侧的"..."，选择“移除用户”，即可取消该用户使用这个角色的权限。
+
+在“管理”-“工作空间”列表进入工作空间详情页面，在“角色”页签也可以查看该空间内的角色列表，并通过上述操作将该角色授予或取消授予用户。
+
+:-: ![](.topwrite/assets/image_1734878871234.png =795)
+
+***
+
+**SQL端操作**
+
+仅工作空间级别的用户支持使用SQL操作进行授权。在工作空间内执行以下语句，可将空间内的角色授予指定用户。
+
+```SQL
+Grant ROLE <ROLE_NAME> TO USER <USER_NAME>;
+```
+
+执行以下语句可移除角色中的指定用户；
+
+```SQL
+REVOKE ROLE <ROLE_NAME> FROM USER <USER_NAME>;
+```
+
+### 示例：创建自定义角色并授予权限
+
+**提示**：当前暂不支持在 Web 端创建自定义角色和对自定义角色授权。你需要使用 SQL 创建自定义角色。
+
+假设你希望创建一个空间级角色r1，用于管理特定schema s1下的一张表t1。为此，需要为r1授予：
+
+* 对计算集群（假设名称为v1）的使用权限（USAGE）。
+* \[可选] 计算集群（假设名称为 v1）的 READ METADATA 权限，以在计算集群页面或 SHOW VCLUSTERS 结果中可见这个计算集群；
+* 对表s1.t1的ALL权限，以对表执行select、insert、update、alter等操作。
+
+#### 创建自定义角色
+
+```
+CREATE ROLE r1;
+```
+
+#### 为角色授予权限
+
+```
+-- 为r1角色授予对计算集群（假设名称为v1）的使用权限（USAGE）
+GRANT use ON VCLUSTER v1 TO ROLE r1;
+--[可选]为r1角色授予对计算集群（假设名称为v1）的read metadata权限
+GRANT read metadata ON VCLUSTER v1 TO ROLE r1;
+
+
+--为r1角色授予对表s1.t1的所有权限
+GRANT all ON table s1.t1 to ROLE r1;
+
+```
+
+#### 将角色授予给用户
+
+```
+GRANT ROLE r1 TO USER u1;
+```
+
+### 示例：创建只读角色
+
+若你需要一个角色仅能对某schema中所有表进行查询（只读访问），可按照与创建自定义角色相同的流程操作。区别在于这个场景下仅授予表的SELECT和READ METADATA权限，而不包含任何写入、修改、删除等权限。同时，这里使用 `ALL TABLES IN SCHEMA s1` 来表达 s1 下当前和未来的所有 table 对象，以简化授权表达。
+
+例如，为read\_only角色授予schema s1下所有表的SELECT和READ METADATA权限：
+
+```
+GRANT SELECT, READ METADATA ON ALL TABLES IN SCHEMA s1 TO ROLE read_only;
+```
+
+请注意，如果read\_only角色没有计算集群的使用权限，此时无法使用计算资源对table执行查询。所以还需要至少授予该角色1个计算集群（vcluster）的使用权限。
+
+例如，为read\_only角色授予名称为demo\_vcluster的计算集群的使用权限。
+
+```
+GRANT USE ON VCLUSTER demo_vcluster TO ROLE read_only;
+```
+
+### 查看已授予的权限
+
+使用SHOW GRANTS命令可查看某对象或角色的当前权限状况。例如：
+
+```
+-- 查看schema d1.s1上的已授予权限
+SHOW GRANTS ON SCHEMA d1.s1;
+
+-- 查看角色r1获得的权限
+SHOW GRANTS TO ROLE r1;
+
+-- 查看用户smith获得的权限和角色
+SHOW GRANTS TO USER smith;
+```
+
+^