pub fn action(&self, relation: &mut MirRelationExpr) {
        if let MirRelationExpr::TopK {
            input,
            group_key,
            order_key,
            limit,
            offset,
            monotonic,
        } = relation
        {
            while let MirRelationExpr::TopK {
                input: inner_input,
                group_key: inner_group_key,
                order_key: inner_order_key,
                limit: inner_limit,
                offset: inner_offset,
                monotonic: inner_monotonic,
            } = &mut **input
            {
                // We can fuse two chained TopK operators as long as they share the
                // same grouping and ordering key.
                if *group_key == *inner_group_key && *order_key == *inner_order_key {
                    // Given the following limit/offset pairs:
                    //
                    // inner_offset          inner_limit
                    // |------------|xxxxxxxxxxxxxxxxxx|
                    //              |------------|xxxxxxxxxxxx|
                    //              outer_offset    outer_limit
                    //
                    // the limit/offset pair of the fused TopK operator is computed
                    // as:
                    //
                    // offset = inner_offset + outer_offset
                    // limit = min(max(inner_limit - outer_offset, 0), outer_limit)
                    if let Some(inner_limit) = inner_limit {
                        let inner_limit_minus_outer_offset = inner_limit.saturating_sub(*offset);
                        if let Some(limit) = limit {
                            *limit = std::cmp::min(*limit, inner_limit_minus_outer_offset);
                        } else {
                            *limit = Some(inner_limit_minus_outer_offset);
                        }
                    }

                    if let Some(0) = limit {
                        relation.take_safely();
                        break;
                    }

                    *offset += *inner_offset;
                    *monotonic = *inner_monotonic;
                    **input = inner_input.take_dangerous();
                } else {
                    break;
                }
            }
        }
    }
/// Fuses a sequence of `TopK` operators in to one `TopK` operator.
Fuses a sequence of `TopK` operators in to one `TopK` operator.
Fuses a sequence of ` TopK ` operators in to one ` TopK ` operator .
pub fn action(&self, relation: &mut MirRelationExpr) {
        if let MirRelationExpr::TopK {
            input,
            group_key,
            order_key,
            limit,
            offset,
            monotonic,
        } = relation
        {
            while let MirRelationExpr::TopK {
                input: inner_input,
                group_key: inner_group_key,
                order_key: inner_order_key,
                limit: inner_limit,
                offset: inner_offset,
                monotonic: inner_monotonic,
            } = &mut **input
            {
                // We can fuse two chained TopK operators as long as they share the
                // same grouping and ordering key.
                if *group_key == *inner_group_key && *order_key == *inner_order_key {
                    // Given the following limit/offset pairs:
                    //
                    // inner_offset          inner_limit
                    // |------------|xxxxxxxxxxxxxxxxxx|
                    //              |------------|xxxxxxxxxxxx|
                    //              outer_offset    outer_limit
                    //
                    // the limit/offset pair of the fused TopK operator is computed
                    // as:
                    //
                    // offset = inner_offset + outer_offset
                    // limit = min(max(inner_limit - outer_offset, 0), outer_limit)
                    if let Some(inner_limit) = inner_limit {
                        let inner_limit_minus_outer_offset = inner_limit.saturating_sub(*offset);
                        if let Some(limit) = limit {
                            *limit = std::cmp::min(*limit, inner_limit_minus_outer_offset);
                        } else {
                            *limit = Some(inner_limit_minus_outer_offset);
                        }
                    }
                    if let Some(0) = limit {
                        relation.take_safely();
                        break;
                    }
                    *offset += *inner_offset;
                    *monotonic = *inner_monotonic;
                    **input = inner_input.take_dangerous();
                } else {
                    break;
                }
            }
        }
    }
pub fn action ( & self , relation : & mut MirRelationExpr ) { if let MirRelationExpr :: TopK { input , group_key , order_key , limit , offset , monotonic , } = relation { while let MirRelationExpr :: TopK { input : inner_input , group_key : inner_group_key , order_key : inner_order_key , limit : inner_limit , offset : inner_offset , monotonic : inner_monotonic , } = & mut * * input { // We can fuse two chained TopK operators as long as they share the // same grouping and ordering key. if * group_key == * inner_group_key && * order_key == * inner_order_key { // Given the following limit/offset pairs: // // inner_offset          inner_limit // |------------|xxxxxxxxxxxxxxxxxx| //              |------------|xxxxxxxxxxxx| //              outer_offset    outer_limit // // the limit/offset pair of the fused TopK operator is computed // as: // // offset = inner_offset + outer_offset // limit = min(max(inner_limit - outer_offset, 0), outer_limit) if let Some ( inner_limit ) = inner_limit { let inner_limit_minus_outer_offset = inner_limit . saturating_sub ( * offset ) ; if let Some ( limit ) = limit { * limit = std :: cmp :: min ( * limit , inner_limit_minus_outer_offset ) ; } else { * limit = Some ( inner_limit_minus_outer_offset ) ; } } if let Some ( 0 ) = limit { relation . take_safely ( ) ; break ; } * offset += * inner_offset ; * monotonic = * inner_monotonic ; * * input = inner_input . take_dangerous ( ) ; } else { break ; } } } }
Fuses a sequence of `TopK` operators in to one `TopK` operator.
Fuses a sequence of ` TopK ` operators in to one ` TopK ` operator .
&self
relation
&mut MirRelationExpr
&self
relation
&mut MirRelationExpr