npm package: @icreate/imedx-js-sdk
Description: npm i @icreate/imedx-js-sdk
Author: chujinzhu
Latest version: 0.0.32-beta.2

#### 安装

    npm i @icreate/imedx-js-sdk

#### 引用

    import { createClient, DbDataType, sql } from '@icreate/imedx-js-sdk'

#### 创建 imedxService

```
/**
* @description: 创建 imedxService
* @param {String} URL 请求地址
* @param {String} headers 请求头
* @param {String} appId 应用ID
* @param {String} secretKey 密钥
* @param {String} autoEncrypt 自动加密
* @return {*}
*/
const imedxService = createClient('http://192.168.2.24:9090', {
  headers: { data_source: 'default' },
  appId: '',
  secretKey: '',
  autoEncrypt: true
})
```

#### 请求拦截器

```
imedxService.interceptors.request.use(
  config => {
    // if (store.getters.token) {
    config.headers['Authorization'] = `Bearer zzzzzzzzzzz`
    // }
    return config
  },
  error => {
    console.log('------request error------', error)
    return Promise.reject(error)
  }
)
```

#### 响应拦截器

```
imedxService.interceptors.response.use(
  async res => {
    try {
      res.data = JSON.parse(res.data)
    } catch (error) {
      return Promise.reject(error)
    }
    if (res.code !== 200) {
      return Promise.reject(new Error(res.message || 'Error'))
    } else {
      return res
    }
  },
  error => {
    console.log('------response error------', error)
    return Promise.reject(error)
  }
)
```

#### 查询

- from: 表名称。
- select: 查询列字符串，无入参时默认 \* 。
- where: 条件字符串，默认 AND 拼接。
- in: 列名 + 数据集。
- notIn: 列名 + 数据集。
- and 条件字符串，是会追加 AND 条件。
- or 拼接 OR 条件
- order 排序 倒叙直接列名.desc
- limit pageSize 分页查询条数 currentPage 当前页，从 1 开始

```
const startDate = '2022-01-01'
const endDate = '2022-02-01'
const StudentIds = ['1111111', '22222222', '333333333']
const StudentName = ['aaaaaa', 'bbbbbbb', 'cccccccc']
let keys = '关键字'
keys = keys.replace(/'/g, `''`)
var LikeKey = [
  `STUDENT_ID LIKE '%${keys}%'`,
  `STUDENT_NAME LIKE '%${keys}%'`,
  `HEIGHT LIKE '%${keys}%'`,
  `WEIGHT LIKE '%${keys}%'`
]

const data = await imedxService
  .from('SIMS_STUDENT')
  .select('STUDENT_ID, STUDENT_NAME, HEIGHT, WEIGHT')
  .where(`CREATED_TIME >= '${startDate}'`, `CREATED_TIME < '${endDate}'`, `STATUS = 1`)
  .in('STUDENT_ID', StudentIds)
  .notIn('STUDENT_NAME', StudentName)
  .and(`GENDER = '男'`, `NATION = '汉'`)
  .or(LikeKey)
  .order('STUDENT_ID', 'HEIGHT.DESC')
  .limit(20, 1)
```

#### 查询 - 根据主键 ID

- from: 表名称。
- select: 查询列字符串，无入参时默认 \* 。
- id: 主键 ID 的值。

```
const data = await imedxService
  .from('SIMS_STUDENT')
  .select('STUDENT_ID, STUDENT_NAME, HEIGHT, WEIGHT')
  .id('123456')
```

#### 查询 - 支持参数化设置

- params 参数对象，支持多入参，合并参数属性。

```
const params = {
  startDate: '2022-01-01',
  endDate: '2022-02-01',
  status: 1
}
const data = await imedxService
  .from('SIMS_STUDENT')
  .select('STUDENT_ID, STUDENT_NAME, HEIGHT, WEIGHT')
  .where(`CREATED_TIME >= #{startDate}`, `CREATED_TIME < #{endDate}`, `STATUS = #{status}`)
  .order('STUDENT_ID', 'HEIGHT.DESC')
  .limit(20, 1)
  .params(params)
```

#### 查询 - CLOB 类型列

- selectClob： 列名称，仅单行单列查询。

```
const data = await imedxService
  .from('DB_SOURCE')
  .selectClob('AVATAR')
  .where('id="cccc"')
```

#### 查询 - BLOB 类型列

- selectBlob 列名称，仅单独列查询。

```
const data = await imedxService
  .from('DB_SOURCE')
  .selectBlob('AVATAR')
  .where('id="cccc"')
```

#### 复杂查询

| 操作对象 |    方法    | 入参                                    | 说明                                                         |
| :------: | :--------: | :-------------------------------------- | :----------------------------------------------------------- |
|   sql    |   define   | 表名+列数组：{ name: '', columns: [] }  | 定义表结构                                                   |
|    表    |   select   | 列对象，无参时默认\*，支持多入参        | 指定查询列                                                   |
|    表    |    from    | 表对象                                  | 指定查询表                                                   |
|    表    |   where    | 列条件                                  | 指定 where 条件                                              |
|    表    |  orderBy   | 列对象，倒序直接: 列.desc()，支持多入参 | 指定排序规则                                                 |
|    表    | pagination | pageSize: 行数, currentPage：当前页     | 指定分页查询；必须有 order by 条件                           |
|    表    |  toQuery   |                                         | 返回查询对象                                                 |
|    表    |    join    | 表对象                                  | join 表                                                      |
|    表    |  leftJoin  | 表对象                                  | left join 表                                                 |
|    表    | rightJoin  | 表对象                                  | right join 表                                                |
|    表    | innerJoin  | 表对象                                  | inner join 表                                                |
|    表    |     on     | 列条件                                  | 在 join、leftJoin、rightJoin、innerJoin 后使用，指定关联条件 |
|    列    |   isNull   |                                         | IS NULL                                                      |
|    列    | isNotNull  |                                         | IS NOT NULL                                                  |
|    列    |   equals   | 值或列                                  | 等于： =                                                     |
|    列    | notEquals  | 值或列                                  | 不等于：<>                                                   |
|    列    |     gt     | 值或列                                  | 大于：>                                                      |
|    列    |    gte     | 值或列                                  | 大于等于：>=                                                 |
|    列    |     lt     | 值或列                                  | 小于：<                                                      |
|    列    |    lte     | 值或列                                  | 小于等于：<=                                                 |
|    列    |    like    | 值                                      | LIKE                                                         |
|    列    |  notLike   | 值                                      | NOT LIKE                                                     |
|    列    |     in     | 值集合                                  | IN                                                           |
|    列    |   notIn    | 值集合                                  | NOT IN                                                       |
|    列    |  between   | 开始值 + 结束值                         | BETWEEN                                                      |
|    列    | notBetween | 开始值 + 结束值                         | NOT BETWEEN                                                  |
|    列    |    desc    |                                         | 倒序 DESC                                                    |
|    列    |    and     | 列条件                                  | 拼接 AND 条件                                                |
|    列    |     or     | 列条件                                  | 拼接 OR 条件                                                 |

```
// 定义学生表
var SimsStudent = sql.define({
  name: 'SIMS_STUDENT',
  columns: ['COLLEGE_ID', 'CLASS_ID', 'STUDENT_ID', 'STUDENT_NAME', 'ENG_NAME', 'ID_CARD_NO', 'CONTENT']
})

// 定义班级表
var SimsClass = sql.define({
  name: 'SIMS_CLASS',
  columns: ['COLLEGE_ID', 'MAJOR_ID', 'CLASS_ID', 'CLASS_NAME', 'STUDENT_NUMBER']
})

// 单行单列查询 CLOB类型
var query = SimsStudent.selectClob(SimsStudent.CONTENT)
  .from(SimsStudent)
  .where(SimsStudent.STUDENT_ID.equals('boom'))
  .toQuery()

// 单表查询
var query1 = SimsStudent
  .select(SimsStudent.STUDENT_ID, SimsStudent.STUDENT_NAME, SimsStudent.ID_CARD_NO)
  .from(SimsStudent)
  .where(
    SimsStudent.STUDENT_NAME
      .equals('boom')
      .and(SimsStudent.ENG_NAME.equals('sssss'))
      .or(SimsStudent.COLLEGE_ID.equals('55555555').and(SimsStudent.CLASS_ID.isNull()))
  )
  .toQuery()

// 关联表查询
var query2 = SimsStudent
  .select()
  .from(
    SimsStudent
      .join(SimsClass)
      .on(SimsStudent.COLLEGE_ID.equals(SimsClass.COLLEGE_ID))
  )
  .where(SimsStudent.STUDENT_NAME.equals('boom').and(SimsClass.CLASS_NAME.equals('aaaaaa')))
  .orderBy(SimsClass.CLASS_ID.desc(), SimsStudent.STUDENT_ID)
  .pagination(20, 1)
  .toQuery()

const data = await imedxService.commit(query, query1, query2)
```

#### SQL执行

- SQLQuery：SQL语句，参数对象
- SQL语句中参数用 #{} 占位。

```
var querySQL = `SELECT * FROM SIMS_STUDENT WHERE ID = #{ID} AND NAME = #{NAME)`
var params = {ID: '159159159', NAME: '储某某'}
var query = sql.SQLQuery(querySQL, params)

const data = await imedxService.commit(query)
```

#### 插入数据

- from: 表名称。
- insert: 插入数据集。
- field: 在 URL 中指定列对应数据类型。

```
const data = await imedxService
  .from('SIMS_STUDENT')
  .insert([
    { ID: '6', STUDENT_ID: '6', STUDENT_NAME: '6', HEIGHT: '6', version: '1' },
    { ID: '8', STUDENT_ID: '8', STUDENT_NAME: '8', HEIGHT: '8', version: '1' }
  ])
  .field('ID', DbDataType.Varchar2)
  .field('STUDENT_ID', DbDataType.Varchar2)
  .field('STUDENT_NAME', DbDataType.Varchar2)
```

#### 更新数据

- from: 表名称。
- update: 更新数据集。

```
const data = await imedxService
  .from('SIMS_STUDENT')
  .update(
    [
      { ID: '4', STUDENT_ID: '4', STUDENT_NAME: '4', HEIGHT: '4', version: '2' },
      { ID: '5', STUDENT_ID: '5', STUDENT_NAME: '5', HEIGHT: '5', version: '2' }
    ]
  )
```

#### 更新数据 - 根据主键 ID

- from: 表名称。
- update: 更新数据集 + 主键 ID 值。

```
const data = await imedxService
  .from('SIMS_STUDENT')
  .update({ STUDENT_ID: '11', STUDENT_NAME: '2' }, 'aaaaaa')
```

#### 删除数据

- from: 表名称。
- delete: 删除数据集。

```
const data = await imedxService
  .from('SIMS_STUDENT')
  .delete([{ ID: '4' }, { ID: '5' }])
```

#### 删除数据 - 根据主键 ID

- from: 表名称。
- delete: 无需入参
- id: 主键值

```
const data = await imedxService
  .from('SIMS_STUDENT')
  .delete()
  .id('5')
```

#### 存储过程调用（无返回值）

- proc1: 存储过程过程名 + 存储过程过程入参 JSON 字符串

```
const data = await imedxService.proc1('procedure_name', '{"p_user_id":"sa"}')
```

#### 存储过程调用（有返回值）

- proc2: 存储过程过程名 + 存储过程过程入参 JSON 字符串

```
const data = await imedxService.proc2('procedure_name', '{"p_user_id":"sa"}')
```

#### 存储过程调用 - 方式二

- proc1：无返回值；入参：存储过程名，参数对象
- proc2：有返回值；入参：存储过程名，参数对象

```
var procName = `P_TEST`
var params = {ID: '159159159', NAME: '储某某'}
var proc1 = sql.proc1(procName, params)
var proc2 = sql.proc1(procName, params)

const data = await imedxService.commit(proc1, proc2)
```

#### 函数调用

- func: 函数名 + 函数入参对象

```
const data = await imedxService.func('function_name', { param1: 'value1' })
```

#### 多表操作

- 多张表的 增 删 改 操作 - 写法一
- result_id: 请求 ID，用于区分结果集属于哪个表操作。
- table_name: 表名称。
- type: 操作类型 insert|update|delete
- data: 操作数据集
- fields: 列类型对象

```
const data = await imedxService
  .commit(
    {
      result_id: '111111',
      table_name: 'ICS_TEST_TABLE',
      type: 'insert',
      data: [
        { ID: '10', name: '10', age: '10', address: '10', version: '1' },
        { ID: '11', name: '11', age: '11', address: '11', version: '1' }
      ],
      fields: { desc: DbDataType.Clob, remark: DbDataType.Varchar2 }
    },
    {
      result_id: '222222',
      table_name: 'ICS_TEST_TABLE',
      type: 'update',
      data: [
        { ID: '12', name: '12', age: '12', address: '12', version: '1' },
        { ID: '13', name: '13', age: '13', address: '13', version: '1' }
      ],
      fields: { desc: DbDataType.Clob, remark: DbDataType.Varchar2 }
    },
    {
      result_id: '333333',
      table_name: 'ICS_TEST_TABLE',
      type: 'delete',
      data: [
        { ID: '12', name: '12', age: '12', address: '12', version: '1' },
        { ID: '13', name: '13', age: '13', address: '13', version: '1' }
      ],
      fields: { desc: DbDataType.Clob, remark: DbDataType.Varchar2 }
    }
  )
```

- 多张表的 增 删 改 操作 - 写法二
- sql.define

| 操作对象 | 方法名  | 入参                                            | 说明                       |
| :------: | :-----: | :---------------------------------------------- | :------------------------- |
|   sql    | define  | 表名+列数组：{ name: '', columns: [] }          | 定义表结构                 |
|    表    | insert  | 数据集，即需要插入的数据集                      | 生成多表操作的 insert 对象 |
|    表    | update  | 数据集，即需要更新的数据集                      | 生成多表操作的 update 对象 |
|    表    | delete  | 数据集，即需要删除的数据集                      | 生成多表操作的 delete 对象 |
|    表    | fields  | 特殊列类型指定：{ columnName: DbDataType.Clob } | 参数说明特殊列类型         |
|    表    | toQuery |                                                 | 返回指定类型对象           |

```
// 定义学生表
var SimsStudent = sql.define({
  name: 'SIMS_STUDENT',
  columns: ['COLLEGE_ID', 'CLASS_ID', 'STUDENT_ID', 'STUDENT_NAME', 'ENG_NAME', 'ID_CARD_NO']
})
// 定义班级表
var SimsClass = sql.define({
  name: 'SIMS_CLASS',
  columns: ['COLLEGE_ID', 'MAJOR_ID', 'CLASS_ID', 'CLASS_NAME', 'STUDENT_NUMBER']
})

// 通过表生成 Insert 对象
var Insert = SimsStudent
  .insert({ COLLEGE_ID: '5', CLASS_ID: '5', STUDENT_ID: '5', STUDENT_NAME: '5', ENG_NAME: '1', ID_CARD_NO: '1' })
  .fields({ ID_CARD_NO: DbDataType.Clob })
  .toQuery()

// 通过表生成 Update 对象
var Update = SimsStudent
  .update([{ COLLEGE_ID: '5', CLASS_ID: '6', STUDENT_ID: '6', STUDENT_NAME: '6', ENG_NAME: '6', ID_CARD_NO: '6' }])
  .fields({ ID_CARD_NO: DbDataType.Clob })
  .toQuery()

// 通过表生成 Delete 对象
var Delete = SimsStudent
  .delete([{ COLLEGE_ID: '5', CLASS_ID: '5', STUDENT_ID: '5', STUDENT_NAME: '5', ENG_NAME: '1', ID_CARD_NO: '1' }])
  .fields({ ID_CARD_NO: DbDataType.Clob })
  .toQuery()

const data = await imedxService.commit(Insert, Update, Delete)
```