Struct DeltaJoinSolver

pub struct DeltaJoinSolver {
    arrange_strategy: ArrangeStrategy,
    stream_strategy: StreamStrategy,
    edges: Vec<JoinEdge>,
    join_order: Vec<JoinTable>,
}

Given a multi-way inner join plan, the solver will produces the most efficient way of getting those join done.

Input

DeltaJoinSolver needs the information of the cost of joining two tables. You’ll need to provide edges of the join graph. Each JoinEdge (a, b) -> cost describes the cost of inner join a and b.

Output

The solve function will return a vector of LookupPath. See LookupPath for more.

Fields

arrange_strategy: ArrangeStrategy

Strategy of arrangement placement, see docs of ArrangeStrategy for more details.

stream_strategy: StreamStrategy

Strategy of stream placement, see docs of StreamStrategy for more details.

edges: Vec<JoinEdge>

Possible combination of joins. If (a, b) is in edges, then a and b can be joined. The edge is bi-directional, so only one pair (either a, b or b, a) needs to be present in this vector.

join_order: Vec<JoinTable>

The recommended join order from optimizer in a multi-way join plan node.

Implementations

impl DeltaJoinSolver

fn find_lookup_path( &self, solver_env: &SolverEnv, input_stream: JoinTable, ) -> Result<LookupPath>

Generate a lookup path using the user provided strategy. The lookup path is generated in the following way:

• Firstly, we find all tables that can be joined with the current join table set. The tables should have the same join key as the current join set.
• If there are multiple tables that satisfy this condition, we will pick tables according to ArrangeStrategy.
• If not, then we have to do a shuffle. We pick all tables that have join condition with the current table set.
• And then pick a table using ArrangeStrategy.

Basically, this algorithm will greedily pick all tables with the same join key first (so that there won’t be shuffle). Then, switch a distribution, and do this process again.

pub fn solve(&self) -> Result<Vec<LookupPath>>

pub fn new( stream_strategy: StreamStrategy, edges: Vec<JoinEdge>, join_order: Vec<JoinTable>, ) -> Self