Class: Polars::MetaExpr

Inherits:
Object
  • Object
show all
Defined in:
lib/polars/meta_expr.rb

Overview

Namespace for expressions on a meta level.

Instance Method Summary collapse

Instance Method Details

#!=(other) ⇒ Boolean

Not equal.

Returns:



22
23
24
 
# File 'lib/polars/meta_expr.rb', line 22

def !=(other)
  !(self == other)
end

#==(other) ⇒ Boolean

Equal.

Returns:



15
16
17
 
# File 'lib/polars/meta_expr.rb', line 15

def ==(other)
  _rbexpr.meta_eq(other._rbexpr)
end

#as_expression ⇒ Expr

Return the original expression.

Returns:



246
247
248
 
# File 'lib/polars/meta_expr.rb', line 246

def as_expression
  Utils.wrap_expr(_rbexpr)
end

#as_selector ⇒ Expr

Note:

This functionality is considered unstable. It may be changed at any point without it being considered a breaking change.

Try to turn this expression in a selector.

Raises if the underlying expressions is not a column or selector.

Returns:



259
260
261
 
# File 'lib/polars/meta_expr.rb', line 259

def as_selector
  Selector._from_rbselector(_rbexpr.into_selector)
end

#eq(other) ⇒ Boolean

Indicate if this expression is the same as another expression.

Examples:

foo_bar = Polars.col("foo").alias("bar")
foo = Polars.col("foo")
foo_bar.meta.eq(foo)
# => false
foo_bar2 = Polars.col("foo").alias("bar")
foo_bar.meta.eq(foo_bar2)
# => true

Returns:



38
39
40
 
# File 'lib/polars/meta_expr.rb', line 38

def eq(other)
  _rbexpr.meta_eq(other._rbexpr)
end

#has_multiple_outputs ⇒ Boolean

Indicate if this expression expands into multiple expressions.

Examples:

e = Polars.col(["a", "b"]).alias("bar")
e.meta.has_multiple_outputs
# => true

Returns:



66
67
68
 
# File 'lib/polars/meta_expr.rb', line 66

def has_multiple_outputs
  _rbexpr.meta_has_multiple_outputs
end

#is_column ⇒ Boolean

Indicate if this expression is a basic (non-regex) unaliased column.

Examples:

e = Polars.col("foo")
e.meta.is_column
# => true
e = Polars.col("foo") * Polars.col("bar")
e.meta.is_column
# => false
e = Polars.col("^col.*\d+$")
e.meta.is_column
# => false

Returns:



84
85
86
 
# File 'lib/polars/meta_expr.rb', line 84

def is_column
  _rbexpr.meta_is_column
end

#is_column_selection(allow_aliasing: false) ⇒ Boolean

Indicate if this expression only selects columns (optionally with aliasing).

This can include bare columns, columns matched by regex or dtype, selectors and exclude ops, and (optionally) column/expression aliasing.

Examples:

e = Polars.col("foo")
e.meta.is_column_selection
# => true
e = Polars.col("foo").alias("bar")
e.meta.is_column_selection
# => false
e.meta.is_column_selection(allow_aliasing: true)
# => true
e = Polars.col("foo") * Polars.col("bar")
e.meta.is_column_selection
# => false
e = Polars.cs.starts_with("foo")
e.meta.is_column_selection
# => true
e = Polars.cs.starts_with("foo").exclude("foo!")
e.meta.is_column_selection
# => true

Parameters:

  • allow_aliasing (Boolean) (defaults to: false) —

    If false (default), any aliasing is not considered to be column selection. Set true to allow for column selection that also includes aliasing.

Returns:



139
140
141
 
# File 'lib/polars/meta_expr.rb', line 139

def is_column_selection(allow_aliasing: false)
  _rbexpr.meta_is_column_selection(allow_aliasing)
end

#is_literal(allow_aliasing: false) ⇒ Boolean

Indicate if this expression is a literal value (optionally aliased).

Examples:

e = Polars.lit(123)
e.meta.is_literal
# => true
e = Polars.lit(987.654321).alias("foo")
e.meta.is_literal
# => false

Parameters:

  • allow_aliasing (Boolean) (defaults to: false) —

    If false (default), only a bare literal will match. Set true to also allow for aliased literals.

Returns:



160
161
162
 
# File 'lib/polars/meta_expr.rb', line 160

def is_literal(allow_aliasing: false)
  _rbexpr.meta_is_literal(allow_aliasing)
end

#is_regex_projection ⇒ Boolean

Indicate if this expression expands to columns that match a regex pattern.

Examples:

e = Polars.col("^.*$").alias("bar")
e.meta.is_regex_projection
# => true

Returns:



96
97
98
 
# File 'lib/polars/meta_expr.rb', line 96

def is_regex_projection
  _rbexpr.meta_is_regex_projection
end

#ne(other) ⇒ Boolean

Indicate if this expression is NOT the same as another expression.

Examples:

foo_bar = Polars.col("foo").alias("bar")
foo = Polars.col("foo")
foo_bar.meta.ne(foo)
# => true
foo_bar2 = Polars.col("foo").alias("bar")
foo_bar.meta.ne(foo_bar2)
# => false

Returns:



54
55
56
 
# File 'lib/polars/meta_expr.rb', line 54

def ne(other)
  !eq(other)
end

#output_name(raise_if_undetermined: true) ⇒ String

Get the column name that this expression would produce.

Examples:

e = Polars.col("foo") * Polars.col("bar")
e.meta.output_name
# => "foo"
e_filter = Polars.col("foo").filter(Polars.col("bar") == 13)
e_filter.meta.output_name
# => "foo"
e_sum_over = Polars.sum("foo").over("groups")
e_sum_over.meta.output_name
# => "foo"
e_sum_slice = Polars.sum("foo").slice(Polars.len - 10, Polars.col("bar"))
e_sum_slice.meta.output_name
# => "foo"
Polars.len.meta.output_name
# => "len"

Returns:



183
184
185
186
187
188
189
190
 
# File 'lib/polars/meta_expr.rb', line 183

def output_name(raise_if_undetermined: true)
  _rbexpr.meta_output_name
rescue Polars::ComputeError
  if !raise_if_undetermined
    return nil
  end
  raise
end

#pop(schema: nil) ⇒ Array

Pop the latest expression and return the input(s) of the popped expression.

Examples:

e = Polars.col("foo") + Polars.col("bar")
first = e.meta.pop[0]
_ = first.meta == Polars.col("bar")
# => true
_ = first.meta == Polars.col("foo")
# => false

Returns:



203
204
205
 
# File 'lib/polars/meta_expr.rb', line 203

def pop(schema: nil)
  _rbexpr.meta_pop(schema).map { |e| Utils.wrap_expr(e) }
end

#root_names ⇒ Array

Get a list with the root column name.

Examples:

e = Polars.col("foo") * Polars.col("bar")
e.meta.root_names
# => ["foo", "bar"]
e_filter = Polars.col("foo").filter(Polars.col("bar") == 13)
e_filter.meta.root_names
# => ["foo", "bar"]
e_sum_over = Polars.sum("foo").over("groups")
e_sum_over.meta.root_names
# => ["foo", "groups"]
e_sum_slice = Polars.sum("foo").slice(Polars.len - 10, Polars.col("bar"))
e_sum_slice.meta.root_names
# => ["foo", "bar"]

Returns:



224
225
226
 
# File 'lib/polars/meta_expr.rb', line 224

def root_names
  _rbexpr.meta_roots
end

#serialize(file = nil) ⇒ Object

Note:

Serialization is not stable across Polars versions: a LazyFrame serialized in one Polars version may not be deserializable in another Polars version.

Serialize this expression to a file or string.

Examples:

Serialize the expression into a binary representation.

expr = Polars.col("foo").sum.over("bar")
bytes = expr.meta.serialize
Polars::Expr.deserialize(StringIO.new(bytes))
# => col("foo").sum().over([col("bar")])

Parameters:

  • file (Object) (defaults to: nil) —

    File path to which the result should be written. If set to nil (default), the output is returned as a string instead.

Returns:

Raises:

  • (Todo) 


280
281
282
283
284
285
286
 
# File 'lib/polars/meta_expr.rb', line 280

def serialize(file = nil)
  raise Todo unless _rbexpr.respond_to?(:serialize_binary)

  serializer = _rbexpr.method(:serialize_binary)

  Utils.serialize_polars_object(serializer, file)
end

#show_graph(show: true, output_path: nil, raw_output: false, figsize: [16.0, 12.0], schema: nil) ⇒ Object

Format the expression as a Graphviz graph.

Note that Graphviz must be installed to render the visualization (if not already present, you can download it here: https://graphviz.org/download.

Examples:

e = (Polars.col("foo") * Polars.col("bar")).sum.over(Polars.col("ham")) / 2
e.meta.show_graph

Parameters:

  • show (Boolean) (defaults to: true) —

    Show the figure.

  • output_path (String) (defaults to: nil) —

    Write the figure to disk.

  • raw_output (Boolean) (defaults to: false) —

    Return dot syntax. This cannot be combined with show and/or output_path.

  • figsize (Array) (defaults to: [16.0, 12.0]) —

    Passed to matplotlib if show == true.

Returns:



327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
 
# File 'lib/polars/meta_expr.rb', line 327

def show_graph(
  show: true,
  output_path: nil,
  raw_output: false,
  figsize: [16.0, 12.0],
  schema: nil
)
  dot = _rbexpr.meta_show_graph(schema)
  Utils.display_dot_graph(
    dot: dot,
    show: show,
    output_path: output_path,
    raw_output: raw_output,
    figsize: figsize
  )
end

#tree_format(return_as_string: false, schema: nil) ⇒ String

Format the expression as a tree.

Examples:

e = (Polars.col("foo") * Polars.col("bar")).sum.over(Polars.col("ham")) / 2
e.meta.tree_format(return_as_string: true)

Parameters:

  • return_as_string (Boolean) (defaults to: false) —

    If true, return as string rather than printing to stdout.

Returns:



298
299
300
301
302
303
304
305
306
 
# File 'lib/polars/meta_expr.rb', line 298

def tree_format(return_as_string: false, schema: nil)
  s = _rbexpr.meta_tree_format(schema)
  if return_as_string
    s
  else
    puts s
    nil
  end
end

#undo_aliases ⇒ Expr

Undo any renaming operation like alias or keep_name.

Examples:

e = Polars.col("foo").alias("bar")
_ = e.meta.undo_aliases.meta == Polars.col("foo")
# => true
e = Polars.col("foo").sum.over("bar")
_ = e.name.keep.meta.undo_aliases.meta == e
# => true

Returns:



239
240
241
 
# File 'lib/polars/meta_expr.rb', line 239

def undo_aliases
  Utils.wrap_expr(_rbexpr.meta_undo_aliases)
end