分析映射函数

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

分析组件已弃用。我们建议查看 JSON Facet API 中的类似功能。如果您需要 JSON Facet 目前未涵盖的功能，请通知项目。

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

数字函数

否定

否定数字表达式的结果。

neg(<_Numeric_ T>) ⇒ <T>

  • neg(10.53) ⇒ -10.53

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

绝对值

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

abs(< Numeric T >) ⇒ < T >

  • abs(-10.53) ⇒ 10.53

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

四舍五入

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

round(< Float >) ⇒ < Int >
round(< Double >) ⇒ < Long >

  • round(-1.5) ⇒ -1

  • round([1.75, 100.34]) ⇒ [2, 100]

向上取整

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

ceil(< Float >) ⇒ < Int >
ceil(< Double >) ⇒ < Long >

  • ceil(5.01) ⇒ 5

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

向下取整

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

floor(< Float >) ⇒ < Int >
floor(< Double >) ⇒ < Long >

  • floor(5.75) ⇒ 5

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

加法

对数值表达式求和。

add(< Multi Double >) ⇒ < Single Double >

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

add(< Single Double >, < Multi Double >) ⇒ < Multi Double >

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

add(< Multi Double >, < Single Double >) ⇒ < Multi Double >

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

add(< Single Double >, …​) ⇒ < Single Double >

  • add(3.5, 100, -27.6) ⇒ 75.9

减法

对数值表达式求差。

sub(< Single Double >, < Single Double >) ⇒ < Single Double >

  • sub(3.5, 100) ⇒ -76.5

sub(< Single Double >, < Multi Double >) ⇒ < Multi Double >

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

sub(< Multi Double >, < Single Double >) ⇒ < Multi Double >

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

乘法

对数值表达式求积。

mult(< Multi Double >) ⇒ < Single Double >

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

mult(< Single Double >, < Multi Double >) ⇒ < Multi Double >

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

mult(< Multi Double >, < Single Double >) ⇒ < Multi Double >

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

mult(< Single Double >, …​) ⇒ < Single Double >

  • 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(empty) ⇒ 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"

条件

如果

根据布尔条件表达式的值是 true 还是 false，返回 THEN 或 ELSE 表达式的值。在执行隐式转换后，THEN 和 ELSE 表达式必须为同一种类型和基数。

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

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

  • if(false, "abc", 123) ⇒ "123"

替换

用第 3 个表达式的值替换等于第 2 个表达式值的第 1 个表达式中的所有值。在执行隐式转换后，所有参数必须为同一种类型。

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

  • replace([1,3], 3, "4") ⇒ ["1", "4"]

  • replace("abc", "abc", 18) ⇒ "18"

  • replace("abc", 1, "def") ⇒ "abc"

填充缺失值

如果第 1 个表达式没有值，则用第 2 个表达式的值填充它。在执行隐式转换后，两个表达式必须为同一种类型和基数。

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

  • fill_missing([], 3) ⇒ [3]

  • fill_missing(empty, "abc") ⇒ "abc"

  • fill_missing("abc", [1]) ⇒ ["abc"]

移除

从第 1 个表达式的值中移除所有第 2 个表达式的值。在执行隐式转换后，两个表达式必须为同一种类型。

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

  • remove([1,2,3,2], 2) ⇒ [1, 3]

  • remove("1", 1) ⇒ empty

  • remove(1, "abc") ⇒ "1"

筛选

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

filter(< T >, < Single Boolean >) ⇒ < T >

  • filter([1,2,3], true) ⇒ [1,2,3]

  • filter([1,2,3], false) ⇒ []

  • filter("abc", false) ⇒ empty

  • filter("abc", true) ⇒ 1

日期

日期解析

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

date(< String >) ⇒ < Date >

  • date('1800-01-02') ⇒ 1800-01-02T​00:00:00Z

  • date(['1800-01-02', '2016-05-23']) ⇒ [1800-01-02T…​, 2016-05-23T…​]

date(< Long >) ⇒ < Date >

  • date(1232343246648) ⇒ 2009-01-19T​05:34:06Z

  • date([1232343246648, 223234324664]) ⇒ [2009-01-19T…​, 1977-01-27T…​]

日期数学

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

date_math(< Date >, < Constant String >…​) ⇒ < Date >

  • 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 >) ⇒ < String >

  • string(1) ⇒ '1'

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

连接

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

concat(< Multi String >) ⇒ < Single String >

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

concat(< Single String >, < Multi String >) ⇒ < Multi String >

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

concat(< Multi String >, < Single String >) ⇒ < Multi String >

  • 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'

    忽略空值