« EQL syntax reference EQL pipe reference »
Elastic Docs ›Elasticsearch Guide ›EQL search

EQL 函数参考

edit

EQL 函数参考

edit

Elasticsearch 支持以下 EQL 函数。

添加

edit

返回两个提供的加数的和。

示例

add(4, 5)                                           // returns 9
add(4, 0.5)                                         // returns 4.5
add(0.5, 0.25)                                      // returns 0.75
add(4, -2)                                          // returns 2
add(-2, -2)                                         // returns -4

// process.args_count = 4
add(process.args_count, 5)                          // returns 9
add(process.args_count, 0.5)                        // returns 4.5

// process.parent.args_count = 2
add(process.args_count, process.parent.args_count)  // returns 6

// null handling
add(null, 4)                                        // returns null
add(4. null)                                        // returns null
add(null, process.args_count)                       // returns null
add(process.args_count null)                        // returns null

语法

add(<addend>, <addend>)

参数:

<addend>

(必需的, 整数或浮点数或 null) 要添加的加数。如果为 null, 函数返回 null。

需要两个加数。最多只能提供两个加数。

如果使用字段作为参数，此参数仅支持 numeric 字段数据类型。

返回值: 整数, 浮点数, 或 null

between

edit

提取源字符串中位于提供的 left 和 right 文本之间的子字符串。默认情况下，匹配是区分大小写的。

示例

// file.path = "C:\\Windows\\System32\\cmd.exe"
between(file.path, "System32\\\\", ".exe")                // returns "cmd"
between(file.path, "system32\\\\", ".exe")                // returns ""
between(file.path, "workspace\\\\", ".exe")               // returns ""

// Make matching case-insensitive
between~(file.path, "system32\\\\", ".exe")               // returns "cmd"

// Greedy matching defaults to false.
between(file.path, "\\\\", "\\\\", false)                 // returns "Windows"

// Sets greedy matching to true
between(file.path, "\\\\", "\\\\", true)                  // returns "Windows\\System32"

// empty source string
between("", "System32\\\\", ".exe")                       // returns ""
between("", "", "")                                       // returns ""

// null handling
between(null, "System32\\\\", ".exe")                     // returns null

语法

between(<source>, <left>, <right>[, <greedy_matching>])

参数

<source>

(必需，字符串或null) 源字符串。空字符串返回空字符串("")，无论或参数如何。如果为null，函数返回null。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

<left>

(必需，字符串) 要提取的子字符串左侧的文本。此文本应包含空格。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

<right>

(必需，字符串) 要提取的子字符串右侧的文本。此文本应包含空格。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

<greedy_matching>
(可选, 布尔值) 如果为true，匹配最长的可能子串，类似于正则表达式中的.*。如果为false，匹配最短的可能子串，类似于正则表达式中的.*?。默认为false。

返回值: 字符串或null

cidrMatch

edit

如果一个IP地址包含在一个或多个提供的CIDR块中，则返回true。

示例

// source.address = "192.168.152.12"
cidrMatch(source.address, "192.168.0.0/16")               // returns true
cidrMatch(source.address, "192.168.0.0/16", "10.0.0.0/8") // returns true
cidrMatch(source.address, "10.0.0.0/8")                   // returns false
cidrMatch(source.address, "10.0.0.0/8", "10.128.0.0/9")   // returns false

// null handling
cidrMatch(null, "10.0.0.0/8")                             // returns null
cidrMatch(source.address, null)                           // returns null

语法

`cidrMatch(<ip_address>, <cidr_block>[, ...])`

参数

<ip_address>

(必需，字符串或 null) IP地址。支持 IPv4 和 IPv6 地址。如果为 null，函数返回 null。

如果使用字段作为参数，此参数仅支持 ip 字段数据类型。

<cidr_block>
(必需†[1], 字符串或null) 您希望搜索的CIDR块。如果为null，函数返回null。

返回值: 布尔值或null

concat

edit

返回提供的值的连接字符串。

示例

concat("process is ", "regsvr32.exe")         // returns "process is regsvr32.exe"
concat("regsvr32.exe", " ", 42)               // returns "regsvr32.exe 42"
concat("regsvr32.exe", " ", 42.5)             // returns "regsvr32.exe 42.5"
concat("regsvr32.exe", " ", true)             // returns "regsvr32.exe true"
concat("regsvr32.exe")                        // returns "regsvr32.exe"

// process.name = "regsvr32.exe"
concat(process.name, " ", 42)                 // returns "regsvr32.exe 42"
concat(process.name, " ", 42.5)               // returns "regsvr32.exe 42.5"
concat("process is ", process.name)           // returns "process is regsvr32.exe"
concat(process.name, " ", true)               // returns "regsvr32.exe true"
concat(process.name)                          // returns "regsvr32.exe"

// process.arg_count = 4
concat(process.name, " ", process.arg_count)  // returns "regsvr32.exe 4"

// null handling
concat(null, "regsvr32.exe")                  // returns null
concat(process.name, null)                    // returns null
concat(null)                                  // returns null

语法

concat(<value>[, <value>])

参数

<value>

(必需†[1]) 要连接的值。如果任何参数为 null，函数返回 null。

如果使用字段作为参数，此参数不支持 text 字段数据类型。

返回值: 字符串或null

divide

edit

返回提供的被除数和除数的商。

如果被除数和除数都是整数，divide 函数会将返回的任何浮点数 向下取整 到最接近的整数。为了避免取整，请将除数或被除数转换为浮点数。

示例

字段 process.args_count 是一个包含进程参数计数的 long 整数字段。

用户可能期望以下EQL查询仅匹配具有process.args_count值为4的事件。

process where divide(4, process.args_count) == 1

然而，EQL 查询匹配事件的 process.args_count 值为 3 或 4。

对于具有 process.args_count 值为 3 的事件，divide 函数返回一个浮点数 1.333...，该数被向下舍入为 1。

要匹配仅具有 process.args_count 值为 4 的事件，请将除数或被除数转换为浮点数。

以下EQL查询将整数4转换为等效的浮点数4.0。

process where divide(4.0, process.args_count) == 1

示例

divide(4, 2)                                            // returns 2
divide(4, 3)                                            // returns 1
divide(4, 3.0)                                          // returns 1.333...
divide(4, 0.5)                                          // returns 8
divide(0.5, 4)                                          // returns 0.125
divide(0.5, 0.25)                                       // returns 2.0
divide(4, -2)                                           // returns -2
divide(-4, -2)                                          // returns 2

// process.args_count = 4
divide(process.args_count, 2)                           // returns 2
divide(process.args_count, 3)                           // returns 1
divide(process.args_count, 3.0)                         // returns 1.333...
divide(12, process.args_count)                          // returns 3
divide(process.args_count, 0.5)                         // returns 8
divide(0.5, process.args_count)                         // returns 0.125

// process.parent.args_count = 2
divide(process.args_count, process.parent.args_count)   // returns 2

// null handling
divide(null, 4)                                         // returns null
divide(4, null)                                         // returns null
divide(null, process.args_count)                        // returns null
divide(process.args_count, null)                        // returns null

语法

divide(<dividend>, <divisor>)

参数

<dividend>

(必需的, 整数或浮点数或 null) 被除数。如果为 null, 函数返回 null。

如果使用字段作为参数，此参数仅支持 numeric 字段数据类型。

<divisor>

(必需的，整数或浮点数或 null) 除数。如果为 null，函数返回 null。此值不能为零 (0)。

如果使用字段作为参数，此参数仅支持 numeric 字段数据类型。

返回值: 整数, 浮点数, 或 null

以...结尾

edit

如果源字符串以提供的子字符串结尾，则返回 true。默认情况下，匹配是区分大小写的。

示例

endsWith("regsvr32.exe", ".exe")          // returns true
endsWith("regsvr32.exe", ".EXE")          // returns false
endsWith("regsvr32.exe", ".dll")          // returns false
endsWith("", "")                          // returns true

// Make matching case-insensitive
endsWith~("regsvr32.exe", ".EXE")         // returns true

// file.name = "regsvr32.exe"
endsWith(file.name, ".exe")               // returns true
endsWith(file.name, ".dll")               // returns false

// file.extension = ".exe"
endsWith("regsvr32.exe", file.extension)  // returns true
endsWith("ntdll.dll", file.name)          // returns false

// null handling
endsWith("regsvr32.exe", null)            // returns null
endsWith("", null)                        // returns null
endsWith(null, ".exe")                    // returns null
endsWith(null, null)                      // returns null

语法

endsWith(<source>, <substring>)

参数

<source>

(必需，字符串或null) 源字符串。如果为null，函数返回null。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

<substring>

(必需，字符串或null) 要搜索的子字符串。如果为null，函数返回null。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

返回值: 布尔值或null

indexOf

edit

返回提供的子字符串在源字符串中的第一个位置。默认情况下，匹配是区分大小写的。

如果提供了可选的起始位置，此函数将返回从起始位置开始或之后的子字符串的第一次出现。

示例

// url.domain = "subdomain.example.com"
indexOf(url.domain, "d")        // returns 3
indexOf(url.domain, "D")        // returns null
indexOf(url.domain, ".")        // returns 9
indexOf(url.domain, ".", 9)     // returns 9
indexOf(url.domain, ".", 10)    // returns 17
indexOf(url.domain, ".", -6)    // returns 9

// Make matching case-insensitive
indexOf~(url.domain, "D")        // returns 4

// empty strings
indexOf("", "")                 // returns 0
indexOf(url.domain, "")         // returns 0
indexOf(url.domain, "", 9)      // returns 9
indexOf(url.domain, "", 10)     // returns 10
indexOf(url.domain, "", -6)     // returns 0

// missing substrings
indexOf(url.domain, "z")        // returns null
indexOf(url.domain, "z", 9)     // returns null

// start position is higher than string length
indexOf(url.domain, ".", 30)    // returns null

// null handling
indexOf(null, ".", 9)           // returns null
indexOf(url.domain, null, 9)    // returns null
indexOf(url.domain, ".", null)  // returns null

语法

indexOf(<source>, <substring>[, <start_pos>])

参数

<source>

(必需，字符串或null) 源字符串。如果为null，函数返回null。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

<substring>

(必需，字符串或null) 要搜索的子字符串。

如果这个参数是 null 或者 字符串不包含这个子字符串，函数返回 null。

如果 是正数，空字符串 ("") 返回 。 否则，空字符串返回 0。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

<start_pos>

(可选，整数或null) 匹配的起始位置。函数不会返回在此位置之前的匹配项。默认为0。

位置是从零开始索引的。负偏移量被视为0。

如果这个参数是 null 或者大于 字符串的长度， 该函数返回 null。

如果使用字段作为参数，此参数仅支持以下 数值字段数据类型：

  • long
  • integer
  • short
  • byte

返回值： 整数或null

长度

edit

返回所提供字符串的字符长度，包括空白和标点符号。

示例

length("explorer.exe")         // returns 12
length("start explorer.exe")   // returns 18
length("")                     // returns 0
length(null)                   // returns null

// process.name = "regsvr32.exe"
length(process.name)           // returns 12

语法

length(<string>)

参数

<string>

(必需，字符串或null) 要返回字符长度的字符串。如果为null，函数返回null。空字符串返回0。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

返回值： 整数或null

取模

edit

返回提供的被除数和除数相除后的余数。

示例

modulo(10, 6)                                       // returns 4
modulo(10, 5)                                       // returns 0
modulo(10, 0.5)                                     // returns 0
modulo(10, -6)                                      // returns 4
modulo(-10, -6)                                     // returns -4

// process.args_count = 10
modulo(process.args_count, 6)                       // returns 4
modulo(process.args_count, 5)                       // returns 0
modulo(106, process.args_count)                     // returns 6
modulo(process.args_count, -6)                      // returns 4
modulo(process.args_count, 0.5)                     // returns 0

// process.parent.args_count = 6
modulo(process.args_count, process.parent.args_count)  // returns 4

// null handling
modulo(null, 5)                                     // returns null
modulo(7, null)                                     // returns null
modulo(null, process.args_count)                    // returns null
modulo(process.args_count, null)                    // returns null

语法

modulo(<dividend>, <divisor>)

参数

<dividend>

(必需的，整数或浮点数或 null) 被除数。如果为 null，函数返回 null。浮点数返回 0。

如果使用字段作为参数，此参数仅支持 numeric 字段数据类型。

<divisor>

(必需的，整数或浮点数或 null) 除数。如果为 null，函数返回 null。浮点数返回 0。此值不能为零 (0)。

如果使用字段作为参数，此参数仅支持 numeric 字段数据类型。

返回值: 整数, 浮点数, 或 null

multiply

edit

返回两个提供因数的乘积。

示例

multiply(2, 2)                                           // returns 4
multiply(0.5, 2)                                         // returns 1
multiply(0.25, 2)                                        // returns 0.5
multiply(-2, 2)                                          // returns -4
multiply(-2, -2)                                         // returns 4

// process.args_count = 2
multiply(process.args_count, 2)                          // returns 4
multiply(0.5, process.args_count)                        // returns 1
multiply(0.25, process.args_count)                       // returns 0.5

// process.parent.args_count = 3
multiply(process.args_count, process.parent.args_count)  // returns 6

// null handling
multiply(null, 2)                                        // returns null
multiply(2, null)                                        // returns null

语法

multiply(<factor, <factor>)

参数

<factor>

(必需，整数或浮点数或null) 乘数因子。如果为null，函数返回null。

需要两个因素。最多只能提供两个因素。

如果使用字段作为参数，此参数仅支持 numeric 字段数据类型。

返回值: 整数, 浮点数, 或 null

数字

edit

将字符串转换为相应的整数或浮点数。

示例

number("1337")              // returns 1337
number("42.5")              // returns 42.5
number("deadbeef", 16)      // returns 3735928559

// integer literals beginning with "0x" are auto-detected as hexadecimal
number("0xdeadbeef")        // returns 3735928559
number("0xdeadbeef", 16)    // returns 3735928559

// "+" and "-" are supported
number("+1337")             // returns 1337
number("-1337")             // returns -1337

// surrounding whitespace is ignored
number("  1337  ")          // returns 1337

// process.pid = "1337"
number(process.pid)         // returns 1337

// null handling
number(null)                // returns null
number(null, 16)            // returns null

// strings beginning with "0x" are treated as hexadecimal (base 16),
// even if the <base_num> is explicitly null.
number("0xdeadbeef", null) // returns 3735928559

// otherwise, strings are treated as decimal (base 10)
// if the <base_num> is explicitly null.
number("1337", null)        // returns 1337

语法

number(<string>[, <base_num>])

参数

<string>

(必需，字符串或null) 要转换为整数或浮点数的字符串。如果此值是字符串，则必须是以下之一：

  • 一个整数的字符串表示形式（例如，"42"）
  • 一个浮点数的字符串表示形式（例如，"9.5"）
  • 如果指定了参数，则包含以基数表示法表示的整数文字的字符串（例如，"0xDECAFBAD"在十六进制或基数16中）

以0x开头的字符串会被自动检测为十六进制，并使用默认的值16。

- 和 + 在没有空格的情况下是支持的。周围的空白会被忽略。空字符串 ("") 是不支持的。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

如果这个参数是 null，函数返回 null。

<base_num>

(可选，整数或null) 用于转换字符串的基数或基数。如果以0x开头， 此参数默认为16（十六进制）。否则，它默认为基数 10。

如果此参数明确为null，则使用默认值。

字段不支持作为参数。

返回值： 整数或浮点数或 null

startsWith

edit

如果源字符串以提供的子字符串开头，则返回 true。默认情况下，匹配是区分大小写的。

示例

startsWith("regsvr32.exe", "regsvr32")  // returns true
startsWith("regsvr32.exe", "Regsvr32")  // returns false
startsWith("regsvr32.exe", "explorer")  // returns false
startsWith("", "")                      // returns true

// Make matching case-insensitive
startsWith~("regsvr32.exe", "Regsvr32")  // returns true

// process.name = "regsvr32.exe"
startsWith(process.name, "regsvr32")    // returns true
startsWith(process.name, "explorer")    // returns false

// process.name = "regsvr32"
startsWith("regsvr32.exe", process.name) // returns true
startsWith("explorer.exe", process.name) // returns false

// null handling
startsWith("regsvr32.exe", null)        // returns null
startsWith("", null)                    // returns null
startsWith(null, "regsvr32")            // returns null
startsWith(null, null)                  // returns null

语法

startsWith(<source>, <substring>)

参数

<source>

(必需，字符串或null) 源字符串。如果为null，函数返回null。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

<substring>

(必需，字符串或null) 要搜索的子字符串。如果为null，函数返回null。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

返回值: 布尔值或null

字符串

edit

将一个值转换为字符串。

示例

string(42)               // returns "42"
string(42.5)             // returns "42.5"
string("regsvr32.exe")   // returns "regsvr32.exe"
string(true)             // returns "true"

// null handling
string(null)             // returns null

语法

string(<value>)

参数

<value>

(必需) 要转换为字符串的值。如果为 null，函数返回 null。

如果使用字段作为参数，此参数不支持 text 字段数据类型。

返回值: 字符串或null

stringContains

edit

如果源字符串包含提供的子字符串，则返回 true。默认情况下，匹配是区分大小写的。

示例

// process.command_line = "start regsvr32.exe"
stringContains(process.command_line, "regsvr32")  // returns true
stringContains(process.command_line, "Regsvr32")  // returns false
stringContains(process.command_line, "start ")    // returns true
stringContains(process.command_line, "explorer")  // returns false

// Make matching case-insensitive
stringContains~(process.command_line, "Regsvr32")  // returns false

// process.name = "regsvr32.exe"
stringContains(command_line, process.name)        // returns true

// empty strings
stringContains("", "")                            // returns false
stringContains(process.command_line, "")          // returns false

// null handling
stringContains(null, "regsvr32")                  // returns null
stringContains(process.command_line, null)        // returns null

语法

stringContains(<source>, <substring>)

参数

<source>
(必需，字符串或null) 要搜索的源字符串。如果为null，函数返回null。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

  • keyword 家族中的一个类型

  • text 字段带有一个 keyword 子字段

    (必需，字符串或 null) 要搜索的子字符串。如果为 null，函数返回 null。

如果使用字段作为参数，此参数仅支持以下字段数据类型：

返回值: 布尔值或null

substring

edit

从源字符串中提取指定起始和结束位置的子字符串。

如果没有提供结束位置，函数会提取剩余的字符串。

示例

substring("start regsvr32.exe", 6)        // returns "regsvr32.exe"
substring("start regsvr32.exe", 0, 5)     // returns "start"
substring("start regsvr32.exe", 6, 14)    // returns "regsvr32"
substring("start regsvr32.exe", -4)       // returns ".exe"
substring("start regsvr32.exe", -4, -1)   // returns ".ex"

语法

substring(<source>, <start_pos>[, <end_pos>])

参数

<source>
(必需, 字符串) 源字符串。
<start_pos>

(必需，整数) 提取的起始位置。

如果此位置高于 位置或 字符串的长度，函数将返回一个空字符串。

位置是从零开始索引的。支持负偏移量。

<end_pos>

(可选, 整数) 提取的独占结束位置。如果未提供此位置，函数将返回剩余的字符串。

位置是从零开始索引的。支持负偏移量。

返回值: 字符串

减法

edit

返回提供的被减数和减数之间的差值。

示例

subtract(10, 2)                                          // returns 8
subtract(10.5, 0.5)                                      // returns 10
subtract(1, 0.2)                                         // returns 0.8
subtract(-2, 4)                                          // returns -8
subtract(-2, -4)                                         // returns 8

// process.args_count = 10
subtract(process.args_count, 6)                          // returns 4
subtract(process.args_count, 5)                          // returns 5
subtract(15, process.args_count)                         // returns 5
subtract(process.args_count, 0.5)                        // returns 9.5

// process.parent.args_count = 6
subtract(process.args_count, process.parent.args_count)  // returns 4

// null handling
subtract(null, 2)                                        // returns null
subtract(2, null)                                        // returns null

语法

subtract(<minuend>, <subtrahend>)

参数

<minuend>

(必需的，整数或浮点数或 null) 被减数。

如果使用字段作为参数，此参数仅支持 numeric 字段数据类型。

<subtrahend>

(可选，整数或浮点数或null) 减数。如果为null，函数返回null。

如果使用字段作为参数，此参数仅支持 numeric 字段数据类型。

返回值: 整数, 浮点数, 或 null

[1] This parameter accepts multiple arguments.
« EQL syntax reference EQL pipe reference »