yaoxin521123

一篇文章了解定义类成员结构

文章目录

一篇文章了解定义类成员结构
- `%Dictionary.ClassDefinition` - 类定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.ForeignKeyDefinition` - 外键定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.IndexDefinition` - 索引定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.MethodDefinition` - 方法定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.ParameterDefinition` - 参数定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.ProjectionDefinition` - 映射定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.PropertyDefinition` - 属性定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.PropertyUDLTextDefinition` - `PropertyUDLText`定义表
- - - 索引
    - 表结构
- `%Dictionary.QueryDefinition` - 查询定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.StorageDefinition` - `Storage`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.StorageDataDefinition` - `StorageData`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.StorageDataValueDefinition` - `StorageDataValue`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.StorageIndexDefinition` -` StorageIndex`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.StoragePropertyDefinition` - `StorageProperty`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.StorageSQLMapDefinition` - `StorageSQLMap`定义表
- - - 简介
    - 取值
    - 示例
    - 表结构
- `%Dictionary.StorageSQLMapDataDefinition` -`StorageSQLMapData`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.StorageSQLMapRowIdSpecDefinition` - `StorageSQLMapRowIdSpec`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.StorageSQLMapSubDefinition` -` StorageSQLMapSub`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.StorageSQLMapSubAccessvarDefinition` - `StorageSQLMapSubAccessvar`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.StorageSQLMapSubInvalidconditionDefinition` - `StorageSQLMapSubInvalidcondition`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.TriggerDefinition` - 触发器定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.UDLTextDefinition` - `UDLText`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `%Dictionary.XDataDefinition` - `XData`定义表
- - - 简介
    - 索引
    - 示例
    - 表结构
- `^oddDEF`一览

一篇文章了解定义类成员结构

Definition - 结尾的表均为定义时的内容，不包含编译时自动生成的内容。例如：方法等。
^oddDEF -所有定义表的Global信息。

`%Dictionary.ClassDefinition` - 类定义表

简介

新建类或更改类关键字时会修改此表字段。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name})
- %Dictionary.ClassDefinition.Name - 类名

示例

增加User.Human类Final关键字。

Class User.Human Extends (%Persistent, %Populate) [ ClassType = persistent, Final, SqlRowIdName = id ]
{
}

SQL查询该表，可以观察到Final字段为1。

Global中增加：

^oddDEF("User.Human",7)=1

Global示例：

USER>zw ^oddDEF("User.Human")
^oddDEF("User.Human")=25
^oddDEF("User.Human",1)="User.Human"
^oddDEF("User.Human",7)=1
^oddDEF("User.Human",23)="persistent"
^oddDEF("User.Human",55)="id"
^oddDEF("User.Human",60)="%Persistent,%Populate"
^oddDEF("User.Human",63)="66691,65113.785077"
^oddDEF("User.Human",64)="66691,65047.028275"

表结构

字检	类型	描述	位置	检索码
`ID`	`%CacheString`	类名
`Abstract`	`%Boolean`	指定类不能有实例；对于数据类型，指定类不能用作属性类型。	21	`s {Abstract}=$s($d(^oddDEF({L1},21))#2:^(21),1:0)`
`ClassDefinitionError`	`%Boolean`	如果序列化类时出现问题，则设置为`True`，以便编译器知道不编译此类。	67	`s {ClassDefinitionError}=$s($d(^oddDEF({L1},67))#2:^(67),1:0)`
`ClassType`	`%CacheString`	指定如何使用此类。	23	`s {ClassType}=$s($d(^oddDEF({L1},23))#2:^(23),1:"")`
`ClientDataType`	`%CacheString`	对于数据类型类，指定通过`ActiveX`或`Java`公开时使用的类型。`DataType`类必须指定客户端数据类型。	24	`s {ClientDataType}=$s($d(^oddDEF({L1},24))#2:^(24),1:"VARCHAR")`
`ClientName`	`%CacheString`	类提供了一个备用名称，用于映射到`Java`。	73	`s {ClientName}=$s($d(^oddDEF({L1},73))#2:^(73),1:"")`
`CompileAfter`	`%CacheString`	指示类编译器应在指定类之后编译此类。	28	`s {CompileAfter}=$s($d(^oddDEF({L1},28))#2:^(28),1:"")`
`ConstraintClass`	`%CacheString`	要继承的其他约束成员父类。	80	`s {ConstraintClass}=$s($d(^oddDEF({L1},80))#2:^(80),1:"")`
`DdlAllowed`	`%Boolean`	对于持久类，指示是否可以使用`DDL`语句来更改或删除类定义。	29	`s {DdlAllowed}=$s($d(^oddDEF({L1},29))#2:^(29),1:0)`
`DependsOn`	`%CacheString`	此类编译所依赖的可运行类的列表。	84	`s {DependsOn}=$s($d(^oddDEF({L1},84))#2:^(84),1:"")`
`Deployed`	`%Integer`	指示类是否已部署，即是否已与用于生成的源文件取消关联。	72	`s {Deployed}=$s($d(^oddDEF({L1},72))#2:^(72),1:0)`
`Deprecated`	`%Boolean`	如果此类已弃用，则为`True`。	17	`s {Deprecated}=$s($d(^oddDEF({L1},17))#2:^(17),1:0)`
`Description`	`%CacheString`	指定类的描述。	4	`s {Description}=$s($d(^oddDEF({L1},4))#2:^(4),1:"")`
`Dynamic`	`%Boolean`	弃用	30	`s {Dynamic}=$s($d(^oddDEF({L1},30))#2:^(30),1:0)`
`EmbeddedClass`	`%CacheString`	如果在成员类型类中指定，则为形成嵌入式父类的类的名称	100	`s {EmbeddedClass}=$s($d(^oddDEF({L1},100))#2:^(100),1:"")`
`Final`	`%Boolean`	指定类不能有子类。	7	`s {Final}=$s($d(^oddDEF({L1},7))#2:^(7),1:0)`
`GeneratedBy`	`%CacheString`	如果这个类是由其他组件生成的，那么这是生成这个类的项目的名称	87	`s {GeneratedBy}=$s($d(^oddDEF({L1},87))#2:^(87),1:"")`
`Hidden`	`%Boolean`	指定在查看类字典的内容时通常不列出此类。	32	`s {Hidden}=$s($d(^oddDEF({L1},32))#2:^(32),1:0)`
`Import`	`%CacheString`	提供要为此类导入的类包列表。	33	`s {Import}=$s($d(^oddDEF({L1},33))#2:^(33),1:"")`
`IncludeCode`	`%CacheString`	指定编译此类时使用的缓存包含文件的可选列表。	35	`s {IncludeCode}=$s($d(^oddDEF({L1},35))#2:^(35),1:"")`
`IncludeGenerator`	`%CacheString`	指定编译此类的方法生成器方法时使用的缓存包含文件的可选列表。	37	`s {IncludeGenerator}=$s($d(^oddDEF({L1},37))#2:^(37),1:"")`
`IndexClass`	`%CacheString`	要继承的其他索引成员超类。	81	`s {IndexClass}=$s($d(^oddDEF({L1},81))#2:^(81),1:"")`
`Inheritance`	`%CacheString`	定义使用多重继承时的继承顺序，如果一个成员存在于多个超类中，哪一个优先。	92	`s {Inheritance}=$s($d(^oddDEF({L1},92))#2:^(92),1:"left")`
`LegacyInstanceContext`	`%Boolean`	用于实现此类方法的默认语言。	96	`s {LegacyInstanceContext}=$s($d(^oddDEF({L1},96))#2:^(96),1:0)`
`MemberSuper`	`%CacheString`	如果为真则将 `%this` 作为所有实例方法的第一个参数传递	83	`s {MemberSuper}=$s($d(^oddDEF({L1},83))#2:^(83),1:"")`
`ModificationAuxiliary`	`%CacheString`	如果在成员继承中将此类用作成员类，则为要继承的类。	68	`s {ModificationAuxiliary}=$s($d(^oddDEF({L1},68))#2:^(68),1:"")`
`ModificationLevel`	`%Integer`	弃用	69	`s {ModificationLevel}=$s($d(^oddDEF({L1},69))#2:^(69),1:9)`
`Name`	`%Dictionary.CacheClassname`	类名
`Modified`	`%CacheString`	如果设置为 `0`，那么类总是被修改，所以它总是被保存。	40	`s {Modified}=$s($d(^oddDEF({L1},40))#2:^(40),1:3)`
`NoContext`	`%Boolean`	`NoContext`	42	`s {NoContext}=$s($d(^oddDEF({L1},42))#2:^(42),1:0)`
`NoExtent`	`%Boolean`	如果为`True`，将不允许此类继续任何类。	76	`s {NoExtent}=$s($d(^oddDEF({L1},76))#2:^(76),1:0)`
`OdbcType`	`%CacheString`	对于数据类型类，指定通过`ODBC`或`JDBC`公开时使用的类型。`DataType`类必须指定`ODBC`类型。	43	`s {OdbcType}=$s($d(^oddDEF({L1},43))#2:^(43),1:"VARCHAR")`
`Owner`	`%CacheString`	指定类及其对应表的所有者。默认情况下，类和表归 `_SYSTEM` 所有。	44	`s {Owner}=$s($d(^oddDEF({L1},44))#2:^(44),1:"")`
`ProcedureBlock`	`%Boolean`	指定该类对方法代码使用过程块。	46	`s {ProcedureBlock}=$s($d(^oddDEF({L1},46))#2:^(46),1:1)`
`ProjectionClass`	`%CacheString`	映射定义外键	82	`s {ProjectionClass}=$s($d(^oddDEF({L1},82))#2:^(82),1:"")`
`PropertyClass`	`%CacheString`	属性定义外键	48	`s {PropertyClass}=$s($d(^oddDEF({L1},48))#2:^(48),1:"")`
`QueryClass`	`%CacheString`	查询定义外键	79	`s {QueryClass}=$s($d(^oddDEF({L1},79))#2:^(79),1:"")`
`ServerOnly`	`%CacheString`	`ServerOnly`	88	`s {ServerOnly}=$s($d(^oddDEF({L1},88))#2:^(88),1:"")`
`SoapBindingStyle`	`%CacheString`	指定此类在用于通过 `SOAP` 发送和接收消息时使用的 `SOAP` 绑定。	70	`s {SoapBindingStyle}=$s($d(^oddDEF({L1},70))#2:^(70),1:"document")`
`SoapBodyUse`	`%CacheString`	指定用于 `SOAP` 消息的编码。	71	`s {SoapBodyUse}=$s($d(^oddDEF({L1},71))#2:^(71),1:"literal")`
`SqlCategory`	`%CacheString`	在数据类型类的情况下，指定用于 `SQL` 计算的类型。数据类型类必须指定一个 `SQL` 类别。	52	`s {SqlCategory}=$s($d(^oddDEF({L1},52))#2:^(52),1:"STRING")`
`SqlRoutinePrefix`	`%CacheString`	弃用	54	`s {SqlRoutinePrefix}=$s($d(^oddDEF({L1},54))#2:^(54),1:"")`
`SqlRowIdName`	`%CacheString`	`在持久类的情况下，指定用于` ID `列的替代名称字段名称。默认情况下，`ID `称为 ID`。	55	`s {SqlRowIdName}=$s($d(^oddDEF({L1},55))#2:^(55),1:"")`
`SqlRowIdPrivate`	`%Boolean`	在持久类的情况下，指定 `ID` 列是否作为隐藏字段映射到 `ODBC`。	56	`s {SqlRowIdPrivate}=$s($d(^oddDEF({L1},56))#2:^(56),1:0)`
`SqlTableName`	`%CacheString`	在持久类的情况下，指定用于在其 `SQL` 映射中标识该类的表名。默认情况下，`SQL` 表名与类名相同。	58	`s {SqlTableName}=$s($d(^oddDEF({L1},58))#2:^(58),1:"")`
`StorageStrategy`	`%CacheString`	指定用于控制此类持久性的存储策略的名称。	59	`s {StorageStrategy}= $s ($ d(^{oddDEF({L1},59))#2:}(59),1:“”)
`Super`	`%CacheString`	为类指定一个或多个父类。	60	`s {Super}=$s($d(^oddDEF({L1},60))#2:^(60),1:"")`
`System`	`%CacheString`	指定该类是实现的内部类。通常不应使用此关键字标记类。	61	`s {System}=$s($d(^oddDEF({L1},61))#2:^(61),1:0)`
`TimeChanged`	`%CacheString`	给出最后一次对类进行更改的时间。	63	`s {TimeChanged}=$s($d(^oddDEF({L1},63))#2:^(63),1:"")`
`TimeCreated`	`%CacheString`	给出类首次创建的时间。	64	`s {TimeCreated}=$s($d(^oddDEF({L1},64))#2:^(64),1:"")`
`TriggerClass`	`%CacheString`	要继承的其他触发器成员父类。	99	`s {TriggerClass}=$s($d(^oddDEF({L1},99))#2:^(99),1:"")`
`ViewQuery`	`%CacheString`	给出用于此类的视图定义的 `SQL` 查询。	65	`s {ViewQuery}=$s($d(^oddDEF({L1},65))#2:^(65),1:"")`
`_Language`			39	`s {_Language}=$s($d(^oddDEF({L1},39))#2:^(39),1:"cache")`

`%Dictionary.ForeignKeyDefinition` - 外键定义表

简介

新建或更改外键时会修改此表字段。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"f",{%Dictionary.ForeignKeyDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.ForeignKeyDefinition.Name - 外键名

示例

增加User.Human类外键MenuFK。

Class User.Human Extends (%Persistent, %Populate) [ ClassType = persistent, Final, SqlRowIdName = id ]
{

Property menu As %String ;

ForeignKey MenuFK(menu) References User.FKMenu();
}

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","f")
^oddDEF("User.Human","f","MenuFK")=""
^oddDEF("User.Human","f","MenuFK",11)=4
^oddDEF("User.Human","f","MenuFK",23)="menu"
^oddDEF("User.Human","f","MenuFK",24)="User.FKMenu"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Deprecated`	`%Boolean`	如果此外键已弃用，则为`True`。	`17`	`s {Deprecated}=$s($d(^oddDEF({L1},"f",{L3},17))#2:^(17),1:0)`
`Description`	`%CacheString`	提供外键的描述。	`4`	`s {Description}=$s($d(^oddDEF({L1},"f",{L3},4))#2:^(4),1:"")`
`Internal`	`%Boolean`	如果为`True`，则不在文档中显示此项。	`14`	`s {Internal}=$s($d(^oddDEF({L1},"f",{L3},14))#2:^(14),1:0)`
`NoCheck`	`%Boolean`	`NoCheck`	`27`	`s {NoCheck}=$s($d(^oddDEF({L1},"f",{L3},27))#2:^(27),1:0)`
`OnDelete`	`%CacheString`	指定从外表中删除键值时要采取的引用操作。	`21`	`s {OnDelete}=$s($d(^oddDEF({L1},"f",{L3},21))#2:^(21),1:"noaction")`
`OnUpdate`	`%CacheString`	指定在外表中更新键值时要采取的引用操作。	`22`	`s {OnUpdate}=$s($d(^oddDEF({L1},"f",{L3},22))#2:^(22),1:"noaction")`
`Properties`	`%CacheString`	指定一个或多个属性，这些属性的值用于约束外键的值。	`23`	`s {Properties}=$s($d(^oddDEF({L1},"f",{L3},23))#2:^(23),1:"")`
`ReferencedClass`	`%Dictionary.CacheClassname`	指定包含此外键定义引用的键的类的名称。	`24`	`s {ReferencedClass}=$s($d(^oddDEF({L1},"f",{L3},24))#2:^(24),1:"")`
`ReferencedKey`	`%CacheString`	指定类中唯一索引的键名，该类为该外键提供一组允许的值。	`25`	`s {ReferencedKey}=$s($d(^oddDEF({L1},"f",{L3},25))#2:^(25),1:"")`
`SequenceNumber`	`%Integer`	序列号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"f",{L3},11))#2:^(11),1:0)`
`SqlName`	`%CacheString`	指定通过`SQL`引用此外键时的替代名称。	`26`	`s {SqlName}=$s($d(^oddDEF({L1},"f",{L3},26))#2:^(26),1:"")`

`%Dictionary.IndexDefinition` - 索引定义表

简介

新建或修改索引时会修改此表字段。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"i",{%Dictionary.IndexDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.IndexDefinition.Name - 索引名

示例

添加User.Human类索引IndexName。

Index IndexName On name;

Property name As %String;

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","i")
^oddDEF("User.Human","i","IndexName")=""
^oddDEF("User.Human","i","IndexName",11)=1
^oddDEF("User.Human","i","IndexName",28)="name"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Condition`	`%CacheString`	如果是条件索引，则指定索引项必须满足的条件。	`23`	`s {Condition}=$s($d(^oddDEF({L1},"i",{L3},23))#2:^(23),1:"")`
`Data`	`%CacheString`	指定其值将存储在此索引中的属性列表。	`24`	`s {Data}=$s($d(^oddDEF({L1},"i",{L3},24))#2:^(24),1:"")`
`Deprecated`	`%Boolean`	如果此索引已弃用，则为`True`。	`17`	`s {Deprecated}=$s($d(^oddDEF({L1},"i",{L3},17))#2:^(17),1:0)`
`Description`	`%CacheString`	指定索引的描述。	`4`	`s {Description}=$s($d(^oddDEF({L1},"i",{L3},4))#2:^(4),1:"")`
`Extent`	`%Boolean`	范围索引用于跟踪哪些对象实例属于子类。当使用位图索引时，则自动维护范围索引，无需定义范围索引。	`25`	`s {Extent}=$s($d(^oddDEF({L1},"i",{L3},25))#2:^(25),1:0)`
`IdKey`	`%Boolean`	指定为该索引定义的一个或多个属性将用于形成该对象的对象标识值。此值用于唯一地定位持久对象实例。	`26`	`s {IdKey}=$s($d(^oddDEF({L1},"i",{L3},26))#2:^(26),1:0)`
`Internal`	`%Boolean`	如果为true，则不要在自动文档中显示此项。	`14`	`s {Internal}=$s($d(^oddDEF({L1},"i",{L3},14))#2:^(14),1:0)`
`Parameters`	`%CacheString`	参数	`0`	`n sub s {Parameters}="",sub="" f s sub=$o(^oddDEF({L1},"i",{L3},"P",sub)) q:sub="" s {Parameters}={Parameters}_$lb($lb(sub,$g(^oddDEF({L1},"i",{L3},"P",sub))))`
`PrimaryKey`	`%Boolean`	指定应该通过`SQL`报告此索引作为该类的主键。	`27`	`s {PrimaryKey}=$s($d(^oddDEF({L1},"i",{L3},27))#2:^(27),1:0)`
`Properties`	`%CacheString`	指定用于构建此索引的属性列表。还可以包括每个属性的排序规范。	`28`	`s {Properties}=$s($d(^oddDEF({L1},"i",{L3},28))#2:^(28),1:"")`
`SequenceNumber`	`%Integer`	序号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"i",{L3},11))#2:^(11),1:0)`
`SqlName`	`%CacheString`	当通过`SQL`引用时，定义此索引的替代名称。	`29`	`s {SqlName}=$s($d(^oddDEF({L1},"i",{L3},29))#2:^(29),1:"")`
`Type`	`%CacheString`	指定索引的类型。输入`key`已弃用。	`5`	`s {Type}=$s($d(^oddDEF({L1},"i",{L3},5))#2:^(5),1:"")`
`TypeClass`	`%Dictionary.CacheClassname`	指定用于提供功能索引接口的实现的`FunctionalIndex` 类。	`33`	`s {TypeClass}=$s($d(^oddDEF({L1},"i",{L3},33))#2:^(33),1:"")`
`_Unique`			`31`	`s {_Unique}=$s($d(^oddDEF({L1},"i",{L3},31))#2:^(31),1:0)`

`%Dictionary.MethodDefinition` - 方法定义表

简介

新建或修改方法时会修改此表字段。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"m",{%Dictionary.MethodDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.MethodDefinition.Name - 方法名

示例

添加User.Human类如下方法：

ClassMethod Add(num1, num2)
{
	q num1 + num2
}

Method Min(num1, num2)
{
	q num1 - num2
}

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","m")
^oddDEF("User.Human","m","Add")=""
^oddDEF("User.Human","m","Add",11)=6
^oddDEF("User.Human","m","Add",23)=1
^oddDEF("User.Human","m","Add",27)="num1,num2"
^oddDEF("User.Human","m","Add",30)=1
^oddDEF("User.Human","m","Add",30,1)=$c(9)_"q num1 + num2"
^oddDEF("User.Human","m","Min")=""
^oddDEF("User.Human","m","Min",11)=7
^oddDEF("User.Human","m","Min",27)="num1,num2"
^oddDEF("User.Human","m","Min",30)=1
^oddDEF("User.Human","m","Min",30,1)=$c(9)_"q num1 - num2"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Abstract`	`%Boolean`	指定这是一个抽象方法。抽象方法没有实现，也没有为其生成可执行代码。抽象方法的存在仅仅是为了定义可以在一个或多个子类中重写和实现的方法签名或接口。	`21`	`s {Abstract}=$s($d(^oddDEF({L1},"m",{L3},21))#2:^(21),1:0)`
`ClassMethod`	`%Boolean`	指定该方法是类方法。实例方法只能通过实例化的对象来调用，而类方法可以在没有对象实例的情况下直接调用。	`23`	`s {ClassMethod}=$s($d(^oddDEF({L1},"m",{L3},23))#2:^(23),1:0)`
`ClientMethod`	`%Boolean`	如果为 `true`，则此方法仅在服务器上可用，并且将被映射为客户端方法。	`70`	`s {ClientMethod}=$s($d(^oddDEF({L1},"m",{L3},70))#2:^(70),1:0)`
`ClientName`	`%CacheString`	`ClientName`	`24`	`s {ClientName}=$s($d(^oddDEF({L1},"m",{L3},24))#2:^(24),1:"")`
`CodeMode`	`%CacheString`	指定如何实现给定方法：作为例程调用、要编译的代码行、表达式或将生成结果方法或对象的方法。	`25`	`s {CodeMode}=$s($d(^oddDEF({L1},"m",{L3},25))#2:^(25),1:"code")`
`Deprecated`	`%Boolean`	如果此方法已被弃用，则为 `True`。	`17`	`s {Deprecated}=$s($d(^oddDEF({L1},"m",{L3},17))#2:^(17),1:0)`
`Description`	`%CacheString`	指定方法的描述。	`4`	`s {Description}=$s($d(^oddDEF({L1},"m",{L3},4))#2:^(4),1:"")`
`ExternalProcName`	`%CacheString`	指定外部数据库中的 `SQL` 过程名称。	`63`	`s {ExternalProcName}=$s($d(^oddDEF({L1},"m",{L3},63))#2:^(63),1:"")`
`Final`	`%Boolean`	指定子类不能重写该方法的实现。	`7`	`s {Final}=$s($d(^oddDEF({L1},"m",{L3},7))#2:^(7),1:0)`
`ForceGenerate`	`%Boolean`	当 `true` 时，总是在每个子类中重新生成此方法，即使正常规则允许我们调用父类实现。	`71`	`s {ForceGenerate}=$s($d(^oddDEF({L1},"m",{L3},71))#2:^(71),1:0)`
`FormalSpec`	`%CacheString`	指定参数列表。每个参数的格式为`[&	][:][=]`，其中`&`表示按引用传递，``表示仅输出。
`GenerateAfter`	`%CacheString`	对于方法生成器方法，指定生成器应在生成列出的方法后调用。	`29`	`s {GenerateAfter}=$s($d(^oddDEF({L1},"m",{L3},29))#2:^(29),1:"")`
`Hash`	`%CacheString`	`Hash`	`66`	`s {Hash}=$s($d(^oddDEF({L1},"m",{L3},66))#2:^(66),1:"")`
`Implementation`	`%Stream.TmpCharacter`	调用方法时执行的代码。对于表达式方法，这是一个表达式。对于调用方法，这是要调用的缓存例程的名称。	`0`	`s {Implementation}=""`
`Internal`	`%Boolean`	如果为 `true`，则不在文档中显示此项。	`14`	`s {Internal}=$s($d(^oddDEF({L1},"m",{L3},14))#2:^(14),1:0)`
`NoContext`	`%Boolean`	如果为 true 并且在数据类型方法中，这会阻止 `* Set %val=..prop Set $this="" *` 添加到属性方法中，以便可以重写 Get/Set 方法等内容。	`33`	`s {NoContext}=$s($d(^oddDEF({L1},"m",{L3},33))#2:^(33),1:0)`
`NotForProperty`	`%Boolean`	弃用	`34`	`s {NotForProperty}=$s($d(^oddDEF({L1},"m",{L3},34))#2:^(34),1:0)`
`NotInheritable`	`%Boolean`	指定该方法不在子类中继承。	`9`	`s {NotInheritable}=$s($d(^oddDEF({L1},"m",{L3},9))#2:^(9),1:0)`
`PlaceAfter`	`%CacheString`	指定类编译器应将此方法放置在它为类创建的例程中列出的方法之后。	`38`	`s {PlaceAfter}=$s($d(^oddDEF({L1},"m",{L3},38))#2:^(38),1:"")`
`Private`	`%Boolean`	指定该方法是私有的。私有方法只能由此类或其子类的实例方法调用。	`39`	`s {Private}=$s($d(^oddDEF({L1},"m",{L3},39))#2:^(39),1:0)`
`ProcedureBlock`	`%CacheString`	指定此方法使用方法代码的过程块。	`40`	`s {ProcedureBlock}=$s($d(^oddDEF({L1},"m",{L3},40))#2:^(40),1:"")`
`PublicList`	`%CacheString`	指定公共列表。仅当 `procedureBlock` 关键字设置为 `true` 时才使用此关键字。	`41`	`s {PublicList}=$s($d(^oddDEF({L1},"m",{L3},41))#2:^(41),1:"")`
`ReturnResultsets`	`%Boolean`	如果为 `true`，则此方法可能会在 `%sqlcontext` 中返回零个、一个或多个结果集。	`64`	`s {ReturnResultsets}=$s($d(^oddDEF({L1},"m",{L3},64))#2:^(64),1:0)`
`ReturnType`	`%Dictionary.CacheClassname`	指定调用方法返回值的数据类型。将 `ReturnType` 设置为空字符串指定没有返回值。	`42`	`s {ReturnType}=$s($d(^oddDEF({L1},"m",{L3},42))#2:^(42),1:"")`
`ReturnTypeParams`	`%CacheString`	`ReturnType` 关键字上的所有参数的逗号分隔列表。	`62`	`s {ReturnTypeParams}=$s($d(^oddDEF({L1},"m",{L3},62))#2:^(62),1:"")`
`SequenceNumber`	`%Integer`	序号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"m",{L3},11))#2:^(11),1:0)`
`ServerOnly`	`%CacheString`	指定方法不会映射到 `Java` 或 `C++` 客户端。	`59`	`s {ServerOnly}=$s($d(^oddDEF({L1},"m",{L3},59))#2:^(59),1:"")`
`SoapAction`	`%CacheString`	允许您指定将此 `Web` 服务方法作为 `Web` 方法调用时必须使用的 `HTTP SOAP` 操作。对于 `SOAP 1.1`，`SOAP` 操作是从 `SOAPAction HTTP` 标头获取的。对于 `SOAP 1.2`，它是从 `Content-Type HTTP` 标头获取的。	`67`	`s {SoapAction}=$s($d(^oddDEF({L1},"m",{L3},67))#2:^(67),1:"[default]")`
`SoapBindingStyle`	`%CacheString`	指定 `Web` 方法使用什么类型的 `SOAP` 调用。对于非 `Web` 方法，此关键字将被忽略。	`53`	`s {SoapBindingStyle}=$s($d(^oddDEF({L1},"m",{L3},53))#2:^(53),1:"")`
`SoapBodyUse`	`%CacheString`	指定 `Web` 方法的输入和输出使用哪种 `SOAP` 编码。对于非 `Web` 方法，此关键字将被忽略。	`54`	`s {SoapBodyUse}=$s($d(^oddDEF({L1},"m",{L3},54))#2:^(54),1:"")`
`SoapMessageName`	`%CacheString`	指定 `Web` 服务方法的响应消息正文的子元素的名称。	`68`	`s {SoapMessageName}=$s($d(^oddDEF({L1},"m",{L3},68))#2:^(68),1:"")`
`SoapNameSpace`	`%CacheString`	覆盖此 `Web` 服务或 `Web` 服务客户端的 `SOAPNAMESPACE` 类参数。	`61`	`s {SoapNameSpace}=$s($d(^oddDEF({L1},"m",{L3},61))#2:^(61),1:"")`
`SoapRequestMessage`	`%CacheString`	该关键字将反映 `SOAP` 请求中 `SOAP` 主体顶部元素的预期元素名称。需要此元素来区分具有相同 `SoapAction` 但不同顶级主体元素的多个请求。	`73`	`s {SoapRequestMessage}=$s($d(^oddDEF({L1},"m",{L3},73))#2:^(73),1:"")`
`SoapTypeNameSpace`	`%CacheString`	覆盖此 `Web` 服务或 `Web` 服务客户端的 `SOAPTYPENAMESPACE` 类参数。	`65`	`s {SoapTypeNameSpace}=$s($d(^oddDEF({L1},"m",{L3},65))#2:^(65),1:"")`
`SqlName`	`%CacheString`	如果此方法被投影为 `SQL` 存储过程，则此名称将用作存储过程的名称。	`45`	`s {SqlName}=$s($d(^oddDEF({L1},"m",{L3},45))#2:^(45),1:"")`
`SqlProc`	`%Boolean`	指定该方法可以作为 `SQL` 存储过程调用。只有类方法才能作为 `SQL` 存储过程进行调用。	`46`	`s {SqlProc}=$s($d(^oddDEF({L1},"m",{L3},46))#2:^(46),1:0)`
`SqlRoutine`	`%CacheString`	如果“程序”是那么这相当于 `SqlProc` 关键字，意味着类方法可以作为 `SQL` 过程调用。如果“函数”那么这个类方法就可以作为 `SQL` 函数来调用。	`74`	`s {SqlRoutine}=$s($d(^oddDEF({L1},"m",{L3},74))#2:^(74),1:"")`
`WebMethod`	`%Boolean`	指定可以使用 `SOAP` 协议将方法作为 `Web` 方法进行调用。	`51`	`s {WebMethod}=$s($d(^oddDEF({L1},"m",{L3},51))#2:^(51),1:0)`
`ZenMethod`	`%Boolean`	指定该方法应投影到 `Web` 客户端以在 `Zen` 框架中使用。	`52`	`s {ZenMethod}=$s($d(^oddDEF({L1},"m",{L3},52))#2:^(52),1:0)`
`_Language`			`32`	`s {_Language}=$s($d(^oddDEF({L1},"m",{L3},32))#2:^(32),1:"")`

`%Dictionary.ParameterDefinition` - 参数定义表

简介

新建或修改类参数时会修改此表字段。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"p",{%Dictionary.ParameterDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.ParameterDefinition.Name - 参数名

示例

添加User.Human类AppName参数：

Parameter AppName = "yx";

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","p")
^oddDEF("User.Human","p","AppName")=""
^oddDEF("User.Human","p","AppName",11)=1
^oddDEF("User.Human","p","AppName",22)="yx"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Abstract`	`%Boolean`	抽象	`24`	`s {Abstract}=$s($d(^oddDEF({L1},"p",{L3},24))#2:^(24),1:0)`
`Deprecated`	`%Boolean`	如果此参数已弃用，则为 `True`。	`17`	`s {Deprecated}=$s($d(^oddDEF({L1},"p",{L3},17))#2:^(17),1:0)`
`Description`	`%CacheString`	指定参数的描述。	`4`	`s {Description}=$s($d(^oddDEF({L1},"p",{L3},4))#2:^(4),1:"")`
`Encoded`	`%Boolean`	如果为 `true`，则参数值采用 `Base64` 编码。	`27`	`s {Encoded}=$s($d(^oddDEF({L1},"p",{L3},27))#2:^(27),1:0)`
`Expression`	`%CacheString`	在编译时计算种子参数的表达式，如果指定，则优先于 `Default` 关键字。	`25`	`s {Expression}=$s($d(^oddDEF({L1},"p",{L3},25))#2:^(25),1:"")`
`Final`	`%Boolean`	指定子类不能覆盖参数的定义。	`7`	`s {Final}=$s($d(^oddDEF({L1},"p",{L3},7))#2:^(7),1:0)`
`Flags`	`%CacheString`	指定参数类型的任何附加修饰符标志。	`23`	`s {Flags}=$s($d(^oddDEF({L1},"p",{L3},23))#2:^(23),1:"")`
`Internal`	`%Boolean`	如果为 `true`，则不在文档中显示此项。	`14`	`s {Internal}=$s($d(^oddDEF({L1},"p",{L3},14))#2:^(14),1:0)`
`SequenceNumber`	`%Integer`	序号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"p",{L3},11))#2:^(11),1:0)`
`Type`	`%CacheString`	指定参数的类型。 `Studio` 使用该类型为参数提供输入验证。	`5`	`s {Type}=$s($d(^oddDEF({L1},"p",{L3},5))#2:^(5),1:"")`
`_Constraint`			`21`	`s {_Constraint}=$s($d(^oddDEF({L1},"p",{L3},21))#2:^(21),1:"")`
`_Default`			`22`	`s {_Default}=$s($d(^oddDEF({L1},"p",{L3},22))#2:^(22),1:"")`

`%Dictionary.ProjectionDefinition` - 映射定义表

简介

新建或修改类映射时会修改此表字段。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"j",{%Dictionary.ProjectionDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.ProjectionDefinition.Name - 映射名

示例

添加User.Human类JavaClient映射：

Projection JavaClient As %Projection.Java(ROOTDIR = "e:\m\java");

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","j")
^oddDEF("User.Human","j","JavaClient")=""
^oddDEF("User.Human","j","JavaClient",5)="%Projection.Java"
^oddDEF("User.Human","j","JavaClient",11)=1
^oddDEF("User.Human","j","JavaClient","P","ROOTDIR")="e:\m\java"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Deprecated`	`%Boolean`	如果此映射已弃用，则为 `True`。	`17`	`s {Deprecated}=$s($d(^oddDEF({L1},"j",{L3},17))#2:^(17),1:0)`
`Description`	`%CacheString`	指定映射的描述。	`4`	`s {Description}=$s($d(^oddDEF({L1},"j",{L3},4))#2:^(4),1:"")`
`Internal`	`%Boolean`	如果为`true`，则不在文档中显示此项。	`14`	`s {Internal}=$s($d(^oddDEF({L1},"j",{L3},14))#2:^(14),1:0)`
`NotInheritable`	`%Boolean`	指定该映射不在子类中继承。	`9`	`s {NotInheritable}=$s($d(^oddDEF({L1},"j",{L3},9))#2:^(9),1:0)`
`Parameters`	`%CacheString`	参数	`0`	`n sub s {Parameters}="",sub="" f s sub=$o(^oddDEF({L1},"j",{L3},"P",sub)) q:sub="" s {Parameters}={Parameters}_$lb($lb(sub,$g(^oddDEF({L1},"j",{L3},"P",sub))))`
`SequenceNumber`	`%Integer`	序号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"j",{L3},11))#2:^(11),1:0)`
`Type`	`%Dictionary.CacheClassname`	指定与映射关联的类的名称。	`5`	`s {Type}=$s($d(^oddDEF({L1},"j",{L3},5))#2:^(5),1:"")`

`%Dictionary.PropertyDefinition` - 属性定义表

简介

新建或修改类属性时会修改此表字段。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"a",{%Dictionary.PropertyDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.PropertyDefinition.Name - 属性名

示例

添加User.Human类name，age属性：

Property name As %String;

Property age As %Integer;

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","a")
^oddDEF("User.Human","a","age")=""
^oddDEF("User.Human","a","age",5)="%Integer"
^oddDEF("User.Human","a","age",11)=5
^oddDEF("User.Human","a","menu")=""
^oddDEF("User.Human","a","menu",5)="%String"
^oddDEF("User.Human","a","menu",11)=6
^oddDEF("User.Human","a","name")=""
^oddDEF("User.Human","a","name",5)="%String"
^oddDEF("User.Human","a","name",11)=4

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Aliases`	`%CacheString`	该属性的别名列表。	`58`	`s {Aliases}=$s($d(^oddDEF({L1},"a",{L3},58))#2:^(58),1:"")`
`Calculated`	`%Boolean`	指定在实例化包含该属性的对象时，没有为其分配内存存储。	`23`	`s {Calculated}=$s($d(^oddDEF({L1},"a",{L3},23))#2:^(23),1:0)`
`Cardinality`	`%CacheString`	指定关系属性的基数。关系属性需要 `Cardinality` 关键字。它被非关系属性忽略。	`24`	`s {Cardinality}=$s($d(^oddDEF({L1},"a",{L3},24))#2:^(24),1:"")`
`ClientName`	`%CacheString`	客户端名称	`26`	`s {ClientName}=$s($d(^oddDEF({L1},"a",{L3},26))#2:^(26),1:"")`
`Collection`	`%CacheString`	指定属性是集合属性以及它是什么类型的集合。	`27`	`s {Collection}=$s($d(^oddDEF({L1},"a",{L3},27))#2:^(27),1:"")`
`Deprecated`	`%Boolean`	如果此属性已弃用，则为 true。	`17`	`s {Deprecated}=$s($d(^oddDEF({L1},"a",{L3},17))#2:^(17),1:0)`
`Description`	`%CacheString`	指定属性的描述。	`4`	`s {Description}=$s($d(^oddDEF({L1},"a",{L3},4))#2:^(4),1:"")`
`Final`	`%Boolean`	指定子类不能覆盖此属性的定义。	`7`	`s {Final}=$s($d(^oddDEF({L1},"a",{L3},7))#2:^(7),1:0)`
`InitialExpression`	`%CacheString`	指定属性的初始值。	`31`	`s {InitialExpression}=$s($d(^oddDEF({L1},"a",{L3},31))#2:^(31),1:"""""")`
`Internal`	`%Boolean`	如果为真，则不在文档中显示此项。	`14`	`s {Internal}=$s($d(^oddDEF({L1},"a",{L3},14))#2:^(14),1:0)`
`Inverse`	`%CacheString`	指定关系的反面名称。即相关类中对应关系属性的名称。逆属性必须存在于相关类中并且具有正确的基数值。关系属性需要 `Inverse` 关键字。它被非关系属性忽略。	`32`	`s {Inverse}=$s($d(^oddDEF({L1},"a",{L3},32))#2:^(32),1:"")`
`MultiDimensional`	`%Boolean`	指定属性具有多维数组的特征。	`33`	`s {MultiDimensional}=$s($d(^oddDEF({L1},"a",{L3},33))#2:^(33),1:0)`
`NoModBit`	`%Boolean`	弃用	`53`	`s {NoModBit}=$s($d(^oddDEF({L1},"a",{L3},53))#2:^(53),1:0)`
`NotInheritable`	`%Boolean`	弃用	`9`	`s {NotInheritable}=$s($d(^oddDEF({L1},"a",{L3},9))#2:^(9),1:0)`
`OnDelete`	`%CacheString`	指定从外表中删除键值时要采取的参考操作。	`59`	`s {OnDelete}=$s($d(^oddDEF({L1},"a",{L3},59))#2:^(59),1:"")`
`Parameters`	`%CacheString`	参数	`0`	`n sub s {Parameters}="",sub="" f s sub=$o(^oddDEF({L1},"a",{L3},"P",sub)) q:sub="" s {Parameters}={Parameters}_$lb($lb(sub,$g(^oddDEF({L1},"a",{L3},"P",sub))))`
`Private`	`%Boolean`	指定该属性是私有的。私有属性只能由此类或其子类的实例方法使用。	`35`	`s {Private}=$s($d(^oddDEF({L1},"a",{L3},35))#2:^(35),1:0)`
`ReadOnly`	`%Boolean`	指定该属性是只读的。	`52`	`s {ReadOnly}=$s($d(^oddDEF({L1},"a",{L3},52))#2:^(52),1:0)`
`Relationship`	`%Boolean`	指定属性是关系属性。	`36`	`s {Relationship}=$s($d(^oddDEF({L1},"a",{L3},36))#2:^(36),1:0)`
`Required`	`%Boolean`	对于持久类，指定必须先为属性的值指定一个值，然后才能将其存储到磁盘。	`37`	`s {Required}=$s($d(^oddDEF({L1},"a",{L3},37))#2:^(37),1:0)`
`SequenceNumber`	`%Integer`	序号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"a",{L3},11))#2:^(11),1:0)`
`ServerOnly`	`%CacheString`	指定属性不会投影到 `Java` 或 `C++` 客户端。	`57`	`s {ServerOnly}=$s($d(^oddDEF({L1},"a",{L3},57))#2:^(57),1:"")`
`SqlCollation`	`%CacheString`	弃用	`42`	`s {SqlCollation}=$s($d(^oddDEF({L1},"a",{L3},42))#2:^(42),1:"")`
`SqlColumnNumber`	`%CacheString`	显式设置此属性的 `SQL` 列号。这是为了支持遗留应用程序而提供的。	`43`	`s {SqlColumnNumber}=$s($d(^oddDEF({L1},"a",{L3},43))#2:^(43),1:"")`
`SqlComputeCode`	`%CacheString`	指定缓存计算字段值的 `ObjectScript` 代码。	`44`	`s {SqlComputeCode}=$s($d(^oddDEF({L1},"a",{L3},44))#2:^(44),1:"")`
`SqlComputeOnChange`	`%CacheString`	指定一个或多个属性，其修改将触发 `SQL` 中此计算字段的重新计算。	`46`	`s {SqlComputeOnChange}=$s($d(^oddDEF({L1},"a",{L3},46))#2:^(46),1:"")`
`SqlComputed`	`%Boolean`	指定此属性是 `SQL` 计算字段。	`45`	`s {SqlComputed}=$s($d(^oddDEF({L1},"a",{L3},45))#2:^(45),1:0)`
`SqlFieldName`	`%CacheString`	对于持久类，指定用于标识其 `SQL` 映射中的属性的列名。默认情况下`SQL` 列名称与属性名称相同。	`47`	`s {SqlFieldName}=$s($d(^oddDEF({L1},"a",{L3},47))#2:^(47),1:"")`
`SqlListDelimiter`	`%CacheString`	指定 `SQL` 中用于列表的分隔符。这是为了支持遗留应用程序而提供的。	`48`	`s {SqlListDelimiter}=$s($d(^oddDEF({L1},"a",{L3},48))#2:^(48),1:"")`
`SqlListType`	`%CacheString`	指定用于列表的表示形式。	`49`	`s {SqlListType}=$s($d(^oddDEF({L1},"a",{L3},49))#2:^(49),1:"")`
`Transient`	`%Boolean`	对于持久类，指定该属性不存储在数据库中。	`51`	`s {Transient}=$s($d(^oddDEF({L1},"a",{L3},51))#2:^(51),1:0)`
`Type`	`%Dictionary.CacheClassname`	指定与属性关联的类的名称，该类可以是数据类型类、持久类或可嵌入串行类。	`5`	`s {Type}=$s($d(^oddDEF({L1},"a",{L3},5))#2:^(5),1:"")`
`_Identity`			`56`	`s {_Identity}=$s($d(^oddDEF({L1},"a",{L3},56))#2:^(56),1:0)`

`%Dictionary.PropertyUDLTextDefinition` - `PropertyUDLText`定义表

该表为%Dictionary.PropertyDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"a",{%Dictionary.ForeignKeyDefinition.Name},"u",{%Dictionary.PropertyUDLTextDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.ForeignKeyDefinition.Name - 外键名
%Dictionary.PropertyUDLTextDefinition.Name - PropertyUDLText名

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Category`	`%CacheString`	目录	`23`	`s {Category}=$s($d(^oddDEF({L1},"a",{L3},"u",{L5},23))#2:^(23),1:"comment")`
`Content`	`%Stream.TmpCharacter`	保存 `UDL` 文本的内容。	`0`	`s {Content}=""`
`Position`	`%CacheString`	位置	`24`	`s {Position}=$s($d(^oddDEF({L1},"a",{L3},"u",{L5},24))#2:^(24),1:"body")`
`SequenceNumber`	`%Integer`	序号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"a",{L3},"u",{L5},11))#2:^(11),1:0)`
`TextType`	`%Integer`	文本类型	`22`	`s {TextType}=$s($d(^oddDEF({L1},"a",{L3},"u",{L5},22))#2:^(22),1:0)`

`%Dictionary.QueryDefinition` - 查询定义表

简介

新建或修改Query定义时会修改此表字段。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"q",{%Dictionary.QueryDefinition.Name}

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.QueryDefinition.Name - 查询名

示例

添加User.Human类如下Query方法：

Query QueryPersonByName(name As %String = "") As %SQLQuery(COMPILEMODE = "IMMEDIATE", CONTAINID = 1, ROWSPEC = "id:%Integer:ID,name:%String,age:%String", SELECTMODE = "RUNTIME") [ SqlName = QueryPersonByName, SqlProc ]
{
	SELECT top 10 ID, name, age
	FROM SQLUser.Human
	WHERE (name %STARTSWITH :name)
	ORDER BY id
}

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","q")
^oddDEF("User.Human","q","QueryPersonByName")=""
^oddDEF("User.Human","q","QueryPersonByName",4)="d ##class(%ResultSet).RunQuery(""M.Query"", ""QueryPersonByName"")"
^oddDEF("User.Human","q","QueryPersonByName",5)="%SQLQuery"
^oddDEF("User.Human","q","QueryPersonByName",11)=1
^oddDEF("User.Human","q","QueryPersonByName",24)="name:%String="""""
^oddDEF("User.Human","q","QueryPersonByName",27)="QueryPersonByName"
^oddDEF("User.Human","q","QueryPersonByName",28)=1
^oddDEF("User.Human","q","QueryPersonByName",29)=$c(9)_"SELECT top 10 ID, name, age"_$c(13,10,9)_"FROM SQLUser.Human"_$c(13,10,9)_"WHERE (name %STARTSWITH :name)"_$c(13,10,9)_"ORDER BY id"
^oddDEF("User.Human","q","QueryPersonByName","P","COMPILEMODE")="IMMEDIATE"
^oddDEF("User.Human","q","QueryPersonByName","P","CONTAINID")=1
^oddDEF("User.Human","q","QueryPersonByName","P","ROWSPEC")="id:%Integer:ID,name:%String,age:%String"
^oddDEF("User.Human","q","QueryPersonByName","P","SELECTMODE")="RUNTIME"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`ClientName`	`%CacheString`	客户端名称	`41`	`s {ClientName}=$s($d(^oddDEF({L1},"q",{L3},41))#2:^(41),1:"")`
`Deprecated`	`%Boolean`	如果此查询已弃用，则为 `True`。	`17`	`s {Deprecated}=$s($d(^oddDEF({L1},"q",{L3},17))#2:^(17),1:0)`
`Description`	`%CacheString`	指定查询的描述。	`4`	`s {Description}=$s($d(^oddDEF({L1},"q",{L3},4))#2:^(4),1:"")`
`Final`	`%Boolean`	指定子类不能覆盖查询的定义。	`7`	`s {Final}=$s($d(^oddDEF({L1},"q",{L3},7))#2:^(7),1:0)`
`FormalSpec`	`%CacheString`	指定传递给`Execute`方法的参数列表。每个参数的格式为`[&	][:][=]`，其中`&`表示按引用传递，``表示仅输出。
`Internal`	`%Boolean`	如果为true，则不要在自动文档中显示此项。	`14`	`s {Internal}=$s($d(^oddDEF({L1},"q",{L3},14))#2:^(14),1:0)`
`NotInheritable`	`%Boolean`	弃用	`9`	`s {NotInheritable}=$s($d(^oddDEF({L1},"q",{L3},9))#2:^(9),1:0)`
`Parameters`	`%CacheString`	参数	`0`	`n sub s {Parameters}="",sub="" f s sub=$o(^oddDEF({L1},"q",{L3},"P",sub)) q:sub="" s {Parameters}={Parameters}_$lb($lb(sub,$g(^oddDEF({L1},"q",{L3},"P",sub))))`
`Private`	`%Boolean`	弃用	`26`	`s {Private}=$s($d(^oddDEF({L1},"q",{L3},26))#2:^(26),1:0)`
`SequenceNumber`	`%Integer`	序号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"q",{L3},11))#2:^(11),1:0)`
`SoapBindingStyle`	`%CacheString`	指定用于`web`方法的`SOAP`调用的类型。非`web`方法忽略此关键字。	`35`	`s {SoapBindingStyle}=$s($d(^oddDEF({L1},"q",{L3},35))#2:^(35),1:"")`
`SoapBodyUse`	`%CacheString`	指定用于`web`方法的输入和输出的`SOAP`编码类型。非`web`方法忽略此关键字。	`36`	`s {SoapBodyUse}=$s($d(^oddDEF({L1},"q",{L3},36))#2:^(36),1:"")`
`SoapNameSpace`	`%CacheString`	Soap命名空间	`37`	`s {SoapNameSpace}=$s($d(^oddDEF({L1},"q",{L3},37))#2:^(37),1:"")`
`SqlName`	`%CacheString`	如果将此查询映射为`SQL`存储过程，则使用此名称作为存储过程的名称。	`27`	`s {SqlName}=$s($d(^oddDEF({L1},"q",{L3},27))#2:^(27),1:"")`
`SqlProc`	`%Boolean`	指定查询可以作为`SQL`存储过程调用。	`28`	`s {SqlProc}=$s($d(^oddDEF({L1},"q",{L3},28))#2:^(28),1:0)`
`SqlQuery`	`%CacheString`	指定要用于基于`SQL`的查询的`SQL`语句。	`29`	`s {SqlQuery}=$s($d(^oddDEF({L1},"q",{L3},29))#2:^(29),1:"")`
`SqlView`	`%Boolean`	指定是否将此查询映射为`SQL`视图。	`30`	`s {SqlView}=$s($d(^oddDEF({L1},"q",{L3},30))#2:^(30),1:0)`
`SqlViewName`	`%CacheString`	为从该查询映射的视图指定`SQL`别名。	`31`	`s {SqlViewName}=$s($d(^oddDEF({L1},"q",{L3},31))#2:^(31),1:"")`
`Type`	`%Dictionary.CacheClassname`	指定用于提供查询接口实现的`Query`类。	`5`	`s {Type}=$s($d(^oddDEF({L1},"q",{L3},5))#2:^(5),1:"")`
`WebMethod`	`%Boolean`	指定该查询可以使用`SOAP`协议调用。	`33`	`s {WebMethod}=$s($d(^oddDEF({L1},"q",{L3},33))#2:^(33),1:0)`

`%Dictionary.StorageDefinition` - `Storage`定义表

简介

新建或修改Storage定义时会修改此表字段。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.StorageDefinition.Name - Storage名

示例

User.Human类添加如下Storage定义：

Storage Default
{
<Data name="HumanDefaultData">
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>name</Value>
</Value>
<Value name="3">
<Value>age</Value>
</Value>
<Value name="4">
<Value>menu</Value>
</Value>
</Data>
<DataLocation>^User.HumanD</DataLocation>
<DefaultData>HumanDefaultData</DefaultData>
<IdLocation>^User.HumanD</IdLocation>
<IndexLocation>^User.HumanI</IndexLocation>
<StreamLocation>^User.HumanS</StreamLocation>
<Type>%Library.CacheStorage</Type>
}

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","s")
^oddDEF("User.Human","s","Default")=""
^oddDEF("User.Human","s","Default",5)="%Library.CacheStorage"
^oddDEF("User.Human","s","Default",11)=11
^oddDEF("User.Human","s","Default",21)="^User.HumanD"
^oddDEF("User.Human","s","Default",22)="HumanDefaultData"
^oddDEF("User.Human","s","Default",24)="^User.HumanD"
^oddDEF("User.Human","s","Default",25)="^User.HumanI"
^oddDEF("User.Human","s","Default",33)="^User.HumanS"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`CounterLocation`	`%CacheString`	为类型为`%Library.Counter`的属性指定计数器的基本位置。通常，这将是一个`Global`引用，如`^User.PersonC`。`Global`引用还可以包括一个或多个前导下标。	`36`	`s {CounterLocation}=$s($d(^oddDEF({L1},"s",{L3},36))#2:^(36),1:"")`
`DataLocation`	`%CacheString`	指定表达式，该表达式是该类的数据存储位置。通常，这将是`Global`引用，例如 `^User.PersonD`。`Global`引用还可以包括一个或多个前导下标。	`21`	`s {DataLocation}=$s($d(^oddDEF({L1},"s",{L3},21))#2:^(21),1:"")`
`DefaultData`	`%CacheString`	指定类编译器数据结构生成器用来放置任何以前未存储的属性的 `DATA` 定义的名称。如果属性可存储，但未在任何 `DATA` 定义中列出，则该属性未存储。	`22`	`s {DefaultData}=$s($d(^oddDEF({L1},"s",{L3},22))#2:^(22),1:"")`
`Deprecated`	`%Boolean`	如果此存储已弃用，则为 `true`。	`17`	`s {Deprecated}=$s($d(^oddDEF({L1},"s",{L3},17))#2:^(17),1:0)`
`Description`	`%CacheString`	指定存储定义的描述。此	`4`	`s {Description}=$s($d(^oddDEF({L1},"s",{L3},4))#2:^(4),1:"")`
`ExtentSize`	`%CacheString`	范围大小	`34`	`s {ExtentSize}=$s($d(^oddDEF({L1},"s",{L3},34))#2:^(34),1:"")`
`Final`	`%Boolean`	指定子类不能修改存储定义。	`7`	`s {Final}=$s($d(^oddDEF({L1},"s",{L3},7))#2:^(7),1:0)`
`IdExpression`	`%CacheString`	`Id`表达式	`23`	`s {IdExpression}=$s($d(^oddDEF({L1},"s",{L3},23))#2:^(23),1:"")`
`IdFunction`	`%CacheString`	指定用于分配新 `id` 值的系统函数。	`37`	`s {IdFunction}=$s($d(^oddDEF({L1},"s",{L3},37))#2:^(37),1:"")`
`IdLocation`	`%CacheString`	指定 `ID` 计数器的位置。	`24`	`s {IdLocation}=$s($d(^oddDEF({L1},"s",{L3},24))#2:^(24),1:"")`
`IndexLocation`	`%CacheString`	指定用于此类索引的`Global`。如果未指定，则索引位置为 `^MyApp.MyClassI`，其中 `MyApp.MyClass` 是类名。	`25`	`s {IndexLocation}=$s($d(^oddDEF({L1},"s",{L3},25))#2:^(25),1:"")`
`Internal`	`%Boolean`	如果为 `true`，则不在自动文档中显示此项。	`14`	`s {Internal}=$s($d(^oddDEF({L1},"s",{L3},14))#2:^(14),1:0)`
`SequenceNumber`	`%Integer`	序号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"s",{L3},11))#2:^(11),1:0)`
`SqlChildSub`	`%CacheString`	`SqlChildSub`	`27`	`s {SqlChildSub}=$s($d(^oddDEF({L1},"s",{L3},27))#2:^(27),1:"")`
`SqlIdExpression`	`%CacheString`	`SqlIdExpression`	`28`	`s {SqlIdExpression}=$s($d(^oddDEF({L1},"s",{L3},28))#2:^(28),1:"")`
`SqlRowIdName`	`%CacheString`	指定投影到 `SQL` 的行 `ID` 列的名称。	`29`	`s {SqlRowIdName}=$s($d(^oddDEF({L1},"s",{L3},29))#2:^(29),1:"")`
`SqlRowIdProperty`	`%CacheString`	指定 `SQL RowId` 属性。此关键字仅由从早期 `ISC` 产品迁移的类使用。	`30`	`s {SqlRowIdProperty}=$s($d(^oddDEF({L1},"s",{L3},30))#2:^(30),1:"")`
`SqlTableNumber`	`%CacheString`	指定内部 `SQL` 表号。此关键字仅由从早期 `ISC`产品迁移的类使用。	`31`	`s {SqlTableNumber}=$s($d(^oddDEF({L1},"s",{L3},31))#2:^(31),1:"")`
`State`	`%CacheString`	对于串行嵌入类，此关键字指定使用哪个数据定义来定义对象的序列化状态。这也是默认结构生成器将添加未存储属性的默认数据定义。	`32`	`s {State}=$s($d(^oddDEF({L1},"s",{L3},32))#2:^(32),1:"")`
`StreamLocation`	`%CacheString`	指定用于存储此类中流属性的默认`Global`值。如果未指定，则索引位置为 `^MyApp.MyClassS`，其中 `MyApp.MyClass` 是类名。	`33`	`s {StreamLocation}=$s($d(^oddDEF({L1},"s",{L3},33))#2:^(33),1:"")`
`Type`	`%Dictionary.CacheClassname`	指定用于为此类提供持久性的存储类。	`5`	`s {Type}=$s($d(^oddDEF({L1},"s",{L3},5))#2:^(5),1:"")`
`VersionLocation`	`%CacheString`	指定`%Version`计数器的位置。	`35`	`s {VersionLocation}=$s($d(^oddDEF({L1},"s",{L3},35))#2:^(35),1:"")`

`%Dictionary.StorageDataDefinition` - `StorageData`定义表

简介

新建或修改StorageData定义时会修改此表字段。

该表为%Dictionary.StorageDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"D",{%Dictionary.StorageDataDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.StorageDefinition.Name - Storage名称
%Dictionary.StorageDataDefinition.Name - StorageData名称

示例

User.Human类添加如下StorageData定义：

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","s","Default","D")
^oddDEF("User.Human","s","Default","D","HumanDefaultData")=""

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Attribute`	`%CacheString`	属性	`0`	`s {Attribute}=$g(^oddDEF({L1},"s",{L3},"D",{L5},21),$g(^%qCacheObjectKey(1,"D",21)))`
`Structure`	`%CacheString`	指定如何将数据存储到`Gloabl`节点中。	`0`	`s {Structure}=$g(^oddDEF({L1},"s",{L3},"D",{L5},22),$g(^%qCacheObjectKey(1,"D",22)))`
`Subscript`	`%CacheString`	下标	`0`	`s {Subscript}=$g(^oddDEF({L1},"s",{L3},"D",{L5},23),$g(^%qCacheObjectKey(1,"D",23)))`

`%Dictionary.StorageDataValueDefinition` - `StorageDataValue`定义表

简介

新建或修改StorageDataValue定义时会修改此表字段。

该表为%Dictionary.StorageDataDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"D",{%Dictionary.StorageDataDefinition.Name},"V",{%Dictionary.StorageDataValueDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.StorageDefinition.Name - Storage名称
%Dictionary.StorageDataDefinition.Name - StorageData名称
%Dictionary.StorageDataValueDefinition.Name - StorageDataValue名称

示例

User.Human类添加如下StorageDataValue定义：

<Data name="HumanDefaultData">
<Value name="1">
<Value>%%CLASSNAME</Value>
</Value>
<Value name="2">
<Value>name</Value>
</Value>
<Value name="3">
<Value>age</Value>
</Value>
<Value name="4">
<Value>menu</Value>
</Value>
<Value name="5">
<Value>role</Value>
</Value>
</Data>

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","s","Default","D")
^oddDEF("User.Human","s","Default","D","HumanDefaultData")=""
^oddDEF("User.Human","s","Default","D","HumanDefaultData","V",1)=""
^oddDEF("User.Human","s","Default","D","HumanDefaultData","V",1,21)="%%CLASSNAME"
^oddDEF("User.Human","s","Default","D","HumanDefaultData","V",2)=""
^oddDEF("User.Human","s","Default","D","HumanDefaultData","V",2,21)="name"
^oddDEF("User.Human","s","Default","D","HumanDefaultData","V",3)=""
^oddDEF("User.Human","s","Default","D","HumanDefaultData","V",3,21)="age"
^oddDEF("User.Human","s","Default","D","HumanDefaultData","V",4)=""
^oddDEF("User.Human","s","Default","D","HumanDefaultData","V",4,21)="menu"
^oddDEF("User.Human","s","Default","D","HumanDefaultData","V",5)=""
^oddDEF("User.Human","s","Default","D","HumanDefaultData","V",5,21)="role"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Value`	`%CacheString`	值	`0`	`s {Value}=$g(^oddDEF({L1},"s",{L3},"D",{L5},"V",{L7},21),$g(^%qCacheObjectKey(1,"V",21)))`

`%Dictionary.StorageIndexDefinition` - `StorageIndex`定义表

简介

新建或修改StorageIndex定义时会修改此表字段。

该表为%Dictionary.StorageDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"X",{%Dictionary.StorageIndexDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.StorageDefinition.Name - Storage名
%Dictionary.StorageIndexDefinition.Name - StorageIndex名称

示例

User.Human类添加如下StorageIndex定义：

<Index name="IndexName">
<Location>^User.HumanI</Location>
</Index>

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","s","Default","X")
^oddDEF("User.Human","s","Default","X","IndexName")=""
^oddDEF("User.Human","s","Default","X","IndexName",11)=1
^oddDEF("User.Human","s","Default","X","IndexName",21)="^User.HumanI"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Location`	`%CacheString`	位置	`21`	`s {Location}=$g(^oddDEF({L1},"s",{L3},"X",{L5},21),$g(^%qCacheObjectKey(1,"X",21)))`

`%Dictionary.StoragePropertyDefinition` - `StorageProperty`定义表

简介

新建或修改StorageProperty定义时会修改此表字段。

进行调优表时会自动添加该属性，调优表时需要表存在数据。

该表为%Dictionary.StorageDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"M",{%Dictionary.StoragePropertyDefinition.Name})
- %Dictionary.ClassDefinition.Name - 类名
- %Dictionary.StorageDefinition.Name - Storage名
- %Dictionary.StoragePropertyDefinition.Name - StorageProperty名称

示例

User.Status类进行调优表：

<Property name="%%CLASSNAME">
<AverageFieldSize>1</AverageFieldSize>
<Selectivity>100.0000%</Selectivity>
</Property>
<Property name="%%ID">
<AverageFieldSize>1.1</AverageFieldSize>
<Selectivity>1</Selectivity>
</Property>
<Property name="code">
<AverageFieldSize>3</AverageFieldSize>
<Selectivity>33.3333%</Selectivity>
</Property>
<Property name="name">
<AverageFieldSize>2</AverageFieldSize>
<Selectivity>33.3333%</Selectivity>
</Property>

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Status","s","Default","M")
^oddDEF("User.Status","s","Default","M","%%CLASSNAME",21)="100.0000%"
^oddDEF("User.Status","s","Default","M","%%CLASSNAME",26)=1
^oddDEF("User.Status","s","Default","M","%%ID",21)=1
^oddDEF("User.Status","s","Default","M","%%ID",26)=1.1
^oddDEF("User.Status","s","Default","M","code",21)="33.3333%"
^oddDEF("User.Status","s","Default","M","code",26)=3
^oddDEF("User.Status","s","Default","M","name",21)="33.3333%"
^oddDEF("User.Status","s","Default","M","name",26)=2

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`AverageFieldSize`	`%CacheString`	平均字段大小	`26`	`s {AverageFieldSize}=$g(^oddDEF({L1},"s",{L3},"M",{L5},26),$g(^%qCacheObjectKey(1,"M",26)))`
`BiasQueriesAsOutlier`	`%CacheString`	偏差查询作为异常值	`25`	`s {BiasQueriesAsOutlier}=$g(^oddDEF({L1},"s",{L3},"M",{L5},25),$g(^%qCacheObjectKey(1,"M",25)))`
`ChildBlockCount`	`%CacheString`	子块计数	`27`	`s {ChildBlockCount}=$g(^oddDEF({L1},"s",{L3},"M",{L5},27),$g(^%qCacheObjectKey(1,"M",27)))`
`ChildExtentSize`	`%CacheString`	子范围大小	`23`	`s {ChildExtentSize}=$g(^oddDEF({L1},"s",{L3},"M",{L5},23),$g(^%qCacheObjectKey(1,"M",23)))`
`OutlierSelectivity`	`%CacheString`	异常值选择性	`24`	`s {OutlierSelectivity}=$g(^oddDEF({L1},"s",{L3},"M",{L5},24),$g(^%qCacheObjectKey(1,"M",24)))`
`Selectivity`	`%CacheString`	离散值	`21`	`s {Selectivity}=$g(^oddDEF({L1},"s",{L3},"M",{L5},21),$g(^%qCacheObjectKey(1,"M",21)))`
`StreamLocation`	`%CacheString`	流位置	`22`	`s {StreamLocation}=$g(^oddDEF({L1},"s",{L3},"M",{L5},22),$g(^%qCacheObjectKey(1,"M",22)))`

`%Dictionary.StorageSQLMapDefinition` - `StorageSQLMap`定义表

简介

新建或修改StorageSQLMap定义时会修改此表字段。

此表为储存定义为SQLStorage时生效。

该表为%Dictionary.StorageDefinition子表。

取值

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name})
- %Dictionary.ClassDefinition.Name - 类名
- %Dictionary.StorageDefinition.Name - Storage名
- %Dictionary.StorageSQLMapDefinition.Name - StorageSQLMap名称

示例

User.Human类增加SQLStorage并且维护主索引Master，如下：

Storage SQLStorage
{
<SQLMap name="Master">
<ConditionalWithHostVars></ConditionalWithHostVars>
<Data name="age">
<Delimiter>"^"</Delimiter>
<Piece>2</Piece>
</Data>
<Data name="menu">
<Delimiter>"^"</Delimiter>
<Piece>3</Piece>
</Data>
<Data name="name">
<Delimiter>"^"</Delimiter>
<Piece>1</Piece>
</Data>
<Global>^User.Human</Global>
<PopulationType>nonnull</PopulationType>
<Subscript name="1">
<Expression>{id}</Expression>
</Subscript>
<Type>data</Type>
</SQLMap>
<StreamLocation>^User.HumanS</StreamLocation>
<Type>%CacheSQLStorage</Type>
}

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","s","SQLStorage","S")
^oddDEF("User.Human","s","SQLStorage","S","Master")=""
^oddDEF("User.Human","s","SQLStorage","S","Master",5)="data"
^oddDEF("User.Human","s","SQLStorage","S","Master",11)=1
^oddDEF("User.Human","s","SQLStorage","S","Master",22)=""
^oddDEF("User.Human","s","SQLStorage","S","Master",24)="^User.Human"
^oddDEF("User.Human","s","SQLStorage","S","Master",26)="nonnull"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`BlockCount`	`%Integer`	块数	`29`	`s {BlockCount}=$g(^oddDEF({L1},"s",{L3},"S",{L5},29),$g(^%qCacheObjectKey(1,"S",29)))`
`Condition`	`%CacheString`	条件	`21`	`s {Condition}=$g(^oddDEF({L1},"s",{L3},"S",{L5},21),$g(^%qCacheObjectKey(1,"S",21)))`
`ConditionFields`	`%CacheString`	条件字段	`23`	`s {ConditionFields}=$g(^oddDEF({L1},"s",{L3},"S",{L5},23),$g(^%qCacheObjectKey(1,"S",23)))`
`ConditionalWithHostVars`	`%Boolean`	有条件的主机变量	`22`	`s {ConditionalWithHostVars}=$g(^oddDEF({L1},"s",{L3},"S",{L5},22),$g(^%qCacheObjectKey(1,"S",22)))`
`PopulationPct`	`%CacheString`	`PopulationPct`	`25`	`s {PopulationPct}=$g(^oddDEF({L1},"s",{L3},"S",{L5},25),$g(^%qCacheObjectKey(1,"S",25)))`
`PopulationType`	`%CacheString`	填充类型	`26`	`s {PopulationType}=$g(^oddDEF({L1},"s",{L3},"S",{L5},26),$g(^%qCacheObjectKey(1,"S",26)))`
`RowReference`	`%CacheString`	行引用	`27`	`s {RowReference}=$g(^oddDEF({L1},"s",{L3},"S",{L5},27),$g(^%qCacheObjectKey(1,"S",27)))`
`Structure`	`%CacheString`	结构	`28`	`s {Structure}=$g(^oddDEF({L1},"s",{L3},"S",{L5},28),$g(^%qCacheObjectKey(1,"S",28)))`
`Type`	`%CacheString`	指定这是什么类型的映射。	`5`	`s {Type}=$g(^oddDEF({L1},"s",{L3},"S",{L5},5),$g(^%qCacheObjectKey(1,"S",5)))`
`_Global`			`24`	`s {_Global}=$g(^oddDEF({L1},"s",{L3},"S",{L5},24),$g(^%qCacheObjectKey(1,"S",24)))`

`%Dictionary.StorageSQLMapDataDefinition` -`StorageSQLMapData`定义表

简介

新建或修改StorageSQLMapData定义时会修改此表字段。

此表为储存定义为SQLStorage时生效。

该表为%Dictionary.StorageSQLMapDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name},"T",{%Dictionary.StorageSQLMapDataDefinition.Name})
- %Dictionary.ClassDefinition.Name - 类名
- %Dictionary.StorageDefinition.Name - Storage名
- %Dictionary.StorageSQLMapDefinition.Name - StorageSQLMap名称
- %Dictionary.StorageSQLMapDataDefinition.Name - StorageSQLMapData名称

示例

User.Human类增加SQLStorage并且维护主索引Master，添加字段映射，如下：

<Data name="age">
<Delimiter>"^"</Delimiter>
<Piece>2</Piece>
</Data>
<Data name="menu">
<Delimiter>"^"</Delimiter>
<Piece>3</Piece>
</Data>
<Data name="name">
<Delimiter>"^"</Delimiter>
<Piece>1</Piece>
</Data>

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","s","SQLStorage","S","Master","T")
^oddDEF("User.Human","s","SQLStorage","S","Master","T","age")=""
^oddDEF("User.Human","s","SQLStorage","S","Master","T","age",11)=14
^oddDEF("User.Human","s","SQLStorage","S","Master","T","age",21)="""^"""
^oddDEF("User.Human","s","SQLStorage","S","Master","T","age",23)=2
^oddDEF("User.Human","s","SQLStorage","S","Master","T","menu")=""
^oddDEF("User.Human","s","SQLStorage","S","Master","T","menu",11)=15
^oddDEF("User.Human","s","SQLStorage","S","Master","T","menu",21)="""^"""
^oddDEF("User.Human","s","SQLStorage","S","Master","T","menu",23)=3
^oddDEF("User.Human","s","SQLStorage","S","Master","T","name")=""
^oddDEF("User.Human","s","SQLStorage","S","Master","T","name",11)=13
^oddDEF("User.Human","s","SQLStorage","S","Master","T","name",21)="""^"""
^oddDEF("User.Human","s","SQLStorage","S","Master","T","name",23)=1

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Delimiter`	`%CacheString`	分隔符	`21`	`s {Delimiter}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"T",{L7},21),$g(^%qCacheObjectKey(1,"T",21)))`
`Node`	`%CacheString`	节点	`22`	`s {Node}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"T",{L7},22),$g(^%qCacheObjectKey(1,"T",22)))`
`Piece`	`%CacheString`	位置	`23`	`s {Piece}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"T",{L7},23),$g(^%qCacheObjectKey(1,"T",23)))`
`RetrievalCode`	`%CacheString`	检索码	`24`	`s {RetrievalCode}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"T",{L7},24),$g(^%qCacheObjectKey(1,"T",24)))`

`%Dictionary.StorageSQLMapRowIdSpecDefinition` - `StorageSQLMapRowIdSpec`定义表

简介

新建或修改StorageSQLMapRowIdSpec定义时会修改此表字段。

此表为储存定义为SQLStorage时生效。

该表为%Dictionary.StorageSQLMapDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name},"R",{%Dictionary.StorageSQLMapRowIdSpecDefinition.Name})
- %Dictionary.ClassDefinition.Name - 类名
- %Dictionary.StorageDefinition.Name - Storage名
- %Dictionary.StorageSQLMapDefinition.Name - StorageSQLMap名称
- %Dictionary.StorageSQLMapRowIdSpecDefinition.Name - StorageSQLMapRowIdSpec名称

示例

User.Human类增加SQLStorage并且维护主索引Master，添加RowID映射，如下：

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","s","SQLStorage","S","Master","R")
^oddDEF("User.Human","s","SQLStorage","S","Master","R",1)=""
^oddDEF("User.Human","s","SQLStorage","S","Master","R",1,11)=21
^oddDEF("User.Human","s","SQLStorage","S","Master","R",1,21)="{L1}"
^oddDEF("User.Human","s","SQLStorage","S","Master","R",1,22)="id"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Expression`	`%CacheString`	Expression	`21`	`s {Expression}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"R",{L7},21),$g(^%qCacheObjectKey(1,"R",21)))`
`Field`	`%CacheString`	Field	`22`	`s {Field}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"R",{L7},22),$g(^%qCacheObjectKey(1,"R",22)))`

`%Dictionary.StorageSQLMapSubDefinition` - `StorageSQLMapSub`定义表

简介

新建或修改StorageSQLMapSub定义时会修改此表字段。

此表为储存定义为SQLStorage时生效。

该表为%Dictionary.StorageSQLMapDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name},"B",{%Dictionary.StorageSQLMapSubDefinition.Name})
- %Dictionary.ClassDefinition.Name - 类名
- %Dictionary.StorageDefinition.Name - Storage名
- %Dictionary.StorageSQLMapDefinition.Name - StorageSQLMap名称
- %Dictionary.StorageSQLMapSubDefinition.Name - StorageSQLMapSub名称

示例

User.Human类增加SQLStorage并且维护主索引Master，添加Subscripts映射，如下：

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","s","SQLStorage","S","Master","B")
^oddDEF("User.Human","s","SQLStorage","S","Master","B",1)=""
^oddDEF("User.Human","s","SQLStorage","S","Master","B",1,11)=20
^oddDEF("User.Human","s","SQLStorage","S","Master","B",1,24)="{id}"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`AccessType`	`%CacheString`	接入类型	`0`	`s {AccessType}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},21),$g(^%qCacheObjectKey(1,"B",21)))`
`DataAccess`	`%CacheString`	数据存取	`0`	`s {DataAccess}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},22),$g(^%qCacheObjectKey(1,"B",22)))`
`Delimiter`	`%CacheString`	分隔符	`0`	`s {Delimiter}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},23),$g(^%qCacheObjectKey(1,"B",23)))`
`Expression`	`%CacheString`	表达式	`0`	`s {Expression}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},24),$g(^%qCacheObjectKey(1,"B",24)))`
`LoopInitValue`	`%CacheString`	循环初始值	`0`	`s {LoopInitValue}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},25),$g(^%qCacheObjectKey(1,"B",25)))`
`NextCode`	`%CacheString`	下一个代码	`0`	`s {NextCode}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},26),$g(^%qCacheObjectKey(1,"B",26)))`
`NullMarker`	`%CacheString`	空标记	`0`	`s {NullMarker}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},27),$g(^%qCacheObjectKey(1,"B",27)))`
`StartValue`	`%CacheString`	起始值	`0`	`s {StartValue}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},28),$g(^%qCacheObjectKey(1,"B",28)))`
`StopExpression`	`%CacheString`	停止表达式	`0`	`s {StopExpression}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},29),$g(^%qCacheObjectKey(1,"B",29)))`
`StopValue`	`%CacheString`	停止值	`0`	`s {StopValue}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},30),$g(^%qCacheObjectKey(1,"B",30)))`

`%Dictionary.StorageSQLMapSubAccessvarDefinition` - `StorageSQLMapSubAccessvar`定义表

简介

新建或修改StorageSQLMapSubAccessvar定义时会修改此表字段。

此表为储存定义为SQLStorage时生效。

该表为%Dictionary.StorageSQLMapSubDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name},"B",{%Dictionary.StorageSQLMapSubDefinition.Name},"A",{%Dictionary.StorageSQLMapSubAccessvarDefinition.Name})
- %Dictionary.ClassDefinition.Name - 类名
- %Dictionary.StorageDefinition.Name - Storage名
- %Dictionary.StorageSQLMapDefinition.Name - StorageSQLMap名称
- %Dictionary.StorageSQLMapSubDefinition.Name - StorageSQLMapSub名称
- %Dictionary.StorageSQLMapSubAccessvarDefinition.Name - StorageSQLMapSubAccessvar名称

示例

在表的Storage的Subscripts中AccessVariables中维护：

查询SQL表：

Global示例：

USER>zw ^oddDEF("%SYS.ProcessQuery","s","Process","S","Map1","B",1,"A")
^oddDEF("%SYS.ProcessQuery","s","Process","S","Map1","B",1,"A",1)=""
^oddDEF("%SYS.ProcessQuery","s","Process","S","Map1","B",1,"A",1,21)=" s {1D1}=$zu(67,3,{L1})"
^oddDEF("%SYS.ProcessQuery","s","Process","S","Map1","B",1,"A",1,22)="{1D1}"
^oddDEF("%SYS.ProcessQuery","s","Process","S","Map1","B",1,"A",2)=""
^oddDEF("%SYS.ProcessQuery","s","Process","S","Map1","B",1,"A",2,21)=" s {1D2}="""""
^oddDEF("%SYS.ProcessQuery","s","Process","S","Map1","B",1,"A",2,22)="{1D2}"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Code`	`%CacheString`	代码	`21`	`s {Code}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},"A",{L9},21),$g(^%qCacheObjectKey(1,"A",21)))`
`Variable`	`%CacheString`	变量	`22`	`s {Variable}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},"A",{L9},22),$g(^%qCacheObjectKey(1,"A",22)))`

`%Dictionary.StorageSQLMapSubInvalidconditionDefinition` - `StorageSQLMapSubInvalidcondition`定义表

简介

新建或修改StorageSQLMapSubInvalidcondition定义时会修改此表字段。

此表为储存定义为SQLStorage时生效。

该表为%Dictionary.StorageSQLMapSubDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name},"B",{%Dictionary.StorageSQLMapSubDefinition.Name},"N","{%Dictionary.StorageSQLMapSubInvalidconditionDefinition.Name}")
- %Dictionary.ClassDefinition.Name - 类名
- %Dictionary.StorageDefinition.Name - Storage名
- %Dictionary.StorageSQLMapDefinition.Name - StorageSQLMap名称
- %Dictionary.StorageSQLMapSubDefinition.Name - StorageSQLMapSub名称
- %Dictionary.StorageSQLMapSubInvalidconditionDefinition.Name - StorageSQLMapSubInvalidcondition名称

示例

在表的Storage的Subscripts中Invalidconditions中维护：

查询SQL表：

Global示例：

USER>zw ^oddDEF("%SYS.ProcessQuery","s","Process","S","Map1","B",1,"N")
^oddDEF("%SYS.ProcessQuery","s","Process","S","Map1","B",1,"N",1)=""
^oddDEF("%SYS.ProcessQuery","s","Process","S","Map1","B",1,"N",1,21)="##Class(%SYS.ProcessQuery).AllowToOpen({L1})'=1"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Expression`	`%CacheString`	表达式	`0`	`s {Expression}=$g(^oddDEF({L1},"s",{L3},"S",{L5},"B",{L7},"N",{L9},21),$g(^%qCacheObjectKey(1,"N",21)))`

`%Dictionary.TriggerDefinition` - 触发器定义表

简介

新建或修改触发器时会修改此表字段。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"t",{%Dictionary.TriggerDefinition.Name})
- %Dictionary.ClassDefinition.Name - 类名
- %Dictionary.TriggerDefinition.Name - 触发器名称

示例

添加User.Human类如下LogEvent触发器：

Trigger LogEvent [ Event = INSERT, Time = AFTER ]
{
}

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","t")
^oddDEF("User.Human","t","LogEvent")=""
^oddDEF("User.Human","t","LogEvent",11)=1
^oddDEF("User.Human","t","LogEvent",22)="INSERT"
^oddDEF("User.Human","t","LogEvent",25)="AFTER"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Code`	`%CacheString`	触发触发器时执行的代码。	`21`	`s {Code}=$s($d(^oddDEF({L1},"t",{L3},21))#2:^(21),1:"")`
`CodeMode`	`%CacheString`	指定如何实现给定方法：要编译的代码行，或将生成结果方法或对象的方法。	`31`	`s {CodeMode}=$s($d(^oddDEF({L1},"t",{L3},31))#2:^(31),1:"code")`
`Deprecated`	`%Boolean`	如果此触发器已弃用，则为 `True`。	`17`	`s {Deprecated}=$s($d(^oddDEF({L1},"t",{L3},17))#2:^(17),1:0)`
`Description`	`%CacheString`	指定 `SQL` 触发器的描述。	`4`	`s {Description}=$s($d(^oddDEF({L1},"t",{L3},4))#2:^(4),1:"")`
`Event`	`%CacheString`	指定将触发触发器的 `SQL` 事件。	`22`	`s {Event}=$s($d(^oddDEF({L1},"t",{L3},22))#2:^(22),1:"")`
`Final`	`%Boolean`	指定子类不能覆盖 `SQL` 触发器的定义。	`7`	`s {Final}=$s($d(^oddDEF({L1},"t",{L3},7))#2:^(7),1:0)`
`Foreach`	`%CacheString`	指示是否将为每行、行和对象或每个语句调用触发器	`26`	`s {Foreach}=$s($d(^oddDEF({L1},"t",{L3},26))#2:^(26),1:"")`
`Internal`	`%Boolean`	如果为 `true`，则不在自动文档中显示此项。	`14`	`s {Internal}=$s($d(^oddDEF({L1},"t",{L3},14))#2:^(14),1:0)`
`NewTable`	`%CacheString`	保存触发器新值的 `SQL` 表的名称。	`29`	`s {NewTable}=$s($d(^oddDEF({L1},"t",{L3},29))#2:^(29),1:"")`
`OldTable`	`%CacheString`	保存触发器旧值的 `SQL` 表的名称。	`30`	`s {OldTable}=$s($d(^oddDEF({L1},"t",{L3},30))#2:^(30),1:"")`
`Order`	`%Integer`	如果同一事件和时间有多个触发器，请指定触发器的触发顺序。	`23`	`s {Order}=$s($d(^oddDEF({L1},"t",{L3},23))#2:^(23),1:0)`
`SequenceNumber`	`%Integer`	序号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"t",{L3},11))#2:^(11),1:0)`
`SqlName`	`%CacheString`	指定 `SQL` 使用此触发器时的备用名称。	`24`	`s {SqlName}=$s($d(^oddDEF({L1},"t",{L3},24))#2:^(24),1:"")`
`UpdateColumnList`	`%CacheString`	指定一个或多个列，其修改会导致 `SQL` 拉动触发器。	`28`	`s {UpdateColumnList}=$s($d(^oddDEF({L1},"t",{L3},28))#2:^(28),1:"")`
`_Language`			`27`	`s {_Language}=$s($d(^oddDEF({L1},"t",{L3},27))#2:^(27),1:"")`
`_Time`			`25`	`s {_Time}=$s($d(^oddDEF({L1},"t",{L3},25))#2:^(25),1:"BEFORE")`

`%Dictionary.UDLTextDefinition` - `UDLText`定义表

简介

新建或修改UDLText时会修改此表字段。

该注释只在类中生效，在方法中不会添加到此表中。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"u",{%Dictionary.UDLTextDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.UDLTextDefinition.Name - UDLText名

示例

添加User.Human类\\注释：

// todo:对外提供接口

// Property type As %String;

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","u")
^oddDEF("User.Human","u","T1")=""
^oddDEF("User.Human","u","T1",11)=1
^oddDEF("User.Human","u","T1",21)=2
^oddDEF("User.Human","u","T1",21,1)="// todo:对外提供接口"
^oddDEF("User.Human","u","T1",21,2)=""
^oddDEF("User.Human","u","T2")=""
^oddDEF("User.Human","u","T2",11)=2
^oddDEF("User.Human","u","T2",21)=2
^oddDEF("User.Human","u","T2",21,1)="// Property type As %String;"
^oddDEF("User.Human","u","T2",21,2)=""

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Category`	`%CacheString`	Category	`23`	`s {Category}=$s($d(^oddDEF({L1},"u",{L3},23))#2:^(23),1:"comment")`
`Content`	`%Stream.TmpCharacter`	保存 `UDL` 文本的内容。	`0`	`s {Content}=""`
`Position`	`%CacheString`	位置	`24`	`s {Position}=$s($d(^oddDEF({L1},"u",{L3},24))#2:^(24),1:"body")`
`SequenceNumber`	`%Integer`	序号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"u",{L3},11))#2:^(11),1:0)`
`TextType`	`%Integer`	文本类型	`22`	`s {TextType}=$s($d(^oddDEF({L1},"u",{L3},22))#2:^(22),1:0)`

`%Dictionary.XDataDefinition` - `XData`定义表

简介

新建或修改XData时会修改此表字段。

该表为%Dictionary.ClassDefinition子表。

索引

取值索引 - ^oddDEF({%Dictionary.ClassDefinition.Name},"x",{%Dictionary.XDataDefinition.Name})

%Dictionary.ClassDefinition.Name - 类名
%Dictionary.XDataDefinition.Name - XData名

示例

添加User.Human类如下Xdata：

XData XmlData [ MimeType = application/xml ]
{
<person>
 <name>yx</name>
 <age>18</age>
</person>
}

查询SQL表：

Global示例：

USER>zw ^oddDEF("User.Human","x")
^oddDEF("User.Human","x","XmlData")=""
^oddDEF("User.Human","x","XmlData",11)=16
^oddDEF("User.Human","x","XmlData",21)=4
^oddDEF("User.Human","x","XmlData",21,1)=""
^oddDEF("User.Human","x","XmlData",21,2)=" yx"
^oddDEF("User.Human","x","XmlData",21,3)=" 18"
^oddDEF("User.Human","x","XmlData",21,4)=""
^oddDEF("User.Human","x","XmlData",24)="application/xml"

表结构

字检	类型	描述	位置	检索码
`ID1`
`parent`	`%Dictionary.ClassDefinition`	指向包含父对象的指针
`Name`	`%Dictionary.Identifier`
`Data`	`%Stream.TmpCharacter`	数据流。	`0`	`s {Data}=""`
`Deprecated`	`%Boolean`	如果此 `XDATA` 已弃用，则为 `True`。	`17`	`s {Deprecated}=$s($d(^oddDEF({L1},"x",{L3},17))#2:^(17),1:0)`
`Description`	`%CacheString`	指定 `XData` 的描述。	`4`	`s {Description}=$s($d(^oddDEF({L1},"x",{L3},4))#2:^(4),1:"")`
`Internal`	`%Boolean`	如果为真，则不在文档中显示此项。	`14`	`s {Internal}=$s($d(^oddDEF({L1},"x",{L3},14))#2:^(14),1:0)`
`MimeType`	`%CacheString`	`XData` 块的 `Mime` 类型。	`24`	`s {MimeType}=$s($d(^oddDEF({L1},"x",{L3},24))#2:^(24),1:"text/xml")`
`SchemaSpec`	`%CacheString`	数据的模式定义。	`22`	`s {SchemaSpec}=$s($d(^oddDEF({L1},"x",{L3},22))#2:^(22),1:"")`
`SequenceNumber`	`%Integer`	序号	`11`	`s {SequenceNumber}=$s($d(^oddDEF({L1},"x",{L3},11))#2:^(11),1:0)`
`XMLNamespace`	`%CacheString`	`XDATA` 的默认 `XML` 命名空间。	`23`	`s {XMLNamespace}=$s($d(^oddDEF({L1},"x",{L3},23))#2:^(23),1:"")`

`^oddDEF`一览

表名	索引关键字	索引
`%Dictionary.ClassDefinition`		`^oddDEF({%Dictionary.ClassDefinition.Name})`
`%Dictionary.ForeignKeyDefinition`	`f`	`^oddDEF({%Dictionary.ClassDefinition.Name},"f",{%Dictionary.ForeignKeyDefinition.Name})`
`%Dictionary.IndexDefinition`	`i`	`^oddDEF({%Dictionary.ClassDefinition.Name},"i",{%Dictionary.IndexDefinition.Name})`
`%Dictionary.MethodDefinition`	`m`	`^oddDEF({%Dictionary.ClassDefinition.Name},"m",{%Dictionary.MethodDefinition.Name})`
`%Dictionary.ParameterDefinition`	`p`	`^oddDEF({%Dictionary.ClassDefinition.Name},"p",{%Dictionary.ParameterDefinition.Name})`
`%Dictionary.ProjectionDefinition`	`j`	`^oddDEF({%Dictionary.ClassDefinition.Name},"j",{%Dictionary.ProjectionDefinition.Name})`
`%Dictionary.PropertyDefinition`	`a`	`^oddDEF({%Dictionary.ClassDefinition.Name},"a",{%Dictionary.PropertyDefinition.Name})`
`%Dictionary.PropertyUDLTextDefinition`	`a,u`	`^oddDEF({%Dictionary.ClassDefinition.Name},"a",{%Dictionary.ForeignKeyDefinition.Name},"u",{%Dictionary.PropertyUDLTextDefinition.Name})`
`%Dictionary.QueryDefinition`	`q`	`^oddDEF({%Dictionary.ClassDefinition.Name},"q",{%Dictionary.QueryDefinition.Name}`
`%Dictionary.StorageDefinition`	`s`	`^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name})`
`%Dictionary.StorageDataDefinition`	`s,D`	`^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"D",{%Dictionary.StorageDataDefinition.Name})`
`%Dictionary.StorageDataValueDefinition`	`s,D,V`	`^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"D",{%Dictionary.StorageDataDefinition.Name},"V",{%Dictionary.StorageDataValueDefinition.Name})`
`%Dictionary.StorageIndexDefinition`	`s,X`	`^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"X",{%Dictionary.StorageIndexDefinition.Name})`
`%Dictionary.StoragePropertyDefinition`	`s,M`	`^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"M",{%Dictionary.StoragePropertyDefinition.Name})`
`%Dictionary.StorageSQLMapDefinition`	`s,S`	`^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name})`
`%Dictionary.StorageSQLMapDataDefinition`	`s,S,T`	- `^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name},"T",{%Dictionary.StorageSQLMapDataDefinition.Name})`
`%Dictionary.StorageSQLMapRowIdSpecDefinition`	`s,S,R`	`^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name},"R",{%Dictionary.StorageSQLMapRowIdSpecDefinition.Name})`
`%Dictionary.StorageSQLMapSubDefinition`	`s,S,B`	`^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name},"B",{%Dictionary.StorageSQLMapSubDefinition.Name})`
`%Dictionary.StorageSQLMapSubAccessvarDefinition`	`s,S,B,A`	`^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name},"B",{%Dictionary.StorageSQLMapSubDefinition.Name},"A",{%Dictionary.StorageSQLMapSubAccessvarDefinition.Name})`
`%Dictionary.StorageSQLMapSubInvalidconditionDefinition`	`s,S,B,N`	`^oddDEF({%Dictionary.ClassDefinition.Name},"s",{%Dictionary.StorageDefinition.Name},"S",{%Dictionary.StorageSQLMapDefinition.Name},"B",{%Dictionary.StorageSQLMapSubDefinition.Name},"N","{%Dictionary.StorageSQLMapSubInvalidconditionDefinition.Name}")`
`%Dictionary.TriggerDefinition`	`t`	`^oddDEF({%Dictionary.ClassDefinition.Name},"t",{%Dictionary.TriggerDefinition.Name})`
`%Dictionary.UDLTextDefinition`	`u`	`^oddDEF({%Dictionary.ClassDefinition.Name},"u",{%Dictionary.UDLTextDefinition.Name})`
`%Dictionary.XDataDefinition`	`x`	`^oddDEF({%Dictionary.ClassDefinition.Name},"x",{%Dictionary.XDataDefinition.Name})`

一篇文章了解定义类成员结构

文章目录

一篇文章了解定义类成员结构

%Dictionary.ClassDefinition - 类定义表

简介

索引

示例

表结构

%Dictionary.ForeignKeyDefinition - 外键定义表

简介

索引

示例

表结构

%Dictionary.IndexDefinition - 索引定义表

简介

索引

示例

表结构

%Dictionary.MethodDefinition - 方法定义表

简介

索引

示例

表结构

%Dictionary.ParameterDefinition - 参数定义表

简介

索引

示例

表结构

%Dictionary.ProjectionDefinition - 映射定义表

简介

索引

示例

表结构

%Dictionary.PropertyDefinition - 属性定义表

简介

索引

示例

表结构

%Dictionary.PropertyUDLTextDefinition - PropertyUDLText定义表

索引

表结构

%Dictionary.QueryDefinition - 查询定义表

简介

索引

示例

表结构

%Dictionary.StorageDefinition - Storage定义表

简介

索引

示例

表结构

%Dictionary.StorageDataDefinition - StorageData定义表

简介

索引

示例

表结构

%Dictionary.StorageDataValueDefinition - StorageDataValue定义表

简介

索引

示例

表结构

%Dictionary.StorageIndexDefinition - StorageIndex定义表

简介

索引

示例

表结构

%Dictionary.StoragePropertyDefinition - StorageProperty定义表

简介

索引

示例

表结构

%Dictionary.StorageSQLMapDefinition - StorageSQLMap定义表

简介

取值

示例

表结构

%Dictionary.StorageSQLMapDataDefinition -StorageSQLMapData定义表

简介

索引

示例

`%Dictionary.ClassDefinition` - 类定义表

`%Dictionary.ForeignKeyDefinition` - 外键定义表

`%Dictionary.IndexDefinition` - 索引定义表

`%Dictionary.MethodDefinition` - 方法定义表

`%Dictionary.ParameterDefinition` - 参数定义表

`%Dictionary.ProjectionDefinition` - 映射定义表

`%Dictionary.PropertyDefinition` - 属性定义表

`%Dictionary.PropertyUDLTextDefinition` - `PropertyUDLText`定义表

`%Dictionary.QueryDefinition` - 查询定义表

`%Dictionary.StorageDefinition` - `Storage`定义表

`%Dictionary.StorageDataDefinition` - `StorageData`定义表

`%Dictionary.StorageDataValueDefinition` - `StorageDataValue`定义表

`%Dictionary.StorageIndexDefinition` - `StorageIndex`定义表

`%Dictionary.StoragePropertyDefinition` - `StorageProperty`定义表

`%Dictionary.StorageSQLMapDefinition` - `StorageSQLMap`定义表

`%Dictionary.StorageSQLMapDataDefinition` -`StorageSQLMapData`定义表

`%Dictionary.StorageSQLMapRowIdSpecDefinition` - `StorageSQLMapRowIdSpec`定义表

`%Dictionary.StorageSQLMapSubDefinition` - `StorageSQLMapSub`定义表

`%Dictionary.StorageSQLMapSubAccessvarDefinition` - `StorageSQLMapSubAccessvar`定义表

`%Dictionary.StorageSQLMapSubInvalidconditionDefinition` - `StorageSQLMapSubInvalidcondition`定义表

`%Dictionary.TriggerDefinition` - 触发器定义表

`%Dictionary.UDLTextDefinition` - `UDLText`定义表

`%Dictionary.XDataDefinition` - `XData`定义表

`^oddDEF`一览