清除过滤器
文章
Michael Lei · 七月 18, 2022
Hi 大家好! 我是 Sergei Sarkisian，在InterSystems 做Angular 前端7年。Angular是非常流行的框架，我们的开发人员、客户和合作伙伴经常选择它来开发他们的应用程序。
我会写一系列的文章，涵盖Angular的不同方面：概念、方法、最佳实践、高级主题等等。这个系列的文章将针对那些已经熟悉Angular的人，不会涉及基本概念。由于我正在构建文章的路线图，我想从突出最近的Angular版本中的一些重要功能开始。
## 严格类型化表单
这可能是近几年来Angular最受欢迎的功能。有了Angular 14，开发者现在可以在Angular Reactive Forms中使用TypeScript的所有严格类型检查功能。
表单控制Formcontrol 类现在是通用的，并接受它所持有的值的类型。
```typescript
/* Before Angular 14 */
const untypedControl = new FormControl(true);
untypedControl.setValue(100); // value is set, no errors
// Now
const strictlyTypedControl = new FormControl(true);
strictlyTypedControl.setValue(100); // you will receive the type checking error message here
// Also in Angular 14
const strictlyTypedControl = new FormControl(true);
strictlyTypedControl.setValue(100); // you will receive the type checking error message here
```
正如你所见，第一个和最后一个例子几乎是一样的，但有不同的结果。这是因为在Angular 14中，新的FormControl类从开发者提供的初始值中推断出类型。因此，如果提供了`true`的值，Angular就为这个FormControl设置`boolean | null`的类型。`.reset()`方法需要可置空的值，如果没有提供值，就会置空这些值。
一个旧的、没有定义类型的FormControl类被转换为`UntypedFormControl`（对`UntypedFormGroup`、`UntypedFormArray`和`UntypedFormBuilder`来说也是如此），它实际上是`FormControl`的别名。如果你从以前的Angular版本升级，你所有提到的`FormControl`类将被Angular CLI替换为`UntypedFormControl`类。
Untyped* 类通常用以实现特定目标:
1. 保持应用程序的工作方式与从以前的版本过渡之前完全一样（记住，新的FormControl将从初始值推断出类型）
2. 确保所有的`FormControl`的使用都是有意的。所以你需要自己将任何UntypedFormControl改为`FormControl`。
3. 为了给开发者提供更多的灵活性（我们将在下面介绍这个问题）
记住，如果你的初始值是 "null"，那么你将需要明确指定FormControl类型。另外，在TypeScript中有一个错误，如果你的初始值是 "false"，也需要这样做。
对于表单组，你也可以定义接口，并把这个接口作为表单组的类型传递。在这种情况下，TypeScript将推断出FormGroup中的所有类型。
```typescript
interface LoginForm {
email: FormControl;
password?: FormControl;
}
const login = new FormGroup({
email: new FormControl('', {nonNullable: true}),
password: new FormControl('', {nonNullable: true}),
});
```
FormBuilder的方法`.group()`现在有了通用属性，可以接受你预定义的接口，就像上面的例子中我们手动创建了FormGroup。
```typescript
interface LoginForm {
email: FormControl;
password?: FormControl;
}
const fb = new FormBuilder();
const login = fb.group({
email: '',
password: '',
});
```
由于我们的接口只有原始的nonNullable类型，它可以用新的 "nonNullable "表单生成器属性来简化（它包含 "NonNullable FormBuilder表单生成器 "类实例，也可以直接创建）:
```typescript
const fb = new FormBuilder();
const login = fb.nonNullable.group({
email: '',
password: '',
});
```
❗ 请注意，如果你使用nonNullable的FormBuilder或者你在FormControl中设置了nonNullable的选项，那么当你调用`.reset()`方法时，它将使用初始FormControl值作为重置值。
另外，非常重要的一点是，`this.form.value`中的所有属性都将被标记为可选属性。像这样:
```typescript
const fb = new FormBuilder();
const login = fb.nonNullable.group({
email: '',
password: '',
});
// login.value
// {
// email?: string;
// password?: string;
// }
```
发生这种情况是因为当你禁用表单组FormGroup内的任何表单控件FromControl时，这个表单控件的值将从`form.value`中删除。
```typescript
const fb = new FormBuilder();
const login = fb.nonNullable.group({
email: '',
password: '',
});
login.get('email').disable();
console.log(login.value);
// {
// password: ''
// }
```
要获得整个表单对象，你应该使用`.getRawValue()`方法：:
```typescript
const fb = new FormBuilder();
const login = fb.nonNullable.group({
email: '',
password: '',
});
login.get('email').disable();
console.log(login.getRawValue());
// {
// email: '',
// password: ''
// }
```
严格类型化表单的优势:
1. 任何返回FormControl / FormGroup值的属性和方法现在都是严格类型的。例如：`value`，`getRawValue()`，`valueChanges`.
2. 任何改变表单控件值的方法现在都是类型安全的:`setValue()`, `patchValue()`, `updateValue()`
3. 表单控件现在是严格类型化的。它也适用于表单组的`.get()`方法。这也将防止你在编译时发生访问不存在的情况.
### 新的 FormRecord 类
新的 "表单组 "类的缺点是它失去了它的动态性质。一旦定义了，你将不能在运行中添加或删除表单控件。
为了解决这个问题，Angular提出了新的类--`FormRecord'。`FormRecord`实际上与`FormGroup`相同，但它是动态的，所有的表单控件都应该有相同的类型。.
```typescript
folders: new FormRecord({
home: new FormControl(true, { nonNullable: true }),
music: new FormControl(false, { nonNullable: true })
});
// Add new FormContol to the group
this.foldersForm.get('folders').addControl('videos', new FormControl(false, { nonNullable: true }));
// This will throw compilation error as control has different type
this.foldersForm.get('folders').addControl('books', new FormControl('Some string', { nonNullable: true }));
```
正如你所看到的，这里有另一个限制 - 所有的FormControls必须是相同的类型。如果你真的需要动态和异质的FormGroup，你应该使用`UntypedFormGroup`类来定义你的表单
## 无模块的 (独立standalone) 组件
这个特性仍然被标记为实验性的，但它是一个有趣的功能。它允许你定义组件、指令和管道，而不把它们包含在任何模块中。
这个概念还没有完全准备好，但我们已经能够在没有ngModules的情况下建立一个应用程序。
要定义一个独立的组件，你需要使用Component组件/Pipe管道/Directive Decorator指令装饰器中新的`standalone'属性:
```typescript
@Component({
selector: 'app-table',
standalone: true,
templateUrl: './table.component.html'
})
export class TableComponent {
}
```
在这种情况下，这个组件不能在任何NgModule中声明。但它可以在NgModules和其他独立组件中被导入。
每个独立的组件/管道/指令现在都有机制可以直接在Decorator装饰器中导入它的依赖项:
```typescript
@Component({
standalone: true,
selector: 'photo-gallery',
// an existing module is imported directly into a standalone component
// CommonModule imported directly to use standard Angular directives like *ngIf
// the standalone component declared above also imported directly
imports: [CommonModule, MatButtonModule, TableComponent],
template: `
...
Next Page
`,
})
export class PhotoGalleryComponent {
}
```
正如我上面提到的，你可以在任何现有的ngModule中导入独立的组件。不再需要导入整个共享模块，我们可以只导入我们真正需要的东西。这也是一个开始使用新的独立组件的好策略:
```typescript
@NgModule({
declarations: [AppComponent],
imports: [BrowserModule, HttpClientModule, TableComponent], // import our standalone TableComponent
bootstrap: [AppComponent]
})
export class AppModule {}
```
你可以通过输入Angular CLI创建独立的组件:
```bash
ng g component --standalone user
```
### Bootstrap 无模块的应用
如果你想摆脱你的应用程序中的所有ngModules，你将需要以不同的方式启动你的应用程序。Angular有新的函数，你需要在main.ts文件中调用这个函数:
```typescript
bootstrapApplication(AppComponent);
```
这个函数的第二个参数将允许你定义你在你的应用程序中需要的提供者。由于大多数提供者通常存在于模块中，Angular（目前）需要为它们使用一个新的`importProvidersFrom`提取函数:
```typescript
bootstrapApplication(AppComponent, { providers: [importProvidersFrom(HttpClientModule)] });
```
### 懒人加载独立组件的路线:
Angular有新的懒人-加载路由函数`loadComponent`，它的存在正是为了加载独立的组件:
```typescript
{
path: 'home',
loadComponent: () => import('./home/home.component').then(m => m.HomeComponent)
}
```
`loadChildren`现在不仅允许懒人加载ngModule，而且还允许直接从路由文件中加载子路由:
```typescript
{
path: 'home',
loadChildren: () => import('./home/home.routes').then(c => c.HomeRoutes)
}
```
### 关于本文的一些注意事项
- 独立组件的功能仍处于实验阶段。它在未来会变得更好，因为它将移到Vite builder而不是Webpack，更好的工具，更快的构建时间，更强大的应用架构，更容易的测试等等。但现在这些东西都没有了，所以我们没有得到整个包，但至少我们可以开始用新的Angular范式开发我们的应用程序。
- IDE和Angular工具还没有完全准备好静态地分析新的独立实体。因为你需要在每个独立实体中导入所有的依赖关系，万一你漏掉了什么，编译器也会漏掉它，并在运行时让你失败。这一点会随着时间的推移而得到改善，但现在需要开发人员更加关注导入。
- 目前Angular中没有全局导入（例如在Vue中），所以你需要在每个独立实体中完全导入每个依赖。我希望这个问题能在未来的版本中得到解决，因为在我看来，这个功能的主要目标是减少模板，让事情变得更简单。
#
先写到这，谢谢大家！
文章
姚 鑫 · 十一月 11, 2021
# 第七十三章 SQL命令 SET OPTION
设置执行选项。
# 大纲
```java
SET OPTION option_keyword = value
```
# 描述
`SET OPTION`语句用于设置执行选项，如编译模式、`SQL`配置设置和控制日期、时间和数字约定的区域设置。
每个`set option`语句只能设置一个关键字选项。
`SET OPTION`支持以下选项:
- `AUTO_PARALLEL_THRESHOLD
- `COMPILEMODE`
- `DEFAULT_SCHEMA``
- `EXACT_DISTINCT`
- `LOCK_ESCALATION_THRESHOLD`
- `LOCK_TIMEOUT`
- `PKEY_IS_IDKEY`
- `SUPPORT_DELIMITED_IDENTIFIERS`
- `Locale Options (date, time, and numeric conventions)`
`SET OPTION`可以在动态SQL(包括`SQL Shell`)和嵌入式SQL中使用。
为了`SQL`兼容性，IRIS会解析其他`SET OPTION`参数(这里没有文档)，但不执行任何操作。
因为`SET OPTION`的准备和执行速度很快，而且通常只运行一次，所以`IRIS`不会在`ODBC`、`JDBC`或动态SQL中为`SET OPTION`创建缓存查询。
IRIS支持下列选项:
## `AUTO_PARALLEL_THRESHOLD`
`AUTO_PARALLEL_THRESHOLD`选项被设置为一个整数`n`，用于确定当启用自动并行处理时是否应该对查询应用并行处理。
由于与并行处理相关的性能成本，因此需要为并行处理的优势确定一个阈值。
`n`越高，SQL查询使用并行处理执行的可能性就越低。
默认为`3200`。
这是一个系统范围的设置。
值n大致对应于所访问的映射中发生并行处理所需的最小元组数量。
当自动并行被禁用时，`AUTO_PARALLEL_THRESHOLD`选项没有作用。
也可以使用`$SYSTEM.SQL.Util.SetOption()`方法`AutoParallelThreshold`选项设置该选项。
## COMPILEMODE
`COMPILEMODE`选项将当前名称空间的编译模式设置为`DEFERRED`、`IMMEDIATE`、`INSTALL`或`NOCHECK`。
默认为`IMMEDIATE`。
从`DEFERRED`编译模式更改为`IMMEDIATE`编译模式会导致`DEFERRED compile Queue`中的任何类立即被编译。
如果所有类编译都成功，IRIS将`SQLCODE`设置为0。
如果有任何错误，`SQLCODE`设置为`-400`。
类编译错误记录在`^mtemp2 ("Deferred Compile Mode"，"Error")`中。
如果将`SQLCODE`设置为`-400`，则应该查看此全局结构以获得更精确的错误消息。
`INSTALL`编译模式类似于`DEFERRED`编译模式，但它应该只用于表中没有数据的`DDL`安装。
`NOCHECK`编译模式与`IMMEDIATE`编译模式类似，只是在编译时忽略了以下约束:如果一个表被删除， IRIS不检查引用被删除表的其他表中的外键约束。
如果添加了外键约束， IRIS不会检查现有数据以确保它对这个外键有效。
如果添加了`NOT NULL`约束， IRIS不会检查现有数据是否为`NULL`，也不会指定字段的默认值。
如果删除了`UNIQUE`或`Primary Key`约束 IRIS不会检查该表或其他表中的外键是否引用了被删除的键。
也可以使用`$SYSTEM.SQL.Util.SetOption()`方法`CompileMode`选项设置该选项。
## DEFAULT_SCHEMA
`DEFAULT_SCHEMA`选项为所有名称空间设置系统范围的默认模式。
在显式更改之前，此默认值将保持有效。
默认模式名用于为所有未限定的表、视图或存储过程名提供模式名。
可以指定一个文字模式名或指定`_CURRENT_USER`。
如果指定`_CURRENT_USER`作为默认模式名， IRIS会将当前登录进程的用户名作为默认模式名。
## EXACT_DISTINCT
`EXACT_DISTINCT`布尔值选项指定是否在系统范围内使用`DISTINCT`处理`(TRUE)`或`Fast DISTINCT`处理`(FALSE)`。
系统范围的默认值是使用`Fast Distinct`处理。
当`EXACT_DISTINCT=TRUE`时，`GROUP BY`和`DISTINCT`查询生成原始值。
当`EXACT_DISTINCT=FALSE`时，启用快速`Distinct`，通过更好地使用索引(如果有索引)，使涉及`Distinct`或`GROUP BY`子句的SQL查询更有效地运行。
但是，这些查询返回的值以与存储在索引中的相同的方式进行排序。
这意味着此类查询的结果可能都是大写的。
这可能对区分大小写的应用程序有影响。
这个选项也可以使用`$SYSTEM.SQL.Util.SetOption()`方法`FastDistinct boolean`选项来设置。
## `LOCK_ESCALATION_THRESHOLD`
`LOCK_ESCALATION_THRESHOLD`选项被设置为一个整数`n`，用于确定何时将行锁定升级为表锁定。
默认值是`1000`。
值`n`是单个事务中单个表的插入、更新或删除次数，当到达时将触发表级锁。
这是针对所有名称空间的系统范围设置。
例如，如果锁阈值为`1000`，并且进程启动一个事务，然后插入`2000`行，那么在插入第`1001`行之后，进程将尝试获取表级锁，而不是继续锁定各个行。
这有助于防止锁表变得太满。
这个选项也可以使用`$SYSTEM.SQL.Util.SetOption()`方法`LockThreshold`选项来设置。
## LOCK_TIMEOUT
`LOCK_TIMEOUT`数值选项允许为当前进程设置默认的锁定超时。
`LOCK_TIMEOUT`值是SQL执行期间试图建立锁时等待的秒数。
当锁定冲突阻止当前进程对`lock`、`INSERT`、`UPDATE`、`DELETE`或`SELECT`操作立即锁定一条记录、表或其他实体时，使用此锁定超时。
`SQL`继续尝试建立锁，直到超时超时，这时将生成`SQLCODE -110`或`-114`错误。
可用的值是正整数和零。
超时设置是每个进程的。
可以使用`$SYSTEM.SQL.Util.GetOption(“ProcessLockTimeout”)`方法确定当前进程的锁定超时设置。
如果没有为当前进程设置锁定超时，则默认为当前系统范围的锁定超时设置。
如果您的`ODBC`连接断开并重新连接，重新连接的进程将使用当前系统范围的锁定超时设置。
系统范围的锁定超时默认为10秒。
## PKEY_IS_IDKEY
`PKEY_IS_IDKEY boolean`选项指定主键是否也是系统范围内的ID键。
取值为`TRUE`、`FALSE`。
如果为`TRUE`，且该字段不包含数据，则将主键创建为`ID`键。
也就是说，表的主键也成为了类定义中的`IDKey`索引。
如果字段不包含数据，则没有定义`IDKey`索引。
如果将主键定义为`IDKey`索引，则数据访问将更加有效，但主键值一旦设置，就永远不能修改。
一旦设置，就不能更改分配给主键的值，也不能将其他键指定为主键。
使用此选项还将更改主键排序规则的默认值;
主键字符串值默认为`EXACT`排序规则。
如果为`FALSE`，则主键和`ID`键被定义为独立的，效率较低。
但是，主键值是可修改的，主键字符串值默认为当前排序规则类型`default`，默认为`SQLUPPER`。
要设置`PKEY_IS_IDKEY`选项，必须具有`%Admin_Manage:USE`权限。
否则，将收到一个`SQLCODE -99`错误(特权违反)。
一旦设置，该选项将在系统范围内对所有进程生效。
该选项的系统范围默认值也可以通过以下方式设置:
- `$SYSTEM.SQL.Util.SetOption()`方法配置选项`DDLPKeyNotIDKey`。
要确定当前设置，调用`$SYSTEM.SQL.CurrentSettings()`，它显示通过DDL创建的是主键而不是ID键;
默认值是1。
- 管理门户配置设置。
选择系统管理，配置，SQL和对象设置，SQL。
查看或修改通过DDL创建的表的“将主键定义为ID键”的当前设置。
`PKEY_IS_IDKEY`设置保持有效，直到通过另一个SET OPTION `PKEY_IS_IDKEY`重置或直到 IRIS `Configuration`被重新激活，将该参数重置为IRIS System `Configuration`设置。
## SUPPORT_DELIMITED_IDENTIFIERS
默认情况下，系统范围内支持分隔标识符。
`SUPPORT_DELIMITED_IDENTIFIERS`布尔选项允许您更改系统范围内对分隔标识符的支持。
取值为`TRUE`、`FALSE`。
如果为`TRUE`，用双引号分隔的字符串被认为是SQL语句中的标识符。
如果为`FALSE`，由双引号分隔的字符串被认为是SQL语句中的字符串字面值。
要设置`SUPPORT_DELIMITED_IDENTIFIERS`选项，必须具有`%Admin_Manage:USE`权限。
否则，将收到一个`SQLCODE -99`错误(特权违反)。
一旦设置，该选项将在系统范围内对所有进程生效。
`SUPPORT_DELIMITED_IDENTIFIERS`设置将保持有效，直到通过另一个设置选项`SUPPORT_DELIMITED_IDENTIFIERS`进行重置，或者直到由`$SYSTEM.SQL.Util.SetOption()方法delimitedifiers`选项在系统范围内进行更改。
## Locale Options
区域设置选项是关键字选项，用于为当前进程的日期、时间和数字约定设置IRIS区域设置。
可选关键字有`AM、DATE_FORMAT、DATE_MAXIMUM、DATE_MINIMUM、DATE_SEPARATOR、DECIMAL_SEPARATOR、MIDNIGHT、MINUS_SIGN、MONTH_ABBR、MONTH_NAME、NOON、NUMERIC_GROUP_SEPARATOR、NUMERIC_GROUP_SIZE、PM、PLUS_SIGN、TIME_FORMAT、TIME_PRECISION、TIME_SEPARATOR、WEEKDAY_ABBR、WEEKDAY_NAME、YEAR_OPTION`。
所有这些选项都可以设置为文字，并且都采用默认值(美式英语惯例)。
`TIME_PRECISION`选项是可配置的(参见下面)。
如果将这些选项中的任何一个设置为无效值，InterSystems IRIS将发出`SQLCODE -129`错误(`set OPTION`区域设置属性的非法值)。
Date/Time Option Keyword| Description
---|---
`AM` |`String`. 默认 `'AM'`
`DATE_FORMAT` |`Integer`. 默认值为`1`。取值范围为`0 ~ 15`。
`DATE_MAXIMUM`| `Integer`. 默认为`2980013(12/31/9999)`。可以设置为更早的日期，但不能设置为更晚的日期。
`DATE_MINIMUM`| `Positive Integer`. 默认为0`(12/31/1840)`。可以设置为较晚的日期，但不能设置为较早的日期。
`DATE_SEPARATOR`| Character. Default is '/'
`DECIMAL_SEPARATOR`| Character. Default is '.'
`MIDNIGHT`| String. Default is 'MIDNIGHT'
`MINUS_SIGN`| Character. Default is '-'
`MONTH_ABBR`| String. Default is ' Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec'. (注意，该字符串以空格字符开始，这是默认分隔符.)
`MONTH_NAME`| String. Default is ' January February March April May June ... November December'. 注意，该字符串以空格字符开始，这是默认分隔符.)
`NOON`| String. Default is 'NOON'
`NUMERIC_GROUP_SEPARATOR`| Character. Default is ','
`NUMERIC_GROUP_SIZE` |Integer. Default is 3.PM String. Default is 'PM'
`PLUS_SIGN`| Character. Default is '+'
`TIME_FORMAT`| Integer. Default is 1. 取值范围为1 ~ 4。
`TIME_PRECISION`| Integer from 0 through 9 (inclusive). Default is 0. 小数秒的位数。
`TIME_SEPARATOR`| Character. Default is ':'
`WEEKDAY_ABBR`| String. Default is ' Sun Mon Tue Wed Thu Fri Sat'. (注意，该字符串以空格字符开始，这是默认分隔符.)
`WEEKDAY_NAME`| String. Default is ' Sunday Monday Tuesday Wednesday Thursday Friday Saturday'. (注意，该字符串以空格字符开始，这是默认分隔符.)
`YEAR_OPTION`| Integer. Default is 0. 取值范围为0 ~ 6。有关表示2位数和4位数年份的这些方法的解释，见ObjectScript $ZDATE函数。
要在系统范围内配置`TIME_PRECISION`，请进入管理门户，选择“系统管理”、“配置”、“SQL”和“对象设置”、“SQL”。
查看和编辑`GETDATE()`、`CURRENT_TIME`和`CURRENT_TIMESTAMP`的默认时间精度的当前设置。
它指定小数秒的精确位数。
默认值是`0`。
允许的值的范围是`0`到`9`位精度。
小数秒中有意义的数字的实际数目与平台有关。
文章
Michael Lei · 四月 19, 2022
有很多方法可以使用
Intersystems生成excel文件，其中一些是ZEN报告、IRIS报告（Logi报告或正式称为JReports），或者我们可以使用第三方Java库，可能性几乎是无限的。
但是，如果你想只用Caché ObjectScript创建一个简单的电子表格呢？(没有第三方应用程序)
在我的案例中，我需要生成包含大量原始数据的报告（财务人员喜欢这些数据），但是我的ZEN/IRIS失败了，给了我一个我想称之为 "零字节的文件"，基本上说java的内存用完了，并导致报告服务器上的重载。
这可以用Office Open XML（OOXML）来完成。Office Open XML格式是由一个ZIP包内的一些XML文件组成的。因此，基本上我们需要生成这些XML文件，并将其压缩重命名为.xslx。就这么简单。
这些文件遵循一套简单的惯例，称为开放包装惯例。你需要声明各部分的内容类型，以及告诉消费应用程序应该从哪里开始。
为了创建一个简单的电子表格，我们至少需要5个文件。
workbook.xml
worksheet.xml
[Content_Types].xml
styles.xml
_rels
.rels
workbook.xml.rels
workbook.xml工作簿是各种工作表的容器。工作簿是你可以引用样式部分、共享字符串表以及适用于整个电子表格文件的任何其他信息的地方。、
ClassMethod GenerateWorkbookXML(){
set status =$$$OK
set xmlfile = tempDirectoryPath_"workbook.xml"
try{
set stream = ##class(%Stream.FileCharacter).%New()
set sc=stream.LinkToFile(xmlfile)
do stream.WriteLine("<?xml version='1.0' encoding='UTF-8' standalone='yes'?>")
do stream.WriteLine("<workbook xmlns='http://schemas.openxmlformats.org/spreadsheetml/2006/main' xmlns:r='http://schemas.openxmlformats.org/officeDocument/2006/relationships'>")
do stream.WriteLine("<sheets> <sheet name='"_workSheetName_"' sheetId='1' r:id='rId1'/>")
do stream.WriteLine("</sheets> </workbook>")
do stream.%Save()
}catch{
set status=$$$NO
}
kill stream
return status
}
_rels/workbook.xml.rels
我们只需要创建一个id为rId1的关系，这样它就会与workbook.xml部分的引用相匹配
ClassMethod CreateRelsXML(){
set status =$$$OK
set isunix=$zcvt($p($zv," ",3,$l($p($zv," (")," ")),"U")["UNIX"
if isunix {
set ext="/"
}else{
set ext="\"
}
set xmlfile = fileDirectory_"_rels"_ext_"workbook.xml.rels"
set stream = ##class(%Stream.FileCharacter).%New()
set sc=stream.LinkToFile(xmlfile)
do stream.WriteLine("<?xml version='1.0' encoding='UTF-8' standalone='yes'?>")
do stream.WriteLine("<Relationships xmlns='http://schemas.openxmlformats.org/package/2006/relationships'>")
do stream.WriteLine("<Relationship Id='rId1' Type='http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet' Target='worksheet.xml'/>")
do stream.WriteLine("<Relationship Id='rId2' Type='http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles' Target='styles.xml' />")
do stream.WriteLine("</Relationships>")
try{
do stream.%Save()
}catch{
set status=$$$NO
}
kill stream
set xmlfile = fileDirectory_"_rels"_ext_".rels"
set stream = ##class(%Stream.FileCharacter).%New()
set sc=stream.LinkToFile(xmlfile)
do stream.WriteLine("<?xml version='1.0' encoding='UTF-8' standalone='yes'?>")
do stream.WriteLine("<Relationships xmlns='http://schemas.openxmlformats.org/package/2006/relationships'>")
do stream.WriteLine("<Relationship Id='rId1' Type='http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument' Target='workbook.xml'/>")
do stream.WriteLine("</Relationships>")
try{
do stream.%Save()
}catch{
set status=$$$NO
}
kill stream
return status
}
[Content_Types].xml静态文件（目前，它应该是一个动态文件，取决于工作表的数量）将工作簿的工作表和样式链接在一起。每个Office Open XML文件必须声明ZIP包中使用的内容类型。这是用[Content_Types].xml文件完成的。
ClassMethod GenerateConntentTypesXML(){
set status =$$$OK
set xmlfile = tempDirectoryPath_"[Content_Types].xml"
set stream = ##class(%Stream.FileCharacter).%New()
set sc=stream.LinkToFile(xmlfile)
try{
do stream.WriteLine("<?xml version='1.0' encoding='UTF-8' standalone='yes'?>")
do stream.WriteLine("<Types xmlns='http://schemas.openxmlformats.org/package/2006/content-types'>")
do stream.WriteLine("<Default Extension='rels' ContentType='application/vnd.openxmlformats-package.relationships+xml'/>")
do stream.WriteLine("<Override PartName='/workbook.xml' ContentType='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml'/>")
do stream.WriteLine("<Override PartName='/worksheet.xml' ContentType='application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml'/>")
do stream.WriteLine("<Override PartName='/styles.xml' ContentType='application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml' />")
do stream.WriteLine("</Types>")
do stream.%Save()
}catch{
set status=$$$NO
}
kill stream
return status
}
styles.xml所有的格式化都在这里，目前我已经添加了一些静态样式，（计划将其转换为更多的动态工作簿特定的样式）。
Excel Styles
ID
Style
Excel Format
1
default
Text
2
#;[Red]-#
Number
3
#.##;[Red]-#.##
Number
4
yyyy/mm/dd
Date
5
hh:mm
Date
6
Header and Center Aligned
Text
7
Header 2 Left Aligned
Text
8
Good(Green Highlight)
General
9
Bad(Red Highlight)
General
10
Neutral(Orange Highlight)
General
11
yyyy/mm/dd hh:mm
Date
ClassMethod CreateStylesXML(){
set status =$$$OK
set xmlfile = tempDirectoryPath_"styles.xml"
try{
set stream = ##class(%Stream.FileCharacter).%New()
set sc=stream.LinkToFile(xmlfile)
do stream.WriteLine("<?xml version=""1.0"" encoding=""UTF-8"" standalone=""yes""?>")
do stream.WriteLine("<styleSheet xmlns=""http://schemas.openxmlformats.org/spreadsheetml/2006/main"" xmlns:mc=""http://schemas.openxmlformats.org/markup-compatibility/2006"" mc:Ignorable=""x14ac x16r2 xr"" xmlns:x14ac=""http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac"" xmlns:x16r2=""http://schemas.microsoft.com/office/spreadsheetml/2015/02/main"" xmlns:xr=""http://schemas.microsoft.com/office/spreadsheetml/2014/revision"">")
do stream.WriteLine("<numFmts count=""4"">")
do stream.WriteLine("<numFmt numFmtId=""166"" formatCode=""#,##0;[Red]\-#,##0""/>")
do stream.WriteLine("<numFmt numFmtId=""168"" formatCode=""#,##0.00;[Red]\-#,##0.00""/>")
do stream.WriteLine("<numFmt numFmtId=""169"" formatCode=""dd\/mm\/yyyy;@""/>")
do stream.WriteLine("<numFmt numFmtId=""170"" formatCode=""dd/mm/yyyy\ hh:mm""/></numFmts>")
do stream.WriteLine("<fonts count=""5"" x14ac:knownFonts=""1"">")
do stream.WriteLine("<font><sz val=""10""/><color theme=""1""/><name val=""Calibri""/><family val=""2""/><scheme val=""minor""/></font>")
do stream.WriteLine("<font><sz val=""10""/><color rgb=""FF006100""/><name val=""Calibri""/><family val=""2""/><scheme val=""minor""/></font>")
do stream.WriteLine("<font><sz val=""10""/><color rgb=""FF9C0006""/><name val=""Calibri""/><family val=""2""/><scheme val=""minor""/></font>")
do stream.WriteLine("<font><sz val=""10""/><color rgb=""FF9C5700""/><name val=""Calibri""/><family val=""2""/><scheme val=""minor""/></font>")
do stream.WriteLine("<font><b/><sz val=""10""/><color theme=""1""/><name val=""Calibri""/><family val=""2""/><scheme val=""minor""/></font></fonts>")
do stream.WriteLine("<fills count=""5"">")
do stream.WriteLine("<fill><patternFill patternType=""none""/></fill>")
do stream.WriteLine("<fill><patternFill patternType=""gray125""/></fill>")
do stream.WriteLine("<fill><patternFill patternType=""solid""><fgColor rgb=""FFC6EFCE""/></patternFill></fill>")
do stream.WriteLine("<fill><patternFill patternType=""solid""><fgColor rgb=""FFFFC7CE""/></patternFill></fill>")
do stream.WriteLine("<fill><patternFill patternType=""solid""><fgColor rgb=""FFFFEB9C""/></patternFill></fill></fills>")
do stream.WriteLine("<borders count=""1""><border><left/><right/><top/><bottom/><diagonal/></border></borders>")
do stream.WriteLine("<cellStyleXfs count=""4"">")
do stream.WriteLine("<xf numFmtId=""0"" fontId=""0"" fillId=""0"" borderId=""0""/>")
do stream.WriteLine("<xf numFmtId=""0"" fontId=""1"" fillId=""2"" borderId=""0"" applyNumberFormat=""0"" applyBorder=""0"" applyAlignment=""0"" applyProtection=""0""/>")
do stream.WriteLine("<xf numFmtId=""0"" fontId=""2"" fillId=""3"" borderId=""0"" applyNumberFormat=""0"" applyBorder=""0"" applyAlignment=""0"" applyProtection=""0""/>")
do stream.WriteLine("<xf numFmtId=""0"" fontId=""3"" fillId=""4"" borderId=""0"" applyNumberFormat=""0"" applyBorder=""0"" applyAlignment=""0"" applyProtection=""0""/></cellStyleXfs>")
do stream.WriteLine("<cellXfs count=""12""><xf numFmtId=""0"" fontId=""0"" fillId=""0"" borderId=""0"" xfId=""0""/>")
do stream.WriteLine("<xf numFmtId=""49"" fontId=""0"" fillId=""0"" borderId=""0"" xfId=""0"" quotePrefix=""1"" applyNumberFormat=""1""/>")
do stream.WriteLine("<xf numFmtId=""166"" fontId=""0"" fillId=""0"" borderId=""0"" xfId=""0"" applyNumberFormat=""1""/>")
do stream.WriteLine("<xf numFmtId=""168"" fontId=""0"" fillId=""0"" borderId=""0"" xfId=""0"" applyNumberFormat=""1""/>")
do stream.WriteLine("<xf numFmtId=""169"" fontId=""0"" fillId=""0"" borderId=""0"" xfId=""0"" applyNumberFormat=""1""/>")
do stream.WriteLine("<xf numFmtId=""20"" fontId=""0"" fillId=""0"" borderId=""0"" xfId=""0"" applyNumberFormat=""1""/>")
do stream.WriteLine("<xf numFmtId=""49"" fontId=""4"" fillId=""0"" borderId=""0"" xfId=""0"" applyNumberFormat=""1"" applyFont=""1""/>")
do stream.WriteLine("<xf numFmtId=""49"" fontId=""4"" fillId=""0"" borderId=""0"" xfId=""0"" applyNumberFormat=""1"" applyFont=""1"" applyAlignment=""1""><alignment horizontal=""center""/>")
do stream.WriteLine("</xf>")
do stream.WriteLine("<xf numFmtId=""49"" fontId=""1"" fillId=""2"" borderId=""0"" xfId=""1"" applyNumberFormat=""1""/>")
do stream.WriteLine("<xf numFmtId=""0"" fontId=""2"" fillId=""3"" borderId=""0"" xfId=""2""/>")
do stream.WriteLine("<xf numFmtId=""0"" fontId=""3"" fillId=""4"" borderId=""0"" xfId=""3""/>")
do stream.WriteLine("<xf numFmtId=""170"" fontId=""0"" fillId=""0"" borderId=""0"" xfId=""0"" applyNumberFormat=""1""/></cellXfs>")
do stream.WriteLine("<cellStyles count=""4""><cellStyle name=""Bad"" xfId=""2"" builtinId=""27""/>")
do stream.WriteLine("<cellStyle name=""Good"" xfId=""1"" builtinId=""26""/><cellStyle name=""Neutral"" xfId=""3"" builtinId=""28""/>")
do stream.WriteLine("<cellStyle name=""Normal"" xfId=""0"" builtinId=""0""/></cellStyles><dxfs count=""0""/>")
do stream.WriteLine("<tableStyles count=""0"" defaultTableStyle=""TableStyleMedium2"" defaultPivotStyle=""PivotStyleLight16""/> ")
do stream.WriteLine("<extLst><ext uri=""{EB79DEF2-80B8-43e5-95BD-54CBDDF9020C}"" xmlns:x14=""http://schemas.microsoft.com/office/spreadsheetml/2009/9/main"">")
do stream.WriteLine("<x14:slicerStyles defaultSlicerStyle=""SlicerStyleLight1""/></ext><ext uri=""{9260A510-F301-46a8-8635-F512D64BE5F5}"" xmlns:x15=""http://schemas.microsoft.com/office/spreadsheetml/2010/11/main"">")
do stream.WriteLine("<x15:timelineStyles defaultTimelineStyle=""TimeSlicerStyleLight1""/></ext></extLst>")
do stream.WriteLine("</styleSheet>")
do stream.%Save()
}catch{
set status=$$$NO
}
kill stream
return status
}
worksheet.xml这是我们的数据所在的地方。工作表的第一行将有列的标题。 接下来的行将只有第一列的数据。我们将在这里定义每一列的列宽，如果不是默认的，列将被设置为自动适应。
worksheet xml 示例
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<worksheet xmlns="https://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="https://schemas.openxmlformats.org/officeDocument/2006/relationships">
<sheetData>
<row>
<c t="inlineStr">
<is>
<t>Name</t>
</is>
</c>
<c t="inlineStr">
<is>
<t>Amount</t>
</is>
</c>
</row>
<row>
<c t="inlineStr">
<is>
<t>Jhon Smith</t>
</is>
</c>
<c>
<v>1000.74</v>
</c>
</row>
<row>
<c t="inlineStr">
<is>
<t>Tracy A</t>
</is>
</c>
<c>
<v>6001.74</v>
</c>
</row>
</sheetData>
</worksheet>
Excel 示例
工作表中的公式可以用函数<f>标签来完成
<c >
<f>B2*0.08</f >
</c >
<c >
<f>B2+C2</f >
</c>
and finally we zip them, rename it to.xlsx (using unix zip)
set cmd ="cd "_fileDirectory_" && find . -type f | xargs zip .."_ext_xlsxFile
生成excel文件.
以下代码生成excel 文件.
set file = "/temp/test.xlsx"
set excelObj = ##class(XLSX.writer).%New(file)
do excelObj.SetWorksheetName("test1")
set status = excelObj.BeginWorksheet()
set row = 0
set row = row+1
;----------- excelObj.Cells(rowNumber,columnNumber,style,content)
set status = excelObj.Cells(row,1,1,"Header1")
set row = row+1
set status = excelObj.Cells(row,1,2,"Content 1")
set status = excelObj.EndWorksheet()
W !,excelObj.fileName
写Excel类请看这里 xlsx.writer.xml.zip
文章
姚 鑫 · 六月 17, 2022
# 第三章 锁定和并发控制（三）
# 升级锁
使用升级锁来管理大量锁。当锁定数组的节点时，它们是相关的，特别是当将多个节点锁定在同一下标级别时。
当给定进程在同一数组中的给定下标级别创建了超过特定数量（默认为 `1000`）的升级锁时， 将删除所有单独的锁名称并用新锁替换它们。新锁位于父级，这意味着数组的整个分支被隐式锁定。示例（如下所示）演示了这一点。
应用程序应在合适的情况下尽快释放特定子节点的锁（与非升级锁完全相同）。当释放锁时， 会减少相应的锁计数。当的应用程序移除足够多的锁时，会移除父节点上的锁。第二小节显示了一个示例。
## 锁升级示例
假设有 `1000` 个`^MyGlobal("sales","EU",salesdate)` 形式的锁，其中 `salesdate` 表示日期。锁表可能如下所示：
注意 `Owner 19776` 的条目（这是拥有锁的进程）。 `ModeCount` 列指示这些是共享的、升级的锁。
当同一进程试图创建另一个相同形式的锁时， 会升级它们。它会移除这些锁并用名称为 `^MyGlobal("sales","EU")` 的单个锁替换它们。现在锁表可能如下所示：
`ModeCount` 列表明这是一个共享的升级锁，它的计数是 `1001`。
请注意以下关键点：
- `^MyGlobal("sales","EU")` 的所有子节点现在都被隐式锁定，遵循数组锁定的基本规则。
- 锁定表不再包含有关 `^MyGlobal("sales","EU")` 的哪些子节点被特别锁定的信息。这在删除锁时具有重要意义。见下一小节。
当同一进程添加更多形式为 `^MyGlobal("sales","EU",salesdate)` 的锁名称时，锁表会增加锁名称 `^MyGlobal("sales","EU")` 的锁计数。锁定表可能如下所示：
`ModeCount` 列指示此锁的锁计数现在为 `1026`。
## 移除升级锁
与非升级锁完全相同，应用程序应尽快释放特定子节点的锁。当这样做时， 会减少升级锁的锁计数。例如，假设代码删除了 `^MyGlobal("sales","EU",salesdate)` 的锁定，其中 `salesdate` 对应于 2011 年的任何日期 — 因此删除了 `365` 个锁定。锁表现在看起来像这样：
请注意，即使现在锁的数量低于阈值 (`1000`)，锁表也不包含 `^MyGlobal("sales","EU",salesdate)`. 的锁的单独条目。
节点 `^MyGlobal("sales")`保持显式锁定，直到该过程再删除 `661` 个 `^MyGlobal("sales","EU",salesdate)` 形式的锁定。
重要提示：有一点需要考虑，与前面的讨论有关。应用程序可能会“释放”数组节点上的锁，这些节点一开始就从未锁定，从而导致升级锁的锁计数不准确 - 并且可能在需要这样做之前释放升级锁。
例如，假设进程锁定 `^MyGlobal("sales","EU",salesdate)` 中从 2010 年到现在的节点。这将创建超过 `1000` 个锁，并且此锁将按计划升级。假设应用程序中的错误删除了 `1970` 年节点的锁。 将允许此操作，即使这些节点以前没有被锁定，并且 会将锁计数减少 `365`。生成的锁计数不会是所需锁的准确计数。如果应用程序随后移除了其他年份的锁，则升级的锁可能会意外地提前移除。
# Locks, Globals, and Namespaces
锁通常用于控制对全局变量的访问。因为可以从多个命名空间访问全局， 为其锁定机制提供自动跨命名空间支持。该行为是自动的，不需要干预，但在此描述以供参考。有几种情况需要考虑：
- 任何命名空间都有一个默认数据库，其中包含持久类和任何其他全局变量的数据；这是此命名空间的全局数据库。访问数据时， IRIS 会从该数据库中检索数据，除非有其他考虑。一个给定的数据库可以是多个命名空间的全局数据库。请参见方案 1。
- 命名空间可以包括提供对存储在其他数据库中的全局变量的访问的映射。请参见方案 2。
- 命名空间可以包括下标级别的全局映射，这些映射提供对部分存储在其他数据库中的全局变量的访问。请参见方案 3。
- 在一个命名空间中运行的代码可以使用扩展引用来访问在此命名空间中不可用的全局变量。请参见方案 4。
尽管锁名称本质上是任意的，但是当使用以插入符号 (`^`) 开头的锁名称时，IRIS 提供了适合这些情况的特殊行为。以下小节给出了详细信息。为简单起见，只讨论排他锁；共享锁的逻辑类似。
## 场景 1：具有相同Global数据库的多个命名空间
如前所述，虽然进程 `A` 拥有一个具有给定锁名的独占锁，但没有其他进程可以获取任何具有相同锁名的锁。
如果锁名称以插入符号开头，则此规则适用于使用相同全局数据库的所有命名空间。
例如，假设命名空间 `ALPHA` 和 `BETA` 都配置为使用数据库 `GAMMA` 作为其全局数据库。下面显示一个草图：
然后考虑以下场景：
1. 在命名空间 `ALPHA` 中，进程 `A` 获得一个名为 `^MyGlobal(15)` 的独占锁。
2. 在命名空间 `BETA` 中，进程 `B` 尝试获取名称为 `^MyGlobal(15)` 的锁。此 `LOCK` 命令不返回；进程被阻塞，直到进程 `A` 释放锁。
在这种情况下，锁表只包含进程 `A` 拥有的锁的条目。如果检查锁表，会注意到它指示了该锁应用到的数据库；请参阅目录列。例如：
## 场景 2：命名空间使用映射的Global
如果一个或多个命名空间包含全局映射，系统会自动跨适用的命名空间强制实施锁定机制。当在非默认命名空间中获得锁时， IRIS 会自动创建额外的锁表条目。
例如，假设命名空间 `ALPHA` 配置为使用数据库 `ALPHADB` 作为其全局数据库。假设命名空间 `BETA` 配置为使用不同的数据库 (`BETADB`) 作为其全局数据库。命名空间 `BETA` 还包括一个全局映射，它指定 `^MyGlobal` 存储在 `ALPHADB` 数据库中。下面显示一个草图：
然后考虑以下场景：
1. 在命名空间 `ALPHA` 中，进程 `A` 获得一个名为 `^MyGlobal(15)` 的独占锁。
与前面的场景一样，锁表仅包含进程 `A` 拥有的锁的条目。此锁适用于 `ALPHADB` 数据库：
2. 在命名空间 `BETA` 中，进程 `B` 尝试获取名称为 `^MyGlobal(15)` 的锁。此 `LOCK` 命令不返回；进程被阻塞，直到进程 `A` 释放锁。
## 场景 3：命名空间使用映射的`Global`下标
如果一个或多个命名空间包含使用下标级别映射的全局映射，系统会自动跨适用的命名空间强制实施锁定机制。在这种情况下，当在非默认命名空间中获取锁时，IRIS 还会自动创建额外的锁表条目。
例如，假设命名空间 `ALPHA` 配置为使用数据库 `ALPHADB` 作为其全局数据库。命名空间 `BETA` 使用 `BETADB` 数据库作为其全局数据库。
还假设命名空间 `BETA` 还包括一个下标级别的全局映射，因此 `^MyGlobal(15)` 存储在 `ALPHADB` 数据库中（而这个全局的其余部分存储在命名空间的默认位置）。下面显示一个草图：
然后考虑以下场景：
1. 在命名空间 `ALPHA` 中，进程 `A` 获得一个名为 `^MyGlobal(15)` 的独占锁。
2. 与前面的场景一样，锁表仅包含进程 `A` 拥有的锁的条目。此锁适用于 `ALPHADB` 数据库（例如，`c:\InterSystems\IRIS\mgr\alphadb`）。
当非默认命名空间获得锁时，整体行为是相同的，但 IRIS 处理细节略有不同。假设在命名空间 `BETA` 中，一个进程获得了一个名为 `^MyGlobal(15)` 的锁。在这种情况下，锁表包含两个条目，一个用于 `ALPHADB` 数据库，一个用于 `BETADB` 数据库。这两个锁都归命名空间 `BETA` 中的进程所有。
当此进程释放锁名称 `^MyGlobal(15)` 时，系统会自动删除两个锁。
# 场景 4：扩展的Global引用
在一个命名空间中运行的代码可以使用扩展引用来访问在此命名空间中不可用的全局变量。在这种情况下，IRIS 将一个条目添加到影响相关数据库的锁表中。锁归创建它的进程所有。例如，考虑以下场景。为简单起见，此方案中没有全局映射。
1. 进程 `A` 在 `ALPHA` 命名空间中运行，该进程使用以下命令获取 `BETA` 命名空间中可用的全局锁：
```java
lock ^["beta"]MyGlobal(15)
```
2. 现在锁定表包括以下条目：
请注意，这仅显示全局名称（而不是用于访问它的引用）。此外，在这种情况下，`BETADB` 是 `BETA` 命名空间的默认数据库。
3. 在命名空间 `BETA` 中，进程 `B` 尝试获取名称为 `^MyGlobal(15)` 的锁。此 `LOCK` 命令不返回；进程被阻塞，直到进程 `A` 释放锁。
进程私有`Global`在技术上是一种扩展引用，但 IRIS 不支持使用进程私有全局名称作为锁名称；无论如何，都不需要这样的锁，因为根据定义，只有一个进程可以访问这样的全局。
文章
Lilian Huang · 十二月 29, 2023
我们继续推出有关可供 HealthShare HealthConnect 和 InterSystems IRIS 用户使用的 FHIR 适配器工具的系列文章。
在前几篇文章中，我们介绍了小型应用程序，并在此基础上建立了我们的工作，并展示了安装 FHIR 适配器后在 IRIS 实例中部署的架构。在今天的文章中，我们将看到一个示例，说明如何执行最常见的 CRUD（创建 - 读取 - 更新 - 删除）操作之一，即读取操作，我们将通过恢复资源来完成此操作。
什么是资源？
FHIR 中的一个资源对应一种相关的临床信息，这种信息可以是病人（Patient）、对实验室的请求（ServiceRequest）或诊断（Condition）等。每种资源都定义了组成它的数据类型，以及对数据的限制和与其他类型资源的关系。每个资源都允许对其包含的信息进行扩展，从而满足 FHIR 80% 以外的需求（满足 80% 以上用户的需求）。
在本文的示例中，我们将使用最常见的资源 "Patient"。让我们来看看它的定义：
{ "resourceType" : "Patient" , // from Resource: id, meta, implicitRules, and language // from DomainResource: text, contained, extension, and modifierExtension "identifier" : [{ Identifier }], // An identifier for this patient "active" : <boolean>, // Whether this patient's record is in active use "name" : [{ HumanName }], // A name associated with the patient "telecom" : [{ ContactPoint }], // A contact detail for the individual "gender" : "<code>" , // male | female | other | unknown "birthDate" : "<date>" , // The date of birth for the individual // deceased[x]: Indicates if the individual is deceased or not. One of these 2 : "deceasedBoolean" : <boolean>, "deceasedDateTime" : "<dateTime>" , "address" : [{ Address }], // An address for the individual "maritalStatus" : { CodeableConcept }, // Marital (civil) status of a patient // multipleBirth[x]: Whether patient is part of a multiple birth. One of these 2 : "multipleBirthBoolean" : <boolean>, "multipleBirthInteger" : <integer>, "photo" : [{ Attachment }], // Image of the patient "contact" : [{ // A contact party (eg guardian, partner, friend) for the patient "relationship" : [{ CodeableConcept }], // The kind of relationship "name" : { HumanName }, // IA name associated with the contact person "telecom" : [{ ContactPoint }], // IA contact detail for the person "address" : { Address }, // I Address for the contact person "gender" : "<code>" , // male | female | other | unknown "organization" : { Reference(Organization) }, // I Organization that is associated with the contact "period" : { Period } // The period during which this contact person or organization is valid to be contacted relating to this patient }], "communication" : [{ // A language which may be used to communicate with the patient about his or her health "language" : { CodeableConcept }, // R! The language which can be used to communicate with the patient about his or her health "preferred" : <boolean> // Language preference indicator }], "generalPractitioner" : [{ Reference(Organization|Practitioner| PractitionerRole) }], // Patient's nominated primary care provider "managingOrganization" : { Reference(Organization) }, // Organization that is the custodian of the patient record "link" : [{ // Link to a Patient or RelatedPerson resource that concerns the same actual individual "other" : { Reference(Patient|RelatedPerson) }, // R! The other patient or related person resource that the link refers to "type" : "<code>" // R! replaced-by | replaces | refer | seealso }] }
正如您所看到的，它几乎涵盖了患者的所有管理信息需求。
从我们的 HIS 中恢复患者信息
如果您还记得之前的文章中我们部署了一个模拟 HIS 系统数据库的 PostgreSQL 数据库，那么让我们看一下我们特定 HIS 中的示例表。
虽然数量不多，但对于我们的例子来说已经足够了。让我们更详细地看看我们的患者表。
这里我们有 3 个示例患者，您可以看到每个患者都有一个唯一的标识符 ( ID ) 以及一系列与卫生组织相关的管理数据。我们的首要目标是为我们的一位患者获取 FHIR 资源。
患者咨询
我们如何从我们的服务器请求患者数据？根据 FHIR 制定的实现规范，我们必须通过 REST 对包含我们服务器地址、资源名称和标识符的 URL 执行 GET。我们必须调用：
http://SERVER_PATH/Patient/{id}
在我们的示例中，我们将搜索 Juan López Hurtado，其 id = 1，因此我们必须调用以下 URL：
http://localhost:52774/Adapter/r4/Patient/1
为了进行测试，我们将使用 Postman 作为客户端。让我们看看服务器的响应是什么：
{ "resourceType" : "Patient" , "address" : [ { "city" : "TERUEL" , "line" : [ "CALLE SUSPIROS 39 2ºA" ], "postalCode" : "98345" } ], "birthDate" : "1966-11-23" , "gender" : "M" , "id" : "1" , "identifier" : [ { "type" : { "text" : "ID" }, "value" : "1" }, { "type" : { "text" : "NHC" }, "value" : "588392" }, { "type" : { "text" : "DNI" }, "value" : "12345678X" } ], "name" : [ { "family" : "LÓPEZ HURTADO" , "given" : [ "JUAN" ] } ], "telecom" : [ { "system" : "phone" , "value" : "844324239" }, { "system" : "email" , "value" : "juanitomaravilla@terra.es" } ] }
现在让我们分析一下我们的请求在生产中所采取的路径：
这里我们有路径：
请求到达我们的 BS InteropService。
将请求转发到我们已配置为 BS 目的地的 BP，在该 BP 中将恢复所接收呼叫的患者标识符。
从我们的 BO FromAdapterToHIS 查询到我们的 HIS 数据库。
将患者数据转发到我们的 BP，并将其转换为 FHIR 患者资源。
将响应转发给BS。
让我们看一下我们在 BP ProcessFHIRBP中收到的消息类型：
让我们看一下三个属性，它们对于识别客户端请求的操作类型至关重要：
Request.RequestMethod：它告诉我们要执行什么类型的操作。在此示例中，搜索病人将采用 GET 方式。
Request.RequestPath：该属性包含到达服务器的请求路径，该属性将指示我们要处理的资源，在本例中，它将包括恢复资源的特定标识符。
Quick.StreamId： FHIR 适配器会将收到的每条 FHIR 消息转换为流，并为其分配一个标识符，该标识符将保存在此属性中。在本例中，我们不需要它，因为我们执行的是 GET，并没有发送任何 FHIR 对象。
让我们深入分析负责处理的 GLP，继续我们的消息之旅。
流程FHIRBP：
我们在生产中实施了 BPL，它将管理我们从业务服务收到的 FHIR 消息传递。让我们看看它是如何实现的：
让我们看看每个步骤中将执行的操作：
管理 FHIR 对象：
我们将调用负责连接到 HIS 数据库并负责数据库查询的 BO FromAdapterToHIS。
Method ManageFHIR(requestData As HS.FHIRServer.Interop.Request, response As Adapter.Message.FHIRResponse) As %Status { set sc = $$$OK set response = ##class (Adapter.Message.FHIRResponse). %New () if (requestData.Request.RequestPath = "Bundle" ) { If requestData.QuickStreamId '= "" { Set quickStreamIn = ##class (HS.SDA3.QuickStream). %OpenId (requestData.QuickStreamId,, .tSC) set dynamicBundle = ##class ( %DynamicAbstractObject ). %FromJSON (quickStreamIn) set sc = ..GetBundle (dynamicBundle, .response) } } elseif (requestData.Request.RequestPath [ "Patient" ) { if (requestData.Request.RequestMethod = "POST" ) { If requestData.QuickStreamId '= "" { Set quickStreamIn = ##class (HS.SDA3.QuickStream). %OpenId (requestData.QuickStreamId,, .tSC) set dynamicPatient = ##class ( %DynamicAbstractObject ). %FromJSON (quickStreamIn) set sc = ..InsertPatient (dynamicPatient, .response) } } elseif (requestData.Request.RequestMethod = "GET" ) { set patientId = $Piece (requestData.Request.RequestPath, "/" , 2 ) set sc = ..GetPatient (patientId, .response) } } Return sc }
我们的 BO 将检查收到的HS.FHIRServer.Interop.Request类型的消息，在本例中，通过设置 GET 并在与患者资源对应的路径中指示将调用GetPatient方法，我们将在下面看到：
Method GetPatient(patientId As %String , Output patient As Adapter.Message.FHIRResponse) As %Status { Set tSC = $$$OK set sql= "SELECT id, name, lastname, phone, address, city, email, nhc, postal_code, birth_date, dni, gender FROM his.patient WHERE id = ?" //perform the Select set tSC = ..Adapter .ExecuteQuery(.resultSet, sql, patientId) If resultSet.Next() { set personResult = { "id" :(resultSet.GetData( 1 )), "name" : (resultSet.GetData( 2 )), "lastname" : (resultSet.GetData( 3 )), "phone" : (resultSet.GetData( 4 )), "address" : (resultSet.GetData( 5 )), "city" : (resultSet.GetData( 6 )), "email" : (resultSet.GetData( 7 )), "nhc" : (resultSet.GetData( 8 )), "postalCode" : (resultSet.GetData( 9 )), "birthDate" : (resultSet.GetData( 10 )), "dni" : (resultSet.GetData( 11 )), "gender" : (resultSet.GetData( 12 )), "type" : ( "Patient" )} } else { set personResult = {} } //create the response message do patient.Resource.Insert(personResult. %ToJSON ()) Return tSC }
正如您所看到的，此方法仅在我们的 HIS 数据库上启动查询并恢复所有患者信息，然后生成一个 DynamicObject，随后将其转换为 String 并存储在Adapter.Message.FHIRResponse类型的变量中。我们已将 Resource 属性定义为字符串列表，以便能够稍后在跟踪中显示响应。您可以直接将其定义为 DynamicObjects，从而节省后续转换。
检查是否捆绑：
根据 BO 的响应，我们检查它是否是 Bundle 类型（我们将在以后的文章中解释）或者它是否只是一个 Resource。
创建动态对象：
我们将 BO 响应转换为 DynamicObject 并将其分配给临时上下文变量 (context.temporalDO)。用于转换的函数如下：
##class ( %DynamicAbstractObject ). %FromJSON (context.FHIRObject.Resource.GetAt( 1 ))
FHIR 变换：
使用 DynamicObject 类型的临时变量，我们将其转换为HS.FHIR.DTL.vR4.Model.Resource.Patient类的对象。如果我们想寻找其他类型的资源，我们必须为每种类型定义特定的转换。让我们看看我们的转变：
这种转换使我们能够拥有 BS InteropService 可以解释的对象。我们将结果存储在变量context.PatientResponse中。
将资源分配给 Stream ：
我们将FHIR变换中获得的变量context.PatientResponse转换为Stream。
转换为 QuickStream：
我们将必须返回给客户端的所有数据分配给响应变量：
set qs= ##class (HS.SDA3.QuickStream). %New () set response.QuickStreamId = qs. %Id () set copyStatus = qs.CopyFrom(context.JSONPayloadStream) set response.Response.ResponseFormatCode= "JSON" set response.Response.Status= 200 set response.ContentType= "application/fhir+json" set response.CharSet = "utf8"
在这种情况下，我们总是返回 200 响应。在生产环境中，我们应该检查是否已正确恢复搜索到的资源，如果没有，请将响应状态从 200 修改为对应“未找到”的 404。正如您在此代码片段中看到的，对象HS.FHIR.DTL.vR4.Model.Resource.Patient转换为 Stream 并存储为HS.SDA3.QuickStream ，将所述对象的标识符添加到QuickStreamID属性，随后我们的 InteropService 服务将以 JSON 形式正确返回结果。
结论：
让我们总结一下我们所做的事情：
我们发送了一个 GET 类型的请求，以搜索具有定义 ID 的患者资源。
BS InteropService已将请求转发至配置的BP。
BP 调用了负责与 HIS 数据库交互的 BO。
已配置的 BO 已从 HIS 数据库检索患者数据。
业务处理程序将结果转换为默认互操作服务创建的 BS 可理解的对象。
BS已收到响应并将其转发给客户端。
如您所见，操作相对简单，如果我们想在服务器中添加更多类型的资源，只需在 BO 中添加对数据库中与要恢复的新资源相对应的表的查询，并在 BP 中将 BO 的结果转换为与之相对应的 HS.FHIR.DTL.vR4.Model.Resource.* 类型的对象。
在下一篇文章中，我们将回顾如何将患者类型的新 FHIR 资源添加到我们的 HIS 数据库中。
感谢大家的关注！
文章
姚 鑫 · 二月 9, 2021
# 第二十九章 Caché 变量大全 $ZERROR 变量
包含上一个错误的名称和位置。
# 大纲
```
$ZERROR
$ZE
```
# 描述
`$ZERROR`包含最新错误的名称，最新错误的位置（在适用的情况下）以及（对于某些错误代码而言）有关导致错误的原因的其他信息。 `$ZERROR`始终包含相应语言模式的最新错误。
`$ZERROR`值旨在错误后立即使用。由于`$ZERROR`值可能不会在例程调用中保留，因此希望保留`$ZERROR`值以供以后使用的用户应将其复制到变量中。**强烈建议用户在使用后立即将`$ZERROR`设置为空字符串(“”)。**
$ZERROR中包含的字符串可以是以下任何一种形式：
```java
entryref
info
entryref info
```
- `` 错误名称。错误名称始终以全部大写字母返回，并用尖括号括起来。它可能包含空格。
- `entryref` 对发生错误的代码行的引用。它由标签名称和距该标签的行偏移量组成，后跟`^`和程序名称。此`entryre`f紧跟在错误名称的右尖括号之后。从终端调用`$ZERROR`时，此`entryref`信息没有意义，因此不会返回。对最近使用`ZLOAD`加载到例程缓冲区中的例程的引用。
- `info` 特定于某些错误类型的附加信息(见下表)。此信息与``或`entryref`之间用空格分隔。如果有多个组件要提供信息，则用逗号分隔。
例如，一个程序(名为`zerrortest`)包含以下例程(名为`ZerrorMain`)，该例程试图写入`fred`(一个未定义的局部变量)的内容：
```java
/// d ##class(PHA.TEST.SpecialVariables).ZERROR()
ClassMethod ZERROR()
{
ZerrorMain
TRY {
SET $ZERROR=""
WRITE "$ZERROR = ",$ZERROR,!
WRITE fred }
CATCH {
WRITE "$ZERROR = ",$ZCVT($ZERROR,"O","HTML")
}
}
```
```java
DHC-APP> d ##class(PHA.TEST.SpecialVariables).ZERROR()
$ZERROR =
$ZERROR = <UNDEFINED>zZERROR+5^PHA.TEST.SpecialVariables.1 *fred
```
在上面的示例中，第一个`$ZERROR`包含一个空字符串(`“”`)，因为自从`$ZERROR`重置为空字符串以来没有发生任何错误。尝试写入未定义的变量会设置`$ZERROR`并将其抛给`CATCH`块。此`$ZERROR`包含`ZerrorMain+4^zerrortest*fred`，指定错误的名称、位置和特定于该类型错误的附加信息。在本例中，附加信息是未定义的局部变量`fred`的名称；星号前缀表示它是局部变量。(请注意，本例中使用`$ZCVT($ZERROR，“O”，“HTML”)`，因为Caché错误名称用尖括号括起来，并且本例从Web浏览器运行。)
`Entryref`可能如下所示：
- `ZerrorMain+4^zerrortest`--程序`zerrortest`中标签`ZerrorMain`的4行偏移量
- `ZerrorMain^zerrortest`--在程序`zerrortest`中没有与标签`ZerrorMain`的偏移量；标签行中出现错误
- `+3^zerrortest`--从程序`zerrortest`开始的3行偏移量；错误行前面没有标签
`$ZERROR`值的最大长度为512个字符。超过该长度的值将被截断为512个字符。
## AsSystemError() Method
`%Exception.SystemException`类的`AsSystemError()`方法返回与`$ZERROR`相同的值。下面的示例显示了这一点：
```java
/// d ##class(PHA.TEST.SpecialVariables).ZERROR1()
ClassMethod ZERROR1()
{
TRY {
KILL mylocal
WRITE mylocal
}
CATCH myerr {
WRITE "AsSystemError is: ",myerr.AsSystemError(),!
WRITE "$ZERROR is: ",$ZERROR
}
}
```
```java
DHC-APP>d ##class(PHA.TEST.SpecialVariables).ZERROR1()
AsSystemError is: zZERROR1+3^PHA.TEST.SpecialVariables.1 *mylocal
$ZERROR is: zZERROR1+3^PHA.TEST.SpecialVariables.1 *mylocal
```
**在`Try/Catch`异常处理块结构中，`AsSystemError()`比`$ZERROR`更可取，因为`$ZERROR`可能会被异常处理期间发生的错误覆盖。**
## 有关某些错误的其他信息
当发生某些类型的错误时，`$ZERROR`将以以下格式返回错误：
```java
entryref info
```
`INFO`组件包含有关错误原因的附加信息。下表列出了错误列表，其中包括附加信息和该信息的格式。错误代码与`INFO`组件之间用空格字符分隔。
错误代码 |信息组件
---|---
`` | 未定义变量的名称(包括使用的任何下标)。这可以是局部变量、进程私有全局属性、全局属性或多维类属性。局部变量名称以星号作为前缀。多维属性名以句点开头，以区别于本地变量名。通过设置`%SYSTEM.Process.Unfined()`方法，可以更改Caché行为，以便在引用未定义的变量时不会生成``错误。
`` | 错误的下标引用：生成错误的行引用(例程和行偏移)、下标变量以及错误的下标级别。对于结构化系统变量(SSVN)，仅提供行引用(例程和行偏移量)。通过设置`%SYSTEM.Process.NullSubscript()`方法，可以更改默认行为，以便在引用字符串下标为空的全局变量时不会生成错误。局部变量不允许使用空字符串下标。
`` |前缀为星号，即引用的例程名称。
`` | 前缀为星号，即引用的类名。
`` | 前缀为星号(引用属性的名称)，后跟逗号分隔符和应该在其中的类名。
`` |前缀是星号，即调用的方法的名称，后跟逗号分隔符和应该在其中的类名。
`` | 全局引用的名称和包含全局引用的目录的名称，用逗号分隔。
`` |前缀为星号、对象名称，后跟`DisplayString()`方法返回的值。
`` | 当不在事务中调用`TCOMMIT`时，`INFO`组件为`*NoTransaction`。当调用不返回值的用户定义函数时，`INFO`组件是一条消息，其中包含本应返回值的命令的位置。
`` |以星号为前缀的无效目录的完整路径名。
`` | 当``错误终止进程时，带有附加信息的``错误将作为消息写入`mgr/cconsole.log`。信息性消息显示已终止进程的进程ID(PID)和产生错误的行引用(例程和行偏移量)。例如：`(PID)0at+13^|“user\|mytest`
例程(或方法)本地变量的名称以及未定义例程、类、属性和方法的名称都以星号(`*`)为前缀。进程-专用全局变量由其`^||`前缀标识。全局变量由它们的`^`(插入符号)前缀标识。类名以其`%`前缀形式表示。
以下示例显示了指定错误原因的其他错误信息。在每种情况下，指定的项都不存在。请注意，生成的错误的`INFO`组件与错误名称之间用空格分隔。星号(`*`)表示局部变量、类、属性或方法。插入符号(`^`)表示全局，`^||`表示进程私有全局。
``错误示例：
```java
/// d ##class(PHA.TEST.SpecialVariables).ZERROR2()
ClassMethod ZERROR2()
{
UndefTest ;
SET $NAMESPACE="SAMPLES"
KILL x,abc(2)
KILL ^xyz(1,1),^|"USER"|xyz(1,2)
KILL ^||ppg(1),^||ppg(2)
TRY {
WRITE x
} // 未定义的局部变量
CATCH {
WRITE $ZERROR,!
}
TRY {
WRITE abc(2)
} // 未定义的下标局部变量
CATCH {
WRITE $ZERROR,!
}
TRY {
WRITE ^xyz(1,1)
} // 未定义的全局变量
CATCH {
WRITE $ZERROR,!
}
TRY {
WRITE ^|"USER"|xyz(1,2)
} // 另一个命名空间中未定义的全局变量
CATCH {
WRITE $ZERROR,!
}
TRY {
WRITE ^||ppg(1)
} // 未定义的进程专用全局变量
CATCH {
WRITE $ZERROR,!
}
TRY {
WRITE ^|"^"|ppg(2)
} // 未定义的进程专用全局变量
CATCH {
WRITE $ZERROR,!
}
}
```
```java
DHC-APP>d ##class(PHA.TEST.SpecialVariables).ZERROR2()
zZERROR2+7^PHA.TEST.SpecialVariables.1 *x
zZERROR2+13^PHA.TEST.SpecialVariables.1 *abc(2)
zZERROR2+19^PHA.TEST.SpecialVariables.1 ^xyz(1,1)
zZERROR2+25^PHA.TEST.SpecialVariables.1 ^xyz(1,2)
zZERROR2+31^PHA.TEST.SpecialVariables.1 ^||ppg(1)
zZERROR2+37^PHA.TEST.SpecialVariables.1 ^||ppg(2)
```
``错误的示例：
```java
/// d ##class(PHA.TEST.SpecialVariables).ZERROR3()
ClassMethod ZERROR3()
{
SubscriptTest ;
DO $SYSTEM.Process.NullSubscripts(0)
KILL abc,xyz
TRY {
SET abc(1,2,3,"")=123
}
CATCH {
WRITE $ZERROR,!
}
TRY {
SET xyz(1,$JUSTIFY(1,1000))=1
}
CATCH {
WRITE $ZERROR,!
}
}
```
```java
DHC-APP>d ##class(PHA.TEST.SpecialVariables).ZERROR3()
zZERROR3+5^PHA.TEST.SpecialVariables.1 *abc() Subscript 4 is ""
zZERROR3+11^PHA.TEST.SpecialVariables.1 *xyz() Subscript 2 > 511 chars
```
``错误的示例：
```java
/// d ##class(PHA.TEST.SpecialVariables).ZERROR4()
ClassMethod ZERROR4()
{
NoRoutineTest ;
KILL ^NotThere
TRY {
DO ^NotThere
}
CATCH {
WRITE $ZERROR,!
}
TRY {
JOB ^NotThere
}
CATCH {
WRITE $ZERROR,!
}
TRY {
GOTO ^NotThere
}
CATCH {
WRITE $ZERROR,!
}
}
```
```java
DHC-APP>d ##class(PHA.TEST.SpecialVariables).ZERROR4()
zZERROR4+4^PHA.TEST.SpecialVariables.1 *NotThere
zZERROR4+10^PHA.TEST.SpecialVariables.1 *NotThere
zZERROR4+16^PHA.TEST.SpecialVariables.1 *NotThere
```
对象错误的示例：
```java
DHC-APP>DO $SYSTEM.SQL.MyMethod()
DO $SYSTEM.SQL.MyMethod()
^
*MyMethod,%SYSTEM.SQL
DHC-APP>WRITE $SYSTEM.XXQL.MyMethod()
WRITE $SYSTEM.XXQL.MyMethod()
^
*%SYSTEM.XXQL
DHC-APP>SET x=##class(%SQL.Statement).%New()
DHC-APP>WRITE x.MyProp
WRITE x.MyProp
^
*MyProp,%SQL.Statement
```
``错误的示例（在Windows上）：
```java
// 用户没有％SYS名称空间的访问权限
SET x=^|"%SYS"|var
^var,c:\intersystems\cache\mgr\
```
调用用户定义函数时的``错误示例。在本例中，`MyFunc Quit`命令不返回值。这将生成一个``错误，其中`entryref`指定`$$MyFunc`调用的位置，`INFO`消息指定`QUIT`命令的位置：
```java
/// d ##class(PHA.TEST.SpecialVariables).ZERROR5()
ClassMethod ZERROR5()
{
Main
TRY {
KILL x
SET x=$$MyFunc(7,10)
WRITE "returned value is ",x,!
RETURN
}
CATCH {
WRITE "$ZERROR = ",$ZCVT($ZERROR,"O","HTML"),!
}
MyFunc(a,b)
SET c=a+b
QUIT
}
```
```java
DHC-APP>d ##class(PHA.TEST.SpecialVariables).ZERROR5()
$ZERROR = <COMMAND>zZERROR5+4^PHA.TEST.SpecialVariables.1 *Function must return a value at zZERROR5+13^PHA.TEST.SpecialVariables.1
```
使用`PUBLIC`关键字将函数作为过程调用时，出现相同的``错误：
```java
Main
TRY {
KILL x
SET x=$$MyFunc(7,10)
WRITE "returned value is ",x,!
RETURN
}
CATCH {
WRITE "$ZERROR = ",$ZCVT($ZERROR,"O","HTML"),!
}
MyFunc(a,b) PUBLIC {
SET c=a+b
QUIT
}
```
``错误示例(在Windows上)：
```java
/// d ##class(PHA.TEST.SpecialVariables).ZERROR6()
ClassMethod ZERROR6()
{
TRY {
SET prev=$SYSTEM.Process.CurrentDirectory("bogusdir")
WRITE "previous directory: ",prev,!
RETURN
}
CATCH {
WRITE "$ZERROR = ",$ZCVT($ZERROR,"O","HTML"),!
QUIT
}
}
```
```java
DHC-APP>d ##class(PHA.TEST.SpecialVariables).ZERROR6()
$ZERROR = <DIRECTORY>zCurrentDirectory+2^%SYSTEM.Process.1 *e:\dthealth\db\dthis\data\bogusdir\
```
## 5.1版本之前的错误处理代码
在Caché5.1和后续版本的这些错误代码中添加`INFO`组件的结果是，假设`$ZERROR`中的字符串格式的5.1版本之前的错误处理例程可能需要重新设计才能像以前一样工作。例如，以下内容在5.1版中将不再有效：
```java
WRITE "Error line: ", $PIECE($ZERROR, ">", 2)
```
并应更改为类似以下内容：
```java
WRITE "Error line: ", $PIECE($PIECE($ZERROR, ">", 2), " ", 1)
```
# 注意
## ZLOAD和错误消息
在`ZLOAD`操作之后，加载到例程缓冲区中的例程的名称出现在后续错误消息的`entryref`部分。这将在整个过程中持续存在，或者直到使用`ZREMOVE`删除，或者被另一个`ZLOAD`删除或替换。以下终端示例显示例程缓冲区内容的此显示：
```java
SAMPLES>ZLOAD Sample.Person.1
SAMPLES>WRITE 6/0
^Sample.Person.1
SAMPLES>WRITE fred
^Sample.Person.1 *fred
SAMPLES>WRITE ^fred
^Sample.Person.1 ^fred
SAMPLES>ZNAME "USER"
USER>WRITE 7/0
^Sample.Person.1
USER>ZREMOVE
USER>WRITE ^fred
^fred
```
## $ZERROR和程序栈
`$ZERROR`字符串的``部分包含最新的错误消息。`$ZERROR`字符串的`entryref`部分的内容反映了最近错误的堆栈级别。以下终端会话试图调用无意义的命令`gobbledegook`，导致``错误。它还运行`ZerrorMain`(上面指定)，产生`$ZERROR`值``。此终端会话期间的后续`$ZERROR`值反映了此程序调用，如下所示：
```java
SAMPLES>gobbledegook
SAMPLES>WRITE $ZERROR
SAMPLES>DO ^zerrortest
SAMPLES>WRITE $ZERROR
ZerrorMain+2^zerrortest *FRED
SAMPLES 2d0>gobbledegook
SAMPLES 2d0>WRITE $ZERROR
^zerrortest
SAMPLES 2d0>QUIT
SAMPLES>WRITE $ZERROR
^zerrortest
SAMPLES>gobbledegook
SAMPLES>WRITE $ZERROR
```
## 设置`$ZTRAP`时的`$ZERROR`操作
发生错误并设置`$ZTRAP`时，Caché在`$ZERROR`中返回错误消息，并分支到为`$ZTRAP`指定的错误陷阱处理程序
## 设置`$ZERROR`
只有在Caché模式下，才能使用`set`命令将`$ZERROR`设置为最多512个字符的值。长度超过512个字符的值将被截断为512。
**强烈建议在错误处理后将`$ZERROR`重置为空字符串(`“”`)。**
文章
Hao Ma · 五月 26, 2023
题外话：我刚刚翻译了InterSystems专家Bob Binstock的[Caché Mirroring 101：简要指南和常见问题解答](https://cn.community.intersystems.com/post/cach%C3%A9-mirroring-101%EF%BC%9A%E7%AE%80%E8%A6%81%E6%8C%87%E5%8D%97%E5%92%8C%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98%E8%A7%A3%E7%AD%94)。 尽管题目是Caché Mirror 101, 而且是写于2016年，但因为讲解的都是Mirror的基本原理，所以在大量使用IRIS的今天也完全适用。
前面的3篇文章，包括了配置Mirror的各个方面。如果您照着操作，现在已经有了一个工作的mirror环境，并加入了您的数据库。然而，还没完，这篇我来讨论一下后面的工作，首先的问题是：
**Mirror不复制什么**
简单说，Caché/IRIS镜像是**数据库复制(Database Replication)**。在Caché/IRIS里什么是数据库？也就是**Cache.dat和iris.dat**文件。数据库的修改日志，也就是journal，从主机被传送到其他镜像成员。而除此之外的内容，需要维护人员来分别的个个处理， 解决这些内容在各个镜像成员间的拷贝。需要很多的计划和细心。
>系统数据库, 包括IRISSYS, IRISTEMP, IRISLIB等等, 这些Caché/IRIS本身的数据库不应该被加入Mirror，在大多数Caché/IRIS版本里也都设置成不可以加入入MIRROR。
>
>例外的HealthCare产品， HSSYS需要做Mirror, HSCustom可以做Mirror, 而HSLIB不可以Mirror
我们可以把问题转换成下面的题目：
## 需要人工在镜像成员中同步的项目
### 命名空间(namespace)和Mapping
命名空间是应用开发的概念，它使用数据库。命名空间定义了3种映射关系：Package Mapping, Routing Mapping, Global Mapping。这样在一个命名空间可以使用多个数据库的内容。
通常情况下，用户会在主机创建命名空间的同时，创建一个新的带有mirror属性的数据库，然后会在其他mirror成员中手工一个个的创建命名空间，加入镜像的数据库。之后，管理员无需考虑更多的操作。
然而，对命名空间的修改，比如要添加或者删除命名空间的某些mapping，这偶尔会需要，尤其是应用迭代和系统扩容的情况下，那么，管理员/实施人员，必须清楚Mirror无法同步这个修改，您必须手工同步修改到其他机器去。
如果配置的mapping比较多， 我建议使用Manifest来操作。Mainfest是一个xml的文本，用来安装或者修改Caché/IRIS的配置，你可以参考[在线文档: Using a Manifest](https://docs.intersystems.com/iris20231/csp/docbook/DocBook.UI.Page.cls?KEY=GCI_manifest), 或者社区文章[使用Manifest](https://cn.community.intersystems.com/post/%E4%BD%BF%E7%94%A8manifest)。
这里给一个配置mapping的例子：
```xml
```
如果是资深的Caché维护工程师，懂得如果修改CPF文件并在不重启实例的情况下应用修改后的内容，可以考虑把主机上的CPF中的mapping部分复制粘贴到其他机器。如果您没有这方面的经验，我不建议这种方式。
另外，在IRIS 2022后的版本中有了一个新工具，Configuration Merge。 文档在[这里](https://docs.intersystems.com/iris20231/csp/docbook/Doc.View.cls?KEY=ACMF)。可惜只有最新版的IRIS或者Health Connect 用户有的用。
### 数据库的修改
数据库的内容会通过Journal从主机同步到其他成员，但修改不会，一般会遇到的是**压缩和截断**。
由于某种错误操作，某个数据库，会扩展到不正常的大，而当错误修正后，用户可能需要对该数据库进行压缩和截断，以释放被错误占用的空闲的磁盘空间。
由于除主机外，其他镜像成员的数据库都是只读的，这个操作的顺序应该是这样：
1. 在主机A执行压缩和截断
2. 切换到备机B, 再次执行压缩和截断。
3. 异步成员DR。 一种方案是吧DR提升到备机。这时当前的备机A会将为灾备，然后再切换DR为主机，再进行压缩和截断。
还有一个选择，就是重新配置DR上的这个数据库，这需要从主机到DR的数据库备份和恢复。
### IRIS实例的配置
从最常用的内存的配置，Service的配置， **用户，权限，资源**的配置等等。它们都不会被MIRROR同步。如果您在MIRROR主机里做了修改了缩表的大小，或者启动了一个，比如TELNET服务， 您需要人工在其他机器上做相同操作。
像上面的mapping配置一样，这里还是建议使用Manifest人工同步IRIS得修改。注意的是，Mainfest不保证能支持所有的配置。比如在Caché的版本下， 比如您在主机上启动了TELNET服务, Manifest没有相应的标签。这种情况下， 如果您熟悉ObjectScript语言，可以把ObjectScript实现加入执行Manifest的方法，比如说：
```java
ClassMethod main(){
//执行Manifest修改命名空间
Set pVars("Namespace")="MYNAMESPACE"
$$$ThrowOnError(..ModifyNamespace(.pVars))
//启动IRIS的TELNET服务
set properties("Enabled")=1 // 有効
set sts=##class(Security.Services).Modify("%Service_Telnet",.properties)
}
```
当然，如果您缺乏开发实施的知识，在用户界面上一个个机器的操作是最省心的办法。
问题是，打开一个服务，修改一个配置参数操作都很简单，但是如果要添加大量的用户和权限怎么办？
用Manifest管理是一个办法。但根本上，如果您经常有大量的用户管理的工作，其实使用Kerberos或者LDAP管理用户身份认证和授权的工作， 在有多个镜像成员的情况下，尤其的合适。 关于这部分内容，请参考[在线文档：Authentication and Authorization](https://docs.intersystems.com/iris20231/csp/docbook/DocBook.UI.Page.cls?KEY=PAGE_security_authentication_authorization)
### 定时任务(TASK)
在主机上创建的定时任务， 您需要人工在其他机器上做相同操作。这里有2个步骤：
1. 在主机上创建新任务的时候，要选择”**应如何为镜像运行任务**“。 这是个下拉菜单，选项有*”仅在主镜像成员上运行“，“仅在非主镜像成员上运行“ ，“在任何镜像成员上运行"。*
选择的出发点是：非主镜像成员的数据库是只读的。因此，比如一个Ensemble的镜像配置中， 删除Ensemble消息的定时任务， 一定是”仅在主镜像成员上运行“。
2. 把新的定时任务从主机同步到其他成员。
如果是一个或者少量几个TASK， 那么手工在其他各个镜像成员上添加是最简单直接的做法。而如果是有很长 的任务列表，尤其在配置Mirror得时候可以需要同步一个长长的列表时， 您可以考虑**从主机导出Task到其 他机器导入**，我只知道使用ObjectScript命令的方法， 使用`%SYS.Task.ExportTask()`和 `%SYS.Task.ImportTasks()`。 文档在[这里](https://docs.intersystems.com/iris20231/csp/documatic/%25CSP.Documatic.cls?LIBRARY=%25SYS&CLASSNAME=%25SYS.Task)。
### Web Application
主机上配置的Web Applicaiton 也要同步到其他镜像成员。如果要同步的Web Application比较多，推荐的方式依然是Manifest, 下面是一个例子。
```xml
```
麻烦的是不同的版本Caché/IRIS使用的标签上会略有不同，要稍微仔细的查看一下您的版本的文档。
如果您对ZPM, 现在称为IPM熟悉的话， 用ZPM做同步也是个好选择。关于zpm， 您可以参考这个帖子[zpm介绍](https://cn.community.intersystems.com/post/zpm%E4%BB%8B%E7%BB%8D1)。提醒一下的是，程序因为是存在数据库里面的，如果该数据库是被镜像的，您其实不需要用ZPM把程序代码拷贝到其他镜像成员。
### Gateway
一般用到的有**SQL Gateway**和**External Language Gateway**，它们分别用于连接其他的数据库和使用其他语音的代码包。
SQL Gateway
记录保存在%SYS命名空间的*%Library.sys_SQLConnection*数据表里。简单的方法是使用工具把表记录导入导出。
External Language Gateway(外部语言网关)
新版的IRIS系统内嵌了外部语言服务器，包括%Python Server, %Java Server, %Dotnet Server等。如果您使用的是默认配置，各个镜像成员是一致的，无需操心。如果只是IP端口的修改，手工同步一下也很容易，毕竟工作量有限，只是您需要清楚的记得，这个也是不被Mirror自动同步的。
### 文件
我把文件分为两类， 一类是“固定文件”，包括一下几个部分，
- CSP文件，js文件，css文件，html文件等
- XSLT文件
- 其他语言的程序代码，Java文件，python文件, .Net文件
这类文件上传到主机的时候， 也必须上传到其他镜像成员，这是个简单的操作，别忘了就行。
麻烦的是**流文件**。在ObjectScript里如果使用了%Stream.FileBinary, %Stream.FileCharacter等类，那么数据不是保存到Cache.Dat或者IRIS.data, 而是保存在和.Dat同目录的一个stream的子目录下，而这个目录是不会被镜像同步的。 而且，因为这是实时数据，你也不可能手工的把它拷来拷去。
如果您的应用里用到了文件流，我任务您需要一个文件服务器保证流文件在各个各个镜像成员间的同步。
### Ensemble Production Consideration
对于Ensemble和Health Connect用户，您需要阅读这部分在线文档： [Production Considerations for Mirroring](https://docs.intersystems.com/iris20223/csp/docbook/DocBook.UI.Page.cls?KEY=GHA_mirror_manage#GHA_mirror_set_ensemble) , 简单总结一下：
- 创建的带有ensemble或者Inteoprability的命名空间，数据库要创建为Mirror的数据库。
- **"production是否自动启动“**应该在主机和备机上，甚至DR上都配置为“自动启动”。 在Mirror配置下的Production会先检查这个实例是不是主机，如果不是，“自动启动”的配置也不会生效，这样保证了Production只在主机上运行，而切换后也不需要人工干预。
上面的这些并不是完整的内容，尽管在大多少情况下这些内容差不多够了。如果您想要确保Mirror的主机的工作内容完全同步到了备机和DR, 请仔细阅读在线文档的这一部分：[Mirror Configuration Guidelines](https://docs.intersystems.com/iris20223/csp/docbook/DocBook.UI.Page.cls?KEY=GHA_mirror_set_config#GHA_mirror_set_config_guidelines)
另外，对于各种需要人工同步的内容的操作，还建议阅读[在线文档：Server Migration](https://docs.intersystems.com/irislatest/csp/docbook/Doc.View.cls?KEY=AMIG#AMIG_migration_external)。
如果是最新的IRIS用户，请参考[在线文档：Deploy Mirrors Using Configuration Merge](https://docs.intersystems.com/iris20223/csp/docbook/DocBook.UI.Page.cls?KEY=GHA_mirror_set_config#GHA_mirror_set_config_auto_merge)
文章
Hao Ma · 九月 17, 2022
# 把数据库添加进Mirror
以往的经验里， 用户在把数据库添加到镜像时遇到过各种各样的问题，以致必须请求外部帮助才能解决。除了步骤本身比较繁琐，很大的原因是阅读文档不细致。还有一个，就是对英文水平不太高的用户，有些英文句式并不是很好懂，比如说，文档中有这一句其实非常关键：
> If you attempt to add a new database to the mirror on a nonprimary member that was not created as a mirrored database on the primary, but rather added to the mirror after it was created, an error message notes this and you cannot complete the operation.
我用最好的翻译器DeepL翻译后的中文是：
**如果你试图在一个非主要成员上向镜像添加一个新的数据库，而这个数据库并不是在主要成员上作为镜像数据库创建的，而是在创建后添加到镜像中的，那么就会出现错误信息提示，你无法完成操作。**
很讨厌的是它没用说明错误信息是什么，以致于很多用户， 当他们在Backup成员中把一个数据库添加到镜像时，遇到相关的错误时，没有把问题和这句话关联起来，这个错误提示是这样的：
>“错误 #2105: 与成员 SERVERA/IRIS 中的相匹配的数据库 :mirror:AUGEST:DEMO 未被创建为镜像数据库”。
或者用英文，
> ERROR #2105: Matching mirrored DB :mirror:AUGEST:DEMO in member SERVERA/IRIS was not created as mirrored DB
我来解释一下这句话，它说的是： ”嘿， 你在本机要添加的:mirror:AUGEST:DEMO数据库， 它在主镜像成员SERVERA/IRIS里， 未被创建为镜像数据库。“
如果您看了我的解释， 还觉得莫名其秒，我相信您其实是没懂这个关键点：
**“一个数据库创建成镜像数据库，和创建成普通数据库后面后再添加到镜像里，它们是不同的。”**
关于这一点，其实文档也有说明，啰嗦，但说明了原因。直接上翻译：
> 创建镜像数据库（即添加一个不含数据的新数据库）的过程与向镜像添加现有数据库的过程不同。作为镜像数据库创建的数据库上的Global操作从一开始就被记录在镜像Journal中，因此镜像可以访问它所需要的所有数据，以便在镜像成员之间同步数据库。但现有数据库在被添加到镜像之前的Global操作包含在非镜像Journal文件中，镜像不能访问这些文件。由于这个原因，一个现有的数据库在被添加到镜像后，必须在主故障转移成员上进行备份，并在备份故障转移成员和它要所在的任何异步成员上进行恢复。一旦这样做了，你必须激活并赶上数据库，使其与主数据库保持同步。
清楚了这个关键， 您才能理解为什么安装步骤分为下面的两个类型，
- **创建新的镜像数据库**
- **将已有的数据库加入镜像**
> TIP: 另外，还有一个值得提醒的：只有用户自己的数据库可以被加入镜像。系统本身的数据库， 比如IRISSYS, IRISLIB, IRISTEMP等等，都不能加入镜像。早期有些版本可以，NOMORE!
## 创建新的镜像数据库
- 在**主镜像成员**的系统维护界面上，选择System Administration – Configuration – System Configuration – Local Databases ， 选择Create New Database. **在数据库创建向导窗口，在“镜像数据库?”下拉菜框，选择'是‘(Yes)**。
SQL"页面, 确认表Persons同步到了所有的镜像成员。
> 这里如果您遇到上面提到的“Error 2105“， 那就是这个数据库在Primary上先是创建成一般数据库，然后加入的镜像，那您应该按下面的步骤操作了。
>
> 如果有人好奇：在Primary上的这种区别，Backup是怎么知道的，它不是还没加入到镜像吗？ 故事是这样的： 镜像日志中同步的不是只有镜像数据库的数据的修改， 还包括IRISSYS, IRISAUDIT,等库的内容。NEWDB在主成员中是怎么加入到镜像的， IRISSYS里的Global Set是不一样的，而这个set， 是同步给备用成员backup的。 又一个没用的知识。
## 将已有的数据库加入镜像
**已有的(Existing)数据库是指原本在主成员里按普通数据库创建的，然后加入镜像的数据库。**
这样的情况，哪怕同样名称，配置的数据库在其他成员上已经有了。能直接加入镜像吗？比如你主成员上有个User, 备用成员上也有，您能在主机， 备机直接把它们加入镜像吗？
答案是肯定不行。系统根本没法保证这两个库里面已有的数据是一样的。**您要在主成员上备份数据库，在其他成员恢复， 而恢复操作成功后，在其他成员上，这个数据库自动变成了“镜像数据库”**， 也就是加入了镜像。
这个同名的数据库要先在其他成员上创建。创建成普通数据库。如果其他成员上已经有了，也不用删除，就直接用主机的备份文件覆盖就好。
以下是详细的步骤：
- 在主机的“系统>配置>本地数据库“页面， 点击**添加到镜像**按钮。然后在跳出窗口中选中您要添加的数据库，可以一次选多个。 数据库很大或者多个数据库同时加入是，可以选中”在后台运行“。通常这个添加动作是在秒级时候内完成的，无所谓是否后台运行。
- 到镜像监视器查看添加的结果。被添加的数据库状态这时候应该是"一般"(Normal) 。
- 到其他镜像成员的镜像监视器查看， 您会看到主机来的通知引发的提醒：
- 在备机检查自己的数据库状态。如果没有DEMO或者USER数据库，那么创建它们，创建时下拉框”是否镜像？”选择否或者NO。之后在本地数据库列表中它们应该是这样，注意没有在镜像里。
- 在Primary做数据库的在线备份, 用于后面步骤里到其他成员上去做数据库恢复。
以下过程仅供参考：
```sh
# 在主成员备份，并发送给备份成员serverb
%SYS>do ^BACKUP
1) Backup
2) Restore ALL
3) Restore Selected or Renamed Directories
4) Edit/Display List of Directories for Backups
5) Abort Backup
6) Display Backup volume information
7) Monitor progress of backup or restore
Option? 1
*** The time is: 2022-09-17 15:27:48 ***
InterSystems IRIS Backup Utility
--------------------------
What kind of backup:
1. Full backup of all in-use blocks
2. Incremental since last backup
3. Cumulative incremental since last full backup
4. Exit the backup program
1 => 1
Specify output device (type STOP to exit)
Device: /isc/FullDBList_user.cbk => /isc/setmirror.cbk
Backing up to device: /isc/setmirror.cbk
Description:
Backing up the following directories:
/isc/data/demo/
/isc/iris/mgr/user/
Start the Backup (y/n)? => y
Journal file switched to:
/isc/jrnpri/MIRROR-AUGEST-20220917.011
Starting backup pass 1
Backing up /isc/data/demo/ at 09/17/2022 15:28:26
Copied 82 blocks in 0.004 seconds
Finished this pass of copying /isc/data/demo/
Backing up /isc/iris/mgr/user/ at 09/17/2022 15:28:28
Copied 908 blocks in 0.475 seconds
Finished this pass of copying /isc/iris/mgr/user/
Backup pass 1 complete at 09/17/2022 15:28:29
Starting backup pass 2
Backing up /isc/data/demo/ at 09/17/2022 15:28:31
Copied 2 blocks in 0.000 seconds
Finished this pass of copying /isc/data/demo/
Backing up /isc/iris/mgr/user/ at 09/17/2022 15:28:33
Copied 2 blocks in 0.000 seconds
Finished this pass of copying /isc/iris/mgr/user/
Backup pass 2 complete at 09/17/2022 15:28:33
Starting backup pass 3
Journal file '/isc/jrnpri/MIRROR-AUGEST-20220917.010' and the subsequent ones are required for recovery purpose if the backup were to be restored
Journal marker set at
offset 197572 of /isc/jrnpri/MIRROR-AUGEST-20220917.011
- This is the last pass - Suspending write daemon
Backing up /isc/data/demo/ at 09/17/2022 15:28:35
Copied 2 blocks in 0.000 seconds
Finished this pass of copying /isc/data/demo/
Backing up /isc/iris/mgr/user/ at 09/17/2022 15:28:35
Copied 2 blocks in 0.001 seconds
Finished this pass of copying /isc/iris/mgr/user/
Backup pass 3 complete at 09/17/2022 15:28:35
***FINISHED BACKUP***
Global references are enabled.
Backup complete.
1) Backup
2) Restore ALL
3) Restore Selected or Renamed Directories
4) Edit/Display List of Directories for Backups
5) Abort Backup
6) Display Backup volume information
7) Monitor progress of backup or restore
Option?
%SYS>!scp /isc/setmirror.cbk root@172.16.58.102:/isc
Enter passphrase for key '/root/.ssh/id_rsa':
root@172.16.58.102's password:
setmirror.cbk 100% 8448KB 49.4MB/s 00:00
%SYS>
```
- 在其他成员上恢复数据库，这里分两种情况：
- 其他成员上没有这个数据库： 比如我的serverb没有DEMO数据库，要做的是：创建一个DEMO数据库，使用和servera一样的设置，除了**在下拉框“镜像数据库？“，回答”NO“**
- 其他成员上有这个库，比如备机serverb里有User, 不用管它，下面我们就可以直接把它覆盖掉。
请参考下面的数据库恢复过程。 **提醒一点：不要使用第一个选项“All Directories", 该选项不能用其他机器的备份文件恢复本机。**
```sh
# 在Backup成员serverb上执行，恢复用源文件拷贝自servera
%SYS>do ^DBREST
Cache DBREST Utility
Restore database directories from a backup archive
Restore: 1. All directories
2. Selected and/or renamed directories
3. Display backup volume information
4. Exit the restore program
1 => 2
Do you want to set switch 10 so that other processes will be
prevented from running during the restore? Yes =>
Specify input file for volume 1 of backup 1
(Type STOP to exit)
Device: /isc/setmirror.cbk
This backup volume was created by:
IRIS for UNIX (Red Hat Enterprise Linux 7 for x86-64) 2022.1
The volume label contains:
Volume number 1
Volume backup SEP 17 2022 03:28PM Full
Previous backup SEP 16 2022 09:11AM Full
Last FULL backup SEP 16 2022 09:11AM
Description
Buffer Count 0
Mirror name AUGEST
Failover Member SERVERA/IRIS
Is this the backup you want to start restoring? Yes =>
This backup was made on the other mirror member.
Limit restore to mirrored databases? yes
For each database included in the backup file, you can:
-- press RETURN to restore it to its original directory;
-- type X, then press RETURN to skip it and not restore it at all.
-- type a different directory name. It will be restored to the directory
you specify. (If you specify a directory that already contains a
database, the data it contains will be lost).
/isc/data/demo/ (:mirror:AUGEST:DEMO) =>
/isc/iris/mgr/user/ (:mirror:AUGEST:USER) =>
Do you want to change this list of directories? No =>
Restore will overwrite the data in the old database. Confirm Restore? No => Yes
***Restoring /isc/data/demo/ at 15:47:09
82 blocks restored in 0.0 seconds for this pass, 82 total restored.
Expanding /isc/iris/mgr/user/ ...
Expanding /isc/iris/mgr/user/ from 1 MB to 654 MB
***Restoring /isc/iris/mgr/user/ at 15:47:12
908 blocks restored in 0.0 seconds for this pass, 908 total restored.
***Restoring /isc/data/demo/ at 15:47:12
2 blocks restored in 0.0 seconds for this pass, 84 total restored.
***Restoring /isc/iris/mgr/user/ at 15:47:12
2 blocks restored in 0.0 seconds for this pass, 910 total restored.
***Restoring /isc/data/demo/ at 15:47:12
2 blocks restored in 0.0 seconds for this pass, 86 total restored.
***Restoring /isc/iris/mgr/user/ at 15:47:12
2 blocks restored in 0.0 seconds for this pass, 912 total restored.
Specify input file for volume 1 of backup following SEP 17 2022 03:28PM
(Type STOP to exit)
Device:
Do you have any more backups to restore? Yes => no
Mounting /isc/data/demo/ which is a mirrored DB
/isc/data/demo/ ... (Mounted)
Mounting /isc/iris/mgr/user/ which is a mirrored DB
/isc/iris/mgr/user/ ... (Mounted)
Journal records for mirrored DBs were restored successfully.
%SYS>
```
- 检查数据库列表中的状态，注意它们已经成了AUGEST的镜像数据库了, **而且它们是只读模式**。
- 在serverb上查看镜像监视器，确认它们的状态是Dejournaling
后面您可以像上面提到的，在主机上操作数据， 确认数据修改同步给了备机。到此这部分工作才算结束。
> 如果只有外部备份文件:
>
> 按照文档上的说法，如果用外部备份在非主成员恢复，恢复后需要在镜像监视器的”镜像数据库列表里“点击"ACtiviate", 直到看到状态为Caaught up为至。请参考文档，我不是很清楚细节。
# 其他的镜像操作
这里我说说怎么删除镜像， 以及其他的一些常用操作的要点， 比如什么时候使用“SET NO FAILOVER”等等。
TO BE CONTINUED...
文章
Qiao Peng · 十二月 4, 2023
1. 通用RESTful业务服务和业务操作
InterSystems IRIS 提供了一组通用的RESTful 业务服务和业务操作类，用户无需开发自定义的业务服务和业务操作类，就可以直接向外提供RESTful服务和调用外部的RESTful API。
BS
EnsLib.REST.GenericService
通用REST业务服务
BS
EnsLib.REST.SAMLGenericService
检查SAML令牌的签名和时间戳的REST业务服务
BO
EnsLib.REST.GenericOperation
通用REST业务操作
BO
EnsLib.REST.GenericOperationInProc
用于透传模式的通用REST业务操作
2. 通用RESTful 消息
通用的RESTful 业务服务和业务操作类使用一个通用的RESTful消息类 - EnsLib.REST.GenericMessage，它是EnsLib.HTTP.GenericMessage的子类，二者数据结构都是
HTTPHeaders
记录http头的数组
Stream
记录http体的数据流
Type
数据流类型，例如是字符流还是二进制流。自动赋值，无需设置
Attributes
记录属性的数组
OriginalFilename
无需使用
OutputFolder
无需使用
OutputFilename
无需使用
因此EnsLib.REST.GenericMessage和EnsLib.HTTP.GenericMessage都可以被通用RESTful业务操作和业务服务所使用。
3. 通用RESTful 业务操作
使用通用的RESTful业务操作，可以连接到任何第三方的RESTful服务器，调用其RESTful API。
3.1 向production中加入通用RESTful业务操作
增加通用RESTful业务操作，只需要在Production配置页面的操作中添加EnsLib.REST.GenericOperation。
建议加入Production时，给业务操作起一个名字，用于代表具体的业务，例如是连接到LIS的RESTful 服务，可以命名为RESTtoLIS（可以考虑的命名规则 - 接口方式+业务系统）。如果未命名，默认会使用类名作为业务操作名。
3.2 配置通用RESTful业务操作
主要的设置项是以下3个：
1. HTTP服务器：目标RESTful服务器的服务器名或IP地址
2. HTTP端口：目标RESTful服务器提供RESTful API的端口号
3. URL：RESTful API的服务端点
启用该业务操作后，既可以访问外部RESTful API了。
3.3 测试通用RESTful业务操作
启用后，加入的通用的RESTful业务操作即可测试了。因为EnsLib.HTTP.GenericMessage的REST消息体是一个流类型的属性，为了测试时方便输入这个数据，我们增加一个业务流程。
1. 创建一个新的业务流程，设置其请求消息为Ens.StringRequest，用于测试时传入REST body数据。并为其上下文增加一个名为DataBody、类型为%Stream.GlobalCharacter（可持久化的字符流类型）的属性：
2. 在业务流程中增加一个代码流程(<code>)，将请求消息的字符串数据写入上下文的DataBody字符流：
Do context.DataBody.Write(request.StringValue)
注意行首加空格。
3. 然后在业务流程中再加入一个调用流程(<call>)，调用上面已经加入production的业务操作，例如RESTtoLIS，并设置请求和响应消息为EnsLib.REST.GenericMessage或EnsLib.HTTP.GenericMessage。
4. 配置RESTtoLIS业务操作的请求消息（Request）
可以直接点击构建请求消息(Request Builder)按钮，使用图形化拖拽建立请求消息：
4.1 将左边上下文context里的DataBody拖拽到callrequest的Stream属性上；
4.2 对callrequest的HTTPHeaders赋值，它是一个元素类型为字符串的数组，代表HTTP请求的头。以下3个HTTP头是必须要填写的：
HTTP头属性说明
下标
值
HTTP方法
"httprequest"
例如"POST"
HTTP消息体的内容类型
"content-type"
例如"application/json"
客户端希望接收的内容类型
"Accept"
例如"*/*"
这3个数组元素赋值，可以通过在添加操作下拉列表中设置(Set)进行赋值。
5. 将业务流程加入Production，并测试
确保Production的设置是允许调试。在Production配置页面中选中这个业务流程，在右侧的操作标签页中选择测试按钮，并在弹出的测试消息页面里填入测试用的数据，并点击调用测试服务：
然后可以检查测试的消息处理流程，并确认REST消息体和HTTP消息头被正确地传递到目标REST API
4. 通用RESTful 业务服务
使用通用的RESTful业务服务，可以向外发布能处理任何RESTful API调用请求的RESTful服务端。
4.1 将通用RESTful业务服务加入Production
在Production配置页面，点击服务后面的加号。弹出的向导页面，服务类选择EnsLib.REST.GenericService；输入服务名，建议写一个能代表组件功能的名字，例如向HIS系统开放的REST服务，可以起名RESTforHIS；选中立即启用。
RESTful通用业务服务可以通过2种方式向外提供RESTful API服务：第一种通过Web服务器向外提供服务，第二种使用IRIS服务器的特定TCP端口向外提供服务。第二种方式不依赖于独立的Web服务器，但推荐使用Web服务器，从而得到更好的性能和安全性。
这里我们使用Web服务器提供REST服务，因此在业务服务的端口配置中，保持空白。在接受消息的目标名称中，选择接收RESTful API请求的业务流程或业务操作，这里我们测试使用一个空的业务流程。点击应用激活这些设置。
4.2 建立一个向外提供RESTful API的Web应用
向外发布RESTful服务，不仅涉及到服务发布的URL，还涉及到安全。我们通过创建一个专用的Web应用来进行管理和控制。
在IRIS系统管理门户>系统管理>安全>应用程序>Web应用程序 中，点击新建Web应用程序按钮，新建一个Web应用程序，并做以下配置：
1. 名称，填写一个计划发布的服务端点，例如/IRISRESTServer。注意前面的/
2. NameSpace，选择Production所在的命名空间
3. 选中启用 REST，并设置分派类为EnsLib.REST.GenericService
4. 根据安全需要，配置安全设置部分。这里方便测试起见，允许的身份验证方法选择了未验证（无需验证）。如果是生产环境，或者您在做性能压力测试，都应该选择密码或Kerberos安全的身份验证方式！
注意，请保证同一个命名空间下，仅有一个分派类为EnsLib.REST.GenericService的REST类型的Web应用。
4.3 测试RESTful业务服务
现在就可以测试这个RESTful业务服务了。这个RESTful服务可以响应任何REST API的请求，如何响应则是后续业务流程/业务操作的事。
它的完整的RESTful URL是：[Web服务器地址]:[Web服务器端口]/[Web应用的名称]/[通用REST服务在production中的配置名]/[API名称和参数]，例如我在IRIS本机的私有Apache的52773端口上访问上面创建的REST通用业务服务，调用PlaceLabOrder的API （注意，这里我们并没有实现过PlaceLabOrder这个API，但我们依然可以响应，而不会报404错误），那么完整的REST 调用地址是：
127.0.0.1:52773/IRISRESTServer/RESTforHIS/PlaceLabOrder
打开POSTMAN，用POST方法，发起上面REST API的调用：
在IRIS里会得到类似这样的消息追踪结果，如果你没有实现过处理REST API请求的业务流程，会得到一个500错，但依然可以查看IRIS产生的EnsLib.HTTP.GenericMessage消息内容：
这个通用RESTful业务服务会把REST请求转换为EnsLib.HTTP.GenericMessage消息，向目标业务操作/业务流程发送。因此，通过解析它的消息内容，就知道REST API请求的全部信息：
1. Stream里是POST的数据
2. HTTPHeaders 的下标"HttpRequest"是HTTP的方法
3. HTTPHeaders 的下标"URL"是完整的API路径，包括了服务端点（在"CSPApplication"下标下）、REST业务服务名称（在"EnsConfigName"下标下）和API
后续业务流程可以通过这些数据对REST API请求进行响应。
4.4 使用业务流程对REST API调用进行路由
有了通用RESTful业务服务生成的EnsLib.HTTP.GenericMessage消息，我们就可以使用消息路由规则或业务流程对REST API请求进行路由。这里我使用业务流程方法对REST API请求进行路由演示。
构建一个新的业务流程，请求消息和响应消息都是EnsLib.REST.GenericMessage或EnsLib.HTTP.GenericMessage，同时为context增加一个名为ReturnMsg的字符串类型的属性，并设置它默认值为："{""Code"":-100,""Msg"":""未实现的API""}"。
在业务流程里增加一个<switch>流程，然后在<switch>下增加2个条件分支，分别为：
名称：下达检验医嘱，条件：判断是否http头的URL为PlaceLabOrder，且http头的HttpRequest为POST：
(request.HTTPHeaders.GetAt("URL")="/IRISRESTServer/RESTforHIS/PlaceLabOrder") && (request.HTTPHeaders.GetAt("HttpRequest")="POST")
名称：查询检验项目，条件：判断是否http头的URL为GetLabItems，且http头的HttpRequest为GET：
(request.HTTPHeaders.GetAt("URL")="/IRISRESTServer/RESTforHIS/GetLabItems") && (request.HTTPHeaders.GetAt("HttpRequest")="GET")
在两个分支里，分别增加<code>, 产生返回的REST消息内容：
Set context.ReturnMsg="{""Code"":200,""Msg"":""检验医嘱下达成功""}"
Set context.ReturnMsg="{""Code"":200,""Msg"":""查询检验项目成功""}"
最后在<switch>后增加一个<code>，构建响应消息：
// 初始化响应消息
set response = ##class(EnsLib.REST.GenericMessage).%New()
// 初始化响应消息的流数据
Set response.Stream = ##class(%Stream.GlobalCharacter).%New()
// 将REST返回数据写入流
Do response.Stream.Write(context.ReturnMsg)
编译这个业务流程，并将其加入Production。
之后修改通用RESTful业务服务的设置，将接收消息的目标名称改为这个新建的业务流程。
现在再通过POSTMAN测试一下各种API，并查看返回REST响应：
在真实项目中，根据实际情况，将上面<switch>流程分支的<code>替换为API响应业务流程或业务操作即可。
总结：使用通用RESTful业务操作和业务服务，无需创建自定义的RESTful 业务组件类，就可以调用外部RESTful API和向外提供RESTful API服务，降低开发和实施成本，实现低代码开发。
后记：关于EnsLib.REST.GenericService对CORS(跨域资源共享)的支持
CORS是一种基于 HTTP 头的机制，通过允许服务器标示除了它自己以外的其它origin(域、协议和端口)等信息，让浏览器可以访问加载这些资源。所以要让EnsLib.REST.GenericService支持CORS，需要让它的响应消息增加对于CORS支持的HTTP头的信息，这里不详细介绍这些头含义了，大家可以去W3C的网站或者搜索引擎查询具体定义，最简单可以使用以下代码替代上面4.4中的初始化响应消息代码：
// 设置HTTP响应的头信息
set tHttpRes=##class(%Net.HttpResponse).%New()
set tHttpRes.Headers("Access-Control-Allow-Origin")="*"
set tHttpRes.Headers("Access-Control-Allow-Headers")="*"
set tHttpRes.Headers("Access-Control-Allow-Methods")="*"
// 初始化响应消息
set response = ##class(EnsLib.REST.GenericMessage).%New(,,tHttpRes)
文章
姚 鑫 · 十一月 4, 2021
# 第六十六章 SQL命令 REVOKE
从用户或角色中删除特权。
# 大纲
```sql
REVOKE admin-privilege FROM grantee
REVOKE role FROM grantee
REVOKE [GRANT OPTION FOR] object-privilege
ON object-list FROM grantee [CASCADE | RESTRICT] [AS grantor]
REVOKE [GRANT OPTION FOR] SELECT ON CUBE[S] object-list FROM grantee
REVOKE column-privilege (column-list)
ON table FROM grantee [CASCADE | RESTRICT]
```
## 参数
- `admin-privilege` - 管理员级特权或以前授予要撤销的管理员级特权的以逗号分隔的列表。
可用的`syspriv`选项包括`16`个对象定义权限和`4`个数据修改权限。对象定义权限为:`%CREATE_FUNCTION`， `%DROP_FUNCTION`， `%CREATE_METHOD`， `%DROP_METHOD`， `%CREATE_PROCEDURE`， `%DROP_PROCEDURE`， `%CREATE_QUERY`， `%DROP_QUERY`， `%CREATE_TABLE`， `%ALTER_TABLE`， `%DROP_TABLE`， `%CREATE_VIEW`， `%ALTER_VIEW`， `%DROP_VIEW`， `%CREATE_TRIGGER`， `%DROP_TRIGGER`。
或者，可以指定`%DB_OBJECT_DEFINITION`，这将撤销所有`16`个对象定义特权。数据修改权限为`INSERT`、`UPDATE`、`DELETE`操作的`%NOCHECK`、`%NOINDEX`、`%NOLOCK`、`%NOTRIGGER`权限。
- `grantee` - 拥有SQL系统权限、`SQL`对象权限或角色的一个或多个用户的列表。
有效值是一个以逗号分隔的用户或角色列表，或`“*”`。
星号(`*`)指定当前定义的所有没有`%all`角色的用户。
- `AS grantor` - 此子句允许通过指定原始授予者的名称来撤销另一个用户授予的特权。
有效的授予者值是用户名、以逗号分隔的用户名列表或`“*”`。
星号(`*`)指定当前定义的所有授予者。
要使用`AS`授予器子句，必须具有`%All`角色或`%Admin_Secure`资源。
- `role` - 一个角色或以逗号分隔的角色列表，这些角色的权限将从用户被撤销。
- `object-privilege` - 基本级别特权或先前授予要撤销的基本级别特权的逗号分隔列表。
该列表可以包含以下一个或多个:`%ALTER`、`DELETE`、`SELECT`、`INSERT`、`UPDATE`、`EXECUTE`和`REFERENCES`。
要撤销所有特权，可以使用`“all [privileges]”`或`“*”`作为此参数的值。
注意，您只能从多维数据集撤销`SELECT`特权，因为这是惟一可授予的多维数据集特权。
- `object-list` - 一个以逗号分隔的列表，其中包含一个或多个正在撤销对象特权的表、视图、存储过程或多维数据集。
可以使用`SCHEMA`关键字指定从指定模式中的所有对象撤销对象特权。
可以使用`" * "`指定从当前命名空间中的所有对象撤销对象特权。
- `column-privilege` - 从一个或多个列列表列出的列撤销基本权限。
可用选项有`SELECT`、`INSERT`、`UPDATE`和`REFERENCES`。
- `column-list` - 由一个或多个列名组成的列表，用逗号分隔，用括号括起来。
- `table` - 包含列列表列的表或视图的名称。
# 描述
`REVOKE`语句撤销允许用户或角色在指定的表、视图、列或其他实体上执行指定任务的权限。
`REVOKE`还可以撤销用户分配的角色。
`REVOKE`撤销`GRANT`命令的操作;
特权只能由授予特权的用户撤消，或者通过`CASCADE`操作(如下所述)。
可以从指定用户、用户列表或所有用户(使用`*`语法)撤销角色或特权。
因为`REVOKE`的准备和执行速度很快，而且通常只运行一次，所以`IRIS`不会在`ODBC`、`JDBC`或动态SQL中为`REVOKE`创建缓存查询。
即使不能执行实际的撤销(例如，指定的特权从未被授予或已经被撤销)，`REVOKE`也会成功地完成。
但是，如果在`REVOKE`操作期间发生错误，`SQLCODE`将被设置为负数。
## 撤销的角色
角色可以通过`SQL GRANT`和`REVOKE`命令授予或撤销，也可以通过`^SECURITY IRIS System SECURITY`命令授予或撤销。
可以使用`REVOKE`命令从某个用户撤消一个角色，也可以从另一个角色撤消一个角色。
不能使用`IRIS System Security`将角色授予或撤销给其他角色。
特殊变量`$ROLES`不显示授予角色的角色。
`REVOKE`可以指定单个角色，也可以指定要撤销的角色列表，以逗号分隔。
`REVOKE`可以从指定的用户(或角色)、用户(或角色)列表或所有用户(使用*语法)中撤销一个或多个角色。
`GRANT`命令可以将一个不存在的角色授予用户。
可以使用`REVOKE`命令从现有用户撤销不存在的角色。
但是，角色名必须使用与授予角色时相同的字母大小写来指定。
如果试图从不存在的用户或角色撤销现有角色， IRIS将发出`SQLCODE -118`错误。
如果不是超级用户，并且试图撤销一个不拥有且没有`ADMIN OPTION`的角色，InterSystems IRIS将发出`SQLCODE -112`错误。
## 撤销对象权限
对象特权赋予用户或角色对特定对象的某些权限。
从一个被授予者的对象列表上撤销一个对象特权。
对象列表可以在当前名称空间中指定一个或多个表、视图、存储过程或多维数据集。
通过使用逗号分隔的列表，单个`REVOKE`语句可以从多个用户和/或角色中撤销多个对象上的多个对象特权。
可以使用星号(`*`)通配符作为对象列表值，从当前名称空间中的所有对象撤销对象特权。
例如，`REVOKE SELECT ON * FROM Deborah`将撤销该用户对所有表和视图的SELECT权限。
`REVOKE EXECUTE ON * FROM Deborah`将撤销该用户对所有非隐藏存储过程的`EXECUTE`权限。
可以使用`SCHEMA SCHEMA -name`作为对象列表值，以撤销指定模式中当前名称空间中的所有表、视图和存储过程的对象特权。
例如，`REVOKE SELECT ON SCHEMA Sample FROM Deborah`将撤销该用户对`Sample`模式中所有对象的`SELECT`权限。
可以将多个模式指定为逗号分隔的列表;
例如，`REVOKE SELECT ON SCHEMA Sample,Cinema FROM Deborah`撤销`Sample`和`Cinema`模式中所有对象的`SELECT`权限。
可以从用户或角色撤消对象特权。
如果从某个角色撤销该权限，则仅通过该角色拥有该权限的用户将不再拥有该权限。
不再拥有特权的用户不能再执行需要该对象特权的现有缓存查询。
当`REVOKE`撤销对象特权时，它将成功完成并将`SQLCODE`设置为0。
如果`REVOKE`没有执行实际的撤销(例如，指定的对象权限从未被授予或已经被撤销)，它将成功完成，并将`SQLCODE`设置为`100`(不再有数据)。
如果在`REVOKE`操作期间发生错误，它将`SQLCODE`设置为负数。
多维数据集是不受模式名称限制的SQL标识符。
要指定多维数据集对象列表，必须指定`CUBE`(或cubes)关键字。
因为多维数据集只能有`SELECT`权限，所以您只能从多维数据集撤销`SELECT`权限。
对象权限可以通过以下任意方式撤销:
- `REVOKE command`.
- `$SYSTEM.SQL.Security.RevokePrivilege()`方法。
- 通过IRIS系统安全。
转到管理门户，选择系统管理、安全、用户(或系统管理、安全、角色)，为所需的用户或角色选择`Edit`，然后选择SQL表或SQL视图选项卡。
在下拉列表中选择`Namespace`。
向下滚动到所需的表，然后单击`revoke`来撤销权限。
可以通过调用`%CHECKPRIV`命令来确定当前用户是否具有指定的对象特权。
通过调用`$SYSTEM.SQL.Security.CheckPrivilege()`方法，可以确定指定的用户是否具有指定的表级对象特权。
## 撤销对象所有者特权
如果从对象的所有者那里撤消对SQL对象的特权，那么所有者仍然隐式地拥有对对象的特权。
为了从对象的所有者完全撤销对象上的所有特权，必须更改对象以指定不同的所有者或没有所有者。
## 撤销表级和列级特权
`REVOKE`可用于撤销表级特权或列级特权的授予。
表级特权提供对表中所有列的访问。
列级特权提供对表中每个指定列的访问。
向表中的所有列授予列级特权在功能上等同于授予表级特权。
然而，这两者在功能上并不完全相同。
列级`REVOKE`只能撤销在列级授予的权限。
不能向表授予表级特权，然后在列级为一个或多个列撤销此特权。
在这种情况下，`REVOKE`语句对已授予的权限没有影响。
## CASCADE 或 RESTRICT
IRIS支持可选的`CASCADE`和`ESTRICT关`键字来指定`REVOKE`对象特权行为。
如果没有指定关键字，则默认为`RESTRICT`。
可以使用`CASCADE`或`RESTRICT`来指定从一个用户撤销对象特权或列特权是否也会从通过`WITH GRANT OPTION`接收到该特权的任何其他用户撤销该特权。
`CASCADE`撤销所有这些关联的特权。
当检测到关联的特权时，`RESTRICT(默认值)`导致`REVOKE`失败。
相反，它设置`SQLCODE -126`错误`“REVOKE with RESTRICT failed”`。
下面的例子展示了这些关键字的使用:
```sql
--UserA
GRANT Select ON MyTable TO UserB WITH GRANT OPTION
```
```sql
--UserB
GRANT Select ON MyTable TO UserC
```
```sql
--UserA
REVOKE Select ON MyTable FROM UserB
-- This REVOKE fails with SQLCODE -126
```
```sql
--UserA
REVOKE Select ON MyTable FROM UserB CASCADE
-- This REVOKE succeeds
-- It revokes this privilege from UserB and UserC
```
注意，`CASCADE`和`RESTRICT`对`UserB`创建的引用`MyTable`的视图没有影响。
## 对缓存查询的影响
当撤销特权或角色时， IRIS将更新系统上所有缓存的查询，以反映特权中的这一更改。
但是，当无法访问某个名称空间时——例如，当连接到数据库服务器的ECP连接关闭时——`REVOKE`会成功完成，但不会对该名称空间中的缓存查询执行任何操作。
这是因为`REVOKE`不能更新不可达名称空间中的缓存查询，以撤销缓存查询级别的特权。
没有发出错误。
如果数据库服务器稍后启动，则该名称空间中缓存查询的权限可能不正确。
如果某个角色或特权可能在某个名称空间不可访问时被撤销，建议清除该名称空间中的缓存查询。
## IRIS Security
REVOKE命令是一个特权操作。
在嵌入式SQL中使用`REVOKE`之前，必须以具有适当特权的用户身份登录。
如果不这样做，将导致`SQLCODE -99`错误(特权冲突)。
使用`$SYSTEM.Security.Login()`方法为用户分配适当的权限:
```
DO $SYSTEM.Security.Login("_SYSTEM","SYS")
&sql( )
```
必须具有`%Service_Login:Use`权限才能调用`$SYSTEM.Security`。
登录方法。
# 示例
下面的嵌入式SQL示例创建两个用户，创建一个角色，并将角色分配给用户。
然后，它使用星号(`*`)语法从所有用户撤销该角色。
如果用户或角色已经存在，`CREATE`语句将发出`SQLCODE -118`错误。
如果用户不存在，`GRANT`或`REVOKE`语句将发出`SQLCODE -118`错误。
如果用户存在但角色不存在，则`GRANT`或`REVOKE`语句发出`SQLCODE 100`。
如果用户和角色存在，则`GRANT`或`REVOKE`语句发出`SQLCODE 0`。
即使已经完成了角色的授予或撤销，如果您试图撤销从未被授予的角色，也是如此。
```java
ClassMethod Revoke()
{
d $SYSTEM.Security.Login("_SYSTEM","SYS")
&sql(
CREATE USER User1 IDENTIFY BY fredpw
)
&sql(
CREATE USER User2 IDENTIFY BY barneypw
)
w !,"CREATE USER error code: ",SQLCODE
&sql(
CREATE ROLE workerbee
)
w !,"CREATE ROLE error code: ",SQLCODE
&sql(
GRANT workerbee TO User1,User2
)
w !,"GRANT role error code: ",SQLCODE
&sql(
REVOKE workerbee FROM *
)
w !,"REVOKE role error code: ",SQLCODE
}
```
在下面的示例中，使用`AS`授予子句，一个用户(`Joe`)授予一个特权，另一个用户(`John`)撤销该特权:
```sql
/* User Joe */
GRANT SELECT ON Sample.Person TO Michael
```
```sql
/* User John */
REVOKE SELECT ON Sample.Person FROM Michael AS Joe
```
注意，`John`必须具有`%All`角色或`%Admin_Secure`资源。
文章
Nicky Zhu · 一月 6, 2023
国务院于2022年12月19日发布了《中共中央 国务院关于构建数据基础制度更好发挥数据要素作用的意见》（后简称《数据二十条》），如何有效利用数据已经成为下一步的趋势。另一方面，无论是基于数据中台还是数据编织理念，两者也都对如何利用数据提出了构想。因此医疗行业数字化建设的目标已不能再局限于如何收集数据，建立医疗行业数据的流通机制将会是为越来越普遍的需求。
时钟拨回几年前，数据中台概念开始火爆。人们对数据中台的定义、诠释尽管有诸多差异，通过数据中台降低数据共享和利用的成本则是共同的期望。但经过这几年的探索之后，中台已死的观点也在涌现。究其原因，除去中台概念在技术上的不确定，数据流通过程中的责权益的不清晰也是严重的制约因素。毕竟，数据中台自身作为一套技术框架并不能代替法律法规与市场自动将数据转变为商品从而创造出流通价值。
那么，如何能够使数据的流通合规合法，使数据能够如货币和商品一般自由流动，则是我们需要思考和探索的主题，这次《数据二十条》的出现，无疑为医疗信息技术工作者提供了一个明确的思考方向。
政策利好与约束
鉴于《数据二十条》对数据行业生态的覆盖范围之广，涉及数据权属界定、数据产品流通、数据收益分配和数据市场有效监管等各方面，本文将无法全面展开每一条政策进行解读和思考，因此将聚焦于与每个从业人员都息息相关的数据产权和数据产品流通两方面进行。
产权与使用权的破与立
还记得数年前与信息科同事谈及基于医疗数据的统计与分析时，医院的同事对于数据被第三方访问的恐惧远多于期待。对数据要素的权属及其确立规则的不清晰使得每个从业人员都无法在具备法律法规保障的前提下运用数据。本次《数据二十条》对于个人数据、企业数据和公共数据进行了产权定义，还提出了数据资源持有权、数据加工使用权、数据产品经营权等分置的产权运行机制，从而打破了这样无法可依的尴尬局面。
可以预见的是，通过对数据的产权与使用权进行分离，在取得数据所有者（如个人或企业）授权的前提下，对数据进行加工处理，通过数据洞察进行盈利将成为合理合法的业务形态。
数据供应链的建立
《数据二十条》第三章对数据供应链体系做了一系列的规划，包括数据流通过程中参与方的角色，如数据商和第三方专业服务机构；包括流通场所，如数据交易所以及对应的流程合规与监管规则体系的远景。这样一个体系的构建，其规模和复杂性并不亚于为汽车工业组织零部件生产和消费的供应链。
特别需要注意的是，正如《数据二十条》中明确指出的，数据供应链的建立必将依托数据质量标准化体系，推进对数据采集和接口的标准化，依赖于数据整合互通和互操作。
这些概念和体系对于医疗信息技术工作者来说并不陌生。然而在既往的工作中，跨企业、跨区域医疗行业数据共享的产业规模并未对标准化产生强劲的推力。尽管近年来随着互联互通标准化评测工作的开展，医疗信息互操作在标准化方面得到了极大的进展，但是医疗行业数据与上下游生态企业（如药企、保险、养老机构等）间进行数据流通所需的统一语义和标准还未确立和应用，势必将在不远的未来对医疗信息技术工作者提出更高的挑战。
另一方面，在鼓励数据交易所发挥作用的同时，《数据二十条》也倡导在数据流程合规与受规则体系监管的前提下，培育一批数据商和第三方专业服务机构，依法依规在场内和场外采取开放、共享、交换、交易等方式流通数据，也为创建数据供应、数据托管和数据服务代理等多种模式的数据经济形态创造了条件。
医疗行业数据流通案例
医疗数据产业并不是一个已经成熟的规模化产业，即使对于美国、英国这些在医疗信息化方面较早起步的国家，医疗数据产品和流通也仍然处于初步的市场探索阶段。我们可以看到一个案例。
Epic COSMOS数据集
美国最大的电子病历厂商Epic于2019年推出了数据集产品COSMOS（https://COSMOS.epic.com/）。所有Epic电子病历系统的用户都可以自愿与Epic签约成为COSMOS合作伙伴，在开放自己的医疗健康数据的同时共享同样加入了COSMOS网络其他用户的数据。时至今日，COSMOS已经收录了1亿6千7百万患者的数据，覆盖一千余家医院和两万余家诊所。
图 1 COSMOS数据流
如上图所示，Epic采用了非常传统的前置机+中心化存储方案构建。在置于院端的前置机中，以批量上传和事件触发上传两种方式加载数据集，在前置机一侧对数据进行标准化和匿名化，并通过HL7 CDA标准以文档的形式将数据传到数据中心。置于AWS云端的数据中心将负责对数据进行去重及合并。其中，数据在云端将以非结构化的Global形态存储于InterSystems的Caché中，并利用Caché自带的后结构化能力将非结构化的Global转换并存储为关系型数据对外提供SQL访问能力。
在这个过程中，COSMOS进行的若干细节处理非常值得即将面临数据开放的医疗信息技术工作者参考和借鉴。读者可参考相关论文查阅（如https://www.thieme-connect.com/products/ejournals/pdf/10.1055/s-0041-1731004.pdf）。
真实数据的可访问性：COSMOS本质上只解决了分散的，真实的医疗数据的可访问性问题，还没有运用任何颠覆性的BI、AI技术。作为美国最大的电子病历厂商，手握上亿人的医疗数据的Epic，需要从基础数据的准备切入市场，这从侧面反映了当前医疗行业所面临的客观现实，即供应链底层的数据原料并不存在稳定的供给，从而阻碍了其他技术的演进。这同样是我们面临的现状。
非常传统的数据采集：COSMOS只采集EHR中的结构化数据，并不收纳任何影像、视频和除实验室检测结果外的文本等多媒体数据，也未采用实时数据流进行采集。这并不意味着多媒体数据没有价值，也不意味着实时数据流没有价值，而是意味着半静态的，结构化的数据中的价值并没有得以充分提炼和发挥，仅通过收集整理结构化数据形成规模一项工作已足以支撑起庞大的价值链条，尽管这些静态数据并不是唯一的价值来源。
去识别化与个人数据授权：作为对患者信息进行隐私保护的首要手段，COSMOS及与之相似的数据集产品Cerner Real-World Data（CRWD）均遵循美国自1996年通过的HIPPA法案，只开放法案允许开放的数据集，并按照HIPPA的要求对可能暴露患者隐私或反向识别个人的数据字段进行匿名化处理。需要注意的是，尽管CRWD相关的论文中声明，由于对数据进行了匿名化处理，对个人医疗数据的使用不需要患者本人的授权（https://www.sciencedirect.com/science/article/pii/S2352340922003304），但COSMOS仍然提供了供患者撤回数据授权，将本人的数据从COSMOS网络中退出的工作流。因此，即使在美国，数据所有者和数据使用者之间的权益平衡仍保留了相当的灵活性，我国在制定相关法规时也会对基于所有权和使用权定义相应的细则。
数据访问控制：在前置机与云端数据中心通信过程中，CDA文档将被加密并通过专网传输，避免在公网传输并被截获和解析的可能。另一方面，尽管COSMOS收集了诊断、药嘱、手术史、社会史和家族史等患者个人的明细数据，但它并不对最终用户开放这些数据；COSMOS用户可以通过查询门户，制定条件，查询基于这些明细的统计数据，例如在一定行政区域内罹患新冠的患者数量及其年龄分布等，但无法查询到对应的个人，因此经过认证的科研机构在COSMOS中发起查询并不再需要特定的审查委员会审核；同时COSMOS也不提供将数据从COSMOS网络中导出的渠道，避免数据流出网络。从这些控制手段上来看，COSMOS选择的技术路线和服务模式与《新二十条》中“原始数据不出域、数据可用不可见”的要求和“以模型、核验等产品和服务等形式向社会提供”的倡导高度吻合，值得借鉴。
数据标准化：COSMOS在前置机上收集一家医院的数据时已落实了数据的标准化，采用固定的数据结构和术语集。医院需要先完成对数据和术语的标准化映射，才能接入COSMOS网络。而在云端存储中，原始数据也是以标准化的CDA文档形式保存，进一步巩固了数据标准。也正是在标准化数据存储的基础上，最终用户才能够通过统一的查询构建器，在同一种语义环境下同时访问来自于不同医院，采用了不同术语标准的医疗数据。因此通过数据标准术语标准达成语义一致性的重要性不言而喻，这是医疗数据的利用迅速得到规模效应的客观需求。
医疗数据产品发展前景
如前所述，基于数据所有权与数据使用权分离的假设，很难想象未来医疗数据产品的发展方向以生数据产品的形态，开放对个人数据的（即使经过了匿名化）访问。相反的，基于医疗数据需求的多样性以及个人、企业、公共数据管理规则的差异性，以生数据为基础，以对药企、保险等企业提供潜在可招募患者的区域锁定或针对患者的年龄、诊断、家族史的普遍特征与医疗支出进行精算为例，针对人群展开的数据洞察和数据分析服务，更可能得到业界的认可并在数据价值利用和数据隐私保护间取得平衡，有很大概率成为率先得以实现的商业模式。同时，作为一个新兴产业，生产者（数据工程师）群体的培养和储备，以及与之配套的生产资料的制造和积累，则是医疗数据产业能够成型的前提，值得医疗信息技术工作者关注和投入。
因此，在未来相当长的一段时间内，对医疗行业数据的利用，将以各医院、集团和企业建立的数据中心为基础，通过对真实数据进行洞察分析和价值挖掘的形态，以数据服务的形式对外提供，从而迅速释放这些被积累了很久的数据的价值。
后续我们还会继续阐述和分析在医疗数据流通领域中的生产者和生产资料的特征，欢迎大家与我们交流，谢谢。
文章
Weiwei Gu · 七月 12, 2022
开始 - 请拉到页面底部查看该系列文章第一部分 .
3. 使用globals时结构的变体
一个结构，比如说一个有序排列的“树”，有各种特殊的情况。让我们来看看那些对使用globals有实际价值的情况。
3.1 特殊情况1. 一个没有分支的节点
Globals不仅可以像数组一样使用，而且可以像普通变量一样使用。例如，用于创建一个计数器:
Set ^counter = 0 ; setting counter
Set id=$Increment(^counter) ; atomic incrementation
同时，一个global除了值以外，还可以有分支。一个并不排斥另一个。
3.2 特殊情况2. 一个节点和多个分支
事实上，这是一个典型的键值库。而如果我们把健和值都存下来而不是仅仅是存值的话，那我们会得到一个有主键的普通表。
为了实现一个基于globals的表，我们将不得不从列值中形成字符串，然后通过主键将它们保存到global中。为了能够在读取过程中把字符串分割成列，我们可以使用以下方法。
分隔符
Set ^t(id1) = "col11/col21/col31"
Set ^t(id2) = "col12/col22/col32"
一个固定的方案，即每个字段占据特定数量的字节。在关系型数据库中通常就是这样做的。 一个特殊的$LB
一个特殊的 $LB函数（从Caché开始引入的），可以从值中组成一个字符串。
Set ^t(id1) = $LB("col11", "col21", "col31")
Set ^t(id2) = $LB("col12", "col22", "col32")
有趣的是，使用globals做一些类似于关系型数据库中外键的事情并不难。我们把这种结构称为index globals。Index globals是一个补充"树"，用于快速搜索那些不属于主Global主键组成部分的字段。你需要编写额外的代码来填充和使用它。
下面，让我们在第一列的基础上创建一个Index global.
Set ^i("col11", id1) = 1
Set ^i("col12", id2) = 1
要想通过第一列快速搜索，你需要查看^i global，并找到与第一列中必要值对应的主键（id）。
当插入一个值时，我们可以同时为必要的字段创建值和Index global。为了保证可靠性，让我们把它包装成一个事务(transaction)。
TSTART
Set ^t(id1) = $LB("col11", "col21", "col31")
Set ^i("col11", id1) = 1
TCOMMIT
更多的信息可以从这里查看 making tables in M using globals and emulation of secondary keys.
如果用COS/M编写插入/更新/删除函数并进行编译，这些表的工作速度将与传统DB一样快（甚至更快）。
我通过对一个单一的双列表进行大量的INSERT和SELECT操作，同时使用TSTART和TCOMMIT命令（transactions事务）来验证这个声明。
我没有测试更复杂的并发访问和并行事务的情况。
在不使用transactions事务的情况下，一百万个值的插入速度为778,361次/秒。
对于3亿个值，速度是422,141次/秒。
当使用transactions交易时，对于5000万个值，速度达到572,082次插入/秒。所有的操作都是通过编译的M代码运行的。我使用了普通的硬盘，而不是SSD。RAID5有回写功能。所有运行在Phenom II 1100T CPU上。
为了对SQL数据库进行同样的测试，我们需要写一个存储过程，在一个循环中进行插入。当使用同样的方法测试MySQL 5.5（InnoDB存储）时，我从来没有得到超过每秒11K次的插入。
确实，用globals实现表比在关系型数据库中做同样的事情要复杂。这就是为什么基于globals的工业数据库会有SQL访问，以来简化表格数据的工作。
一般来说，如果数据模式不会经常改变，插入的速度不是很关键，而且整个数据库可以很容易地用规范化的表来表示，那么使用SQL就比较容易，因为它提供了一个更高的抽象层次。
在这种情况下，我想表明globals可以被用作创建其他DB的构造函数。就像汇编语言可以用来创建其他语言一样。而这里有一些使用globals来创建对应的 键值key-values, 列表lists, 集合sets, 表格-tabular, 文档数据库-document-oriented DB 的例子。
如果你需要以最小的努力创建一个非标准的数据库，你应该考虑使用globals。
3.3 特殊情况 3.一个有两个层级的“树”，每个二级节点都有固定数量的分支
你可能已经猜到了：这是一个使用globals的表格的可选实现形式。我们把它与之前的那个进行比较。
两层树中的表 VS .一层树中的表
缺点
优点
1.插入速度慢，因为节点的数量必须设置为与列的数量相等。2 更高的硬盘空间消耗，因为带有列名的全局索引（如数组索引）占用了硬盘空间，并且每一行都是重复的。
1.对特定列的值的访问速度更快，因为你不需要解析字符串。根据我的测试，对于2个列来说，它的速度要快11.5%，对于更多的列来说，速度甚至更快。2. 更容易改变数据模式3. 更容易阅读代码
结论:没什么可写的。由于性能是globals的关键优势之一，使用这种方法几乎没有任何意义，因为它不可能比关系型数据库中的普通表工作得更快。
3.4 一般情况。"树"和有序键
任何可以被表示为"树"的数据结构都能完美地适合globals。
3.4.1 有子对象的对象
这就是传统上使用 globals 的领域。在医疗领域有无数的疾病、药物、症状和治疗方法。为每个病人创建一个有一百万个字段的表是不合理的，尤其是99%的字段都是空白的。
想象一下，一个由以下表格组成的SQL数据库。"病人"~10万个字段，"药物 "10万个字段，"治疗 "10万个字段，"并发症 "10万个字段，等等。作为一个替代方案，你可以创建一个有数千个表的数据库，每个表都代表一个特定的病人类型（它们也可以重叠！）、治疗、药物，以及这些表之间关系的数千个表。
Globals就像一只手套一样适合医疗行业，因为它使每个病人都有完整的病例记录、治疗方法列表、使用的药物及其效果--所有这些都以"树"的形式存在，而不会像关系型数据库那样在空的列上浪费太多的磁盘空间。
当任务是最大限度地积累和系统化关于客户的各种个人数据时，Globals用于记录个人各种细节的数据库非常有效。这对于医疗、银行、营销、档案和其他领域来说尤其重要。
不言而喻，SQL也能让你只用几个表(EAV, 1,2,3,4,5,6, 7,8)来模拟一棵树， 但它要复杂得多，工作速度也慢。从本质上讲，我们必须写一个基于表的Global，并将所有与表有关的routines隐藏在一个抽象层下。用高层技术（SQL）来模拟底层技术（globals）是不正确的
改变巨大的表的数据模式（ALTER TABLE）可能需要相当长的时间，这并不是什么秘密。例如，MySQL在执行ALTER TABLE ADD|DROP COLUMN操作时，会将所有数据从旧表复制到新表（我在MyISAM和InnoDB上测试过）。这可能会使一个有数十亿条记录的生产数据库停滞几天，甚至几周。
如果我们使用globals，改变数据结构对我们来说是没有成本的。我们可以在任何时候向层次结构中任何级别的任何对象添加任何新的属性。需要对分支进行重命名的改变可以在后台模式下应用，同时数据库也会启动并运行。
因此，当涉及到存储具有大量可选属性的对象时，globals工作得非常好！
我也提醒一下各位，对任何一个属性的访问都是即时的，因为在global中，所有的路径都是一个B-tree。
在一般情况下，基于globals的数据库也是一种面向文档的数据库，支持存储分层信息。因此，在存储医疗卡的领域，面向文档的数据库可以有效地与globals竞争。
但是，现在还不完全是这样。
让我们以MongoDB为例。在这个领域，它输给了globals，原因如下：
1.文档大小
存储单元是一个JSON格式的文本（确切地说，是BSON），最大尺寸为16MB左右。引入这个限制的目的是为了确保JSON数据库在解析过程中不会变得太慢，当一个巨大的JSON文档被保存到数据库中时，需要处理特定的字段值。这个文件应该有关于病人的完整信息。我们都知道病人卡可以有多“厚”。如果卡的最大大小被限制在16MB，它就会立即过滤掉卡中包含核磁共振扫描、X光扫描和和其他材料的病人。Global的一个分支可以有数千兆字节和数万兆字节的数据。这算是说明了一切，但我还可以告诉你更多。
2. 创建/改变/删除病人卡上的新属性所需的时间
这样一个数据库需要将整个卡片复制到内存中（大量的数据！），解析BSON数据，添加/改变/删除新的节点，更新索引，将其全部打包回BSON并保存到磁盘。而一个Global只需要寻址必要的属性并执行必要的操作。3.对特定属性的访问速度
如果文档有许多属性和多级结构，对特定属性的访问会更快，因为Global中的每个路径都是B-Tree。在BSON中，你需要对文档进行线性解析以找到必要的属性。
3.3.2 关联数组
关联数组（即使是嵌套数组）可以完美地与globals一起工作。例如，这个PHP数组将看起来像3.3.1中的第一个插图。
$a = array(
"name" => "Vince Medvedev",
"city" => "Moscow",
"threatments" => array(
"surgeries" => array("apedicectomy", "biopsy"),
"radiation" => array("gamma", "x-rays"),
"physiotherapy" => array("knee", "shoulder")
)
);
3.3.3 层次化的文件。XML、JSON
也可以很容易地存储在globals中并以不同的方式进行分解。
XML
将XML分解成globals的最简单方法是将标签属性存储在节点中。而如果你需要快速访问标签属性，我们可以把它们放在单独的分支中。
<note id=5>
<to>Alex</to>
<from>Sveta</from>
<heading>Reminder</heading>
<body>Call me tomorrow!</body>
</note>
在COS中，代码将看起来像这样。
Set ^xml("note")="id=5"
Set ^xml("note","to")="Alex"
Set ^xml("note","from")="Sveta"
Set ^xml("note","heading")="Reminder"
Set ^xml("note","body")="Call me tomorrow!"
注意：对于XML、JSON和关联数组，你可以想出很多方法来在globals中显示它们。在这个特殊的例子中，我们没有在 "note "标签中反映嵌套标签的顺序。在^xml global中，嵌套标签将按字母顺序显示。为了精确地显示顺序，你可以使用下面的模式，比如:
JSON
这个JSON文档的内容显示在第3.3.1节的第一个插图中
var document = {
"name": "Vince Medvedev",
"city": "Moscow",
"threatments": {
"surgeries": ["apedicectomy", "biopsy"],
"radiation": ["gamma", "x-rays"],
"physiotherapy": ["knee", "shoulder"]
},
};
3.3.4 由等级关系约束的相同结构
例子：销售办公室的结构组成，传销组织结构中人的位置，国际象棋的首秀。
关于首秀的数据库。
你可以使用棋力评估作为Global的节点索引的值。在这种情况下，你需要选择一个具有最高权重的分支来确定最佳棋步。在Global中，每一层的所有分支都将按棋力进行排序。
销售办公室的结构，传销公司的人。节点可以存储一些反映整个子树特征的缓存值。例如，这个特定子树的销售人员情况。我们可以在任何时候获得关于任何分支的销售成果的确切信息。
4. 使用globals有好处的情况
第一栏包含了使用globals会在性能方面给你带来相当大的优势的情况列表，第二栏则包含了使用globals会简化开发或数据模型的情况列表。
Speed
数据处理/呈现的便利性
1. 插入[每层都有自动排序]，[通过主键建立索引]。2. 移除子树3. 具有大量嵌套属性的对象，你需要对其进行单独访问4. 分层结构，可以从任何一个分支开始，甚至是不存在的分支，进行子分支的遍历。5.深入的树形遍历
1.具有大量非必需[和/或嵌套]属性/物质的对象/物质
2.无模式的数据--经常可以添加新的属性和删除旧的属性。3.你需要创建一个非标准的DB。4.路径数据库和解决方案树。当路径可以方便地表示为一棵"树“的时候。5.在不使用递归的情况下删除层次结构
下一章继续第三篇，未完待续！（待翻译） "Globals - Magic swords for Storing Data. Sparse Arrays. Part 3"
Disclaimer: this article and my comments on it reflect my opinion only and have nothing to do with the official position of the InterSystems Corporation.
文章
Louis Lu · 一月 19, 2023
这篇文章主要介绍 HL7 V2.5.1 标准是如何定义查询类请求，以及查询类响应的。相关HL7 V2 的更多基础知识可以参考：HL7v2到底是什么?! 的一系列文章。
1 查询标准的发展
1.1 最早的查询模式
最初，HL7的查询参数通过QRD以及QFR 字段传入。因为这两个字段的设计是为了满足所有的查询需求，所以这两个字段的定义非常随意。
1.2 加强的查询模式
从HL7 V2.3开始，引入了加强版的查询模式，它包含了四种方式：
• 嵌入式查询语言类请求查询：自由格式的select SQL语句
• 虚拟表类请求查询：基于特定的select 条件查询服务端的数据库表
• 存储过程类请求查询：执行服务端的存储过程返回数据
• 事件类请求查询：返回基于特定事件的查询结果
1.3 基于2.4 版本的查询
HL 7 v2.3.1之后的版本更清晰地将请求查询的方式与返回查询数据的方式分开，并且强调了“符合性声明”的存在。 HL 7继续支持存储过程、事件查询和虚拟表查询的语义，但推荐使用新的查询方式，即按参数查询（QBP），使语法更清晰。
QBP查询的目的是在一个精确的一致性声明的框架内统一存储过程、事件和虚拟表查询的语义。
同时该标准仍可以继续使用最初模式查询（QRD/QRF），但使用新的查询形式可以更清楚地解释其语义。
2 符合性声明Conformance Statement
符合性声明很像我们熟悉的“接口文档”，在其中定义了哪些数据是可用的，数据将如何被返回，以及哪些变量可以在查询中被赋值以及其约束范围。典型的符合性声明应由下面的内容组成：
介绍部分包含标题、触发事件、模式、特点和目的
查询语法
返回语法
输入规范和注释
返回控制
输出规范和注释
更多符合性声明文档的解释和例子可以参考HL7官方文档。
3 消息格式
正如前面说的，HL 7 v2.3.1之后的版本更清晰地将请求查询的方式与返回查询数据的方式分开，这里重点介绍这两个不同的方式。每种消息的示例会在文章最后给出。
3.1 返回查询结果数据
HL7 定义了三种返回查询结果数据的格式：分段、表格或显示格式。分段格式的响应是由一组HL7段组成。每个查询都会在符合性声明中定义它将返回的HL7片段每个字段的含义。表格式响应是以一组行的形式返回数据，每行一个RDT段。最后的显示查询是以DSP段承载返回数据。
3.1.1 分段响应格式
分段格式的返回是HL7提供数据的传统方式。服务器通过返回HL7段的方式对查询作出响应。例如，对检验数据查询的响应的核心可能由以下分段语法定义。
{
PID
OBR
[{OBX}]。
}
其中，病人信息将在PID段中返回，实验室检验结果在OBR和OBX段中返回。在这种模式下，服务器返回的消息通常与现有的非请求类HL7消息非常接近。
在为分段模式的返回内容定义一致性声明时，数据所有者必须决定它将返回的确切段语法。它应该在必要时阐明每个字段的含义、数据的数量，以及数据是可选的还是必须的。
3.1.2 表格响应格式
表格模式的返回是一个相当传统的由行和列组成的表格。行和列的具体含义会在在该查询的符合性声明中被完整的定义。
当所返回的信息相对简单时，以表格的方式是合适的。但对于涉及复杂的结果嵌套的检验报告来说，它并不是很合适。同时典型的HL7段或段组所携带的数据也可以被建模为一个表格。例如，ADT系统可以将PID、NK1和PV1段拼接到一张表中。但另一方面，在一个单一的表格中包含一个病人的所有就诊历史是很困难的。
3.1.3 显示响应格式
一些情况下，返回的信息不需要被接收的系统保存在数据库里，而只要显示出来就行。
显示响应实际上并不代表组织数据的正式风格。它代表了一个决定，即返回的内容为人类阅读而不是为计算机使用的数据格式。从逻辑上讲，以显示模式返回的内容可能是HL7段模式携带的复杂数据，也可能是由表格模式响应携带的简单记录。
3.2 请求格式
前面介绍的是三种返回查询客户端的方式，现在这里介绍HL7 推荐的三种不同的查询请求方式。
3.2.1 简单参数查询
在简单参数查询中，输入参数在HL7段中连续按顺序传递。 服务器只需要从相应的HL7段中读取它们，并将它们插入到内部函数中执行查询操作。
这是查询的最基本形式，服务端在符合性声明中指定一个固定的参数列表，调用查询时，客户端为每个参数传递一个特定值，这就类似于对数据库调用存储过程并传入参数。
MSH|^~\&|FEH.IVR|HUHA.CSC|HUHA.DEMO||199902031135-0600||QBP^Z58^QBP_Q13|1|D|2.5.1
QPD|Z58^Pat Parm Qry 2|Q502|111069999
RCP|I
3.2.2 示例查询
按示例查询（QBE）是按参数查询（QBP）的扩展，其通过在原本定义的段中发送搜索参数来传递搜索参数，而不是作为QPD段中的字段传递。 例如，如果想要使用QBE执行“查找候选者”查询，则将查询参数保存在PID和或PD 1字段中，并将其中不是查询参数的那些字段留空。 例如，如果宗教不是查询参数之一，则当在查询中发送PID时，PID-17将被留空。 HL 7消息原本定义中不出现的参数，如搜索算法、置信度等， 将继续在QPD段中携带，就像它们在按参数查询一样。 可用作查询参数的确切段和字段将在查询的符合性声明中指定。
MSH|^~\&|FEH.IVR|HUHA.CSC|HUHA.DEMO||199902031135-0600||QBP^Z58^QBP_Q13|1|D|2.5.1
QPD|Z58^Pat Parm Qry 2|Q502
PID|||111069999
RCP|I
3.2.3 选择性查询QSC(Query selection criteria)
第三个方式称为选择性查询QSC，因为它使用了QSC数据类型，而QSC数据类型一般在虚拟表查询中使用。 服务端的符合性声明中将定义客户端可能在表达式中使用的所有变量。 在运行时，客户端能够通过构造类似于“树”节点的方式定义可用的输入参数。 服务端要执行查询，必须可以在运行时分析和解析查询表达式。 服务端可以将输入表达式翻译成它本地可访问数据的语言。 客户端的复杂表达式类似于针对关系数据库的SQL select语句。
MSH|^~\&|FEH.IVR|HUHA.CSC|HUHA.DEMO||199902031135-0600||QBP^Q13^QBP_Q13|1|D|2.5.1
QPD|Z999^Pat Sel Qry 1|Q501|@MedicalRecordNo^EQ^111069999
RCP|I
3.2.4 三种请求格式比较
在使用QSC时，客户端可以选择所提供的任何或所有变量，并且可以为每个变量指定任何允许的运算符和值。 相比之下，在简单参数查询或示例查询中，客户端必须为所提供的所有变量提供值。
简单参数查询易于解析和处理，查询传入参数是预定义好以及有着固定的顺序。 类似地，示例查询也较容易处理，因为参数将出现在定义的段中的固定位置。 相反的，选择性查询需要更多的解析和处理，因为它的灵活性和参数的可选性。 因此，虽然选择性查询向客户端提供了更多功能，但是它对于服务端的处理来说是更繁琐的，简单参数查询和示例查询向客户端提供较少的功能，但通常更易于服务端实现，并且它们往往是基于服务端现有存储过程而提供的。
4 查询返回消息示例
4.1 简单参数查询(QBP)/分段模式返回(RSP)
用户希望查询从1998年5月31日开始到1999年5月31日结束的时间段内，为病历号为“555444222111”的患者分配的所有药物。 使用以下简单参数查询请求消息：
MSH|^~\&|PCR|Gen Hosp|PIMS||199811201400-0800||QBP^Z81^QBP_Q11|ACK9901|P|2.5.1||||||||
QPD|Z81^Dispense History^HL7nnnn|Q001|555444222111^^^MPI^MR||19980531|19990531|
RCP|I|999^RD|
药房系统识别属于Adam Everyman的医疗记录号“555444222111”，并定位从1998年5月31日开始到1999年5月31日结束的时间段内有4次处方配药，并返回以下RSP消息：
MSH|^~\&|PIMS|Gen hosp|PCR||199811201400-0800||RSP^Z82^RSP_Z82|8858|P|2.5.1||||||||
MSA|AA|ACK9901|
QAK|Q001|OK|Z81^Dispense History^HL7nnnn|4|
QPD|Z81^Dispense History^HL7nnnn|Q001|555444222111^^^MPI^MR||19980531|19990531|
PID|||555444222111^^^MPI^MR||Everyman^Adam||19600614|M||C|2222 HOME STREET^^Oakland^CA^94612||^^^^^555^5552004|^^^^^555^5552004|||||34313 2266|||N|||||||||
ORC|RE||89968665||||||199805121345-0700|||77^Hippocrates^Harold^H^III^DR^MD||^^^^^555^ 5552104||||||
RXE|1^BID^^19980529|00378112001^Verapamil Hydrochloride 120 mg TAB^NDC|120||mgm||||||||||||||||||||||||||
RXD|1|00378112001^Verapamil Hydrochloride 120 mg TAB^NDC |199805291115-0700|100|||1331665|3|||||||||||||||||
RXR|PO||||
ORC|RE||89968665||||||199805291030-0700|||77^Hippocrates^Harold^H^III^DR^MD||^^^^^555^555-5001||||||
RXE|1^^D100^^20020731^^^TAKE 1 TABLET DAILY --GENERIC FOR CALANSR|00182196901^VERAPAMIL HCL ER TAB 180MG ER^NDC |100||180MG|TABLETSA|||G|||0|BC3126631^CHU^Y^L||213220929|0|0|19980821|||
RXD|1|00182196901^VERAPAMIL HCL ER TAB 180MG ER^NDC|19980821|100|||213220929|0|TAKE 1 TABLET DAILY --GENERIC FOR CALANSR||||||||||||
RXR|PO||||
ORC|RE||235134037||||||199809221330-0700|||8877^Hippocrates^Harold^H^III^DR^MD||^^^^^555^555-5001||||||RXD|1|00172409660^BACLOFEN 10MG TABS^NDC|199809221415-0700|10|||235134037|5|AS DIRECTED||||||||||||
RXR|PO||||
ORC|RE||235134030||||||199810121030-0700|||77^Hippocrates^Harold^H^III^DR^MD||^^^^^555^555-5001||||||
RXD|1|00054384163^THEOPHYLLINE 80MG/15ML SOLN^NDC|199810121145-0700|10|||235134030|5|AS DIRECTED||||||||||||
RXR|PO
4.2 简单参数查询(QBP)/表格模式返回(RTB)
用户希望获取病历号为“555444222111”的患者的身份信息。使用简单参数查询
MSH|^~\&|PCR|GenHosp|MPI||199811201400-0800||QBP^Z91^QBP_Q13|8699|P|2.5.1||||||||
QPD|Z91^WhoAmI^HL7nnnn|Q0009|555444222111^^^MPI^MR
RCP|I|999^RD|
RDF|PatientList^CX^20~PatientName^XPN^48~Mother’sMaidenName^XPN^48~DOB^TS^26~Sex^IS^1~Race^CE^80|
以表格方式返回查询结果：
MSH|^~\&|MPI|GenHosp|PCR||199811201400-0800||RTB^Z92^RTB_K13|8699|P|2.5.1||||||||
MSA|AA|8699|
QAK|Q0009|OK|Z91^WhoAmI^HL7nnnn|1^1|
QPD|Z91^WhoAmI^HL7nnnn|Q0009|555444222111^^MPI^MR
RDF|PatientList^CX^20~PatientName^XPN^48~Mother’sMaidenName^XPN^48~DOB^TS^26~Sex^IS^1~Race^CE^80|
RDT|555444222111^^^MPI^MR|Everyman^Adam||19600614|M||
4.3 简单参数查询(QBP)/显示模式返回(RDY)
用户希望了解从1998年5月31日开始到1999年5月31日结束的时间段内，为病历号为“555444222111”的患者分配的所有药物。请求消息：
MSH|^~\&|PCR|Gen Hosp|PIMS||199909171400-0800||QBP^Z97^QBP_Q15|8699|P|2.5.1||||||||
QPD|Z97^DispenseHistoryDisplay^HL7nnnn|Q005|555444222111^^^MPI^MR||19980531|19990531|
RCP|I|999^RD|
返回消息：
MSH|^~\&|PIMS|Gen Hosp|PCR||199909171401-0800||RDY^Z98^RDY_K15|8858|P|2.5.1||||||||
MSA|AA|8699|
QAK|Q005|OK|Z97^DispenseHistoryDisplay|4
QPD|Z97^DispenseHistoryDisplay^HL7nnnn|Q005|555444222111^^^MPI^MR||19980531|19990531|
DSP|| GENERAL HOSPITAL – PHARMACY DEPARTMENT DATE:09-17-99
DSP|| DISPENSE HISTORY REPORT Page 1
DSP||MRN Patient Name MEDICATION Dispense DISP-DATE
DSP||555444222111 Everyman,Adam VERAPAMIL HCL 120 mg TAB 05/29/1998
DSP||555444222111 Everyman,Adam VERAPAMIL HCL ER TAB 180MG 08/21/1998
DSP||555444222111 Everyman,Adam BACLOFEN 10MG TABS 09/22/1998
DSP||555444222111 Everyman,Adam THEOPHYLLINE 80MG/15ML SOL 10/12/1998
DSP|| << END OF REPORT >>
4.4 示例查询(QBP)/表格模式返回(RTB)
客户希望查看人口统计学资料如下的患者列表：
姓名：张三
性别：男
生日： 1948年12月11日
客户希望使用peekaboo算法，以及满足80%置信水平。
请求消息：
MSH|^~\&|PCR|GenHosp|MPI||199811201400-0800||QBP^Z77^QBP_Q13|8699|P|2.5.1||||||||
QPD|Z77^find_candidates^HL7nnnn|Q0001|peekaboo|80|
PID|||||张&三||19481211|M
RCP|I|25^RD|
RDF|PatientList^CX^20~PatientName^XPN^48~Mother’sMaidenName^XPN^48~DOB^TS^26~Sex^IS^1~Race^CE^80|
返回消息：
MSH|^~\&|MPI|GenHosp|PCR||199811201400- 0800||RTB^Z78^RTB_R13|8699|P|2.5.1||||||||
MSA|AA|8699|
QAK|
QPD|Z77^find_candidates^HL7nnnn|Q0001|peekaboo|80|
RDF|PatientList^CX^20~PatientName^XPN^48~Mother’sMaidenName^XPN^48~DOB^TS^26~Sex^IS^1~Race^CE^80|
RDT|555444222111^^^MPI&KP.NCA&L^MR|张^三||19481211|M||
4.5 选择性查询/表格模式返回(RTB)
用户希望了解从1998年5月31日开始到1999年5月31日结束的时间段内，为病历号为"555444222111"的患者分配的所有药物。 将生成以下消息。
请求消息：
MSH|^~\&|PCR|Gen Hosp|PIMS||199811201400-0800||QBP^Z95^QBP_Q13|8699|P|2.5.1||||||||
QPD|Z95^Dispense Information^HL7nnnn|Q504|PID.3^EQ^55544422211^AND~RXD.3^GE^19980531^AND~RXD.3^LE^19990531
RCP|I|999^RD|
RDF|3|PatientList^ST^20~PatientName^XPN^48~OrderControlCode^ID^2~OrderingProvider^XCN^120~MedicationDispensed^ST^40~DispenseDate^TS^26~QuantityDispensed^NM^20|
返回消息：
MSH|^~\&|PIMS|Gen Hosp|PCR||199811201400-0800||RTB^Z96^RTB_K13|8858|P|2.5.1||||||||
MSA|AA|8699|
QAK|Q001|OK|Z95^Dispense Information^HL7nnnn|4
QPD|Z95^Dispense Information^HL7nnnn|Q504|PID.3^EQ^55544422211^AND~RXD.3^GE^19980531^AND~RXD.3^LE^19990531
RDF|3|PatientList^ST^20~PatientName^XPN^48~OrderControlCode^ID^2~OrderingProvider^XCN^120~MedicationDispensed^ST^40~DispenseDate^TS^26~QuantityDispensed^NM^20|
RDT|555444222111^^^MPI^MR|Everyman^Adam|RE|77^Hippocrates^Harold^H^III^DR^MD |525440345^Verapamil Hydrochloride 120 mg TAB^NDC |199805291115-0700|100
RDT|555444222111^^^MPI^MR|Everyman^Adam|RE|77^Hippocrates^Harold^H^III^DR^MD |00182196901^VERAPAMIL HCL ER TAB 180MG ER^NDC|19980821-0700|100
RDT|555444222111^^^MPI^MR|Everyman^Adam|RE|88^Seven^Henry^^^DR^MD|00172409660^BACLOFEN 10MG TABS^NDC |199809221415-0700|10
RDT|555444222111^^^MPI^MR|Everyman^Adam|RE|99^Assigned^Amanda^^^DR^MD|00054384163^THEOPHYLLINE 80MG/15ML SOLN^NDC|199810121145-0700|10
5 InterSystems IRIS 对于HL7 V2.x 的支持
5.1 内置 HL7 V2.x 文档
方便随时查看HL7 V2.x 各个字段、节点的含义、限制以及可用字典表定义
可以方便的打开一个HL7 V2.x 文档，鼠标悬停就可以看到该字段的解释：
5.2 互操作性
5.2.1 内置的数据转化工具：使用鼠标拖拽就可以进行数据格式的转换
5.2.2 HL7 消息路由编辑器: 图形化页面设置，方便根据HL7 消息字段内容将消息发送到不同目标
5.2.3 消息追踪器：方便追踪在平台中的经过数据的流向
文章
Hao Ma · 六月 13, 2023
在维护IRIS的镜像前，管理员需要清楚的了解以下一些概念：
## Mirror的切换模式(failover mode)
切换模式在镜像监视器里被翻译成”故障转移模式“。 有两种模式：
- Agent Controlled模式：
- Arbiter Controlled模式：(页面上翻译为“仲裁程序受控制”)
通常情况，生产环境的镜像是安装了arbiter(仲裁者)的。Mirror启动时，在还没有连接上arbiter的时候，自动进入Agent-Controlled模式。而后当两台机器，主机，备机都连通了Arbiter，会保持在这个模式。
- 主备之间有连接；
- 又都连到arbiter;
- backup is active,
满足上面的条件，就进入arbiter controlled mode。而如果主备的任一方，失去了和arbiter的连接，或者备用侧丢了active, 开始尝试连接另一方，退回到agent-controlled模式。
## Mirror同步成员的状态
[Mirror Member Journal Transfer and Dejournaling Status](https://docs.intersystems.com/irisforhealth20231/csp/docbook/DocBook.UI.Page.cls?KEY=GHA_mirror_manage#GHA_mirror_set_status). 请注意，这里面有两个概念：一个是**Mirror成员的状态**，一个是**Journal传输和Dejournaling的状态**。下面的图中是3个字段： STATUS, Journal传输，Dejournaling.
**STATUS**
镜像成员的状态。 正常工作状态
- 对于同步成员，是Primary(主)， Backup(备机)。
- 对于异步成员，正常状态是Connected(已连接)
- In Trouble : 如果主机In Trouble, 是失去了到backup的连接。备机收到主机的同步数据是要返回证实(Ack)消息的。一旦出现问题，主机无法收到备机的Ack， 主机就会把备机标为"In trouble", 从此再也不会向备机发同步数据。
- Transition: 暂时状态，进程正在查看一个成员的状态，很快会转换到一个稳定状态。 如果在mirror配置的member中发现了primary，本机会进入Synchronizing状态，否则自己会尝试进入primary状态。
- Sychronizing: 从Primary接收journal，同步数据库。
## Journal Transfer and Dejournaling Status
Journal Transfer是主机向其他成员发送Journal文件。而Dejournal是把Journal文件读入数据库。 对于backup或者asycn成员，**Journal Transfer**状态表示镜像成员是否有来自主数据库的最新日志数据，如果没有，则表示日志传输的落后程度，**Dejournaling**表示从主数据库收到的所有日志数据是否已经被dejournaled（应用到成员的镜像数据库），如果没有，则表示dejournaling的落后程度。
上图中显示的是正常的状态，其中主机 Journal Transfer 和 Dejournaling 都是N/A, 表示不适用。
对于其他成员，我们分开看：
Journal Transfer状态
- Active: backup的正常状态。说明backup从primary收到了最新的journal。注意哪怕是Dejournal状态只是“x秒落后“，而不是"被捕获"，Journal Transfer状态也可以是Active，只要是从主机收到了最新的Journal更新。
- Caught up(被捕获) : 备机被捕获状态，说明备机从主机收到了最新的journal数据，但主机没有在等待备机的证实消息。 这通常是一个暂时的过程，当备机在连接主机的时候会出现。 异步成员，因为不需要向主机发证实，所以正常的状态就是“被捕获”
If the Primary Failover Member does not receive an acknowledgment from the Backup every Heartbeat Interval period, it demotes the Backup system from Active status to Catch-Up mode.
- time behind (多少秒落后)
- Disconnected on time（断开）: 在一个时间点上这个成员和primary断开了。
Dejournaling状态
- Caught up
- time behind
- Disconnected on time
- Warning! Some Databases need attention
- Wanring! Dejournaling is stopped
**正常状态下的图；**
备机Backup MirrorB, Journal Transfer是Active, Dejournaling是Caught up, 异步机器MirrorDR的Journal Transfer状态和Dejournaling状态都是Caught up. 表示它们收到了最新的journal数据，并且也都把最新的global修改写入了自己的数据库。
## Mirror的自动切换
Mirror的核心是自动切换。Backup接替主机的工作有两个前提：1. 备机在同步（Active) 状态, 2. 主机不能正常工作。在这两个前提下，我们来看看自动切换的触发条件，涉及主机，备机，仲裁机之间的通信，
**自动切换触发条件**
1. Primary要求Backup接替。这种情况，主机会发生一个请求消息给备机， 要求备机接替。
- 主机IRIS正常退出
- 主机发现自己hung
2. 备机收到arbiter的请求，报告失去了到主机的连接。
仲裁机要求是和外部系统以及应用服务器部署在一个网段的。如果仲裁机无法联络主机，可以认为其他的应用系统和服务器也无法连接主机。有可能主机宕机， 也有可能主机还在正常工作，但外界已经无法联络它了， 这时候也是需要备机接手的。
这时备机也要再去核实一下，是不是能联络到主机。如果能联络到， 备机会发请求让主机Down。如果不能， 说明主机要么死了， 要么失联了， 备机先接手，等联络上再让对方force down.
3. 从主机的ISCAgent收到消息，报告Primary已经down or hung.
在agent-controlled的情况。 primary的服务器还活着。备机主动去问主机的agent, 一旦agent报告主机死了， 那备机就可以上位了。
## Mirror的进程
管理员应该了解mirror涉及的那些进程。当出现故障时，这些进程名字，或者称为User， 经常会出现在message log记录的故障描述中。
On Primary Failover Member(主机)
我们来一个个的看看这些进程：
- Mirror Master: 系统启动时自动启动，负载mirror control 和管理。
- Mirror Primary: 出向数据传输通道。 上图中有两个Mirror Primary进程，状态时RUNW, 一个连接MirrorB, 一个连接MirrorDR.
- Mirror Svr: Rd*: 入向证实通道(inbound acknowledgement)， 也是单向的。 上图中同样有两个此进程，状态都是READ, IP地址分别是MirrorB和MirrorDR.
- Mirror Arbiter: 到aibiter的通信进程，注意它的状态是"EVTW", 也是个单向写的频道。
On Backup Member/Async member(备机)
Mirror Masht, Mirror Arbiter不再重复解释，我们看看其他进程是干什么的。
- Mirror JrnRead: Mirror Journal从Primary发送到backup是先写到硬盘的。 JrnRead进程把收到的journal同步读到内存里，然后才进行下一步，Dejournal的工作。
- Mirror Dejour: backup机器的dejournal job进程。它把从Primary收到的journal中记录的global改变(set and kill)保存到本机的镜像数据库。
- Mirror Prefetch: 这个稍微有点难懂。当收到的journal修改中包括了使用当前backup的journal中已有的内容时，比如收到了一个修改：set ^A=^B+1, 而^B当前存在backup里， Prefetch进程会把^B从硬盘拿到内存，以加快dejournal的速度。
- Mirror Backup: two-way channel， 把收到的primary的journal写到backup的mirror journal，并且返回证实(ACK)
这里我省略了在DR上的进程，如果有兴趣，请自己查看文档。
## MIRROR状态的监控
根据不同的场景，查看Mirror的状态有以下几种途径
### **[使用镜像监视器](https://docs.intersystems.com/iris20231/csp/docbook/DocBook.UI.Page.cls?KEY=GHA_mirror_manage#GHA_mirror_monitor_portal)**
### 使用^MIRROR
如果您只是要简单的获得Mirror成员的状态，最直接的方法是使用^Mirror程序。 我们先看看在IRIS Terminal下^MIRROR的执行。
```bash
%SYS>do ^MIRROR
1) Mirror Status
2) Mirror Management
3) Mirror Configuration
Option? 1
1) List mirrored databases
2) Display mirror status of this node
3) Display journal file info
4) Status Monitor
Option? 4
Status of Mirror MIRRORTEST at 08:09:24 on 05/19/2023
Arbiter Connection Status:
Arbiter Address: arbiter|2188
Failover Mode: Agent Controlled
Connection Status: This member is not connected to the arbiter
Journal Transfer
Member Name+Type Status Latency Dejournal Latency
-------------------------- --------- --------------- --------------
MIRRORA
Failover Primary N/A N/A
Press RETURN to refresh, D to toggle database display, Q to quit,
or specify new refresh interval D
Database display is now on
Status of Mirror MIRRORTEST at 08:09:29 on 05/19/2023
Arbiter Connection Status:
Arbiter Address: arbiter|2188
Failover Mode: Agent Controlled
Connection Status: This member is not connected to the arbiter
Journal Transfer
Member Name+Type Status Latency Dejournal Latency
-------------------------- --------- --------------- --------------
MIRRORA
Failover Primary N/A N/A
Mirror Databases:
Record To
Name Directory path Status Dejournal
------------- ----------------------------------- ----------- -----------
TEST /isc/mirrorA/TESTDB/ Normal N/A
Press RETURN to refresh, D to toggle database display, Q to quit,
or specify new refresh interval
```
**在操作系统中执行^MIRROR**
您可以把以下的代码写入您的脚本语言，查看mirror的状态
```bash
irisowner@mirrorA:~$ iris session iris -U "%sys" "Monitor^MIRROR"
Status of Mirror MIRRORTEST at 02:57:08 on 06/13/2023
Arbiter Connection Status:
Arbiter Address: arbiter|2188
Failover Mode: Arbiter Controlled
Connection Status: Both failover members are connected to the arbiter
Journal Transfer
Member Name+Type Status Latency Dejournal Latency
-------------------------- --------- --------------- --------------
MIRRORA
Failover Primary N/A N/A
MIRRORB
Failover Backup Active Caught up
MIRRORDR
Disaster Recovery Connected Caught up Caught up
Press RETURN to refresh, D to toggle database display, Q to quit,
or specify new refresh interval q
Doneirisowner@mirrorA:~$
```
或者更简单的，只查看本机的mirror成员状态：
```bash
irisowner@mirrorA:~$ iris session iris -U "%sys" "LocalMirrorStatus^MIRROR"
This instance is a Failover member
Status for mirror MIRRORTEST is "Primary"
Current mirror file #2 ends at 681224
Min trans file #2 min trans index: 680744
irisowner@mirrorA:~$
```
如果您熟悉ObjectScript， 也可以使用`$SYSTEM.Mirror`类的各个method来查看：
```bash
irisowner@mirrorB:~$ echo "write \$SYSTEM.Mirror.GetMemberStatus(),! halt" |iris session iris -U "%sys"
Node: mirrorB, Instance: IRIS
%SYS>
Backup
irisowner@mirrorB:~$
```
如果您要查看更多的内容，您可以更多的使用%SYSTEM.Mirror类的其他方法，比如%SYSTEM.Mirror.GetFailoverMemberStatus(.pri,.alt)， $SYSTEM.Mirror.ArbiterState()等等。
### 使用Mirror_MemberStatusList存储过程
如果您从第3方的工具查询mirror成员的状态，还有一个简单的方案，就是调用%SYS命名空间的存储过程。下图是从iris管理门户调用的截图，你可以使用任何SQL客户端调用。
如果是从iris里执行，
```
%SYS>do ##class(%ResultSet).RunQuery("SYS.Mirror","MemberStatusList")
Member Name:Current Role:Current Status:Journal Transfer Latency:Dejournal Latency:Journal Transfer Latency:Dejournal Latency:Display Type:Display Status:
MDCHCNDBSL1.HICGRP.COM/STAGE:Primary:Active:N/A:N/A:N/A:N/A:Failover:Primary:
MDCHCNDBSL2.HICGRP.COM/STAGE:Backup:Active:Active:Caught up:Active:Caught up:Failover:Backup:
CDCHCNDRSL.HICGRP.COM/STAGE:Async:Async:Caught up:Caught up:Caught up:Caught up:Disaster Recovery:Connected:
```
### 通过SNMP获得
如果使用监控工具，您可以通过SNMP获得Mirror的状态，下面是最新的ISC-IRIS.mib中有关Mirror得指标部分。
```
.4.1.12 = irisMirrorTab | Table of current Mirror Members status and information
-- .4.1.12.1 = irisMirrorRow | Conceptual row for Mirror status and metrics | INDEX = irisSysIndex, irisMirrorIndex
-- .4.1.12.1.1 = irisMirrorIndex | unique index for each Mirror Member | INTEGER
-- .4.1.12.1.2 = irisMirrorName | Name of the mirror this system is a member of | STRING
-- .4.1.12.1.3 = irisMirrorMember | Mirror member name | STRING
-- .4.1.12.1.4 = irisMirrorRole | "Primary", "Backup", or "Async". | STRING
-- .4.1.12.1.5 = irisMirrorStatus | "Active" or "Activate". | STRING
-- .4.1.12.1.6 = irisMirrorJrnLatency | Mirror journal latency "Caught up", "Catchup", or "N/A". | STRING
-- .4.1.12.1.7 = irisMirrorDBLatency | Mirror database latency "Caught up", "Catchup", or "N/A". | STRING
```
## MIRROR的日志和告警
通常情况下， 维护人员是通过mirror的日志和警告来获得Mirror状态，Mirror成员之间的连接情况，而不必须定时的用命令或者调用存储过程来查看。
Cache'和IRIS的日志和警告保存在两个文件： console.log/messages.log和alert.log， 其中alert.log中记录了console.log/messages.log中级别为2，3的记录， 并必须实时发送给管理员。有关这部分内容，请参考在线文档，或者我的帖子：
我们来看看在日志中有哪些mirror的记录：
**Becoming primary mirror server**
系统固有的通知消息， level =2。当一个iris实例从备机变成了主机，此信息会写到此实例的alert.log, 同时发送给管理员。 可以查看这个[链接](https://docs.intersystems.com/iris20231/csp/docbook/DocBook.UI.Page.cls?KEY=GCM_monitor#GCM_monitor_errors)。
在Mirror切换时，管理员除了从刚刚接手的机器中收到Becoming primary mirror server的通知。如果原来的主机没有宕机或者从宕机中恢复，它也会将引起切换的故障从alert.log发送给管理员，是一个level2, 或者level3的记录。
**Arbiter connection lost**
level =2 , 自动发送给管理员。 当主机和arbiter失去连接后，在主机上会出现此警告。此时在备机上会出现“Switched from Arbiter Controlled to Agent Controlled failover on request from primary”的提示，是个level0的信息。
**MirrorServer: Connection to xxxx(backup) terminated**
**MirrorServer: Connection to MIRRORDR (async member) terminated**
当主机和备机(backup)失去连接，在主机上会出现level2的警告。 而和异步成员丢失连接，主机会出现level1的消息。尽管level1的消息不能自动通知管理员，但这时如果同时监控该异步成员的alert.log, 通常会有level2的警告消息发出，能提醒管理员检查MIRRORDR这个镜像成员的状态。
举例说明：如果在MirrorDR中操作系统重启，IRIS启动后会出现这样的level2的警告：“Previous system shutdown was abnormal, ^SHUTDOWN forced down”
**Async member for MirrorSetName started but failed to connect to primary**
level =2 , 自动发送给管理员
其他更多的关于Mirror出错的level2, 也就是警告记录, 比如：
- Could not open mirror journal log to read checksum, errno = 2
- Preserving all mirror journal files for offline failover member
- Server^MIRRORCOMM(d): Failed to notify MIRRORB for mirror configuration change
- Failed to become either Primary or Backup at startup
这不是个完整的列表，实际环境中会出现各种各样的告警通知。读懂这些通知，需要管理员了解镜像的原理，架构，以及上面介绍的镜像状态和进程的功能。
除此之外，绝大多数的level2日志的同时，会有更多的level0,level1的有关mirror变化的记录。这些内容不需要通知管理员，只是用于分析问题。 如图，下面是在一个messages.log里一个iris从备机变成主机的过程。
```
06/13/23-07:16:25:472 (2189) 0 [Generic.Event] MirrorClient: Switched from Arbiter Controlled to Agent Controlled failover on request from primary
06/13/23-07:16:26:274 (2189) 1 [Generic.Event] MirrorClient: Mirror_Client: Primary closed down, last # read = 504
06/13/23-07:16:26:301 (2189) 0 [Generic.Event] MirrorClient: Backup waiting for old Dejournal Reader (pid: 2190, job #31) to exit
06/13/23-07:16:27:394 (2189) 0 [Generic.Event] MirrorClient: Set status for MIRRORTEST to Transition
06/13/23-07:16:28:477 (1996) 0 [Utility.Event] [SYSTEM MONITOR] Mirror status changed. Member type = Failover, Status = Transition
06/13/23-07:16:30:261 (2177) 0 [Utility.Event] Returning to restart, old primary reported: "DOWN
06/13/23-07:16:31:524 (11721) 0 [Utility.Event] Applying journal data for mirror "MIRRORTEST" starting at 1538184 in file #2(/isc/mirrorB/mgr/journal/MIRROR-MIRRORTEST-20230613.001)
06/13/23-07:16:31:804 (2177) 0 [Utility.Event] Manager initialized for MIRRORTEST
06/13/23-07:16:31:986 (2177) 0 [Utility.Event] MIRRORA reports it is DOWN, becoming primary mirror server
06/13/23-07:16:32:381 (2177) 0 [Generic.Event] INTERSYSTEMS IRIS JOURNALING SYSTEM MESSAGE
Journaling switched to: /isc/mirrorB/mgr/journal/MIRROR-MIRRORTEST-20230613.002
06/13/23-07:16:32:426 (2177) 0 [Utility.Event] Scanning /isc/mirrorB/mgr/journal/MIRROR-MIRRORTEST-20230613.001
06/13/23-07:16:32:479 (2177) 0 [Utility.Event] No open transactions to roll back
06/13/23-07:16:32:485 (2177) 0 [Generic.Event] MirrorServer: New primary activating databases which are current as of 1538184 (0x00177888) in mirror journal file #2
06/13/23-07:16:32:488 (2177) 0 [Generic.Event] Changed database /isc/mirrorB/TESTDB/ (SFN 5) to read-write due to becoming primary.
06/13/23-07:16:32:924 (2177) 0 [Utility.Event] Initializing Interoperability during mirror initialization
06/13/23-07:16:32:930 (2177) 2 [Utility.Event] Becoming primary mirror server
```
更多的有关mirror监控和排除的问题， 请各位留言。 谢谢
文章
Michael Lei · 七月 4, 2023
这是个实验项目，使用OpenAI API与FHIR资源和Python相结合来回答医疗行业的用户提问。
## 项目想法
生成式人工智能，如[OpenAI上提供的LLM模型](https://platform.openai.com/docs/models), 已被证明在理解和回答高层次问题方面具有显著能力。他们使用大量的数据来训练他们的模型，因此他们可以回答复杂的问题。
他们甚至可以[使用编程语言，根据提示创建代码](https://platform.openai.com/examples?category=code) --我不得不承认，让我的工作自动化的想法让我感到有些焦虑。但到目前为止，似乎这是人们必须要习惯的事情，不管你喜不喜欢。所以我决定做一些尝试。
这个项目的主要想法是在我读到[这篇文章](https://the-decoder.com/chatgpt-programs-ar-app-using-only-natural-language-chatarkit/)关于[ChatARKit项目](https://github.com/trzy/ChatARKit)时产生的。这个项目使用OpenAI的API来解释语音命令，在智能手机摄像头的实时视频中渲染3D物体--非常酷的项目。而且，这似乎是一个热门话题，因为我发现最近有一篇[论文](https://dl.acm.org/doi/pdf/10.1145/3581791.3597296)遵循类似的想法。
让我最担心的是使用ChatGPT对AR进行**编程。由于有一个开放的github repo，我搜索了一下，发现[作者是如何使用ChatGPT生成代码的](https://github.com/trzy/ChatARKit/blob/master/iOS/ChatARKit/ChatARKit/Engine/ChatGPT.swift)。这种技术被称为*提示工程Prompt Engineering*--[这是维基百科关于它的文章](https://en.wikipedia.org/wiki/Prompt_engineering)，或者这两个更实用的参考资料： [1](https://microsoft.github.io/prompt-engineering/)和[2](https://learn.microsoft.com/en-us/azure/cognitive-services/openai/concepts/advanced-prompt-engineering?pivots=programming-language-chat-completions)。
所以我想--为什么不结合FHIR和Python试试类似的东西？以下是我的想法：
其主要构成是：
- 一个提示工程模块，将命令人工智能模型使用FHIR和Python
- 一个OpenAI API集成模块
- 一个Python解释器，用于执行生成的代码
- 一个FHIR服务器，回答人工智能模型生成的查询
基本思路是使用[OpenAI Completion API](https://platform.openai.com/docs/api-reference/completions)，要求人工智能将问题分解为一堆FHIR查询。然后，人工智能模型创建一个Python脚本来处理InterSystems IRIS for Health中FHIR服务器返回的FHIR资源。
如果这个简单的设计是有效的，用户就可以得到应用的分析模型尚未支持的问题的答案。此外，这些由人工智能模型回答的问题可以被分析，以发现对用户需求的新见解。
这种设计的另一个好处是，你不需要用外部的API暴露你的数据和模型。例如，你可以问关于病人的问题，而不需要将病人数据或你的数据库模式发送到人工智能服务器上。由于人工智能模型使用公共可用的功能--FHIR和Python，你也不需要发布内部数据。.
但是，这种设计也导致了一些问题，比如：
- 如何引导人工智能根据用户需求使用FHIR和Python？
- 人工智能模型产生的答案是否正确？是否有可能对它们有信心？
- 如何处理运行外部生成的Python代码的安全问题？
因此，为了尝试解决一下这些问题，我对最初的设计做了一些阐述，得到了这个：
我在项目里增加了一些新的元素：
- 一个代码分析器来扫描安全问题
- 一个日志记录器，用于记录重要事件，以便进行进一步分析
- 一个用于进一步整合的API REST
因此，这个项目旨在验证这个概念，它可以支持实验来收集信息，以尝试回答这些问题。
在接下来的章节中，你会发现如何安装该项目并试用它。
然后，你会看到我在尝试回答上述问题时得到的一些结果和一些结论。
希望你觉得它有用。我们也非常欢迎你为这个项目做出贡献！
## 项目尝试
要试一试，请打开IRIS终端，运行以下内容：
```objectscript
ZN "USER"
Do ##class(fhirgenerativeai.FHIRGenerativeAIService).RunInTerminal("")
```
例如，以下问题被用来测试该项目：
1. 数据集里有多少病人？
2. 病人的平均年龄是多少？
3. 给我所有的条件（代码和名称），去除重复的。将结果以表格的形式呈现出来。(不要使用pandas)
4. 有多少病人患有病毒性鼻窦炎（代码444814009）？
5. 病毒性鼻窦炎（代码444814009）在患者群体中的流行率是多少？对于多次出现相同病情的患者，考虑只打一次就可以计算出来。
6. 在病毒性鼻窦炎（代码444814009）患者中，性别组的分布是怎样的？
你可以找到这些问题的输出例子[这里](https://github.com/jrpereirajr/iris-fhir-generative-ai/blob/master/misc/tests-accuacy)。
> 请注意，如果你在你的系统上尝试，结果可能会有所不同，即使你使用相同的提示。这是由于LLM模型的随机性。
这些问题是由ChatGPT提出的。他们要求这些问题是以复杂程度不断提高的方式来创建的。第3个问题是个例外，它是由作者提出的。
## 提示工程Prompt Engineering
项目使用的提示Prompt可以在方法`GetSystemTemplate()`中找到[这里](https://github.com/jrpereirajr/iris-fhir-generative-ai/blob/master/src/fhirgenerativeai/PromptService.cls)。
它遵循提示工程的指南，首先你给人工智能模型分配一个角色，然后输入一堆限制条件和指令。它的每个部分的意图都有注释，所以你可以理解它是如何工作的。
请注意一种接口定义的使用，当模型被指示假设一个已经定义好的名为`CallFHIR()`的函数与FHIR交互，而不是自己声明一些东西。这是受ChatARKit项目的启发，作者在该项目中定义了一整套函数，为使用AR库抽象出复杂的行为。
在这里，我使用这个技术来避免直接创建代码进行HTTP调用的模式。
这里一个有趣的发现是关于强迫人工智能模型以XML格式返回其响应。由于打算返回的是Python代码，我在XML中使用了CDATA块，将其对称化。
尽管在提示中明确指出响应格式必须是XML格式，但在以XML格式发送用户提示后，AI模型就开始遵循这个指令。你可以在上面提到的同一个类中的`FormatUserPrompt()`方法中看到这一点。
## 代码分析器
该模块使用[bandit库](https://bandit.readthedocs.io/en/latest/)来扫描安全问题。
这个库生成Python程序的AST，并针对常见的安全问题对其进行测试。你可以在这些链接中找到被扫描的问题种类：
- [测试插件](https://bandit.readthedocs.io/en/latest/plugins/index.html#complete-test-plugin-listing)
- [调用黑名单](https://bandit.readthedocs.io/en/latest/blacklists/blacklist_calls.html)
- [导入黑名单](https://bandit.readthedocs.io/en/latest/blacklists/blacklist_imports.html)
由人工智能模型返回的每一个Python代码都会针对这些安全问题进行扫描。如果发现有问题，就会取消执行并记录错误。
## 日志记录器
所有的事件都被记录下来，以便在表[LogTable](https://github.com/jrpereirajr/iris-fhir-generative-ai/blob/master/src/fhirgenerativeai/LogTable.cls)中作进一步分析。
每个回答问题的运行都有一个会话ID。你可以在表中的'SessionID'列中找到它，并通过将它传递给方法`RunInTerminal("", )`来获得所有事件。例如：
```objectscript
Do ##class(fhirgenerativeai.FHIRGenerativeAIService).RunInTerminal("", "asdfghjk12345678")
```
你也可以用这个SQL来检查所有的日志事件:
```sql
SELECT *
FROM fhirgenerativeai.LogTable
order by id desc
```
## 测试
我执行了一些测试以获得信息来衡量人工智能模型的性能。
每个测试执行了15次，它们的输出被存储在[this](https://github.com/jrpereirajr/iris-fhir-generative-ai/blob/master/misc/tests-accuacy)和[this](https://github.com/jrpereirajr/iris-fhir-generative-ai/blob/master/misc/tests-security)的目录下。
> 请注意，如果你在你的系统上尝试，结果可能会有所不同，即使你使用相同的提示。这是由于LLM模型的随机性。
### 准确率
对于问题#1的测试，有`14个结果6`和`1个错误`。正确值是`6'。所以它是`100%`正确的，但有`6%`的执行失败。
验证#1结果的SQL语句:
```sql
SELECT
count(*)
FROM HSFHIR_X0001_S.Patient
```
对于第2题的测试，有`3个结果52`，`6个结果52.5`和`6个错误`。正确的数值--考虑到有小数点的年龄，是`52.5'。所以我认为这两个值都是正确的，因为这一点差异可能是由于提示不明确造成的--它没有提到任何关于允许或不允许带小数的年龄。因此，它是`100%`正确的，但执行失败的是`40%`。
验证#2结果的SQL语句:
```sql
SELECT
birthdate, DATEDIFF(yy,birthdate,current_date), avg(DATEDIFF(yy,birthdate,current_date))
FROM HSFHIR_X0001_S.Patient
```
在第3个问题的测试中，有 "3个错误 "和 "12个有23个不同元素的表格"。表的值不在相同的位置和格式中，但我还是认为这因为错误格式的提示造成的。因此，它是`100%`正确的，但有`20%`的执行失败。
验证#3结果的SQL语句:
```sql
SELECT
code, count(*)
FROM HSFHIR_X0001_S.Condition
group by code
```
对于第4题的测试，有`2个错误`，`12个结果7`和`1个结果4`。正确值是`4'。所以它是`12%`正确的，有执行失败的`13%`。
验证#4结果的SQL语句:
```sql
SELECT
p.Key patient, count(c._id) qtde_conditions, list(c.code) conditions
FROM HSFHIR_X0001_S.Patient p
join HSFHIR_X0001_S.Condition c on c.patient = p.key
where code like '%444814009%'
group by p.Key
```
对于5号问题的测试，有`11个错误`，`3个结果为4`，`1个结果为0.6`。正确值是`4'。所以它的正确率是`75%`，执行失败率是`73%`。
用来验证#5结果的SQL与#4所用的相同。
对于6号问题的测试，有`12个错误`和`3个结果{女性：4，男性：2，其他： 0}`. 正确的值是`{女性：3，男性：1，其他： 0}`. 所以它是`0%`正确的，有执行失败的`80%`。
验证#6结果的SQL语句:
```sql
SELECT
p.gender, count(distinct p._id) qty_patients, list(p.key) patients, list(c.code) conditions
FROM HSFHIR_X0001_S.Patient p
join HSFHIR_X0001_S.Condition c on c.patient = p.key
where code like '%444814009%'
group by p.gender
```
总结一下测试结果:
| 测试编号 # |准确率 | 执行失败率 |
|--------|----------|-------------------|
| 1 | 100% | 6% |
| 2 | 100% | 40% |
| 3 | 100% | 20% |
| 4 | 12% | 13% |
| 5 | 75 % | 73% |
| 6 | 0% | 80% |
### 安全性
你可以在[测试目录](https://github.com/jrpereirajr/iris-fhir-generative-ai/blob/master/misc/tests-accuacy)中检查生成的代码，似乎人工智能模型没有产生安全问题--这也是代码分析器模块发现的结果，没有安全问题。
因此，为了测试代码分析器是否能够检测到安全问题，[执行Python代码的模块](https://github.com/jrpereirajr/iris-fhir-generative-ai/blob/master/src/fhirgenerativeai/PythonService.cls)有一个名为 "代码注入 "的属性，可以注入恶意代码，以便进行测试。
因此，为安全测试注入了以下代码:
1. 安全测试 #1:
```python
print(eval("os.chmod('%s', 0o777)" % 'test.txt'))
```
这段代码试图访问SO文件系统并改变一个文件的权限。这显然是一个不符合项目意图的代码，所以它必须被阻止。
2. 安全测试 #2:
```python
import requests
url = "https://postman-echo.com/get"
params = {"arg": "value"}
response = requests.get(url, params=params)
data = response.json()
print(data)
```
这段代码试图向一个外部地址发出HTTP请求--本例中是Postman API。如果这段代码被执行，本地信息就会被攻击者轻易地获取。
正如你在[安全测试目录]（https://github.com/jrpereirajr/iris-fhir-generative-ai/blob/master/misc/tests-security）中所看到的，代码分析器成功地发现了安全问题。
## 结论
就准确性而言，人工智能模型在低复杂度的问题上得到了正确的结果，但随着问题复杂度的增加而开始失败。同样的情况也出现在执行失败上。因此，问题越复杂，人工智能模型产生的代码就越多，无法执行，导致错误结果的概率就越大。
这意味着需要对提示做出一些努力。例如，在[问题#6的代码](https://github.com/jrpereirajr/iris-fhir-generative-ai/blob/master/misc/tests-accuacy/6/1688265739062.txt)中，错误在于只询问病人而忽略了条件。这种分析对于指导提示的改变是必要的。
总的来说，人工智能模型在这次测试中的表现表明，在能够回答分析性问题之前，它仍然需要更多的改进。
这是由于人工智能模型的随机性质。我的意思是，在上面提到的ChatARKit项目中，如果人工智能模型渲染的三维物体并不完全在要求的地方，但接近它，可能用户不会介意。不幸的是，同样的情况并不适用于分析性问题，答案需要精确。
但是，我并不是说人工智能模型不能执行这样的任务。我要说的是，这个项目中使用的设计需要改进。
需要注意的是，这个项目没有使用更先进的技术来使用生成器AI，像[Langchain](https://python.langchain.com/docs/get_started/introduction.html)和[AutoGPT](https://autogpt.net/autogpt-installation-and-features/)。这里使用了一种更 "纯粹 "的方法，但使用这种更复杂的工具可能会导致更好的结果。
关于安全性，代码分析器发现了所有测试的安全问题。
然而，这并不意味着由人工智能模型生成的代码是100%安全的。此外，允许执行外部生成的Python代码可能绝对是危险的。你甚至不能百分之百地确定提供Python代码的系统实际上是OpenAI的API服务器......
避免安全问题的一个更好的方法可能是尝试其他不如Python强大的语言，或者尝试创建你自己的 "语言 "并将其呈现给AI模型，就像在[这个非常简单的例子]（https://platform.openai.com/examples/default-text-to-command）。
最后，重要的是要注意，像代码性能这样的方面在这个项目中没有涉及，可能也会成为未来工作的一个好主题。
所以，我希望大家能发现这个项目的有趣和有用。
> **免责声明：这是一个实验性项目。它将向OpenAI API发送数据，并在你的系统上执行由AI生成的代码。所以，不要在生产系统上使用它。还要注意，由于OpenAI的API调用是收费的。使用它的风险由你自己承担。它不是一个可用于生产的项目。**
Hi! Just here to a quick update: now we published a video about this project. Enjoy it: 😊
