include "ioutils.pyx"

cimport cython

from libc.stdint cimport uint64_t, uint8_t

from cpython.ref cimport Py_INCREF, PyObject

from cassandra.bytesio cimport BytesIOReader

from cassandra.deserializers cimport Deserializer, from_binary

from cassandra.parsing cimport ParseDesc, ColumnParser, RowParser

from cassandra import cqltypes

from cassandra.util import is_little_endian

import numpy as np

cdef extern from "numpyFlags.h":

# Include 'numpyFlags.h' into the generated C code to disable the

# deprecated NumPy API

pass

cdef extern from "Python.h":

# An integer type large enough to hold a pointer

ctypedef uint64_t Py_uintptr_t

ctypedef struct ArrDesc:

Py_uintptr_t buf_ptr

int stride # should be large enough as we allocate contiguous arrays

int is_object

Py_uintptr_t mask_ptr

arrDescDtype = np.dtype(

[ ('buf_ptr', np.uintp)

, ('stride', np.dtype('i'))

, ('is_object', np.dtype('i'))

, ('mask_ptr', np.uintp)

], align=True)

_cqltype_to_numpy = {

cqltypes.LongType: np.dtype('>i8'),

cqltypes.CounterColumnType: np.dtype('>i8'),

cqltypes.Int32Type: np.dtype('>i4'),

cqltypes.ShortType: np.dtype('>i2'),

cqltypes.FloatType: np.dtype('>f4'),

cqltypes.DoubleType: np.dtype('>f8'),

}

obj_dtype = np.dtype('O')

cdef uint8_t mask_true = 0x01

cdef class NumpyParser(ColumnParser):

return result

cdef _parse_rows(BytesIOReader reader, ParseDesc desc,

ArrDesc *arrs, Py_ssize_t rowcount):

cdef Py_ssize_t i

for i in range(rowcount):

unpack_row(reader, desc, arrs)

def make_arrays(ParseDesc desc, array_size):

return array_descs, arrays

def make_array(coltype, array_size):

return a

@cython.boundscheck(False)

@cython.wraparound(False)

cdef inline int unpack_row(

BytesIOReader reader, ParseDesc desc, ArrDesc *arrays) except -1:

cdef Buffer buf

cdef Py_ssize_t i, rowsize = desc.rowsize

cdef ArrDesc arr

cdef Deserializer deserializer

for i in range(rowsize):

get_buf(reader, &buf)

arr = arrays[i]

if arr.is_object:

deserializer = desc.deserializers[i]

val = from_binary(deserializer, &buf, desc.protocol_version)

Py_INCREF(val)

(<PyObject **> arr.buf_ptr)[0] = <PyObject *> val

elif buf.size >= 0:

memcpy(<char *> arr.buf_ptr, buf.ptr, buf.size)

else:

memcpy(<char *>arr.mask_ptr, &mask_true, 1)

# Update the pointer into the array for the next time

arrays[i].buf_ptr += arr.stride

arrays[i].mask_ptr += 1

return 0

def make_native_byteorder(arr):

"""

if is_little_endian and not arr.dtype.kind == 'O':

# We have arrays in big-endian order. First swap the bytes

# into little endian order, and then update the numpy dtype

# accordingly (e.g. from '>i8' to '<i8')

#

# Ignore any object arrays of dtype('O')

return arr.byteswap().newbyteorder()

return arr