File size: 6,354 Bytes
f0f4f2b |
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 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 |
# 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.
import cython
from cython.cimports.cpython import array
from pyiceberg.avro import STRUCT_DOUBLE, STRUCT_FLOAT
from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free
from libc.string cimport memcpy
from libc.stdint cimport uint64_t, int64_t
import array
cdef extern from "decoder_basic.c":
void decode_zigzag_ints(const unsigned char **buffer, const uint64_t count, uint64_t *result);
void skip_zigzag_int(const unsigned char **buffer);
unsigned_long_long_array_template = cython.declare(array.array, array.array('Q', []))
@cython.final
cdef class CythonBinaryDecoder:
"""Implement a BinaryDecoder that reads from an in-memory buffer."""
# This the data that is duplicated when the decoder is created.
cdef unsigned char *_data
# This is the current pointer to the buffer.
cdef const unsigned char *_current
# This is the address after the data buffer
cdef const unsigned char *_end
# This is the size of the buffer of the data being parsed.
cdef uint64_t _size
def __cinit__(self, input_contents: bytes) -> None:
self._size = len(input_contents)
# Make a copy of the data so the data can be iterated.
self._data = <unsigned char *> PyMem_Malloc(self._size * sizeof(char))
if not self._data:
raise MemoryError()
cdef const unsigned char *input_as_array = input_contents
memcpy(self._data, input_as_array, self._size)
self._end = self._data + self._size
self._current = self._data
def __dealloc__(self):
PyMem_Free(self._data)
cpdef unsigned int tell(self):
"""Return the current stream position."""
return self._current - self._data
cpdef bytes read(self, n: int):
"""Read n bytes."""
if n < 0:
raise ValueError(f"Requested {n} bytes to read, expected positive integer.")
cdef const unsigned char *r = self._current
self._current += n
return r[0:n]
def read_boolean(self) -> bool:
"""Reads a value from the stream as a boolean.
A boolean is written as a single byte
whose value is either 0 (false) or 1 (true).
"""
self._current += 1;
return self._current[-1] != 0
cpdef inline int64_t read_int(self):
"""Reads a value from the stream as an integer.
int/long values are written using variable-length, zigzag coding.
"""
cdef uint64_t result;
if self._current >= self._end:
raise EOFError(f"EOF: read 1 bytes")
decode_zigzag_ints(&self._current, 1, &result)
return result
def read_ints(self, count: int) -> array.array[int]:
"""Reads a list of integers."""
newarray = array.clone(unsigned_long_long_array_template, count, zero=False)
if self._current >= self._end:
raise EOFError(f"EOF: read 1 bytes")
decode_zigzag_ints(&self._current, count, <uint64_t *>newarray.data.as_ulonglongs)
return newarray
cpdef void read_int_bytes_dict(self, count: int, dest: Dict[int, bytes]):
"""Reads a dictionary of integers for keys and bytes for values into a destination dict."""
cdef uint64_t result[2];
if self._current >= self._end:
raise EOFError(f"EOF: read 1 bytes")
for _ in range(count):
decode_zigzag_ints(&self._current, 2, <uint64_t *>&result)
if result[1] <= 0:
dest[result[0]] = b""
else:
dest[result[0]] = self._current[0:result[1]]
self._current += result[1]
cpdef inline bytes read_bytes(self):
"""Bytes are encoded as a long followed by that many bytes of data."""
cdef uint64_t length;
if self._current >= self._end:
raise EOFError(f"EOF: read 1 bytes")
decode_zigzag_ints(&self._current, 1, &length)
if length <= 0:
return b""
cdef const unsigned char *r = self._current
self._current += length
return r[0:length]
cpdef float read_float(self):
"""Reads a value from the stream as a float.
A float is written as 4 bytes.
The float is converted into a 32-bit integer using a method equivalent to
Java's floatToIntBits and then encoded in little-endian format.
"""
return float(STRUCT_FLOAT.unpack(self.read(4))[0])
cpdef float read_double(self):
"""Reads a value from the stream as a double.
A double is written as 8 bytes.
The double is converted into a 64-bit integer using a method equivalent to
Java's doubleToLongBits and then encoded in little-endian format.
"""
return float(STRUCT_DOUBLE.unpack(self.read(8))[0])
cpdef str read_utf8(self):
"""Reads a utf-8 encoded string from the stream.
A string is encoded as a long followed by
that many bytes of UTF-8 encoded character data.
"""
return self.read_bytes().decode("utf-8")
def skip_int(self) -> None:
skip_zigzag_int(&self._current)
return
def skip(self, n: int) -> None:
self._current += n
def skip_boolean(self) -> None:
self._current += 1
def skip_float(self) -> None:
self._current += 4
def skip_double(self) -> None:
self._current += 8
def skip_bytes(self) -> None:
cdef uint64_t result;
decode_zigzag_ints(&self._current, 1, &result)
self._current += result
def skip_utf8(self) -> None:
self.skip_bytes()
|