Module utils

Re-exports

• pub use pretty_serde::PrettySerde;
• pub use column_index_mapping::*;
• pub use condition::*;
• pub use stream_graph_formatter::*;
• pub use with_options::*;
• pub use rewrite_index::*;
• pub use index_set::*;
• pub use group_by::*;
• pub use overwrite_options::*;

Modules

• column_index_mapping 🔒
• condition 🔒
• connected_components 🔒
• group_by 🔒
• index_set 🔒
• overwrite_options
• pretty_serde 🔒
  @kwannoel: This module implements Serde for the Pretty struct. Why not implement it directly on our plan nodes? That’s because Pretty already summarizes the fields that are important to us. You can see that when explain() is called, we directly return the Pretty struct. The proper way to do this would be to create a new data structure that plan nodes get converted into, and then implement Serialize and Deserialize on that data structure (including to Pretty). But that’s a lot of refactoring work. So we just wrap Pretty in a newtype and implement Serialize on that, since it’s a good enough intermediate representation.
• rewrite_index 🔒
• stream_graph_formatter 🔒
• with_options 🔒

Structs

• Substitute
  Substitute InputRef with corresponding ExprImpl.

Traits

• DynEq
  An object safe version of Eq. This trait is automatically implemented for any 'static type that implements Eq.
• DynHash
  An object safe version of Hash. This trait is automatically implemented for any 'static type that implements Hash.
• Endo
  Given a tree-like structure T, we usually can specify a transformation T -> T by providing a pre-order transformation pre : T -> T and a post-order transformation post : T -> T. Specifically, the derived transformation apply : T -> T first applies pre, then maps itself over the subtrees, and finally applies post. This allows us to obtain a global transformation acting recursively on all levels by specifying simpler transformations at acts locally.
• Layer
  A Layer is a container with subcomponents of type Sub. We usually use Layer to represents one layer of a tree-like structure, where the subcomponents are the recursive subtrees. But in general, the subcomponent can be of different type than the Layer. Such structural relation between Sub and Layer allows us to lift transformation on Sub to that on Layer. A related and even more general notion is Functor, which might also be helpful to define in the future.
• Visit
  A similar trait to generate traversal over tree-like structure. See Endo for more details.

Functions

• ordinal

Trait Aliases

• Tree
  A tree-like structure is a Layer where the subcomponents are recursively trees.