arrow-data 53.4.1

Array data abstractions for Apache Arrow
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

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

use crate::{ArrayData, ByteView};

pub(super) fn byte_view_equal(
    lhs: &ArrayData,
    rhs: &ArrayData,
    lhs_start: usize,
    rhs_start: usize,
    len: usize,
) -> bool {
    let lhs_views = &lhs.buffer::<u128>(0)[lhs_start..lhs_start + len];
    let lhs_buffers = &lhs.buffers()[1..];
    let rhs_views = &rhs.buffer::<u128>(0)[rhs_start..rhs_start + len];
    let rhs_buffers = &rhs.buffers()[1..];

    for (idx, (l, r)) in lhs_views.iter().zip(rhs_views).enumerate() {
        // Only checking one null mask here because by the time the control flow reaches
        // this point, the equality of the two masks would have already been verified.
        if lhs.is_null(idx) {
            continue;
        }

        let l_len_prefix = *l as u64;
        let r_len_prefix = *r as u64;
        // short-circuit, check length and prefix
        if l_len_prefix != r_len_prefix {
            return false;
        }

        let len = l_len_prefix as u32;
        // for inline storage, only need check view
        if len <= 12 {
            if l != r {
                return false;
            }
            continue;
        }

        // check buffers
        let l_view = ByteView::from(*l);
        let r_view = ByteView::from(*r);

        let l_buffer = &lhs_buffers[l_view.buffer_index as usize];
        let r_buffer = &rhs_buffers[r_view.buffer_index as usize];

        // prefixes are already known to be equal; skip checking them
        let len = len as usize - 4;
        let l_offset = l_view.offset as usize + 4;
        let r_offset = r_view.offset as usize + 4;
        if l_buffer[l_offset..l_offset + len] != r_buffer[r_offset..r_offset + len] {
            return false;
        }
    }
    true
}

#[cfg(test)]
mod tests {}