Interface ExpressionRealizer

Method Details

• getImplicitTypeName

  static String getImplicitTypeName(RealizationContext context, Type type)

  Returns:

  a succinct and descriptive name for the given type for use with getImplicitName

• getImplicitName

  static String getImplicitName(RealizationContext context, RealizedExpression realized, Collection<String> used)

  Return a name we can use to represent the given realized expression in a struct where no member name has been given.

  ## Examples:

  { # literals 1, # as integer, 2.0, # as floating, 'three', # as text,

  # member access
   foo, # as foo,
   foo.bar, # as bar
   
   # function calls
   str(foo),  # as str_foo
   if_then_else(a, b, c), # as if_then_else
   lookup(foo, bookmark('bar')).event_id # as event_id
   

  } ```

  Parameters:

  used - the names that have already been assigned. If the implicit name would happen to collide with one of these then a counter style suffix is appended to the name to make it distinct, e.g. {foo, foo, foo} is equivalent to {foo: foo, foo_2: foo, foo_3: foo}

• makeUnique

  static String makeUnique(String identifier, Collection<String> used)

  Returns:

  a new identifier based on the given one that is unique among used - will append a _2, _3 to the given identifier until it finds one that is not in used.

• realizeConstant

  default ResultOrProblems<RealizedExpression> realizeConstant(Expression expression)

  Attempts to realize the given expression against an empty struct, returning a meaningful problem if it looks like it failed to realize because it had property access problems (meaning it wasn't constant as it relies on the input scope)

  Returns:

  a RealizedExpression that is constant, i.e should succeed when called like expr.evaluate(Tuple.EMPTY_TUPLE) and should always return the same result.

• realize

  ResultOrProblems<RealizedExpression> realize(Type inputType, Expression expression)

• realize

  ResultOrProblems<RealizedExpression> realize(Type inputType, String unparsedExpression)

• realizeAggregate

  ResultOrProblems<RealizedAggregateExpression> realizeAggregate(Type inputType, Expression expression)

  Returns:

  a RealizedAggregateExpression that can aggregate rows of the given input type.

• parse

  Expression parse(String unparsedExpression)

  Convenience method for parsing an rl expression in to an Expression ast.

  Parameters:

  unparsedExpression - the string of rl to parse

  Returns:

  the parsed Expression

• asStruct

  RealizedExpression asStruct(RealizationContext context, RealizedExpression expression)

  Convert a realized expression to one that always returns a Tuple and has return type that is a Struct. Note that this is a simpler routine than type coercion, and is offered to simplify user input cases where a pipeline wants a struct, but the user doesn't need to know or care about this, e.g. select(foo) is simpler than select({foo}) but they do exactly the same thing.