分析映射函数

映射函数映射每个 Solr 文档或归约的值。

分析组件已弃用。我们建议研究 JSON 分面 API 中提供的类似功能。如果 JSON 分面当前未涵盖您需要的功能，请通知项目。

以下是分析组件提供的所有映射函数的列表。这些映射可以链接在一起以实现更复杂的功能。

数值函数

取反

对数值表达式的结果取反。

neg(<数值_T>) ⇒ <T>

neg(10.53) ⇒ -10.53
neg([1, -4]) ⇒ [-1, 4]

绝对值

返回数值表达式的绝对值。

abs(<数值 T>) ⇒ <T>

abs(-10.53) ⇒ 10.53
abs([1, -4]) ⇒ [1, 4]

四舍五入

将数值表达式四舍五入到最接近的 Integer 或 Long 值。

round(<浮点数>) ⇒ <整数>

round(<双精度>) ⇒ <长整型>

round(-1.5) ⇒ -1
round([1.75, 100.34]) ⇒ [2, 100]

向上取整

将数值表达式四舍五入到大于或等于原始值的最接近的 Integer 或 Long 值。

ceil(<浮点数>) ⇒ <整数>

ceil(<双精度>) ⇒ <长整型>

ceil(5.01) ⇒ 5
ceil([-4.999, 6.99]) ⇒ [-4, 7]

向下取整

将数值表达式向下舍入到最接近的 Integer 或 Long 值，该值小于或等于原始值。

floor(< 浮点数 >) ⇒ < 整数 >

floor(< 双精度浮点数 >) ⇒ < 长整数 >

floor(5.75) ⇒ 5
floor([-4.001, 6.01]) ⇒ [-5, 6]

加法

将数值表达式的值相加。

add(< 多精度双精度浮点数 >) ⇒ < 单精度双精度浮点数 >

add([1, -4]) ⇒ -3.0

add(< 单精度双精度浮点数 >, < 多精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

add(3.5, [1, -4]) ⇒ [4.5, -0.5]

add(< 多精度双精度浮点数 >, < 单精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

add([1, -4], 3.5) ⇒ [4.5, -0.5]

add(< 单精度双精度浮点数 >, …) ⇒ < 单精度双精度浮点数 >

add(3.5, 100, -27.6) ⇒ 75.9

减法

将数值表达式的值相减。

sub(< 单精度双精度浮点数 >, < 单精度双精度浮点数 >) ⇒ < 单精度双精度浮点数 >

sub(3.5, 100) ⇒ -76.5

sub(< 单精度双精度浮点数 >, < 多精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

sub(3.5, [1, -4]) ⇒ [2.5, 7.5]

sub(< 多精度双精度浮点数 >, < 单精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

sub([1, -4], 3.5) ⇒ [-2.5, -7.5]

乘法

将数值表达式的值相乘。

mult(< 多精度双精度浮点数 >) ⇒ < 单精度双精度浮点数 >

mult([1, -4]) ⇒ -4.0

mult(< 单精度双精度浮点数 >, < 多精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

mult(3.5, [1, -4]) ⇒ [3.5, -16.0]

mult(< 多精度双精度浮点数 >, < 单精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

mult([1, -4], 3.5) ⇒ [3.5, 16.0]

mult(< 单精度双精度浮点数 >, …) ⇒ < 单精度双精度浮点数 >

mult(3.5, 100, -27.6) ⇒ -9660

除法

将数值表达式的值相除。

div(< 单精度双精度浮点数 >, < 单精度双精度浮点数 >) ⇒ < 单精度双精度浮点数 >

div(3.5, 100) ⇒ .035

div(< 单精度双精度浮点数 >, < 多精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

div(3.5, [1, -4]) ⇒ [3.5, -0.875]

div(< 多精度双精度浮点数 >, < 单精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

div([1, -4], 25) ⇒ [0.04, -0.16]

幂

将一个数值表达式的值取另一个数值表达式的幂。

注意： 平方根函数 sqrt(< 双精度浮点数 >) 可以用作 pow(< 双精度浮点数 >, .5) 的简写形式

pow(< 单精度双精度浮点数 >, < 单精度双精度浮点数 >) ⇒ < 单精度双精度浮点数 >

pow(2, 4) ⇒ 16.0

pow(< 单精度双精度浮点数 >, < 多精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

pow(16, [-1, 0]) ⇒ [0.0625, 1]

pow(< 多精度双精度浮点数 >, < 单精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

pow([1, 16], .25) ⇒ [1.0, 2.0]

对数

取一个数值表达式的对数，并可选择第二个数值表达式作为底数。如果只给出一个表达式，则使用自然对数。

log(< 双精度浮点数 >) ⇒ < 双精度浮点数 >

log(5) ⇒ 1.6094…
log([1.0, 100.34]) ⇒ [0.0, 4.6085…]

log(< 单精度双精度浮点数 >, < 单精度双精度浮点数 >) ⇒ < 单精度双精度浮点数 >

log(2, 4) ⇒ 0.5

log(< 单精度双精度浮点数 >, < 多精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

log(16, [2, 4]) ⇒ [4, 2]

log(< 多精度双精度浮点数 >, < 单精度双精度浮点数 >) ⇒ < 多精度双精度浮点数 >

log([81, 3], 9) ⇒ [2.0, 0.5]

逻辑

否定

对布尔表达式的结果取反。

neg(< 布尔值 >) ⇒ < 布尔值>

neg(F) ⇒ T
neg([F, T]) ⇒ [T, F]

与

对布尔表达式的值执行 AND 运算。

and(< 多重布尔值 >) ⇒ < 单重布尔值 >

and([T, F, T]) ⇒ F

and(< 单重布尔值 >, < 多重布尔值 >) ⇒ < 多重布尔值 >

and(F, [T, T]) ⇒ [F, F]

and(< 多重布尔值 >, < 单重布尔值 >) ⇒ < 多重布尔值 >

and([F, T], T) ⇒ [F, T]

and(< 单重布尔值 >, …) ⇒ < 单重布尔值 >

and(T, T, T) ⇒ T

或

对布尔表达式的值执行 OR 运算。

or(< 多重布尔值 >) ⇒ < 单重布尔值 >

or([T, F, T]) ⇒ T

or(< 单重布尔值 >, < 多重布尔值 >) ⇒ < 多重布尔值 >

or(F, [F, T]) ⇒ [F, T]

or(< 多重布尔值 >, < 单重布尔值 >) ⇒ < 多重布尔值 >

or([F, T], T) ⇒ [T, T]

or(< 单重布尔值 >, …) ⇒ < 单重布尔值 >

or(F, F, F) ⇒ F

存在

检查表达式是否存在任何值。

exists( T ) ⇒ < 单重布尔值 >

exists([1, 2, 3]) ⇒ T
exists([]) ⇒ F
exists(空) ⇒ F
exists('abc') ⇒ T

比较

相等

检查两个表达式的值是否相等。隐式转换后，参数必须是相同的类型。

equal(< 单值 T >, < 单值 T >) ⇒ < 单重布尔值 >

equal(F, F) ⇒ T

equal(< 单值 T >, < 多值 T >) ⇒ < 多重布尔值 >

equal("a", ["a", "ab"]) ⇒ [T, F]

equal(< 多值 T >, < 单值 T >) ⇒ < 多重布尔值 >

equal([1.5, -3.0], -3) ⇒ [F, T]

大于

检查数值或 Date 表达式的值是否大于另一个表达式的值。隐式转换后，参数必须是相同的类型。

gt(< 单值数值/日期 T >, < 单值 T >) ⇒ < 单重布尔值 >

gt(1800-01-02, 1799-12-20) ⇒ F

gt(< 单值数值/日期 T >, < 多值 T >) ⇒ < 多重布尔值 >

gt(30.756, [30, 100]) ⇒ [F, T]

gt(< 多值数值/日期 T >, < 单值 T >) ⇒ < 多重布尔值 >

gt([30, 75.6], 30) ⇒ [F, T]

大于或等于

检查数值或 Date 表达式的值是否大于或等于另一个表达式的值。隐式转换后，参数必须是相同的类型。

gte(< 单值数值/日期 T >, < 单值 T >) ⇒ < 单重布尔值 >

gte(1800-01-02, 1799-12-20) ⇒ F

gte(< 单值数值/日期 T >, < 多值 T >) ⇒ < 多重布尔值 >

gte(30.756, [30, 100]) ⇒ [F, T]

gte(< 多值数值/日期 T >, < 单值 T >) ⇒ < 多重布尔值 >

gte([30, 75.6], 30) ⇒ [T, T]

小于

检查数值或 Date 表达式的值是否小于另一个表达式的值。隐式转换后，参数必须是相同的类型。

lt(< 单值数值/日期 T >, < 单值 T >) ⇒ < 单重布尔值 >

lt(1800-01-02, 1799-12-20) ⇒ T

lt(< 单值数值/日期 T >, < 多值 T >) ⇒ < 多重布尔值 >

lt(30.756, [30, 100]) ⇒ [T, F]

lt(< 多值数值/日期 T >, < 单值 T >) ⇒ < 多重布尔值 >

lt([30, 75.6], 30) ⇒ [F, F]

小于或等于

检查数值或 Date 表达式的值是否小于或等于另一个表达式的值。隐式转换后，参数必须是相同的类型。

lte(< 单值数值/日期 T >, < 单值 T >) ⇒ < 单重布尔值 >

lte(1800-01-02, 1799-12-20) ⇒ T

lte(< 单值数值/日期 T >, < 多值 T >) ⇒ < 多重布尔值 >

lte(30.756, [30, 100]) ⇒ [T, F]

lte(< 多值数值/日期 T >, < 单值 T >) ⇒ < 多重布尔值 >

lte([30, 75.6], 30) ⇒ [T, F]

最大值

返回数值、Date 或 String 表达式值的最大值。隐式转换后，参数必须是相同的类型。（目前唯一不兼容的类型是 Boolean，为了编译表达式，它将被隐式转换为 String）

top(< 多值 T >) ⇒ < 单值 T >

top([30, 400, -10, 0]) ⇒ 400

top(< 单值 T >, …) ⇒ < 单值 T >

top("a", 1, "d") ⇒ "d"

最小值

返回数值、Date 或 String 表达式值的最小值。隐式转换后，参数必须是相同的类型。（目前唯一不兼容的类型是 Boolean，为了编译表达式，它将被隐式转换为 String）

bottom(< 多值 T >) ⇒ < 单值 T >

bottom([30, 400, -10, 0]) ⇒ -10

bottom(< 单值 T >, …) ⇒ < 单值 T >

bottom("a", 1, "d") ⇒ "1"

条件

If

根据布尔条件表达式的值是 true 还是 false，返回 THEN 或 ELSE 表达式的值。在完成隐式转换后，THEN 和 ELSE 表达式必须具有相同的类型和基数。

if(< 单布尔值>, < T >, < T >) ⇒ < T >

if(true, "abc", [1,2]) ⇒ ["abc"]
if(false, "abc", 123) ⇒ "123"

替换

将第一个表达式中所有等于第二个表达式的值替换为第三个表达式的值。在完成隐式转换后，所有参数必须具有相同的类型。

replace(< T >, < 单值 T >, < 单值 T >) ⇒ < T >

replace([1,3], 3, "4") ⇒ ["1", "4"]
replace("abc", "abc", 18) ⇒ "18"
replace("abc", 1, "def") ⇒ "abc"

填充缺失值

如果第一个表达式没有值，则用第二个表达式的值填充。在完成隐式转换后，两个表达式必须具有相同的类型和基数。

fill_missing(< T >, < T >) ⇒ < T >

fill_missing([], 3) ⇒ [3]
fill_missing(空, "abc") ⇒ "abc"
fill_missing("abc", [1]) ⇒ ["abc"]

移除

从第一个表达式的值中删除所有第二个表达式值出现的实例。在完成隐式转换后，两个表达式必须具有相同的类型。

remove(< T >, < 单值 T >) ⇒ < T >

remove([1,2,3,2], 2) ⇒ [1, 3]
remove("1", 1) ⇒ 空
remove(1, "abc") ⇒ "1"

过滤

如果第二个表达式的值为 true，则返回第一个表达式的值，否则不返回任何值。

filter(< T >, < 单布尔值 >) ⇒ < T >

filter([1,2,3], true) ⇒ [1,2,3]
filter([1,2,3], false) ⇒ []
filter("abc", false) ⇒ 空
filter("abc", true) ⇒ 1

日期

日期解析

显式将 String 或 Long 表达式的值转换为 Dates。

date(< 字符串 >) ⇒ < 日期 >

date('1800-01-02') ⇒ 1800-01-02T00:00:00Z
date(['1800-01-02', '2016-05-23']) ⇒ [1800-01-02T…, 2016-05-23T…]

date(< 长整数 >) ⇒ < 日期 >

date(1232343246648) ⇒ 2009-01-19T05:34:06Z
date([1232343246648, 223234324664]) ⇒ [2009-01-19T…, 1977-01-27T…]

日期数学运算

为 Date 表达式的值计算给定的日期数学字符串。日期数学字符串必须是常量。

date_math(< 日期 >, < 常量字符串 >…) ⇒ < 日期 >

date_math(1800-04-15, '+1DAY', '-1MONTH') ⇒ 1800-03-16
date_math([1800-04-15,2016-05-24], '+1DAY', '-1MONTH') ⇒ [1800-03-16, 2016-04-25]

字符串

显式转换

显式将表达式转换为 String 表达式。

string(< 字符串 >) ⇒ < 字符串 >

string(1) ⇒ '1'
string([1.5, -2.0]) ⇒ ['1.5', '-2.0']

连接

将 String 表达式的值连接在一起。

concat(< 多字符串 >) ⇒ < 单字符串 >

concat(['a','b','c']) ⇒ 'abc'

concat(< 单字符串 >, < 多字符串 >) ⇒ < 多字符串 >

concat(1, ['a','b','c']) ⇒ ['1a','1b','1c']

concat(< 多字符串 >, < 单字符串 >) ⇒ < 多字符串 >

concat(['a','b','c'], 1) ⇒ ['a1','b1','c1']

concat(< 单字符串 >…) ⇒ < 单字符串 >

concat('a','b','c') ⇒ 'abc'
concat('a',空,'c') ⇒ 'ac'
空值将被忽略

分隔连接

使用给定的常量字符串值作为分隔符，将 String 表达式的值连接在一起。

concat_sep(< 常量字符串 >, < 多字符串 >) ⇒ < 单字符串 >

concat_sep('-', ['a','b']) ⇒ 'a-b'

concat_sep(< 常量字符串 >, < 单字符串 >, < 多字符串 >) ⇒ < 多字符串 >

concat_sep(2,1,['a','b']) ⇒ ['12a','12b']

concat_sep(< 常量字符串 >, < 多字符串 >, < 单字符串 >) ⇒ < 多字符串 >

concat_sep(2,['a','b'],1) ⇒ ['a21','b21']
concat_sep('-','a',2,3) ⇒ 'a-2-3'
concat_sep(';','a',空,'c') ⇒ 'a;c'
空值将被忽略