# Dataset APIs
 #### columns
**描述**：获取Dataset的所有列的列名集合。
**语法格式**：
```
columns()
```
**输入参数**：无
**返回值类型**：tuple\[str, ...\]
**示例**：
```
>>> from aura_frame.multimodal import ai_lake 
>>> con = ai_lake.connect( 
...     aura_endpoint='*', 
...     access_key='*', 
...     secret_key='*' 
...     
... 
... ) 
>>> ds = con.load_dataset("demo_table_10", database='my_schema') 
>>> ds.columns 
('species',
  'island',
  'bill_length_mm',
  'bill_depth_mm',  'flipper_length_mm')
```
 #### add_column
**描述**：给一个Dataset添加列。
**语法格式**：
```
add_column(*exprs, **mutations)
```
**输入参数**：
| 参数     | 是否必选 | 参数类型                              | 描述               |
|:---|:---|:---|:---|
| exprs    | 否   | Union\[Sequence\[Expr\], None\] | 要添加为列的命名表达式序列。 |
| mutations | 否  | Value                             | 使用关键字参数的命名表达式。   |
   
**返回值类型**：已添加新列的Dataset。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake 
>>> con = ai_lake.connect( 
...     aura_endpoint='*', 
...     access_key='*' 
...     secret_key='*' 
...     ... 
... ) 
>>> ds = con.load_dataset("demo_table_6", database='my_schema') 
>>> ds 
| species | bill_length_mm |
| ------- | -------------- |
| string  | float64        |
| ------- | -------------- |
| Adelie  | 40.0           |
| Adelie  | 41.0           |
| Adelie  | 42.0           |
| Adelie  | 43.0           |
#Add a new column from a per-element expression
>>> ds.add_column(new_col=ds.bill_length_mm + 1)
| species | bill_length_mm | new_col  |
| ------- | -------------- | -------- |
| string  | float64        | float64  |
| ------- | -------------- | -------- |
| Adelie  | 40.0           | 41.0     |
| Adelie  | 41.0           | 42.0     |
| Adelie  | 42.0           | 43.0     |
| Adelie  | 43.0           | 44.0     |
```
 #### drop_columns
**描述**：删除Dataset的列。
**语法格式**：
```
drop_columns(*fields)
```
**输入参数**：
| 参数     | 是否必选 | 参数类型 | 描述        |
|:---|:---|:---|:---|
| fields | 是 | str | 被删除列的列名。 |
   
**返回值类型**：删除列后的Dataset。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_12", database='my_schema')
>>> ds
| species | island    | bill_length_mm | bill_depth_mm | flipper_length_mm |
| ------- | --------- | -------------- | ------------- | ----------------- |
| string  | string    | float64        | float64       | int64             |
| ------- | --------- | -------------- | ------------- | ----------------- |
| Adelie  | Torgersen | 40.0           | 22.0          | 180               |
| Adelie  | Torgersen | 41.0           | 19.0          | 183               |
| Adelie  | Torgersen | 42.0           | 20.0          | 190               |
| Adelie  | Torgersen | 43.0           | 23.0          | 185               |
# Drop one or more columns
>>> ds.drop_columns("species")
| island    | bill_length_mm | bill_depth_mm | flipper_length_mm |
| --------- | -------------- | ------------- | ----------------- |
| string    | float64        | float64       | int64             |
| --------- | -------------- | ------------- | ----------------- |
| Torgersen | 40.0           | 22.0          | 180               |
| Torgersen | 41.0           | 19.0          | 183               |
| Torgersen | 42.0           | 20.0          | 190               |
| Torgersen | 43.0           | 23.0          | 185               |
```
 #### aggregate
**描述**：通过指定分组字段，用一组聚合函数对数据集进行聚合。
**语法格式**：
```
aggregate(metrics=(), /, *, by=(), having=(), **kwargs)
```
**输入参数**：
| 参数       | 是否必选 | 参数类型                                          | 描述                                             |
|:---|:---|:---|:---|
| metrics | 否    | Union\[Sequence\[AggregateFnBuilder\], None\] | 聚合表达式，这类表达式可以是任何能生成标量值的表达式，其中包括聚合函数，例如sum。      |
| by      | 否  | Union\[Sequence\[Value\], None\]                | 分组表达式，一般设为Dataset的列名集合。                       |
| having   | 否 | Union\[Sequence\[BooleanValue\], None\]         | 聚合后过滤器。其数据维度应该与metrics相同，且having（子句）的输出类型为布尔型。 |
| kwargs  | 否   | -                                               | 命名的聚合表达式。                                      |
   
**返回值类型**：聚合后的Dataset。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_13", database='my_schema')
>>> ds
| fruit  | price |
| ------ | ----- |
| apple  | 0.50  |
| apple  | 0.50  |
| banana | 0.25  |
| orange | 0.33  |
>>> ds.aggregate(
...     by=["fruit"],
...     total_cost=ds.price.sum(),
...     avg_cost=ds.price.mean(),
...     having=ds.price.sum() < 0.5,
... ).order_by("fruit")
| fruit  | total_cost | avg_cost |
| ------ | ---------- | -------- |
| string | float64    | float64  |
| ------ | ---------- | -------- |
| banana | 0.25       | 0.25     |
| orange | 0.33       | 0.33     |
```
 #### count
**描述**：计算该Dataset的总行数。
**语法格式**：
```
count()
```
**输入参数**：无
**返回值类型**：int
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_11", database='my_schema')
>>> ds
| a     |
| ----- |
| string|
| ----- |
| foo   |
| bar   |
| baz   |
>>> ds.count()
┌─┐
│ 3│
└─┘
```
 #### execute
**描述**：执行表达式。
**语法格式**：
```
execute(*, limit='default', params=None,  block=False, **kwargs)
```
**输入参数**：
| 参数     | 是否必选 | 参数类型                                | 描述                              |
|:---|:---|:---|:---|
| limit  | 否    | Union\[int, str, None\]               | 限定表达式执行结果的总行数。                 |
| params   | 否     | Union\[Mapping\[Value, Any\], None\] | 标量参数表达式到值的映射。                   |
| block  | 否     | bool                                 | 表示是否异步执行，若为True，就返回AsyncJob对象。 |
| kwargs | 否       | -                                    | 关键字参数                         |
   
**返回值类型**：Union\[pandas.DataFrame, pandas.Series, AsyncJob ,Any\]
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_8", database='my_schema')
>>> ds.execute()
       a     b
0      1     c
1      1     a
2      2     a
[3 rows x 2 columns]
```
 #### filter
**描述**：过滤掉不满足条件的行。
**语法格式**：
```
filter(expr=None, fn=None, on=None, num_cpus=None, memory=None, arch=None, device=None, model=None, num_models=None, concurrency=None, **fn_constructor_kwargs)
```
**输入参数**：
| 参数                    | 是否必选 | 参数类型                                                                         | 描述                        |
|:---|:---|:---|:---|
| expr                   | 否   | Union\[list\[ir.BooleanValue\], Sequence\[ir.BooleanValue\], IfAnyAll, None\] | 表达式字符串，需为有效的Python表达式。    |
| on                     | 否  | Union\[str, list\[str\]\]                                                     | 用于应用函数的列。                  |
| fn                     | 否    | Union\[str, Callable, None\]                                                    | 可调用的函数，或函数名称。            |
| num_cpus             | 否   | Union\[float, None\]                                                          | CPU的数量。                   |
| memory                 | 否 | Union\[int, None\]                                                           | 内存大小，单位为MB。                |
| arch                   | 否    | Union\[str, None\]                                                            | 架构类型，参数值为x86或arm。        |
| device                 | 否   | Union\[str, None\]                                                            | AI处理单元的类型名，参数值为NPU或GPU。   |
| model                    | 否   | Union\[str, None\]                                                           | AI处理单元型号，例如910B、A100等。    |
| num_models             | 否   | Union\[float, None\]                                                         | AI处理单元的数量，仅NPU和GPU支持配置。   |
| concurrency           | 否   | Union\[int, Tuple\[int, int\], None\]                                         | 函数执行时的并发度。                 |
| fn_constructor_kwargs | 否    | -                                                                            | 构造参数，只有当fn为可调用类时，才能提供此项。 |
   
**返回值类型**：过滤掉不满足条件的行后的Dataset。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_3", database='my_schema')
>>> ds = ds.filter(expr=[ds.a < 2])
>>> ds
| a     | b     |
| ----- | ----- |
| int64 | string|
| ----- | ----- |
| 1     | c     |
| 1     | a     |
# Filtered by User-defined functions
# my_schema.id_filter:inputting an int value, returning false if value is larger than 2.
>>> ds = con.load_dataset("demo_table_2", database='my_schema')
>>> ds = ds.filter(
...     fn='my_schema.id_filter',
...     on='a',
... )
>>> ds
| a     | b     |
| ----- | ----- |
| int64 | string|
| ----- | ----- |
| 1     | c     |
| 1     | a     |
```
 #### flat_map
**描述**：将给定的函数应用于每一行，并对结果进行展平。
**语法格式**：
```
flat_map(fn, on, as_col=None, num_cpus=None, memory=None, arch=None, device=None, model=None, num_models=None, concurrency=None, **fn_constructor_kwargs)
```
**输入参数**：
| 参数                   | 是否必选 | 参数类型                                  | 描述                                   |
|:---|:---|:---|:---|
| fn                    | 是   | Union\[str, Callable\]                 | 可调用的函数或其名称，例如myschema.myfunction。      |
| on                   | 是   | Union\[str, list\[str\], \]            | 要应用函数的列或列的集合。                         |
| as_col               | 否   | Union\[str, list\[str\], None\]       | 输出新列的名称。as_col的长度必须与fn返回的结构体中字段数量一致。 |
| num_cpus              | 否  | Union\[float, None\]                    | CPU的数量。                                 |
| memory               | 否  | Union\[int, None\]                    | 内存大小，单位为MB。                          |
| arch                  | 否    | Union\[str, None\]                     | 架构类型，参数值为x86或arm。                    |
| device                | 否   | Union\[str, None\]                    | AI处理单元的类型名，参数值为NPU或GPU。               |
| model                 | 否   | Union\[str, None\]                     | AI处理单元型号，例如910B、A100等。                  |
| num_models            | 否    | Union\[float, None\]                   | AI处理单元的数量，仅NPU和GPU支持配置。               |
| concurrency          | 否    | Union\[int, Tuple\[int, int\], None\] | 函数执行时的并发度。                            |
| fn_constructor_kwargs | 否  | -                                     | 构造参数，只有当fn为可调用类时，才能提供此项。              |
   
**返回值类型**：
Dataset ：调用函数后包含名为as_col的新列的数据集。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_2", database='my_schema')
>>> ds.execute()
       a     b     c
0      1     4     1
[1 rows x 3 columns]
>>> ds = ds.flat_map(
...     fn='my_schema.py_generate_series',
...     on=['a', 'b', 'c'],
...     as_col=['outCol'])
>>> ds
| a     | b     | c     | outCol |
| ----- | ----- | ----- | ------ |
| int64 | int64 | int64 | int64  |
| ----- | ----- | ----- | ------ |
| 1     | 4     | 1     | 1      |
| 1     | 4     | 1     | 2      |
| 1     | 4     | 1     | 3      |
| 1     | 4     | 1     | 4      |
# Access table columns using the ds.attribute (dot notation) style
>>> ds = ds.flat_map(
...     fn='my_schema.py_generate_series',
...     on=[ds.a, ds.b, ds.c],
...     as_col='udtf_col')
>>> ds
| a     | b     | c     | udtf_col |
| ----- | ----- | ----- | -------- |
| int64 | int64 | int64 | int64    |
| ----- | ----- | ----- | -------- |
| 1     | 4     | 1     | 1        |
| 1     | 4     | 1     | 2        |
| 1     | 4     | 1     | 3        |
| 1     | 4     | 1     | 4        |
```
 #### map_batches
**描述**：将给定的函数应用于批量数据。
**语法格式**：
```
map_batches(fn, on, as_col=None, num_cpus=None, memory=None, arch=None, device=None, model=None, num_models=None, concurrency=None, **fn_constructor_kwargs)
```
**输入参数**：
| 参数                  | 是否必选 | 参数类型                                   | 描述                                     |
|:---|:---|:---|:---|
| fn                  | 是       | Union\[str, Callable\]                | 可调用的函数或其名称，例如myschema.myfunction。      |
| on                  | 是     | Union\[str, list\[str\], \]            | 要应用函数的列或列的集合。                         |
| as_col              | 否    | Union\[str, list\[str\], None\]       | 输出新列的名称。as_col的长度必须与fn返回的结构体中字段数量一致。 |
| num_cpus            | 否     | Union\[float, None\]                   | CPU的数量。                             |
| memory               | 否     | Union\[int, None\]                      | 内存大小，单位为MB。                          |
| arch                 | 否      | Union\[str, None\]                     | 架构类型，参数值为x86或arm。                       |
| device              | 否    | Union\[str, None\]                   | AI处理单元的类型名，取值为NPU或GPU。                |
| model                | 否     | Union\[str, None\]                      | AI处理单元型号，例如910B、A100等。               |
| num_models            | 否     | Union\[float, None\]                    | AI处理单元的数量，仅NPU和GPU支持配置。              |
| concurrency         | 否     | Union\[int, Tuple\[int, int\], None\] | 函数执行时的并发度。                           |
| fn_constructor_kwargs | 否       | -                                     | 构造参数，只有当fn为可调用类时，才能提供此项。               |
   
**返回值类型**：
Dataset：调用函数后包含名为as_col的新列的数据集。
 #### groupby
**描述**：创建一个分组的Dataset。
**语法格式**：
```
groupby(*by, **key_exprs)
```
**输入参数**：
| 参数        | 是否必选 | 参数类型                                 | 描述       |
|:---|:---|:---|:---|
| by        | 否    | Union\[str, Iterable\[str\], None\] | 分组表达式。 |
| key_exprs | 否 | Union\[str, Iterable\[str\]\]       | 命名的分组表达式。 |
   
**返回值类型**：一个分组后的Dataset。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_14", database='my_schema')
>>> ds
| fruit  | price |
| ------ | ----- |
| string | float |
| ------ | ----- |
| apple  | 0.50  |
| apple  | 0.50  |
| banana | 0.25  |
| orange | 0.33  |
```
 #### join
**描述**：在两个Dataset之间执行join操作。
**语法格式**：
```
join(ds, /, on=(), *, join_type='inner', left_suffix='left_', right_suffix='right_')
```
**输入参数**：
| 参数             | 是否必选 | 参数类型                                                                                                        | 描述                                   |
|:---|:---|:---|:---|
| ds           | 是   | Dataset                                                                                                     | 右侧要连接的数据集。                           |
| on           | 否  | Union\[str, Sequence\[Union\[str, BooleanColumn, Literal\[True\], Literal\[False\], tuple\[str, str\]\]\]\] | 连接条件，详见示例。                            |
| join_type    | 否  | JoinKind                                                                                                    | 连接方法，如 "inner" 或 "left"。             |
| left_suffix | 否   | str                                                                                                          | 用于重命名左侧表中重叠列的格式字符串后缀（例如 "left_"）。 |
| right_suffix | 否   | str                                                                                                         | 用于重命名右侧表中重叠列的格式字符串后缀（例如 "right_"）。  |
   
**返回值类型**：join后的Dataset。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds1 = con.load_dataset("demo_table_15", database='my_schema')
>>> ds2 = con.load_dataset("demo_table_16", database='my_schema')
# Equality inner join on the shared id column. Note the _right suffix added to all overlapping columns from the right # table (in this case only the "id" column).
>>> ds1.join(ds2, "id", join_type="inner")
|   id   |  fruit  |  price  |     color     |
| ------ | ------- | ------- | ------------- |
| int64  | string  | float64 | string        |
| ------ | ------- | ------- | ------------- |
|      2 |   apple |    0.25 | Yellow        |
|      3 |  banana |    0.33 | Orange        |
# Explicit equality join using the default join_type value of "inner". Note join_type there is no _right suffix added # to the movieId column since this is an inner join and the movieId column is part of the join condition.
>>> ds1.join(ds2, ds1.id == ds2.id)
|   id   |  fruit  |  price  |     color     |
|---|---|---|---|
| int64  | string  | float64 | string        |
|---|---|---|---|
|      2 |   apple |    0.25 | Yellow        |
|      3 |  banana |    0.33 | Orange        |
```
 #### map
**描述**：对当前Dataset的每一行应用给定函数。
**语法格式**：
```
map(fn, on, as_col=None, num_cpus=None, memory=None, arch=None, device=None, model=None, num_models=None, concurrency=None, **fn_constructor_kwargs)
```
**输入参数**：
| 参数                    | 是否必选 | 参数类型                                 | 描述                                       |
|:---|:---|:---|:---|
| fn                      | 是     | Union\[str, Callable\]                | 可调用函数或其名称，如myschema.myfunction。        |
| on                       | 是    | Union\[str, list\[str\], \]           | 要应用函数的列或列的集合。                         |
| as_col                   | 否    | Union\[str, list\[str\], None\]         | 输出新列的名称。as_col的长度必须与fn返回的结构体中字段数量一致。 |
| num_cpus                | 否      | Union\[float, None\]                  | CPU的数量。                                |
| memory                | 否      | Union\[int, None\]                    | 内存大小，单位为MB。                             |
| arch                    | 否     | Union\[str, None\]                    | 架构类型，取值为x86或arm。                     |
| device                   | 否    | Union\[str, None\]                   | AI处理单元的类型名，取值为NPU或GPU。                |
| model                    | 否    | Union\[str, None\]                  | AI处理单元型号，例如910B、A100等。                  |
| num_models               | 否      | Union\[float, None\]                   | AI处理单元的数量，仅NPU和GPU支持配置。               |
| concurrency            | 否    | Union\[int, Tuple\[int, int\], None\] | 函数执行时的并发度。                            |
| fn_constructor_kwargs | 否    | -                                     | 构造参数，只有当fn为可调用类时，才能提供此项。               |
   
**返回值类型：**
Dataset：调用函数后包含新列（列名为as_col）的数据集。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table", database='my_schema')
>>> ds = ds.map(
...     fn='my_schema.multiply_2',
...     on=['col_a'],
...     as_col='col_c'
... )
>>> ds
| col_a | col_b | col_c |
|---|---|---|
| int64 | string | int64 |
|---|---|---|
|     1 | c     | 2     |
|     1 | a     | 2     |
|     2 | a     | 4     |
```
 #### order_by
**描述**：根据一个或多个表达式对Dataset进行排序。
**语法格式**：
```
order_by(key, descending=False)
```
**输入参数**：
| 参数         | 是否必选 | 参数类型                            | 描述                        |
|:---|:---|:---|:---|
| key       | 否  | Union\[str, List\[str\], None\] | 用于排序的表达式。                 |
| descending | 否    | Union\[bool, List\[bool\]\]    | 是否按降序排序（DESC），默认为False。 |
   
**返回值类型**：排序后的Dataset。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_15", database='my_schema')
>>> ds
| a     | b      | c     |
|---|---|---|
| 3     | a      | 4     |
| 2     | B      | 6     |
| 1     | c      | 5     |
| 3     | D      | 7     |
# Sort by b. Default is ascending. Note how capital letters come before lowercase
>>> ds.order_by("b")
| a     | b      | c     |
|---|---|---|
| int64 | string | int64 |
|---|---|---|
| 2     | B      | 6     |
| 3     | D      | 7     |
| 3     | a      | 4     |
| 1     | c      | 5     |
# Sort in descending order
>>> ds.order_by(ds.b.desc())
| a     | b      | c     |
|---|---|---|
| int64 | string | int64 |
|---|---|---|
| 1     | c      | 5     |
| 3     | a      | 4     |
| 3     | D      | 7     |
| 2     | B      | 6     |
# Sort by multiple columns/expressions
>>> ds.order_by(["a", ds.c.desc()])
| a     | b      | c     |
|---|---|---|
| int64 | string | int64 |
|---|---|---|
| 1     | c      | 5     |
| 2     | B      | 6     |
| 3     | D      | 7     |
| 3     | a      | 4     |
```
 #### rename_columns
**描述**：重命名Dataset中的列。
**语法格式**：
```
rename_columns(names, /, **substitutions)
```
**输入参数**：
| 参数             | 是否必选 | 参数类型                 | 描述                                            |
|:---|:---|:---|:---|
| names         | 是      | Mapping\[str, str\] | 映射（字典），以 {新列名: 旧列名} 的形式指定重命名规则，未在映射中出现的列将保留原名。 |
| substitutions | 否     | str                | 显式重命名的列，以关键字参数形式指定，格式为新名=旧名。                 |
   
**返回值类型**：重命名后的新Dataset。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_8", database='my_schema')
>>> ds
| a     | b      |
|---|---|
| int64 | string |
|---|---|
| 1     | c      |
| 1     | a      |
| 2     | a      |
>>> ds.rename_columns({"rename_col": "a"})
| rename_col | b      |
|---|---|
| int64      | string |
|---|---|
| 1          | c      |
| 1          | a      |
| 2          | a      |
```
 #### schema
**描述**：返回Dataset的schema。
**语法格式**：
```
schema()
```
**输入参数**：无。
**返回值类型**：Schema对象。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_7", database='my_schema')
>>> ds.schema()
ibis.Schema {
  species            string
  island             string
  bill_length_mm     float64
  bill_depth_mm      float64
  flipper_length_mm  int64
}
```
 #### select_columns
**描述**：从Dataset的列中选取指定的列。
**语法格式**：
```
select_columns(*exprs, **named_exprs)
```
**输入参数**：
| 参数           | 是否必选 | 参数类型                                                 | 描述                             |
|:---|:---|:---|:---|
| exprs       | 是    | Union\[Value, str, Iterable\[Union\[Value, str\]\]\] | 列表达式、列名字符串，或由列表达式和列名字符串组成的列表。 |
| named_exprs | 否   | Union\[Value, str\]                                   | 列表达式（支持命名参数形式）。                 |
   
**返回值类型**：包含选定列的Dataset。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_5", database='my_schema')
>>> ds.select_columns("species", "bill_length_mm")
| species    | bill_length_mm |
|---|---|
| string     | float64        |
|---|---|
| Adelie     | 40.0           |
| Adelie     | 41.0           |
| Adelie     | 42.0           |
| Adelie     | 43.0           |
# Selection by zero-indexed column position
>>> ds.select_columns(ds[0], ds[4])
| species    | flipper_length_mm |
|---|---|
| string     | int64             |
|---|---|
| Adelie     | 180               |
| Adelie     | 183               |
| Adelie     | 190               |
| Adelie     | 185               |
```
 #### show
**描述**：显示查询结果生成的数据。
**语法格式**：
```
show(limit=10)
```
输入参数：
| 参数    | 是否必选 | 参数类型  | 描述              |
|:---|:---|:---|:---|
| limit | 否      | int | 限制输出的行数，默认为10。 |
   
**返回值类型**：None。
 #### take
**描述**：从Dataset中返回最多limit行数据，该方法适用于数据检查和预览。
**语法格式**：
```
take(limit)
```
**输入参数**：
| 参数   | 是否必选 | 参数类型 | 描述       |
|:---|:---|:---|:---|
| limit | 是  | int    | 要返回的最大行数。 |
   
**返回值类型**: list\[dict\[str, Any\]\] ：包含数据集中最多limit行的列表，每行以字典形式表示。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_9", database='my_schema')
>>> ds.take(3)
[{'a': 1}, {'a': 1}, {'a': 2}]
```
 #### max
**描述**：计算Dataset中指定列的最大值。
**语法格式**：
```
max(on=None)
```
**输入参数**：
| 参数     | 是否必选 | 参数类型                        | 描述         |
|:---|:---|:---|:---|
| on | 否   | Union\[str, list\[str\], None\] | 指定要计算最大值的列。 |
   
**返回值类型**：Dataset
 #### min
**描述**：计算Dataset中指定列的最小值。
**语法格式**：
```
min(on=None)
```
**输入参数**：
| 参数   | 是否必选 | 参数类型                            | 描述          |
|:---|:---|:---|:---|
| on | 否       | Union\[str, list\[str\], None\] | 指定要计算最小值的列。 |
   
**返回值类型**：Dataset
 #### mean
**描述**：计算Dataset中指定列的均值。
**语法格式**：
```
mean(on=None)
```
**输入参数**：
| 参数 | 是否必选 | 参数类型                            | 描述         |
|:---|:---|:---|:---|
| on  | 否    | Union\[str, list\[str\], None\] | 指定要计算均值的列。 |
   
**返回值类型**：Dataset。
 #### unique
**描述**：计算Dataset中指定列的唯一值集合。
**语法格式**：
```
unique(col)
```
**输入参数**：
| 参数 | 是否必选 | 参数类型 | 描述           |
|:---|:---|:---|:---|
| col  | 是    | str    | 指定要计算唯一值的列。 |
   
**返回值类型**：list。
 #### limit
**描述**：从当前Dataset中选择行，起始位置为偏移量。
**语法格式**：
```
limit(n, /, *, offset=0)
```
**输入参数**：
| 参数    | 是否必选  | 参数类型                 | 描述                               |
|:---|:---|:---|:---|
| n     | 否    | Union\[int, None\] | 要包含的行数。如果为None，则从偏移量开始选择整个数据集。 |
| offset | 否 | int                  | 起始跳过的行数。                         |
   
**返回值类型**：
Dataset ：从偏移量开始的n行数据。
**示例**：
```
>>> from aura_frame.multimodal import ai_lake
>>> con = ai_lake.connect(
...     aura_endpoint='*',
...     access_key='*'
...     secret_key='*'
...     ...
... )
>>> ds = con.load_dataset("demo_table_4", database='my_schema')
>>> ds
| a     | b      |
|---|---|
| int64 | string |
|---|---|
| 1     | c      |
| 1     | a      |
| 2     | a      |
>>> ds.limit(2)
| a     | b      |
|---|---|
| int64 | string |
|---|---|
| 1     | c      |
| 1     | a      |
| 2     | a      |
# use None with offset to slice starting from a particular row
>>> ds.limit(None, offset=1)
| a      | b      |
|---|---|
| int64  | string |
|---|---|
| 1      | a      |
| 2      | a      |
```
 #### take_batch
**描述**： 从Dataset中返回最多batch_size行数据。
**语法格式**：
```
take_batch(batch_size=20, *, batch_format='default')
```
**输入参数**：
| 参数          | 是否必选 | 参数类型              | 描述                                                                                                                                                                                                                                                                                                                                                                             |
|:---|:---|:---|:---|
| batch_size | 否      | int             | batch包含的行数（默认为20）。                                                                                                                                                                                                                                                                                                                                                            |
| batch_format | 否   | Optional\[str\] | batch的格式。 - "default"返回pyarrow.Table。  - "pandas"返回pandas.DataFrame。  - "numpy"返回字典形式的numpy数组。   |
   
**返回值类型**：按指定格式输出数据集合。
 #### create_async_job
**描述**：根据作业id恢复作业实例。
**语法格式**：
```
create_async_job(statement_id)
```
**输入参数**：
| 参数              | 是否必选 | 参数类型 | 描述        |
|:---|:---|:---|:---|
| statement_id | 是    | str   | 作业唯一标识符。 |
   
**返回值**：AsyncJob对象。