Solr查询：分析映射函数

Posted on 本文总阅读量次

Solr查询：分析映射函数

映射函数为每个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(< _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(< _Single Double_ >, < _Single Double_ >) => < _Single Double_ >：

  • div(3.5, 100) => .035
    div(< _Single Double_ >, < _Multi Double_ >) => < _Multi Double_ >：
  • div(3.5, [1, -4]) => [3.5, -0.875]
    div(< _Multi Double_ >, < _Single Double_ >) => < _Multi Double_ >：
  • div([1, -4], 25) => [0.04, -0.16]

幂运算

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

注意： 平方根函数sqrt(< _Double_ >)可以作为pow(< _Double_ >, .5)的简写形式使用

pow(< _Single Double_ >, < _Single Double_ >) => < _Single Double_ >：

  • pow(2, 4) => 16.0
    pow(< _Single Double_ >, < _Multi Double_ >) => < _Multi Double_ >：
  • pow(16, [-1, 0]) => [0.0625, 1]
    pow(< _Multi Double_ >, < _Single Double_ >) => < _Multi Double_ >：
  • pow([1, 16], .25) => [1.0, 2.0]

对数

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

log(< _Double_ >) => < _Double_ >：

  • log(5) => 1.6094...
  • log([1.0, 100.34]) => [0.0, 4.6085...]
    log(< _Single Double_ >, < _Single Double_ >) => < _Single Double_ >：
  • log(2, 4) => 0.5
    log(< _Single Double_ >, < _Multi Double_ >) => < _Multi Double_ >：
  • log(16, [2, 4]) => [4, 2]
    log(< _Multi Double_ >, < _Single Double_ >) => < _Multi Double_ >：
  • log([81, 3], 9) => [2.0, 0.5]

逻辑运算

取反

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

neg(< _Bool_ >) => < _Bool_>：

  • neg(F) => T
  • neg([F, T]) => [T, F]

与运算

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

and(< _Multi Bool_ >) => < _Single Bool_ >：

  • and([T, F, T]) => F
    and(< _Single Bool_ >, < _Multi Bool_ >) => < _Multi Bool_ >：
  • and(F, [T, T]) => [F, F]
    and(< _Multi Bool_ >, < _Single Bool_ >) => < _Multi Bool_ >：
  • and([F, T], T) => [F, T]
    and(< _Single Bool_ >, ...) => < _Single Bool_ >：
  • and(T, T, T) => T

或运算

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

or(< _Multi Bool_ >) => < _Single Bool_ >：

  • or([T, F, T]) => T
    or(< _Single Bool_ >, < _Multi Bool_ >) => < _Multi Bool_ >：
  • or(F, [F, T]) => [F, T]
    or(< _Multi Bool_ >, < _Single Bool_ >) => < _Multi Bool_ >：
  • or([F, T], T) => [T, T]
    or(< _Single Bool_ >, ...) => < _Single Bool_ >：
  • or(F, F, F) => F

存在性检查

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

exists( T ) => < _Single Bool_ >：

  • exists([1, 2, 3]) => T
  • exists([]) => F
  • exists(_empty_) => F
  • exists('abc') => T

比较运算

相等性

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

equal(< _Single_ T >, < _Single_ T >) => < _Single Bool_ >：

  • equal(F, F) => T
    equal(< _Single_ T >, < _Multi_ T >) => < _Multi Bool_ >：
  • equal("a", ["a", "ab"]) => [T, F]
    equal(< _Multi_ T >, < _Single_ T >) => < _Multi Bool_ >：
  • equal([1.5, -3.0], -3) => [F, T]

大于

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

gt(< _Single Numeric/Date_ T >, < _Single_ T >) => < _Single Bool_ >：

  • gt(1800-01-02, 1799-12-20) => F
    gt(< _Single Numeric/Date_ T >, < _Multi_ T >) => < _Multi Bool_ >：
  • gt(30.756, [30, 100]) => [F, T]
    gt(< _Multi Numeric/Date_ T >, < _Single_ T >) => < _Multi Bool_ >：
  • gt([30, 75.6], 30) => [F, T]

大于等于

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

gte(< _Single Numeric/Date_ T >, < _Single_ T >) => < _Single Bool_ >：

  • gte(1800-01-02, 1799-12-20) => F
    gte(< _Single Numeric/Date_ T >, < _Multi_ T >) => < _Multi Bool_ >：
  • gte(30.756, [30, 100]) => [F, T]
    gte(< _Multi Numeric/Date_ T >, < _Single_ T >) => < _Multi Bool_ >：
  • gte([30, 75.6], 30) => [T, T]

小于

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

lt(< _Single Numeric/Date_ T >, < _Single_ T >) => < _Single Bool_ >：

  • lt(1800-01-02, 1799-12-20) => T
    lt(< _Single Numeric/Date_ T >, < _Multi_ T >) => < _Multi Bool_ >：
  • lt(30.756, [30, 100]) => [T, F]
    lt(< _Multi Numeric/Date_ T >, < _Single_ T >) => < _Multi Bool_ >：
  • lt([30, 75.6], 30) => [F, F]

小于等于

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

lte(< _Single Numeric/Date_ T >, < _Single_ T >) => < _Single Bool_ >：

  • lte(1800-01-02, 1799-12-20) => T
    lte(< _Single Numeric/Date_ T >, < _Multi_ T >) => < _Multi Bool_ >：
  • lte(30.756, [30, 100]) => [T, F]
    lte(< _Multi Numeric/Date_ T >, < _Single_ T >) => < _Multi Bool_ >：
  • lte([30, 75.6], 30) => [T, F]

最大值

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

top(< _Multi_ T >) => < _Single_ T >：

  • top([30, 400, -10, 0]) => 400
    top(< _Single_ T >, ...) => < _Single_ T >：
  • top("a", 1, "d") => "d"

最小值

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

bottom(< _Multi_ T >) => < _Single_ T >：

  • bottom([30, 400, -10, 0]) => -10
    bottom(< _Single_ T >, ...) => < _Single_ T >：
  • bottom("a", 1, "d") => "1"

条件运算

条件判断

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

if(< _Single Bool_>, < T >, < T >) => < T >：

  • if(true, "abc", [1,2]) => ["abc"]
  • if(false, "abc", 123) => "123"

替换

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

replace(< T >, < _Single_ T >, < _Single_ 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 >, < _Single_ T >) => < T >：

  • remove([1,2,3,2], 2) => [1, 3]
  • remove("1", 1) => _empty_
  • remove(1, "abc") => "1"

过滤

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

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'（空值被忽略）
Solr查询 Solr查询 分析组件 映射函数 表达式
© 2025 Solr Community of China All Rights Reserved. 本站访客数人次 本站总访问量次
Theme by hiero