algeon-cudf 0.1.2

Safe libcudf execution component for Algeon
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use super::*;

impl DataFrame {
    pub(crate) fn mixed_join_indices_in_context(
        &self,
        right: &DataFrame,
        predicate: &AstExpression,
        options: DataFrameMixedJoinOptions,
        join_type: join::JoinType,
        ctx: Exec<'_>,
    ) -> Result<DataFrameJoinPairIndices> {
        let operation = "dataframe::mixed_join_indices";
        let tables = mixed_join_tables(self, right, &options, operation)?;
        let raw = match join_type {
            join::JoinType::Inner => join::mixed_inner_join_indices_in(
                &tables.left_equality,
                &tables.right_equality,
                &tables.left_conditional,
                &tables.right_conditional,
                predicate,
                options.null_eq(),
                ctx,
            )?,
            join::JoinType::Left => join::mixed_left_join_indices_in(
                &tables.left_equality,
                &tables.right_equality,
                &tables.left_conditional,
                &tables.right_conditional,
                predicate,
                options.null_eq(),
                ctx,
            )?,
            join::JoinType::Full => join::mixed_full_join_indices_in(
                &tables.left_equality,
                &tables.right_equality,
                &tables.left_conditional,
                &tables.right_conditional,
                predicate,
                options.null_eq(),
                ctx,
            )?,
        };
        pair_indices_from_raw(raw, operation)
    }

    pub(crate) fn mixed_join_size_data_in_context<'a>(
        &self,
        right: &DataFrame,
        predicate: &'a AstExpression,
        options: DataFrameMixedJoinOptions,
        join_type: join::SizedMixedJoinType,
        ctx: Exec<'_>,
    ) -> Result<DataFrameMixedJoinSizeData<'a>> {
        let operation = "dataframe::mixed_join_size_data";
        let tables = mixed_join_tables(self, right, &options, operation)?;
        let state = match join_type {
            join::SizedMixedJoinType::Inner => join::mixed_inner_join_begin_size_data_in(
                &tables.left_equality,
                &tables.right_equality,
                &tables.left_conditional,
                &tables.right_conditional,
                predicate,
                options.null_eq(),
                ctx,
            )?,
            join::SizedMixedJoinType::Left => join::mixed_left_join_begin_size_data_in(
                &tables.left_equality,
                &tables.right_equality,
                &tables.left_conditional,
                &tables.right_conditional,
                predicate,
                options.null_eq(),
                ctx,
            )?,
            join::SizedMixedJoinType::Full => join::mixed_full_join_begin_size_data_in(
                &tables.left_equality,
                &tables.right_equality,
                &tables.left_conditional,
                &tables.right_conditional,
                predicate,
                options.null_eq(),
                ctx,
            )?,
        };
        Ok(DataFrameMixedJoinSizeData { state, _left: self.clone(), _right: right.clone() })
    }

    pub(crate) fn mixed_single_side_join_size_data_in_context<'a>(
        &self,
        right: &DataFrame,
        predicate: &'a AstExpression,
        options: DataFrameMixedJoinOptions,
        semi_join: bool,
        ctx: Exec<'_>,
    ) -> Result<DataFrameMixedSingleSideJoinSizeData<'a>> {
        let operation = "dataframe::mixed_single_side_join_size_data";
        let tables = mixed_join_tables(self, right, &options, operation)?;
        let state = if semi_join {
            join::mixed_left_semi_join_begin_size_data_in(
                &tables.left_equality,
                &tables.right_equality,
                &tables.left_conditional,
                &tables.right_conditional,
                predicate,
                options.null_eq(),
                ctx,
            )?
        } else {
            join::mixed_left_anti_join_begin_size_data_in(
                &tables.left_equality,
                &tables.right_equality,
                &tables.left_conditional,
                &tables.right_conditional,
                predicate,
                options.null_eq(),
                ctx,
            )?
        };
        Ok(DataFrameMixedSingleSideJoinSizeData { state, _left: self.clone(), _right: right.clone() })
    }

    pub(crate) fn mixed_single_side_join_indices_in_context(
        &self,
        right: &DataFrame,
        predicate: &AstExpression,
        options: DataFrameMixedJoinOptions,
        semi_join: bool,
        ctx: Exec<'_>,
    ) -> Result<DataFrameJoinIndices> {
        let operation = "dataframe::mixed_single_side_join_indices";
        let tables = mixed_join_tables(self, right, &options, operation)?;
        let raw = if semi_join {
            join::mixed_left_semi_join_indices_in(
                &tables.left_equality,
                &tables.right_equality,
                &tables.left_conditional,
                &tables.right_conditional,
                predicate,
                options.null_eq(),
                ctx,
            )?
        } else {
            join::mixed_left_anti_join_indices_in(
                &tables.left_equality,
                &tables.right_equality,
                &tables.left_conditional,
                &tables.right_conditional,
                predicate,
                options.null_eq(),
                ctx,
            )?
        };
        single_side_indices_from_raw(raw, operation)
    }
}