重要说明：

IBM Cloud Pak® for Data 4.8 版本将于 2025 年 7 月 31 日结束支持（EOS）。欲了解更多信息，请参阅 IBM Cloud Pak for Data 版本 4.X 的停止服务公告。
在版本支持结束之前，升级到版本。 IBM Cloud Pak for Data 4.8 IBM Software Hub 5.1 有关更多信息，请参阅从 IBM Cloud Pak for Data 版本 4.8 升级到 IBM Software Hub 版本 5.1。

DataStage 在管道表达式构建器中使用的函数

例如，在 Watson Pipelines 代码编辑器中使用这些 DataStage 函数来定义用户变量或构建高级条件。

表达式构建器函数的语法

在自变量的语法中，方括号指示自变量是可选的。

参数可以接受任何类型的数据。可以输入类型为 string ， int ， float ， null 和其他类型的自变量。例如，函数 IsNull(input (any)) 接受以下参数类型，但不排除以下类型:

ds.IsNull(1)
ds.IsNull("try null")
ds.IsNull(1.78)
ds.IsNull(null)

注：

在当前版本的管道中，日期，时间和时间戳记的所有输入类型都被视为字符串。

表达式构建器将以下类别用于编码函数:

转换函数
日期和时间函数
逻辑函数
数学函数
数字函数
原始函数
字符串函数
实用程序函数
空处理函数
变换日期函数
变换字符串函数
例程转换函数
宏函数

转换函数

将一种数据元素格式转换为另一种数据元素格式。

Ascii

将字符串中的字符值从 EBCDIC 转换为 ASCII 格式。

语法

ds.Ascii(input (string))

返回: EDBCDI 字符串转换为生成的格式字符串的 ASCII 字符串。

示例

以下代码返回 "65 66 67":

ds.Ascii("193 194 195")

Char

根据其数字代码值返回一个 ASCII 字符。

语法

ds.Char(code (uint8))

返回: 格式为 char 的相应字符。

示例

以下示例将 ASCII 码 65 输出为字符 A。

ds.Char(65)

校验和

返回字符串的循环冗余代码值。

语法

ds.Checksum(input (string))

返回: 作为循环冗余码的格式字符串的校验和值。

示例

以下代码返回 57158:

ds.Checksum("This is any arbitrary string value")

CRC32

使用 CRC32 函数返回 16 位循环冗余代码。

语法

ds.CRC32(input (string))

返回: 格式为十进制的结果。

示例

以下代码返回 57158:

ds.CRC32("This is any arbitrary string value")

DateToString

返回日期的字符串表示。日期的缺省格式字符串为 "%yyyy%mm%dd" ，因此，例如，日期 2009-08-25 存储为十进制数 20090825。但是，您可以选择指定格式字符串，以设置如何将日期存储为十进制数。格式字符串必须指定仅包含数字的格式。例如，您不能指定格式字符串，如“%yyyy-%mm-%dd”，因为无法在压缩十进制值中存储连字符 (-)。以下标记对于与十进制值之间的转换有效：

%yyyy (four-digit year)

%yy (two-digit year)

%NNNNyy (two-digit year with cutoff)

%mm (two-digit month)

%dd (two-digit day of month)

%ddd (three-digit day of year)

字面值数字 0 到 9 都有效。

语法

ds.DateToString(date (date), [format (string)])

返回：string 格式的日期。

示例

如果 mylink.mydate 包含日期 18th ，那么以下代码将返回字符串 "2009-08-18":

ds.DateToString(mylink.mydate)

以下示例将列 mylink.mydate 中包含的日期输出为格式为 dd:mm:yyyy的字符串。如果 mylink.mydate 包含日期 18th ，那么以下代码将返回字符串 "18:08:2009":

ds.DateToString(mylink.mydate, "%dd:%mm:%yyyy")

DateToDecimal

将给定的日期返回为压缩十进制值。日期的缺省格式字符串为 "%yyyy%mm%dd" ，因此，例如，日期 2009-08-25 存储为十进制数 20090825。但是，您可以选择指定格式字符串，以设置如何将日期存储为十进制数。格式字符串必须指定仅包含数字的格式。例如，您不能指定格式字符串，如“%yyyy-%mm-%dd”，因为无法在压缩十进制值中存储连字符 (-)。以下标记对于与十进制值之间的转换有效：

%yyyy (four-digit year)

%yy (two-digit year)

%NNNNyy (two-digit year with cutoff)

%mm (two-digit month)

%dd (two-digit day of month)

%ddd (three-digit day of year)

字面值数字 0 到 9 都有效。

语法

ds.DateToDecimal(basedate (date), [format (string)])

返回：decimal 格式的日期

示例

如果 mylink.basedate 包含日期 2012-08-18，那么以下函数将该日期存储为十进制数 18082012：

ds.DateToDecimal(mylink.basedate, "%dd%mm%yyyy")

如果 mylink.basedate 包含日期 2012-08-18 ，那么以下函数会将日期存储为十进制数 20120818:

ds.DateToDecimal(mylink.basedate)

DecimalToDate

将给定的压缩十进制数返回为日期。在将十进制数转换为日期时，会忽略其符号和小数位数。缺省格式字符串为“%yyyy%mm%dd”，因此，例如日期 2009-08-25 将存储为数字 20090825。但是，您可以选择指定格式字符串，以设置如何将日期存储为十进制数。格式字符串必须仅指定包含数字的格式。例如，您不能指定格式字符串，如“%yyyy-%mm-%dd”，因为无法在压缩十进制值中存储连字符 (-)。以下标记对于与十进制值之间的转换有效：

%yyyy (four-digit year)

%yy (two-digit year)

%NNNNyy (two-digit year with cutoff)

%mm (two-digit month)

%dd (two-digit day of month)

%ddd (three-digit day of year)

字面值数字 0 到 9 都有效。

语法

ds.DecimalToDate(basedec (decimal), [format (string)])

返回：date 格式的十进制数。

示例

如果 mylink.mydecdata 包含值 18082012，那么以下函数将返回日期 2012-08-18：

ds.DecimalToDate(mylink.basedate, "%dd%mm%yyyy")

如果 mylink.mydecdata 包含值 -201208.18，那么以下函数将返回日期 2012-08-18：

ds.DecimalToDate(mylink.basedate)

DecimalToDecimal

以十进制表示法返回给定的十进制数。参数 rtype 指定取整类型，并设置为以下某个值（可选）：

ceil：向正无穷方向对源字段取整。例如， 1.4 -> 2， -1.6 -> -1。

floor：向负无穷方向对源字段取整。例如， 1.6 -> 1， -1.4 -> -2。

round_inf：通过向正无穷方向对正数值取整并向负无穷方向对负数值取整，向最接近的可表示值对源字段进行取整或截断。例如， 1.4 -> 1, 1.5 -> 2, -1.4 -> -1, -1.5 -> -2。

trunc_zero：不论符号如何，丢弃位于目标数据支持的最右侧小数位右侧的任何小数位。例如，如果目标是整数，那么将截断所有小数位。如果目标是另一个小数位较小的小数位，那么它会舍入或截断为目标小数位的小数位大小。例如， 1.6 -> 1， -1.6 -> -1。

语法

ds.DecimalToDecimal(decimal (decimal), [rtype (string)])

返回：十进制数结果。

示例

如果 mylink.mydec 包含十进制数 2.5345，那么以下函数将返回十进制数 2.54:

ds.DecimalToDecimal(mylink.mydec,"ceil")

如果 mylink.mydec 包含十进制数 2.5345，那么以下函数将返回十进制数 2.53。

ds.DecimalToDecimal(mylink.mydec,"floor")

如果 mylink.mydec 包含十进制数 2.5345，那么以下函数将返回十进制数 2.53。

ds.DecimalToDecimal(mylink.mydec,"trunc_zero")

如果 mylink.mydec 包含十进制数 2.5345，那么以下函数将返回十进制数 2.53。

ds.DecimalToDecimal(mylink.mydec,"round_inf")

DecimalToDFloat

返回 dfloat 格式的给定十进制数。可选参数 fix_zero 指定将所有零十进制值视为有效 (缺省情况下，将包含所有零的十进制数字视为无效)。

语法

ds.DecimalToDFloat(decimal (decimal), ["fix_zero"])

返回：dfloat 格式的十进制数。

示例

如果 mylink.mydec 包含十进制数 00000004.00，那么以下函数将返回 dfloat number 4。

ds.DecimalToDFloat(mylink.mydec,"fix_zero")

如果 mylink.mydec 包含十进制数 00012344.00，那么以下函数将返回 dfloat 数字 12344。

ds.DecimalToDFloat(mylink.mydec,"fix_zero")

如果 mylink.mydec 包含十进制数 00012344.120，那么以下函数将返回 dfloat number 12344.12。

ds.DecimalToDFloat(mylink.mydec,"fix_zero")

如果 mylink.mydec 包含十进制数字 00012344.120，那么以下函数将返回 dfloat 数字 12344.12。

ds.DecimalToDFloat(mylink.mydec)

如果 mylink.mydec 包含十进制数 00012344.000，那么以下函数将返回 dfloat 数字 12344。

ds.DecimalToDFloat(mylink.mydec)

DecimalToString

将给定的十进制数返回为字符串。自变量 fix_zero (可选) 指定将所有零十进制值视为有效 (缺省情况下，将包含所有零的十进制数字视为无效)。这涵盖了压缩十进制表示法的符号位全部为 0 且全部为内容数字的情况。除非 fix_zero 为 true，否则此强制转换将被视为无效。

语法

ds.DecimalToString(decimal (decimal), ["fix_zero"])

返回：string 格式的十进制数。

示例

如果 mylink.mydec 包含十进制数 00000004.00，那么以下函数将返回字符串 "4":

ds.DecimalToString(mylink.mydec,"suppress_zero")

如果 mylink.mydec 包含十进制数 00000004.00，那么以下函数将返回字符串 "0000000000000000000000000004.0000000000":

ds.DecimalToString(mylink.mydec,"fix_zero")

如果 mylink.mydec 包含十进制数 00000004.00，那么以下函数将返回字符串 "4":

ds.DecimalToString(mylink.mydec)

DecimalToTime

将给定的压缩十进制数返回为时间。您可以指定格式字符串来指定如何以十进制数形式存储时间（可选）。缺省格式字符串为 "%hh%nn%ss" ，因此，例如，时间 14:03:22 存储为十进制数 140322。格式字符串必须指定仅包含数字的格式。例如，您不能指定格式字符串，如“%hh:%nn:%ss”，因为无法在压缩十进制值中存储冒号字符 (:)。以下标记对于与十进制值之间的转换有效：

%hh (two-digit hours that use 24-hour clock)

%nn (two-digit minutes)

%ss (two-digit seconds)

%ss.N (two-digit seconds, plus the number of fractional digits allowed. The number of fractional digits is from 1 - 6 inclusive).

字面值数字 0 到 9 都有效。

如果指定的格式包含微秒（例如，%ss.4），那么将在十进制值中推断小数点的位置。小数点的位置不必与指定的小数位 (例如，小数位 = 4) 一致。

语法

ds.DecimalToTime(decimal (decimal), [format (string)])

返回: 时间格式的十进制。

示例

如果 mylink.mytimedec 包含十进制值 200658 ，那么以下函数将返回时间 20:06:58:

ds.DecimalToTime(mylink.mytimedec)

如果列 mylink.mytimedec 包含十进制值 580620 ，那么以下函数将返回时间 20:06:58:

ds.DecimalToTime(mylink.mytimedec, "%ss%nn%hh")

DecimalToTimestamp

将给定的压缩十进制数返回为时间戳记。您可以指定格式字符串来指定如何以十进制数形式存储时间戳记（可选）。缺省格式字符串为 "%hh%nn%ss" ，因此，例如，时间戳记 2009-08-25 14:03:22 存储为十进制数 20090825140322。格式字符串必须指定仅包含数字的格式。例如，您不能指定格式字符串，如“%yyyy/%mm/%dd%hh:%nn:%ss”，因为无法在压缩十进制值中存储斜杠字符 (/) 和冒号字符 (:)。以下标记对于与十进制值之间的转换有效：

%yyyy (four-digit year)

%yy (two-digit year)

%NNNNyy (two-digit year with cutoff)

%mm (two-digit month)

%dd (two-digit day of month)

%ddd (three-digit day of year)

%hh (two-digit hours that use 24-hour clock)

%nn (two-digit minutes)

%ss (two-digit seconds)

%ss.N (two-digit seconds, plus the number of fractional digits allowed. The number of fractional digits is from 1 - 6 inclusive).

字面值数字 0 到 9 都有效。

如果指定的格式包含微秒（例如，%ss.4），那么将在十进制值中推断小数点的位置。小数点的位置不必与指定的小数位 (例如，小数位 = 4) 一致。

语法

ds.DecimalToTimestamp(decimal (decimal), [format (string)])

返回: 时间戳记格式的十进制。

示例

如果 mylink.mytimestampdec 包含值 19580818200658 ，那么以下函数将返回时间戳记 1958-08-18 20:06:58:

ds.DecimalToTimestamp(mylink.mytimestampdec)

如果 link.mytimestampdec 包含十进制值 200658220818 ，那么以下函数将返回时间戳记 2022-08-18 20:06:58:

ds.DecimalToTimestamp(mylink.mytimestampdec, "%hh%nn%ss%yy%mm%dd")

DFloatToDecimal

以十进制表示形式返回给定的 dfloat。参数 rtype 指定取整类型，并设置为以下某个值（可选）：

ceil：向正无穷方向对源字段取整。例如， 1.4 -> 2， -1.6 -> -1。

floor：向负无穷方向对源字段取整。例如， 1.6 -> 1， -1.4 -> -2。

语法

ds.DFloatToDecimal(number (dfloat), [rtype (string)])

返回：dfloat 格式的十进制数。

示例

如果 mylink.myfloat 包含 dfloat 数字 2.534，那么以下函数将返回十进制数字 2.54:

ds.DFloatToDecimal(mylink.mydec,"ceil")

如果 mylink.myfloat 包含 dfloat 数字 2.534，那么以下函数将返回十进制数字 2.53:

ds.DFloatToDecimal(mylink.mydec,"floor")

如果 mylink.myfloat 包含 dfloat 数字 2.534，那么以下函数将返回十进制数字 2.53:

ds.DFloatToDecimal(mylink.mydec,"trunc_zero")

如果 mylink.myfloat 包含 dfloat 数字 2.534，那么以下函数将返回十进制数字 2.53:

ds.DFloatToDecimal(mylink.mydec,"round_inf")

DfloatToStringNoExp

通过使用指定的标度，以不带指数的字符串表示法返回给定的 dfloat。

语法

ds.DfloatToStringNoExp(number (dfloat), scale (string))

返回：string 格式的 dfloat 数。

示例

如果 mylink.myfloat 包含 dfloat 数字 2.534，那么以下函数将返回字符串 "2.5":

ds.DfloatToStringNoExp(mylink.myfloat, "2")

德特克斯

将十进制整数转换为十六进制。

语法

ds.Dtx(number (int32), size(int8))

返回: 格式字符串的结果。

示例

以下代码返回 "002F":

ds.Dtx(47,4)

EBCDIC

将表达式的每个字符从其 ASCII 表示值转换为其 EBCDIC 表示值。

语法

ds.Ebcdic(input (string))

返回: 转换为生成的 EDBCDII 字符串的 ASCII 字符串。

示例

以下代码返回 "193 194 195 64 241 242 243":

ds.Ebcdic("ABC 123")

iconv

将字符串转换为内部存储格式。

语法

ds.Iconv(string (string), code (string))

返回: 字符串格式的内部存储格式。

示例

以下代码返回 10740:

ds.Iconv("27 MAY 97", "D2")

以下代码返回 10740:

ds.Iconv("1997 5 27", "D YMD")

IntToBool

将 integer 转换为 bool 类型。对于任何非零值返回 true ，对于 0 返回 false。

语法

ds.IntToBool(integer (int))

返回: 布尔值 true 或 false。

示例

2 的值返回 true。

ds.IntToBool(2)

IsValid

返回给定的字符串对于给定类型是否有效。

有效类型为 "date" ， "decimal" ， "dfloat" ， "sfloat" ， "int8" ， "uint8" ， "int16" ， "uint16" ， "int32" ， "uint32" ， "int64"，"uint64"，" string "，" time "，" timestamp "。

对于数据类型 date、time 和 timestamp，您可以指定格式字符串（可选）。格式字符串描述输入数据的格式与 date、time 或 timestamp 的缺省格式不同时，输入数据所使用的格式。日期的缺省格式为“%yyyy-%mm-%dd”。时间的缺省格式为 "%hh: %mm:%ss"。时间戳记的缺省格式为 "%yyyy-%mm-%dd %hh: %mm:%ss"。该功能不会记录警告。

语法

ds.IsValid(type (string), teststring (string), [format (string)])

返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。

示例

如果 mylink.mystring 包含字符串 "1" ，那么以下函数将返回值 1:

ds.IsValid("int8", mylink.mystring)

如果 mylink.mystring 包含字符串 "380096.06" ，那么以下函数将返回值 0:

ds.IsValid("int8", mylink.mystring)

IsValidDate

返回给定的值是否为有效的 date 类型。该功能记录警告。

语法

ds.IsValidDate(testdate (date))

返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。

如果 mylink.mydate 包含日期 2011-09-13，那么以下函数将返回值 1。

ds.IsValidDate(mylink.mydate)

如果 mylink.mydate 包含字符串 "380096.06" ，那么以下函数将返回值 0 ，因为转换后的字符串不是有效日期。

ds.IsValidDate(mylink.mydate)

IsValidDecimal

返回给定的值是否为有效的 decimal 类型。如果 allzerosflag 设置为 0 ，那么全零表示无效。缺省情况下，allzerosflag 设置为 0。

语法

ds.IsValidDecimal(testvalue (decimal), [allzerosflag (uint8)])

返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。

示例

如果 mylink.mynum 包含值 310007.65，那么以下函数将返回值 1。

ds.IsValidDecimal(mylink.mynum)

IsValidTime

返回给定的时间是否为有效的 time 类型。

语法

ds.IsValidTime(testtime (time))

返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。

示例

如果 mylink.mytime 包含时间 23:09:22，那么以下函数将返回值 1：

ds.IsValidTime(mylink.mytime)

IsValidTimestamp

返回给定的时间戳记是否为有效的 timestamp 类型。

语法

ds.IsValidTimestamp(testtimestamp (timestamp))

返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。

示例

如果 mylink.mytimestamp 包含时间 2011-09-13 23:09:22，那么以下函数将返回值 1：

ds.IsValidTimestamp(mylink.mytimestamp)

奥孔夫

将表达式转换为输出格式。

语法

ds.Oconv(expression (string), conversion (string))

返回: 结果为格式字符串的输出格式。

示例

以下代码返回 1997-147:

ds.Oconv(10740, "D-YJ")

以下代码返回 27 MAY 97:

ds.Oconv(10740, "D DMY, [A3,2]")

RawNumAt

返回指定 raw 字段中指定索引值的整数值。索引从 0 开始。

语法

ds.RawNumAt(rawfield (string), index (int32))

返回：给定索引中的整数值（int32 格式）。

示例

如果 column mylink.myraw 包含派生自字符串 "hello" (即 "{ 0x68 0x65 0x6C 0x6C 0x6F }") 的原始值，则以下函数返回整数 104 (字符 h 的 ASCII 码):

ds.RawNumAt(mylink.myraw, 0)

如果 mylink.myraw 包含派生自字符串 "hello" (即 "{ 0x68 0x65 0x6C 0x6C 0x6F }") 的原始值，那么以下函数将返回 0 ，因为指定的索引超出范围:

ds.RawNumAt(mylink.myraw, 12)

RawToString

以字符串表示形式返回给定的 raw 值。必须确保 raw 输入值包含一个字节序列，这些字节在使用输出字符串的目标字符集中为有效字符。

例如，原始值 { 0xE0 0x41 0x42 } 不是有效的 UTF-8 字符序列，因为前导字节 0xE0 应后跟 [0x80..0xBF] 范围内的字节。

如果将原始值 { xE0 x41 x42 } 传递给 RawToString 函数，那么在访问输出字符串时就好像访问 UTF-8 编码的字符串一样，可能会发生错误。

语法

ds.RawToString(rawfield (string))

返回：字符串格式的给定原始值。

示例

如果 mylink.myraw 包含值 { 0x31 0x31 0x30 0x35 0x32 0x32 0x30 0x39 }，那么以下函数将返回字符串 "11052209"。

ds.RawToString(mylink.myraw)

序号

根据 ASCII 字符生成数字代码值。您可以选择指定 allow8bits 参数来转换 8 位 ASCII 值。

语法

ds.Seq(seq (char))

返回：ASCII 字符数字代码。

示例

以下示例将字符 A 输出为 ASCII 码 65。

ds.Seq("A")

SeqAt

返回给定字符串中指定位置上字符的数字代码点值。索引从 0 开始。如果指定的索引超出范围，那么该函数将返回 0。

语法

ds.SeqAt(basestring (string), index (int32))

返回：给定字符串中指定位置处的字符的数字代码点值（int32 格式）。

示例

如果 mylink.mystring 包含字符串 "horse" ，那么以下函数将返回值 0x6F (即，字符 o 的 ASCII 值)。

ds.SeqAt(mylink.mystring, 1)

StringToBool

将字符串转换为 bool 类型。对于空字符串，返回 false ，对于任何其他值，返回 true。

语法

ds.StringToBool(string (string))

返回: 布尔值 true 或 false。

示例

空字符串返回 false。

ds.StringToBool("")

StringToDate

返回给定字符串中的日期（采用指定格式）。如果字符串包含缺省格式 yyyy-mm-dd 的日期，那么不必指定格式字符串。

语法

ds.StringToDate(string (string), [format (string)])

返回: 指定格式的迄今为止的字符串。

示例

如果 mylink.mystring 包含字符串 "1958-08-18" ，那么以下函数将返回日期 1958-08-18。

ds.StringToDate(mylink.mystring)

如果 mylink.mystring 包含字符串 "18:08:1958" ，那么以下函数将返回日期 1958-08-18。

ds.StringToDate(mylink.mystring,"%dd:%mm:%yyyy")

StringToDecimal

以十进制表示形式返回给定的字符串。参数 rtype 指定取整类型，并设置为以下某个值（可选）：

ceil：向正无穷方向对源字段取整。例如， 1.4 -> 2， -1.6 -> -1。

floor：向负无穷方向对源字段取整。例如， 1.6 -> 1， -1.4 -> -2。

语法

ds.StringToDecimal(string (string), [rtype (string)])

返回：decimal 格式的字符串。

示例

如果 mylink.mystring 包含字符串 "19982.22" ，那么以下函数将返回十进制 19982.22。

ds.StringToDecimal(mylink.mystring)

如果 mylink.mystring 包含字符串 "19982.2276" ，那么以下函数将返回十进制 19982.23。

ds.StringToDecimal(mylink.mystring,"ceil")

StringToRaw

返回要作为原始代码值的字符串。

语法

ds.StringToRaw(string (string))

返回：字符串对应的原始代码值。

示例

如果 mylink.mystring 包含字符串 "hello" ，那么以下函数将返回值 "{0x68 0x65 0x6C 0x6C 0x6F}"。

ds.StringToRaw(mylink.mystring)

StringToTime

返回给定字符串的时间表示。

语法

ds.StringToTime(string (string), [format (string)])

返回：time 格式的字符串。

示例

如果 mylink.mystring 包含字符串 "20:06:58" ，那么该函数将返回时间 20:06:58。

ds.StringToTime(mylink.mystring)

如果 mylink.mystring 包含字符串 "20: 6:58" ，那么此函数将返回时间 20:06:58。

ds.StringToTime(mylink.mystring,"%(h,s):%(n,s):%(s,s)")

StringToTimestamp

返回 timestamp 格式的给定字符串。

语法

ds.StringToTimestamp(string (string), [format (string)])

返回：timestamp 格式的字符串。

示例

如果 mylink.mystring 包含字符串 "1958-08-08 20:06:58" ，那么该函数将返回时间戳记 1958-08-08 20:06:58。

ds.StringToTimestamp(mylink.mystring)

如果 mylink.mystring 包含字符串 "8/ 8/1958 20: 6:58" ，那么该函数将返回时间戳记 1958-08-08 20:06:58。

ds.StringToTimestamp(mylink.mystring, "%(d,s)/%(m,s)/%yyyy%(h,s):%(n,s):%(s,s)")

StringToUstring

返回给定字符串中的一个 ustring，可选择使用指定的映射（否则使用项目缺省值）。

语法

ds.StringToUstring(string (string), [mapname (string)])

返回：ustring 格式的字符串。

示例

如果 mylink.mystring 包含字符串 "11052009" ，那么以下函数将返回 ustring "11052009"。

ds.StringToUstring(mylink.mystring)

TimestampToDate

返回给定时间戳记的日期。

语法

ds.TimestampToDate(timestamp (timestamp))

返回：时间戳记中的日期结果。

示例

如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么以下函数将返回日期 1958-08-18:

ds.TimestampToDate(mylink.mytimestamp)

TimestampToDecimal

将给定的时间戳记返回为压缩十进制。缺省格式字符串为 " %yyyy%mm%dd%hh%nn%ss "。例如，时间戳记 timestamp 2009-08-25 14:03:22 存储为十进制数 20090825140322。但是，您可以选择指定格式字符串，以设置如何将日期存储为十进制数。格式字符串必须指定仅包含数字的格式。例如，您不能指定格式字符串，如“%yyyy/%mm/%dd%hh:%nn:%ss”，因为无法在压缩十进制值中存储斜杠字符 (/) 和冒号字符 (:)。以下标记对于与十进制值之间的转换有效：

%yyyy (four-digit year)

%yy (two-digit year)

%NNNNyy (two-digit year with cutoff)

%mm (two-digit month)

%dd (two-digit day of month)

%ddd (three-digit day of year)

%hh (two-digit hours that use 24-hour clock)

%nn (two-digit minutes)

%ss (two-digit seconds)

%ss.N (two-digit seconds, plus the number of fractional digits allowed. The number of fractional digits is from 1 - 6 inclusive).

字面值数字 0 到 9 都有效。

如果指定的格式包含微秒（例如，%ss.4），那么将在十进制值中推断小数点的位置。小数点的位置不必与指定的十进制小数位一致（例如，小数位 = 4）。

语法

ds.TimestampToDecimal(timestamp (timestamp), [format (string)])

返回：decimal 格式的时间戳记结果。

示例

如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么以下函数将返回十进制值 19580818200658:

ds.TimestampToDecimal(mylink.mytimestamp)

如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么以下函数将返回十进制值 200658580818:

ds.TimestampToDecimal(mylink.mytimestamp, "%hh%nn%ss%yy%mm%dd")

TimestampToString

以字符串格式返回给定时间戳记。

语法

ds.TimestampToString(timestamp (timestamp), [format (string)])

返回：string 格式的时间戳记结果。

示例

如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么该函数将返回字符串 "1958-08-18 20:06:58"。

ds.TimestampToString(mylink.mytimestamp)

如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么此函数将返回字符串 "1 8/0 8/1 9 5 8 20:06:58":

ds.TimestampToString(mylink.mytimestamp, "%dd/%mm/%yyyy %hh:%nn:%ss")

TimestampToTime

返回给定时间戳记作为时间格式。

语法

ds.TimestampToTime(timestamp (timestamp), [format (string)])

返回：time 格式的时间戳记结果。

示例

如果 mylink.mytimestamp 包含时间戳记 1958-08-18 20:06:58 ，那么此函数将返回时间 20:06:58:

ds.TimestampToTime(mylink.mytimestamp)

TimeToString

返回给定时间的字符串。

语法

ds.TimeToString(timestamp (timestamp), [format (string)])

返回：time 格式的结果。

示例

如果 mylink.mytime 包含时间 20:06:58 ，那么以下函数将返回字符串 "20:06:58":

ds.TimeToString(mylink.mytime)

如果 mylink.mytime 包含时间 20:06:58 ，那么以下函数将返回字符串 "58:06:20":

ds.TimeToString(mylink.mytime, "%ss:%nn:%hh")

TimeToDecimal

将给定的时间返回为压缩十进制。缺省格式字符串为“%hh%nn%ss”，因此，例如时间 14:03:22 将存储为十进制数字 140322。但是，您可以选择指定格式字符串，以指定如何将时间存储为十进制数。格式字符串只能指定包含数字的格式。例如，您不能指定格式字符串，如“%hh:%nn:%ss”，因为无法在压缩十进制值中存储冒号字符 (:)。以下标记对于与十进制值之间的转换有效：

%hh (two-digit hours that use 24-hour clock)

%nn (two-digit minutes)

%ss (two-digit seconds)

%ss.N (two-digit seconds, plus the number of fractional digits allowed. The number of fractional digits is from 1 - 6 inclusive).

字面值数字 0 到 9 都有效。

如果指定的格式包含微秒（例如，%ss.4），那么将在十进制值中推断小数点的位置。小数点的位置不必与指定的十进制小数位一致（例如，小数位 = 4）。

语法

ds.TimeToDecimal(time (time), [format (string)])

返回：decimal 格式的时间。

示例

如果 mylink.mytime 包含时间 20:06:58，那么以下函数将返回十进制值 200658：

ds.TimeToDecimal(mylink.mytime)

如果 mylink.mytime 包含时间 20:06:58，那么以下函数将返回十进制值 580620：

ds.TimeToDecimal(mylink.mytime, "%ss%nn%hh")

UniChar

根据 0 到 65535 范围内的十进制值生成单个 Unicode 字符。

语法

ds.UniChar(expression (int32))

返回: 格式字符串的结果。

示例

以下代码返回 "按照":

ds.UniChar(0x00F5)

UniSeq

根据单个 Unicode 字符生成十进制值。

语法

ds.UniSeq(expression (string))

返回: 格式为 int32的 Unicode 字符的相应十进制数。

示例

以下代码返回 195:

ds.UniSeq("ä")

UstringToString

返回给定 ustring 中的一个字符串，可选择使用指定的映射（否则使用项目缺省映射）。

语法

ds.UstringToString(string (ustring), [mapname(string)])

返回：string 格式的结果。

示例

如果 mylink.myustring 包含 ustring "11052009" ，那么以下函数将返回字符串 "11052009":

ds.UstringToString(mylink.myustring)

Xtd

将十六进制字符串转换为十进制。

语法

ds.Xtd(hexadecimal (string))

返回: 十六进制字符串的相应十进制值。

示例

以下代码返回 48879:

ds.Xtd("beef")

整型

返回表达式的整数部分。指定的任何算术运算都是使用系统的完全准确性计算的。值的小数部分将截断，而不是舍入，并且将返回剩余的整数。

语法

ds.Int(expression (dfloat))

返回: 舍入并转换为类型 int64的十进制值。

示例

以下代码返回 454:

ds.Int(454.95)

以下代码返回 2:

ds.Int(2.35)

日期和时间函数

将这些函数用于表达式中的数据和时间函数。

在自变量中指定日期，时间或时间戳记的函数使用具有特定格式的字符串:

对于日期，格式为 %yyyy-%mm-%dd
对于时间，格式为 %hh:%nn:%ss。如果扩展为包含微秒，那么格式为 %hh:%nn:%ss.x，其中 x 指定秒值的小数位数。
对于时间戳记，格式是后跟时间格式的日期格式。

在自变量中包含星期几的函数将采用指定星期几的字符串。星期几可指定为三个字母的缩写，也可指定为完整名称。例如，字符串 "thu" 和 "th星期四" 都有效。

CurrentDate

返回运行作业的日期。

语法

ds.CurrentDate()

返回：date 格式的当前日期。

示例

此函数用于获取当前日期。

ds.CurrentDate()

CurrentTime

返回运行作业的时间。

语法

ds.CurrentTime()

返回: 当前时间格式。

示例

此函数用于获取当前时间。

ds.CurrentTime()

CurrentTimeMS

返回运行作业的时间，包括微秒。

语法

ds.CurrentTimeMS()

返回：time 格式的当前时间（包括微秒）。

示例

使用此函数可检索当前时间并输出数据。

ds.CurrentTimeMS()

CurrentTimestamp

返回给出作业运行日期和时间的时间戳记。

语法

ds.CurrentTimestamp()

返回: 时间戳记格式的当前时间戳记。

示例

此函数用于检索当前时间戳记并将其放入输出数据中。

ds.CurrentTimestamp()

CurrentTimestampMS

返回用于提供作业运行日期和时间的时间戳记（包括微秒）。

语法

ds.CurrentTimestampMS()

返回: 时间戳记格式的当前时间戳记。

示例

此函数用于检索当前时间戳记并将其放入输出数据中。

ds.CurrentTimestampMS()

日期

返回从内部系统日期到 1967 年 12 月 31 日 (即 0 日) 之间经过的单个数字值。之后的所有日期都是正数，表示自第 0 天以来经过的天数。之前的所有日期都是负数，表示第 0 天之前的天数。

语法

ds.Date()

返回: 生成的格式为 int 的日期。

示例

如果当前日期是 1967 年 11 月 15 日，那么以下代码将返回 -46。如果当前日期是 1968 年 2 月 15 日，那么以下代码将返回 46:

ds.Date()

DateFromDaysSince

通过向基线日期添加整数来返回日期。该整数可以是负数，这样会返回早于基准日期的日期。

语法

ds.DateFromDaysSince(number (int32), [baseline_date_object (string)])

返回: 通过向用户输入的基线日期添加整数来返回日期。

示例

如果 mylink.myintcol 包含整数 18250 ，而 mylink.mydatecol 包含日期 1958-08-18 ，那么以下三个函数等效，并返回日期 2008-08-05:

ds.DateFromDaysSince(18250,"1958-08-18")
ds.DateFromDaysSince(mylink.myintcol,"1958-08-18")
ds.DateFromDaysSince(mylink.myintcol,mylink.mydatecol)

如果 mylink.mynegintcol 包含整数 -1 ，而 mylink.mydatecol 包含日期 1958-08-18，那么以下三个函数是等价的，并返回日期 1958-08-17：

ds.DateFromDaysSince(-1,"1958-08-18")
ds.DateFromDaysSince(mylink.mynegintcol,"1958-08-18")
ds.DateFromDaysSince(mylink.mynegintcol,mylink.mydatecol)

DateFromDaysSince2

通过向基线日期添加整数来返回日期。该整数可以是负数，这样会返回早于基准日期的日期。

语法

ds.DateFromDaysSince2(number (int32), [baseline_date_object (date)])

返回: 通过向用户输入的基线日期添加整数来返回日期。

示例

如果 mylink.myint 包含整数 18250 ，而 mylink.mydate 包含日期 1958-08-18 ，那么以下三个函数等效，并返回日期 2008-08-05:

ds.DateFromDaysSince2(18250,"1958-08-18")
ds.DateFromDaysSince2(mylink.myint,"1958-08-18")
ds.DateFromDaysSince2(mylink.myint, mylink.mydate)

如果 mylink.mynegint 包含整数 -1 ，而 mylink.mydate 包含日期 1958-08-18，那么以下三个函数是等价的，并返回日期 1958-08-17：

ds.DateFromDaysSince2(-1,"1958-08-18")
ds.DateFromDaysSince2(mylink.mynegint,"1958-08-18")
ds.DateFromDaysSince2(mylink.mynegint, mylink.mydate)

DateFromComponents

根据由三个单独的值指定的年月日来返回一个日期。

语法

ds.DateFromComponents(years (int32), months (int32), dayofmonth (int32))

返回: 具有指定值的单个日期。

示例

如果 mylink.year 包含值 2010 ， mylink.month 包含值 12 ，而 mylink.dayofmonth 包含值 2 ，那么以下两个函数等效，并返回日期 2010-12-02。

ds.DateFromComponents(2010, 12, 2)
ds.DateFromComponents(mylink.year, mylink.month, mylink.dayofmonth)

DateFromJulianDay

根据指定的儒略日编号返回日期。

语法

ds.DateFromJulianDay(julianday (uint32))

返回：给定儒略日值对应的日期。

示例

如果 mylink.myjul 包含值 2454614 ，那么以下两个函数等效，并返回日期 2008-05-27。

ds.DateFromJulianDay(2454614)
ds.DateFromJulianDay(mylink.myjul)

DateOffsetByComponents

返回指定的日期在应用指定的年偏移量、月偏移量和日偏移量（作为三个单独的值指定）之后得到的日期。每个偏移值都可以是正数、零或负数。

语法

ds.DateOffsetByComponents(basedate (date), year_offset (int32), month_offset (int32), dayofmonth_offset (int32))

返回: 格式日期的给定日期偏移量。

示例

如果 mylink.basedate 包含 2011-08-18 ， mylink.yearos 包含值 2 ， mylink.monthos 包含值 0 ， mylink.dayofmonthosol 包含值 0 ，那么以下两个函数等效，并返回日期 2013-08-18。

ds.DateOffsetByComponents("2011-08-18", 2, 0, 0)
ds.DateOffsetByComponents(mylink.basedate, mylink.yearos, mylink.monthos, mylink.dayofmonthos)

如果 mylink.basedate 包含 2011-08-18， mylink.yearos 包含值 -2 ， mylink.monthos 包含值 0， mylink.dayofmonthosol 包含值 0，那么以下两个函数是等价的，并返回日期 2009-08-18。

ds.DateOffsetByComponents("2011-08-18", -2, 0, 0)
ds.DateOffsetByComponents(mylink.basedate, mylink.yearos, mylink.monthos, mylink.dayofmonthos)

天

从系统日期开始返回月中的第几天。

语法

ds.Day()

返回 :int 格式的月份中的第几天。

示例

如果当前日期为 1967-12-31 ，那么以下代码将返回 31。

ds.Day()

DaysSinceFromDate

采用类型为日期的给定日期和类型为字符串的源日期，并返回从源日期到给定日期的天数。

语法

ds.DaysSinceFromDate(given_date (date), source_date_string (string))

返回: 类型为 int32的两个给定日期之间的天差。

示例

如果 mylink.mysourcedate 包含日期 1958-08-18 ，而 mylink.mygivendate 包含日期 2008-08-18 ，那么以下两个函数等效，并返回整数值 18263。

ds.DaysSinceFromDate(mylink.mygivendate, mylink.mysourcedate)
ds.DaysSinceFromDate("2008-08-18","1958-08-18")

DaysSinceFromDate2

采用类型为日期的给定日期和类型为日期的源日期，并返回从源日期到给定日期的天数。

语法

ds.DaysSinceFromDate2(given_date (date), source_date_object (date))

返回：两个给定日期之间间隔的天数（int32 格式）。

示例

如果 mylink.mysourcedate 包含日期 1958-08-18 ，而 mylink.mygivendate 包含日期 2008-08-18 ，那么以下两个函数等效，并返回整数值 18263。

ds.DaysSinceFromDate2(mylink.mygivendate, mylink.mysourcedate)
ds.DaysSinceFromDate2("2008-08-18","1958-08-18")

DaysInMonth

返回指定的基准日期中月份的天数。

语法

ds.DaysInMonth(basedate (date))

返回：int32 格式的月份天数。

示例

如果 mylink.mysourcedate 包含日期 1958-08-18 ，那么以下两个函数等效，将返回整数值 31。

ds.DaysInMonth(mylink.mysourcedate)
ds.DaysInMonth("1958-08-18")

DaysInYear

返回指定的基准日期中年份的天数。

语法

ds.DaysInYear(basedate (date))

返回：int32 格式的年份天数。

示例

如果 mylink.mysourcedate 包含日期 2012-08-18，那么以下两个函数等效，都会返回整数值 366：

ds.DaysInYear(mylink.mysourcedate)
ds.DaysInYear("2012-08-18")

如果 mylink.mysourcedate 包含日期 2011-08-18 ，那么以下两个函数等效，将返回整数值 365。

ds.DaysInYear(mylink.mysourcedate)
ds.DaysInYear("2011-08-18")

DateOffsetByDays

返回指定的日期在应用指定天数的偏移量之后得到的日期。偏移值可以是正数、零或负数。

语法

ds.DateOffsetByDays(basedate (date), dayoffset (int32))

返回：具有相应偏移量的日期对象。

示例

如果 mylink.basedate 包含 2011-08-18 并且 mylink.dayoffset 包含值 2 ，那么以下两个函数等效，并返回日期 2011-08-20。

ds.DateOffsetByDays("2011-08-18", 2)
ds.DateOffsetByDays(mylink.basedate, mylink.dayoffset)

如果 mylink.basedate 包含 2011-08-18 ，而 mylink.dayoffset 包含值 -31 ，那么以下两个函数等效，将返回日期 2011-07-18。

ds.DateOffsetByDays("2011-08-18", -31)
ds.DateOffsetByDays(mylink.basedate, mylink.dayoffset)

HoursFromTime

返回时间的小时部分。

语法

ds.HoursFromTime(time (time))

返回：int8 格式的小时值。

示例

如果 mylink.mytime 包含时间 22:30:00，那么以下两个函数是等效的，都返回整数值 22。

ds.HoursFromTime(mylink.mytime)
ds.HoursFromTime("22:30:00")

JulianDayFromDate

根据指定的日期返回对应的儒略日编号。

语法

ds.JulianDayFromDate(time (time))

返回：给定日期的儒略日值（int32 格式）。

示例

如果 mylink.mydate 包含日期 2008-05-27 ，那么以下两个函数等效，并返回值 2454614。

ds.JulianDayFromDate("2008-05-27")
ds.JulianDayFromDate(mylink.mydate)

MicroSecondsFromTime

返回时间的微秒部分。

语法

ds.MicroSecondsFromTime(time (time))

返回：给定时间的微秒值（int32 格式）。

示例

如果 mylink.mytime 包含时间 22:30:00.32，那么以下函数将返回值 320000：

ds.MicroSecondsFromTime(mylink.mytime)

MidnightSecondsFromTime

返回从午夜到指定时间的秒数。

语法

ds.MidnightSecondsFromTime(time (time))

返回: 从午夜到时间的第二个值，采用 int8 格式。

示例

如果 mylink.mytime 包含时间 00:30:52，那么以下两个函数是等效的，都返回值 1852：

ds.MidnightSecondsFromTime("00:30:52")
ds.MidnightSecondsFromTime(mylink.mytime)

MinutesFromTime

返回时间的分钟部分。

语法

ds.MinutesFromTime(time (time))

返回: 时间的分钟值，采用 int8 格式。

示例

如果 mylink.mytime 包含时间 22:30:52，那么以下两个函数是等效的，都返回值 30：

ds.MinutesFromTime("22:30:52")
ds.MinutesFromTime(mylink.mytime)

MonthDayFromDate

返回指定日期的日部分。

语法

ds.MonthDayFromDate(date (date))

返回: int8 格式的从给定日期开始的月份中的日期。

示例

如果 mylink.mydate 包含日期 2008-08-18，那么以下两个函数是等效的，都返回值 18：

ds.MonthDayFromDate("2008-08-18")
ds.MonthDayFromDate(mylink.mydate)

MonthFromDate

返回指定日期的月份。

语法

ds.MonthFromDate(date (date))

返回: 格式为 int8的月份数。

示例

如果 mylink.mydate 包含日期 2008-08-18 ，那么以下两个函数都将返回值 8:

ds.MonthFromDate("2008-08-18")
ds.MonthFromDate(mylink.mydate)

WeekdayFromDate

返回自给定日期以来的星期几。您可以指定视为一周中第一天的日期，如果未指定，那么缺省情况下为星期日。

语法

ds.WeekdayFromDate(date (date), [origin_day (string)])

返回: 自给定日期以来的一周中的第几天，格式为 int8 。

示例

如果 mylink.mydate 包含日期 2008-08-18，那么以下两个函数是等效的，都返回值 1：

ds.WeekdayFromDate("2008-08-18")
ds.WeekdayFromDate(mylink.mydate)

如果 mylink.mydate 包含日期 2008-08-18 ，而 mylink.origin_day 包含 "星期六" ，那么以下函数等效，并返回值 2:

ds.WeekdayFromDate("2008-08-18", "saturday")
ds.WeekdayFromDate("2008-08-18", "sat")
ds.WeekdayFromDate(mylink.mydate, mylink.origin_day)

NextWeekdayFromDate

返回源日期之后第一个指定的星期几的日期。将星期几指定为全名，例如， thweek ，或三个字母的缩写，例如， "thu"。

语法

ds.NextWeekdayFromDate(sourcedate (date), day_of_week (string))

返回：给定日期的日部分。

示例

如果 mylink.mysourcedate 包含日期 2008-08-18 并且指定的星期几是星期四，那么以下两个函数等效，并返回值 2008-08-21:

ds.NextWeekdayFromDate("2008-08-18", "thursday")
ds.NextWeekdayFromDate(mylink.mysourcedate, "thu")

NthWeekdayFromDate

返回从源日期偏移指定星期数后的指定星期几的日期。星期几可以用完整名称指定，例如 thursday；也可以用三字母缩写指定，例如 thu。偏移值可以是正数、负数或零。

语法

ds.NthWeekdayFromDate(basedate (date), day_of_week (string), week_offset (int32))

返回：与指定日期偏移几周的指定工作日所在的日期。

示例

如果 mylink.mydate 包含日期 2009-08-18 ，并且使用偏移量 1 指定了星期四，那么以下两个函数等效，并返回值 2009-08-20。将返回第一次出现的星期四。在上述示例中，该星期四与日期 2009-08-18 出现在同一星期中。日期 2009-08-18 是星期二。

ds.NthWeekdayFromDate("2009-08-18", "thursday", 1)
ds.NthWeekdayFromDate(mylink.mydate, "thu", 1)

如果 mylink.mydate 包含日期 2009-08-18，而星期四的偏移量指定为 -2 ，那么下面的两个函数是等价的，并返回值 2009-08-06。返回过去的两个星期四。

ds.NthWeekdayFromDate("2009-08-18", "thursday", -2)
ds.NthWeekdayFromDate(mylink.mydate, "thu", -2)

PreviousWeekdayFromDate

返回源日期之前最近一个指定星期几的日期。将星期几指定为全名，例如， thweek ，或三个字母的缩写，例如， "thu"。

语法

ds.PreviousWeekdayFromDate(sourcedate (date), day_of_week (string))

返回：距离指定日期最近的一个工作日所在的日期。

示例

如果 mylink.mysourcedate 包含指定的日期 2008-08-18 和星期四，那么以下两个函数等效，并返回值 2008-08-14:

ds.PreviousWeekdayFromDate("2008-08-18", "thursday")
ds.PreviousWeekdayFromDate(mylink.mysourcedate, "thu")

SecondsFromTime

返回时间的第二部分。

语法

ds.SecondsFromTime(time (time))

返回 :dfloat 格式的时间的第二个值。

示例

如果 mylink.mytime 包含时间 22:30:52，那么以下两个函数是等效的，都返回值 52：

ds.SecondsFromTime("22:30:52")
ds.SecondsFromTime(mylink.mytime)

SecondsSinceFromTimestamp

返回两个时间戳记对象之间的秒数。

语法

ds.SecondsSinceFromTimestamp(timestamp (timestamp), timestamp_base_string (string))

返回 :dfloat 格式的第二个值。

示例

如果 mylink.mytimestamp 包含时间戳记 2008-08-18 22:30:52 ，并且 mylink.mytimestamp_base 包含时间戳记 2008-08-19 22:30:52 ，那么以下两个函数等效，并返回值 -86400:

ds.SecondsSinceFromTimestamp("2008-08-18 22:30:52","2008-08-19 22:30:52")
ds.SecondsSinceFromTimestamp(mylink.mytimestamp, mylink.mytimestamp_base)

SecondsSinceFromTimestamp2

返回两个时间戳记对象之间的秒数。

语法

ds.SecondsSinceFromTimestamp2(timestamp (timestamp), timestamp_base_object (timestamp))

返回 :dfloat 格式的第二个值。

示例

如果 mylink.mytimestamp 包含时间戳记 2008-08-18 22:30:52 ，并且 mylink.mytimestamp_base 包含时间戳记 2008-08-19 22:30:52 ，那么以下两个函数等效，并返回值 -86400:

ds.SecondsSinceFromTimestamp2("2008-08-18 22:30:52","2008-08-19 22:30:52")
ds.SecondsSinceFromTimestamp2(mylink.mytimestamp, mylink.mytimestamp_base)

时间

返回表示一天中的内部时间的字符串值。内部时间是自午夜起经过到最接近的千分之一秒 (本地时间) 的秒数。

语法

ds.Time()

返回: 格式字符串的结果时间。

示例

如果当前时间为 11:17:43:19 ，那么以下代码将返回 40663.842:

ds.Time()

TimeDate

以格式字符串形式返回系统时间和日期。

语法

ds.TimeDate()

返回：string 格式的系统时间和日期。

TimeFromComponents

以 int32格式返回给定小时，分钟，秒和微秒的日期类型时间。

语法

ds.TimeFromComponents(hours (int32), minutes (int32), seconds (int32), microseconds (int32))

返回: 日期类型中的时间。

示例

如果 mylink.hourcol 包含值 10 ， mylink.mincol 包含值 12 ， mylink.seccol 包含值 2 ， mylink.mseccol 包含 0 ，那么以下两个函数等效，返回时间 10:12:02:

ds.TimeFromComponents(10, 12, 2, 0)
ds.TimeFromComponents(mylink.hourcol, mylink.mincol, mylink.seccol, mylink.mseccol)

TimeFromMidnightSeconds

以时间格式返回系统时间。

语法

ds.TimeFromMidnightSeconds(seconds (time))

返回: 自午夜以来的秒数 (以时间格式表示)。

示例

如果 mylink.mymidnightseconds 包含值 240，那么以下两个函数是等效的，都返回值 00:04:00：

ds.TimeFromMidnightSeconds(240)
ds.TimeFromMidnightSeconds(mylink.mymidnightseconds)

TimeOffsetByComponents

返回基准时间在应用小时偏移量、分钟偏移量和秒偏移量（每个偏移量都以单独的值指定）之后得到的时间。秒偏移量可以包括小数。

语法

ds.TimeOffsetByComponents(basetime (time), hour_offset (int32), minute_offset (int32), second_offset (dfloat))

返回：与指定值对应的时间偏移量。

示例

如果 mylink.basetime 包含 14:05:29，mylink.houros 包含值 2，mylink.minos 包含值 0，并且 mylink.secos 包含值 20，那么以下两个函数是等效的，都返回时间 16:05:49。

ds.TimeOffsetByComponents("14:05:29", 2, 0, 20)
ds.TimeOffsetByComponents(mylink.basetime, mylink.houros, mylink.minos, mylink.secos)

TimeOffsetBySeconds

返回基准时间在应用秒偏移量之后得到的时间。秒偏移量可以包括小数。

语法

ds.TimeOffsetBySeconds(basetime (time), second_offset (dfloat))

返回: 由指定值偏移的时间 (以秒为单位)。

示例

如果 mylink.basetime 包含 14:05:29.30 并且 mylink.secos 包含值 2.5，那么以下两个函数等效，并返回时间 14:05:31。

ds.TimeOffsetBySeconds("14:05:29.30", 2.5)
ds.TimeOffsetBySeconds(mylink.basetime, mylink.secos)

TimestampFromDateTime

返回来自给定日期和时间的时间戳记。

语法

ds.TimestampFromDateTime(date (date), time (time))

返回：给定日期和时间的时间戳记。

示例

如果 mylink.mydate 包含日期 2008-08-18 ，而 mylink.mytime 包含时间 22:30:52 ，那么以下两个函数等效，并返回时间戳记 2008-08-18 22:30:52:

ds.TimestampFromDateTime("2008-08-18","22:30:52")
ds.TimestampFromDateTime(mylink.mydate, mylink.mytime)

TimestampFromSecondsSince

返回派生自基本时间戳记对象的秒数的时间戳记。

语法

ds.TimestampFromSecondsSince(seconds (dfloat), [base_timestamp_object (string)])

返回: 从给定的秒数值派生的时间戳记。

示例

如果 mylink.myseconds 包含值 2563 ，并且 mylink.timestamp_base 包含时间戳记 2008-08-18 22:30:52 ，那么以下两个函数等效，并返回时间戳记 2008-08-18 23:13:35:

ds.TimestampFromSecondsSince(2563,"2008-08-18 22:30:52")
ds.TimestampFromSecondsSince(mylink.myseconds,mylink.timestamp_base)

TimestampFromSecondsSince2

返回派生自基本时间戳记对象的秒数的时间戳记。

语法

ds.TimestampFromSecondsSince2(seconds (dfloat), [base_timestamp_object (timestamp)])

返回: 从给定的秒数值派生的时间戳记。

示例

如果 mylink.myseconds 包含值 2563 ，并且 mylink.timestamp_base 包含时间戳记 2008-08-18 22:30:52 ，那么以下两个函数等效，并返回时间戳记 2008-08-18 23:13:35:

ds.TimestampFromSecondsSince2(2563,"2008-08-18 22:30:52")
ds.TimestampFromSecondsSince2(mylink.myseconds, mylink.timestamp_base)

TimestampFromTimet

返回给定 UNIX time_t 字符串值中的时间戳记。

语法

ds.TimestampFromTimet(timet_string (int32))

返回: 从给定的秒数值派生的时间戳记。

示例

如果 mylink.mytimet 包含值 1234567890 ，那么以下两个函数等效，并返回时间戳记 2009-02-13 23:31:30:

ds.TimestampFromTimet(1234567890)
ds.TimestampFromTimet(mylink.mytimet)

TimestampFromTime2

返回来自给定时间和时间戳记对象的时间戳记。时间对象中的值会覆盖时间戳记对象中的时间值，以便仅使用时间戳记中的日期部分。

语法

ds.TimestampFromTime2(time (time), timestamp (timestamp))

返回：给定时间和时间戳记对象中的时间戳记。

示例

如果 mylink.mytime 包含时间 12:03:22 ，而 mylink.mytimestamp 包含时间戳记 2008-08-18 22:30:52 ，那么以下两个函数等效，并返回时间戳记 2008-08-18 12:03:22:

ds.TimestampFromTime2("12:03:22", "2008-08-18 22:30:52")
ds.TimestampFromTime2(mylink.mytime, mylink.mytimestamp)

TimestampOffsetByComponents

返回时间戳记，带有派生自包含年偏移量、月偏移量、日偏移量、小时偏移量、分钟偏移量和秒偏移量的基本时间戳记的偏移量，每个偏移量作为单独的值给出。秒偏移量可以包括微秒。

语法

ds.TimestampOffsetByComponents(basetimestamp (timestamp), year_offset (int32), month_offset (int32), dayofmonth_offset (int32), hour_offset (int32), minute_offset (int32), second_offset (dfloat))

返回：与指定值对应的时间戳记偏移量。

示例

如果 mylink.basetimestamp 包含 2009-08-18 14:05:29，而 mylink.yearos 包含 0， mylink.monthos 包含值 2， mylink.dayos 包含值 -4 ， mylink.houros 包含值 2， mylink.minos 包含值 0， mylink.secos 包含值 20，那么以下两个函数是等价的，并返回时间戳 2009-10-14 16:05:49。

ds.TimestampOffsetByComponents("2009-08-18 14:05:29", 0, 2, -4, 2, 0, 20)
ds.TimestampOffsetByComponents(mylink.basetimestamp, mylink.houros,
mylink.minos, mylink.secos)

TimestampOffsetBySeconds

返回时间戳记，带有派生自带有秒的基本时间戳记的偏移量。秒偏移量可以包括微秒。

语法

ds.TimestampOffsetBySeconds(basetimestamp (timestamp), second_offset (dfloat))

返回: 时间戳记格式的指定值的时间戳记偏移量。

示例

如果 mylink.basetimestamp 包含 2009-08-18 14:05:29 并且 mylink.secos 包含值 32760 ，那么以下两个函数等效，并返回时间戳记 2009-08-18 23:11:29:

ds.TimestampOffsetBySeconds("2009-08-18 14:05:29", 32760)
ds.TimestampOffsetBySeconds(mylink.basetimestamp, mylink.secos)

TimetFromTimestamp

返回来自给定时间戳记的 UNIX time_t 值。

语法

ds.TimetFromTimestamp(timestamp (timestamp))

返回: UNIX time_t (按给定时间戳记) ，格式为 int32 。

示例

如果 mylink.mytimestamp 包含值 2009-02-13 23:31:30 ，那么以下两个函数等效，并返回值 1234567890:

ds.TimetFromTimestamp("2009-02-13 23:31:30")
ds.TimetFromTimestamp(mylink.mytimestamp)

YeardayFromDate

返回指定的日期在该年份中所处的天数。

语法

ds.YeardayFromDate(date (date))

返回：int16 格式的天数。

示例

如果 mylink.mydate 包含日期 2008-08-18，那么以下两个函数是等效的，都返回值 231：

ds.YeardayFromDate("2008-08-18")
ds.YeardayFromDate(mylink.mydate)

YearFromDate

返回指定的日期所在年份。

语法

ds.YearFromDate(date (date))

返回：int16 格式的年份值。

示例

如果 mylink.mydate 包含日期 2008-08-18，那么以下两个函数是等效的，都返回值 2008：

ds.YearFromDate("2008-08-18")
ds.YearFromDate(mylink.mydate)

YearweekFromDate

返回指定的日期在该年份中所处的星期数。

语法

ds.YearweekFromDate(date (date))

返回：int16 格式的星期数。

示例

如果 mylink.mydate 包含日期 2008-08-18，那么以下两个函数是等效的，都返回值 33：

ds.YearweekFromDate("2008-08-18")
ds.YearweekFromDate(mylink.mydate)

月

返回当前月份。

语法

ds.Month()

返回: 当前月份。

示例

以下代码以 int 格式返回当前月份。

ds.Month()

年

返回当前年份。

语法

ds.Year()

返回: 当前年份为 int 格式。

示例

以下代码返回当前年份。

ds.Year()

逻辑函数

逻辑函数执行位运算。

BitAnd

返回两个整数参数的逐位与运算 (AND)。

语法

ds.BitAnd(number1 (uint64), number2 (uint64))

返回：uint64 格式的逐位与运算 (AND)。

示例

如果 mylink.mynumber1 包含数字 352，并且 mylink.mynumber2 包含数字 400，那么以下两个函数是等效的，都返回值 256：

ds.BitAnd(352,400)
ds.BitAnd(mylink.mynumber1, mylink.mynumber2)

BitCompress

返回由采用二进制“1”和“0”表示法的字符串自变量转换而成的整数。

语法

ds.BitCompress(string (string))

返回: 由格式为 uint64的二进制表示的结果数字。

示例

如果 mylink.mynumber1 包含字符串 "0101100000" ，那么以下两个函数都返回数字 352。

ds.BitCompress("0101100000")
ds.BitCompress(mylink.mynumber)

BitExpand

返回一个字符串，其中包含给定整数的二进制“1”和“0”表示法。

语法

ds.BitExpand(number (uint64))

返回：一个包含整数的二进制表示形式的字符串。

示例

如果 mylink.mynumber1 包含数字 352 ，那么以下两个函数等效，并返回字符串 "101100000"。

ds.BitExpand(352)
ds.BitExpand(mylink.mynumber)

BitOr

返回两个整数参数的逐位与运算 (OR)。

语法

ds.BitOr(number1 (uint64), number2 (uint64))

返回：两个整数参数的逐位或运算 (OR)。

示例

如果 mylink.mynumber1 包含数字 352，并且 mylink.mynumber2 包含数字 400，那么以下两个函数是等效的，都返回值 496：

ds.BitOr(352,400)
ds.BitOr(mylink.mynumber1, mylink.mynumber2)

BitXOr

返回两个整数参数的逐位与运算 (Exclusive OR)。

语法

ds.BitXOr(number1 (uint64), number2 (uint64))

返回：uint64 格式的逐位异或运算 (Exclusive OR)。

示例

如果 mylink.mynumber1 包含数字 352，并且 mylink.mynumber2 包含数字 400，那么以下两个函数是等效的，都返回值 240：

ds.BitXOr(352,400)
ds.BitXOr(mylink.mynumber1, mylink.mynumber2)

非

返回表达式逻辑值的补码。如果表达式的值为 true ，那么 Not 函数将返回值 false (0)。如果表达式的值为 false ，那么 NOT 函数将返回值 true (1)。求值结果为 0 的数字表达式返回逻辑值 False。求值结果为 NULL 值以外的其他任何值的数字表达式返回逻辑值 True。空字符串在逻辑上为 False。其他所有字符串表达式，包括包含空字符串、空格或数字 0 和空格的字符串都为 True。

语法

ds.Not()

返回: complement 的值，采用 int8 格式。

示例

如果 mylink.myexpression 包含表达式 5-5 ，那么以下两个函数等效，并返回值 1:

ds.Not(5-5)
ds.Not(mylink.myexpression)

如果 mylink.myexpression 包含表达式 5+5，那么以下两个函数是等效的，都返回值 0：

ds.Not(5+5)
ds.Not(mylink.myexpression)

SetBit

返回特定位设置为特定状态的整数，其中 origfield 是要对其执行操作的输入值，bitlist 是一个字符串，包含由逗号分隔的要设置状态的位数字的列表，bitstate 为 1 或 0，表明要将这些位设置为哪种状态。

语法

ds.SetBit(origfield (uint64), bitlist (string), bitstate (uint8))

返回：其各个位已设置为指定状态的数字（uint64 格式）。

示例

如果 mylink.origfield 包含数字 352 ， mylink.bitlist 包含列表 "2,4,8" ，而 mylink.bitstate 包含值 1 ，那么以下两个函数等效，并返回值 494:

ds.SetBit(356,"2,4,8",1)
ds.SetBit(mylink.origfield, mylink.bitlist, mylink.bitstate)

True

返回 1 的 true 值。

语法

ds.True()

返回: 整数 1。

示例

以下代码返回 1:

ds.True()

False

返回 0 的 false 值。

语法

ds.False()

返回: 整数 0。

示例

以下代码返回 0:

ds.False()

数学函数

数学函数执行数学运算。

Abs

返回任意数字表达式的绝对值。表达式的绝对值是其无符号量级。

语法

ds.Abs(numeric_expression (int32))

返回：数字表达式的绝对值（dfloat 格式）。

示例

如果 mylink.number1 包含数字 12，并且 mylink.number2 包含数字 34，那么以下两个函数是等效的，都返回数字 22：

ds.Abs(12-34)
ds.Abs(mylink.mynumber1-mylink.mynumber2)

如果 mylink.number1 包含数字 34，并且 mylink.number2 包含数字 12，那么以下两个函数是等效的，都返回数字 22：

ds.Abs(34-12)
ds.Abs(mylink.mynumber1-mylink.mynumber2)

Acos

计算表达式的三角反余弦值。该表达式的值必须是数字值。结果以弧度表示。

语法

ds.Acos(numeric_expression (dfloat))

返回：dfloat 格式的弧度结果。

示例

如果 mylink.number 包含数字 0.707106781，那么以下两个函数等效，并返回值 0.7854:

ds.Acos(0.707106781)
ds.Acos(mylink.mynumber)

ACOS

返回表达式的三角弧余弦值。输入必须是数字值。结果以度数表示。

语法

ds.ACOS(expression (float64))

返回: float64 格式的角度 (以度为单位)。

示例

以下代码返回值 45:

ds.ACOS(0.707106781)

Asin

计算表达式的三角反正弦值。该表达式的值必须是数字值。结果以弧度表示。

语法

ds.Asin(numeric_expression (dfloat))

返回：dfloat 格式的弧度结果。

示例

如果 mylink.number 包含数字 0.707106781，那么以下两个函数等效，并返回值 0.7854:

ds.Asin(0.707106781)
ds.Asin(mylink.mynumber)

ASIN

返回表达式的三角正弦。输入是以度数表示的角度。

语法

ds.ASIN(expression(float64))

返回: float64 格式的角度 (以度为单位)。

示例

以下代码返回值 45:

ds.ASIN(0.707106781)

Atan

计算表达式的三角反正切值。该表达式的值必须是数字值。结果以弧度表示。

语法

ds.Atan(numeric_expression (dfloat))

返回：dfloat 格式的弧度结果。

示例

如果 mylink.number 包含数字 135 ，那么以下两个函数等效，并返回值 1.5634，即弧切线为 135 的角度:

ds.Atan(135)
ds.Atan(mylink.mynumber)

ATAN

返回表达式的三角反正切。输入必须是数字值。结果以度数表示。

语法

ds.ATAN(expression(float64))

返回 :dfloat 格式的角度 (以度数为单位)。

示例

以下代码返回值 45:

ds.ATAN(1)

Atan2

通过使用两个输入的符号计算两个输入的三角反正切，以确定结果的象限。输入必须为数字值。结果以弧度表示。

语法

ds.Atan2(numeric_expression (dfloat, dfloat))

返回：dfloat 格式的弧度结果。

示例

如果 mylink.number1 包含数字 10.0 ，而 mylink.number2 包含数字 -10.0，那么以下两个函数等效，并返回值 2.3562:

ds.Atan2(10.0, -10.0)
ds.Atan2(mylink.mynumber1, mylink.mynumber2)

Ceil

计算大于等于指定十进制值的最小整数值。

语法

ds.Ceil(number (dfloat))

返回：int32 格式的最小整数值。

示例

如果 mylink.number 包含数字 2355.66，那么以下两个函数是等效的，都返回值 2356：

ds.Ceil(2355.66)
ds.Ceil(mylink.mynumber)

Cos

计算表达式的三角余弦值。该表达式的值必须是数字值。该表达式必须生成一个数字值，该数字值是以弧度表示的角度。

语法

ds.Cos(radians (dfloat))

返回：以弧度表示的角度（dfloat 格式）。

示例

如果 mylink.number 包含数字 0.785398，那么以下两个函数是等效的，都返回值 0.7071：

ds.Cos(0.785398)
ds.Cos(mylink.mynumber)

销售成本

返回角度的三角余弦值。表达式是一个以度为单位的值的角度。

语法

ds.COS(expression(float64))

返回: float64 格式的角度 (以度为单位)。

示例

以下代码返回值 0.7071:

ds.COS(45)

Cosh

计算表达式的双曲余弦值。该表达式的值必须是数字值。

语法

ds.Cosh(number (dfloat))

返回：dfloat 格式的余弦结果。

示例

如果 mylink.number 包含数字 2，那么以下两个函数是等效的，都返回值 3.7622：

ds.Cosh(2)
ds.Cosh(mylink.mynumber)

分区

计算表达式的双曲余弦值。该表达式的值必须是数字值。

语法

ds.Div(dividend (dfloat), divisor (dfloat))

返回：dfloat 格式的余弦结果。

示例

如果 mylink.dividend 包含数字 100，并且 mylink.divisor 包含数字 25，那么以下两个函数是等效的，都返回值 4：

ds.Div(100,25)
ds.Div(mylink.dividend, mylink.divisor)

扩充

计算以 e 为底，表达式值指定次幂的结果。 e 的值近似于 2.71828。该表达式的值必须是数字值。

语法

ds.Exp(number (dfloat))

返回：e 的指定次幂（dfloat 格式）。

示例

如果 mylink.number 包含数字 5，那么以下两个函数是等效的，都返回值 54.5982：

ds.Exp(5-1)
ds.Exp(mylink.number-1)

Fabs

计算指定浮点值的绝对值。

语法

ds.Fabs(number (dfloat))

返回：浮点数的绝对值。

示例

如果 mylink.number 包含数字 -26.53，那么以下两个函数是等效的，都返回值 26.53：

ds.Fabs(-26.53)
ds.Fabs(mylink.number)

Floor

计算小于等于指定十进制值的最大整数值。

语法

ds.Floor(number (dfloat))

返回: 小于或等于 int32 格式的十进制值的最大整数。

示例

如果 mylink.number 包含数字 203.25，那么以下两个函数是等效的，都返回值 203：

ds.Floor(203.25)
ds.Floor(mylink.number)

Ldexp

返回 2 的指数次幂乘以尾数的双精度浮点值。

语法

ds.Ldexp(mantissa (dfloat), exponent (int32))

返回：dfloat 格式的尾数结果。

示例

如果 mylink.mantissa 包含数字 2，并且 mylink.exponent 包含数字 3，那么以下两个函数是等效的，都返回值 16：

ds.Ldexp(2,3)
ds.Ldexp(mylink.mantissa, mylink.exponent)

Llabs

计算指定整数值的绝对值。

语法

ds.Llabs(number (integer))

返回：给定整数的绝对值（无符号整数格式）。

示例

如果 mylink.number 包含数字 -26，那么以下两个函数是等效的，都返回值 26。

ds.Llabs(-26)
ds.Llabs(mylink.number)

行

计算以 e为底的表达式的自然对数。 e 的值近似于 2.71828。该表达式的值必须为大于 0 的数字值。

语法

ds.Ln(number (dfloat))

返回：以 e 为底的表达式的对数。

示例

如果 mylink.number 包含数字 6 ，那么以下两个函数等效，并返回值 1.7918:

ds.Ln(6)
ds.Ln(mylink.number)

Log10

返回指定值的以 10 为底的对数。

语法

ds.Log10(number (dfloat))

返回: 生成的 dfloat 格式的以 10 为底的对数。

示例

如果 mylink.number 包含数字 6 ，那么以下两个函数等效，并返回值 1.7782:

ds.Log10(6)
ds.Log10(mylink.number)

最大值

返回两个参数值中较大的值。

语法

ds.Max(number1 (int32), number2(int32))

返回: int32 格式的两个整数中的较大者。

示例

如果 mylink.number1 包含数字 6，并且 mylink.number1 包含数字 101，那么以下两个函数是等效的，都返回值 101：

ds.Max(6,101)
ds.Max(mylink.number1, mylink.number2)

最小值

返回两个自变量值的最小值。

语法

ds.Min(number1 (int32), number2(int32))

返回：两个整数中的较小者。

示例

如果 mylink.number1 包含数字 6，并且 mylink.number1 包含数字 101，那么以下两个函数是等效的，都返回值 6：

ds.Min(6,101)
ds.Min(mylink.number1, mylink.number2)

Mod

计算两个表达式 (dividend, divisor) 的模数（余数）。

语法

ds.Mod(dividend (int32), divisor (int32))

返回：int32 格式的模数结果。

示例

如果 mylink.dividend 包含数字 115，并且 mylink.divisor 包含数字 25，那么以下两个函数是等效的，都返回值 15：

ds.Mod(115,25)
ds.Mod(mylink.dividend, mylink.divisor)

Neg

对数字求反。

语法

ds.Neg(number (dfloat))

返回: 生成的 dfloat 格式的求反数。

示例

如果 mylink.number 包含数字 123，那么以下两个函数是等效的，都返回值 -123：

ds.Neg(123)
ds.Neg(mylink.number)

Pwr

计算表达式的指定次幂的值 (expression, power)。

语法

ds.Pwr(expression (dfloat), power (dfloat))

返回: 以 dfloat 格式将生成的数字提升到指定的幂。

示例

如果 mylink.expression 包含数字 2，并且 mylink.power 包含数字 3，那么以下两个函数是等效的，都返回值 8：

ds.Pwr(2,3)
ds.Pwr(mylink.expression, mylink.power)

兰特

返回 0 到 2³²-1 之间的伪随机整数。

语法

ds.Rand()

返回：uint32 格式的随机整数结果。

示例

此函数用于生成伪随机数：

ds.Rand()

随机

返回 0 到 2³²-1 之间的伪随机整数。

语法

ds.Random()

返回：uint32 格式的随机整数结果。

示例

此函数用于生成随机数：

ds.Random()

朗德

生成任何正或负随机整数或 0。采用整数的总数作为输入，包括可以从中选择随机数的 0。即，如果 n 是 numeric_expression 的值，那么将从数字 0 到 (n-1) 生成随机数。

语法

ds.Rnd(numeric_expression (int))

返回: 从 0 到 (numeric_expression - 1) 的整数格式的随机数。

示例

以下代码返回 0-19 的随机数。

ds.Rnd(20)

Sin

计算表达式的三角正弦值。该表达式的值必须是数字值。该表达式必须生成一个数字值，该数字值是以弧度表示的角度。

语法

ds.Sin(radians (dfloat))

返回：dfloat 格式的角度结果。

示例

如果 mylink.number 包含数字 0.785398，那么以下两个函数是等效的，都返回值 0.7071：

ds.Sin(0.785398)
ds.Sin(mylink.mynumber)

SIN

返回表达式的三角正弦。输入是以度数表示的角度。

语法

ds.SIN(expression(float64))

返回 :dfloat 格式的角度 (以度数为单位)。

示例

以下代码返回值 0.7071:

ds.SIN(45)

Sinh

计算表达式的双曲正弦值。该表达式的值必须是数字值。

语法

ds.Sinh(number (dfloat))

返回：dfloat 格式的正弦结果。

示例

如果 mylink.number 包含数字 2 ，那么以下两个函数等效，并返回值 3.6269:

ds.Sinh(2)
ds.Sinh(mylink.mynumber)

平方根

计算数字的平方根。

语法

ds.Sqrt(number (dfloat))

返回：给定数字的平方根结果（dfloat 格式）。

示例

如果 mylink.number 包含数字 450，那么以下两个函数是等效的，都返回值 21.2132：

ds.Sqrt(450)
ds.Sqrt(mylink.mynumber)

黄褐色

计算表达式的三角正切值。该表达式必须生成一个数字值，该数字值是以弧度表示的角度。

语法

ds.Tan(radians (dfloat))

返回：dfloat 格式的正切结果。

示例

如果 mylink.number 包含数字 0.7853981，那么以下两个函数等效，并返回值 1:

ds.Tan(0.7853981)
ds.Tan(mylink.mynumber)

TAN

返回 TAN 函数以返回输入的三角正切。输入表示以度数表示的角度。

语法

ds.TAN(expression(float64))

返回: float64 格式的角度 (以度为单位)。

示例

以下代码返回值 1:

ds.TAN(45)

ATAN

返回表达式的三角反正切。输入必须是数字值。结果以度数表示。

语法

ds.ATAN(expression(float64))

返回: float64 格式的角度 (以度为单位)。

示例

以下代码返回值 45:

ds.ATAN(1)

Tanh

计算表达式的双曲正切值。该表达式的值必须是数字值。

语法

ds.Tanh(number (dfloat))

返回：dfloat 格式的正切结果。

示例

如果 mylink.number 包含数字 2，那么以下两个函数是等效的，都返回值 0.964028：

ds.Tanh(2)
ds.Tanh(mylink.mynumber)

数字函数

数字函数用于抽取十进制数或浮点数中的尾数。表达式编辑器中的“数字”类别还包含类型为 casting 的函数，您可以使用该函数对数据类型为 double、float 或 integer 的数字进行强制类型转换。

当在结果为字符串的派生中使用变换器函数 AsDouble()， AsFloat()和 AsInteger() 时，它们的行为与其他变换器数据转换函数不同。此行为是因为变换器编译器不会将这些函数的函数结果转换为字符串。

AsDouble

将给定数字视为双精度数。

语法

ds.AsDouble(number (int, float and so on))

返回: 双精度值格式的数字。

示例

在以下表达式中，输入 mynumber 包含一个整数，但函数输出一个双精度值。如果 mylink.mynumber 包含值 56 ，那么以下两个函数等效，并返回值 12.963:

ds.AsDouble(56/4.32)
ds.AsDouble(mylink.mynumber/4.32)

AsFloat

将给定数字视为浮点数。

语法

ds.AsFloat(number (int, double and so on))

返回：float 格式的数字。

示例

在以下表达式中，输入 mynumber 包含一个整数，但函数输出一个浮点数。如果 mylink.mynumber 包含值 56 ，那么以下两个函数等效，并返回值 12.963:

ds.AsFloat(56/4.32)
ds.AsFloat(mylink.mynumber/4.32)

AsInteger

将给定数字视为整数。但是，当将十进制分配给整数时，与将浮点数或双精度值分配给整数时，行为上存在差异。如果是从浮点数或双精度数转换为整数，那么这是对整数的简单赋值。对于十进制 AsInteger()，将启动函数并将输出舍入为最接近的值。

语法

ds.AsInteger(number (float, double and so on))

返回：integer 格式的数字。

示例

在以下表达式中，输入值 12.962963 的类型为 Double。尽管该值的类型为 Double，但函数输出一个整数。因此，它是对整数函数的简单赋值，并返回值 12:

ds.AsInteger(12.962963)

在以下表达式中，类似 (56/4.32) 的计算被视为 "十进制" 类型， AsInteger() 函数调用开始向最接近的值舍入并返回值 13:

ds.AsInteger(56/4.32)

修订

将数字值转换为具有指定精度数的浮点数。如果数字求值为空值，那么将返回空值。精度值是与浮点数中的精度位数相对应的数字值。缺省精度为 4。方式值是一个标志，用于指定处理多余数字的方式。如果方式为 0 或未指定，那么将舍入多余的数字。如果方式不是 0 ，那么将截断多余的数字。

语法

ds.FIX(numeric_expression (string), precision (int8), mode (int32))

返回: 转换的格式 dfloat 数。

示例

以下代码返回数字 37.7363。

ds.FIX("37.73629273")

MantissaFromDecimal

返回给定十进制数的尾数。

语法

ds.MantissaFromDecimal(number (decimal))

返回：dfloat 格式的尾数。

示例

如果 mylink.number 包含数字 243.7675，那么以下两个函数是等效的，都返回值 7675：

ds.MantissaFromDecimal(243.7675)
ds.MantissaFromDecimal(mylink.mynumber)

MantissaFromDFloat

返回给定双精度浮点数的尾数。

语法

ds.MantissaFromDFloat(number (dfloat))

返回：dfloat 格式的尾数。

示例

如果 mylink.number 包含数字 1.234412000000000010E+4，那么以下函数将返回值 1:

ds.MantissaFromDFloat(mylink.mynumber)

实数

将字符串中的数字转换为浮点类型，而不会丢失准确性。

语法

ds.Real(numeric_expression (string))

返回: 转换的格式 dfloat 数。

示例

以下代码返回数字 1.23。

ds.Real("1.23")

原始函数

使用 "原始" 函数可获取包含原始数据的列中数据的长度。

RawLength

返回原始字符串的长度。

语法

ds.RawLength(input string (string))

返回：原始字符串的长度（int32 格式）。

示例

如果 mylink.rawdata 包含来自位图的原始数据，那么以下函数将返回该位图的大小（以字节为单位）：

ds.RawLength(mylink.rawdata)

字符串函数

将这些函数用于表达式中与字符串相关的函数。

AlNum

检查指定的字符串中是否只包含字母数字字符。

语法

ds.AlNum(string (string))

返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。

示例

如果 mylink.mystring1 包含字符串“OED_75_9*E”，那么以下函数将返回值 0 (false)。

ds.AlNum(mylink.mystring1)

如果 mylink.mystring2 包含字符串“12redroses”，那么以下函数将返回值 1 (true)。

ds.AlNum(mylink.mystring2)

Alpha

检查指定的字符串是否只包含字母字符。

语法

ds.Alpha(string (string))

返回：int8 类型的结果；如果输入对于给定类型有效，那么返回 1，否则返回 0。

示例

如果 mylink.mystring1 包含字符串 "12redroses" ，那么以下函数将返回值 0 (false)。

ds.Alpha(mylink.mystring1)

如果 mylink.mystring2 包含字符串 "头" ，那么以下函数将返回值 1 (true)。

ds.Alpha(mylink.mystring2)

cats

并置两个字符串。

语法

ds.Cats(str1 (string), str2 (string))

返回: 生成的并置字符串。

示例

以下代码返回 "ABC123"。

ds.Cats("ABC", "123")

更改

将表达式中的给定子串替换为替换字符串。

如果 substring 自变量为空字符串，那么会返回 expression 自变量的值。

如果替换自变量的值为空字符串，那么将除去从 begin 自变量的值指示的位置开始出现的所有子串。如果出现参数的值小于或等于 0 ，那么将替换从 begin 参数的值指示的位置开始的所有出现。否则，替换的出现次数将由出现自变量的值指示，从 begin 自变量的值指示的位置开始。如果 begin 自变量的值小于或等于 1，那么将从出现的第一个 substring 开始进行替换。否则，替换从由 thebegin 自变量的值指示的位置开始。

语法

ds.Change(expression (string), substring (string), replacement (string), [occurrence (int32), [begin (int32)]])

返回：替换了所有子字符串的新字符串。

示例

如果 mylink.mystring 包含表达式 "aaabbbcccbbb"，那么下面的函数将返回字符串 "aaaZZZcccZZZ"。

ds.Change(mylink.mystring,"bbb","ZZZ")

如果 mylink.mystring 包含表达式 "ABC" 并且子串为空，那么以下函数将返回字符串 "ABC"。

ds.Change(mylink.mystring,"","ZZZ")

如果 mylink.mystring 包含表达式 "aaabbbcccbbb" 并且替换为空，那么以下函数将返回字符串 "aaaccc"。

ds.Change(mylink.mystring, "bbb", "")

CompactWhiteSpace

返回将所有连续空格减少到单个空格后得到的字符串。

语法

ds.CompactWhiteSpace(string (string))

返回：去掉了多余空格的字符串结果。

示例

如果 mylink.mystring 包含字符串 "too many spaces" ，那么以下函数将返回字符串 "too many spaces":

ds.CompactWhiteSpace(mylink.mystring)

比较

比较用于排序的两个字符串。比较可以采用左对齐形式（缺省值），也可以采用右对齐形式。右对齐比较将指定字符串中的数字子串作为数字进行比较。

在每个字符串中，数字字符串必须出现相同的字符位置。例如，对字符串 AB100 和 AB99 的右对齐比较结果表明 AB100 大于 AB99，这是因为 100 大于 99。字符串 AC99 和 AB100 的左对齐比较指示 AC99 更大，因为 C 大于 B。

语法

ds.Compare(string1 (string), string2 (string), [justification ("L" or "R")])

返回：int8 类型的结果；如果 string1 小于 string2，那么返回 -1；如果两个字符串相同，那么返回 0；如果 string1 大于 string2，那么返回 1。

示例

如果 mylink.mystring1 包含字符串 "AB99" ，而 mylink.mystring2 包含字符串 "AB100" ，那么以下函数将返回结果 1。

ds.Compare(mylink.mystring1, mylink.mystring2, "L")

如果 mylink.mystring1 包含字符串 " AB99 "， mylink.mystring2 包含字符串 " AB100 "，那么下面的函数将返回结果 -1。

ds.Compare(mylink.mystring1, mylink.mystring2, "R")

CompareNoCase

比较用于排序的两个字符串（忽略其大小写）。

语法

ds.CompareNoCase(string1 (string), string2 (string))

返回：int8 类型的结果；如果 string1 小于 string2，那么返回 -1；如果两个字符串相同，那么返回 0；如果 string1 大于 string2，那么返回 1。

示例

如果 mylink.mystring1 包含字符串 "巧克力蛋糕" ，而 mylink.mystring2 包含字符串 "巧克力蛋糕" ，那么以下函数将返回结果 0。

ds.CompareNoCase(mylink.mystring1, mylink.mystring2)

CompareNum

比较两个字符串的前 n 个字符（n 由用户指定）。

语法

ds.CompareNum(string1 (string), string2 (string), length (int16))

返回：int8 类型的结果；如果 string1 小于 string2，那么返回 -1；如果两个字符串相同，那么返回 0；如果 string1 大于 string2，那么返回 1。

示例

如果 mylink.mystring1 包含字符串 "巧克力" ，而 mylink.mystring2 包含字符串 "巧克力治疗" ，那么以下函数将返回结果 0。

ds.CompareNum(mylink.mystring1, mylink.mystring2,4)

CompareNumNoCase

比较两个字符串的前 n 个字符（忽略其大小写，n 由用户指定）。

语法

ds.CompareNumNoCase(string1 (string), string2 (string), length (int16))

返回：int8 类型的结果；如果 string1 小于 string2，那么返回 -1；如果两个字符串相同，那么返回 0；如果 string1 大于 string2，那么返回 1。

示例

如果 mylink.myraw 包含字符串 "巧克力" ，而 mylink.mystring2 包含字符串 "巧克力治疗" ，那么以下函数将返回结果 0。

ds.CompareNumNoCase(mylink.mystring1, mylink.mystring2,4)

转换

将字符串转换为指定的内部或外部存储格式。字符串表达式用于对要转换的字符串求值。

下表显示了可为转换指定的值。 conv_code 指定转换中涉及的存储格式类型， conv_mode 指定用于输入或输出的格式。如果对 conv_mode指定 "I" ，那么将使用 ICONV() 函数进行转换。如果为 conv_mode指定 "O" ，那么将使用 OCONV() 函数进行转换。

转换值表

`conv_code`	`conv_mode`	描述
MX	I	将输入字符串从十六进制转换为十进制。
MB	I	将输入字符串从二进制转换为十进制。
MX0C	I	将输入字符串从十六进制转换为 ASCII 字符串。
MB0C	I	将输入字符串从二进制转换为 ASCII 字符串。
MX	O	将输入字符串从十进制转换为十六进制。
MB	O	将输入字符串从十进制转换为二进制。
MX0C	O	将输入字符串从 ASCII 字符串转换为十六进制。
MB0C	O	将输入字符串从 ASCII 字符串转换为二进制。

语法

ds.Conversion(string (string), conv_code (string), conv_mode (string))

返回: 转换后的字符串。

示例

如果 mylink.mystring 包含字符串 "1111" ，那么以下函数将返回值 15。

ds.Conversion(mylink.mystring,"MB", "I")

如果 mylink.mystring 包含字符串 "CDE" ，那么以下函数将返回值 434445。

ds.Conversion(mylink.mystring,"MX0C", "O")

转换

转换给定 expression 中指定的字符串中的字符。将一个列表中指定的字符转换为另一个列表中指定的字符。

语法

ds.Convert(fromlist (string), tolist (string), expression (string))

返回：包含转换后的指定字符的字符串。

示例

如果 mylink.mystring1 包含字符串 "NOW IS THE TIME" ，那么以下函数将返回字符串 "NOW YS XHE XYME"。

ds.Convert("TI","XY", mylink.mystring1)

计数

统计子串在字符串中出现的次数。

语法

ds.Count(string (string), substring (string))

返回: int32 格式的子串出现次数。

示例

如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒" ，那么以下函数将返回 3。

ds.Count(mylink.mystring1, "choc")

Dcount

统计字符串中定界字段的数目。

语法

ds.Dcount(string (string), delimiter (string))

返回: int32 格式的定界字段数。

示例

如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒" ，那么以下函数将返回 3。

ds.Dcount(mylink.mystring1,",")

DownCase

将字符串中的所有大写字母转换为小写字母。

语法

ds.DownCase(string (string))

返回: 生成的字符串 (全小写)。

示例

如果 mylink.mystring1 包含字符串 "CaMel cAsE", ，那么下面的函数将返回字符串 "camel case"。

ds.DownCase(mylink.mystring1)

DQuote

在字符串两边加上双引号。

语法

ds.DQuote(string (string))

返回：用双引号括起的字符串结果。

示例

如果 mylink.mystring1 包含字符串需要引号，那么以下函数将返回字符串 "需要引号"。

ds.DQuote(mylink.mystring1)

Ereplace

将 expression 中的 substring 替换为 replacement 字符串。

如果 substring 自变量为空字符串，那么 replacement 自变量的值将前缀 expression 自变量的值。如果替换自变量是空字符串，那么将除去从 begin 自变量的值指示的位置开始的所有出现的子串。如果实例参数的值小于或等于 0 ，那么将替换从 begin 参数的值开始的所有实例。否则，将从 begin 自变量的值指示的位置开始，替换出现，替换的数量根据 occurrence 自变量的值指示确定。如果 begin 自变量的值小于或等于 1，那么将从出现的第一个 substring 开始进行替换。否则，替换将从 begin 自变量的值所指示的位置开始。

语法

ds.Ereplace(expression (string), substring (string), replacement (string), [occurrence (int32), [begin (int32)]])

返回：替换了所有出现的子字符串的字符串结果。

示例

如果 mylink.mystring 包含表达式 "ABC" 并且子串为空，那么以下函数将返回值 "ZZZABC"。

ds.Ereplace(mylink.mystring,"","ZZZ")

如果 mylink.mystring 包含表达式 "aaabbbcccbbb" 并且替换为空，那么以下函数将返回值 "aaaccc"。

ds.Ereplace(mylink.mystring, "bbb", "")

交换

替换字符串中的字符。

语法

ds.Exchange(str (string), findStr (string), replaceStr (string))

返回: 生成的带有替换字符的字符串。

示例

以下代码返回: ".B.BC"。

ds.Exchange("ABABC", "41", "2E")

EXTRACT

从动态数组中访问指定字段，值或子值的数据内容。与 REMOVE类似的函数。

输入动态数组必须只有 CHAR (254) ， CHAR (253) ， CHAR (252) 作为定界符，并且它们的层次结构必须是前写的。可以分别通过 AM ， FM ， VM ， SM 或 SVM 函数进行检索。 FM 是字符串字段的定界符， VM 是字符串值的定界符， SM 是字符串子值的定界符。

要了解有关 EXTRACT 的更多信息，请参阅 EXTRACT 功能。

语法

ds.EXTRACT(str (string), field (int64), [value (int64), subvalue (int64)])

返回: 生成的格式字符串的抽取字符串。

示例

以下代码均返回: "9 ü 3 ü 5"。动态数组包含以 FM/AM 分隔的 3 个字段，第一个字段中的 2 个值，第一个值中的 1 个子值等等。

ds.EXTRACT("1" + ds.FM() + "4" + ds.VM() + "9" + ds.SM() + "3" + ds.SM() + "5" + ds.FM() + "1" + ds.VM() + "0" + ds.SM() + "7" + ds.SM() + "3", 2, 2)
ds.EXTRACT("1" + ds.AM() + "4" + ds.VM() + "9" + ds.SM() + "3" + ds.SM() + "5" + ds.AM() + "1" + ds.VM() + "0" + ds.SM() + "7" + ds.SM() + "3", 2, 2)

以下代码返回空字符串，因为只有 3 个字段，而不是 10 个或更多字段。

ds.EXTRACT("1" + ds.FM() + "4" + ds.VM() + "9" + ds.SM() + "3" + ds.SM() + "5" + ds.FM() + "1" + ds.VM() + "0" + ds.SM() + "7" + ds.SM() + "3", 10, 0, 0)

字段

返回位于字符串中指定定界符之间的一个或多个子串。自变量 occurrence 指定第几个出现的定界符用作终止符。自变量 number 指定返回多少个子串（可选）。

语法

ds.Field(string (string), delimiter (string), occurrence (int32), [number (int32)])

返回：定界符之间的相应字符串。

示例

如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒，巧克力营养师" ，那么以下函数将返回字符串 " 巧克力冰激凌 "。

ds.Field(mylink.mystring1,",",2)

如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒，巧克力营养师" ，那么以下函数将返回字符串 " 巧克力冰淇淋，巧克力棒 "。

ds.Field(mylink.mystring1,",",2,2)

FieldStore

通过插入，删除或替换由指定定界符字符串分隔的字段来修改字符串。定界符字符串表示要修改的字符串，可以是任何单个 ASCII 字符。此函数还采用参数 start (修改开始的输入字符串的位置) 和 number (这是在输入字符串中插入新字符串的次数)。

语法

ds.FieldStore(str (string), delimiter (string), start (int8), number (int8), new_fields (string))

返回: 格式字符串的已修改字符串。

示例

以下代码返回字符串 A#B#C#D#5:

ds.FieldStore("1#2#3#4#5", "#", 1, 4, "A#B#C#D")

Fmt

使用 FMT 函数或格式表达式来格式化数据以进行输出。任何 BASIC 表达式都可以通过跟在它后面使用格式表达式来进行格式化以输出。有关 Fmt 函数语法的详细信息，请参阅 FMT 函数。

语法

ds.Fmt(string (string), format (string))

返回: 生成的格式字符串的格式化数据。

示例

以下代码返回字符串 "23-69-86":

ds.Fmt("236986","R##-##-##")

以下代码返回数字 "***** $555,666 ，898.00":

ds.Fmt("555666898","20*R2$,")

FmtDP

将类型为字符串的多字节字符集转换为目标格式。如果未启用全球化 (全球化) ，那么 FmtDP 函数的工作方式类似于等效的 Fmt 函数。有关 FmtDP 函数的语法的详细信息，请参阅 FmtDP 函数。

语法

ds.FmtDP(string (string), format (string), [mapname (string)])

返回: 格式字符串的转换字符串。

示例

以下代码返回数字 56789:

ds.FmtDP("123456789","R#5")

折叠

折叠字符串以创建子串。 string 是要折叠的字符串。 length 是子串的长度 (以字符计)。

ds.Fold(str (string), length (int8))

返回: 生成的折叠字符串。

以下代码返回 "T E S I S A B I S A B E S T E S T E D D D STRING"。

ds.Fold("THIS IS A TEST FOLDED STRING", 5)

福尔德普

在全球化 (全球化) 方式下，折叠字符串以创建使用字符显示位置的子串。

语法

ds.Folddp(str (string), length (int), opmap (string))

返回: 生成的折叠字符串。

示例

以下代码返回: "这里需要使用 UNICODE STRING"。

ds.Folddp("这里需要 UNICODE STRING", 5, "0")

索引

查找子串的起始字符位置。自变量 occurrence 指定要查找第几个出现的子串。

语法

ds.Index(string (string), substring (string), occurrence (int32))

返回: int32 格式的出现次数的结果。

示例

如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒，巧克力营养师" ，那么以下函数将返回值 18。

ds.Index(mylink.mystring1,"chocolate",2)

左侧

返回字符串中最左侧的 n 个字符。

语法

ds.Left(string (string) number (int32))

返回：字符串中最左侧的 n 个字符。

示例

如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒，巧克力营养师" ，那么以下函数将返回字符串 "巧克力"。

ds.Left(mylink.mystring1,9)

Len

返回字符中字符串的长度。

语法

ds.Len(string (string))

返回: 字符串的长度，采用 int32 格式。

示例

如果 mylink.mystring1 包含字符串 "巧克力" ，那么以下函数将返回值 9。

ds.Len(mylink.mystring1)

伦德普

在全球化 (全球化) 方式下，返回字符串的长度及其总显示位置。

语法

ds.Lendp(str (string), opmap (string))

返回: 格式为 int64的字符串的长度。

示例

以下代码返回: 19。

ds.Lendp("这里需要 UNICODE STRING", "0")

匹配项

与 MATCHES 的同义词。用于将字符串表达式与模式进行比较。要了解有关 Match 语法的更多信息，请参阅匹配操作符。

语法

ds.Match(str (string), pattern (string))

返回: 模式是否与格式为 Boolean 的输入字符串匹配的结果。

示例

以下代码返回 false:

ds.Match("XYZ123AB", "3X3N")

以下代码返回 true:

ds.Match("XYZ123AB", "3X3N...")

MatchField

搜索字符串并返回其与输入 pattern 参数匹配的部分。要了解有关 MatchField 语法的更多信息，请参阅 MATCH 操作符。

语法

ds.MatchField(str (string), pattern (string), field (int))

返回: 格式字符串的结果。

示例

以下代码返回字符串 "XYZ":

ds.MatchField("XYZ123AB", "3X3N...", 1)

编号

如果字符串可以转换为数字，那么返回 1。否则，返回 0。

语法

ds.Num(string (string))

返回: 如果字符串可以转换为数字，那么返回 1 ，否则返回 0 ，格式为 int32 。

示例

如果 mylink.mystring1 包含字符串 "22" ，那么以下函数将返回值 1。

ds.Num(mylink.mystring1)

如果 mylink.mystring1 包含字符串 "二十二" ，那么以下函数将返回值 0。

ds.Num(mylink.mystring1)

PadString

返回用指定的填充字符数填充的字符串。

语法

ds.PadString(string (string) padstring (string) padlength (int32))

返回：填充字符串结果。

示例

如果 mylink.mystring1 包含字符串 "AB175" ，那么以下函数将返回字符串 "AB17500000"。

ds.PadString(mylink.mystring1,"0",5)

移除

抽取并返回由系统定界符分隔的动态数组元素，并指示找到了哪个系统定界符。它接受一个 CHAR 作为定界符，并返回对应于找到的定界符的数字。

号	分隔符类型
0	字符串结束
1	项标记 ASCII CHAR (255)
2	字段标记 ASCII CHAR (254)
3	值标记 ASCII CHAR (253)
4	子值标记 ASCII CHAR (252)
5	文本标记 ASCII CHAR (251)
6	ASCII CHAR (250) (PIOPEN 风格中不可用)
7	ASCII CHAR (249) (PIOPEN 风格中不可用)
8	ASCII CHAR (248) (在 PIOPEN 类型模板中不可用)

有关 REMOVE 功能的更多信息，请参阅 REMOVE 功能。

语法

ds.REMOVE(str (string))

返回: 除去格式字符串列表的定界符后生成的字符串，以及与找到的定界符对应的数字。

示例

以下代码返回 ["3" ， "12"]。

ds.REMOVE("12" + ds.VM() + "12" + ds.VM())

右侧

返回字符串中最右侧的 n 个字符。

语法

ds.Right(string (string) number (int32))

返回：字符串中最右侧的 n 个字符。

示例

如果 mylink.mystring1 包含字符串 "巧克力滴，巧克力冰淇淋，巧克力棒，巧克力营养师" ，那么以下函数将返回字符串 "dippers"。

ds.Right(mylink.mystring1,7)

soundex

返回一个代码，该代码根据 SOUNDEX 求值的标准开放式算法来标识一组 (大致) 发音相似的词。

语法

ds.Soundex(string (string))

返回：用于标识一组发音相似的单词的代码。

示例

如果 mylink.mystring1 包含字符串 "Griffin" ，那么以下函数将返回代码 "G615"。

ds.Soundex(mylink.mystring1)

如果 mylink.mystring1 包含字符串 "Griphin" ，那么以下函数还会返回代码 "G615"。

ds.Soundex(mylink.mystring1)

空格

返回包含 n 个空格字符的字符串。

语法

ds.Space(length (int32))

返回：包含指定长度的空格的字符串。

示例

如果 mylink.mylength 包含数字 100，那么以下函数将返回一个包含 100 个空格的字符串。

ds.Space(mylink.mylength)

SQuote

将字符串用单引号括起来。

语法

ds.SQuote(string (string))

返回：用单引号括起的字符串。

示例

如果 mylink.mystring1 包含字符串需要引号，那么以下函数将返回字符串 "需要引号"。

ds.SQuote(mylink.mystring1)

Str

将字符串重复指定的次数。

语法

ds.Str(string (string), repeats (int32))

返回：重复了 n 次的字符串结果。

示例

如果 mylink.mystring1 包含字符串需要 "choc" ，那么以下函数将返回字符串 "巧克力巧克力巧克力"。

ds.Str(mylink.mystring1,5)

StripWhiteSpace

在除去字符串中的所有空格字符后返回该字符串。

语法

ds.StripWhiteSpace(string (string))

返回：不含空格的字符串。

示例

如果 mylink.mystring 包含字符串 "太多空格" ，那么以下函数将返回字符串 "toomanyspaces":

ds.StripWhiteSpace(mylink.mystring)

子串

返回指定的子串。

指定 n 时，该函数将获取字符串的最后 n 个字符。

当指定了 start 和 length 时，函数将从字符串的 start 位置开始获取长度等于 length 的字符。

指定 定界符 时，该函数将获取一个或多个位于字符串中指定定界符之间的子串。 occu 是定界符数， num 是生成的子串中定界符之间的子串长度。

语法

ds.Substring(string (string), n (int8))
ds.Substring(string (string), start (int8), length (int8))
ds.Substring(string (string), delimiter (string), occu (int8), num (int8))

返回: 生成的格式字符串的子串数组。

示例

以下代码返回 "ab.cd"。

ds.Substring("ab.cd", ".", 1, 2)

子串

创建一个动态数组，其中所有元素都是输入动态数组的相应元素的子串。

语法

ds.Substrings(str (string), start (int8), length (int8))

返回: 生成的具有与输入数组对应的子串的字符串格式的动态数组。

示例

以下代码将返回 "NESýITHþ23üý50ü"。

ds.Substrings("JONESýSMITHþ1.23ü20ý2.50ü10", 3, 20)

删除

除去所有前导空格、结尾空格和制表符。此函数还会将空格或制表符的内部出现至少至一个。

参数 stripchar 指定除空格或跳格之外的字符（可选）。自变量 options 指定要执行的修剪操作的类型，并包含以下一个或多个值:

A：移除所有出现的 stripchar。
B：移除出现的前导和尾随 stripchar。
D：移除前导、尾随和多余的空格字符。
E：移除尾随空格字符。
F：移除前导空格字符。
L：移除所有出现的前导 stripchar。
R：移除出现的前导、尾随和多余的 stripchar。
T：移除所有出现的尾随 stripchar。

语法

ds.Trim(string (string), [stripchar (string)], [options (string)])

返回：修剪后的字符串。

示例

如果 mylink.mystring 包含字符串 " 具有空格的字符串 "，然后以下函数返回字符串" 具有空格的字符串 ":

ds.Trim(mylink.mystring)

如果 mylink.mystring 包含字符串 " ..除去 .. 冗余 .. 点 .... " ，那么以下函数将返回字符串 "Remove.redundant.dots":

ds.Trim(mylink.mystring,".")

如果 mylink.mystring 包含字符串 "Remove .. all.. dots...." ，那么以下函数将返回字符串 "Removealldot":

ds.Trim(mylink.mystring,".","A")

如果 mylink.mystring 包含字符串 "Remove .. trailing.. dots...." ，然后，以下函数返回字符串 "Remove .. trailing.. dot":

ds.Trim(mylink.mystring,".","T")

TrimB

除去字符串中所有结尾空格和制表符。

语法

ds.TrimB(string (string))

返回：修剪后的字符串。

示例

如果 mylink.mystring 包含字符串 "尾随空格过多" ，那么以下函数将返回字符串 "尾随空格过多":

ds.TrimB(mylink.mystring)

TrimF

除去字符串中所有前导空格和制表符。

语法

ds.TrimF(string (string))

返回：修剪后的字符串。

示例

如果 mylink.mystring 包含字符串 " 过多前导空格 "，那么以下函数将返回字符串" 过多前导空格 ":

ds.TrimF(mylink.mystring)

TrimLeadingTrailing

除去字符串中所有前导空格、结尾空格和制表符。

语法

ds.TrimLeadingTrailing(string (string))

返回：修剪后的字符串。

示例

如果 mylink.mystring 包含字符串 " 太多空格 "，那么以下函数返回字符串" 太多空格 ":

ds.TrimLeadingTrailing(mylink.mystring)

UpCase

将字符串中的所有小写字母转换为大写字母。

语法

ds.UpCase(string (string))

返回: 生成的字符串 (全大写)。

示例

如果 mylink.mystring1 包含字符串 "CaMel cAsE", ，那么下面的函数将返回字符串 "CAMEL CASE "：

ds.UpCase(mylink.mystring1)

IM

返回 CHAR (255)。工作方式与 AM 相同。

语法

ds.IM()

返回: 生成的 CHAR (255)。

示例

以下代码将返回 "维尔"。

ds.IM()

FM

返回 CHAR (254)。

语法

ds.FM()

返回: 生成的 CHAR (254)。

示例

以下代码返回 "守则"。

ds.FM()

上午

返回 CHAR (254)。工作方式与 FM 相同。

语法

ds.AM()

返回: 生成的 CHAR (254)。

示例

以下代码返回 "守则"。

ds.AM()

虚拟机

返回 CHAR (253)。

语法

ds.VM()

返回: 生成的 CHAR (253)。

示例

以下代码返回 "ý"。

ds.VM()

SM

返回 CHAR (252)。工作方式与 SVM 相同。

语法

ds.SM()

返回: 生成的 CHAR (252)。

示例

以下代码返回 "ü"。

ds.SM()

SVM

返回 CHAR (252)。工作方式与 SM 相同。

语法

ds.SVM()

返回: 生成的 CHAR (252)。

示例

以下代码返回 "ü"。

ds.SVM()

TM

返回 CHAR (251)。

语法

ds.TM()

返回: 生成的 CHAR (251)。

示例

以下代码返回 "a"。

ds.TM()

实用程序函数

实用程序函数指定与检索有关特定 DataStage 函数的信息相关的各种用途。

ElementAt

返回由索引指定的列表中的元素。

语法

ds.ElementAt(list (object))

返回: 格式对象的元素索引。

示例

以下代码返回 "b":

ds.ElementAt(["a","b","c"], 1)

以下代码返回 2:

ds.ElementAt([1,2,3], 1)

GetCommandName

获取 "运行 Bash 脚本活动" 的节点标识，并检索 Run bash 脚本活动的命令名。

语法

ds.GetCommandName(tasks.activity_id (string))

返回: 格式字符串的命令名。

示例

以下代码返回任务 run_bash_script_5的命令名:

ds.GetCommandName(tasks.run_bash_script_5)

GetCommandOutput

获取 "运行 Bash 脚本活动" 的节点标识，并检索其标准输出。它相当于 CEL 表达式:

tasks.<activity_id>.results.standard_output

语法

ds.GetCommandOutput(tasks.activity_id (string))

返回: 格式字符串的标准输出。

示例

以下代码返回任务 run_bash_script_5的标准输出:

ds.GetCommandOutput(tasks.run_bash_script_5)

GetErrorMessage

仅在异常处理程序中的任务中使用，输出是在发生异常时记录为警告的消息文本。

语法

ds.GetErrorMessage()

返回: 生成的格式字符串的消息。

示例

以下代码返回失败任务的错误消息:

ds.GetErrorMessage()

GetErrorNumber

仅在异常处理程序中的任务中使用，输出为整数，指示启动的错误类型。 1 或 -1。

1 指示任务运行了已取消的作业，并且未设置任何特定处理程序。

-1 表示任务因其他原因运行失败。

语法

ds.GetErrorNumber()

返回: 生成格式为 int 的整数。

示例

以下代码返回异常处理程序活动类型的错误号:

ds.GetErrorNumber()

GetErrorSource

仅在异常处理程序中的任务中使用，输出是引发异常的活动阶段的阶段名称。

语法

ds.GetErrorSource()

返回: 格式字符串的任务的结果值。

示例

以下代码返回失败的任务:

ds.GetErrorSource()

GetJobName

返回运行函数时 "运行 DataStage " 活动的作业名。它相当于 CEL 表达式:

tasks.<activity_id>.results.job_name

语法

ds.GetJobName(tasks.activity_id (string))

返回: 格式字符串的作业名。

示例

以下代码返回任务 run_datastage_flow_1的作业名:

ds.GetJobName(tasks.run_datastage_flow_1)

GetJobStatus

获取 "运行 DataStage 活动" 的节点标识，并检索其 <activity_name>.$JobStatus的作业状态。它相当于以下包裹表达式:

((tasks.<activity_id>.results.status == 'Completed') ? 1 : ((tasks.<activity_id>.results.status == 'CompletedWithWarnings') ? 2 : ((tasks.<activity_id>.results.status == 'Cancelled') ? 96 : 3)))

语法

ds.GetJobStatus(tasks.activity_id (string))

返回: 格式为 int 的作业状态。

示例

以下代码返回任务 run_datastage_flow_1的状态:

ds.GetJobStatus(tasks.run_datastage_flow_1)

GetListCounter

仅在具有列表计数器的循环中在任务中使用，输出是计数器变量的当前值。

语法

ds.GetListCounter()

返回: 格式字符串计数器的结果值。

示例

以下代码返回循环的当前值。

ds.GetListCounter()

GetNumericCounter

仅在具有数字计数器的循环中的任务中使用，输出是循环的计数器变量的当前值。

语法

ds.GetNumericCounter()

返回: 格式为 int 的计数器的结果值。

示例

以下代码返回循环的当前值。

ds.GetNumericCounter()

GetOutputArg

从类型为字符串的 JSON 输入返回键的指定值。

语法

ds.GetOutputArg(JSON (string), key_value (string))

返回: 属性字段的值。

示例

以下代码返回字符串值 "tom":

ds.GetOutputArg("{"name":"tom"}", "name")

GetReturnValue

获取 "运行 Bash 脚本活动" 的节点标识，并返回 "运行 Bash 脚本" 活动的值。它相当于以下 CEL 表达式:

tasks.<activity_id>.results.return_value

语法

ds.GetReturnValue(tasks.activity_id (string))

返回: 格式为 int 的任务的结果值。

示例

以下代码返回任务 tasks.run_bash_script_5的值:

ds.GetReturnValue(tasks.run_bash_script_5)

GetUserStatus

获取 DataStage 流任务的标识，并返回序列作业中 DataStage 流任务的状态。如果在并行作业中运行，那么该函数不起作用。它相当于 CEL 表达式:

tasks.<activity_id>.results.user_status

语法

ds.GetUserStatus(tasks.run_datastage_id (string))

返回: 格式字符串的 DataStage 流任务标识的状态。

示例

以下代码返回任务标识 run_datastage_5的值:

ds.GetUserStatus(tasks.run_datastage_5)

LogName

返回当前用户的登录名。

语法

ds.LogName()

返回: 格式字符串的当前用户的登录名。

示例

以下代码返回当前用户的登录名。

ds.LogName()

路径

返回当前用户的路径名。

语法

ds.Path()

返回: 格式字符串的当前用户的路径名。

示例

以下代码返回当前用户的路径名。

ds.Path()

模式

返回当前用户的模式名称。

语法

ds.Schema()

返回: 格式字符串的当前用户的模式名称。

示例

以下代码返回当前用户的模式名称。

ds.Schema()

UserNo

返回当前用户的用户编号。

语法

ds.UserNo()

返回: 格式为 int 的当前用户的用户信息。

示例

以下代码返回当前用户的用户编号。

ds.UserNo()

谁

返回当前用户。

语法

ds.Who()

返回: 格式字符串的当前用户。

示例

以下代码返回当前用户。

ds.Who()

空处理函数

执行空处理的函数。

IsNull

当输入表达式求值为空值时，返回 true。

语法

ds.IsNull(input (any))

返回: 表达式是否求值为 null (格式为 Boolean) 的结果。

示例

以下代码返回 true。

ds.IsNull(null)

以下代码返回 false。

ds.IsNull(0)

IsNotNull

当输入表达式未求值为空值时，返回 true。

语法

ds.IsNotNull(input (any))

返回: 表达式是否求值为 null (格式为 Boolean) 的结果。

示例

以下代码返回 false。

ds.IsNotNull(null)

以下代码返回 true。

ds.IsNotNull(0)

Null

返回空值。

语法

ds.Null()

返回: 空值。

示例

以下代码返回 null。

ds.Null()

NullToEmpty

如果输入为空，那么返回空字符串，否则返回输入列值。

语法

ds.NullToEmpty(input (any))

返回: 空字符串或输入值。

示例

以下代码返回 "AA"。

ds.NullToEmpty("AA")

以下代码返回 ""。

ds.NullToEmpty(null)

NullStr

返回空字符串 CHAR (128)。

语法

ds.NullStr()

返回: 空字符串 CHAR (128)。

示例

以下代码返回 €。

ds.NullStr()

NullToValue

如果输入为空，那么返回指定的值，否则返回输入列值。

语法

ds.NullToValue(input (any), default (any))

返回: 指定的值或输入值。

示例

以下代码返回 "test"。

ds.NullToValue("test", "default")

以下代码返回 "default"。

ds.NullToValue(null, "default")

以下代码返回 1。

ds.NullToValue(null, 1)

NullToZero

如果输入为空，那么返回 0 ，否则返回输入列值。

语法

ds.NullToZero(input (any))

返回: 0 或输入值。

示例

以下代码返回 88。

ds.NullToZero(88)

以下代码返回 0。

ds.NullToZero(null)

SetNull

将 Null 值赋给目标列。

语法

ds.SetNull()

返回: 将目标设置为空值。

示例

以下代码返回 null。

ds.SetNull()

变换日期函数

用于从日期查询返回已变换数据的函数。

内部日期和时间

内部日期是基于参考日期 1967 年 12 月 31 日的天数。
内部时间是自午夜以来经过到最接近的千分之一秒 (本地时间) 的秒数。

DateTag

将数字内部日期转换为 DATE.TAG 格式 YYYY-MM-DD的字符串。

语法

ds.DateTag(date (string))

返回: 类型为 dateTag (int64) 的 DATE.TAG format YYYY-MM-DD 。

示例

以下代码返回值 1993-02-14。

ds.DateTag(9177)

MonthFirst

返回一个月中第一天的内部日期表示。

语法

ds.MonthFirst(monthTag (string))

返回: 类型为 date (int64) 的第一天的内部日期表示。

示例

以下代码返回值 9164 ，即 1993 年 2 月 1 的内部表示。

ds.MonthFirst("1993-02")

MonthLast

返回一个月中最后一天的内部日期表示。

语法

ds.MonthLast(monthTag (string))

返回: 日期类型 (int64) 的最后一天的内部日期表示。

示例

以下代码返回值 9191 ，即 1993 年 2 月 28 日的内部表示。

ds.MonthLast("1993-02")

MonthTag

将数字内部日期转换为 MONTH.TAG 格式 YYYY-MM的字符串。

语法

ds.MonthTag(date (int64))

返回: 类型为 monthTag (字符串) 的 MONTH.TAG format YYYY-MM 。

示例

以下代码返回值 "1993-02"。

ds.MonthTag(9177)

MonthToQuarter

将 MONTH.TAG format YYYY-MM 中的字符串转换为 QUARTER.TAG format YYYYQn。

语法

ds.MonthToQuarter(monthTag (string))

返回: 类型为 quarterTag (字符串) 的 QUARTER.TAG format YYYYQn 。

示例

下面的代码会返回值 "1993Q1"。

ds.MonthToQuarter(9177)

MonthToYear

将 MONTH.TAG format YYYY-MM 中的字符串转换为 YEAR.TAG format YYYY。

语法

ds.MonthToYear(monthTag (string))

返回: 类型为 uearTag (字符串) 的 YEAR.TAG format YYYY 。

示例

以下代码返回值 "1993"。

ds.MonthToYear("1993-02")

QuarterFirst

返回对应于季度第一天的数字内部日期。

语法

ds.QuarterFirst(quarterTag (string))

返回: 类型为日期 (int64) 的季度中第一天的内部日期表示。

示例

以下代码返回值 9133。 9133 是 1993 年 1 月 1 的内部表示。

ds.QuarterFirst("1993Q1")

QuarterLast

返回对应于季度的最后一天的数字内部日期。

语法

ds.QuarterLast(quarterTag (string))

返回: 类型为日期 (int64) 的季度中最后一天的内部日期表示。

示例

以下代码返回值 9222。 9222 是 1993 年 3 月 31 日的内部代表。

ds.QuarterLast("1993Q1")

QuarterTag

将数字内部日期转换为 QUARTER.TAG 格式 YYYYQn的字符串。

语法

ds.QuarterTag(date (int64))

返回: 表示 QUARTER.TAG 格式的内部日期的字符串。

示例

下面的代码会返回值 "1993Q1"。

ds.QuarterTag(9222)

QuarterToYear

将 QUARTER.TAG format YYYYQn 中的字符串转换为 YEAR.TAG format YYYY。

语法

ds.QuarterToYear(quarterTag (string))

返回: 表示类型为 yearTag (字符串) 的季度的年份的字符串。

示例

以下代码返回值 "1993"。

ds.QuarterToYear("1993Q2")

TimeStamp

将数字内部日期转换为 TIMESTAMP 格式 YYYY-MM-DD HH:MM:SS的字符串。

语法

ds.TimeStamp(date (int64))

返回: 字符串类型的输入内部日期的时间戳记。

示例

以下代码返回值 "1996-12-05 00:00:00"。 10567 是 1996 年 12 月 5 的内部表示。

ds.TimeStamp("10567")

TimeStampToDate

将 TIMESTAMP format YYYY-MM-DD HH:MM:SS 转换为数字内部日期。

语法

ds.TimeStampToDate(timestamp (string))

返回: 给定时间戳记的内部日期表示。

示例

以下代码返回值 10567。 10567 是 1996 年 12 月 5 的内部表示。

ds.TimeStampToDate("1996-12-05 13:46:21")

TimeStampToTime

将 TIMESTAMP format YYYY-MM-DD HH:MM:SS 转换为数字内部时间。内部时间是自午夜以来的秒数。

语法

ds.TimeStampToTime(timestamp (string))

返回: 时间类型的转换时间 (int64)。

示例

以下代码返回值 49581。 49581 是从午夜到时间 13:46:21 的秒数。

ds.TimeStampToTime("1996-12-05 13:46:21")

TagToDate

将 DATE.TAG format YYYY-MM-DD 中的字符串转换为数字内部日期。

语法

ds.TagToDate(dateTag (string))

返回: 类型为 int64的转换日期。

示例

以下代码返回值 9177。 9171 是 1993 年 2 月 14 日的内部代表。

ds.TagToDate("1993-02-14")

TagToMonth

将 DATE.TAG format YYYY-MM-DD 中的字符串转换为 MONTH.TAG format YYYY-MM。

语法

ds.TagToMonth(dateTag (string))

返回: 类型为 monthTag (字符串) 的 dateTag 的月份。

示例

以下代码返回值 "1993-02"。

ds.TagToMonth("1993-02-14")

TagToQuarter

将 DATE.TAG format YYYY-MM-DD 中的字符串转换为 QUARTER.TAG format YYYYQn。

语法

ds.TagToQuarter(dateTag (string))

返回: 类型为 quarterTag (字符串) 的 dateTag 的季度。

示例

下面的代码会返回值 "1993Q1"。

ds.TagToQuarter("1993-02-14")

TagToWeek

将 DATE.TAG format YYYY-MM-DD 中的字符串转换为 WEEK.TAG format YYYYWnn。

语法

ds.TagToWeek(dateTag (string))

返回: 类型为 weekTag (字符串) 的 dateTag 的周。

示例

下面的代码会返回值 "1993W06"。

ds.TagToWeek("1993-02-14")

TagToYear

将 DATE.TAG format YYYY-MM-DD 中的字符串转换为 YEAR.TAG format YYYY。

语法

ds.TagToYear(dateTag (string))

返回: 类型为 yearTag (字符串) 的 dateTag 的年份。

示例

以下代码返回值 "1993"。

ds.TagToYear("1993-02-14")

WeekFirst

返回对应于一周中的星期一的数字内部日期。

语法

ds.WeekFirst(weekTag (string))

返回: 类型为日期 (int64) 的一周的第一天的日期。

示例

以下代码返回值 9171。 9171 是 1993 年 2 月 8 的内部表示。

ds.WeekFirst("1993W06")

WeekLast

返回对应于星期天的数字内部日期。

语法

ds.WeekLast(weekTag (string))

返回: 类型为日期 (int64) 的周的最后一天的日期。

示例

以下代码返回值 9177。 9171 是 1993 年 2 月 14 日的内部代表。

ds.WeekLast("1993W06")

WeekTag

将数字内部日期转换为 WEEK.TAG 格式 YYYYWnn的字符串。

语法

ds.WeekTag(date (int64))

返回: 类型为 weekTag (字符串) 的日期的周。

示例

下面的代码会返回值 "1993W06"。

ds.WeekTag(9177)

YearFirst

返回一个数字内部日期，对应于以 YEAR.TAG format YYYY给出的一年中的第一天。

语法

ds.YearFirst(yearTag (string))

返回: 类型为日期 (int64) 的给定年份中第一天的日期。

示例

以下代码返回值 9133。 9133 是 1993 年 1 月 1 的内部表示。

ds.YearFirst("1993")

YearLast

返回一个数字内部日期，对应于以 YEAR.TAG format YYYY给出的一年中的第一天。

语法

ds.YearLast(yearTag (string))

返回: 类型为日期 (int64) 的给定年份中第一天的日期。

示例

以下代码返回值 9133。 9133 是 1993 年 1 月 1 的内部表示。

ds.YearLast("1993")

YearTag

将数字内部日期转换为 YEAR.TAG 格式 YYYY的字符串。

语法

ds.YearTag(date (int64))

返回: 类型为 yearTag (字符串) 的日期的转换年份。

示例

以下代码返回值 "1993"。

ds.YearTag(9177)

变换字符串函数

对字符串输入执行变换的函数。

首都

使字符串输入中每个单词的第一个字符大写。空格之间的任何字符序列都以单词形式有效。

语法

ds.Capitals(input (string))

返回: 生成字符串类型的字符串输入的大写输出。

示例

以下代码返回 "星期一二月 14th"。

ds.Capitals("monday feb 14th")

数字

返回除数字 0-9 之外的所有字符的字符串输入。

语法

ds.Digits(input (string))

返回: 已除去类型为字符串的所有非数字字符的结果字符串。

示例

以下代码返回 "123456"。

ds.Digits("123abc456")

字母

返回除字母数字字符之外的所有字符的字符串输入。

语法

ds.Letters()

返回: 已除去类型为字符串的所有非字母数字字符的结果字符串。

示例

以下代码返回 "abc"。

ds.Letters("123abc456")

StringIsSpace

如果字符串由一个或多个空格组成，那么返回 "1" 的二进制函数，否则返回 "0"。

语法

ds.StringIsSpace(input (string))

如果字符串由一个或多个空格组成，那么返回 "1" ，否则返回 "0"。

示例

以下代码返回 "1"。

ds.StringIsSpace(" ")

StringLeftJust

从输入字符串中除去前导空格。

语法

ds.StringLeftJust(input (string))

示例

以下代码返回 "abc"。

ds.StringLeftJust(" abc ")

StringRightJust

从输入中除去尾部空格。

语法

ds.StringRightJust(input (string))

返回: 除去了尾部空格的结果字符串。

示例

以下代码返回 " Abc "。

ds.StringRightJust(" abc ")

StringUpperFirst

使字符串输入中每个单词的第一个字符大写。空格之间的任何字符序列都以单词形式有效。

语法

ds.StringUpperFirst(input (string))

返回: 生成字符串类型的字符串输入的大写输出。

示例

以下代码返回 "星期一二月 14th"。

ds.StringUpperFirst("monday feb 14th")

StringDecode

采用键名和数组作为自变量。数组包含键/值对。该函数在数组中搜索键并返回相应的值。

语法

ds.StringDecode(input (string))

返回: 字符串类型的结果值。

示例

以下代码返回 "1"。

ds.StringDecode("A", "A=1|B=2|CD=3")

例程转换函数

执行各种转换的函数。

ConvertMonth

将 MONTH.TAG 作为输入并对其进行变换。应用的变换取决于第二个自变量。

如果第二个自变量是:

F: 返回格式为 DATE.TAG的月份的第一天。
L: 返回格式为 DATE.TAG的月份的最后一天。
Q: 返回格式为 QUARTER.TAG的月份的季度。
Y: 返回格式为 YEAR.TAG的月份的年份。

语法

ds.ConvertMonth(monthTag (string), type (string))

返回: 对应格式的月份的第一天，最后一天，季度或年份。

示例

以下代码返回 9164。

ds.ConvertMonth("1993-02", "F")

ConvertQuarter

将 MONTH.TAG 作为输入并对其进行变换。应用的变换取决于第二个自变量。

如果第二个自变量是:

F: 返回格式为 DATE.TAG的季度的第一天。
L: 返回格式为 DATE.TAG的季度的最后一天。
Y: 返回格式为 YEAR.TAG的季度的年份。

语法

ds.ConvertQuarter(quarterTag (string), type (string))

返回: 对应格式的月份的第一天，最后一天或年份。

示例

以下代码返回 91。

ds.ConvertQuarter("1968Q1", "L")

ConvertTag

将 DATE.TAG 作为输入并对其进行变换。应用的变换取决于第二个自变量。

如果第二个自变量是:

I: 返回类型为 date (int) 的内部日期。
W: 返回格式为 WEEK.TAG的日期的周。
M: 返回格式为 MONTH.TAG的日期的月份。
Q: 返回格式为 QUARTER.TAG的日期的季度。
Y: 返回格式为 YEAR.TAG的日期的年份。

语法

ds.ConvertTag(dateTag (string), type (string))

返回: 相应格式的内部日期，周，月，季度或月的年份。

示例

以下代码返回 "1968W26"。

ds.ConvertTag("1968-06-30", "W")

ConvertWeek

将 WEEK.TAG 作为输入，并将其转换为对应于一周中特定日期的内部日期。应用的变换取决于第二个自变量。

如果第二个自变量是:

0: 返回一周中的星期一的日期。
1: 返回一周中的星期二的日期。
2: 返回周中的星期三的日期。
3: 返回一周中的星期四的日期。
4: 返回一周中的星期五的日期。
5: 返回一周中的星期六的日期。
6: 返回星期天的日期。

语法

ds.ConvertWeek(weekTag (string), type (int))

返回: 生成的内部日期 (类型为 int 的星期几)。

示例

以下代码返回 182。

ds.ConvertWeek("1968W26", 6)

ConvertYear

将 YEAR.TAG 作为输入并对其进行变换。应用的变换取决于第二个自变量。

如果第二个自变量是:

F: 返回格式为 DATE.TAG的年份的第一天。
L: 返回格式为 DATE.TAG的年份的最后一天。

语法

ds.ConvertYear(yearTag (string), type (string))

返回: 对应格式的月份的第一天，最后一天或年份。

示例

以下代码返回 366。

ds.ConvertYear("1968", "L")

宏函数

用于处理与 DataStage 序列作业相关的一组项目元数据的检索的函数。

JobName

返回顺序器作业名。

语法

ds.JobName

返回: 格式字符串的排序器作业名。

示例

以下代码返回定序器作业名。

ds.JobName

JobStartDate

返回定序器作业开始日期。

语法

ds.JobStartDate

返回: 格式字符串的排序器作业开始日期。

示例

以下代码返回定序器作业开始日期。

ds.JobStartDate

JobStartTime

返回定序器作业开始时间。

语法

ds.JobStartTime

返回: 格式字符串的定序器作业开始时间。

示例

以下代码返回定序器作业开始时间。

ds.JobStartTime

JobStartTimestamp

返回排序器作业开始时间戳记。

语法

ds.JobStartTimestamp

返回: 格式时间戳记的排序器作业开始时间戳记。

示例

以下代码返回定序器作业开始时间戳记。

ds.JobStartTimestamp

HostName

返回 DataStage 服务器的主机名。

语法

ds.HostName

返回: 格式字符串的排序器作业 InvocationId 。

示例

以下代码返回定序器作业 InvocationId。

ds.HostName

ProjectName

返回正在运行的定序器作业的项目名称

语法

ds.ProjectName

返回: 正在运行的定序器作业的项目名称。

示例

以下代码返回正在运行的定序器作业的项目名称。

ds.ProjectName

ProjectId

返回正在运行的定序器作业的项目标识。

语法

ds.ProjectId

返回: 正在运行的定序器作业的项目标识。

示例

以下代码返回正在运行的定序器作业的项目标识。

ds.ProjectId

JobId

返回正在运行的定序器作业的作业标识。

语法

ds.JobId

返回: 正在运行的定序器作业的作业标识。

示例

以下命令返回正在运行的定序器作业的作业标识。

ds.JobId

JobController

返回正在运行的定序器作业的管道流名称。

语法

ds.JobController

返回: 正在运行的定序器作业的管道流名称。

示例

以下命令返回正在运行的定序器作业的管道流名称。

ds.JobController

父主题: 向管道添加条件