Analytics Mapping Functions

2020-01-12

Mapping functions map values for each Solr Document or Reduction.

Below is a list of all mapping functions provided by the Analytics Component. These mappings can be chained together to implement more complex functionality.

Numeric Functions

Negation

Negates the result of a numeric expression.

neg(<_Numeric_ T>) => <T>
  • neg(10.53) => -10.53

  • neg([1, -4]) => [-1, 4]

Absolute Value

Returns the absolute value of the numeric expression.

abs(< Numeric T >) => < T >
  • abs(-10.53) => 10.53

  • abs([1, -4]) => [1, 4]

Round

Rounds the numeric expression to the nearest Integer or Long value.

round(< Float >) => < Int >
round(< Double >) => < Long >
  • round(-1.5) => -1

  • round([1.75, 100.34]) => [2, 100]

Ceiling

Rounds the numeric expression to the nearest Integer or Long value that is greater than or equal to the original value.

ceil(< Float >) => < Int >
ceil(< Double >) => < Long >
  • ceil(5.01) => 5

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

Floor

Rounds the numeric expression to the nearest Integer or Long value that is less than or equal to the original value.

floor(< Float >) => < Int >
floor(< Double >) => < Long >
  • floor(5.75) => 5

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

Addition

Adds the values of the numeric expressions.

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

Subtraction

Subtracts the values of the numeric expressions.

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]

Multiplication

Multiplies the values of the numeric expressions.

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

Division

Divides the values of the numeric expressions.

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]

Power

Takes one numeric expression to the power of another.

NOTE: The square root function sqrt(< Double >) can be used as shorthand for 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]

Logarithm

Takes one logarithm of numeric expressions, with an optional second numeric expression as the base. If only one expression is given, the natural log is used.

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]

Logic

Negation

Negates the result of a boolean expression.

neg(< Bool >) => < Bool>
  • neg(F) => T

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

And

ANDs the values of the boolean expressions.

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

ORs the values of the boolean expressions.

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

Checks whether any value(s) exist for the expression.

exists( T ) => < Single Bool >
  • exists([1, 2, 3]) => T

  • exists([]) => F

  • exists(empty) => F

  • exists('abc') => T

Comparison

Equality

Checks whether two expressions' values are equal. The parameters must be the same type, after implicit casting.

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]

Greater Than

Checks whether a numeric or Date expression’s values are greater than another expression’s values. The parameters must be the same type, after implicit casting.

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]

Greater Than or Equals

Checks whether a numeric or Date expression’s values are greater than or equal to another expression’s values. The parameters must be the same type, after implicit casting.

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]

Less Than

Checks whether a numeric or Date expression’s values are less than another expression’s values. The parameters must be the same type, after implicit casting.

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]

Less Than or Equals

Checks whether a numeric or Date expression’s values are less than or equal to another expression’s values. The parameters must be the same type, after implicit casting.

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]

Top

Returns the maximum of the numeric, Date or String expression(s)' values. The parameters must be the same type, after implicit casting. (Currently the only type not compatible is Boolean, which will be converted to a String implicitly in order to compile the expression)

top(< Multi T >) => < Single T >
  • top([30, 400, -10, 0]) => 400

top(< Single T >, …​) => < Single T >
  • top("a", 1, "d") => "d"

Bottom

Returns the minimum of the numeric, Date or String expression(s)' values. The parameters must be the same type, after implicit casting. (Currently the only type not compatible is Boolean, which will be converted to a String implicitly in order to compile the expression)

bottom(< Multi T >) => < Single T >
  • bottom([30, 400, -10, 0]) => -10

bottom(< Single T >, …​) => < Single T >
  • bottom("a", 1, "d") => "1"

Conditional

If

Returns the value(s) of the THEN or ELSE expressions depending on whether the boolean conditional expression’s value is true or false. The THEN and ELSE expressions must be of the same type and cardinality after implicit casting is done.

if(< Single Bool>, < T >, < T >) => < T >
  • if(true, "abc", [1,2]) => ["abc"]

  • if(false, "abc", 123) => "123"

Replace

Replace all values from the 1st expression that are equal to the value of the 2nd expression with the value of the 3rd expression. All parameters must be the same type after implicit casting is done.

replace(< T >, < Single T >, < Single T >) => < T >
  • replace([1,3], 3, "4") => ["1", "4"]

  • replace("abc", "abc", 18) => "18"

  • replace("abc", 1, "def") => "abc"

Fill Missing

If the 1st expression does not have values, fill it with the values for the 2nd expression. Both expressions must be of the same type and cardinality after implicit casting is done.

fill_missing(< T >, < T >) => < T >
  • fill_missing([], 3) => [3]

  • fill_missing(empty, "abc") => "abc"

  • fill_missing("abc", [1]) => ["abc"]

Remove

Remove all occurrences of the 2nd expression’s value from the values of the 1st expression. Both expressions must be of the same type after implicit casting is done.

remove(< T >, < Single T >) => < T >
  • remove([1,2,3,2], 2) => [1, 3]

  • remove("1", 1) => empty

  • remove(1, "abc") => "1"

Filter

Return the values of the 1st expression if the value of the 2nd expression is true, otherwise return no values.

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

Date

Date Parse

Explicitly converts the values of a String or Long expression into 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 Math

Compute the given date math strings for the values of a Date expression. The date math strings must be constant.

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

Explicit Casting

Explicitly casts the expression to a String expression.

string(< String >) => < String >
  • string(1) => '1'

  • string([1.5, -2.0]) => ['1.5', '-2.0']

Concatenation

Concatenations the values of the String expression(s) together.

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'
    Empty values are ignored

Separated Concatenation

Concatenations the values of the String expression(s) together using the given constant string value as a separator.

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'
    Empty values are ignored