# informat.table 数据表操作

## 概述

使用`informat.table`对象进行数据表相关操作
:::tip 提示
在脚本中对于数据表的更新，插入和删除操作不会触发监听器
:::

## Query 使用示例

```javascript
const query = {
  // 页码，从1开始。默认为1
  pageIndex: 1,
  // 每页数据量 默认值100，-1表示查询所有数据
  pageSize: 10,
  // 过滤器 TableRecordFilter
  filter: {
    // 过滤条件 TableRecordCondition
    conditionList: [
      {
        // 查询的字段标识符
        fieldId: "name",
        /**
         * 比较方式 TableRecordConditionOpt ，取值如下
         * eq                等于
         * ne                不等于
         * gt                大于
         * ge                大于等于
         * lt                小于
         * le                小于等于
         * contains          包含
         * notcontains       不包含
         * startswith        开始是
         * endswith          结尾是
         * isnull            等于空值
         * isnotnull         不等于空值
         * in                在列表内
         * notin             不在列表内
         * between           在范围内
         * notbetween        不在范围内
         * parenteq          父对象等于
         * parentrooteq      根节点等于
         * parentcontains    父对象包含
         * multipleandquery  多值且模糊查询
         * multipleorquery   多值或模糊查询
         * intree            在树中
         */
        opt: "eq",
        /**
         * 对数据值的处理函数 TableRecordConditionFunc
         * 日期类型字段取值如下：
         * week                 周内天数（周一=1，周二=2，依次类推，周日=7）
         * month                年度的第几月
         * quarter              年度的第几季度
         * year                 年份
         * dayofyear            年度天数
         * weekofyear           年度周数
         * dayofmonth           月内天数
         * daytonow             距离今天的天数（昨天=1，今天=0，明天=-1）
         * weektonow            距离今天的周数（上周=1，本周=0，下周=-1）
         * monthtonow           距离今天的月份数（上月=1，本月=0，下月=-1）
         * quartertonow         距离今天的季度数（上季度=1，本季度=0，下季度=-1）
         * yeartonow            距离今天的年份数（去年=1，今年=0，明年=-1）
         * fmtday               年-月-日 格式:2021-01-01
         * fmtweek              年-周 格式:2021-1
         * fmtmonth             年-月 格式:2021-01
         * fmtquarter           年-季度 格式:2021-1
         * 成员类型字段取值如下：
         * nameOfAccount        姓名
         */
        func: null,
        // 对比值
        value: "张三",
      },getTableInfo
    ],
    // 嵌套子过滤器,值为 TableRecordFilter 的数组，支持逐层嵌套结构
    children: [],
    /**
     * 子过滤器与上层过滤器组合方式
     * 取值如下
     * and      全部匹配
     * or       任意匹配
     */
    opt: "and",
  },
  // 返回值包含的字段标识符列表,不传递或传递空数组时查询全部字段
  includeFields: ["id", "name", "age"],
  // 分组字段标识符列表
  groupByList: [],
  // 聚合查询列表 TableRecordAggregationQuery
  aggregationQueryList: [
    {
      // 聚合的字段
      fieldId: "sex",
      /**
       * 聚合方式
       * 取值如下
       * count        数量
       * avg          平均值(数字、日期类型)
       * sum          求和(数字、日期类型)
       * max          最大值(数字、日期类型)
       * min          最小值(数字、日期类型)
       */
      func: "count",
      // 是否去重
      distinct: false,
    },
  ],
  // 排序方式数组，OrderBy
  orderByList: [
    {
      // 排序的字段标识符
      field: "name",
      /**
       * 排序方式取值如下
       * asc      正序
       * desc     倒序
       */
      type: "desc",
    },
  ],
  // 去重字段标识符列表
  distinctFieldList: [],
  // 返回值排除的字段标识符列表,不传递或传递空数组时查询全部字段
  excludeFields: [],
  // 是否返回选项名称,`列表选择`、`级联选择`、`树形选择`返回选项名称
  returnOptionName: false,
};
```

:::warning 注意事项

**TableRecordConditionOpt 中 contains 和 in 的区别**

比如:任务表有责任人字段（标识符:owner,类型:用户选择，多选），有如下记录

| ID  | 责任人    |
| --- | --------- |
| 1   | 张三,李四 |
| 2   | 张三      |
| 3   | 王五      |

- 包含（contains）:右侧成员列表包含左侧任意一个成员

  - { fieldId: 'owner', opt: 'contains', value: ['张三'] }
    则记录 1,2 是满足条件的

- 在列表中（in）:右侧成员列表包含左侧所有成员
  - { fieldId: 'owner', opt: 'in', value: ['张三'] }
    则只有记录 2 是满足条件的
  - { fieldId: 'owner', opt: 'in', value: ['张三','李四'] }
    记录 1,2 是满足条件的

:::

## queryList

通过条件查询多条数据

```javascript
informat.table.queryList(tableId, query);
```

| 参数    | 类型                                            | 描述           |
| ------- | ----------------------------------------------- | -------------- |
| tableId | String                                          | 数据表的标识符 |
| query   | [`Query`](/guide/script/table.md#query使用示例) | 查询条件       |

#### 返回值

数据记录列表,类型为`Array<Object>`

:::: tabs

::: tab "示例 1-查询"
查询姓名中包含张或李且年龄大于 20 岁的前 3 位员工，按照年龄从低到高排序

```js
informat.table.queryList("staffs", {
  pageIndex: 1,
  pageSize: 3,
  filter: {
    opt: "and",
    conditionList: [{ fieldId: "age", opt: "gt", value: "20" }],
    children: [
      {
        opt: "or",
        conditionList: [
          { fieldId: "name", opt: "startswith", value: "张" },
          { fieldId: "name", opt: "startswith", value: "李" },
        ],
      },
    ],
  },
  orderByList: [{ field: "age", type: "asc" }],
});
```

上面的调用等同于 sql

```sql
where age>20 and (name like '张%' or name like '李%')
```

:::

::: tab "示例 2-级联选择"
查询所在地区是深圳市南山区的员工列表

```javascript
informat.table.queryList("staffs", {
  pageIndex: 1,
  pageSize: 3,
  filter: {
    opt: "and",
    conditionList: [{ fieldId: "area", opt: "eq", value: ["广东省", "深圳市", "南山区"] }],
  },
});
```

:::

::: tab "示例 3-子对象"

子对象-查询技术部的所有子部门列表

```javascript
informat.table.queryList("scriptTableB", {
  pageSize: -1,
  filter: {
    opt: "and",
    conditionList: [{ fieldId: "children", opt: "parentrooteq", value: ["rpev2ztqnbu8o"] }],
  },
});
```

返回数据如下：

```json
[
  {
    "children": "o32bbe3eqrrg0.zzzq65nxu0qv1",
    "id": "c91au1arsncd6"
  },
  {
    "children": "o32bbe3eqrrg0.zzzq65nxu0qv1",
    "id": "z00ei9fqymbra"
  },
  {
    "children": "o32bbe3eqrrg0.zzzq65nxu0qv1.z00ei9fqymbra",
    "id": "ci92j4ddenf9o"
  }
]
```

:::

::: tab "示例 4-返回指定字段"

分页查询员工列表,只返回名称和性别字段，并返回性别的选项名称 \*

```javascript
informat.table.queryList("staffs", {
  pageIndex: 1, //从1开始
  pageSize: 10,
  returnOptionName: true,
  includeFields: ["name", "sex"],
});
```

:::

::: tab "示例 5-返回排除指定字段的数据"

分页查询员工列表,返回除了名称和性别的其他字段 \*

```javascript
informat.table.queryList("staffs", {
  pageIndex: 1, //从1开始
  pageSize: 10,
  excludeFields: ["name", "sex"],
});
```

:::

::: tab "示例 6-聚合查询"

按照年龄分组 聚合查询

```javascript
informat.table.queryList("staffs", {
  groupByList: ["age"],
  /*
   * 日期聚合查询
   * groupByList使用样例 groupByList: ['dataTime$year'],
   * dataTime：聚合字段
   * $ 聚合方法分隔符
   * year：聚合方法，年份：year，年度的第几月：month，一周内的第几天：week
   * 请参考 TableRecordQuery说明
   */
  aggregationQueryList: [
    {
      func: "count",
      fieldId: "age",
    },
  ],
  orderByList: [{ field: "age", type: "asc" }],
});
```

返回数据如下

```json
[
  {
    "age": 23,
    "age_count": 2
  },
  {
    "age": 24,
    "age_count": 1
  },
  {
    "age": 25,
    "age_count": 1
  }
]
```

按照生日年份分组 聚合查询


```javascript
informat.table.queryList('staffs', {
    groupByList:["birthday$year"],
    aggregationQueryList: [
        {
            func: 'count'
        }
    ],
    orderByList: [{ field: 'birthday$year', type: 'asc' }]
});
```

返回数据如下

```json
[
  {
    "birthday$year":"1998",
    "count":2
  },
  {
    "birthday$year":"1999",
    "count":1
  },
  {
    "birthday$year":"2000",
    "count":1
  }
]
```

:::

::: tab "示例 7-查询2025-05月份创建的员工列表(使用fmtmonth)"

```javascript
informat.table.queryList("staffs", {
  pageSize: -1,
  filter: {
    conditionList: [{ fieldId: "createTime", opt: "eq", func:"fmtmonth", value: "2025-05" }],
  }
});
```

返回数据如下

```json
[
  {
    "createUser_name":"skydu",
    "recordId":"kq91s9fosqh2l",
    "id":"kq91s9fosqh2l",
    "seq":415,
    "rewardCount":0,
    "updateUser_name":"skydu",
    "seqno":415,
    "staffNo":"INFO-2025-00012",
    "sex":"male",
    "updateUser":"skydu",
    "updateTime":1746755574341,
    "totalLevelDays":0,
    "createTime":1746755574341,
    "grade":4,
    "name":"张三",
    "updateUser_avatar":"pic10.png",
    "createUser":"skydu",
    "createUser_avatar":"pic10.png",
    "age":28,
    "status":"onjob"
  }
]
```
:::


::::

## queryListCount

查询满足条件的数据数量

```javascript
informat.table.queryListCount(tableId, filter);
```

| 参数    | 类型                | 描述           |
| ------- | ------------------- | -------------- |
| tableId | String              | 数据表的标识符 |
| filter  | `TableRecordFilter` | 查询条件，必填；无过滤条件时传 `{}`，不要省略 |

#### 返回值

满足条件的记录数量，类型为`Integer`

**_示例_**

::: code-group

```js
informat.table.queryListCount("staffs", {
  conditionList: [{ fieldId: "name", opt: "contains", value: "张" }],
});
```

无过滤条件时也必须传第二个参数：

```js
informat.table.queryListCount("staffs", {});
```

```json
2
```

:::


## getTableInfo

查询数据表信息

```javascript
informat.table.getTableInfo(tableId);
```

| 参数    | 类型   | 描述           |
| ------- | ------ | -------------- |
| tableId | String | 数据表的标识符 |

#### 返回值

类型为[TableInfo](/guide/script/model.md#tableinfo)，返回数据表信息

**_示例_**
::: code-group

```js
informat.table.getTableInfo("task");
```

```json
{
  "table": {
    "id": "cfg9ywr41G",
    "key": "task",
    "name": "任务"
  },
  "tableFieldList": [
    {
      "id": "id",
      "key": "id",
      "name": "id",
      "type": "UUID"
    },
    {
      "id": "mzqlwrDgOM",
      "key": "expectDate",
      "name": "期望完成时间",
      "type": "Date"
    },
    {
      "id": "tp0rfnbmcc3sd",
      "key": "updateTime",
      "name": "更新时间",
      "type": "LastModifyTime"
    },
    {
      "id": "u3qh6zf0lgwus",
      "key": "updateUser",
      "name": "更新人",
      "type": "LastModifyUser"
    },
    {
      "id": "Wfgb3bwKdf",
      "key": "name",
      "name": "名称",
      "type": "SingleText"
    }
  ]
}
```

:::


## getTableFieldInfo

查询数据表字段信息

```javascript
informat.table.getTableFieldInfo(tableId, fieldId);
```

| 参数    | 类型   | 描述               |
| ------- | ------ | ------------------ |
| tableId | String | 数据表的标识符     |
| fieldId | String | 数据表字段的标识符 |

#### 返回值

类型为[TableFieldInfo](/guide/script/model.md#tablefieldinfo)，返回数据表字段信息

**_示例_**

::: code-group

```js
informat.table.getTableFieldInfo("task", "name");
```

```json
{
  "changeLogAccessRoleList": [],
  "defaultValueRuleList": [],
  "displayWidth": 50,
  "enableChangeLog": true,
  "hidden": false,
  "icon": "text",
  "id": "Wfgb3bwKdf",
  "key": "name",
  "name": "名称",
  "readonly": false,
  "singleTextSetting": {
    "autoCompleteAutomaticVarList": [],
    "autoCompleteTriggerOnFocus": false,
    "buttonList": [],
    "enableAutoComplete": false,
    "format": "string",
    "max": 200,
    "min": 0,
    "nullable": true,
    "storageSize": 200
  },
  "tableId": "task",
  "type": "SingleText",
  "validateRuleList": []
}
```

:::

## queryById

根据 ID 查询单条数据

```javascript
informat.table.queryById(tableId, recordId);
```

| 参数     | 类型   | 描述              |
| -------- | ------ | ----------------- |
| tableId  | String | 数据表的标识符    |
| recordId | String | 需要查询的数据 ID |

#### 返回值

查询的数据记录类型为`Object`

**_示例_**

::: code-group

```js
informat.table.queryById("task", "aorxux52i4t1z");
```

```json
{
  "id": "aorxux52i4t1z",
  "name": "任务1",
  "startDate": "2022-12-05 00:00:00.0"
}
```

:::

## queryOne

根据条件查询满足条件的第一条数据

```javascript
informat.table.queryOne(tableId, query);
```

| 参数    | 类型                                                       | 描述           |
| ------- | ---------------------------------------------------------- | -------------- |
| tableId | String                                                     | 数据表的标识符 |
| query   | [`TableRecordQuery`](/guide/script/table.md#query使用示例) | 查询条件       |

#### 返回值

查询的数据记录类型为`Object`

**_示例_**

::: code-group

```js
informat.table.queryOne("task", {
  pageSize: 1,
  filter: {
    conditionList: [{ fieldId: "name", opt: "eq", value: "任务1" }],
  },
});
```

```json
{
  "id": "aorxux52i4t1z",
  "name": "任务1",
  "startDate": "2022-12-05 00:00:00.0"
}
```

:::

## query

根据 ID 和条件查询单条记录

```javascript
informat.table.query(tableId, recordId, setting);
```

| 参数     | 类型                      | 描述              |
| -------- | ------------------------- | ----------------- |
| tableId  | String                    | 数据表的标识符    |
| recordId | String                    | 需要查询的数据 ID |
| setting  | `TableRecordQuerySetting` | 查询设置          |

`TableRecordQuerySetting`的结构如下

| 参数             | 类型            | 描述                                                               |
| ---------------- | --------------- | ------------------------------------------------------------------ |
| forUpdate        | Boolean         | 是否锁定行                                                         |
| returnOptionName | Boolean         | 如果有`列表选择`、`级联选择`、`树形选择`字段，同时会返回选项值名称 |
| includeFields    | `Array<String>` | 返回的字段列表，如果为空，则返回全部字段                           |

#### 返回值

查询的数据记录类型为`Object`

**_示例:使用行锁查询记录_**

::: code-group

```js
informat.table.query("task", "aorxux52i4t1z", {
  forUpdate: true,
});
```

```json
{
  "id": "aorxux52i4t1z",
  "name": "任务1",
  "startDate": "2022-12-05 00:00:00.0"
}
```

:::



## insert

创建记录

针对`创建人`、`创建时间`、`最后修改人`、`最后修改时间`这四个字段，如果创建的记录没有传过来，则系统会把当前时间作为`创建时间`
和`最后修改时间`的值，把当前操作人作为`创建人`和`最后修改人`的值。如果是定时任务触发的创建记录，则当前操作人是`INFORMAT`。

```javascript
informat.table.insert(tableId, data);
```

| 参数    | 类型   | 描述           |
| ------- | ------ | -------------- |
| tableId | String | 数据表的标识符 |
| data    | Object | 需要创建的记录 |

#### 返回值

返回创建的记录 ID

#### 示例

::: code-group

```js
informat.table.insert("staffs", {
  name: "赵六",
  sex: "male",
  age: 30,
  grade: 5,
  area: ["广东省", "深圳市", "南山区"],
});
```

```json
"twmvau4ogujcc"
```

:::

详细格式见：[**记录的类型转换**](/guide/table/table_transform_record.md)

## insertEx

根据配置信息创建记录
与`创建记录`类似，唯一的区别是多了配置信息

```javascript
informat.table.insertEx(tableId, data, config);
```

| 参数    | 类型                 | 描述           |
| ------- | -------------------- | -------------- |
| tableId | String               | 数据表的标识符 |
| data    | Object               | 需要创建的记录 |
| config  | `InsertRecordConfig` | 配置信息       |

`InsertRecordConfig`结构如下：

| 参数                        | 类型    | 描述                          |
| --------------------------- | ------- | ----------------------------- |
| disableCalculateRollupField | Boolean | 是否不计算汇总字段,默认 false |

在创建新记录时，如果所在表是某主表的子表，某些字段是主表查找汇总或关联列表汇总里的汇总字段，系统会自动计算主表的这些汇总字段。例如，当一次性创建大量子表记录时，实际上不需要在每次创建子表记录时都重新计算主表里的汇总字段，因为计算汇总所需的时间较长。因此，只需在最后一条子表记录创建后再重新计算汇总即可。
为了提高效率并减少不必要的计算，可以在这种情况下将 `InsertRecordConfig` 中的配置参数 `disableCalculateRollupField`
设置为 `true`
。这样，在每次创建子表记录时，系统就不会计算汇总字段。当所有子表记录创建完成后，再单独调用 `informat.table.refreshRelationRollup`
和 `informat.table.refreshLookupRollup` 来计算汇总。

#### 返回值

创建的记录 ID

::: code-group

```js
informat.table.insertEx(
  "staffs",
  {
    name: "赵六",
    sex: "male",
    age: 30,
    grade: 5,
    area: ["广东省", "深圳市", "南山区"],
  },
  {
    disableCalculateRollupField: true,
  }
);
```

```json
"ecxnsomw69dmn"
```

:::

## batchInsert

批量创建记录

针对`创建人`、`创建时间`、`最后修改人`、`最后修改时间`这四个字段，如果创建的记录没有传过来，则系统会把当前时间作为`创建时间`
和`最后修改时间`的值，把当前操作人作为`创建人`和`最后修改人`的值。如果是定时任务触发的创建记录，则当前操作人是`INFORMAT`。

```javascript
informat.table.batchInsert(tableId, dataList);
```

| 参数     | 类型   | 描述               |
| -------- | ------ | ------------------ |
| tableId  | String | 数据表标识符       |
| dataList | Array  | 需要创建的记录列表 |

#### 返回值

创建记录的数量

:::: tabs

::: tab "示例 1-批量插入"

::: code-group

```js
informat.table.batchInsert("staffs", [
  { name: "赵六", sex: "male", age: 30, grade: 5, area: ["广东省", "深圳市", "南山区"] },
  { name: "孙七", sex: "female", age: 27, grade: 4, area: ["广东省", "深圳市", "宝安区"] },
]);
```

```json
2
```

:::

::: tab "示例 2-自带记录 ID 批量插入"

::: code-group

```js
informat.table.batchInsert("staffs", [
  { id: "1", name: "赵六", sex: "male", age: 30, grade: 5, area: ["广东省", "深圳市", "南山区"] },
  { id: "2", name: "孙七", sex: "female", age: 27, grade: 4, area: ["广东省", "深圳市", "宝安区"] },
]);
```

```json
2
```

:::
::::

:::warning 注意事项
批量插入记录与普通单条插入记录的区别：

`子对象编号`、`编号`、`查找汇总`、`关联列表汇总`字段在批量插入记录时不会计算。
:::

## update

更新记录
针对`最后修改人`、`最后修改时间`这两个字段，如果更新的记录里没传过来，则系统会把当前时间作为`最后修改时间`
的值，把当前操作人作为`最后修改人`的值。如果是定时任务触发的更新记录，则当前操作人是`INFORMAT`。

```javascript
informat.table.update(tableId, data);
```

| 参数    | 类型   | 描述           |
| ------- | ------ | -------------- |
| tableId | String | 数据表的标识符 |
| data    | Object | 需要更新的记录 |

#### 返回值

更新成功的记录条数

#### 示例 1

::: code-group

```js
informat.table.update("staffs", {
  id: "1",
  name: "赵六2",
  sex: "male",
  age: 28,
  grade: 2,
  area: ["广东省", "深圳市", "福田区"],
});
```

```json
1
```

:::

详细格式见：[**记录的类型转换**](/guide/table/table_transform_field.md)

## updateEx

根据配置信息更新记录
与`更新记录`类似，唯一的区别是多了更新配置信息

```javascript
informat.table.updateEx(tableId, data, config);
```

| 参数    | 类型                 | 描述           |
| ------- | -------------------- | -------------- |
| tableId | String               | 数据表的标识符 |
| data    | Object               | 需要更新的记录 |
| config  | `UpdateRecordConfig` | 更新配置信息   |

`UpdateRecordConfig`结构如下：

| 参数                        | 类型    | 描述                          |
| --------------------------- | ------- | ----------------------------- |
| enableChangeLog             | Boolean | 是否启用变更记录,默认 false   |
| disableCalculateRollupField | Boolean | 是否不计算汇总字段,默认 false |
| updateBpmnInstaceFormVar    | Boolean | 是否同步更新工作流实例form变量,默认 false |

在更新记录时，如果所在表是某主表的子表，更新的字段是主表查找汇总或关联列表汇总里的汇总字段，系统会自动计算主表的这些汇总字段。例如，当一次性更新大量子表记录时，实际上不需要在每次更新子表记录时都重新计算主表里的汇总字段，因为计算汇总所需的时间较长。因此，只需在最后一条子表记录更新后再重新计算汇总即可。
为了提高效率并减少不必要的计算，可以在这种情况下将 `UpdateRecordConfig` 中的配置参数 `disableCalculateRollupField`
设置为 `true`
。这样，在每次更新子表记录时，系统就不会计算汇总字段。当所有子表记录更新完成后，再单独调用 `informat.table.refreshRelationRollup`
和 `informat.table.refreshLookupRollup` 来计算汇总。

#### 示例 1

::: code-group

```js
informat.table.updateEx(
  "staffs",
  {
    id: "1",
    name: "赵六2",
    sex: "male",
    age: 28,
    grade: 2,
    area: ["广东省", "深圳市", "福田区"],
  },
  {
    enableChangeLog: true,
    disableCalculateRollupField: true,
  }
);
```

```json
1
```

:::

#### 返回值

更新成功的记录条数

## batchUpdate

批量更新记录
针对`最后修改人`、`最后修改时间`这两个字段，如果更新的记录里没传过来，则系统会把当前时间作为`最后修改时间`
的值，把当前操作人作为`最后修改人`的值。如果是定时任务触发的更新记录，则当前操作人是`INFORMAT`。
注意事项：所有更新的记录列表，更新的字段列表都是一致的,如果值为 null 也会批量更新为空。

```javascript
informat.table.batchUpdate(tableId, dataList);
```

| 参数     | 类型   | 描述               |
| -------- | ------ | ------------------ |
| tableId  | String | 数据表的标识符     |
| dataList | Object | 需要更新的记录列表 |

**示例**

::: code-group

```js
informat.table.batchUpdate("staffs", [
  { id: "1", name: "赵六2", sex: "male", age: 29, grade: 3, area: ["广东省", "深圳市", "南山区"] },
  { id: "2", name: "孙七2", sex: "female", age: 26, grade: 2, area: ["广东省", "深圳市", "宝安区"] },
]);
```

```json
3
```

:::

:::warning 注意事项
批量更新记录与普通单条更新记录的区别：

`子对象编号`、`编号`、`查找汇总`、`关联列表汇总`字段在批量更新记录时不会计算。
:::

## updateList

根据条件更新多条记录

```javascript
informat.table.updateList(tableId, filter, data);
```

| 参数    | 类型     | 描述           |
| ------- | -------- | -------------- |
| tableId | String   | 数据表的标识符 |
| filter  | `Filter` | 过滤条件       |
| data    | Object   | 需要更新的数据 |

#### 返回值

更新成功的记录条数

示例：更新所有姓张的员工的级别为 4

::: code-group

```js
informat.table.updateList(
  "staffs",
  {
    conditionList: [{ fieldId: "name", opt: "contains", value: "张%" }],
  },
  { grade: 4 }
);
```

```json
2
```

:::

## updateListEx

根据条件和配置更新多条记录

```javascript
informat.table.updateListEx(tableId, filter, data, config);
```

| 参数    | 类型                 | 描述           |
| ------- | -------------------- | -------------- |
| tableId | String               | 数据表的标识符 |
| filter  | `Filter`             | 过滤条件       |
| data    | Object               | 需要更新的数据 |
| config  | `UpdateRecordConfig` | 更新配置信息   |

`UpdateRecordConfig`结构如下：

| 参数                        | 类型    | 描述                          |
| --------------------------- | ------- | ----------------------------- |
| enableChangeLog             | Boolean | 是否启用变更记录,默认 false   |
| disableCalculateRollupField | Boolean | 是否不计算汇总字段,默认 false |
| updateBpmnInstaceFormVar    | Boolean | 是否同步更新工作流实例form变量,默认 false |

#### 返回值

更新成功的记录条数

示例：

::: code-group

```js
informat.table.updateListEx(
  "staffs",
  {
    conditionList: [{ fieldId: "name", opt: "contains", value: "张%" }],
  },
  { grade: 4 },
  { disableCalculateRollupField: true }
);
```

```json
2
```

:::

## delete

如果开启了回收站，被删除记录的记录会放到回收站里。
删除单条记录

```javascript
informat.table.delete(tableId, recordId);
```

| 参数     | 类型   | 描述              |
| -------- | ------ | ----------------- |
| tableId  | String | 数据表的标识符    |
| recordId | String | 需要删除的记录 ID |

#### 返回值

删除成功的记录条数

示例：

::: code-group

```js
informat.table.delete("staffs", "twmvau4ogujcc");
```

```json
1
```

:::

## deleteEx

根据配置信息删除记录
与`删除记录`类似，唯一的区别是多了配置信息

```javascript
informat.table.deleteEx(tableId, recordId, config);
```

| 参数     | 类型                 | 描述              |
| -------- | -------------------- | ----------------- |
| tableId  | String               | 数据表的标识符    |
| recordId | String               | 需要删除的记录 ID |
| config   | `DeleteRecordConfig` | 配置信息          |

`DeleteRecordConfig`结构如下：

| 参数                        | 类型    | 描述                          |
| --------------------------- | ------- | ----------------------------- |
| disableCalculateRollupField | Boolean | 是否不计算汇总字段,默认 false |

在删除记录时，如果所在表是某主表的子表，某些字段是主表查找汇总或关联列表汇总里的汇总字段，系统会自动计算主表的这些汇总字段。例如，当一次性删除大量子表记录时，实际上不需要在每次删除子表记录时都重新计算主表里的汇总字段，因为计算汇总所需的时间较长。因此，只需在删除最后一条子表记录后再重新计算汇总即可。
为了提高效率并减少不必要的计算，可以在这种情况下将 `DeleteRecordConfig` 中的配置参数 `disableCalculateRollupField`
设置为 `true`
。这样，在每次删除子表记录时，系统就不会计算汇总字段。当所有子表记录删除完成后，再单独调用 `informat.table.refreshRelationRollup`
和 `informat.table.refreshLookupRollup` 来计算汇总。

#### 返回值

删除成功的记录条数

## deleteList

如果开启了回收站，被删除记录的记录会放到回收站里。
根据条件删除多条记录

```javascript
informat.table.deleteList(tableId, filter);
```

| 参数    | 类型     | 描述           |
| ------- | -------- | -------------- |
| tableId | String   | 数据表的标识符 |
| filter  | `Filter` | 过滤条件       |

#### 返回值

删除成功的记录条数

示例：删除离职的员工列表

::: code-group

```js
informat.table.deleteList("staffs", {
  conditionList: [{ fieldId: "status", opt: "ge", value: "dimission" }],
});
```

```json
2
```

:::

:::tip
`informat.table.deleteList`
的底层实现逻辑是先查询所有的记录，然后一条一条删除，如果配置了回收站，则删除后会放入回收站，所以速度不快。当批量删除大数据量的记录时，如果想追求更快的速度，请使用
`informat.table.batchDelete`
:::

## deleteListEx

如果开启了回收站，被删除记录的记录会放到回收站里。
根据条件和配置删除多条记录

```javascript
informat.table.deleteListEx(tableId, filter, config);
```

| 参数    | 类型                 | 描述           |
| ------- | -------------------- | -------------- |
| tableId | String               | 数据表的标识符 |
| filter  | `Filter`             | 过滤条件       |
| config  | `DeleteRecordConfig` | 配置信息       |

#### 返回值

删除成功的记录条数

示例：

::: code-group

```js
informat.table.deleteListEx(
  "user",
  {
    conditionList: [{ fieldId: "id", opt: "in", value: ["k3oybvxo0lwxv", "htfesu6ghbcro"] }],
  },
  {
    disableCalculateRollupField: true,
  }
);
```

```json
2
```

:::

## batchDelete

批量删除记录
如果开启了回收站，被删除记录的记录不会放到回收站里。

```javascript
informat.table.batchDelete(tableId, idList);
```

| 参数    | 类型   | 描述         |
| ------- | ------ | ------------ |
| tableId | String | 数据表标识符 |
| idList  | Array  | 记录 ID 列表 |

**_示例_**

::: code-group

```js
informat.table.batchDelete("staffs", ["uphuksrz88xij", "cyljta5v60mup"]);
```

```json
2
```

:::

## queryRelationList

通过主表记录 ID 查询关联列表字段对应子表的记录列表

```javascript
informat.table.queryRelationList(tableId, relationFieldId, recordId, query);
```

| 参数            | 类型    | 描述            |
| --------------- | ------- | --------------- |
| tableId         | String  | 数据表的标识符  |
| relationFieldId | String  | 关联列表字段 ID |
| recordId        | String  | 主表的记录 ID   |
| query           | `Query` | 子表查询条件    |

#### 返回值

数据记录列表，类型为`Array<Object>`

**_示例_**

```javascript
informat.table.queryRelationList("staffs", "rewardList", "yhg8b23ej2gt6", {
  pageIndex: 1,
  pageSize: 50,
  filter: {
    conditionList: [{ fieldId: "name", opt: "contains", value: "优秀员工" }],
  },
});
```

## addRelation

添加关联列表值

```javascript
informat.table.addRelation(tableId, relationFieldId, recordId, relationRecordId);
```

| 参数             | 类型   | 描述              |
| ---------------- | ------ | ----------------- |
| tableId          | String | 数据表的标识符    |
| relationFieldId  | String | 关联列表字段      |
| recordId         | String | 主表的记录 ID     |
| relationRecordId | String | 关联列表的记录 ID |

**_示例_**

```javascript
informat.table.addRelation("staffs", "rewardList", "yhg8b23ej2gt6", "rgf4fbbb543kj");
```

## deleteRelation

删除关联列表值

```javascript
informat.table.deleteRelation(tableId, relationFieldId, recordId, relationRecordId);
```

| 参数             | 类型   | 描述              |
| ---------------- | ------ | ----------------- |
| tableId          | String | 数据表的标识符    |
| relationFieldId  | String | 关联列表字段      |
| recordId         | String | 主表的记录 ID     |
| relationRecordId | String | 关联列表的记录 ID |

**_示例_**

```javascript
informat.table.deleteRelation("staffs", "rewardList", "yhg8b23ej2gt6", "rgf4fbbb543kj");
```

## hasRelation

查询记录是否在关联列表中
如果关联列表中存在 relationRecordIdList 中指定的记录 ID，则返回的数组中也包含此记录 ID。

例如关联列表中存储的数据为

- record1
- record2
- record3

relationRecordIdList 为`record1` `record2` `record4`，则返回值为 `record1` `record2`

```javascript
informat.table.hasRelation(tableId, relationFieldId, recordId, relationRecordIdList);
```

| 参数                 | 类型                | 描述                   |
| -------------------- | ------------------- | ---------------------- |
| tableId              | String              | 数据表的标识符         |
| relationFieldId      | String              | 关联列表字段           |
| recordId             | String              | 主表的记录 ID          |
| relationRecordIdList | Array&lt;String&gt; | 关联记录的记录 ID 列表 |

#### 返回值

在 recordId 的 relationFieldId 关联列表中存在的记录 ID 列表，类型为`Array<String>`

**_示例_**

```javascript
informat.table.hasRelation("staffs", "rewardList", "yhg8b23ej2gt6", ["rgf4fbbb543kj", "ct82dszf20s2u"]);
// 返回数据如下：
["rgf4fbbb543kj"];
```

## getRelationRecordIdList

查询关联列表中存在指定记录的记录列表
通过**关联列表**字段关联的目标表中的**记录 ID**查询与**主表**有关联的数据。返回有关联的主表记录 ID 列表

例如数据表存储的数据如下

| 主表记录 ID | 关联列表          |
| ----------- | ----------------- |
| m1          | [record1,record2] |
| m2          | [record1,record3] |
| m3          | [record3,record4] |

指定记录为`record3` 则返回值为 `m2` `m3`

```javascript
informat.table.getRelationRecordIdList(tableId, relationFieldId, recordId);
```

| 参数            | 类型   | 描述                        |
| --------------- | ------ | --------------------------- |
| tableId         | String | 主表数据表的标识符          |
| relationFieldId | String | 主表数据表关联列表字段的 ID |
| recordId        | String | 子表的记录 ID               |

#### 返回值

recordId 在 relationFieldId 关联列表中存在的记录 ID 列表，类型为`Array<String>`

**_示例_**

```javascript
informat.table.getRelationRecordIdList("staffs", "rewardList", "rgf4fbbb543kj");
// 返回数据如下：
["yhg8b23ej2gt6"];
```

## updateChildrenField

更新子对象字段

将记录移动到 parentRecordId 下，如果当前记录有子节点，将会同步更新子节点

```javascript
informat.table.updateChildrenField(tableId, childrenFieldId, recordId, parentRecordId);
```

| 参数            | 类型   | 描述                                                         |
| --------------- | ------ | ------------------------------------------------------------ |
| tableId         | String | 数据表的标识符                                               |
| childrenFieldId | String | 子对象字段                                                   |
| recordId        | String | 要更新的记录 ID                                              |
| parentRecordId  | String | 要移动到的父节点，如果父节点为`null`，则会将记录移动到根目录 |

**_示例_**

```javascript
informat.table.updateChildrenField("task", "children", "z00ei9fqymbra", "zzzq65nxu0qv1");
```

## queryChildrenList

通过条件查询指定记录的`子对象`记录列表

```javascript
informat.table.queryChildrenList(tableId, childrenFieldId, recordId, query);
```

| 参数            | 类型    | 描述           |
| --------------- | ------- | -------------- |
| tableId         | String  | 数据表的标识符 |
| childrenFieldId | String  | 子对象字段     |
| recordId        | String  | 主表的记录 ID  |
| query           | `Query` | 查询条件       |

**_示例_**

::: code-group

```js
informat.table.queryChildrenList("staffsDept", "children", "rpev2ztqnbu8o", {
  pageIndex: 1,
  pageSize: 50,
});
```

```json
[
  {
    "children": "rpev2ztqnbu8o",
    "createTime": 1717500998762,
    "name": "技术一组",
    "id": "pz9y1fse8hccw",
    "seq": 5
  },
  {
    "children": "rpev2ztqnbu8o",
    "createTime": 1717501030793,
    "name": "技术二组",
    "id": "l8w9u9raftp2a",
    "seq": 6
  }
]
```

:::

## cloneAttachment

拷贝附件字段的文件到目标字段
将源数据表中的附件字段中的文件拷贝到目标表的附件字段中。

:::tip
注意:attachment是对象，不是数组，如果附件字段是多选，需要使用数组下标选择对应的attachment对象
:::

```javascript
informat.table.cloneAttachment(sourceTableId, sourceFieldId, targetTableId, targetFieldId, attachment);
```

| 参数          | 类型                                                      | 描述               |
| ------------- | --------------------------------------------------------- | ------------------ |
| sourceTableId | String                                                    | 源数据表的标识符   |
| sourceFieldId | String                                                    | 源字段的标识符     |
| targetTableId | String                                                    | 目标数据表的标识符 |
| targetFieldId | String                                                    | 目标字段的标识符   |
| attachment    | [TableAttachment](/guide/script/model.md#tableattachment) | 附件对象           |

#### 返回值

复制成功后的附件对象,类型为[TableAttachment](/guide/script/model.md#tableattachment)

**_示例_**

::: code-group

```js
var record = informat.table.queryById("staffs", "yhg8b23ej2gt6");
console.log("record.attachment", record.attachment);
if (record.attachment == null) {
  return null;
}
var targetAttachments = [];
record.attachment.forEach((att) => {
  //多选
  var targetAttachment = informat.table.cloneAttachment("staffs", "attachment", "staffsDept", "attachment", att);
  targetAttachments.push(targetAttachment);
});
console.log("targetAttachments", targetAttachments);
informat.table.update("staffsDept", {
  id: "pz9y1fse8hccw",
  attachment: targetAttachments,
});
```

```json
[
  {
    "id": "1d14a4c1080e4f5992052aeab13951df.jpg",
    "md5": "b394f37c3180e68090e2a0f1370f2aa9",
    "name": "测试.jpg",
    "path": "uljrmxosme2uw/dwbndumn3dc8k/1d14a4c1080e4f5992052aeab13951df.jpg",
    "size": 7757,
    "thumbnail": "c270728528b54876abf67fb7e9ec4f24.jpg"
  }
]
```

:::

## moveAttachment

移动附件字段的文件到目标附件字段
将源数据表中的附件字段下的文件移动到目标表的附件字段下。

:::tip
注意:attachment是对象，不是数组，如果附件字段是多选，需要使用数组下标选择对应的attachment对象
:::

```javascript
informat.table.moveAttachment(sourceTableId, sourceFieldId, targetTableId, targetFieldId, attachment);
```

| 参数          | 类型                                                      | 描述               |
| ------------- | --------------------------------------------------------- | ------------------ |
| sourceTableId | String                                                    | 源数据表的标识符   |
| sourceFieldId | String                                                    | 源字段的标识符     |
| targetTableId | String                                                    | 目标数据表的标识符 |
| targetFieldId | String                                                    | 目标字段的标识符   |
| attachment    | [TableAttachment](/guide/script/model.md#tableattachment) | 附件对象           |

#### 返回值

移动成功后的附件对象,类型为[TableAttachment](/guide/script/model.md#tableattachment)

**_示例_**

```javascript
var record = informat.table.queryById("task", "cyrzgschwivz1");
informat.table.moveAttachment("task", "attachment", "task2", "attachment", record.attachment);
```

## createAttachment

使用本地沙盒中的文件生成附件
上传本地沙盒中的文件到共享存储中，并生成[TableAttachment](/guide/script/model.md#tableattachment)对象。如果文件为图片类型系统会自动的生成缩略图，
如果附件设置中有水印设置，系统会自动的生成水印。


```javascript
informat.table.createAttachment(tableId, fieldId, path);
```

| 参数    | 类型   | 描述                 |
| ------- | ------ | -------------------- |
| tableId | String | 数据表的标识符       |
| fieldId | String | 附件字段的标识符     |
| path    | String | 本地沙盒中的文件路径 |

#### 返回值

创建成功后的附件字段，类型为[TableAttachment](/guide/script/model.md#tableattachment)

**_示例_**

从 URL 下载图片，保存到本地沙盒文件中，再使用本地沙盒中的文件生成附件，保存到员工表某条记录的附件字段

员工表 staffs 有个附件字段

| 字段标识符 | 类型 | 描述 |
| ---------- | ---- | ---- |
| attachment | 附件 | 多选 |

```javascript
const req = {
  url: "https://www.informat.cn/favicon.ico",
};
const rsp = informat.http.request(req);
//保存到本地沙盒中
rsp.saveBodyAsFile("tmp/demo.png");
var attachment = informat.table.createAttachment("staffs", "attachment", "tmp/demo.png");
//更新数据表记录的附件字段
informat.table.update("staffs", {
  id: "yhg8b23ej2gt6",
  attachment: [attachment], //因为附件字段是多选，所以这里使用数组；同理如果不是多选，则不需要使用数组
});
//删除本地文件
informat.file.delete("tmp/demo.png");
```

## createAttachmentStorage

使用远程存储中的文件生成附件
复制远程存储中的文件作为附件字段的值，如果是图片类型，不会生成缩略图，缩略图的值会和附件的值相同。
该操作也不会生成水印。

```javascript
informat.table.createAttachmentStorage(tableId, fieldId, path);
```

| 参数    | 类型   | 描述                 |
| ------- | ------ | -------------------- |
| tableId | String | 数据表的标识符       |
| fieldId | String | 附件字段的标识符     |
| path    | String | 远程存储中的文件路径 |

#### 返回值

创建成功后的附件字段，类型为[TableAttachment](/guide/script/model.md#tableattachment)

**_示例_**

从 URL 下载图片，保存到共享存储中，再使用本地沙盒中的文件生成附件，保存到员工表某条记录的附件字段

员工表 staffs 有个附件字段

| 字段标识符 | 类型 | 描述 |
| ---------- | ---- | ---- |
| attachment | 附件 | 多选 |

```javascript
const req = {
  url: "https://www.informat.cn/favicon.ico",
};
const rsp = informat.http.request(req);
//保存到远程存储中
rsp.saveBodyAsStorage("remote/demo.png");
var attachment = informat.table.createAttachmentStorage("staffs", "attachment", "remote/demo.png");
//更新数据表记录的附件字段
informat.table.update("staffs", {
  id: "lc44f3lfggnbb",
  attachment: [attachment], //因为附件字段是多选，所以这里使用数组；同理如果不是多选，则不需要使用数组
});
//删除本地文件
informat.file.delete("tmp/demo.png");
```

## cloneTableSignature

拷贝手写签名字段的文件到目标字段
将源数据表中的手写签名字段中的文件拷贝到目标表的手写签名字段中。

```javascript
informat.table.cloneTableSignature(sourceTableId, sourceFieldId, targetTableId, targetFieldId, signature);
```

| 参数          | 类型                                                    | 描述               |
| ------------- | ------------------------------------------------------- | ------------------ |
| sourceTableId | String                                                  | 源数据表的标识符   |
| sourceFieldId | String                                                  | 源字段的标识符     |
| targetTableId | String                                                  | 目标数据表的标识符 |
| targetFieldId | String                                                  | 目标字段的标识符   |
| signature     | [TableSignature](/guide/script/model.md#tablesignature) | 手写签名对象       |

#### 返回值

复制成功后的手写签名,类型为[TableSignature](/guide/script/model.md#tablesignature)

**_示例_**

自动化上传手写签名到自定义表单，从自定义表单复制手写签名附件到员工表 staffs 某记录的手写签名字段。

自定义表单数据表标识符:$Automatic_b0qt6ci821n2m_nuxfjrga56kj
自定义表单数据表有个手写签名字段（单选）
员工表 staffs 有个手写签名字段（单选）

| 字段标识符 | 类型 | 描述 |
| ---------- | ---- | ---- |
| signature  | 手写 | 单选 |

```javascript
let signature = informat.table.cloneTableSignature("$Automatic_b0qt6ci821n2m_nuxfjrga56kj", "signature", "staffs", "signature", form.signature);
informat.table.update("staffs", {
  id: "yhg8b23ej2gt6",
  signature: signature,
});
```

## refreshDataSource

刷新物化视图的数据
当数据源是来自`数据库视图`时，并且开始了物化视图选项后，会刷新物化视图的数据，在其它情况下会抛出异常

```javascript
informat.table.refreshDataSource(tableId);
```

| 参数    | 类型   | 描述           |
| ------- | ------ | -------------- |
| tableId | String | 数据表的标识符 |

**_示例_**

```javascript
informat.table.refreshDataSource("techStaffsView");
```

## refreshRelationRollup

重新计算关联列表汇总字段的值

```javascript
informat.table.refreshRelationRollup(tableId, fieldId, recordIdList);
```

| 参数         | 类型   | 描述                                        |
| ------------ | ------ | ------------------------------------------- |
| tableId      | String | 数据表标识符                                |
| fieldId      | String | 关联列表汇总字段标识符                      |
| recordIdList | String | 主表记录 ID 列表,如果为空，就是全表重新计算 |

**_示例_**

```javascript
informat.table.refreshRelationRollup("staffs", "rewardCount", null); //全部记录重新计算
informat.table.refreshRelationRollup("staffs", "rewardCount", ["yhg8b23ej2gt6"]); //只重新计算yhg8b23ej2gt6对应的汇总数据
```

## refreshLookupRollup

重新计算查找列表汇总字段的值

```javascript
informat.table.refreshLookupRollup(tableId, fieldId, recordIdList, subFilter);
```

| 参数         | 类型                                    | 描述                                        |
| ------------ | --------------------------------------- | ------------------------------------------- |
| tableId      | String                                  | 数据表标识符                                |
| fieldId      | String                                  | 查找列表汇总字段标识符                      |
| recordIdList | `Array<String>`                         | 主表记录 ID 列表,如果为空，就是全表重新计算 |
| subFilter    | [Filter](/guide/script/model.md#filter) | 子表过滤条件,可以为空                       |

**_示例_**

```javascript
informat.table.refreshLookupRollup("staffs", "totalLevelDays", null, null); //全部记录重新计算
informat.table.refreshLookupRollup("staffs", "totalLevelDays", ["yhg8b23ej2gt6"], null); //只重新计算yhg8b23ej2gt6
```

## queryChangeLogListCount

获取变更记录总数

```javascript
informat.table.queryChangeLogListCount(tableId, filter);
```

| 参数    | 类型                                    | 描述         |
| ------- | --------------------------------------- | ------------ |
| tableId | String                                  | 数据表标识符 |
| filter  | [Filter](/guide/script/model.md#filter) | 过滤条件     |

过滤器中可以使用的字段列表

| 字段         | 类型    | 描述        |
| ------------ | ------- | ----------- |
| id           | Integer | 变更记录 ID |
| fieldName    | String  | 字段名称    |
| recordId     | String  | 记录 ID     |
| createUserId | String  | 创建人 ID   |

**返回值**
类型为`Integer`
返回变更记录列表

**示例**

```javascript
const count = informat.table.queryChangeLogListCount("tableKey", {
  conditionList: [
    {
      fieldId: "recordId",
      opt: "eq",
      value: "gn43hedzzgztp",
    },
  ],
});
// 获取匹配到的列表
console.log("count:", count);
```

## queryChangeLogList

获取变更记录列表

```javascript
informat.table.queryChangeLogList(tableId, informatQuery);
```

| 参数          | 类型                                  | 描述         |
| ------------- | ------------------------------------- | ------------ |
| tableId       | String                                | 数据表标识符 |
| informatQuery | [Query](/guide/script/model.md#query) | 查询条件     |

过滤器中可以使用的字段列表

| 字段         | 类型    | 描述        |
| ------------ | ------- | ----------- |
| id           | Integer | 变更记录 ID |
| fieldName    | String  | 字段名称    |
| recordId     | String  | 记录 ID     |
| createUserId | String  | 创建人 ID   |

**返回值**
类型为 Array<[TableChangeLog](/guide/script/model.md#tablechangelog)>
返回变更记录列表

**示例**

:::code-group

```js
informat.table.queryChangeLogList("staffs", {
  pageIndex: 1,
  pageSize: 20,
  filter: {
    conditionList: [
      {
        fieldId: "recordId",
        opt: "eq",
        value: "yhg8b23ej2gt6",
      },
    ],
  },
});
```

```json
[
  {
    "afterValue": {
      "type": "RelationRecord",
      "value": "fh1snm1k18kqc",
      "multiple": false,
      "valueString": "销售部"
    },
    "beforeValue": {
      "type": "RelationRecord",
      "multiple": false
    },
    "fieldName": "所在部门",
    "id": "1",
    "recordId": "yhg8b23ej2gt6"
  }
]
```

:::

## queryCommentListCount

获取表单评论总数

```javascript
informat.table.queryCommentListCount(tableId, filter);
```

| 参数    | 类型                                    | 描述         |
| ------- | --------------------------------------- | ------------ |
| tableId | String                                  | 数据表标识符 |
| filter  | [Filter](/guide/script/model.md#filter) | 过滤条件     |

过滤器中可以使用的字段列表

| 字段         | 类型    | 描述        |
| ------------ | ------- | ----------- |
| id           | int     | 评论 ID     |
| comment      | String  | 评论内容    |
| isDeleted    | Boolean | 是否删除    |
| parentId     | Integer | 回复评论 ID |
| recordId     | String  | 记录 ID     |
| createUserId | String  | 创建人 ID   |

**返回值**
类型为`Intetger`
返回表单评论列表

**示例**
:::code-group

```js
informat.table.queryCommentListCount("staffs", {
  conditionList: [
    {
      fieldId: "recordId",
      opt: "eq",
      value: "yhg8b23ej2gt6",
    },
  ],
});
```

```json
1
```

:::

## queryCommentList

获取表单评论列表

```javascript
informat.table.queryCommentList(tableId, query);
```

| 参数    | 类型                                  | 描述         |
| ------- | ------------------------------------- | ------------ |
| tableId | String                                | 数据表标识符 |
| query   | [Query](/guide/script/model.md#query) | 查询条件     |

过滤器中可以使用的字段列表

| 字段         | 类型    | 描述        |
| ------------ | ------- | ----------- |
| id           | int     | 评论 ID     |
| comment      | String  | 评论内容    |
| isDeleted    | Boolean | 是否删除    |
| parentId     | Integer | 回复评论 ID |
| recordId     | String  | 记录 ID     |
| createUserId | String  | 创建人 ID   |

**返回值**
类型为 Array<[TableComment](/guide/script/model.md#tablecomment)>
返回表单评论列表

**示例**

:::code-group

```js
informat.table.queryCommentList("staffs", {
  pageIndex: 1,
  pageSize: 20,
  filter: {
    conditionList: [
      {
        fieldId: "recordId",
        opt: "eq",
        value: "yhg8b23ej2gt6",
      },
    ],
  },
});
```

```json
[
  {
    "comment": "{\"type\":\"doc\",\"content\":[{\"type\":\"paragraph\",\"content\":[{\"text\":\"挺好的\",\"type\":\"text\"}]}]}",
    "createTime": 1717728322411,
    "createUserAvatar": "79a487eb7f384321bfaed16eb9e020d8.jpg",
    "createUserId": "skydu",
    "createUserName": "杜展扬",
    "delete": false,
    "id": 1,
    "isDelete": false,
    "parentId": 0,
    "recordId": "yhg8b23ej2gt6"
  }
]
```

:::

## addComment

添加表单评论

```javascript
informat.table.addComment(tableId, tableComment);
```

| 参数         | 类型                                                        | 描述         |
| ------------ | ----------------------------------------------------------- | ------------ |
| tableId      | String                                                      | 数据表标识符 |
| tableComment | [TableCommentForm](/guide/script/model.md#tablecommentform) | 表单评论     |

**返回值**
类型为`Integer`
返回新增的 ID

**评论示例**

:::code-group

```js
informat.table.addComment("staffs", {
  recordId: "yhg8b23ej2gt6",
  content: "评论内容",
  createUserId: "skydu", //非必填
});
```

```json
2
```

:::

**回复评论示例**

:::code-group

```js
informat.table.addComment("staffs", {
  recordId: "yhg8b23ej2gt6",
  parentId: 2, // 非必填
  content: "回复上一条评论",
  createUserId: "skydu", //非必填
});
```

```json
3
```

:::

## deleteComment

删除表单评论
:::tip
如果评论有回复，则逻辑删除，否则物理删除；
如果评论不存在，会报评论不存在错误
:::

```javascript
informat.table.deleteComment(tableId, commentId);
```

| 参数      | 类型    | 描述         |
| --------- | ------- | ------------ |
| tableId   | String  | 数据表标识符 |
| commentId | Integer | 表单评论 Id  |

**示例**

```javascript
informat.table.deleteComment("staffs", 3);
```

## getIdFieldSeq

查询编号字段当前自增序号

```javascript
informat.table.getIdFieldSeq(tableId, fieldId);
```

| 参数    | 类型   | 描述           |
| ------- | ------ | -------------- |
| tableId | String | 数据表标识符   |
| fieldId | String | 编号字段标识符 |

**返回值**
类型为`Integer`
返回当前自增序号

**示例**

:::code-group

```js
informat.table.getIdFieldSeq("task", "number");
```

```js[返回值]
2
```

:::

## setIdFieldSeq

设置编号字段自增序号

```javascript
informat.table.setIdFieldSeq(tableId, fieldId, seq);
```

| 参数    | 类型    | 描述           |
| ------- | ------- | -------------- |
| tableId | String  | 数据表标识符   |
| fieldId | String  | 编号字段标识符 |
| seq     | Integer | 自增序号       |

**示例**

```javascript
informat.table.setIdFieldSeq("staffs", "staffNo", 10);
```

## updateRecordSeq

更新数据表排序序号

```javascript
informat.table.updateRecordSeq(tableId, recordId, seq);
```

| 参数     | 类型    | 描述          |
| -------- | ------- | ------------- |
| tableId  | String  | 数据表标识符  |
| recordId | String  | 数据表记录 ID |
| seq      | Integer | 新的排序序号  |

**示例**

```javascript
informat.table.updateRecordSeq("staffs", "yhg8b23ej2gt6", 101);
```

## moveRecord

移动记录
:::tip
移动后会按照顺序重新计算 seq
:::

```javascript
informat.table.moveRecord(tableId, recordId, targetRecordId, type);
```

| 参数           | 类型   | 描述                                                                                           |
| -------------- | ------ | ---------------------------------------------------------------------------------------------- |
| tableId        | String | 数据表标识符                                                                                   |
| recordId       | String | 记录 ID                                                                                        |
| targetRecordId | String | 目标记录 ID                                                                                    |
| type           | String | 拖拽方式 可选值如下：<br />before:将记录移动至目标记录之前<br />after:将记录移动至目标记录之后 |

**示例**

```javascript
informat.table.moveRecord("task", "ksrhoqarae7hj", "dvmdfh74m0s2w", "before");
```

## moveTreeViewRecord

树形视图下移动记录

```javascript
informat.table.moveTreeViewRecord(tableId, childrenFieldId, recordId, parentRecordId, targetRecordId, type);
```

| 参数            | 类型   | 描述                                                                                                                   |
| --------------- | ------ | ---------------------------------------------------------------------------------------------------------------------- |
| tableId         | String | 数据表标识符                                                                                                           |
| childrenFieldId | String | 子对象字段                                                                                                             |
| recordId        | String | 记录 ID                                                                                                                |
| parentRecordId  | String | 父对象记录 ID,如果在同一层级移动，不需要设置                                                                           |
| targetRecordId  | String | 目标记录 ID                                                                                                            |
| type            | String | 拖拽方式 可选值如下：<br />before:将记录移动至目标记录之前<br />after:将记录移动至目标记录之后<br />inner:在父对象内部 |

**示例 1 同一层级下移动记录**

```javascript
informat.table.moveTreeViewRecord("staffsDept", "children", "l8w9u9raftp2a", null, "pz9y1fse8hccw", "before");
```

**示例 2 把记录拖动到新的父记录下**

```javascript
informat.table.moveTreeViewRecord("staffsDept", "children", "l8w9u9raftp2a", "fh1snm1k18kqc", "u3lma96ibq52h", "before");
```

## moveLookupFieldRecord

移动查找列表字段里的记录

```javascript
informat.table.moveLookupFieldRecord(tableId, lookupFieldId, mainRecordId, recordId, targetRecordId, type);
```

| 参数           | 类型   | 描述                                                                                           |
| -------------- | ------ | ---------------------------------------------------------------------------------------------- |
| tableId        | String | 数据表标识符                                                                                   |
| lookupFieldId  | String | 查找列表字段                                                                                   |
| mainRecordId   | String | 主表记录 ID                                                                                    |
| recordId       | String | 子表记录 ID                                                                                    |
| targetRecordId | String | 子表目标记录 ID                                                                                |
| type           | String | 拖拽方式 可选值如下：<br />before:将记录移动至目标记录之前<br />after:将记录移动至目标记录之后 |

**示例**

```javascript
informat.table.moveLookupFieldRecord("staffs", "leaveLogRel", "yhg8b23ej2gt6", "p54xumqba4kmm", "vdbt9kk1cugvy", "before");
```

## moveRelationFieldRecord

移动关联列表字段里的记录

```javascript
informat.table.moveRelationFieldRecord(tableId, relationFieldId, mainRecordId, recordId, targetRecordId, type);
```

| 参数            | 类型   | 描述                                                                                           |
| --------------- | ------ | ---------------------------------------------------------------------------------------------- |
| tableId         | String | 数据表标识符                                                                                   |
| relationFieldId | String | 关联列表字段                                                                                   |
| mainRecordId    | String | 主表记录 ID                                                                                    |
| recordId        | String | 子表记录 ID                                                                                    |
| targetRecordId  | String | 子表目标记录 ID                                                                                |
| type            | String | 拖拽方式 可选值如下：<br />before:将记录移动至目标记录之前<br />after:将记录移动至目标记录之后 |

**示例**

```javascript
informat.table.moveRelationFieldRecord("staffs", "rewardList", "yhg8b23ej2gt6", "vsf3lo6ryj6lc", "ct82dszf20s2u", "before");
```

## moveChildrenFieldRecord

移动子对象字段里的记录

```javascript
informat.table.moveChildrenFieldRecord(tableId, childrenFieldId, mainRecordId, recordId, targetRecordId, type);
```

| 参数            | 类型   | 描述                                                                                           |
| --------------- | ------ | ---------------------------------------------------------------------------------------------- |
| tableId         | String | 数据表标识符                                                                                   |
| childrenFieldId | String | 子对象字段                                                                                     |
| mainRecordId    | String | 主表记录 ID                                                                                    |
| recordId        | String | 子表记录 ID                                                                                    |
| targetRecordId  | String | 子表目标记录 ID                                                                                |
| type            | String | 拖拽方式 可选值如下：<br />before:将记录移动至目标记录之前<br />after:将记录移动至目标记录之后 |

**示例**

```javascript
informat.table.moveChildrenFieldRecord("staffsDept", "children", "rpev2ztqnbu8o", "l8w9u9raftp2a", "pz9y1fse8hccw", "before");
```

## moveLookupFieldTreeViewRecord

查找列表字段树形视图下移动记录

```javascript
informat.table.moveLookupFieldTreeViewRecord(tableId, lookupFieldId, childrenFieldId, mainRecordId, recordId, parentRecordId, targetRecordId, type);
```

| 参数            | 类型   | 描述                                                                                                                   |
| --------------- | ------ | ---------------------------------------------------------------------------------------------------------------------- |
| tableId         | String | 数据表标识符                                                                                                           |
| lookupFieldId   | String | 查找列表字段                                                                                                           |
| childrenFieldId | String | 子对象字段                                                                                                             |
| mainRecordId    | String | 主表记录 ID                                                                                                            |
| recordId        | String | 子表记录 ID                                                                                                            |
| parentRecordId  | String | 父对象记录 ID                                                                                                          |
| targetRecordId  | String | 子表目标记录 ID                                                                                                        |
| type            | String | 拖拽方式 可选值如下：<br />before:将记录移动至目标记录之前<br />after:将记录移动至目标记录之后<br />inner:在父对象内部 |

**示例**

```javascript
informat.table.moveLookupFieldTreeViewRecord("lookup", "lookup_children", "children", "ozyqa05tj4xs0", "xim3193k04lu0", null, "pjrpekzh9gc2j", "before");
```

## moveRelationFieldTreeViewRecord

关联列表字段树形视图下移动记录

```javascript
informat.table.moveRelationFieldTreeViewRecord(tableId, relationFieldId, childrenFieldId, mainRecordId, recordId, parentRecordId, targetRecordId, type);
```

| 参数            | 类型   | 描述                                                                                                                   |
| --------------- | ------ | ---------------------------------------------------------------------------------------------------------------------- |
| tableId         | String | 数据表标识符                                                                                                           |
| relationFieldId | String | 关联列表字段                                                                                                           |
| childrenFieldId | String | 子对象字段                                                                                                             |
| mainRecordId    | String | 主表记录 ID                                                                                                            |
| recordId        | String | 子表记录 ID                                                                                                            |
| parentRecordId  | String | 父对象记录 ID                                                                                                          |
| targetRecordId  | String | 子表目标记录 ID                                                                                                        |
| type            | String | 拖拽方式 可选值如下：<br />before:将记录移动至目标记录之前<br />after:将记录移动至目标记录之后<br />inner:在父对象内部 |

**示例**

```javascript
informat.table.moveRelationFieldTreeViewRecord("relation", "relation_children", "children", "xzyqa35tj4xsq", "kim3193k54lu8", null, "fjrpekzh9gc6h", "before");
```

## moveChildrenFieldTreeViewRecord

子对象字段树形视图下移动记录

```javascript
informat.table.moveChildrenFieldTreeViewRecord(tableId, mainChildrenFieldId, childrenFieldId, mainRecordId, recordId, parentRecordId, targetRecordId, type);
```

| 参数                | 类型   | 描述                                                                                                                   |
| ------------------- | ------ | ---------------------------------------------------------------------------------------------------------------------- |
| tableId             | String | 数据表标识符                                                                                                           |
| mainChildrenFieldId | String | 子对象字段                                                                                                             |
| childrenFieldId     | String | 子对象字段                                                                                                             |
| mainRecordId        | String | 主表记录 ID                                                                                                            |
| recordId            | String | 子表记录 ID                                                                                                            |
| parentRecordId      | String | 父对象记录 ID                                                                                                          |
| targetRecordId      | String | 子表目标记录 ID                                                                                                        |
| type                | String | 拖拽方式 可选值如下：<br />before:将记录移动至目标记录之前<br />after:将记录移动至目标记录之后<br />inner:在父对象内部 |

**示例**

```javascript
informat.table.moveChildrenFieldTreeViewRecord("children", "children_children", "children", "izyqa25tj4xsp", "iim3103k54lup", null, "ilrpekzh3gc2p", "before");
```

## refreshIndexNumber

重新计算子对象编号

```javascript
informat.table.refreshIndexNumber(tableId, fieldId, parentRecordId);
```

| 参数           | 类型   | 描述                                               |
| -------------- | ------ | -------------------------------------------------- |
| tableId        | String | 数据表标识符                                       |
| fieldId        | String | 子对象编号字段                                     |
| parentRecordId | String | 父对象记录 ID,可以为空；当值未空时就是全部重新计算 |

**示例**

```javascript
informat.table.refreshIndexNumber("staffsDept", "indexNumber", "rpev2ztqnbu8o"); //重新计算父记录的子记录列表
informat.table.refreshIndexNumber("staffsDept", "indexNumber", null);
```

## validateForm

执行字段校验规则校验表单数据

```javascript
informat.table.validateForm(tableId, record);
```

| 参数           | 类型   | 描述                                               |
| -------------- | ------ | -------------------------------------------------- |
| tableId        | String | 数据表标识符                                       |
| record        | Object | 表单记录                                     |

**示例**

```javascript
let result=informat.table.validateForm("staffs", {
	age:-1
}); 
console.log(result);
```
输出内容
```json
{
  "itemList":[
    {
      "errorCode":270001,
      "errorMessage":"年龄不能小于等于0",
      "fieldId":"urx7djdqnp7mf",
      "fieldKey":"age",
      "fieldName":"年龄"
    }
  ]
}
```

## validateFormBySetting

根据配置校验表单数据

```javascript
informat.table.validateFormBySetting(tableId, record, setting);
```

| 参数           | 类型   | 描述                                               |
| -------------- | ------ | -------------------------------------------------- |
| tableId        | String | 数据表标识符                                       |
| record        | Object | 表单记录                                     |
| setting        | ValidateFormSetting | 配置项                                     |


### ValidateFormSetting
检查配置
```ts
interface ValidateFormSetting {
	nullable:boolean;//必填项校验
	optionValue:boolean;//选项值范围校验
	range:boolean;//单行文本，多行文本的长度；小数整数范围校验
	validateRule:boolean;//字段校验规则校验
}
```

**示例1**

```javascript
let result=informat.table.validateFormBySetting('staff',{'age':'1'},{'nullable':true})
console.log(result);
```
输出内容
```json
{
  "itemList":[
    {
      "errorCode":210204,
      "errorMessage":"字段值不能为空",
      "fieldId":"n05f9w24mu2y3",
      "fieldKey":"name",
      "fieldName":"姓名"
    }
  ]
}
```

**示例2**

```javascript
let result=informat.table.validateFormBySetting('staff',{'salary':'100000'},{'range':true})
console.log(result);
```
输出内容
```json
{
  "itemList":[
    {
      "errorCode":210202,
      "errorMessage":"数据表【员工】字段【薪资】取值不在限定范围内 100000/50000",
      "fieldId":"p6vou466dq0xy",
      "fieldKey":"salary",
      "fieldName":"薪资"
    }
  ]
}
```

**示例3**

```javascript
let result=informat.table.validateFormBySetting('staff',{'sex':'test'},{'optionValue':true})
console.log(result);
```
输出内容
```json
{
  "itemList":[
    {
      "errorCode":210205,
      "errorMessage":"字段值不在选项范围内",
      "fieldId":"jxky9knv40ikm",
      "fieldKey":"sex",
      "fieldName":"性别"
    }
  ]
}
```
