分析映射函數

映射函數會映射每個 Solr 文件或縮減的值。

分析元件已過時。我們建議您研究 JSON 分面 API 中類似的功能。如果目前 JSON 分面未涵蓋您需要的功能，請通知專案。

以下是分析元件提供的所有映射函數的清單。這些映射可以鏈結在一起以實作更複雜的功能。

數值函數

否定

否定數值表示式的結果。

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(< 單精度浮點數或雙精度浮點數 >, < 單精度浮點數或雙精度浮點數 >) ⇒ < 單精度浮點數或雙精度浮點數 >

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"

條件

如果

根據布林條件表達式的值是 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(empty, "abc") ⇒ "abc"
fill_missing("abc", [1]) ⇒ ["abc"]

移除

從第一個運算式的值中移除所有第二個運算式值出現的項目。在完成隱式轉換後，兩個運算式必須具有相同的類型。

remove(< T >, < Single 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-02T00:00:00Z
date(['1800-01-02', '2016-05-23']) ⇒ [1800-01-02T…, 2016-05-23T…]

date(< Long >) ⇒ < Date >

date(1232343246648) ⇒ 2009-01-19T05: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(< Single String >…) ⇒ < Single String >

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

分隔串聯

使用給定的常數字串值作為分隔符號，將 String 運算式的值串聯在一起。

concat_sep(< Constant String >, < Multi String >) ⇒ < Single String >

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

concat_sep(< Constant String >, < Single String >, < Multi String >) ⇒ < Multi String >

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

concat_sep(< Constant String >, < Multi String >, < Single String >) ⇒ < Multi String >

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